@jaimevalasek/aioson 1.6.0 → 1.7.0

package/src/commands/squad-review.js

@@ -0,0 +1,106 @@
+'use strict';
+
+/**
+ * aioson squad:review [projectDir] --squad=<slug> --output=<file>
+ *                    [--criteria=<text,...>] [--synthesize-to=<path>]
+ *                    [--include-current] [--timeout=<seconds>]
+ *
+ * Cross-AI adversarial review of a squad output.
+ *
+ * Detects available AI CLIs (excluding the current runtime), sends the same
+ * review prompt to each, and synthesizes results into REVIEWS.md.
+ *
+ * Usage:
+ *   aioson squad:review . --squad=content-team --output=outputs/ep3.md
+ *   aioson squad:review . --squad=content-team --output=outputs/ep3.md \
+ *     --criteria="Check factual accuracy,Check tone consistency"
+ *   aioson squad:review . --squad=content-team --output=outputs/ep3.md \
+ *     --synthesize-to=outputs/ep3-reviews.md
+ */
+
+const path = require('node:path');
+const { runCrossAIReview, detectAvailableCLIs } = require('../squad/cross-ai-synthesizer');
+
+async function runSquadReview({ args, options = {}, logger }) {
+  const projectDir = path.resolve(process.cwd(), args[0] || '.');
+  const squadSlug = String(options.squad || '').trim();
+  const outputFile = String(options.output || '').trim();
+
+  if (!squadSlug) {
+    logger.error('Error: --squad is required');
+    return { ok: false, error: 'missing_squad' };
+  }
+
+  if (!outputFile) {
+    logger.error('Error: --output <file-to-review> is required');
+    return { ok: false, error: 'missing_output' };
+  }
+
+  const outputPath = path.isAbsolute(outputFile)
+    ? outputFile
+    : path.join(projectDir, outputFile);
+
+  // Parse criteria
+  const rawCriteria = String(options.criteria || '').trim();
+  const reviewCriteria = rawCriteria
+    ? rawCriteria.split(',').map((c) => c.trim()).filter(Boolean)
+    : [];
+
+  const excludeCurrent = options['include-current'] !== true && options['include-current'] !== 'true';
+  const timeoutMs = (Number(options.timeout || 60)) * 1000;
+
+  const synthesizeTo = options['synthesize-to']
+    ? path.resolve(projectDir, String(options['synthesize-to']))
+    : null;
+
+  // Show what CLIs will be queried
+  const clis = detectAvailableCLIs({ excludeCurrent });
+  if (clis.length === 0) {
+    logger.error('No AI CLIs detected. Install claude, gemini, or codex in PATH.');
+    logger.log('You can override with --include-current to include the current runtime.');
+    return { ok: false, error: 'no_clis_detected' };
+  }
+
+  logger.log(`Squad Review — ${squadSlug}`);
+  logger.log(`Output file: ${path.relative(projectDir, outputPath)}`);
+  logger.log(`Reviewers:   ${clis.join(', ')}`);
+  if (reviewCriteria.length > 0) {
+    logger.log(`Criteria:    ${reviewCriteria.join('; ')}`);
+  }
+  logger.log('');
+  logger.log('Querying reviewers...');
+
+  const result = await runCrossAIReview({
+    projectDir,
+    outputFile: outputPath,
+    reviewCriteria,
+    squadSlug,
+    excludeCurrent,
+    synthesizeTo,
+    timeoutMs
+  });
+
+  if (!result.ok) {
+    logger.error(`✗ Review failed: ${result.error}`);
+    return result;
+  }
+
+  logger.log('');
+  logger.log(`✓ Reviews complete`);
+  logger.log(`  Reviewers: ${result.reviewers.join(', ')}`);
+  logger.log(`  Successful: ${result.successCount}/${result.reviewers.length}`);
+  logger.log(`  Written to: ${path.relative(projectDir, result.reviewsPath)}`);
+
+  if (result.failCount > 0) {
+    const failed = result.reviews.filter((r) => !r.ok);
+    logger.log('');
+    logger.log(`  ⚠ Failed reviewers:`);
+    for (const f of failed) {
+      logger.log(`    ${f.cli}: ${f.error}`);
+    }
+  }
+
+  return result;
+}
+
+module.exports = { runSquadReview };

package/src/commands/squad-scaffold.js

@@ -0,0 +1,55 @@
+'use strict';
+
+/**
+ * aioson squad:scaffold — Deterministic squad directory generator
+ *
+ * Usage:
+ *   aioson squad:scaffold . --slug=content-team --name="Content Team" --mode=content
+ *   aioson squad:scaffold . --slug=dev-core --name="Dev Core" --mode=code
+ *   aioson squad:scaffold . --slug=research --name="Research Hub" --mode=hybrid
+ *   aioson squad:scaffold . --slug=test --json
+ */
+
+const path = require('node:path');
+const { scaffoldSquad } = require('../squad/squad-scaffold');
+
+async function runSquadScaffold({ args, options = {}, logger }) {
+  const targetDir = path.resolve(process.cwd(), args[0] || '.');
+  const slug = String(options.slug || '').trim();
+  const name = String(options.name || slug || '').trim();
+  const mode = String(options.mode || 'hybrid').trim();
+
+  if (!slug) {
+    logger.error('Error: --slug is required');
+    return { ok: false, error: 'missing_slug' };
+  }
+
+  const result = await scaffoldSquad(targetDir, { slug, name, mode });
+
+  if (!result.ok) {
+    logger.error(`Error: ${result.error}`);
+    return result;
+  }
+
+  if (options.json) return result;
+
+  logger.log(`Squad "${result.name}" scaffolded (mode: ${result.mode})`);
+  logger.log('');
+  logger.log('Files created:');
+  for (const f of result.files) {
+    logger.log(`  ✓ ${f}`);
+  }
+  if (result.directories.length > 0) {
+    logger.log('');
+    logger.log('Directories created:');
+    for (const d of result.directories) {
+      logger.log(`  ✓ ${d}/`);
+    }
+  }
+  logger.log('');
+  logger.log(`Total: ${result.total} items`);
+
+  return result;
+}
+
+module.exports = { runSquadScaffold };

package/src/commands/squad-tool-register.js

@@ -0,0 +1,157 @@
+'use strict';
+
+/**
+ * aioson squad:tool:register [projectDir] --squad=<slug> --name=<tool-name>
+ *                            --description=<desc> --handler=<shell-command>
+ *                            [--handler-type=shell|script] [--handler-path=<path>]
+ *                            [--input-schema=<json>] [--registered-by=<executor-slug>]
+ *
+ * Register a dynamic tool for a squad at runtime.
+ * Tools registered here are available to executors in subsequent squad:autorun sessions.
+ *
+ * Security: handler only receives AIOSON_TOOL_INPUT env var — no API keys, no PATH injection.
+ *
+ * Usage:
+ *   aioson squad:tool:register . --squad=content-team --name=fetch-rss \
+ *     --description="Fetch RSS feed and return items" \
+ *     --handler='curl -s "$AIOSON_TOOL_INPUT" | python3 -c "import sys,xml.etree.ElementTree as ET; ..."'
+ *
+ *   aioson squad:tool:register . --squad=content-team --list
+ *   aioson squad:tool:register . --squad=content-team --name=fetch-rss --delete
+ */
+
+const path = require('node:path');
+const { openRuntimeDb } = require('../runtime-store');
+
+function nowIso() { return new Date().toISOString(); }
+
+async function handleList(db, squadSlug, logger) {
+  const tools = db.prepare(
+    'SELECT * FROM dynamic_squad_tools WHERE squad_slug = ? ORDER BY registered_at DESC'
+  ).all(squadSlug);
+
+  if (tools.length === 0) {
+    logger.log(`No dynamic tools registered for squad "${squadSlug}"`);
+    logger.log('Register one with: aioson squad:tool:register . --squad=' + squadSlug + ' --name=<name> --description=<desc> --handler=<cmd>');
+    return { ok: true, tools: [] };
+  }
+
+  logger.log(`Dynamic tools for "${squadSlug}" (${tools.length}):`);
+  for (const t of tools) {
+    logger.log(`  • ${t.name} [${t.handler_type}]${t.registered_by ? ' by ' + t.registered_by : ''}`);
+    logger.log(`    ${t.description}`);
+    if (t.handler_code) logger.log(`    Handler: ${t.handler_code.slice(0, 80)}${t.handler_code.length > 80 ? '...' : ''}`);
+    if (t.handler_path) logger.log(`    Script: ${t.handler_path}`);
+  }
+
+  return { ok: true, tools };
+}
+
+async function handleDelete(db, squadSlug, toolName, logger) {
+  const existing = db.prepare(
+    'SELECT name FROM dynamic_squad_tools WHERE name = ? AND squad_slug = ?'
+  ).get(toolName, squadSlug);
+
+  if (!existing) {
+    logger.error(`Tool "${toolName}" not found for squad "${squadSlug}"`);
+    return { ok: false, error: 'tool_not_found' };
+  }
+
+  db.prepare('DELETE FROM dynamic_squad_tools WHERE name = ? AND squad_slug = ?').run(toolName, squadSlug);
+  logger.log(`Deleted tool "${toolName}" from squad "${squadSlug}"`);
+  return { ok: true, deleted: toolName };
+}
+
+async function runSquadToolRegister({ args, options = {}, logger }) {
+  const projectDir = path.resolve(process.cwd(), args[0] || '.');
+  const squadSlug = String(options.squad || '').trim();
+
+  if (!squadSlug) {
+    logger.error('Error: --squad is required');
+    return { ok: false, error: 'missing_squad' };
+  }
+
+  const handle = await openRuntimeDb(projectDir);
+  if (!handle) {
+    logger.error('Runtime database unavailable. Run: aioson runtime:init .');
+    return { ok: false, error: 'no_db' };
+  }
+  const { db } = handle;
+
+  try {
+    // List mode
+    if (options.list) {
+      return handleList(db, squadSlug, logger);
+    }
+
+    const toolName = String(options.name || '').trim();
+    if (!toolName) {
+      logger.error('Error: --name is required');
+      return { ok: false, error: 'missing_name' };
+    }
+
+    // Delete mode
+    if (options.delete) {
+      return handleDelete(db, squadSlug, toolName, logger);
+    }
+
+    // Register mode
+    const description = String(options.description || options.desc || '').trim();
+    if (!description) {
+      logger.error('Error: --description is required');
+      return { ok: false, error: 'missing_description' };
+    }
+
+    const handlerType = String(options['handler-type'] || options.handlerType || 'shell').trim();
+    const handlerCode = String(options.handler || options['handler-code'] || '').trim() || null;
+    const handlerPath = String(options['handler-path'] || options.handlerPath || '').trim() || null;
+
+    if (!handlerCode && !handlerPath) {
+      logger.error('Error: --handler (shell command) or --handler-path (script path) is required');
+      return { ok: false, error: 'missing_handler' };
+    }
+
+    let inputSchema = '{}';
+    if (options['input-schema'] || options.inputSchema) {
+      try {
+        const raw = String(options['input-schema'] || options.inputSchema);
+        JSON.parse(raw); // validate
+        inputSchema = raw;
+      } catch {
+        logger.error('Error: --input-schema must be valid JSON');
+        return { ok: false, error: 'invalid_input_schema' };
+      }
+    }
+
+    const registeredBy = String(options['registered-by'] || options.registeredBy || '').trim() || null;
+
+    db.prepare(`
+      INSERT INTO dynamic_squad_tools
+        (name, squad_slug, description, input_schema, handler_type, handler_code, handler_path, registered_at, registered_by)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(name, squad_slug) DO UPDATE SET
+        description = excluded.description,
+        input_schema = excluded.input_schema,
+        handler_type = excluded.handler_type,
+        handler_code = excluded.handler_code,
+        handler_path = excluded.handler_path,
+        registered_at = excluded.registered_at,
+        registered_by = excluded.registered_by
+    `).run(toolName, squadSlug, description, inputSchema, handlerType, handlerCode, handlerPath, nowIso(), registeredBy);
+
+    logger.log(`✓ Tool "${toolName}" registered for squad "${squadSlug}"`);
+    logger.log(`  Type: ${handlerType}`);
+    logger.log(`  Description: ${description}`);
+    if (handlerCode) logger.log(`  Handler: ${handlerCode.slice(0, 80)}${handlerCode.length > 80 ? '...' : ''}`);
+    if (handlerPath) logger.log(`  Script: ${handlerPath}`);
+    logger.log('');
+    logger.log('Executors can request this tool via the bus (type: tool_request):');
+    logger.log(`  { "type": "tool_request", "content": "run:${toolName}", "metadata": { "input": "..." } }`);
+
+    return { ok: true, tool: { name: toolName, squad: squadSlug, handlerType, description } };
+  } finally {
+    db.close();
+  }
+}
+
+module.exports = { runSquadToolRegister };

package/src/commands/state-save.js

@@ -0,0 +1,122 @@
+'use strict';
+
+/**
+ * aioson state:save — create/update dev-state.md for @dev session resumption.
+ *
+ * Replaces the manual dev-state.md update block. Stores active feature,
+ * phase, next step, spec version, and context package.
+ *
+ * Usage:
+ *   aioson state:save . --feature=checkout --phase=3 --next="Implement notification listeners" \
+ *     --spec-version=3 --status=in_progress
+ *   aioson state:save . --feature=checkout --next="Continue payment webhook" --status=in_progress
+ */
+
+const fs = require('node:fs/promises');
+const path = require('node:path');
+const { contextDir, readFileSafe, parseFrontmatter, scanArtifacts } = require('../preflight-engine');
+
+function nowDate() {
+  return new Date().toISOString().slice(0, 10);
+}
+
+async function runStateSave({ args, options = {}, logger }) {
+  const targetDir = path.resolve(process.cwd(), args[0] || '.');
+  const slug = options.feature ? String(options.feature) : null;
+  const phase = options.phase ? String(options.phase) : null;
+  const next = options.next ? String(options.next) : null;
+  const specVersion = options['spec-version'] ? String(options['spec-version']) : null;
+  const status = options.status ? String(options.status) : 'in_progress';
+  const plan = options.plan ? String(options.plan) : null;
+
+  if (!slug) {
+    if (options.json) return { ok: false, reason: 'missing_feature' };
+    logger.log('--feature=<slug> is required.');
+    return { ok: false };
+  }
+
+  if (!next) {
+    if (options.json) return { ok: false, reason: 'missing_next' };
+    logger.log('--next="<next step>" is required.');
+    return { ok: false };
+  }
+
+  // Build context package based on what exists
+  const artifacts = await scanArtifacts(targetDir, slug);
+  const contextPackage = [];
+  if (artifacts.project_context.exists) contextPackage.push('project.context.md');
+  if (artifacts.spec.exists) contextPackage.push(`spec-${slug}.md`);
+  if (plan) contextPackage.push(plan);
+  else if (artifacts.implementation_plan.exists) contextPackage.push(`implementation-plan-${slug}.md`);
+
+  const today = nowDate();
+  const statePath = path.join(contextDir(targetDir), 'dev-state.md');
+
+  const existingContent = await readFileSafe(statePath);
+  const existingFm = existingContent ? parseFrontmatter(existingContent) : {};
+
+  // Build history entry
+  const historyLine = `- ${today}: phase ${phase || existingFm.active_phase || '?'} — ${next}`;
+  const existingHistory = [];
+  if (existingContent) {
+    const historyMatch = existingContent.match(/## History\n([\s\S]*?)(?=\n##|\s*$)/);
+    if (historyMatch) {
+      const lines = historyMatch[1].split('\n').filter((l) => l.trim().startsWith('-'));
+      existingHistory.push(...lines.slice(-4)); // keep last 4 + new = 5 total
+    }
+  }
+  const history = [...existingHistory, historyLine];
+
+  const lines = [
+    '---',
+    `last_updated: ${today}`,
+    `active_feature: ${slug}`,
+    phase ? `active_phase: ${phase}` : (existingFm.active_phase ? `active_phase: ${existingFm.active_phase}` : null),
+    `next_step: "${next}"`,
+    specVersion ? `last_spec_version: ${specVersion}` : (existingFm.last_spec_version ? `last_spec_version: ${existingFm.last_spec_version}` : null),
+    `status: ${status}`,
+    '---',
+    '',
+    '# Dev State',
+    '',
+    `**Feature:** ${slug}`,
+    phase ? `**Phase:** ${phase}` : null,
+    `**Status:** ${status}`,
+    `**Next step:** ${next}`,
+    '',
+    '## Context package',
+    '',
+    ...contextPackage.map((f, i) => `${i + 1}. ${f}`),
+    '',
+    '## History',
+    '',
+    ...history,
+    ''
+  ].filter((l) => l !== null);
+
+  await fs.mkdir(path.dirname(statePath), { recursive: true });
+  await fs.writeFile(statePath, lines.join('\n'), 'utf8');
+
+  const result = {
+    ok: true,
+    path: path.relative(targetDir, statePath),
+    active_feature: slug,
+    active_phase: phase,
+    next_step: next,
+    last_spec_version: specVersion,
+    context_package: contextPackage
+  };
+
+  if (options.json) return result;
+
+  logger.log('dev-state.md updated:');
+  logger.log(`  active_feature: ${slug}`);
+  if (phase) logger.log(`  active_phase: ${phase}`);
+  logger.log(`  next_step: "${next}"`);
+  if (specVersion) logger.log(`  last_spec_version: ${specVersion}`);
+  logger.log(`  context_package: [${contextPackage.join(', ')}]`);
+
+  return result;
+}
+
+module.exports = { runStateSave };

package/src/commands/update.js

@@ -9,11 +9,13 @@ const { applyAgentLocale } = require('../locales');
 async function runUpdate({ args, options, logger, t }) {
   const targetDir = path.resolve(process.cwd(), args[0] || '.');
   const dryRun = Boolean(options['dry-run']);
+  const all = Boolean(options.all);
   const requestedLanguage = options.lang || options.language;
 
   const detection = await detectFramework(targetDir);
   const result = await updateInstallation(targetDir, {
     dryRun,
+    all,
     frameworkDetection: detection.framework
   });