@orkastery/cli 0.5.3 → 0.5.6

package/dist/worktree-local.js

@@ -0,0 +1,165 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.COMANDO_CONFIRMAR_WORKTREE = exports.ARQUIVO_WORKTREE_LOCAL = exports.CONTRATO_WORKTREE_LOCAL = void 0;
+exports.caminhoRealPrevisto = caminhoRealPrevisto;
+exports.pastaDasWorktreesPedida = pastaDasWorktreesPedida;
+exports.lerWorktreeLocal = lerWorktreeLocal;
+exports.recusaDePastaDasWorktrees = recusaDePastaDasWorktrees;
+exports.exigirPastaDasWorktrees = exigirPastaDasWorktrees;
+exports.confirmarWorktreeLocal = confirmarWorktreeLocal;
+exports.revogarWorktreeLocal = revogarWorktreeLocal;
+/**
+ * RM-047 (fronteira de confiança, P3): a pasta das worktrees fora da raiz vale só com a confirmação
+ * desta máquina.
+ *
+ * O `worktree.dir` mora no `orkastery.yaml`, que vem com o repositório, e o `git worktree add` cria o
+ * checkout (e o `.gitignore` da pasta) onde ele apontar. Dentro da raiz do projeto, pelo caminho real,
+ * nada muda. Fora dela (`..`, caminho absoluto ou um link versionado que leva para fora), a criação
+ * recusa com `worktree.dir-fora-da-raiz` até a máquina confirmar a mesma pasta com
+ * `ork setup worktree confirmar`. A confirmação fica em `.orkastery/private/worktree-local.json`, com
+ * as mesmas regras da postura de sandbox (P1): pasta 0700, arquivo 0600, nunca link, nunca rastreado
+ * pelo git, e só para este checkout e esta pasta.
+ */
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const estado_thread_1 = require("./estado-thread");
+const postura_local_1 = require("./postura-local");
+const util_1 = require("./util");
+exports.CONTRATO_WORKTREE_LOCAL = 'ork.worktree-local/v1';
+exports.ARQUIVO_WORKTREE_LOCAL = 'worktree-local.json';
+/**
+ * Caminho real de um caminho que talvez ainda não exista: o real do ancestral mais próximo que existe,
+ * mais o resto. Um link no caminho (inclusive versionado no clone) é resolvido aqui.
+ */
+function caminhoRealPrevisto(alvo) {
+    let atual = path.resolve(alvo);
+    const resto = [];
+    for (;;) {
+        try {
+            return path.join(fs.realpathSync(atual), ...resto.reverse());
+        }
+        catch { /* sobe */ }
+        const pai = path.dirname(atual);
+        if (pai === atual)
+            return path.resolve(alvo);
+        resto.push(path.basename(atual));
+        atual = pai;
+    }
+}
+/** A pasta das worktrees que o manifesto pede, pelo caminho real, e se ela fica dentro da raiz. */
+function pastaDasWorktreesPedida(raiz, manifesto) {
+    let principal;
+    try {
+        principal = (0, estado_thread_1.raizDoEstado)(raiz);
+    }
+    catch {
+        principal = path.resolve(raiz);
+    }
+    const raizReal = caminhoRealPrevisto(principal);
+    const dir = caminhoRealPrevisto(path.resolve(principal, manifesto.worktree.dir));
+    const rel = path.relative(raizReal, dir);
+    const primeiro = rel.split(path.sep)[0];
+    const dentro = !rel.startsWith('..') && !path.isAbsolute(rel) && primeiro !== '.git';
+    return { dir, dentro };
+}
+/** Lê a confirmação local; `null` com o motivo quando ela não existe ou não vale. */
+function lerWorktreeLocal(raiz) {
+    const { bruto: o, motivo } = (0, postura_local_1.lerArquivoPrivado)(raiz, exports.ARQUIVO_WORKTREE_LOCAL);
+    if (!o)
+        return { local: null, motivo };
+    if (o.contrato !== exports.CONTRATO_WORKTREE_LOCAL || typeof o.dir !== 'string' || typeof o.raiz !== 'string' ||
+        typeof o.confirmadoEm !== 'string' || typeof o.por !== 'string') {
+        return { local: null, motivo: `${exports.ARQUIVO_WORKTREE_LOCAL} fora do contrato ${exports.CONTRATO_WORKTREE_LOCAL}` };
+    }
+    if (o.raiz !== (0, postura_local_1.raizRealDoEstado)(raiz))
+        return { local: null, motivo: 'a confirmação local é de outro checkout' };
+    return { local: o, motivo: null };
+}
+/** Comando que confirma a pasta nesta máquina; vai em toda recusa. */
+exports.COMANDO_CONFIRMAR_WORKTREE = 'ork setup worktree confirmar';
+/**
+ * A recusa da criação de worktree: `null` quando a pasta do manifesto fica dentro da raiz, ou quando
+ * a máquina confirmou exatamente essa pasta; senão o erro tipado com o comando que confirma.
+ */
+function recusaDePastaDasWorktrees(raiz, manifesto) {
+    const { dir, dentro } = pastaDasWorktreesPedida(raiz, manifesto);
+    if (dentro)
+        return null;
+    const { local, motivo } = lerWorktreeLocal(raiz);
+    if (local && local.dir === dir)
+        return null;
+    const porque = local ? `a máquina confirmou ${local.dir}` : motivo ?? 'sem confirmação local';
+    return `worktree.dir-fora-da-raiz: o orkastery.yaml pede worktree.dir: ${JSON.stringify(manifesto.worktree.dir).slice(0, 200)}, ` +
+        `que leva a ${dir}, fora da raiz do projeto (pelo caminho real), e esta máquina não confirmou essa pasta (${porque}). ` +
+        'Nenhuma worktree foi criada. O manifesto vem com o repositório; quem decide criar checkout fora da raiz é a ' +
+        `máquina. Para aceitar nesta máquina: ${exports.COMANDO_CONFIRMAR_WORKTREE} (ou volte worktree.dir para dentro do projeto, ` +
+        'como .claude/worktrees).';
+}
+/** Lança a recusa, quando houver. */
+function exigirPastaDasWorktrees(raiz, manifesto) {
+    const recusa = recusaDePastaDasWorktrees(raiz, manifesto);
+    if (recusa)
+        throw new Error(recusa);
+}
+/**
+ * Grava a confirmação local da pasta que o manifesto pede hoje. Com `esperado`, ele precisa levar à
+ * mesma pasta: a máquina confirma o que leu, não o que o manifesto pode passar a dizer depois.
+ */
+function confirmarWorktreeLocal(raiz, manifesto, por, esperado) {
+    const { dir, dentro } = pastaDasWorktreesPedida(raiz, manifesto);
+    if (esperado !== undefined) {
+        let principal;
+        try {
+            principal = (0, estado_thread_1.raizDoEstado)(raiz);
+        }
+        catch {
+            principal = path.resolve(raiz);
+        }
+        const pedido = caminhoRealPrevisto(path.resolve(principal, esperado));
+        if (pedido !== dir) {
+            throw new Error(`worktree.dir-divergente: o orkastery.yaml leva a ${dir}, não a ${pedido}; nada foi confirmado`);
+        }
+    }
+    if (dentro)
+        throw new Error(`worktree.dir-dentro-da-raiz: ${dir} fica dentro do projeto e não precisa de confirmação`);
+    const local = { contrato: exports.CONTRATO_WORKTREE_LOCAL, dir, raiz: (0, postura_local_1.raizRealDoEstado)(raiz), confirmadoEm: (0, util_1.agora)(), por };
+    (0, postura_local_1.gravarArquivoPrivado)(raiz, exports.ARQUIVO_WORKTREE_LOCAL, local);
+    return local;
+}
+/** Apaga a confirmação local; devolve se havia uma. */
+function revogarWorktreeLocal(raiz) {
+    return (0, postura_local_1.revogarArquivoPrivado)(raiz, exports.ARQUIVO_WORKTREE_LOCAL);
+}

package/dist/worktree.js

@@ -64,6 +64,7 @@ const leases_1 = require("./leases");
 const thread_1 = require("./thread");
 const util_1 = require("./util");
 const estado_thread_1 = require("./estado-thread");
+const procedencia_1 = require("./procedencia");
 /**
  * Diretorio canonico da worktree de uma thread, resolvido pelo `ork` na arvore principal: o mesmo que a criacao usa,
  * tambem quando o comando roda de dentro de outra worktree (P4 do ensaio da 0.5.0).
@@ -520,7 +521,18 @@ function auditarWorktree(carregado, id) {
                 correcao: `git -C ${dir} switch ${branchEsperada}`,
             });
     }
+    // RM-047 (P2): git so roda na worktree registrada e com o thread.json local.
+    let procedencia = null;
     if (existe) {
+        try {
+            (0, procedencia_1.exigirCwdLocal)(raiz, id, dir, 'thread');
+        }
+        catch (e) {
+            procedencia = e.message;
+            checks.push({ nome: 'procedencia', nivel: 'fail', detalhe: procedencia, correcao: `ork worktree ensure ${id}` });
+        }
+    }
+    if (existe && procedencia === null) {
         const limpa = arvoreLimpa(dir);
         checks.push(limpa === true
             ? { nome: 'arvore', nivel: 'ok', detalhe: 'sem alteracao nao commitada' }
@@ -641,6 +653,14 @@ function liberarWorktree(carregado, id, opcoes = {}) {
             correcao: '',
         };
     }
+    // RM-047 (P2): nada de git num diretorio que o thread.json escolheu e o git nao registra.
+    try {
+        (0, procedencia_1.exigirCwdLocal)(raiz, id, dir, 'thread');
+    }
+    catch (e) {
+        return { ok: false, removida: false, dir, branch, leasesLiberados: [], motivo: 'tree.blocked',
+            detalhe: e.message, correcao: `confira o diretorio e o thread.json da thread ${id}` };
+    }
     const limpa = arvoreLimpa(dir);
     if (limpa === false && !opcoes.forcar) {
         return {

package/dist/yaml.js

@@ -55,10 +55,16 @@ function escalar(bruto) {
     }
     return t;
 }
-function preparar(texto) {
+function preparar(texto, estrito) {
     const linhas = [];
     texto.split('\n').forEach((original, i) => {
-        const semComentario = tirarComentario(original).replace(/\s+$/, '');
+        const cortada = tirarComentario(original);
+        // D9: no modo estrito, o `#` depois do valor nao corta o valor calado (`titulo: Decisao #42`); com o `#`
+        // no texto, o valor vai entre aspas. Comentario na linha inteira segue valendo.
+        if (estrito && cortada !== original && cortada.trim() !== '') {
+            throw new Error(`YAML invalido na linha ${i + 1}: comentario depois do valor (com # no texto, use aspas)`);
+        }
+        const semComentario = cortada.replace(/\s+$/, '');
         if (semComentario.trim() === '')
             return;
         if (semComentario.trim() === '---')
@@ -68,7 +74,7 @@ function preparar(texto) {
     });
     return linhas;
 }
-function parseBloco(linhas, inicio, indent) {
+function parseBloco(linhas, inicio, indent, estrito) {
     let i = inicio;
     if (i >= linhas.length)
         return [null, i];
@@ -89,6 +95,9 @@ function parseBloco(linhas, inicio, indent) {
             throw new Error(`YAML invalido na linha ${linha.numero}: esperado "chave: valor"`);
         }
         const chave = linha.conteudo.slice(0, sep).trim().replace(/^["']|["']$/g, '');
+        if (estrito && (chave === '__proto__' || Object.hasOwn(mapa, chave))) {
+            throw new Error(`YAML invalido na linha ${linha.numero}: chave ${chave === '__proto__' ? 'reservada' : 'repetida'}`);
+        }
         const resto = linha.conteudo.slice(sep + 1).trim();
         i++;
         if (resto !== '') {
@@ -96,7 +105,7 @@ function parseBloco(linhas, inicio, indent) {
             continue;
         }
         if (i < linhas.length && linhas[i].indent > indent) {
-            const [filho, proximo] = parseBloco(linhas, i, linhas[i].indent);
+            const [filho, proximo] = parseBloco(linhas, i, linhas[i].indent, estrito);
             mapa[chave] = filho;
             i = proximo;
         }
@@ -106,11 +115,21 @@ function parseBloco(linhas, inicio, indent) {
     }
     return [mapa, i];
 }
-/** Le um documento YAML do subconjunto suportado. */
-function lerYaml(texto) {
-    const linhas = preparar(texto);
+/**
+ * Le um documento YAML do subconjunto suportado.
+ *
+ * RM-026 K7 (D9): `estrito` serve a quem le texto que nao e do `ork` (o frontmatter do conhecimento). Chave
+ * repetida no mesmo mapa, `__proto__`, comentario depois do valor e linha que sobra (indentacao fora do bloco)
+ * recusam, em vez de sumir calados como no modo padrao, que o `orkastery.yaml` e as paginas de docs seguem usando.
+ */
+function lerYaml(texto, opcoes = {}) {
+    const estrito = opcoes.estrito === true;
+    const linhas = preparar(texto, estrito);
     if (linhas.length === 0)
         return {};
-    const [valor] = parseBloco(linhas, 0, linhas[0].indent);
+    const [valor, proximo] = parseBloco(linhas, 0, linhas[0].indent, estrito);
+    if (estrito && proximo < linhas.length) {
+        throw new Error(`YAML invalido na linha ${linhas[proximo].numero}: indentacao fora do bloco`);
+    }
     return valor;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@orkastery/cli",
-  "version": "0.5.3",
+  "version": "0.5.6",
   "description": "A software factory of AI agents that proves its work: parallel threads, verified results, and short decisions only when they matter.",
   "license": "MIT",
   "homepage": "https://github.com/orkastery/orkastery#readme",

package/schemas/code-artifact-graph.v1.schema.json

@@ -258,7 +258,8 @@
                   "imports",
                   "calls",
                   "references",
-                  "derived_from"
+                  "derived_from",
+                  "cites"
                 ]
               },
               "snapshot_id": {