@jaimevalasek/aioson 1.3.0 → 1.4.0

package/src/commands/squad-doctor.js

@@ -120,7 +120,7 @@ async function parseSquadPaths(targetDir, slug) {
       ? path.join(targetDir, normalizeRel(packageInfo.agentsDir || `.aioson/squads/${slug}/agents`))
       : path.join(targetDir, 'agents', slug),
     outputDir: path.join(targetDir, normalizeRel(rules.outputsDir || `output/${slug}`)),
-    logsDir: path.join(targetDir, normalizeRel(rules.logsDir || `aios-logs/${slug}`)),
+    logsDir: path.join(targetDir, normalizeRel(rules.logsDir || `aioson-logs/${slug}`)),
     mediaDir: path.join(targetDir, normalizeRel(rules.mediaDir || `media/${slug}`))
   };
 }
@@ -209,6 +209,56 @@ async function runSquadDoctor({ args, options = {}, logger, t }) {
   checks.push(makeCheck('output_dir', outputExists, outputExists ? 'info' : 'warn', t('squad_doctor.check_output_dir', { path: paths.outputDir })));
   checks.push(makeCheck('media_dir', mediaExists, mediaExists ? 'info' : 'warn', t('squad_doctor.check_media_dir', { path: paths.mediaDir })));
 
+  // Output strategy checks
+  const outputStrategy = manifest.outputStrategy && typeof manifest.outputStrategy === 'object'
+    ? manifest.outputStrategy
+    : null;
+
+  if (outputStrategy) {
+    const delivery = outputStrategy.delivery && typeof outputStrategy.delivery === 'object'
+      ? outputStrategy.delivery
+      : {};
+    const webhooks = Array.isArray(delivery.webhooks) ? delivery.webhooks : [];
+    const hasDelivery = webhooks.length > 0 || delivery.cloudPublish;
+
+    checks.push(makeCheck(
+      'output_strategy',
+      true,
+      'info',
+      `Output strategy: mode=${outputStrategy.mode || 'unknown'}, webhooks=${webhooks.length}, cloudPublish=${Boolean(delivery.cloudPublish)}, autoPublish=${Boolean(delivery.autoPublish)}`
+    ));
+
+    if (delivery.autoPublish && !hasDelivery) {
+      checks.push(makeCheck(
+        'output_auto_publish',
+        false,
+        'warn',
+        'autoPublish is enabled but no delivery targets configured (no webhooks, no cloudPublish)'
+      ));
+    }
+
+    for (const wh of webhooks) {
+      if (wh.url && wh.url.includes('{{ENV:')) {
+        const envMatch = wh.url.match(/\{\{ENV:(\w+)\}\}/);
+        if (envMatch && !process.env[envMatch[1]]) {
+          checks.push(makeCheck(
+            `webhook_env_${wh.slug}`,
+            false,
+            'warn',
+            `Webhook "${wh.slug}" references unset env var: ${envMatch[1]}`
+          ));
+        }
+      }
+    }
+  } else {
+    checks.push(makeCheck(
+      'output_strategy',
+      true,
+      'info',
+      'No output strategy configured (default file output will be used)'
+    ));
+  }
+
   const runtimeHandle = await openRuntimeDb(targetDir, { mustExist: true });
   if (!runtimeHandle) {
     checks.push(makeCheck('runtime_store', false, 'warn', t('squad_doctor.check_runtime_missing')));

package/src/commands/squad-investigate.js

@@ -0,0 +1,261 @@
+'use strict';
+
+const fs = require('node:fs/promises');
+const path = require('node:path');
+const {
+  openRuntimeDb,
+  insertInvestigation,
+  listInvestigations,
+  getInvestigation,
+  linkInvestigation
+} = require('../runtime-store');
+
+const SEARCHES_DIR = 'squad-searches';
+const DIMENSION_HEADERS = ['D1', 'D2', 'D3', 'D4', 'D5', 'D6', 'D7'];
+
+async function pathExists(targetPath) {
+  try {
+    await fs.access(targetPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Count how many of the 7 investigation dimensions are present in a report.
+ * Looks for headers like "## D1:", "## D2:", ..., "## D7:" in the markdown.
+ */
+function countDimensions(content) {
+  const text = String(content || '');
+  let count = 0;
+  for (const dim of DIMENSION_HEADERS) {
+    const pattern = new RegExp(`^##\\s+${dim}[:\\s]`, 'm');
+    if (pattern.test(text)) count++;
+  }
+  return count;
+}
+
+/**
+ * Calculate an investigation completeness score (0-1).
+ */
+function scoreCompleteness(content) {
+  const covered = countDimensions(content);
+  const total = DIMENSION_HEADERS.length;
+  return { covered, total, score: Math.round((covered / total) * 100) / 100 };
+}
+
+/**
+ * Subcommand: list
+ * Lists all investigations registered in the runtime SQLite.
+ */
+async function handleList(projectDir, { logger, t }) {
+  const handle = await openRuntimeDb(projectDir, { mustExist: true });
+  if (!handle) {
+    logger.error(t('squad_investigate.no_runtime'));
+    return { investigations: [], count: 0 };
+  }
+  const { db } = handle;
+  try {
+    const rows = listInvestigations(db);
+    if (rows.length === 0) {
+      logger.log(t('squad_investigate.no_investigations'));
+      return { investigations: [], count: 0 };
+    }
+    for (const row of rows) {
+      const linked = row.linked_squad_slug ? ` → ${row.linked_squad_slug}` : '';
+      const dims = `${row.dimensions_covered}/${row.total_dimensions}`;
+      logger.log(`  ${row.investigation_slug}  [${row.mode}]  ${row.domain}  ${dims}  conf=${row.confidence}${linked}`);
+    }
+    return { investigations: rows, count: rows.length };
+  } finally {
+    db.close();
+  }
+}
+
+/**
+ * Subcommand: show <slug>
+ * Shows the investigation report content.
+ */
+async function handleShow(projectDir, slug, { logger, t }) {
+  const handle = await openRuntimeDb(projectDir, { mustExist: true });
+  if (!handle) {
+    logger.error(t('squad_investigate.no_runtime'));
+    return { found: false };
+  }
+  const { db } = handle;
+  try {
+    const row = getInvestigation(db, slug);
+    if (!row) {
+      logger.error(t('squad_investigate.not_found', { slug }));
+      return { found: false };
+    }
+    logger.log(`Investigation: ${row.investigation_slug}`);
+    logger.log(`Domain: ${row.domain}`);
+    logger.log(`Mode: ${row.mode}`);
+    logger.log(`Dimensions: ${row.dimensions_covered}/${row.total_dimensions}`);
+    logger.log(`Confidence: ${row.confidence}`);
+    logger.log(`Report: ${row.report_path || '(none)'}`);
+    logger.log(`Linked squad: ${row.linked_squad_slug || '(standalone)'}`);
+    logger.log(`Created: ${row.created_at}`);
+
+    if (row.report_path) {
+      const reportFile = path.resolve(projectDir, row.report_path);
+      if (await pathExists(reportFile)) {
+        const content = await fs.readFile(reportFile, 'utf8');
+        logger.log('');
+        logger.log(content);
+      }
+    }
+    return { found: true, investigation: row };
+  } finally {
+    db.close();
+  }
+}
+
+/**
+ * Subcommand: score <slug>
+ * Calculates the completeness score for an investigation report.
+ */
+async function handleScore(projectDir, slug, { logger, t }) {
+  const handle = await openRuntimeDb(projectDir, { mustExist: true });
+  if (!handle) {
+    logger.error(t('squad_investigate.no_runtime'));
+    return { found: false, score: 0 };
+  }
+  const { db } = handle;
+  try {
+    const row = getInvestigation(db, slug);
+    if (!row) {
+      logger.error(t('squad_investigate.not_found', { slug }));
+      return { found: false, score: 0 };
+    }
+    if (!row.report_path) {
+      logger.error(t('squad_investigate.no_report', { slug }));
+      return { found: true, score: 0 };
+    }
+    const reportFile = path.resolve(projectDir, row.report_path);
+    if (!(await pathExists(reportFile))) {
+      logger.error(t('squad_investigate.report_missing', { path: row.report_path }));
+      return { found: true, score: 0 };
+    }
+    const content = await fs.readFile(reportFile, 'utf8');
+    const result = scoreCompleteness(content);
+    logger.log(`Completeness: ${result.covered}/${result.total} dimensions (${result.score})`);
+    return { found: true, ...result };
+  } finally {
+    db.close();
+  }
+}
+
+/**
+ * Subcommand: link <investigation-slug> <squad-slug>
+ * Associates an investigation with a squad.
+ */
+async function handleLink(projectDir, invSlug, squadSlug, { logger, t }) {
+  if (!invSlug || !squadSlug) {
+    logger.error(t('squad_investigate.link_usage'));
+    return { linked: false };
+  }
+  const handle = await openRuntimeDb(projectDir, { mustExist: true });
+  if (!handle) {
+    logger.error(t('squad_investigate.no_runtime'));
+    return { linked: false };
+  }
+  const { db } = handle;
+  try {
+    const success = linkInvestigation(db, invSlug, squadSlug);
+    if (success) {
+      logger.log(t('squad_investigate.linked', { investigation: invSlug, squad: squadSlug }));
+    } else {
+      logger.error(t('squad_investigate.not_found', { slug: invSlug }));
+    }
+    return { linked: success };
+  } finally {
+    db.close();
+  }
+}
+
+/**
+ * Subcommand: register
+ * Registers an existing investigation report file into the runtime SQLite.
+ */
+async function handleRegister(projectDir, reportPath, options, { logger, t }) {
+  const handle = await openRuntimeDb(projectDir, { mustExist: true });
+  if (!handle) {
+    logger.error(t('squad_investigate.no_runtime'));
+    return { registered: false };
+  }
+  const { db } = handle;
+  try {
+    const absPath = path.resolve(projectDir, reportPath);
+    if (!(await pathExists(absPath))) {
+      logger.error(t('squad_investigate.report_missing', { path: reportPath }));
+      return { registered: false };
+    }
+    const content = await fs.readFile(absPath, 'utf8');
+    const { covered, total, score } = scoreCompleteness(content);
+    const relPath = path.relative(projectDir, absPath);
+    const slug = insertInvestigation(db, {
+      investigationSlug: options.slug || undefined,
+      domain: options.domain || path.basename(reportPath, '.md'),
+      mode: options.mode || 'full',
+      dimensionsCovered: covered,
+      totalDimensions: total,
+      confidence: options.confidence ? Number(options.confidence) : score,
+      reportPath: relPath,
+      linkedSquadSlug: options.squad || null
+    });
+    logger.log(t('squad_investigate.registered', { slug, path: relPath }));
+    return { registered: true, slug };
+  } finally {
+    db.close();
+  }
+}
+
+async function runSquadInvestigate({ args = [], options = {}, logger = console, t = (k) => k } = {}) {
+  const projectDir = path.resolve(process.cwd(), args[0] || '.');
+  const sub = options.sub || args[1] || 'list';
+
+  if (sub === 'list') {
+    return handleList(projectDir, { logger, t });
+  }
+
+  if (sub === 'show') {
+    const slug = options.investigation || args[2];
+    if (!slug) {
+      logger.error(t('squad_investigate.show_usage'));
+      return { found: false };
+    }
+    return handleShow(projectDir, slug, { logger, t });
+  }
+
+  if (sub === 'score') {
+    const slug = options.investigation || args[2];
+    if (!slug) {
+      logger.error(t('squad_investigate.score_usage'));
+      return { found: false, score: 0 };
+    }
+    return handleScore(projectDir, slug, { logger, t });
+  }
+
+  if (sub === 'link') {
+    const invSlug = options.investigation || args[2];
+    const squadSlug = options.squad || args[3];
+    return handleLink(projectDir, invSlug, squadSlug, { logger, t });
+  }
+
+  if (sub === 'register') {
+    const reportPath = options.report || args[2];
+    if (!reportPath) {
+      logger.error(t('squad_investigate.register_usage'));
+      return { registered: false };
+    }
+    return handleRegister(projectDir, reportPath, options, { logger, t });
+  }
+
+  logger.error(t('squad_investigate.unknown_sub', { sub }));
+  return { error: `Unknown subcommand: ${sub}` };
+}
+
+module.exports = { runSquadInvestigate, scoreCompleteness, countDimensions };

package/src/commands/squad-learning.js

@@ -0,0 +1,209 @@
+'use strict';
+
+const path = require('node:path');
+const {
+  openRuntimeDb,
+  listSquadLearnings,
+  getSquadLearning,
+  updateSquadLearningStatus,
+  promoteSquadLearning,
+  archiveStaleSquadLearnings,
+  getSquadLearningStats
+} = require('../runtime-store');
+
+const SQUADS_DIR = path.join('.aioson', 'squads');
+
+/**
+ * Subcommand: list <slug> [--status=active|stale|archived|promoted]
+ * Lists learnings for a squad.
+ */
+async function handleList(projectDir, squadSlug, statusFilter, { logger, t }) {
+  if (!squadSlug) {
+    logger.error(t('squad_learning.slug_required'));
+    return { found: false };
+  }
+
+  const handle = await openRuntimeDb(projectDir, { mustExist: true });
+  if (!handle) {
+    logger.error(t('squad_learning.no_runtime'));
+    return { found: false };
+  }
+  const { db } = handle;
+  try {
+    const rows = listSquadLearnings(db, squadSlug, statusFilter || null);
+    if (rows.length === 0) {
+      logger.log(t('squad_learning.no_learnings', { slug: squadSlug }));
+      return { found: true, learnings: [] };
+    }
+
+    logger.log(`Learnings for squad: ${squadSlug} (${rows.length})`);
+    logger.log('');
+    for (const row of rows) {
+      const icon = row.status === 'active' ? '●' : row.status === 'promoted' ? '★' : row.status === 'stale' ? '○' : '▪';
+      logger.log(`  ${icon} [${row.type}] ${row.title} (freq: ${row.frequency}, ${row.confidence}) [${row.status}]`);
+      logger.log(`    id: ${row.learning_id}`);
+    }
+    return { found: true, learnings: rows };
+  } finally {
+    db.close();
+  }
+}
+
+/**
+ * Subcommand: stats <slug>
+ * Shows statistics for a squad's learnings.
+ */
+async function handleStats(projectDir, squadSlug, { logger, t }) {
+  if (!squadSlug) {
+    logger.error(t('squad_learning.slug_required'));
+    return { found: false };
+  }
+
+  const handle = await openRuntimeDb(projectDir, { mustExist: true });
+  if (!handle) {
+    logger.error(t('squad_learning.no_runtime'));
+    return { found: false };
+  }
+  const { db } = handle;
+  try {
+    const stats = getSquadLearningStats(db, squadSlug);
+    if (stats.length === 0) {
+      logger.log(t('squad_learning.no_learnings', { slug: squadSlug }));
+      return { found: true, stats: [] };
+    }
+
+    logger.log(`Learning stats for squad: ${squadSlug}`);
+    logger.log('');
+    let total = 0;
+    for (const row of stats) {
+      logger.log(`  ${row.type} / ${row.status}: ${row.count}`);
+      total += row.count;
+    }
+    logger.log('');
+    logger.log(`  Total: ${total}`);
+    return { found: true, stats, total };
+  } finally {
+    db.close();
+  }
+}
+
+/**
+ * Subcommand: archive <slug> [--days=90]
+ * Moves stale learnings to archived status.
+ */
+async function handleArchive(projectDir, squadSlug, days, { logger, t }) {
+  if (!squadSlug) {
+    logger.error(t('squad_learning.slug_required'));
+    return { archived: 0 };
+  }
+
+  const handle = await openRuntimeDb(projectDir, { mustExist: true });
+  if (!handle) {
+    logger.error(t('squad_learning.no_runtime'));
+    return { archived: 0 };
+  }
+  const { db } = handle;
+  try {
+    const count = archiveStaleSquadLearnings(db, squadSlug, days);
+    logger.log(t('squad_learning.archived_count', { count, slug: squadSlug }));
+    return { archived: count };
+  } finally {
+    db.close();
+  }
+}
+
+/**
+ * Subcommand: promote <slug> <learning-id> --to=<rule-path>
+ * Promotes a learning to a rule.
+ */
+async function handlePromote(projectDir, squadSlug, learningId, promotedTo, { logger, t }) {
+  if (!squadSlug || !learningId) {
+    logger.error(t('squad_learning.promote_usage'));
+    return { promoted: false };
+  }
+
+  const handle = await openRuntimeDb(projectDir, { mustExist: true });
+  if (!handle) {
+    logger.error(t('squad_learning.no_runtime'));
+    return { promoted: false };
+  }
+  const { db } = handle;
+  try {
+    const learning = getSquadLearning(db, learningId);
+    if (!learning || learning.squad_slug !== squadSlug) {
+      logger.error(t('squad_learning.not_found', { id: learningId }));
+      return { promoted: false };
+    }
+
+    const rulePath = promotedTo || path.join(SQUADS_DIR, squadSlug, 'rules', `${learning.type}-${Date.now()}.md`);
+    const updated = promoteSquadLearning(db, learningId, rulePath);
+    if (updated) {
+      logger.log(t('squad_learning.promoted', { id: learningId, path: rulePath }));
+    }
+    return { promoted: updated, rulePath };
+  } finally {
+    db.close();
+  }
+}
+
+/**
+ * Subcommand: export <slug>
+ * Exports learnings as JSON.
+ */
+async function handleExport(projectDir, squadSlug, { logger, t }) {
+  if (!squadSlug) {
+    logger.error(t('squad_learning.slug_required'));
+    return { exported: false };
+  }
+
+  const handle = await openRuntimeDb(projectDir, { mustExist: true });
+  if (!handle) {
+    logger.error(t('squad_learning.no_runtime'));
+    return { exported: false };
+  }
+  const { db } = handle;
+  try {
+    const rows = listSquadLearnings(db, squadSlug);
+    const output = {
+      squad: squadSlug,
+      exported_at: new Date().toISOString(),
+      learnings: rows
+    };
+    logger.log(JSON.stringify(output, null, 2));
+    return { exported: true, count: rows.length };
+  } finally {
+    db.close();
+  }
+}
+
+/**
+ * Entry point for CLI integration.
+ */
+async function runSquadLearning({ args = [], options = {}, logger = console, t = (k) => k } = {}) {
+  const projectDir = path.resolve(process.cwd(), args[0] || '.');
+  const sub = options.sub || args[1] || 'list';
+  const slug = options.squad || args[2] || null;
+  const context = { logger, t };
+
+  if (sub === 'list') {
+    return handleList(projectDir, slug, options.status || null, context);
+  }
+  if (sub === 'stats') {
+    return handleStats(projectDir, slug, context);
+  }
+  if (sub === 'archive') {
+    return handleArchive(projectDir, slug, options.days || 90, context);
+  }
+  if (sub === 'promote') {
+    const learningId = args[3] || options.id;
+    return handlePromote(projectDir, slug, learningId, options.to || null, context);
+  }
+  if (sub === 'export') {
+    return handleExport(projectDir, slug, context);
+  }
+
+  logger.error(`Unknown subcommand: ${sub}. Available: list, stats, archive, promote, export`);
+  return { error: true };
+}
+
+module.exports = { runSquadLearning, handleList, handleStats, handleArchive, handlePromote, handleExport };