@jaimevalasek/aioson 1.5.1 → 1.7.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');
@@ -61,6 +62,14 @@ 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 { runSquadBus } = require('./commands/squad-bus');
+const { runSquadAutorun } = require('./commands/squad-autorun');
+const { runSquadDependencyGraph } = require('./commands/squad-dependency-graph');
+const { runSquadToolRegister } = require('./commands/squad-tool-register');
+const { runSquadReview } = require('./commands/squad-review');
+const { runAgentAudit } = require('./commands/agent-audit');
+const { runBriefGen } = require('./commands/brief-gen');
+const { runVerifyGate } = require('./commands/verify-gate');
 const {
   runRuntimeInit,
   runRuntimeIngest,
@@ -108,11 +117,60 @@ 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 { runLearningRollback } = require('./commands/learning-rollback');
+const { runToolRegistry } = require('./commands/tool-registry-cmd');
+const { runHealth } = require('./commands/health');
+const { runContextHealth } = require('./commands/context-health');
+const { runContextTrim } = require('./commands/context-trim');
+const { runHooksEmit } = require('./commands/hooks-emit');
+const { runHooksInstall, runHooksUninstall } = require('./commands/hooks-install');
+const { runSessionGuard } = require('./commands/session-guard');
+const { runDevlogProcess } = require('./commands/devlog-process');
+const { runDevlogWatch } = require('./commands/devlog-watch');
+const { runDevlogExportBrains } = require('./commands/devlog-export-brains');
+const { runSpecSync } = require('./commands/spec-sync');
+const { runSpecStatus } = require('./commands/spec-status');
+const { runSpecCheckpoint } = require('./commands/spec-checkpoint');
+const { runSpecTasks } = require('./commands/spec-tasks');
+const { runLearningExport } = require('./commands/learning-export');
+const { runRunnerRun } = require('./commands/runner-run');
+const { runRunnerQueue } = require('./commands/runner-queue');
+const { runRunnerPlan } = require('./commands/runner-plan');
+const { runRunnerDaemon } = require('./commands/runner-daemon');
+const { runPreflight } = require('./commands/preflight');
+const { runClassify } = require('./commands/classify');
+const { runSizing } = require('./commands/sizing');
+const { runDetectTestRunner } = require('./commands/detect-test-runner');
+const { runPulseUpdate } = require('./commands/pulse-update');
+const { runStateSave } = require('./commands/state-save');
+const { runFeatureClose } = require('./commands/feature-close');
+const { runGateCheck } = require('./commands/gate-check');
+const { runArtifactValidate } = require('./commands/artifact-validate');
+const { runWorkflowExecute } = require('./commands/workflow-execute');
+const { runRunnerQueueFromPlan } = require('./commands/runner-queue-from-plan');
+const { runLearningAutoPromote } = require('./commands/learning-auto-promote');
+const { runBriefValidate } = require('./commands/brief-validate');
+const { runPreflightContext } = require('./commands/preflight-context');
+const { runContextCompact } = require('./commands/context-compact');
+const { runSquadScaffold } = require('./commands/squad-scaffold');
+const { runPatternDetect } = require('./commands/pattern-detect');
+const { runSelfLoop } = require('./commands/self-implement-loop');
+const { runSquadCard } = require('./commands/squad-card');
+const { runAgentExportSkill } = require('./commands/agent-export-skill');
 
 const JSON_SUPPORTED_COMMANDS = new Set([
   'init',
   'install',
+  'setup',
   'update',
   'i18n:add',
   'i18n-add',
@@ -235,12 +293,71 @@ const JSON_SUPPORTED_COMMANDS = new Set([
   'plan',
   'squad:plan',
   'squad-plan',
+  'squad:bus',
+  'squad-bus',
+  'squad:autorun',
+  'squad-autorun',
+  'squad:dependency-graph',
+  'squad-dependency-graph',
+  'squad:tool:register',
+  'squad-tool-register',
+  'squad:review',
+  'squad-review',
+  'agent:audit',
+  'agent-audit',
+  'brief:gen',
+  'brief-gen',
+  'verify:gate',
+  'verify-gate',
+  'brief:validate',
+  'brief-validate',
+  'preflight:context',
+  'preflight-context',
+  'context:compact',
+  'context-compact',
+  'squad:scaffold',
+  'squad-scaffold',
+  'pattern:detect',
+  'pattern-detect',
+  'self:loop',
+  'self-loop',
+  'squad:card',
+  'squad-card',
+  'agent:export-skill',
+  'agent-export-skill',
   'squad:learning',
   'squad-learning',
   'learning',
   'learning:list',
   'learning:stats',
   'learning:promote',
+  'learning:evolve',
+  'learning-evolve',
+  'learning:apply',
+  'learning-apply',
+  'learning:rollback',
+  'learning-rollback',
+  'learning:export',
+  'learning-export',
+  'spec:sync',
+  'spec-sync',
+  'spec:status',
+  'spec-status',
+  'spec:checkpoint',
+  'spec-checkpoint',
+  'spec:tasks',
+  'spec-tasks',
+  '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',
@@ -298,6 +415,20 @@ const JSON_SUPPORTED_COMMANDS = new Set([
   'cloud-publish-squad',
   'cloud:publish:genome',
   'cloud-publish-genome',
+  'hooks:emit',
+  'hooks-emit',
+  'hooks:install',
+  'hooks-install',
+  'hooks:uninstall',
+  'hooks-uninstall',
+  'session:guard',
+  'session-guard',
+  'devlog:process',
+  'devlog-process',
+  'devlog:watch',
+  'devlog-watch',
+  'devlog:export-brains',
+  'devlog-export-brains',
   'runtime:backup',
   'runtime-backup',
   'runtime:restore',
@@ -308,9 +439,68 @@ 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:health',
+  'context-health',
+  'context:trim',
+  'context-trim',
+  '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',
+  'runner:run',
+  'runner-run',
+  'runner:queue',
+  'runner-queue',
+  'runner:plan',
+  'runner-plan',
+  'runner:daemon',
+  'runner-daemon',
   'version',
   '--version',
-  '-v'
+  '-v',
+  'preflight',
+  'classify',
+  'sizing',
+  'detect:test-runner',
+  'detect-test-runner',
+  'pulse:update',
+  'pulse-update',
+  'state:save',
+  'state-save',
+  'feature:close',
+  'feature-close',
+  'gate:check',
+  'gate-check',
+  'artifact:validate',
+  'artifact-validate',
+  'workflow:execute',
+  'workflow-execute',
+  'runner:queue:from-plan',
+  'runner-queue-from-plan',
+  'learning:auto-promote',
+  'learning-auto-promote'
 ]);
 
 const LEGACY_DASHBOARD_COMMANDS = new Set([
@@ -354,6 +544,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 +619,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 +683,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') {
@@ -641,9 +837,58 @@ async function main() {
       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:bus' || command === 'squad-bus') {
+      const sub = args[1] || options.sub || 'read';
+      result = await runSquadBus({ args, options: { ...options, sub }, logger: commandLogger });
+    } else if (command === 'squad:autorun' || command === 'squad-autorun') {
+      result = await runSquadAutorun({ args, options, logger: commandLogger });
+    } else if (command === 'squad:dependency-graph' || command === 'squad-dependency-graph') {
+      result = await runSquadDependencyGraph({ args, options, logger: commandLogger });
+    } else if (command === 'squad:tool:register' || command === 'squad-tool-register') {
+      result = await runSquadToolRegister({ args, options, logger: commandLogger });
+    } else if (command === 'squad:review' || command === 'squad-review') {
+      result = await runSquadReview({ args, options, logger: commandLogger });
+    } else if (command === 'agent:audit' || command === 'agent-audit') {
+      result = await runAgentAudit({ args, options, logger: commandLogger });
+    } else if (command === 'brief:gen' || command === 'brief-gen') {
+      result = await runBriefGen({ args, options, logger: commandLogger });
+    } else if (command === 'verify:gate' || command === 'verify-gate') {
+      result = await runVerifyGate({ args, options, logger: commandLogger });
+    } else if (command === 'brief:validate' || command === 'brief-validate') {
+      result = await runBriefValidate({ args, options, logger: commandLogger });
+    } else if (command === 'preflight:context' || command === 'preflight-context') {
+      result = await runPreflightContext({ args, options, logger: commandLogger });
+    } else if (command === 'context:compact' || command === 'context-compact') {
+      result = await runContextCompact({ args, options, logger: commandLogger });
+    } else if (command === 'squad:scaffold' || command === 'squad-scaffold') {
+      result = await runSquadScaffold({ args, options, logger: commandLogger });
+    } else if (command === 'pattern:detect' || command === 'pattern-detect') {
+      result = await runPatternDetect({ args, options, logger: commandLogger });
+    } else if (command === 'self:loop' || command === 'self-loop') {
+      result = await runSelfLoop({ args, options, logger: commandLogger });
+    } else if (command === 'squad:card' || command === 'squad-card') {
+      result = await runSquadCard({ args, options, logger: commandLogger });
+    } else if (command === 'agent:export-skill' || command === 'agent-export-skill') {
+      result = await runAgentExportSkill({ args, options, logger: commandLogger });
     } 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:rollback' || command === 'learning-rollback') {
+      result = await runLearningRollback({ args, options, logger: commandLogger });
+    } else if (command === 'learning:apply' || command === 'learning-apply') {
+      result = await runLearningApply({ args, options, logger: commandLogger, t });
+    } else if (command === 'learning:export' || command === 'learning-export') {
+      result = await runLearningExport({ args, options, logger: commandLogger });
+    } else if (command === 'spec:sync' || command === 'spec-sync') {
+      result = await runSpecSync({ args, options, logger: commandLogger });
+    } else if (command === 'spec:status' || command === 'spec-status') {
+      result = await runSpecStatus({ args, options, logger: commandLogger });
+    } else if (command === 'spec:checkpoint' || command === 'spec-checkpoint') {
+      result = await runSpecCheckpoint({ args, options, logger: commandLogger });
+    } else if (command === 'spec:tasks' || command === 'spec-tasks') {
+      result = await runSpecTasks({ args, options, logger: commandLogger });
     } 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 });
@@ -704,6 +949,20 @@ async function main() {
       result = await runOutputStrategyImport({ args, options, logger: commandLogger, t });
     } else if (command === 'devlog:sync' || command === 'devlog-sync') {
       result = await runDevlogSync({ args, options, logger: commandLogger, t });
+    } else if (command === 'hooks:emit' || command === 'hooks-emit') {
+      result = await runHooksEmit({ args, options, logger: commandLogger });
+    } else if (command === 'hooks:install' || command === 'hooks-install') {
+      result = await runHooksInstall({ args, options, logger: commandLogger });
+    } else if (command === 'hooks:uninstall' || command === 'hooks-uninstall') {
+      result = await runHooksUninstall({ args, options, logger: commandLogger });
+    } else if (command === 'session:guard' || command === 'session-guard') {
+      result = await runSessionGuard({ args, options, logger: commandLogger });
+    } else if (command === 'devlog:process' || command === 'devlog-process') {
+      result = await runDevlogProcess({ args, options, logger: commandLogger });
+    } else if (command === 'devlog:watch' || command === 'devlog-watch') {
+      result = await runDevlogWatch({ args, options, logger: commandLogger });
+    } else if (command === 'devlog:export-brains' || command === 'devlog-export-brains') {
+      result = await runDevlogExportBrains({ args, options, logger: commandLogger });
     } else if (command === 'runtime:prune' || command === 'runtime-prune') {
       result = await runRuntimePrune({ args, options, logger: commandLogger, t });
     } else if (command === 'runtime:backup' || command === 'runtime-backup') {
@@ -718,6 +977,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 +987,73 @@ 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:health' || command === 'context-health') {
+      result = await runContextHealth({ args, options, logger: commandLogger });
+    } else if (command === 'context:trim' || command === 'context-trim') {
+      result = await runContextTrim({ args, options, logger: commandLogger });
+    } 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 if (command === 'runner:run' || command === 'runner-run') {
+      result = await runRunnerRun({ args, options, logger: commandLogger });
+    } else if (command === 'runner:queue' || command === 'runner-queue') {
+      const sub = args[1] || options.sub || 'list';
+      result = await runRunnerQueue({ args, options: { ...options, sub }, logger: commandLogger });
+    } else if (command === 'runner:plan' || command === 'runner-plan') {
+      result = await runRunnerPlan({ args, options, logger: commandLogger });
+    } else if (command === 'runner:daemon' || command === 'runner-daemon') {
+      const sub = args[1] || options.sub || 'status';
+      result = await runRunnerDaemon({ args, options: { ...options, sub }, logger: commandLogger });
+    } else if (command === 'preflight') {
+      result = await runPreflight({ args, options, logger: commandLogger });
+    } else if (command === 'classify') {
+      result = await runClassify({ args, options, logger: commandLogger });
+    } else if (command === 'sizing') {
+      result = await runSizing({ args, options, logger: commandLogger });
+    } else if (command === 'detect:test-runner' || command === 'detect-test-runner') {
+      result = await runDetectTestRunner({ args, options, logger: commandLogger });
+    } else if (command === 'pulse:update' || command === 'pulse-update') {
+      result = await runPulseUpdate({ args, options, logger: commandLogger });
+    } else if (command === 'state:save' || command === 'state-save') {
+      result = await runStateSave({ args, options, logger: commandLogger });
+    } else if (command === 'feature:close' || command === 'feature-close') {
+      result = await runFeatureClose({ args, options, logger: commandLogger });
+    } else if (command === 'gate:check' || command === 'gate-check') {
+      result = await runGateCheck({ args, options, logger: commandLogger });
+    } else if (command === 'artifact:validate' || command === 'artifact-validate') {
+      result = await runArtifactValidate({ args, options, logger: commandLogger });
+    } else if (command === 'workflow:execute' || command === 'workflow-execute') {
+      result = await runWorkflowExecute({ args, options, logger: commandLogger });
+    } else if (command === 'runner:queue:from-plan' || command === 'runner-queue-from-plan') {
+      result = await runRunnerQueueFromPlan({ args, options, logger: commandLogger });
+    } else if (command === 'learning:auto-promote' || command === 'learning-auto-promote') {
+      result = await runLearningAutoPromote({ args, options, logger: commandLogger });
     } else {
       const message = t('cli.unknown_command', { command });
       if (jsonMode) {