@jaimevalasek/aioson 1.4.0 → 1.6.0

package/src/cli.js

@@ -5,6 +5,7 @@ const { parseArgv } = require('./parser');
 const { createTranslator, normalizeLocale } = require('./i18n');
 const { runInit } = require('./commands/init');
 const { runInstall } = require('./commands/install');
+const { runSetup } = require('./commands/setup');
 const { runUpdate } = require('./commands/update');
 const { runInfo } = require('./commands/info');
 const { runDoctorCommand } = require('./commands/doctor');
@@ -32,6 +33,8 @@ const { runQaInit } = require('./commands/qa-init');
 const { runQaRun } = require('./commands/qa-run');
 const { runQaScan } = require('./commands/qa-scan');
 const { runQaReport } = require('./commands/qa-report');
+const { runWebMap } = require('./commands/web-map');
+const { runWebScrape } = require('./commands/web-scrape');
 const { runScanProject } = require('./commands/scan-project');
 const { runConfig } = require('./commands/config');
 const { runGenomeDoctor } = require('./commands/genome-doctor');
@@ -48,6 +51,17 @@ const { runImplementationPlan } = require('./commands/implementation-plan');
 const { runSquadPlan } = require('./commands/squad-plan');
 const { runSquadLearning } = require('./commands/squad-learning');
 const { runLearning } = require('./commands/learning');
+const { runSquadDashboard } = require('./commands/squad-dashboard');
+const { runSquadWorker } = require('./commands/squad-worker');
+const { runSquadDaemon } = require('./commands/squad-daemon');
+const { runSquadMcp } = require('./commands/squad-mcp');
+const { runSquadRoi } = require('./commands/squad-roi');
+const { runSquadScore } = require('./commands/squad-score');
+const { runSquadProcesses } = require('./commands/squad-processes');
+const { runSquadWorktrees, runSquadMerge } = require('./commands/squad-worktrees');
+const { runSquadRecovery } = require('./commands/squad-recovery');
+const { runSquadDeploy } = require('./commands/squad-deploy');
+const { runSquadWebhook } = require('./commands/squad-webhook');
 const {
   runRuntimeInit,
   runRuntimeIngest,
@@ -60,6 +74,8 @@ const {
   runRuntimeFail,
   runRuntimeStatus,
   runRuntimeLog,
+  runAgentDone,
+  runAgentRecover,
   runRuntimeSessionStart,
   runRuntimeSessionLog,
   runRuntimeSessionFinish,
@@ -93,10 +109,22 @@ const {
   runSkillList,
   runSkillRemove
 } = require('./commands/skill');
+const { runDesignHybridOptions } = require('./commands/design-hybrid-options');
+const { runBackupLocal } = require('./commands/backup-local-cmd');
+const { runRecoveryGenerate, runRecoveryShow } = require('./commands/recovery');
+const { runContextMonitor } = require('./commands/context-monitor');
+const { runContextSearch, runContextSearchIndex } = require('./commands/context-search');
+const { runContextCacheList, runContextCacheSave, runContextCacheRestore, runContextCacheCleanup } = require('./commands/context-cache');
+const { runSandboxExec } = require('./commands/sandbox');
+const { runAgentLoad, runAgentShardIndex } = require('./commands/agent-loader');
+const { runLearningEvolve, runLearningApply } = require('./commands/learning-evolve');
+const { runToolRegistry } = require('./commands/tool-registry-cmd');
+const { runHealth } = require('./commands/health');
 
 const JSON_SUPPORTED_COMMANDS = new Set([
   'init',
   'install',
+  'setup',
   'update',
   'i18n:add',
   'i18n-add',
@@ -159,6 +187,10 @@ const JSON_SUPPORTED_COMMANDS = new Set([
   'qa-scan',
   'qa:report',
   'qa-report',
+  'web:map',
+  'web-map',
+  'web:scrape',
+  'web-scrape',
   'scan:project',
   'scan-project',
   'config',
@@ -182,6 +214,31 @@ const JSON_SUPPORTED_COMMANDS = new Set([
   'squad-agent-create',
   'squad:investigate',
   'squad-investigate',
+  'squad:dashboard',
+  'squad-dashboard',
+  'squad:worker',
+  'squad-worker',
+  'squad:daemon',
+  'squad-daemon',
+  'squad:mcp',
+  'squad-mcp',
+  'squad:mcp:call',
+  'squad:roi',
+  'squad-roi',
+  'squad:score',
+  'squad-score',
+  'squad:processes',
+  'squad-processes',
+  'squad:worktrees',
+  'squad-worktrees',
+  'squad:merge',
+  'squad-merge',
+  'squad:recovery',
+  'squad-recovery',
+  'squad:deploy',
+  'squad-deploy',
+  'squad:webhook',
+  'squad-webhook',
   'plan:show',
   'plan:status',
   'plan:checkpoint',
@@ -196,6 +253,21 @@ const JSON_SUPPORTED_COMMANDS = new Set([
   'learning:list',
   'learning:stats',
   'learning:promote',
+  'learning:evolve',
+  'learning-evolve',
+  'learning:apply',
+  'learning-apply',
+  'tool:register',
+  'tool-register',
+  'tool:list',
+  'tool-list',
+  'tool:call',
+  'tool-call',
+  'tool:unregister',
+  'tool-unregister',
+  'tool:show',
+  'tool-show',
+  'health',
   'runtime:init',
   'runtime-init',
   'runtime:ingest',
@@ -218,6 +290,10 @@ const JSON_SUPPORTED_COMMANDS = new Set([
   'runtime-status',
   'runtime:log',
   'runtime-log',
+  'agent:done',
+  'agent-done',
+  'agent:recover',
+  'agent-recover',
   'runtime:session:start',
   'runtime-session-start',
   'runtime:session:log',
@@ -259,6 +335,32 @@ const JSON_SUPPORTED_COMMANDS = new Set([
   'skill-list',
   'skill:remove',
   'skill-remove',
+  'design-hybrid:options',
+  'design-hybrid-options',
+  'recovery:generate',
+  'recovery-generate',
+  'recovery:show',
+  'recovery-show',
+  'context:monitor',
+  'context-monitor',
+  'context:search',
+  'context-search',
+  'context:search:index',
+  'context-search-index',
+  'context:cache',
+  'context-cache',
+  'context:cache:save',
+  'context-cache-save',
+  'context:cache:restore',
+  'context-cache-restore',
+  'context:cache:cleanup',
+  'context-cache-cleanup',
+  'sandbox:exec',
+  'sandbox-exec',
+  'agent:load',
+  'agent-load',
+  'agent:shard:index',
+  'agent-shard-index',
   'version',
   '--version',
   '-v'
@@ -305,6 +407,7 @@ function printHelp(t, logger) {
   logger.log(t('cli.usage'));
   logHelpLine(t, logger, 'cli.help_init');
   logHelpLine(t, logger, 'cli.help_install');
+  logHelpLine(t, logger, 'cli.help_setup');
   logHelpLine(t, logger, 'cli.help_update');
   logHelpLine(t, logger, 'cli.help_info');
   logHelpLine(t, logger, 'cli.help_doctor');
@@ -333,6 +436,8 @@ function printHelp(t, logger) {
   logHelpLine(t, logger, 'cli.help_qa_run');
   logHelpLine(t, logger, 'cli.help_qa_scan');
   logHelpLine(t, logger, 'cli.help_qa_report');
+  logHelpLine(t, logger, 'cli.help_web_map');
+  logHelpLine(t, logger, 'cli.help_web_scrape');
   logHelpLine(t, logger, 'cli.help_scan_project');
   logHelpLine(t, logger, 'cli.help_config');
   logHelpLine(t, logger, 'cli.help_genome_doctor');
@@ -345,6 +450,12 @@ function printHelp(t, logger) {
   logHelpLine(t, logger, 'cli.help_squad_pipeline');
   logHelpLine(t, logger, 'cli.help_squad_agent_create');
   logHelpLine(t, logger, 'cli.help_squad_investigate');
+  logHelpLine(t, logger, 'cli.help_squad_dashboard');
+  logHelpLine(t, logger, 'cli.help_squad_worker');
+  logHelpLine(t, logger, 'cli.help_squad_daemon');
+  logHelpLine(t, logger, 'cli.help_squad_mcp');
+  logHelpLine(t, logger, 'cli.help_squad_roi');
+  logHelpLine(t, logger, 'cli.help_squad_score');
   logHelpLine(t, logger, 'cli.help_squad_learning');
   logHelpLine(t, logger, 'cli.help_learning');
   logHelpLine(t, logger, 'cli.help_runtime_init');
@@ -371,6 +482,7 @@ function printHelp(t, logger) {
   logHelpLine(t, logger, 'cli.help_skill_install');
   logHelpLine(t, logger, 'cli.help_skill_list');
   logHelpLine(t, logger, 'cli.help_skill_remove');
+  logHelpLine(t, logger, 'cli.help_design_hybrid_options');
   logHelpLine(t, logger, 'cli.help_cloud_import_squad');
   logHelpLine(t, logger, 'cli.help_cloud_import_genome');
   logHelpLine(t, logger, 'cli.help_cloud_publish_squad');
@@ -434,6 +546,10 @@ async function main() {
       result = await runInit({ args, options, logger: commandLogger, t });
     } else if (command === 'install') {
       result = await runInstall({ args, options, logger: commandLogger, t });
+    } else if (command === 'setup') {
+      result = await runSetup({ args, options, logger: commandLogger, t });
+    } else if (command === 'install') {
+      result = await runInstall({ args, options, logger: commandLogger, t });
     } else if (command === 'update') {
       result = await runUpdate({ args, options, logger: commandLogger, t });
     } else if (command === 'info') {
@@ -523,6 +639,10 @@ async function main() {
       result = await runQaScan({ args, options, logger: commandLogger, t });
     } else if (command === 'qa:report' || command === 'qa-report') {
       result = await runQaReport({ args, options, logger: commandLogger, t });
+    } else if (command === 'web:map' || command === 'web-map') {
+      result = await runWebMap({ args, options, logger: commandLogger, t });
+    } else if (command === 'web:scrape' || command === 'web-scrape') {
+      result = await runWebScrape({ args, options, logger: commandLogger, t });
     } else if (command === 'scan:project' || command === 'scan-project') {
       result = await runScanProject({ args, options, logger: commandLogger, t });
     } else if (command === 'config') {
@@ -547,11 +667,46 @@ async function main() {
       result = await runSquadAgentCreate({ args, options, logger: commandLogger, t });
     } else if (command === 'squad:investigate' || command === 'squad-investigate') {
       result = await runSquadInvestigate({ args, options, logger: commandLogger, t });
+    } else if (command === 'squad:dashboard' || command === 'squad-dashboard') {
+      result = await runSquadDashboard({ args, options, logger: commandLogger, t });
+    } else if (command === 'squad:worker' || command === 'squad-worker') {
+      const sub = options.sub || 'list';
+      result = await runSquadWorker({ args, options: { ...options, sub }, logger: commandLogger, t });
+    } else if (command === 'squad:daemon' || command === 'squad-daemon') {
+      const sub = options.sub || 'status';
+      result = await runSquadDaemon({ args, options: { ...options, sub }, logger: commandLogger, t });
+    } else if (command === 'squad:mcp:call') {
+      result = await runSquadMcp({ args, options: { ...options, sub: 'call' }, logger: commandLogger, t });
+    } else if (command === 'squad:mcp' || command === 'squad-mcp') {
+      const sub = options.sub || 'status';
+      result = await runSquadMcp({ args, options: { ...options, sub }, logger: commandLogger, t });
+    } else if (command === 'squad:roi' || command === 'squad-roi') {
+      const sub = options.sub || 'report';
+      result = await runSquadRoi({ args, options: { ...options, sub }, logger: commandLogger, t });
+    } else if (command === 'squad:score' || command === 'squad-score') {
+      result = await runSquadScore({ args, options, logger: commandLogger, translator: t });
+    } else if (command === 'squad:processes' || command === 'squad-processes') {
+      result = await runSquadProcesses({ args, options, logger: commandLogger, t });
+    } else if (command === 'squad:worktrees' || command === 'squad-worktrees') {
+      result = await runSquadWorktrees({ args, options, logger: commandLogger, t });
+    } else if (command === 'squad:merge' || command === 'squad-merge') {
+      result = await runSquadMerge({ args, options, logger: commandLogger, t });
+    } else if (command === 'squad:recovery' || command === 'squad-recovery') {
+      result = await runSquadRecovery({ args, options, logger: commandLogger, t });
+    } else if (command === 'squad:deploy' || command === 'squad-deploy') {
+      result = await runSquadDeploy({ args, options, logger: commandLogger, t });
+    } else if (command === 'squad:webhook' || command === 'squad-webhook') {
+      const sub = options.sub || 'start';
+      result = await runSquadWebhook({ args, options: { ...options, sub }, logger: commandLogger, t });
     } else if (command === 'squad:plan' || command === 'squad-plan') {
       result = await runSquadPlan({ args, options, logger: commandLogger, t });
     } else if (command === 'squad:learning' || command === 'squad-learning') {
       const sub = args[1] || 'list';
       result = await runSquadLearning({ args, options: { ...options, sub }, logger: commandLogger, t });
+    } else if (command === 'learning:evolve' || command === 'learning-evolve') {
+      result = await runLearningEvolve({ args, options, logger: commandLogger, t });
+    } else if (command === 'learning:apply' || command === 'learning-apply') {
+      result = await runLearningApply({ args, options, logger: commandLogger, t });
     } else if (command.startsWith('learning:') || command === 'learning') {
       const sub = command === 'learning' ? (args[1] || 'list') : command.split(':')[1];
       result = await runLearning({ args, options: { ...options, sub }, logger: commandLogger, t });
@@ -580,6 +735,10 @@ async function main() {
       result = await runRuntimeStatus({ args, options, logger: commandLogger, t });
     } else if (command === 'runtime:log' || command === 'runtime-log') {
       result = await runRuntimeLog({ args, options, logger: commandLogger, t });
+    } else if (command === 'agent:done' || command === 'agent-done') {
+      result = await runAgentDone({ args, options, logger: commandLogger, t });
+    } else if (command === 'agent:recover' || command === 'agent-recover') {
+      result = await runAgentRecover({ args, options, logger: commandLogger, t });
     } else if (command === 'runtime:session:start' || command === 'runtime-session-start') {
       result = await runRuntimeSessionStart({ args, options, logger: commandLogger, t });
     } else if (command === 'runtime:session:log' || command === 'runtime-session-log') {
@@ -614,12 +773,16 @@ async function main() {
       result = await runRuntimeBackup({ args, options, logger: commandLogger, t });
     } else if (command === 'runtime:restore' || command === 'runtime-restore') {
       result = await runRuntimeRestore({ args, options, logger: commandLogger, t });
+    } else if (command === 'backup:local' || command === 'backup-local') {
+      result = await runBackupLocal({ args, options, logger: commandLogger, t });
     } else if (command === 'skill:install' || command === 'skill-install') {
       result = await runSkillInstall({ args, options, logger: commandLogger, t });
     } else if (command === 'skill:list' || command === 'skill-list') {
       result = await runSkillList({ args, options, logger: commandLogger, t });
     } else if (command === 'skill:remove' || command === 'skill-remove') {
       result = await runSkillRemove({ args, options, logger: commandLogger, t });
+    } else if (command === 'design-hybrid:options' || command === 'design-hybrid-options') {
+      result = await runDesignHybridOptions({ args, options, logger: commandLogger, t });
     } else if (command === 'cloud:import:squad' || command === 'cloud-import-squad') {
       result = await runCloudImportSquad({ args, options, logger: commandLogger, t });
     } else if (command === 'cloud:import:genome' || command === 'cloud-import-genome') {
@@ -628,6 +791,35 @@ async function main() {
       result = await runCloudPublishSquad({ args, options, logger: commandLogger, t });
     } else if (command === 'cloud:publish:genome' || command === 'cloud-publish-genome') {
       result = await runCloudPublishGenome({ args, options, logger: commandLogger, t });
+    } else if (command === 'recovery:generate' || command === 'recovery-generate') {
+      result = await runRecoveryGenerate({ args, options, logger: commandLogger, t });
+    } else if (command === 'recovery:show' || command === 'recovery-show') {
+      result = await runRecoveryShow({ args, options, logger: commandLogger, t });
+    } else if (command === 'context:monitor' || command === 'context-monitor') {
+      result = await runContextMonitor({ args, options, logger: commandLogger, t });
+    } else if (command === 'context:search' || command === 'context-search') {
+      result = await runContextSearch({ args, options, logger: commandLogger, t });
+    } else if (command === 'context:search:index' || command === 'context-search-index') {
+      result = await runContextSearchIndex({ args, options, logger: commandLogger, t });
+    } else if (command === 'context:cache' || command === 'context-cache') {
+      result = await runContextCacheList({ args, options, logger: commandLogger, t });
+    } else if (command === 'context:cache:save' || command === 'context-cache-save') {
+      result = await runContextCacheSave({ args, options, logger: commandLogger, t });
+    } else if (command === 'context:cache:restore' || command === 'context-cache-restore') {
+      result = await runContextCacheRestore({ args, options, logger: commandLogger, t });
+    } else if (command === 'context:cache:cleanup' || command === 'context-cache-cleanup') {
+      result = await runContextCacheCleanup({ args, options, logger: commandLogger, t });
+    } else if (command === 'sandbox:exec' || command === 'sandbox-exec') {
+      result = await runSandboxExec({ args, options, logger: commandLogger, t });
+    } else if (command === 'agent:load' || command === 'agent-load') {
+      result = await runAgentLoad({ args, options, logger: commandLogger, t });
+    } else if (command === 'agent:shard:index' || command === 'agent-shard-index') {
+      result = await runAgentShardIndex({ args, options, logger: commandLogger, t });
+    } else if (command.startsWith('tool:') || command.startsWith('tool-')) {
+      const sub = command.replace(/^tool[:-]/, '');
+      result = await runToolRegistry({ args, options: { ...options, sub }, logger: commandLogger, t });
+    } else if (command === 'health') {
+      result = await runHealth({ args, options, logger: commandLogger, t });
     } else {
       const message = t('cli.unknown_command', { command });
       if (jsonMode) {

package/src/commands/agent-loader.js

@@ -0,0 +1,85 @@
+'use strict';
+
+const path = require('node:path');
+const { AgentLoader } = require('../agent-loader');
+
+async function runAgentLoad({ args, options, logger }) {
+  const agentId = args[0] || options.agent || '';
+  const goal = options.goal || '';
+  const cwd = path.resolve(process.cwd(), options.cwd || '.');
+  const agentsDir = path.join(cwd, options['agents-dir'] || '.aioson/agents');
+  const maxShards = Number(options['max-shards']) || 3;
+  const maxTokens = Number(options['max-tokens']) || 2000;
+
+  if (!agentId) {
+    logger.error('Usage: aioson agent:load <agent-id> --goal="..." [--cwd=.]');
+    return { ok: false, error: 'missing_agent' };
+  }
+
+  const loader = new AgentLoader();
+  await loader.open();
+
+  try {
+    // Index agents dir if needed
+    await loader.indexAgentsDir(agentsDir, { force: Boolean(options.force) });
+
+    // Load relevant shards
+    const result = await loader.loadRelevantShards(agentId, goal, { maxShards, maxTokens });
+
+    if (result.shards.length === 0) {
+      logger.log(`No shards found for agent: ${agentId}`);
+      logger.log(`Make sure the agents directory exists: ${agentsDir}`);
+      return { ok: true, agentId, shards: [], tokens: 0 };
+    }
+
+    if (options.json) {
+      return { ok: true, ...result };
+    }
+
+    logger.log(`\n  Agent: ${agentId}  (${result.shards.length}/${result.totalShards} shards, ${result.tokens} tokens)\n`);
+    for (const shard of result.shards) {
+      logger.log(`  ## ${shard.heading}  (${shard.tokens} tokens)`);
+    }
+    logger.log('');
+
+    if (options.print) {
+      logger.log('\n---\n');
+      logger.log(AgentLoader.buildContext(result.shards));
+    }
+
+    return { ok: true, ...result };
+  } finally {
+    loader.close();
+  }
+}
+
+async function runAgentShardIndex({ args, options, logger }) {
+  const cwd = path.resolve(process.cwd(), args[0] || '.');
+  const agentsDir = path.join(cwd, options['agents-dir'] || '.aioson/agents');
+  const force = Boolean(options.force);
+
+  logger.log(`Indexing agent shards from: ${agentsDir}`);
+
+  const loader = new AgentLoader();
+  await loader.open();
+
+  try {
+    const result = await loader.indexAgentsDir(agentsDir, { force });
+    const stats = loader.stats();
+
+    if (options.json) {
+      return { ok: true, ...result, stats };
+    }
+
+    logger.log(`  Agents indexed: ${result.agents}`);
+    logger.log(`  Total shards: ${result.totalShards}`);
+    logger.log(`  Index total docs: ${stats.totalDocs}`);
+    logger.log('');
+
+    return { ok: true, ...result, stats };
+  } finally {
+    loader.close();
+  }
+}
+
+module.exports = { runAgentLoad, runAgentShardIndex };

package/src/commands/backup-local-cmd.js

@@ -0,0 +1,25 @@
+'use strict';
+
+const path = require('node:path');
+const { backupAiosonDocs } = require('../backup-local');
+
+/**
+ * aioson backup:local [.]
+ *
+ * Manually backs up all .md files from .aioson/context/ and .aioson/plans/
+ * to ~/.aioson/backups/{project}/{timestamp}/
+ */
+async function runBackupLocal({ args, options, logger }) {
+  const targetDir = path.resolve(process.cwd(), args[0] || '.');
+  const result = await backupAiosonDocs(targetDir);
+
+  if (result.count === 0) {
+    logger.log('backup:local — nothing to back up (no .md files found in .aioson/context/ or .aioson/plans/)');
+    return { ok: true, count: 0, backupPath: null };
+  }
+
+  logger.log(`backup:local — ${result.count} file(s) backed up → ${result.backupPath}`);
+  return { ok: true, count: result.count, backupPath: result.backupPath };
+}
+
+module.exports = { runBackupLocal };

package/src/commands/context-cache.js

@@ -0,0 +1,90 @@
+'use strict';
+
+const path = require('node:path');
+const { saveContextShadow, listSessions, restoreContext, cleanup } = require('../context-cache');
+
+async function runContextCacheList({ args, options, logger }) {
+  const cacheDir = options.cacheDir || undefined;
+  const sessions = await listSessions({ cacheDir });
+
+  if (options.json) {
+    return { ok: true, sessions };
+  }
+
+  if (sessions.length === 0) {
+    logger.log('No cached sessions found.');
+    return { ok: true, sessions: [] };
+  }
+
+  logger.log('\n  Cached Context Sessions\n');
+  for (const s of sessions) {
+    const kb = Math.round(s.size / 1024);
+    const goal = s.metadata.goal ? ` — ${s.metadata.goal.slice(0, 50)}` : '';
+    logger.log(`  ${s.sessionId}  ${s.createdAt.slice(0, 16)}  ${kb}KB${goal}`);
+  }
+  logger.log('');
+
+  return { ok: true, sessions };
+}
+
+async function runContextCacheSave({ args, options, logger }) {
+  const cwd = path.resolve(process.cwd(), args[0] || '.');
+  const content = options.content || '';
+
+  if (!content) {
+    logger.error('--content is required. Example: aioson context:cache:save . --content="..." --goal="..."');
+    return { ok: false, error: 'missing_content' };
+  }
+
+  const result = await saveContextShadow(content, {
+    goal: options.goal || '',
+    agent: options.agent || '',
+    projectDir: cwd
+  });
+
+  if (options.json) return result;
+
+  logger.log(`Context saved. Session ID: ${result.sessionId}`);
+  logger.log(`Path: ${result.path}`);
+  return result;
+}
+
+async function runContextCacheRestore({ args, options, logger }) {
+  const sessionId = options.session || args[0] || '';
+  const cacheDir = options.cacheDir || undefined;
+
+  if (!sessionId) {
+    logger.error('--session=<id> is required.');
+    return { ok: false, error: 'missing_session' };
+  }
+
+  const result = await restoreContext(sessionId, {
+    cacheDir,
+    query: options.query || undefined
+  });
+
+  if (!result.ok) {
+    logger.error(`Restore failed: ${result.error}`);
+    return result;
+  }
+
+  if (options.json) return result;
+
+  logger.log(result.content);
+  return result;
+}
+
+async function runContextCacheCleanup({ args, options, logger }) {
+  const cacheDir = options.cacheDir || undefined;
+  const maxAgeHours = Number(options['max-age']) || 24;
+  const maxAge = maxAgeHours * 60 * 60 * 1000;
+
+  const result = await cleanup({ cacheDir, maxAge });
+
+  if (options.json) return { ok: true, ...result };
+
+  logger.log(`Removed ${result.removed} expired session(s).`);
+  return { ok: true, ...result };
+}
+
+module.exports = { runContextCacheList, runContextCacheSave, runContextCacheRestore, runContextCacheCleanup };

package/src/commands/context-monitor.js

@@ -0,0 +1,92 @@
+'use strict';
+
+const path = require('node:path');
+const {
+  getContextUsage,
+  computeWarningLevel,
+  THRESHOLDS
+} = require('../squad-dashboard/context-monitor');
+
+const BAR_WIDTH = 20;
+const LEVEL_ICONS = { normal: ' ', warning: '⚠', critical: '!', overflow: 'X', unknown: '?' };
+
+function renderBar(ratio, width) {
+  const clamped = Math.max(0, Math.min(1, ratio));
+  const filled = Math.round(clamped * width);
+  const bar = '█'.repeat(filled) + '░'.repeat(width - filled);
+  return `[${bar}] ${Math.round(clamped * 100)}%`;
+}
+
+function formatTokens(n) {
+  if (typeof n !== 'number') return '?';
+  return n.toLocaleString();
+}
+
+function renderAgent(slug, agent) {
+  const used = agent.totalUsed || 0;
+  const win = agent.windowSize || 0;
+  const ratio = win > 0 ? used / win : 0;
+  const level = agent.warningLevel || computeWarningLevel(used, win);
+  const icon = LEVEL_ICONS[level] || '?';
+  const bar = renderBar(ratio, BAR_WIDTH);
+  const line = `  ${icon} ${slug.padEnd(16)} ${bar}  ${formatTokens(used)}/${formatTokens(win)}`;
+  if (level === 'warning' || level === 'critical' || level === 'overflow') {
+    return `${line}  [${level.toUpperCase()}]`;
+  }
+  return line;
+}
+
+async function runContextMonitor({ args, options, logger }) {
+  const cwd = path.resolve(process.cwd(), args[0] || '.');
+  const squadSlug = options.squad || null;
+  const agentSlug = options.agent || null;
+
+  if (!squadSlug) {
+    logger.log('\n  Context Monitor\n');
+    logger.log('  No squad specified. Use --squad=<slug> to monitor a squad.');
+    logger.log('  Example: aioson context:monitor . --squad=my-squad');
+    logger.log('');
+    return { ok: true, squads: [] };
+  }
+
+  const data = await getContextUsage(cwd, squadSlug, agentSlug || null);
+
+  if (!data) {
+    logger.log(`\n  No context data found for squad: ${squadSlug}`);
+    logger.log('  The squad may not have started yet or context-monitor.json is missing.');
+    logger.log('');
+    return { ok: true, squadSlug, agents: {} };
+  }
+
+  if (options.json) {
+    return { ok: true, ...data };
+  }
+
+  logger.log(`\n  Context Monitor — ${squadSlug}\n`);
+
+  if (agentSlug) {
+    // Single agent
+    const agent = data;
+    logger.log(renderAgent(agentSlug, agent));
+  } else {
+    const agents = data.agents || {};
+    if (Object.keys(agents).length === 0) {
+      logger.log('  No agents tracked yet.');
+    } else {
+      for (const [slug, agent] of Object.entries(agents)) {
+        logger.log(renderAgent(slug, agent));
+      }
+    }
+  }
+
+  logger.log('');
+  logger.log(`  Thresholds: warning=${Math.round(THRESHOLDS.warning * 100)}%  critical=${Math.round(THRESHOLDS.critical * 100)}%`);
+  if (data.updatedAt) {
+    logger.log(`  Updated: ${data.updatedAt}`);
+  }
+  logger.log('');
+
+  return { ok: true, ...data };
+}
+
+module.exports = { runContextMonitor };