@jaimevalasek/aioson 1.5.1 → 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');
@@ -108,11 +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',
@@ -241,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',
@@ -308,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'
@@ -354,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');
@@ -428,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');
@@ -491,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') {
@@ -644,6 +703,10 @@ async function main() {
     } 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 });
@@ -718,6 +781,8 @@ async function main() {
       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') {
@@ -726,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/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 };

package/src/commands/context-search.js

@@ -0,0 +1,66 @@
+'use strict';
+
+const path = require('node:path');
+const { withIndex } = require('../context-search');
+
+async function runContextSearch({ args, options, logger }) {
+  const query = args[0] || options.query || '';
+  const cwd = path.resolve(process.cwd(), options.cwd || '.');
+  const limit = Number(options.limit) || 10;
+
+  if (!query) {
+    logger.log('Usage: aioson context:search <query> [--limit=10] [--cwd=.]');
+    return { ok: false, error: 'missing_query' };
+  }
+
+  const results = await withIndex(async (idx) => {
+    return idx.search(query, { limit, projectDir: cwd });
+  });
+
+  if (options.json) {
+    return { ok: true, results };
+  }
+
+  if (results.length === 0) {
+    logger.log(`No results for: ${query}`);
+    return { ok: true, results: [] };
+  }
+
+  logger.log(`\n  Search results for: "${query}"\n`);
+  for (let i = 0; i < results.length; i++) {
+    const r = results[i];
+    logger.log(`  ${i + 1}. ${r.title}`);
+    logger.log(`     ${r.relPath}`);
+    if (r.snippet) {
+      logger.log(`     ${r.snippet.replace(/\n/g, ' ')}`);
+    }
+    logger.log('');
+  }
+
+  return { ok: true, results };
+}
+
+async function runContextSearchIndex({ args, options, logger }) {
+  const cwd = path.resolve(process.cwd(), args[0] || '.');
+  const force = Boolean(options.force);
+
+  logger.log(`Indexing: ${cwd} ...`);
+
+  const result = await withIndex(async (idx) => {
+    const r = await idx.indexDirectory(cwd, { force });
+    const stats = idx.stats();
+    return { ...r, stats };
+  });
+
+  if (options.json) {
+    return { ok: true, ...result };
+  }
+
+  logger.log(`  Indexed: ${result.indexed} files`);
+  logger.log(`  Skipped: ${result.skipped} files (already indexed)`);
+  logger.log(`  Total in index: ${result.stats.totalDocs} docs`);
+
+  return { ok: true, ...result };
+}
+
+module.exports = { runContextSearch, runContextSearchIndex };