@orkastery/cli 0.2.0

package/dist/init.js

@@ -0,0 +1,231 @@
+"use strict";
+/**
+ * `ork init`: gera o `orkastery.yaml` do repositorio.
+ *
+ * O wizard detecta em vez de perguntar (gerenciador de pacotes, branch base, scripts de
+ * verificacao) e nunca sobrescreve um manifesto existente sem `--force`.
+ */
+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.raizDoRepo = raizDoRepo;
+exports.nomeDetectado = nomeDetectado;
+exports.baseBranchDetectada = baseBranchDetectada;
+exports.verifyDetectado = verifyDetectado;
+exports.detectar = detectar;
+exports.manifestoYaml = manifestoYaml;
+exports.init = init;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const manifest_1 = require("./manifest");
+const slug_1 = require("./slug");
+const util_1 = require("./util");
+/** Raiz do repositorio git, resolvendo tambem o caso de worktree. */
+function raizDoRepo(dirInicial) {
+    const r = (0, util_1.exec)('git', ['rev-parse', '--show-toplevel'], dirInicial);
+    return r.ok ? r.stdout.trim() : path.resolve(dirInicial);
+}
+/** Nome canonico do produto a partir do diretorio principal do repositorio. */
+function nomeDetectado(dirInicial) {
+    const comum = (0, util_1.exec)('git', ['rev-parse', '--path-format=absolute', '--git-common-dir'], dirInicial);
+    const base = comum.ok
+        ? path.basename(path.dirname(comum.stdout.trim()))
+        : path.basename(raizDoRepo(dirInicial));
+    return base.replace(/-(novo|new|old|repo|main)$/i, '').toLowerCase();
+}
+/** Branch base do repositorio: origin/HEAD, senao main, senao master, senao a atual. */
+function baseBranchDetectada(raiz) {
+    const origem = (0, util_1.exec)('git', ['symbolic-ref', '--quiet', 'refs/remotes/origin/HEAD'], raiz);
+    if (origem.ok && origem.stdout.trim()) {
+        return origem.stdout.trim().replace('refs/remotes/origin/', '');
+    }
+    for (const candidata of ['main', 'master']) {
+        if ((0, util_1.exec)('git', ['show-ref', '--verify', '--quiet', `refs/heads/${candidata}`], raiz).ok) {
+            return candidata;
+        }
+    }
+    const atual = (0, util_1.exec)('git', ['rev-parse', '--abbrev-ref', 'HEAD'], raiz);
+    return atual.ok ? atual.stdout.trim() : 'main';
+}
+function gerenciadorDetectado(dir) {
+    if (fs.existsSync(path.join(dir, 'pnpm-lock.yaml')))
+        return 'pnpm';
+    if (fs.existsSync(path.join(dir, 'yarn.lock')))
+        return 'yarn';
+    if (fs.existsSync(path.join(dir, 'bun.lockb')))
+        return 'bun';
+    return 'npm';
+}
+/** Procura o package.json do projeto na raiz e nos subdiretorios convencionais. */
+function acharPacote(raiz) {
+    const candidatos = ['', 'core', 'app', 'src'];
+    for (const sub of candidatos) {
+        const dir = path.join(raiz, sub);
+        if (fs.existsSync(path.join(dir, 'package.json'))) {
+            return { dir, prefixo: sub };
+        }
+    }
+    return null;
+}
+/** Detecta os comandos de verificacao a partir dos scripts do package.json. */
+function verifyDetectado(raiz) {
+    const pacote = acharPacote(raiz);
+    if (!pacote)
+        return {};
+    let scripts = {};
+    try {
+        const json = JSON.parse(fs.readFileSync(path.join(pacote.dir, 'package.json'), 'utf8'));
+        scripts = (json.scripts ?? {});
+    }
+    catch {
+        return {};
+    }
+    const gerenciador = gerenciadorDetectado(pacote.dir === raiz ? raiz : pacote.dir);
+    const prefixo = pacote.prefixo ? `${gerenciador} --prefix ${pacote.prefixo}` : gerenciador;
+    const verify = {};
+    if (scripts.build)
+        verify.build = `${prefixo} run build`;
+    if (scripts.test)
+        verify.test = `${prefixo} test`;
+    if (scripts.typecheck)
+        verify.typecheck = `${prefixo} run typecheck`;
+    return verify;
+}
+/** Roda a deteccao completa do repositorio. */
+function detectar(dirInicial, nomeForcado, abbrevForcada) {
+    const raiz = raizDoRepo(dirInicial);
+    const nome = nomeForcado ?? nomeDetectado(dirInicial);
+    return {
+        raiz,
+        nome,
+        abbrev: (0, slug_1.normalizarAbbrev)(abbrevForcada ?? nome),
+        baseBranch: baseBranchDetectada(raiz),
+        gerenciador: gerenciadorDetectado(raiz),
+        verify: verifyDetectado(raiz),
+    };
+}
+/** Serializa o manifesto v1 a partir da deteccao. */
+function manifestoYaml(d) {
+    const linhaVerify = (chave, valor) => valor ? `  ${chave}: "${valor}"` : `  # ${chave}: nao detectado`;
+    return `# Manifesto do Orkastery (v1, bloco B0)
+# Gerado por \`ork init\`. Fonte unica da configuracao do projeto.
+# Limite duro de 16 KB: prosa longa vai para a memoria com tag, nao para este arquivo.
+
+project:
+  name: "${d.nome}"
+  # abbrev: ate 3 caracteres [a-z0-9], parte 1 do slug de sessao, unica no workspace
+  abbrev: "${d.abbrev}"
+  stage: nascente
+
+board:
+  adapter: hermes-kanban
+  default: default
+
+runtime:
+  # claude-bg despacha \`claude --bg\` (sessao visivel no app e em \`claude agents\`)
+  adapter: claude-bg
+  model: opus
+  effort: high
+  # subscription-only: proibido despachar por provider pago (licao dos US$ 16)
+  provider_policy: subscription-only
+
+conduction:
+  # modo usado quando o pedido do builder nao traz #TAG
+  default_mode: classic
+  allowed_modes: [look, ork, classic, maestro, auto]
+
+worktree:
+  base_branch: "${d.baseBranch}"
+  dir: ".claude/worktrees"
+  por_thread: true
+
+verify:
+${linhaVerify('build', d.verify.build)}
+${linhaVerify('test', d.verify.test)}
+${linhaVerify('typecheck', d.verify.typecheck)}
+
+concurrency:
+  max_parallel_threads: 3
+
+handoff:
+  # gate de tokens (bloco B1): rotaciona a sessao acima destas ocupacoes de janela
+  rotate_above: 0.70
+  force_rotate_above: 0.85
+
+retry:
+  # autonomia do bloco B3: retry tipado por motivo de gate e fila duravel de rate limit
+  # max_tentativas e o LIMITE DE ESCALACAO: estourado, pausa qualquer modo, ate #Auto
+  max_tentativas: 3
+  # janela usada so quando o runtime diz "rate limit" e NAO diz a hora do reset
+  # (fica marcada como estimativa na fila; o ork nunca inventa horario medido)
+  janela_padrao_min: 60
+  escalar_esforco: true
+
+memory:
+  # files = fallback honesto sem OrkMind (handoff por arquivos, ponteiro path#ancora)
+  # orkmind = camada semantica do bloco B6 por cima, com degradacao honesta para files
+  mode: files
+  # NOME da variavel de ambiente com a DSN da base PROPRIA deste tenant, nunca a DSN.
+  # Vazio = o regime orkmind nao liga (o ork nao adivinha base: base alheia e pior que
+  # base nenhuma, precedente do incidente memory-orkmind).
+  database_url_env: ""
+  cli: orkmind
+  timeout_ms: 15000
+
+audit:
+  # governanca de custo dos auditores periodicos (bloco B5)
+  # janela ociosa da assinatura: fora dela a rodada so anda com --agora <quem>
+  janela_ociosa: "22:00-06:00"
+  effort: eco
+  since_padrao: 7d
+  graphify: auto
+
+policies:
+  provider: block
+  segredo_em_prompt: block
+  push_direto_na_base: block
+`;
+}
+/** Gera o manifesto e o esqueleto de `.orkastery/`. Nao sobrescreve sem `force`. */
+function init(dirInicial, opcoes = {}) {
+    const deteccao = detectar(dirInicial, opcoes.nome, opcoes.abbrev);
+    const caminho = path.join(deteccao.raiz, manifest_1.NOME_MANIFESTO);
+    const existe = fs.existsSync(caminho);
+    if (existe && !opcoes.force) {
+        return { caminho, criado: false, deteccao };
+    }
+    (0, util_1.gravar)(caminho, manifestoYaml(deteccao));
+    fs.mkdirSync(path.join(deteccao.raiz, manifest_1.DIR_ESTADO, 'threads'), { recursive: true });
+    return { caminho, criado: true, deteccao };
+}