@jaimevalasek/aioson 1.6.0 → 1.7.2

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
+};

package/src/runtime-store.js

@@ -590,6 +590,32 @@ async function openRuntimeDb(targetDir, options = {}) {
       created_at TEXT DEFAULT (datetime('now')),
       updated_at TEXT DEFAULT (datetime('now'))
     );
+
+    CREATE TABLE IF NOT EXISTS dynamic_squad_tools (
+      name TEXT NOT NULL,
+      squad_slug TEXT NOT NULL,
+      description TEXT NOT NULL,
+      input_schema TEXT NOT NULL DEFAULT '{}',
+      handler_type TEXT NOT NULL DEFAULT 'shell',
+      handler_code TEXT,
+      handler_path TEXT,
+      registered_at TEXT NOT NULL,
+      registered_by TEXT,
+      PRIMARY KEY (name, squad_slug)
+    );
+    CREATE INDEX IF NOT EXISTS idx_dynamic_squad_tools_squad ON dynamic_squad_tools(squad_slug);
+
+    CREATE TABLE IF NOT EXISTS inter_squad_events (
+      id TEXT PRIMARY KEY,
+      from_squad TEXT NOT NULL,
+      event TEXT NOT NULL,
+      payload TEXT,
+      created_at TEXT NOT NULL,
+      consumed_by TEXT NOT NULL DEFAULT '[]',
+      ttl_hours INTEGER NOT NULL DEFAULT 48
+    );
+    CREATE INDEX IF NOT EXISTS idx_inter_squad_events_from ON inter_squad_events(from_squad, created_at DESC);
+    CREATE INDEX IF NOT EXISTS idx_inter_squad_events_event ON inter_squad_events(event, created_at DESC);
   `);
 
   ensureLegacyColumns(db);
@@ -694,6 +720,31 @@ function ensureLegacyColumns(db) {
 
   try { db.exec('ALTER TABLE worker_runs ADD COLUMN conversation_id TEXT'); } catch { /* já existe */ }
 
+  // Event Enrichment (Plan 61) — new columns in execution_events
+  const execEventColumns = db.prepare('PRAGMA table_info(execution_events)').all();
+  const execEventColumnNames = new Set(execEventColumns.map((col) => col.name));
+
+  if (!execEventColumnNames.has('plan_step_id')) {
+    db.exec('ALTER TABLE execution_events ADD COLUMN plan_step_id TEXT');
+  }
+  if (!execEventColumnNames.has('worker_status')) {
+    db.exec('ALTER TABLE execution_events ADD COLUMN worker_status TEXT');
+  }
+  if (!execEventColumnNames.has('verdict')) {
+    db.exec('ALTER TABLE execution_events ADD COLUMN verdict TEXT');
+  }
+  if (!execEventColumnNames.has('token_count')) {
+    db.exec('ALTER TABLE execution_events ADD COLUMN token_count INTEGER');
+  }
+  if (!execEventColumnNames.has('progress_pct')) {
+    db.exec('ALTER TABLE execution_events ADD COLUMN progress_pct REAL');
+  }
+
+  db.exec('CREATE INDEX IF NOT EXISTS idx_execution_events_agent_type ON execution_events(agent_name, event_type, created_at DESC)');
+  db.exec('CREATE INDEX IF NOT EXISTS idx_execution_events_verdict ON execution_events(verdict, created_at DESC)');
+  db.exec('CREATE INDEX IF NOT EXISTS idx_plan_phases_status ON plan_phases(plan_id, status)');
+  db.exec('CREATE INDEX IF NOT EXISTS idx_artifacts_run ON artifacts(run_key, created_at DESC)');
+
   // Dynamic Tools (Feature: Tool Registry)
   db.exec(`
     CREATE TABLE IF NOT EXISTS dynamic_tools (
@@ -767,12 +818,14 @@ function insertExecutionEvent(db, record) {
       task_key, run_key, agent_name, agent_kind, squad_slug, session_key,
       source, workflow_id, workflow_stage, parent_run_key,
       event_type, phase, status, tool_name, message, payload_json,
-      sequence_no, parent_event_id, created_at
+      sequence_no, parent_event_id, created_at,
+      plan_step_id, worker_status, verdict, token_count, progress_pct
     ) VALUES (
       @task_key, @run_key, @agent_name, @agent_kind, @squad_slug, @session_key,
       @source, @workflow_id, @workflow_stage, @parent_run_key,
       @event_type, @phase, @status, @tool_name, @message, @payload_json,
-      @sequence_no, @parent_event_id, @created_at
+      @sequence_no, @parent_event_id, @created_at,
+      @plan_step_id, @worker_status, @verdict, @token_count, @progress_pct
     )
   `).run(record);
 }
@@ -814,7 +867,12 @@ function appendRunEvent(db, options) {
       payload_json: payloadJson,
       sequence_no: nextExecutionSequence(db, run.run_key),
       parent_event_id: options.parentEventId || null,
-      created_at: now
+      created_at: now,
+      plan_step_id: options.planStepId ? String(options.planStepId).trim() : null,
+      worker_status: options.workerStatus ? String(options.workerStatus).trim() : null,
+      verdict: options.verdict ? String(options.verdict).trim().toUpperCase() : null,
+      token_count: options.tokenCount != null ? Number(options.tokenCount) || null : null,
+      progress_pct: options.progressPct != null ? Number(options.progressPct) || null : null
     });
   });
 

package/src/squad/agent-teams-adapter.js

@@ -0,0 +1,264 @@
+'use strict';
+
+/**
+ * Agent Teams Adapter — Plan 81, Phase 1.1
+ *
+ * Translates squad manifests into Claude Code Agent Teams configurations.
+ * Enables squads to execute via native Agent Teams parallelism instead of
+ * manual Promise.all of subprocesses.
+ *
+ * Mapping:
+ *   executors[].slug            → teammates[].name
+ *   executors[].type            → teammates[].subagent definition
+ *   tasks[].wave                → tasks[].dependencies
+ *   tasks[].must_haves          → tasks[].acceptance_criteria
+ *   budget.max_tokens_per_task  → per-teammate token limits
+ *   intra-bus messages          → shared mailbox messages
+ *
+ * Fallback: if Agent Teams is not available (Claude Code < v2.1.32),
+ * returns { available: false } and caller falls back to legacy engine.
+ */
+
+const { execSync } = require('node:child_process');
+const fs = require('node:fs/promises');
+const path = require('node:path');
+
+const SQUADS_DIR = path.join('.aioson', 'squads');
+
+// ─── Availability detection ──────────────────────────────────────────────────
+
+/**
+ * Detect if Claude Code Agent Teams is available.
+ * Checks for claude binary and version >= 2.1.32.
+ */
+function detectAgentTeams() {
+  try {
+    const versionOutput = execSync('claude --version 2>/dev/null', {
+      encoding: 'utf8',
+      timeout: 5000
+    }).trim();
+
+    const match = versionOutput.match(/(\d+)\.(\d+)\.(\d+)/);
+    if (!match) return { available: false, reason: 'version_parse_error', raw: versionOutput };
+
+    const [, major, minor, patch] = match.map(Number);
+    const version = `${major}.${minor}.${patch}`;
+
+    // Agent Teams requires v2.1.32+
+    const meetsMinimum =
+      major > 2 ||
+      (major === 2 && minor > 1) ||
+      (major === 2 && minor === 1 && patch >= 32);
+
+    return {
+      available: meetsMinimum,
+      version,
+      reason: meetsMinimum ? 'ok' : 'version_too_old'
+    };
+  } catch {
+    return { available: false, reason: 'claude_not_found' };
+  }
+}
+
+// ─── Manifest to Team Config translation ─────────────────────────────────────
+
+/**
+ * Build a teammate definition from a squad executor.
+ */
+function executorToTeammate(executor, squadSlug, projectDir) {
+  const agentFile = executor.file
+    ? path.join(projectDir, executor.file)
+    : path.join(projectDir, SQUADS_DIR, squadSlug, 'agents', `${executor.slug}.md`);
+
+  const teammate = {
+    name: executor.slug,
+    role: executor.role || executor.title || executor.slug,
+    type: mapExecutorType(executor.type),
+    agentFile: agentFile
+  };
+
+  // Model tier mapping
+  if (executor.modelTier) {
+    const tierMap = {
+      powerful: 'opus',
+      balanced: 'sonnet',
+      fast: 'haiku',
+      none: null
+    };
+    teammate.model = tierMap[executor.modelTier] || 'sonnet';
+  }
+
+  // Skills
+  if (executor.skills && executor.skills.length > 0) {
+    teammate.skills = executor.skills;
+  }
+
+  return teammate;
+}
+
+/**
+ * Map AIOSON executor type to Agent Teams teammate type.
+ */
+function mapExecutorType(type) {
+  const typeMap = {
+    agent: 'subagent',
+    worker: 'worker',
+    clone: 'subagent',
+    assistant: 'subagent',
+    'human-gate': 'gate',
+    research: 'research',
+    reviewer: 'subagent',
+    skill: 'skill'
+  };
+  return typeMap[type] || 'subagent';
+}
+
+/**
+ * Convert a task decomposition plan to Agent Teams task list.
+ */
+function planToTeamTasks(plan, executors) {
+  const tasks = [];
+
+  for (const task of plan.tasks) {
+    const teamTask = {
+      id: task.id,
+      title: task.title,
+      description: task.description,
+      assignTo: task.executor || null,
+      dependencies: task.dependencies || [],
+      acceptance_criteria: task.acceptance_criteria || [],
+      priority: task.priority || 0,
+      metadata: {}
+    };
+
+    // Map must_haves to structured acceptance criteria
+    if (task.must_haves) {
+      if (task.must_haves.artifacts) {
+        teamTask.acceptance_criteria.push(
+          ...task.must_haves.artifacts.map((a) => `Artifact exists: ${a}`)
+        );
+      }
+      if (task.must_haves.key_links) {
+        teamTask.acceptance_criteria.push(
+          ...task.must_haves.key_links.map((l) => `Wired: ${l}`)
+        );
+      }
+    }
+
+    // read_first_hints become context for the teammate
+    if (task.read_first_hints && task.read_first_hints.length > 0) {
+      teamTask.metadata.read_first = task.read_first_hints;
+    }
+
+    tasks.push(teamTask);
+  }
+
+  return tasks;
+}
+
+/**
+ * Translate a full squad manifest + plan into an Agent Teams configuration.
+ *
+ * @param {string} projectDir
+ * @param {object} manifest  — squad.manifest.json contents
+ * @param {object} plan  — decomposed task plan
+ * @param {object} [options]  — { budget, enableBus }
+ * @returns {object}  — Agent Teams config
+ */
+function translateToTeamConfig(projectDir, manifest, plan, options = {}) {
+  const { budget = {} } = options;
+  const executors = manifest.executors || [];
+
+  // Build teammates
+  const teammates = executors.map((e) =>
+    executorToTeammate(e, manifest.slug, projectDir)
+  );
+
+  // Build tasks
+  const tasks = planToTeamTasks(plan, executors);
+
+  // Team configuration
+  const teamConfig = {
+    name: `squad-${manifest.slug}`,
+    description: manifest.mission || manifest.goal || `Squad: ${manifest.name}`,
+    teammates,
+    tasks,
+    settings: {
+      parallel: true,
+      maxConcurrent: teammates.length,
+      taskTimeout: budget.max_tokens_per_task ? Math.ceil(budget.max_tokens_per_task / 100) : 300,
+      quality: {
+        verifyOnComplete: true,
+        blockOnFail: true
+      }
+    }
+  };
+
+  // Budget constraints
+  if (budget.max_tokens_per_session) {
+    teamConfig.settings.tokenBudget = budget.max_tokens_per_session;
+  }
+  if (budget.max_tokens_per_task) {
+    teamConfig.settings.perTaskTokenLimit = budget.max_tokens_per_task;
+  }
+
+  // Anti-loop settings
+  if (manifest.anti_loop) {
+    teamConfig.settings.antiLoop = {
+      threshold: manifest.anti_loop.threshold || 8,
+      action: manifest.anti_loop.action || 'feedback'
+    };
+  }
+
+  return teamConfig;
+}
+
+/**
+ * Write Agent Teams config to a JSON file for claude --team usage.
+ */
+async function writeTeamConfig(projectDir, squadSlug, teamConfig) {
+  const configDir = path.join(projectDir, '.aioson', 'squads', squadSlug, 'team-config');
+  await fs.mkdir(configDir, { recursive: true });
+
+  const configPath = path.join(configDir, 'team.json');
+  await fs.writeFile(configPath, JSON.stringify(teamConfig, null, 2), 'utf8');
+
+  return configPath;
+}
+
+/**
+ * Resolve the execution engine for a squad:autorun run.
+ * Returns 'agent-teams' if requested and available, otherwise 'legacy'.
+ */
+function resolveEngine(requestedEngine) {
+  if (requestedEngine === 'legacy') return { engine: 'legacy', reason: 'explicit' };
+
+  if (requestedEngine === 'agent-teams') {
+    const detection = detectAgentTeams();
+    if (detection.available) {
+      return { engine: 'agent-teams', version: detection.version, reason: 'explicit' };
+    }
+    return { engine: 'legacy', reason: `agent-teams requested but ${detection.reason}`, fallback: true };
+  }
+
+  // Auto-detect
+  if (requestedEngine === 'auto') {
+    const detection = detectAgentTeams();
+    if (detection.available) {
+      return { engine: 'agent-teams', version: detection.version, reason: 'auto-detected' };
+    }
+    return { engine: 'legacy', reason: 'auto-fallback' };
+  }
+
+  return { engine: 'legacy', reason: 'default' };
+}
+
+module.exports = {
+  detectAgentTeams,
+  translateToTeamConfig,
+  writeTeamConfig,
+  resolveEngine,
+  executorToTeammate,
+  planToTeamTasks,
+  mapExecutorType
+};