@jaimevalasek/aioson 1.5.1 → 1.7.0

package/src/commands/recovery.js

@@ -0,0 +1,43 @@
+'use strict';
+
+const path = require('node:path');
+const { generateSessionRecovery, readSessionRecovery } = require('../recovery-context-session');
+
+async function runRecoveryGenerate({ args, options, logger }) {
+  const cwd = path.resolve(process.cwd(), args[0] || '.');
+  const sessionState = {
+    goal: options.goal || undefined,
+    agent: options.agent || undefined,
+    tasks: [],
+    notes: []
+  };
+
+  const result = await generateSessionRecovery(cwd, sessionState);
+
+  if (!result.ok) {
+    logger.error(`recovery:generate failed: ${result.error}`);
+    return result;
+  }
+
+  logger.log(`Recovery context generated: ${result.path} (${result.tokens} tokens)`);
+  return result;
+}
+
+async function runRecoveryShow({ args, options, logger }) {
+  const cwd = path.resolve(process.cwd(), args[0] || '.');
+  const content = await readSessionRecovery(cwd);
+
+  if (!content) {
+    logger.log('No recovery context found. Run: aioson recovery:generate');
+    return { ok: false, error: 'not_found' };
+  }
+
+  if (options.json) {
+    return { ok: true, content };
+  }
+
+  logger.log(content);
+  return { ok: true, content };
+}
+
+module.exports = { runRecoveryGenerate, runRecoveryShow };

package/src/commands/runner-daemon.js

@@ -0,0 +1,274 @@
+'use strict';
+
+const fs = require('node:fs/promises');
+const path = require('node:path');
+const { openRuntimeDb } = require('../runtime-store');
+const {
+  ensureRunnerQueue,
+  listTasks,
+  nextPending,
+  updateTaskStatus
+} = require('../runner/queue-store');
+const { launchCLI } = require('../runner/cli-launcher');
+const { runWithCascade, parseCascadeChain } = require('../runner/cascade');
+
+const DAEMON_DDL = `
+  CREATE TABLE IF NOT EXISTS runner_daemon (
+    id            INTEGER PRIMARY KEY,
+    status        TEXT    NOT NULL DEFAULT 'stopped',
+    pid           INTEGER,
+    agent         TEXT    NOT NULL DEFAULT 'dev',
+    poll_ms       INTEGER NOT NULL DEFAULT 10000,
+    current_task  INTEGER,
+    heartbeat     TEXT,
+    started_at    TEXT,
+    stopped_at    TEXT
+  );
+`;
+
+const DAEMON_ROW_ID = 1;
+
+/**
+ * aioson runner:daemon — daemon que processa a fila do runner em background.
+ *
+ * Subcomandos:
+ *   start <path> [--agent=dev] [--poll=10]
+ *   stop <path>
+ *   status <path>
+ */
+async function runRunnerDaemon({ args, options = {}, logger }) {
+  const sub = options.sub || args[1] || 'status';
+  const projectDir = path.resolve(process.cwd(), args[0] || '.');
+
+  switch (sub) {
+    case 'start':  return await handleStart(projectDir, options, logger);
+    case 'stop':   return await handleStop(projectDir, logger);
+    case 'status': return await handleStatus(projectDir, logger);
+    default:
+      logger.error(`Unknown subcommand: ${sub}. Use start, stop, or status.`);
+      return { ok: false };
+  }
+}
+
+// ── Helpers ───────────────────────────────────────────────────────────────────
+
+function ensureDaemonTable(db) {
+  db.exec(DAEMON_DDL);
+  ensureRunnerQueue(db);
+}
+
+function getDaemonRow(db) {
+  return db.prepare('SELECT * FROM runner_daemon WHERE id = ?').get(DAEMON_ROW_ID);
+}
+
+function upsertDaemonRow(db, fields) {
+  const existing = getDaemonRow(db);
+  if (existing) {
+    const keys = Object.keys(fields);
+    const sets = keys.map((k) => `${k} = ?`).join(', ');
+    db.prepare(`UPDATE runner_daemon SET ${sets} WHERE id = ?`).run(...Object.values(fields), DAEMON_ROW_ID);
+  } else {
+    db.prepare(`
+      INSERT INTO runner_daemon (id, ${Object.keys(fields).join(', ')})
+      VALUES (${DAEMON_ROW_ID}, ${Object.keys(fields).map(() => '?').join(', ')})
+    `).run(...Object.values(fields));
+  }
+}
+
+// ── Subcommand handlers ───────────────────────────────────────────────────────
+
+async function handleStatus(projectDir, logger) {
+  let handle;
+  try {
+    handle = await openRuntimeDb(projectDir, { mustExist: true });
+  } catch { /* noop */ }
+
+  if (!handle) {
+    logger.log('[runner:daemon] No runtime database found. Use `runner:daemon start` to begin.');
+    return { ok: true, status: 'not_initialized' };
+  }
+
+  const { db } = handle;
+  ensureDaemonTable(db);
+  const row = getDaemonRow(db);
+
+  const pending = listTasks(db, { status: 'pending' }).length;
+  const running = listTasks(db, { status: 'running' }).length;
+  const completed = listTasks(db, { status: 'completed' }).length;
+  const failed = listTasks(db, { status: 'failed' }).length;
+
+  try { db.close(); } catch { /* noop */ }
+
+  if (!row || row.status === 'stopped') {
+    logger.log('[runner:daemon] Daemon is stopped.');
+  } else {
+    const icon = row.status === 'running' ? '[*]' : '[ ]';
+    logger.log(`${icon} runner-daemon ${row.status} (pid: ${row.pid || '-'})`);
+    logger.log(`    Queue: ${pending} pending | ${running} running | ${completed} completed | ${failed} failed`);
+    if (row.current_task) logger.log(`    Current task: #${row.current_task}`);
+    if (row.heartbeat) logger.log(`    Last heartbeat: ${row.heartbeat}`);
+  }
+
+  return { ok: true, row, stats: { pending, running, completed, failed } };
+}
+
+async function handleStop(projectDir, logger) {
+  const handle = await openRuntimeDb(projectDir, { mustExist: true });
+  if (!handle) {
+    logger.error('[runner:daemon] No runtime database found.');
+    return { ok: false };
+  }
+  const { db } = handle;
+  ensureDaemonTable(db);
+  const row = getDaemonRow(db);
+
+  if (!row || row.status === 'stopped') {
+    logger.log('[runner:daemon] Daemon is not running.');
+    try { db.close(); } catch { /* noop */ }
+    return { ok: true };
+  }
+
+  if (row.pid) {
+    try {
+      process.kill(row.pid, 'SIGTERM');
+      logger.log(`[runner:daemon] Sent SIGTERM to pid ${row.pid}`);
+    } catch {
+      logger.log(`[runner:daemon] Process ${row.pid} already gone.`);
+    }
+  }
+
+  upsertDaemonRow(db, { status: 'stopped', pid: null, stopped_at: new Date().toISOString() });
+  try { db.close(); } catch { /* noop */ }
+
+  logger.log('[runner:daemon] Daemon stopped.');
+  return { ok: true };
+}
+
+async function handleStart(projectDir, options, logger) {
+  const agent = options.agent || 'dev';
+  const pollMs = options.poll ? Number(options.poll) * 1000 : 10000;
+  const timeout = options.timeout ? Number(options.timeout) * 1000 : 120000;
+
+  const handle = await openRuntimeDb(projectDir, {});
+  if (!handle) {
+    logger.error('Could not open runtime database.');
+    return { ok: false };
+  }
+  const { db } = handle;
+  ensureDaemonTable(db);
+
+  // Marca daemon como running
+  upsertDaemonRow(db, {
+    status: 'running',
+    pid: process.pid,
+    agent,
+    poll_ms: pollMs,
+    started_at: new Date().toISOString(),
+    heartbeat: new Date().toISOString()
+  });
+
+  logger.log(`[runner:daemon] Started (pid: ${process.pid}, agent: @${agent}, poll: ${pollMs / 1000}s)`);
+  logger.log('[runner:daemon] Press Ctrl+C to stop gracefully.');
+
+  let stopping = false;
+  let currentTaskId = null;
+
+  const onSignal = () => {
+    if (stopping) return;
+    stopping = true;
+    logger.log('\n[runner:daemon] Stopping after current task completes...');
+    upsertDaemonRow(db, { status: 'stopping' });
+  };
+  process.once('SIGINT', onSignal);
+  process.once('SIGTERM', onSignal);
+
+  // Heartbeat a cada 30s
+  const heartbeatInterval = setInterval(() => {
+    try {
+      upsertDaemonRow(db, { heartbeat: new Date().toISOString() });
+    } catch { /* noop */ }
+  }, 30000);
+
+  // Loop principal
+  while (!stopping) {
+    const task = nextPending(db);
+
+    if (!task) {
+      await sleep(pollMs);
+      continue;
+    }
+
+    currentTaskId = task.id;
+    upsertDaemonRow(db, { current_task: task.id });
+    updateTaskStatus(db, task.id, { status: 'running' });
+
+    const taskAgent = task.agent || agent;
+    const agentFile = path.join(projectDir, '.aioson', 'agents', `${taskAgent}.md`);
+    const prompt = buildDaemonPrompt(task.task, agentFile);
+
+    logger.log(`\n[runner:daemon] Running task #${task.id}: ${task.task}`);
+    logger.log(`  Agent: @${taskAgent}`);
+
+    let result;
+    const cascadeChain = parseCascadeChain(task.cascade);
+
+    try {
+      if (cascadeChain.length > 0) {
+        const cr = await runWithCascade(projectDir, prompt, cascadeChain, {
+          timeout,
+          onProgress: ({ model, attempt, maxAttempts, status: s, reason }) => {
+            if (s === 'running') logger.log(`  [cascade] ${model} attempt ${attempt}/${maxAttempts}...`);
+            else if (s === 'gate_failed') logger.log(`  [cascade] ${model} attempt ${attempt} — gate failed${reason ? ': ' + reason : ''}`);
+          }
+        });
+        result = cr.ok ? cr.result : { ok: false, error: cr.error };
+      } else {
+        result = await launchCLI(projectDir, prompt, { timeout });
+      }
+    } catch (err) {
+      result = { ok: false, error: err.message };
+    }
+
+    if (result.ok) {
+      updateTaskStatus(db, task.id, { status: 'completed', resultOk: true });
+      logger.log(`  [runner:daemon] Task #${task.id} completed`);
+    } else {
+      const errorMsg = result.error || result.stderr || 'unknown error';
+      updateTaskStatus(db, task.id, { status: 'failed', resultOk: false, errorMsg });
+      logger.error(`  [runner:daemon] Task #${task.id} failed: ${errorMsg}`);
+    }
+
+    currentTaskId = null;
+    upsertDaemonRow(db, { current_task: null, heartbeat: new Date().toISOString() });
+  }
+
+  clearInterval(heartbeatInterval);
+  upsertDaemonRow(db, {
+    status: 'stopped',
+    pid: null,
+    current_task: null,
+    stopped_at: new Date().toISOString()
+  });
+
+  try { db.close(); } catch { /* noop */ }
+  logger.log('[runner:daemon] Stopped gracefully.');
+  return { ok: true };
+}
+
+function buildDaemonPrompt(task, agentFile) {
+  return [
+    'You are operating in autonomous headless mode. Complete the following task independently.',
+    `Agent role: read ${agentFile} for your operating instructions.`,
+    '',
+    `Task: ${task}`,
+    '',
+    'When the task is complete, write TASK_COMPLETE on a new line as the final output.',
+    'If you cannot complete the task, write TASK_FAILED: [reason].'
+  ].join('\n');
+}
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+module.exports = { runRunnerDaemon };

package/src/commands/runner-plan.js

@@ -0,0 +1,70 @@
+'use strict';
+
+const path = require('node:path');
+const { openRuntimeDb } = require('../runtime-store');
+const { ensureRunnerQueue, addTask, listTasks } = require('../runner/queue-store');
+const { importFromPlan } = require('../runner/plan-importer');
+
+/**
+ * aioson runner:plan — importa phases de um implementation-plan.md para a queue do runner.
+ *
+ * Usage:
+ *   aioson runner:plan . --slug=checkout --agent=dev
+ *   aioson runner:plan . --slug=checkout  (usa agent=dev por padrão)
+ */
+async function runRunnerPlan({ args, options = {}, logger }) {
+  const projectDir = path.resolve(process.cwd(), args[0] || '.');
+  const { slug, agent = 'dev' } = options;
+
+  if (!slug) {
+    logger.error('--slug is required. Example: aioson runner:plan . --slug=checkout');
+    return { ok: false };
+  }
+
+  let importResult;
+  try {
+    importResult = await importFromPlan(projectDir, slug, { agent });
+  } catch (err) {
+    logger.error(`[runner:plan] ${err.message}`);
+    return { ok: false, error: err.message };
+  }
+
+  const { tasks, planPath } = importResult;
+
+  if (tasks.length === 0) {
+    logger.error(
+      `[runner:plan] No phases found in implementation-plan-${slug}.md.\n` +
+      '  Expected sections like: ## Phase 1 — Create migration\n' +
+      '  Add phase headings to the plan and try again.'
+    );
+    return { ok: false, error: 'no_phases_found' };
+  }
+
+  const handle = await openRuntimeDb(projectDir, {});
+  if (!handle) {
+    logger.error('Could not open runtime database.');
+    return { ok: false };
+  }
+  const { db } = handle;
+  ensureRunnerQueue(db);
+
+  try {
+    for (const t of tasks) {
+      addTask(db, { task: t.task, agent: t.agent });
+    }
+  } finally {
+    try { db.close(); } catch { /* noop */ }
+  }
+
+  const relPath = path.relative(projectDir, planPath);
+  logger.log(`[runner:plan] Imported ${tasks.length} task(s) from ${relPath}:`);
+  for (const t of tasks) {
+    logger.log(`  ○ @${t.agent}  ${t.task}`);
+  }
+  logger.log('');
+  logger.log('Run with: aioson runner:queue run .');
+
+  return { ok: true, tasks, planPath };
+}
+
+module.exports = { runRunnerPlan };

package/src/commands/runner-queue-from-plan.js

@@ -0,0 +1,166 @@
+'use strict';
+
+/**
+ * aioson runner:queue:from-plan — import phases from an implementation plan into the runner queue.
+ *
+ * Reads an implementation-plan-{slug}.md, extracts phases, and creates runner queue
+ * tasks with dependency ordering. No LLM calls.
+ *
+ * Usage:
+ *   aioson runner:queue:from-plan . --plan=.aioson/context/implementation-plan-checkout.md
+ *   aioson runner:queue:from-plan . --feature=checkout
+ *   aioson runner:queue:from-plan . --feature=checkout --agent=dev --dry-run
+ */
+
+const path = require('node:path');
+const { readFileSafe, contextDir } = require('../preflight-engine');
+const { openRuntimeDb } = require('../runtime-store');
+const { ensureRunnerQueue, addTask } = require('../runner/queue-store');
+
+// Phase extraction patterns
+const PHASE_PATTERNS = [
+  // "## Phase 1: Create migration" or "## Phase 1 — Create migration"
+  /^#{2,3}\s+[Pp]hase\s+(\d+)[:\s—-]+(.+)$/m,
+  // "### 1. Create migration"
+  /^#{2,3}\s+(\d+)\.\s+(.+)$/m,
+  // "**Phase 1:** Create migration"
+  /^\*\*[Pp]hase\s+(\d+)[:\s—-]+\*\*\s*(.+)$/m
+];
+
+function extractPhases(content) {
+  const phases = [];
+  const lines = content.split(/\r?\n/);
+  let currentPhase = null;
+  let currentDescription = [];
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+
+    // Try all phase header patterns
+    let matched = false;
+    for (const pattern of PHASE_PATTERNS) {
+      const m = line.match(pattern);
+      if (m) {
+        // Save previous phase
+        if (currentPhase) {
+          currentPhase.detail = currentDescription.join(' ').trim().slice(0, 200);
+          phases.push(currentPhase);
+        }
+
+        const num = parseInt(m[1]);
+        const title = m[2].trim().replace(/\*+/g, '');
+        currentPhase = { num, title, detail: '', lines: [line] };
+        currentDescription = [];
+        matched = true;
+        break;
+      }
+    }
+
+    if (!matched && currentPhase) {
+      // Collect phase description from bullet points or short lines
+      const bullet = line.match(/^[-*]\s+(.+)$/);
+      if (bullet) currentDescription.push(bullet[1]);
+    }
+  }
+
+  // Save last phase
+  if (currentPhase) {
+    currentPhase.detail = currentDescription.join(' ').trim().slice(0, 200);
+    phases.push(currentPhase);
+  }
+
+  // Fallback: try H3 headings as phases if nothing found
+  if (phases.length === 0) {
+    const h3Re = /^###\s+(.+)$/gm;
+    let m, num = 1;
+    while ((m = h3Re.exec(content)) !== null) {
+      phases.push({ num: num++, title: m[1].trim(), detail: '' });
+    }
+  }
+
+  return phases;
+}
+
+async function runRunnerQueueFromPlan({ args, options = {}, logger }) {
+  const targetDir = path.resolve(process.cwd(), args[0] || '.');
+  const slug = options.feature ? String(options.feature) : null;
+  const agent = options.agent ? String(options.agent) : 'dev';
+  const dryRun = Boolean(options['dry-run'] || options.dry);
+
+  // Resolve plan file
+  let planPath = options.plan ? path.resolve(targetDir, options.plan) : null;
+  if (!planPath && slug) {
+    planPath = path.join(contextDir(targetDir), `implementation-plan-${slug}.md`);
+  }
+
+  if (!planPath) {
+    if (options.json) return { ok: false, reason: 'no_plan', message: 'Provide --plan=<path> or --feature=<slug>' };
+    logger.log('Provide --plan=<path> or --feature=<slug>.');
+    return { ok: false };
+  }
+
+  const content = await readFileSafe(planPath);
+  if (!content) {
+    if (options.json) return { ok: false, reason: 'file_not_found', path: planPath };
+    logger.log(`Plan file not found: ${path.relative(targetDir, planPath)}`);
+    return { ok: false };
+  }
+
+  const phases = extractPhases(content);
+
+  if (phases.length === 0) {
+    if (options.json) return { ok: false, reason: 'no_phases', message: 'No phases found in plan file' };
+    logger.log('No phases found in plan file. Expected "## Phase N: title" headings.');
+    return { ok: false };
+  }
+
+  logger.log(`Importing ${phases.length} phases from ${path.relative(targetDir, planPath)}:`);
+
+  if (dryRun) {
+    for (const phase of phases) {
+      const dep = phase.num > 1 ? ` (depends: Phase ${phase.num - 1})` : '';
+      logger.log(`  Phase ${phase.num}: "${phase.title}"${dep} → would queue (priority: ${phase.num})`);
+    }
+    logger.log(`\n[dry-run] ${phases.length} tasks would be queued for @${agent}`);
+    return { ok: true, dry_run: true, phases, agent };
+  }
+
+  // Open runtime DB and queue tasks
+  const handle = await openRuntimeDb(targetDir, {});
+  if (!handle) {
+    if (options.json) return { ok: false, reason: 'no_runtime' };
+    logger.log('Could not open runtime database.');
+    return { ok: false };
+  }
+
+  const { db } = handle;
+  ensureRunnerQueue(db);
+
+  const queued = [];
+  try {
+    for (const phase of phases) {
+      const taskDesc = phase.detail
+        ? `Phase ${phase.num}: ${phase.title} — ${phase.detail}`
+        : `Phase ${phase.num}: ${phase.title}`;
+
+      const id = addTask(db, {
+        task: taskDesc,
+        agent,
+        cascade: options.cascade || null,
+        priority: phase.num
+      });
+
+      queued.push({ id, phase: phase.num, title: phase.title });
+      const dep = phase.num > 1 ? ` (depends: Phase ${phase.num - 1})` : '';
+      logger.log(`  Phase ${phase.num}: "${phase.title}"${dep} → queued (id: ${id}, priority: ${phase.num})`);
+    }
+  } finally {
+    try { db.close(); } catch { /* noop */ }
+  }
+
+  logger.log(`\n${queued.length} tasks queued. Run: aioson runner:queue list`);
+
+  return { ok: true, plan_path: path.relative(targetDir, planPath), agent, queued };
+}
+
+module.exports = { runRunnerQueueFromPlan };