@jaimevalasek/aioson 1.5.1 → 1.7.0

package/src/recovery-context-session.js

@@ -0,0 +1,154 @@
+'use strict';
+
+const fs = require('node:fs/promises');
+const path = require('node:path');
+const { execFile } = require('node:child_process');
+const { promisify } = require('node:util');
+
+const execFileAsync = promisify(execFile);
+
+const CONTEXT_DIR = path.join('.aioson', 'context');
+const RECOVERY_FILE = 'recovery-context.md';
+const MAX_TOKENS = 2000;
+
+function estimateTokens(str) {
+  return Math.ceil(str.length / 4);
+}
+
+async function readRecentGitLog(cwd, limit = 10) {
+  try {
+    const { stdout } = await execFileAsync('git', [
+      'log', `--max-count=${limit}`, '--oneline', '--no-merges'
+    ], { cwd });
+    return stdout.trim().split('\n').filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+
+async function readModifiedFiles(cwd) {
+  try {
+    const { stdout } = await execFileAsync('git', [
+      'diff', '--name-only', 'HEAD'
+    ], { cwd });
+    return stdout.trim().split('\n').filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+
+function buildSessionRecoveryMarkdown(sessionState, gitLog, modifiedFiles) {
+  const lines = [];
+
+  lines.push('# Recovery Context — Direct Session');
+  lines.push(`> Generated: ${new Date().toISOString()}`);
+  lines.push('');
+
+  // Session goal/task
+  if (sessionState.goal) {
+    lines.push('## Current Goal');
+    lines.push(sessionState.goal);
+    lines.push('');
+  }
+
+  // Active agent
+  if (sessionState.agent) {
+    lines.push('## Active Agent');
+    lines.push(sessionState.agent);
+    lines.push('');
+  }
+
+  // Tasks
+  const tasks = Array.isArray(sessionState.tasks) ? sessionState.tasks : [];
+  if (tasks.length > 0) {
+    lines.push('## Tasks');
+    for (const t of tasks.slice(-5)) {
+      const status = t.status || 'unknown';
+      const title = t.title || t.id || '(untitled)';
+      lines.push(`- [${status}] ${title}`);
+    }
+    lines.push('');
+  }
+
+  // Notes
+  const notes = Array.isArray(sessionState.notes) ? sessionState.notes : [];
+  if (notes.length > 0) {
+    lines.push('## Notes');
+    for (const note of notes.slice(-5)) {
+      lines.push(`- ${note}`);
+    }
+    lines.push('');
+  }
+
+  // Modified files
+  if (modifiedFiles.length > 0) {
+    lines.push('## Modified Files');
+    for (const f of modifiedFiles.slice(0, 10)) {
+      lines.push(`- ${f}`);
+    }
+    lines.push('');
+  }
+
+  // Recent git commits
+  if (gitLog.length > 0) {
+    lines.push('## Recent Commits');
+    for (const entry of gitLog.slice(0, 5)) {
+      lines.push(`- ${entry}`);
+    }
+    lines.push('');
+  }
+
+  lines.push('---');
+  lines.push('*Inject this file at the top of your next session to restore context after a compact.*');
+
+  return lines.join('\n');
+}
+
+/**
+ * Generate and write recovery-context.md for a direct session (no squad).
+ * @param {string} cwd  — project root directory
+ * @param {object} sessionState  — { goal?, agent?, tasks?, notes? }
+ * @returns {{ ok: boolean, path: string, tokens: number }}
+ */
+async function generateSessionRecovery(cwd, sessionState = {}) {
+  const [gitLog, modifiedFiles] = await Promise.all([
+    readRecentGitLog(cwd),
+    readModifiedFiles(cwd)
+  ]);
+
+  let content = buildSessionRecoveryMarkdown(sessionState, gitLog, modifiedFiles);
+
+  // Enforce token budget
+  if (estimateTokens(content) > MAX_TOKENS) {
+    content = buildSessionRecoveryMarkdown(sessionState, gitLog.slice(0, 3), modifiedFiles.slice(0, 5));
+  }
+
+  const tokens = estimateTokens(content);
+  const outDir = path.join(cwd, CONTEXT_DIR);
+  const outPath = path.join(outDir, RECOVERY_FILE);
+
+  try {
+    await fs.mkdir(outDir, { recursive: true });
+    await fs.writeFile(outPath, content, 'utf8');
+  } catch (err) {
+    return { ok: false, error: err.message, path: outPath, tokens };
+  }
+
+  return { ok: true, path: outPath, tokens };
+}
+
+/**
+ * Read the current session recovery-context.md (returns null if missing).
+ * @param {string} cwd
+ * @returns {string|null}
+ */
+async function readSessionRecovery(cwd) {
+  const p = path.join(cwd, CONTEXT_DIR, RECOVERY_FILE);
+  try {
+    return await fs.readFile(p, 'utf8');
+  } catch {
+    return null;
+  }
+}
+
+module.exports = { generateSessionRecovery, readSessionRecovery };

package/src/runner/cascade.js

@@ -0,0 +1,97 @@
+'use strict';
+
+const { launchCLI } = require('./cli-launcher');
+
+const DEFAULT_ATTEMPTS = { haiku: 3, sonnet: 2, opus: 1 };
+
+// Model IDs por alias. Injetados via ANTHROPIC_MODEL env var para Claude Code.
+const MODEL_MAP = {
+  haiku:  'claude-haiku-4-5-20251001',
+  sonnet: 'claude-sonnet-4-6',
+  opus:   'claude-opus-4-6'
+};
+
+/**
+ * Executa uma task com cascade de modelos.
+ *
+ * Para cada modelo na cadeia:
+ *   1. Tenta até N vezes (DEFAULT_ATTEMPTS ou customizado)
+ *   2. Se result.ok: verifica via gateConfig (opcional)
+ *   3. Se aprovado: retorna resultado imediatamente
+ *   4. Se reprovado ou falha: tenta próximo modelo
+ *
+ * @param {string} projectDir
+ * @param {string} prompt
+ * @param {string[]} modelChain  ex: ['haiku', 'sonnet', 'opus']
+ * @param {object} options
+ * @param {string} [options.tool]         CLI a usar (padrão: auto-detectado)
+ * @param {Function} [options.gateCheck]  fn(output: string) → {passed: boolean, reason?: string}
+ * @param {Function} [options.onProgress] fn({model, attempt, maxAttempts, status, reason?})
+ * @param {number} [options.timeout]      Timeout em ms por tentativa
+ * @returns {Promise<{ok: boolean, result?, modelUsed?: string, attempts?: number, error?: string}>}
+ */
+async function runWithCascade(projectDir, prompt, modelChain, options = {}) {
+  const { tool, gateCheck, onProgress, timeout } = options;
+
+  for (const modelAlias of modelChain) {
+    const maxAttempts = DEFAULT_ATTEMPTS[modelAlias] ?? 1;
+    const modelId = MODEL_MAP[modelAlias];
+
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+      if (onProgress) {
+        onProgress({ model: modelAlias, attempt, maxAttempts, status: 'running' });
+      }
+
+      // Injeta o modelo via ANTHROPIC_MODEL (compatível com Claude Code)
+      const extraEnv = modelId ? { ANTHROPIC_MODEL: modelId } : {};
+
+      const result = await launchCLI(projectDir, prompt, {
+        tool,
+        timeout,
+        env: extraEnv
+      });
+
+      if (!result.ok) {
+        if (onProgress) {
+          onProgress({ model: modelAlias, attempt, maxAttempts, status: 'cli_failed' });
+        }
+        continue;
+      }
+
+      // Verifica qualidade se gate configurado
+      if (gateCheck) {
+        const gateResult = gateCheck(result.output);
+        if (gateResult.passed) {
+          return { ok: true, result, modelUsed: modelAlias, attempts: attempt };
+        }
+        if (onProgress) {
+          onProgress({
+            model: modelAlias,
+            attempt,
+            maxAttempts,
+            status: 'gate_failed',
+            reason: gateResult.reason || 'quality gate failed'
+          });
+        }
+        // Não retorna — tenta próxima tentativa ou próximo modelo
+      } else {
+        // Sem gate: aceita o resultado
+        return { ok: true, result, modelUsed: modelAlias, attempts: attempt };
+      }
+    }
+  }
+
+  return { ok: false, error: 'All cascade models exhausted without passing quality gate' };
+}
+
+/**
+ * Parseia uma string de cascade como "haiku,sonnet,opus" para um array.
+ * @param {string} cascadeStr
+ * @returns {string[]}
+ */
+function parseCascadeChain(cascadeStr) {
+  if (!cascadeStr) return [];
+  return cascadeStr.split(',').map((s) => s.trim().toLowerCase()).filter(Boolean);
+}
+
+module.exports = { runWithCascade, parseCascadeChain, MODEL_MAP, DEFAULT_ATTEMPTS };

package/src/runner/cli-launcher.js

@@ -0,0 +1,109 @@
+'use strict';
+
+const { spawn } = require('node:child_process');
+
+/**
+ * Detecta qual CLI de AI está disponível no sistema.
+ * Usa AIOSON_RUNNER_TOOL env var se definida, depois tenta
+ * claude, codex, gemini, opencode em sequência.
+ */
+async function detectCLI() {
+  const envTool = process.env.AIOSON_RUNNER_TOOL;
+  if (envTool) return envTool;
+
+  for (const cli of ['claude', 'codex', 'gemini', 'opencode']) {
+    const found = await new Promise((resolve) => {
+      const child = spawn('which', [cli], { stdio: 'pipe' });
+      child.on('close', (code) => resolve(code === 0));
+      child.on('error', () => resolve(false));
+    });
+    if (found) return cli;
+  }
+  throw new Error('No AI CLI found. Install claude, codex, gemini, or opencode.');
+}
+
+/**
+ * Monta os argumentos de headless para cada CLI.
+ */
+function buildArgs(cli, prompt, options = {}) {
+  const { allowedTools, outputFormat } = options;
+
+  switch (cli) {
+    case 'claude':
+      return [
+        '-p', prompt,
+        '--output-format', outputFormat || 'stream-json',
+        '--dangerously-skip-permissions',
+        ...(allowedTools ? ['--allowedTools', allowedTools] : [])
+      ];
+    case 'codex':
+      return ['-p', prompt, '--quiet', '--no-interactive'];
+    case 'gemini':
+      return ['-p', prompt, '--quiet'];
+    default:
+      return ['-p', prompt];
+  }
+}
+
+/**
+ * Spawna o CLI de AI com o prompt headless e retorna o output.
+ * Detecta TASK_COMPLETE no stream para sinalizar conclusão.
+ *
+ * @param {string} projectDir
+ * @param {string} prompt
+ * @param {object} options
+ * @returns {Promise<{ok: boolean, output: string, stderr: string, completionMarker: boolean, exitCode: number}>}
+ */
+async function launchCLI(projectDir, prompt, options = {}) {
+  const { tool, timeout = 120000, onData, env: extraEnv } = options;
+  const cli = tool || await detectCLI();
+  const args = buildArgs(cli, prompt, options);
+
+  return new Promise((resolve) => {
+    const child = spawn(cli, args, {
+      cwd: projectDir,
+      env: { ...process.env, ...(extraEnv || {}) },
+      stdio: ['ignore', 'pipe', 'pipe']
+    });
+
+    let stdout = '';
+    let stderr = '';
+    let completionMarker = false;
+    let settled = false;
+
+    const timer = timeout > 0
+      ? setTimeout(() => {
+          if (!settled) child.kill('SIGTERM');
+        }, timeout)
+      : null;
+
+    child.stdout.on('data', (chunk) => {
+      const text = chunk.toString();
+      stdout += text;
+      if (onData) onData(text);
+      if (text.includes('TASK_COMPLETE')) completionMarker = true;
+    });
+
+    child.stderr.on('data', (chunk) => { stderr += chunk.toString(); });
+
+    child.on('close', (code) => {
+      settled = true;
+      if (timer) clearTimeout(timer);
+      resolve({
+        ok: code === 0,
+        output: stdout.trim(),
+        stderr: stderr.trim(),
+        completionMarker,
+        exitCode: code ?? -1
+      });
+    });
+
+    child.on('error', (err) => {
+      settled = true;
+      if (timer) clearTimeout(timer);
+      resolve({ ok: false, output: '', stderr: err.message, completionMarker: false, exitCode: -1 });
+    });
+  });
+}
+
+module.exports = { launchCLI, detectCLI, buildArgs };

package/src/runner/plan-importer.js

@@ -0,0 +1,63 @@
+'use strict';
+
+const fs = require('node:fs/promises');
+const path = require('node:path');
+
+/**
+ * Parseia um implementation-plan-{slug}.md e extrai as phases como tasks.
+ *
+ * Formatos suportados:
+ *   ## Phase 1 — Title
+ *   ## Phase 1 - Title
+ *   ## Phase 1: Title
+ *
+ * @param {string} projectDir
+ * @param {string} slug
+ * @param {{ agent?: string }} options
+ * @returns {Promise<Array<{task: string, agent: string, status: string}>>}
+ */
+async function importFromPlan(projectDir, slug, options = {}) {
+  const { agent = 'dev' } = options;
+
+  const candidates = [
+    path.join(projectDir, '.aioson', 'context', `implementation-plan-${slug}.md`),
+    path.join(projectDir, '.aioson', 'plans', `implementation-plan-${slug}.md`),
+    path.join(projectDir, `implementation-plan-${slug}.md`)
+  ];
+
+  let content = null;
+  let foundPath = null;
+  for (const candidate of candidates) {
+    try {
+      content = await fs.readFile(candidate, 'utf8');
+      foundPath = candidate;
+      break;
+    } catch { /* try next */ }
+  }
+
+  if (!content) {
+    throw new Error(
+      `implementation-plan-${slug}.md not found. Tried:\n` +
+      candidates.map((c) => `  ${c}`).join('\n') +
+      '\n\nRun `aioson plan . --slug=' + slug + '` to create one.'
+    );
+  }
+
+  const tasks = [];
+
+  // Captura ## Phase N seguido de separador (—, -, :) e título
+  // Exemplos: "## Phase 1 — Create migration"  "## Phase 1 - Foo"  "## Phase 1: Bar"
+  const phaseRegex = /^##\s+Phase\s+\d+\s*(?:[—\-:])\s*(.+)$/gim;
+  let match;
+
+  while ((match = phaseRegex.exec(content)) !== null) {
+    const title = match[1].trim().replace(/\s*\(.*?\)\s*$/, '').trim(); // remove sufixos como "(2-3 days)"
+    if (title) {
+      tasks.push({ task: title, agent, status: 'pending' });
+    }
+  }
+
+  return { tasks, planPath: foundPath };
+}
+
+module.exports = { importFromPlan };

package/src/runner/queue-store.js

@@ -0,0 +1,159 @@
+'use strict';
+
+/**
+ * CRUD para a tabela runner_queue no SQLite existente.
+ * A tabela é criada automaticamente via openRuntimeDb — este módulo
+ * apenas lida com a DDL adicional e os queries da fila do runner.
+ */
+
+const RUNNER_QUEUE_DDL = `
+  CREATE TABLE IF NOT EXISTS runner_queue (
+    id          INTEGER PRIMARY KEY AUTOINCREMENT,
+    task        TEXT    NOT NULL,
+    agent       TEXT    NOT NULL DEFAULT 'dev',
+    status      TEXT    NOT NULL DEFAULT 'pending',
+    cascade     TEXT,
+    priority    INTEGER NOT NULL DEFAULT 0,
+    created_at  TEXT    NOT NULL DEFAULT (datetime('now')),
+    started_at  TEXT,
+    finished_at TEXT,
+    result_ok   INTEGER,
+    error_msg   TEXT,
+    session_id  TEXT
+  );
+`;
+
+/**
+ * Garante que a tabela runner_queue existe no DB aberto.
+ * @param {import('better-sqlite3').Database} db
+ */
+function ensureRunnerQueue(db) {
+  db.exec(RUNNER_QUEUE_DDL);
+}
+
+/**
+ * Adiciona uma task à fila.
+ * @param {import('better-sqlite3').Database} db
+ * @param {{ task: string, agent?: string, cascade?: string, priority?: number }} options
+ * @returns {number} id da task inserida
+ */
+function addTask(db, options) {
+  ensureRunnerQueue(db);
+  const { task, agent = 'dev', cascade = null, priority = 0 } = options;
+  const result = db.prepare(`
+    INSERT INTO runner_queue (task, agent, cascade, priority)
+    VALUES (?, ?, ?, ?)
+  `).run(task, agent, cascade, priority);
+  return result.lastInsertRowid;
+}
+
+/**
+ * Lista todas as tasks da fila, ordenadas por prioridade DESC, criação ASC.
+ * @param {import('better-sqlite3').Database} db
+ * @param {{ status?: string }} options
+ */
+function listTasks(db, options = {}) {
+  ensureRunnerQueue(db);
+  if (options.status) {
+    return db.prepare(`
+      SELECT * FROM runner_queue WHERE status = ? ORDER BY priority DESC, id ASC
+    `).all(options.status);
+  }
+  return db.prepare(`
+    SELECT * FROM runner_queue ORDER BY priority DESC, id ASC
+  `).all();
+}
+
+/**
+ * Busca a próxima task com status pending.
+ * @param {import('better-sqlite3').Database} db
+ */
+function nextPending(db) {
+  ensureRunnerQueue(db);
+  return db.prepare(`
+    SELECT * FROM runner_queue WHERE status = 'pending' ORDER BY priority DESC, id ASC LIMIT 1
+  `).get();
+}
+
+/**
+ * Atualiza o status de uma task.
+ * @param {import('better-sqlite3').Database} db
+ * @param {number} id
+ * @param {{ status: string, resultOk?: boolean, errorMsg?: string, sessionId?: string }} options
+ */
+function updateTaskStatus(db, id, options) {
+  ensureRunnerQueue(db);
+  const now = new Date().toISOString();
+  const status = options.status;
+  const isFinished = status === 'completed' || status === 'failed' || status === 'skipped';
+  const isStarted = status === 'running';
+
+  db.prepare(`
+    UPDATE runner_queue
+    SET status      = ?,
+        result_ok   = COALESCE(?, result_ok),
+        error_msg   = COALESCE(?, error_msg),
+        session_id  = COALESCE(?, session_id),
+        started_at  = CASE WHEN ? = 1 THEN ? ELSE started_at END,
+        finished_at = CASE WHEN ? = 1 THEN ? ELSE finished_at END
+    WHERE id = ?
+  `).run(
+    status,
+    options.resultOk != null ? (options.resultOk ? 1 : 0) : null,
+    options.errorMsg ?? null,
+    options.sessionId ?? null,
+    isStarted ? 1 : 0, now,
+    isFinished ? 1 : 0, now,
+    id
+  );
+}
+
+/**
+ * Remove todas as tasks da fila (clear).
+ * @param {import('better-sqlite3').Database} db
+ */
+function clearQueue(db) {
+  ensureRunnerQueue(db);
+  db.prepare('DELETE FROM runner_queue').run();
+}
+
+/**
+ * Exporta todas as tasks como Markdown.
+ * @param {import('better-sqlite3').Database} db
+ */
+function exportQueueMarkdown(db) {
+  const tasks = listTasks(db);
+  if (tasks.length === 0) return '# Runner Queue\n\n_Queue is empty._\n';
+
+  const STATUS_ICON = {
+    pending: '○',
+    running: '▶',
+    completed: '✓',
+    failed: '✗',
+    skipped: '—'
+  };
+
+  const lines = ['# Runner Queue', ''];
+  for (const t of tasks) {
+    const icon = STATUS_ICON[t.status] || '?';
+    const cascade = t.cascade ? ` [cascade: ${t.cascade}]` : '';
+    lines.push(`- ${icon} **${t.id}** \`@${t.agent}\`${cascade} — ${t.task}`);
+    if (t.status !== 'pending') {
+      lines.push(`  - Status: ${t.status} | Created: ${t.created_at}`);
+      if (t.finished_at) lines.push(`  - Finished: ${t.finished_at}`);
+      if (t.error_msg) lines.push(`  - Error: ${t.error_msg}`);
+    }
+  }
+  lines.push('');
+  return lines.join('\n');
+}
+
+module.exports = {
+  ensureRunnerQueue,
+  addTask,
+  listTasks,
+  nextPending,
+  updateTaskStatus,
+  clearQueue,
+  exportQueueMarkdown
+};