Fábrica de software open source

Jumentix

A marca Jumentix vem do jegue brasileiro: firme, prático e resistente. A plataforma carrega a arquitetura Node.js enterprise do primeiro monólito modular a um ecossistema ilimitado de serviços.

O animal é a promessa: menos cerimônia, mais software que aguenta carga.

Comece a construir Explore a plataforma

99% quality threshold
DDD + Hexagonal
Bun monorepo
Open source

Jumentix carrega a carga

Uma mascote prática para uma arquitetura prática

O jegue faz parte da linguagem do produto: avanço confiável, pé firme e pouca cerimônia quando o terreno muda. O Jumentix aplica isso a design visual de domínios, runtimes orientados a contratos, adaptadores reutilizáveis, automação de desenvolvimento e governança de deploy.

12+adaptadores HTTP e functions

10+destinos de persistência

3estilos de interface de API

99%padrão de cobertura

Arquitetura que você pode ver

Projete contextos delimitados como um sistema vivo

O Domain Designer transforma domínios, entidades, campos, validações e relacionamentos em um modelo navegável. Os mesmos contratos orientam geração de código e documentação de API.

Veja o produto Docs de arquitetura

Domain Designer do Jumentix exibindo contextos delimitados e relações entre entidades — A interface real do Domain Designer do Jumentix.

Código faz parte do produto

Comece localmente. Mantenha todas as opções de produção abertas.

Os mesmos contratos de aplicação funcionam em monólito modular, servidor em tempo real, functions e serviços distribuídos.

bun install
bun run cli
bun run dev:express

Tooling movido a Bun

O caminho rápido é o caminho padrão

O Jumentix padroniza Bun como runtime, gerenciador de pacotes, executor de scripts, test runner e bundler das specs de browser do monorepo. Isso mantém trabalho local, gates de CI, checagens de pacote e publicação do site em uma ferramenta só.

Por que Bun importa aqui

O repositório usa Bun onde ele realmente reduz atrito: installs rápidos com workspaces, execução direta de TypeScript, scripts repetíveis, gates focados por branch e bundling das specs de browser antes de o Cypress rodar contra IndexedDB e DOM reais.

Uma versão pinada, `bun@1.3.13`, protege todos os workspaces contra drift de ambiente.
`bun run --filter` mantém checagens de pacote focadas enquanto gates completos seguem disponíveis para release.
Bun empacota specs browser do Cana antes do Cypress, evitando fragilidade do webpack do Cypress sem perder evidência em browser real.
A mesma CLI move dev local, sync de docs, dry-runs de pacote, checagens de segurança e publicação do site em produção.

Ver scripts Jumentix Bun docs

bun install
bun run website:dev
bun run ci:affected

1ferramenta de runtime/pacote/teste/bundle

1.3.13+versão Bun pinada

3raízes: apps, packages, tooling

30xteto oficial de velocidade de install vs npm

Qualidade como superfície do produto

Requisitos, testes e evidências não ficam escondidos

O Jumentix trata qualidade como parte da promessa visível do produto. Requisitos são checados, testes são mapeados, regras de arquitetura são executáveis e caminhos de publicação carregam evidências em vez de depender de cerimônia.

99/90padrão de statements/branches

reqsrequisitos ligados a checagens executáveis

0tolerância a drift oculto de docs

realtestes browser para APIs browser

Registro de requisitos

O trabalho de entrega conecta comportamento, docs, testes e evidência de release para que “pronto” seja auditável.

requirements:check

Testes confiáveis

Unit, integração, route sweep Cypress, specs de browser e smoke de Storybook cobrem a superfície real de cada camada.

test-map:check

Arquitetura executável

Scripts de limite rejeitam imports e atalhos que vazariam frameworks, bancos ou infraestrutura para o domínio.

arch:check-*

Disciplina de publicação

Sync de conteúdo, checagens de rota, dry-runs de pacote e governança de release rodam antes de artefatos públicos avançarem.

website:test:prepublish

bun run requirements:check
bun run docs:consumers:package-scripts
bun run website:test:prepublish

Plataforma pronta para AI

A UI entrega arquitetura com governança acoplada

O Jumentix é preparado para AI porque o produto não obriga agentes a inferir arquitetura a partir de código espalhado. A UI captura contextos delimitados, entidades, interfaces, perfis de deploy e requisitos; o repositório expõe docs legíveis por agentes e checagens executáveis que tornam trabalho gerado auditável.

UImodelo de domínio como input de primeira classe

llmscontexto do site legível por agentes

reqsrequisitos ligados a checks

gatesevidência de arquitetura e publish

1. Modele o serviço

A UI captura o domínio

Category, Task, relacionamentos, validações e superfícies de API viram dados explícitos da plataforma.

2. Fundamente o agente

Docs e pacotes nomeiam o caminho

O agente lê índice de docs, contratos de pacote e blueprint da UI antes de escolher arquivos para alterar.

3. Gere dentro dos limites

Ports e adapters moldam o código

Casos de uso, controllers, SDKs, exemplos Cana e perfis de runtime preservam seus limites de ownership.

4. Verifique evidências

Checks de governança capturam drift

Requisitos, test maps, scripts de arquitetura, checagens de rota e gates prepublish validam a mudança.

5. Publique com confiança

A PR carrega prova

Revisores veem o que mudou, por que cabe na arquitetura e quais checks provam que está pronto.

Instruções de baixo contexto

Agentes podem partir do índice de docs, páginas de pacote, metadados de rotas e snippets de código em vez de adivinhar qual arquivo possui um comportamento.

/llms-full.txt

UI como input de arquitetura

A UI de Service Management transforma conceitos de produto em contextos, interfaces e escolhas de deploy que geradores e revisores conseguem inspecionar.

service-management-ui

Geração governada

Mudanças geradas ou escritas por agentes ainda passam por requisitos, test maps, rotas, limites de pacote e governança de release antes de publicar.

requirements:check

Grafo de pacotes fundamentado

Pacotes reutilizáveis dão ao trabalho de AI nomes estáveis para persistência, mediação, clientes, Cana, bootstrap de runtime e limites arquiteturais.

packages/*

Trabalho de AI vira entrega governada

A UI entrega para a AI um ponto de partida restrito: vocabulário do serviço, limites, interfaces, perfil de runtime e obrigações de qualidade são explícitos antes de qualquer prompt. Isso transforma o agente de um gerador por chute em um contribuidor dentro das regras da plataforma.

Prompts referenciam contextos delimitados, entidades, requisitos e pacotes nomeados em vez de desejos amplos de implementação.
Código gerado tem destino conhecido: modelo da UI, contratos, SDKs, casos de uso, adaptadores, testes e docs.
Revisores podem rejeitar drift com checagens executáveis em vez de depender apenas de review arquitetural manual.

Ação de AI	Fonte da UI	Guarda-corpo de governança	Saída útil
Desenhar com segurança	Contexto delimitado, entidades, relacionamentos e requisitos.	Validação do modelo de serviço e registro de requisitos.	Uma spec de serviço que produto, arquitetura e engenharia revisam juntas.
Gerar com segurança	Interfaces, eventos, perfil de deploy e escolhas de pacote.	OpenAPI, AsyncAPI, checagens de rota e limites de workspace.	Contratos, SDKs, handlers e exemplos alinhados ao mesmo modelo.
Publicar com evidência	Expectativas de qualidade, caminho de release e índice de docs.	Test map, checagens de arquitetura, sync de docs e gates prepublish.	Uma PR que revisores auditam com prova concreta em vez de confiança narrativa.

{
  "boundedContext": "Tasks",
  "entities": [
    { "name": "Category", "fields": ["id", "name", "color"] },
    { "name": "Task", "fields": ["id", "title", "categoryId", "completed"] }
  ],
  "interfaces": ["REST", "WebSocket"],
  "deploymentProfiles": ["dev", "staging", "production"],
  "requirements": ["REQ-TASK-CATEGORY", "REQ-TASK-LIVE-UPDATES"],
  "governanceChecks": [
    "requirements:check",
    "test-map:check",
    "arch:check-workspace-boundaries"
  ]
}

Escolha uma jornada

O Jumentix é para equipes que querem velocidade de framework sem abrir mão da propriedade do domínio, portabilidade ou evidências operacionais.

Construa o produto. Preserve a arquitetura.

Explore o código, execute a fábrica localmente e transforme seu próximo serviço Node.js em uma capacidade repetível de plataforma.

Leia a documentação GitHub