@orkastery/cli 0.2.0

package/dist/manifest.js

@@ -0,0 +1,255 @@
+"use strict";
+/**
+ * Manifesto por projeto (`orkastery.yaml`), com `devmaster.yaml` lido como fallback
+ * durante a migracao dos habitos.
+ */
+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.LIMITE_MANIFESTO_BYTES = exports.DIR_ESTADO = exports.NOME_MANIFESTO_LEGADO = exports.NOME_MANIFESTO = void 0;
+exports.acharRaiz = acharRaiz;
+exports.dirEstado = dirEstado;
+exports.carregarManifesto = carregarManifesto;
+exports.exigirManifesto = exigirManifesto;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const yaml_1 = require("./yaml");
+const modos_1 = require("./modos");
+const slug_1 = require("./slug");
+const util_1 = require("./util");
+exports.NOME_MANIFESTO = 'orkastery.yaml';
+exports.NOME_MANIFESTO_LEGADO = 'devmaster.yaml';
+exports.DIR_ESTADO = '.orkastery';
+/** Limite duro: o manifesto nao pode virar o novo arquivo de 100 KB. */
+exports.LIMITE_MANIFESTO_BYTES = 16384;
+/** Raiz do projeto: o diretorio que contem o manifesto; senao, a raiz do repositorio git. */
+function acharRaiz(dirInicial = process.cwd()) {
+    const porManifesto = (0, util_1.subirAte)(dirInicial, exports.NOME_MANIFESTO);
+    if (porManifesto)
+        return porManifesto;
+    const porLegado = (0, util_1.subirAte)(dirInicial, exports.NOME_MANIFESTO_LEGADO);
+    if (porLegado)
+        return porLegado;
+    const git = (0, util_1.exec)('git', ['rev-parse', '--show-toplevel'], dirInicial);
+    if (git.ok)
+        return git.stdout.trim();
+    return path.resolve(dirInicial);
+}
+/** Caminho do diretorio de estado da raiz informada. */
+function dirEstado(raiz) {
+    return path.join(raiz, exports.DIR_ESTADO);
+}
+function texto(v, padrao) {
+    return typeof v === 'string' ? v : typeof v === 'number' ? String(v) : padrao;
+}
+function numero(v, padrao) {
+    return typeof v === 'number' ? v : typeof v === 'string' && v.trim() !== '' && !isNaN(Number(v)) ? Number(v) : padrao;
+}
+function booleano(v, padrao) {
+    return typeof v === 'boolean' ? v : padrao;
+}
+function mapa(v) {
+    return v && typeof v === 'object' && !Array.isArray(v) ? v : {};
+}
+/** Le e valida o manifesto. Nunca lanca: erros e avisos voltam na estrutura. */
+function carregarManifesto(dirInicial = process.cwd()) {
+    const raiz = acharRaiz(dirInicial);
+    const candidatos = [
+        { caminho: path.join(raiz, exports.NOME_MANIFESTO), legado: false },
+        { caminho: path.join(raiz, exports.NOME_MANIFESTO_LEGADO), legado: true },
+    ];
+    const achado = candidatos.find((c) => fs.existsSync(c.caminho));
+    if (!achado)
+        return null;
+    const bruto = fs.readFileSync(achado.caminho, 'utf8');
+    const erros = [];
+    const avisos = [];
+    let dados = {};
+    try {
+        dados = mapa((0, yaml_1.lerYaml)(bruto));
+    }
+    catch (e) {
+        erros.push(e.message);
+    }
+    const project = mapa(dados.project);
+    const board = mapa(dados.board);
+    const runtime = mapa(dados.runtime);
+    const conduction = mapa(dados.conduction);
+    const worktree = mapa(dados.worktree);
+    const verify = mapa(dados.verify);
+    const concurrency = mapa(dados.concurrency);
+    const handoff = mapa(dados.handoff);
+    const retry = mapa(dados.retry);
+    const memory = mapa(dados.memory);
+    const audit = mapa(dados.audit);
+    const abbrev = texto(project.abbrev, '');
+    const checkAbbrev = (0, slug_1.validarAbbrev)(abbrev);
+    if (!checkAbbrev.ok)
+        erros.push(checkAbbrev.erro);
+    const nomeProjeto = texto(project.name, '');
+    if (!nomeProjeto)
+        erros.push('project.name ausente no manifesto');
+    const defaultModo = (0, modos_1.parseModo)(texto(conduction.default_mode, 'classic'));
+    if (!defaultModo) {
+        erros.push(`conduction.default_mode invalido: "${texto(conduction.default_mode, '')}"`);
+    }
+    const brutosPermitidos = Array.isArray(conduction.allowed_modes)
+        ? conduction.allowed_modes.map((m) => texto(m, ''))
+        : [...modos_1.ORDEM_DOS_MODOS];
+    const permitidos = [];
+    for (const b of brutosPermitidos) {
+        const m = (0, modos_1.parseModo)(b);
+        if (!m)
+            erros.push(`conduction.allowed_modes contem modo invalido: "${b}"`);
+        else
+            permitidos.push(m);
+    }
+    if (permitidos.length === 0)
+        permitidos.push(...modos_1.ORDEM_DOS_MODOS);
+    if (defaultModo && !permitidos.includes(defaultModo)) {
+        erros.push(`conduction.default_mode (${defaultModo}) fora de conduction.allowed_modes`);
+    }
+    const providerPolicy = texto(runtime.provider_policy, 'subscription-only');
+    if (providerPolicy !== 'subscription-only' && providerPolicy !== 'any') {
+        avisos.push(`runtime.provider_policy desconhecida: "${providerPolicy}"`);
+    }
+    // Bloco B6, isolamento por tenant (precedente do incidente memory-orkmind):
+    // `database_url_env` recebe o NOME da variavel de ambiente, nunca a string de conexao.
+    // Uma DSN colada aqui e exatamente o defeito que fez a memoria de um produto escrever
+    // na base de outro, entao ela reprova o manifesto em vez de degradar em silencio.
+    const modoDeMemoria = texto(memory.mode, 'files');
+    if (modoDeMemoria !== 'files' && modoDeMemoria !== 'orkmind') {
+        erros.push(`memory.mode invalido: "${modoDeMemoria}" (esperado files ou orkmind)`);
+    }
+    const variavelDaDsn = texto(memory.database_url_env, '').trim();
+    if (variavelDaDsn.includes('://')) {
+        erros.push('memory.database_url_env recebe o NOME da variavel de ambiente com a DSN, nunca a ' +
+            'string de conexao (base propria por tenant, sem fallback para base alheia)');
+    }
+    else if (variavelDaDsn !== '' && !/^[A-Z][A-Z0-9_]*$/.test(variavelDaDsn)) {
+        erros.push(`memory.database_url_env invalido: "${variavelDaDsn}" (esperado nome de variavel de ambiente, [A-Z][A-Z0-9_]*)`);
+    }
+    if (modoDeMemoria === 'orkmind' && variavelDaDsn === '') {
+        avisos.push('memory.mode: orkmind sem memory.database_url_env: o regime efetivo cai para files ' +
+            '(o `ork` nao adivinha DSN, e base alheia e pior do que base nenhuma)');
+    }
+    const bytes = Buffer.byteLength(bruto, 'utf8');
+    if (bytes > exports.LIMITE_MANIFESTO_BYTES) {
+        erros.push(`manifesto com ${bytes} bytes, acima do limite duro de ${exports.LIMITE_MANIFESTO_BYTES} (prosa vai para memoria com tag, nao para o YAML)`);
+    }
+    if (achado.legado) {
+        avisos.push(`lendo ${exports.NOME_MANIFESTO_LEGADO} como fallback; migre para ${exports.NOME_MANIFESTO}`);
+    }
+    const manifesto = {
+        project: {
+            name: nomeProjeto,
+            abbrev,
+            stage: texto(project.stage, 'nascente') ?? 'nascente',
+            repo_root: texto(project.repo_root, raiz),
+        },
+        board: {
+            adapter: texto(board.adapter, 'hermes-kanban'),
+            default: texto(board.default, 'default'),
+        },
+        runtime: {
+            adapter: texto(runtime.adapter, 'claude-bg'),
+            model: texto(runtime.model, 'opus'),
+            effort: texto(runtime.effort, 'high'),
+            provider_policy: providerPolicy,
+        },
+        conduction: {
+            default_mode: defaultModo ?? 'classic',
+            allowed_modes: permitidos,
+        },
+        worktree: {
+            base_branch: texto(worktree.base_branch, 'main'),
+            dir: texto(worktree.dir, '.claude/worktrees'),
+            por_thread: booleano(worktree.por_thread, true),
+        },
+        verify: {
+            build: verify.build === null || verify.build === undefined ? undefined : texto(verify.build, ''),
+            test: verify.test === null || verify.test === undefined ? undefined : texto(verify.test, ''),
+            typecheck: verify.typecheck === null || verify.typecheck === undefined
+                ? undefined
+                : texto(verify.typecheck, ''),
+        },
+        concurrency: {
+            max_parallel_threads: numero(concurrency.max_parallel_threads, 3),
+        },
+        handoff: {
+            rotate_above: numero(handoff.rotate_above, 0.7),
+            force_rotate_above: numero(handoff.force_rotate_above, 0.85),
+        },
+        // Bloco B3: o limite de escalacao tem padrao, e o padrao e conservador. Manifesto
+        // sem bloco `retry:` continua andando com 3 tentativas e janela estimada de 60 min,
+        // que e exatamente o que o B3 promete, nao um "sem limite" implicito.
+        retry: {
+            max_tentativas: Math.max(0, Math.trunc(numero(retry.max_tentativas, 3))),
+            janela_padrao_min: Math.max(1, Math.trunc(numero(retry.janela_padrao_min, 60))),
+            escalar_esforco: booleano(retry.escalar_esforco, true),
+        },
+        // Bloco B6: regime de memoria. `files` e o padrao e continua sendo o fallback
+        // honesto; `orkmind` liga a camada semantica POR CIMA, e so liga quando a base
+        // propria do tenant esta declarada por NOME de variavel de ambiente.
+        memory: {
+            mode: modoDeMemoria,
+            database_url_env: variavelDaDsn,
+            cli: texto(memory.cli, 'orkmind'),
+            tenant: texto(memory.tenant, '') || nomeProjeto,
+            timeout_ms: numero(memory.timeout_ms, 15000),
+        },
+        // Bloco B5: governanca de custo dos auditores. Ausente no manifesto quer dizer
+        // "nao declarada", nao "sem limite": a rodada avisa que so `eco` e o escopo
+        // incremental estao governando o custo, em vez de fingir uma janela que ninguem escreveu.
+        audit: {
+            janela_ociosa: texto(audit.janela_ociosa, ''),
+            effort: texto(audit.effort, 'eco'),
+            since_padrao: texto(audit.since_padrao, '7d'),
+            graphify: texto(audit.graphify, 'auto'),
+        },
+        policies: Object.fromEntries(Object.entries(mapa(dados.policies)).map(([k, v]) => [k, texto(v, '')])),
+    };
+    return { caminho: achado.caminho, raiz, legado: achado.legado, bytes, manifesto, erros, avisos };
+}
+/** Carrega o manifesto ou encerra com mensagem acionavel (uso nos subcomandos). */
+function exigirManifesto(dirInicial = process.cwd()) {
+    const carregado = carregarManifesto(dirInicial);
+    if (!carregado) {
+        throw new Error(`manifesto ${exports.NOME_MANIFESTO} nao encontrado a partir de ${dirInicial}. Rode: ork init`);
+    }
+    if (carregado.erros.length > 0) {
+        throw new Error(`manifesto invalido (${carregado.caminho}):\n  - ${carregado.erros.join('\n  - ')}`);
+    }
+    return carregado;
+}