@jaimevalasek/aioson 1.3.0 → 1.5.1

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

package/src/commands/squad-mcp.js

@@ -0,0 +1,270 @@
+'use strict';
+
+const path = require('node:path');
+const { openRuntimeDb, upsertMcpStatus, listMcpStatus, getMcpStatus } = require('../runtime-store');
+const {
+  listBuiltInConnectors,
+  getBuiltInConnector,
+  loadIntegrationConfig,
+  saveIntegrationConfig,
+  listIntegrations,
+  resolveConnectorEnv,
+  runHealthCheck,
+  runAction
+} = require('../mcp-connectors/registry');
+
+async function runSquadMcp({ args, options, logger, t }) {
+  const projectDir = path.resolve(args[0] || options.path || '.');
+  const squadSlug = options.squad;
+  const sub = options.sub || 'status';
+
+  if (!squadSlug) {
+    logger.log(t('squad_mcp.squad_required'));
+    return { ok: false, error: 'squad_required' };
+  }
+
+  if (sub === 'connectors') {
+    return handleConnectors({ logger, t });
+  }
+  if (sub === 'status') {
+    return handleStatus({ projectDir, squadSlug, logger, t });
+  }
+  if (sub === 'configure') {
+    return handleConfigure({ projectDir, squadSlug, options, logger, t });
+  }
+  if (sub === 'test') {
+    return handleTest({ projectDir, squadSlug, options, logger, t });
+  }
+  if (sub === 'call') {
+    return handleCall({ projectDir, squadSlug, options, logger, t });
+  }
+
+  logger.log(t('squad_mcp.unknown_sub', { sub }));
+  return { ok: false, error: 'unknown_sub' };
+}
+
+function handleConnectors({ logger, t }) {
+  const connectors = listBuiltInConnectors();
+  logger.log(t('squad_mcp.connectors_title'));
+  for (const c of connectors) {
+    logger.log(`  ${c.id} — ${c.name}`);
+    logger.log(`    ${t('squad_mcp.actions')}: ${c.actions.join(', ')}`);
+    logger.log(`    ${t('squad_mcp.required_config')}: ${c.requiredConfig.join(', ') || 'none'}`);
+    logger.log('');
+  }
+  return { ok: true, connectors };
+}
+
+async function handleStatus({ projectDir, squadSlug, logger, t }) {
+  const integrations = await listIntegrations(projectDir, squadSlug);
+
+  if (integrations.length === 0) {
+    logger.log(t('squad_mcp.no_integrations', { squad: squadSlug }));
+    return { ok: true, integrations: [] };
+  }
+
+  let handle;
+  try {
+    handle = await openRuntimeDb(projectDir);
+  } catch {
+    handle = null;
+  }
+
+  const results = [];
+  for (const integ of integrations) {
+    const connectorDef = getBuiltInConnector(integ.connector);
+    let status = 'unknown';
+    let missing = [];
+    if (connectorDef) {
+      const env = resolveConnectorEnv(connectorDef, integ.config);
+      status = env.status;
+      missing = env.missing;
+    }
+
+    let dbStatus = null;
+    if (handle) {
+      dbStatus = getMcpStatus(handle.db, squadSlug, integ.slug);
+    }
+
+    const entry = {
+      slug: integ.slug,
+      connector: integ.connector,
+      status: dbStatus ? dbStatus.status : status,
+      missing,
+      calls_total: dbStatus ? dbStatus.calls_total : 0,
+      calls_failed: dbStatus ? dbStatus.calls_failed : 0
+    };
+    results.push(entry);
+
+    const statusIcon = entry.status === 'connected' ? '+' : entry.status === 'configured' ? '~' : '-';
+    logger.log(`  [${statusIcon}] ${integ.slug} (${integ.connector}) — ${entry.status}`);
+    if (missing.length > 0) {
+      logger.log(`      ${t('squad_mcp.missing_config')}: ${missing.join(', ')}`);
+    }
+    if (entry.calls_total > 0) {
+      logger.log(`      ${t('squad_mcp.calls')}: ${entry.calls_total} (${entry.calls_failed} failed)`);
+    }
+  }
+
+  if (handle) handle.db.close();
+  return { ok: true, integrations: results };
+}
+
+async function handleConfigure({ projectDir, squadSlug, options, logger, t }) {
+  const mcpSlug = options.mcp;
+  const connector = options.connector;
+
+  if (!mcpSlug) {
+    logger.log(t('squad_mcp.mcp_required'));
+    return { ok: false, error: 'mcp_required' };
+  }
+  if (!connector) {
+    logger.log(t('squad_mcp.connector_required'));
+    return { ok: false, error: 'connector_required' };
+  }
+
+  const connectorDef = getBuiltInConnector(connector);
+  if (!connectorDef) {
+    logger.log(t('squad_mcp.unknown_connector', { connector }));
+    return { ok: false, error: 'unknown_connector' };
+  }
+
+  // Build config from --key=value options
+  const config = {};
+  for (const [key] of Object.entries(connectorDef.configSchema)) {
+    if (options[key] !== undefined) {
+      config[key] = options[key];
+    }
+  }
+
+  const integrationConfig = { connector, config };
+  await saveIntegrationConfig(projectDir, squadSlug, mcpSlug, integrationConfig);
+
+  // Check resolution
+  const { status, missing } = resolveConnectorEnv(connectorDef, config);
+
+  // Update SQLite status
+  try {
+    const handle = await openRuntimeDb(projectDir);
+    upsertMcpStatus(handle.db, { squadSlug, mcpSlug, connector, status, lastError: null });
+    handle.db.close();
+  } catch { /* SQLite optional */ }
+
+  logger.log(t('squad_mcp.configured', { mcp: mcpSlug, connector, status }));
+  if (missing.length > 0) {
+    logger.log(t('squad_mcp.still_missing', { keys: missing.join(', ') }));
+  }
+  return { ok: true, slug: mcpSlug, connector, status, missing };
+}
+
+async function handleTest({ projectDir, squadSlug, options, logger, t }) {
+  const mcpSlug = options.mcp;
+  if (!mcpSlug) {
+    logger.log(t('squad_mcp.mcp_required'));
+    return { ok: false, error: 'mcp_required' };
+  }
+
+  const config = await loadIntegrationConfig(projectDir, squadSlug, mcpSlug);
+  if (!config) {
+    logger.log(t('squad_mcp.not_configured', { mcp: mcpSlug }));
+    return { ok: false, error: 'not_configured' };
+  }
+
+  const connectorDef = getBuiltInConnector(config.connector);
+  if (!connectorDef) {
+    logger.log(t('squad_mcp.unknown_connector', { connector: config.connector }));
+    return { ok: false, error: 'unknown_connector' };
+  }
+
+  const { resolved, missing, status } = resolveConnectorEnv(connectorDef, config.config);
+
+  if (missing.length > 0) {
+    logger.log(t('squad_mcp.test_missing', { mcp: mcpSlug, keys: missing.join(', ') }));
+
+    try {
+      const handle = await openRuntimeDb(projectDir);
+      upsertMcpStatus(handle.db, { squadSlug, mcpSlug, connector: config.connector, status: 'unconfigured', lastError: `Missing: ${missing.join(', ')}` });
+      handle.db.close();
+    } catch { /* optional */ }
+
+    return { ok: false, error: 'missing_config', missing };
+  }
+
+  logger.log(t('squad_mcp.testing_connection'));
+  const health = await runHealthCheck(config.connector, resolved);
+
+  const healthStatus = health.ok ? 'connected' : 'error';
+  try {
+    const handle = await openRuntimeDb(projectDir);
+    upsertMcpStatus(handle.db, {
+      squadSlug, mcpSlug,
+      connector: config.connector,
+      status: healthStatus,
+      lastCheck: new Date().toISOString(),
+      lastError: health.ok ? null : (health.error || String(health.statusCode))
+    });
+    handle.db.close();
+  } catch { /* optional */ }
+
+  if (health.skipped) {
+    logger.log(t('squad_mcp.health_skipped'));
+    return { ok: true, slug: mcpSlug, status: 'skipped' };
+  }
+  if (health.ok) {
+    logger.log(t('squad_mcp.health_ok', { statusCode: health.statusCode }));
+    return { ok: true, slug: mcpSlug, status: 'connected', statusCode: health.statusCode };
+  }
+  logger.log(t('squad_mcp.health_error', { error: health.error || health.statusCode }));
+  return { ok: false, slug: mcpSlug, status: 'error', error: health.error };
+}
+
+async function handleCall({ projectDir, squadSlug, options, logger, t }) {
+  const mcpSlug = options.mcp;
+  const actionSlug = options.action;
+
+  if (!mcpSlug) {
+    logger.log(t('squad_mcp.mcp_required'));
+    return { ok: false, error: 'mcp_required' };
+  }
+  if (!actionSlug) {
+    logger.log(t('squad_mcp.action_required'));
+    return { ok: false, error: 'action_required' };
+  }
+
+  let input;
+  try {
+    input = JSON.parse(options.input || '{}');
+  } catch {
+    logger.log(t('squad_mcp.invalid_input'));
+    return { ok: false, error: 'invalid_input' };
+  }
+
+  const config = await loadIntegrationConfig(projectDir, squadSlug, mcpSlug);
+  if (!config) {
+    logger.log(t('squad_mcp.not_configured', { mcp: mcpSlug }));
+    return { ok: false, error: 'not_configured' };
+  }
+
+  const connectorDef = getBuiltInConnector(config.connector);
+  if (!connectorDef) {
+    logger.log(t('squad_mcp.unknown_connector', { connector: config.connector }));
+    return { ok: false, error: 'unknown_connector' };
+  }
+
+  const { resolved, missing } = resolveConnectorEnv(connectorDef, config.config);
+  if (missing.length > 0) {
+    logger.log(t('squad_mcp.test_missing', { mcp: mcpSlug, keys: missing.join(', ') }));
+    return { ok: false, error: 'missing_config', missing };
+  }
+
+  const result = await runAction(config.connector, actionSlug, input, resolved);
+
+  if (result.ok) {
+    logger.log(JSON.stringify(result.result, null, 2));
+  } else {
+    logger.log(`Error: ${result.error}`);
+  }
+  return result;
+}
+
+module.exports = { runSquadMcp };