Comandos

eidos <command> --help imprime o mesmo com exemplos. Todo comando ligado a uma raiz aceita --root <path>; sem ele, a raiz é encontrada pela sua marca .eidos/ a partir do diretório de trabalho. Os comandos que leem aceitam --json para uma saída estável em snake_case.

Códigos de saída: 0 feito, 1 a verificação encontrou erros (ou um índice está desatualizado sob --check), 2 o comando não pôde rodar.

`eidos install`

Cria uma raiz, ou traz peças de um Framework (a estrutura) para uma que já existe. O plano é sempre mostrado antes de qualquer escrita.

eidos install                                                   # asks each answer in a terminal
eidos install @BuildableWorks/software --group identity --product "Care Connect" --yes
eidos install @BuildableWorks/book docs/book --naming "Title Case" --yes
eidos install @BuildableWorks/research --collection investigations --yes   # into the root you are in
eidos install acme/[email protected] --path docs/blueprints --role reviewer --yes
eidos install ../other-root --all --plan                        # print the plan, touch nothing

Uma fonte é uma destas:

Um pacote do Registro, @owner/name ou @owner/name@<version>. As três sementes são pacotes; são servidas da cópia dentro da CLI quando as versões batem ou com --offline. O Registro →
Um owner/repo@<tag> do GitHub ou uma URL git, com --path <folder> nomeando a raiz dentro dele.
Um repositório nesta máquina, <path>@<tag>, com --path.
Uma pasta, lida como está.

Sem fonte, em um terminal, o roteiro lista os pacotes incluídos e os do Registro, cada um com a sua descrição; a página do Registro do navegador lista os mesmos e inclui a partir deles na raiz em que você está.

Opção	Significado
`--collection <name>`	Traz uma coleção: sua entrada, variants (variantes), templates (modelos), agrupamento, propriedades restritas e pasta. Repetível
`--variant <collection.variant>`	Traz uma variant e o seu template para uma coleção que a raiz tem. Repetível
`--role <name>`	Traz um arquivo de papel. Repetível
`--top-level <title>`	Traz um documento de nível superior e o seu arquivo. Repetível
`--all`	Pega tudo o que falta à raiz
`--plan` / `--dry-run`	Imprime o plano e para
`--yes`	Confirma sem perguntar
`--on-conflict current\|incoming`	Resolve todo conflito do mesmo jeito. Um conflito é um nome que os dois lados definem de forma diferente
`--force`	Trata cada pulo (um nome que os dois lados definem igual) como conflito
`--offline`	Só pacotes embutidos e pastas locais; não baixa nem envia nada
`--naming <convention>`	Raiz nova: `kebab-case` (padrão), `TitleCase` ou `"Title Case"`
`--group <name>`	Raiz nova: um grupo inicial sob a coleção agrupada. Repetível
`--product <name>`	Raiz nova: preenche o marcador do README
`--no-framing`	Raiz nova: deixa de fora a coleção de enquadramento
`--strict` / `--no-strict`	Raiz nova: se um aviso faz o `eidos check` falhar, guardado com a raiz
`--no-agents`	Raiz nova: não escreve o ponteiro no `AGENTS.md`
`--json`	A fonte, o plano, cada escrita, pulo e conflito, e a verificação

Em uma raiz que já existe, cada nome é convertido para a convenção de nomes da raiz, o documento do Framework é editado com os seus comentários preservados, depois o índice é reescrito e o eidos check roda. Uma segunda execução com os mesmos argumentos não escreve nada.

eidos init continua por uma release como alias oculto de install a partir de uma semente embutida.

`eidos new`

Monta um Blueprint (o plano): o frontmatter a partir das propriedades que se aplicam à coleção, o corpo do template da variant com a sua orientação, o nome do arquivo na convenção de nomes, um id permanente.

eidos new specs "Session Management" --group identity --summary "Keeps a signed-in user signed in."
eidos new specs Passkeys --variant micro --set status=Intake --set tags=auth,security
eidos new frames Market --dry-run

Opção	Significado
`--variant <name>`	Uma das variants da coleção; o padrão é a variant padrão da coleção
`--group <name>`	A subpasta
`--id <id>`	O id permanente, um só token em qualquer forma; o padrão é um novo de `B-` e quatro caracteres, como `B-1AC3`, único na raiz
`--summary <line>`	O resumo de uma linha, para que o índice o liste de imediato
`--set key=value`	Um valor de propriedade na criação; repetível; listas são separadas por vírgula
`--dry-run`	Imprime o arquivo em vez de escrevê-lo

As propriedades obrigatórias são geradas em branco; uma opcional só é escrita quando --set ou --summary lhe dá um valor. Ele recusa um id ocupado ou um arquivo existente.

`eidos draft`

Um Blueprint começado antes de pertencer a uma coleção: o arquivo que new escreveria, mantido com a CLI até ser publicado, fora de qualquer índice, listagem ou verificação.

eidos draft new specs "Session Management" --group identity       # .eidos/plugins/eidosmd/drafts/, shared with the root
eidos draft new specs "A rough idea" --private                     # local/drafts/, private, never committed
eidos drafts                                                        # every draft, with the collection each is meant for
eidos drafts --search passkeys                                      # the drafts holding every word
eidos draft move a-rough-idea shared
eidos draft set a-rough-idea --for frames --group ""
eidos draft publish session-management                              # into its collection under new's rules, then the index
eidos draft discard a-rough-idea

publish precisa do id livre, converte o nome para a convenção da raiz e anota um grupo que a coleção não declara. O navegador oferece o mesmo a partir do formulário de novo Blueprint e do cabeçalho do leitor.

`eidos check`

Valida a raiz inteira, ou os Blueprints nomeados, contra o próprio Framework da raiz.

eidos check
eidos check specs/identity/login.md
eidos check --strict                # this run: warnings fail too
eidos check --json

Os erros estão errados em qualquer leitura: frontmatter que não é analisável, um id ou title faltando, um id duplicado, uma variant que a coleção não declara, um link para um arquivo que não existe, um template que o Framework nomeia mas não tem, uma região sem fechamento.

Os avisos são lacunas para trazer à tona, nunca recusar: uma propriedade obrigatória faltando ou vazia, um valor fora das options de uma propriedade, uma propriedade que nenhum bloco declara, um campo de acompanhamento de trabalho, uma seção que o template declara mas o corpo não tem, uma seção desconhecida (só quando a raiz pede, abaixo), seções fora de ordem (um título que o template não declara é ignorado), um valor de agrupamento que não bate com a sua pasta, um frame (enquadramento) que ninguém escreveu, um índice desatualizado, uma lacuna de versão, e qualquer coisa na raiz que o documento do Framework não declare (ou declare e não esteja lá).

Se um aviso faz a verificação falhar é uma configuração da raiz (eidos setup --strict on|off, guardada no git para que a CI e toda máquina concordem). --strict e --no-strict sobrepõem uma execução.

As regras de seções também são da raiz, cada uma um interruptor no mesmo arquivo. Um título que o template da variant não declara (section-unknown) não é relatado a menos que a raiz o ative (eidos setup --warn-unknown-sections on): um template é o ponto de partida e o guia para um blueprint completo, não uma cerca, então os títulos a mais são decisão de quem mantém a raiz. Um título declarado que falta no corpo (section-missing) e títulos declarados fora de ordem (section-order) são relatados a menos que sejam desligados (--warn-missing-sections off, --warn-section-order off).

`eidos index`

Reconstrói a chave index dentro do Framework.yaml, uma lista por coleção, sem tocar em mais nada do documento.

eidos index
eidos index --check                 # write nothing; exit 1 if stale

Um Blueprint sem summary é listado com resumo nulo e nomeado no stderr. Nunca é inventado.

`eidos framework`, `list`, `show`

eidos framework                     # version, naming, folders, properties, vocabulary
eidos framework --as yaml           # the document, normalized, with guidance as comments
eidos list specs --group identity --where status=Draft
eidos list --search B-5KFM          # by its id; every word of a search, in any case
eidos show login                    # by id, filename, or path
eidos show login --json             # properties and sections parsed out

--where key=value compara uma propriedade sem distinguir maiúsculas; uma propriedade de lista bate com qualquer item. --search <palavras> deixa os Blueprints que têm cada palavra, sem importar maiúsculas nem ordem, no id, no título, no resumo ou no valor de uma propriedade, o mesmo que a caixa de busca de uma tabela encontra na página; nunca lê o corpo. Encontre um Blueprint assim em vez de procurar nos arquivos.

`eidos property`

O frontmatter de um Blueprint a partir do shell, para que ninguém abra um arquivo para mudar um valor.

eidos property get @login
eidos property set @login status Done
eidos property set @login tags auth,security
eidos property unset @login depends_on

O Blueprint é @<id>, um caminho ou um nome de arquivo. Um valor é convertido para o tipo declarado da propriedade. Uma propriedade que a tabela não declara para a coleção, uma que pertence a uma ferramenta ou um valor fora das opções é recusado a menos que --force. --dry-run imprime o frontmatter como ficaria.

`eidos reid`

Ids novos e gerados para os blueprints, a única forma de mudar um id.

eidos reid @login                   # um blueprint, ou vários
eidos reid --all                    # cada blueprint cujo id ainda não seja B- e quatro caracteres

Cada blueprint recebe um id como B-1AC3, único na raiz, e cada referência que um plugin guarda ao antigo o segue: o destino de uma thread de comentários, um nó de uma tela, os blueprints de uma tarefa, os links de um arquivo do Assets. Os arquivos mantêm o nome, e os links entre blueprints são caminhos, então não são tocados. O plano é impresso primeiro, como em configure:, com --dry-run, --yes e --json. Um plugin desligado que guarda arquivos é nomeado no plano, porque não pode acompanhar a mudança.

`eidos move`

Um blueprint movido para outro grupo da sua coleção.

eidos move @login billing           # o blueprint, como show o nomeia, e um grupo que a sua coleção declara

O arquivo vai para a pasta do grupo com o nome e o id mantidos, a propriedade do agrupamento recebe o grupo onde a coleção declara uma, e cada link da raiz que apontava para o caminho antigo o segue. O plano é impresso primeiro, como em configure:, com --dry-run, --yes e --json. Move blueprint to… no ⋮ de um leitor roda o mesmo plano.

`eidos configure:<noun>`

O Framework, editado a partir do shell. Toda mudança imprime um plano (cada entrada, chave, arquivo e link que ela toca, e cada valor que vai desaparecer) e pergunta.

Substantivo	Operações
`property`	`add`, `show`, `rename`, `set`, `remap`, `remove`
`collection`	`add`, `show`, `rename`, `remove`
`folder`	`add`, `show`, `rename`, `set`, `remove`
`group`	`add`, `rename`, `remove`
`variant`	`add`, `rename`, `set-default`, `remove`
`term`	`add`, `set`, `remove`
`doc`	`add`, `rename`, `set`, `remove`
`role`	`add`, `show`, `rename`, `remove`

eidos configure:property add team --type Text --applies-to all --required --meaning "Owning team."
eidos configure:property add tier --type Text --options Core,Extended --meaning "How central the unit is."
eidos configure:property rename status maturity --dry-run
eidos configure:property remap maturity Draft=Nascent Done=Mature --yes
eidos configure:collection rename specs units --unit unit
eidos configure:folder add assets --description "Images the blueprints link to."
eidos configure:folder add exports --owned-by @acme/exports --description "What the exporter writes."
eidos configure:group rename specs cli cli-core
eidos configure:variant add specs api --from micro
eidos configure:doc rename "Design Principles" Principles
eidos configure:role rename developer engineer

Chave	Significado
`--dry-run`	Imprime o plano e para
`--yes`	Prossegue sem perguntar
`--force`	Prossegue onde valores ou arquivos vão desaparecer, ou através de um conflito que o plano nomeia
`--preserve`	Em uma remoção: deixa os arquivos ou chaves em disco para o `check` relatar como não declarados

Um renomeio alcança todo lugar onde o nome aparece: o frontmatter de cada Blueprint, cada link na raiz, me.md, os usuários e as configurações desta CLI. Um movimento é um git mv onde o git está ligado. Estreitar as options de uma propriedade nomeia cada Blueprint com um valor fora da nova lista e precisa de --force. Depois de qualquer mudança o índice é reescrito e o check roda. Sem terminal e sem chave, um comando sai com 2 nomeando a chave, para que um agente a aprenda pelo erro.

`eidos migrate`

Leva uma raiz ao padrão que esta CLI carrega, mecanicamente.

eidos migrate --dry-run
eidos migrate

Ele renomeia o que mudou entre versões, reescreve o bloco properties.core do padrão, define eidos_version e relata o que só o dono pode decidir (uma pasta ou arquivo na raiz que nada declara). Uma raiz já atualizada é deixada em paz. Versionamento →

`eidos setup`

As configurações próprias da CLI para uma raiz, nenhuma delas do padrão: o produto que a raiz define, quais plugins estão ligados, se um aviso faz o check falhar, as pessoas que trabalham na raiz e como quem esta máquina age.

eidos setup                          # a menu of the plugins, then the questions, in a terminal
eidos setup --product "Care Connect" # what the Home and the desktop app call the root; "" goes back to the repository's name
eidos setup --enable backlog --disable terminal --strict on --add-user "Ada Lovelace" --alias ada --role developer --email [email protected] --as ada
eidos setup --warn-unknown-sections on --warn-section-order off  # which section rules warn

Escreve .eidos/plugins/eidosmd/settings.yaml (partilhado com a raiz) e local.yaml (seu, ignorado pelo git).

`eidos plugin`

eidos plugin                         # every plugin: title, version, on or off, where its switch is written
eidos plugin enable backlog          # plugins.backlog: true in settings.yaml; a plugin that keeps a root folder declares it
eidos plugin disable terminal --me   # private, in local.yaml
eidos plugin set plato agent codex   # one declared setting, to the file its scope names (a me setting in local.yaml); --unset for the default
eidos instructions backlog           # a plugin's own guide, while it is on

Desligado, um plugin não registra nada; sua pasta, configurações e regiões ficam para o dia em que ele voltar. Plugins →

Comandos dos plugins

Cada plugin ligado monta o seu comando sob um título Plugins em eidos --help; eidos <plugin> --help o imprime com exemplos.

eidos canvas new "Product Map"       # .eidos/plugins/canvas/product-map.yaml (--private for local/); list, show <id> [--page], move <id> shared|private, schema
eidos comments @login                # the threads on a blueprint; add <target> <text> [--section] [--item] [--reply] [--as], resolve, delete, project
eidos backlog --status "In Progress" # the tasks; add <title> --for @login [--type], show, set, check <task> <n>, promote, types, sections, export, draft:*
eidos decisions --unconfirmed        # the inbox; add <decision> --for @login [--type] [--task] --as <alias>, show, set, confirm, types, statuses, project, remove
eidos assets --for login             # the files; show, add <file>, link <path> --to @login, set --title|--name, remove
eidos linter --fix                   # the markdown files that drifted from the root's rules, settled

Um alvo para o Comments é um Blueprint (@<id>, um caminho, um nome de arquivo), um documento ou <host>:<id> (backlog:<task>, canvas:<page>, decisions:<id>). Plugins →, uma página por plugin

`eidos version`

eidos version                                   # the root's versions, newest first
eidos version record 1.0.0                      # a row naming HEAD
eidos version record 1.0.0 --commit a1b2c3d --tag   # names that commit and tags it blueprints/1.0.0

Uma versão é um ponto fixo: um nome para um commit, para que um time possa ler depois a raiz exatamente como estava (o escopo que um cliente aprovou, contra o que uma release foi construída). O git já guarda cada arquivo; a linha dá um nome ao commit. É o registro desta CLI, em .eidos/plugins/eidosmd/versions.yaml, escrito só quando pedido. O prefixo da tag é versions.tag_prefix em settings.yaml, blueprints/ por padrão.

`eidos views`

eidos views              # every saved view: its id, its name, the address that opens it, shared or private
eidos views --json       # { views[{ id, name, page, query, scope }] }
eidos views move V-7K2M private   # move a view to your local.yaml, or back with shared; its id, filters, and sort kept

As visões salvas no navegador a partir de um quadro ou de uma tabela filtrados (Save as view): primeiro as partilhadas, de .eidos/plugins/eidosmd/views.yaml, enviadas com a raiz, depois as suas, de views em local.yaml, nunca enviadas. Uma visão é criada, renomeada e apagada no navegador, e passa de partilhada a privada ou ao contrário ali ou com eidos views move; o comando as lista, para que um agente possa passar a uma pessoa o endereço de uma sob eidos browser. My work, By status e By type do Backlog são as visões com que toda raiz começa e não ficam em nenhum dos dois arquivos. Visões salvas →

`eidos browser`

eidos browser
eidos browser --port 7000 --no-open

A raiz em uma página web local em 127.0.0.1. O navegador →

`eidos roles`, `whoami`

eidos roles
eidos whoami --role developer --experience "new to this product" --capacity fluent
eidos whoami --clear

whoami escreve o .eidos/me.md privado, ignorado pelo git. Papéis →

`eidos users`

eidos users                          # cada usuário: nome, @alias, papel, email e se é um agente
eidos users add "Plato" --agent       # adiciona um na hora; só o nome é preciso
eidos comments add @login "…" --as plato   # um comentário assinado por esse usuário, não por você

As pessoas e os agentes que trabalham na raiz, a mesma lista da página de configurações Usuários (users em .eidos/plugins/eidosmd/settings.yaml). add só pede o nome: o alias vem do nome, o papel é opcional e um usuário que já existe é indicado em vez de ser adicionado duas vezes. Um agente se adiciona uma vez com --agent e depois assina cada comentário como ele próprio com --as <alias> (ou EIDOS_USER), nunca como a pessoa para quem trabalha. Comentários →

`eidos instructions`, `agents`, `standard`, `seeds`

eidos instructions                  # list the guides
eidos instructions overview         # required first read for an agent
eidos agents --write                # a pointer in AGENTS.md (or --file CLAUDE.md)
eidos standard                      # the text of EIDOS.md this CLI carries; --version for the number
eidos seeds                         # the bundled seeds, their collections and variants

Agentes →

Comandos

eidos install

eidos new

eidos draft

eidos check

eidos index

eidos framework, list, show

eidos property

eidos reid

eidos move

eidos configure:<noun>

eidos migrate

eidos setup

eidos plugin