@aria_asi/cli 0.2.40 → 0.2.41

package/bin/aria.js

@@ -24,6 +24,7 @@ import {
 } from '../dist/aria-connector/src/connectors/repo-guard.js';
 import { installRepoDoctrineGitHooks } from '../dist/aria-connector/src/connectors/repo-git-hooks.js';
 import { installSharedRuntime } from '../dist/aria-connector/src/connectors/runtime.js';
+import { handleTaskCommand } from '../dist/aria-connector/src/task-runner.js';
 import {
   installAriaSyncDaemon,
   runSyncOnce,
@@ -139,6 +140,43 @@ if (command === 'check-update') {
 } else if (command === 'install-hooks' || command === 'connect') {
   const force = args.includes('--force');
   const localOnly = args.includes('--local');
+  const dryRun = args.includes('--dry-run');
+  const strict = args.includes('--strict');
+  const runtimeSidecarOnly = args.includes('--runtime-sidecar-only');
+  const runtimeOnly = args.includes('--runtime-only');
+  const hooksOnly = args.includes('--hooks-only');
+  const withWrappers = args.includes('--with-wrappers');
+  if (runtimeSidecarOnly && withWrappers) {
+    console.error('runtime-sidecar-only mode excludes shell wrapper activation. Remove --with-wrappers and rerun.');
+    process.exit(1);
+  }
+  const explicitOnly = {
+    claude: args.includes('--claude-only'),
+    opencode: args.includes('--opencode-only'),
+    codex: args.includes('--codex-only'),
+    cursor: args.includes('--cursor-only'),
+  };
+  const explicitSurfaceSelected = Object.values(explicitOnly).some(Boolean);
+  const surfaceArg = args.find((arg) => arg.startsWith('--surfaces='));
+  const selectedSurfaces = new Set(
+    surfaceArg
+      ? surfaceArg.slice('--surfaces='.length).split(',').map((item) => item.trim()).filter(Boolean)
+      : [],
+  );
+  for (const [surface, selected] of Object.entries(explicitOnly)) {
+    if (selected) selectedSurfaces.add(surface);
+  }
+  const surfaceExplicit = selectedSurfaces.size > 0;
+  const skipSurface = (surface) => args.includes(`--skip-${surface}`);
+  const wantsSurface = (surface) => {
+    if (runtimeOnly) return false;
+    if (surfaceExplicit) return selectedSurfaces.has(surface);
+    return !skipSurface(surface);
+  };
+  const effectiveStrict = strict || runtimeSidecarOnly;
+  const includeRuntime = !hooksOnly && (runtimeSidecarOnly || runtimeOnly || !surfaceExplicit || args.includes('--runtime'));
+  const includeRepoServices = !runtimeSidecarOnly && !runtimeOnly && !hooksOnly && !surfaceExplicit && !args.includes('--skip-repo-services');
+  const includeSyncd = includeRepoServices && process.env.ARIA_SKIP_SYNCD_INSTALL !== '1' && !args.includes('--skip-syncd');
   let config;
   try {
     config = loadConfig();
@@ -152,50 +190,94 @@ if (command === 'check-update') {
     console.log('  Full harness features activate when aria-soul becomes reachable.');
     console.log('  Run `aria login <token>` later to upgrade.');
   }
+  if (dryRun) {
+    console.log(JSON.stringify({
+      ok: true,
+      command,
+      dryRun: true,
+      installPlan: {
+        runtime: includeRuntime,
+        hooksOnly,
+        surfaces: {
+          claude: wantsSurface('claude'),
+          opencode: wantsSurface('opencode'),
+          codex: wantsSurface('codex'),
+          cursor: wantsSurface('cursor'),
+        },
+        repoServices: includeRepoServices,
+        syncd: includeSyncd,
+        wrappers: withWrappers ? 'enabled_by_explicit_flag' : 'skipped_by_default',
+        strict: effectiveStrict,
+        runtimeSidecarOnly,
+        excluded: runtimeSidecarOnly ? ['shell_wrappers', 'provider_path_takeover', 'consult_quality_engine', 'repo_services', 'syncd'] : [],
+      },
+      note: 'Dry run only; no files were modified.',
+    }, null, 2));
+    process.exit(0);
+  }
   loadAristotleNoorWire().then((wire) => wire.wrapCliCommand(
     'cli-connect',
     makeEmissionId('connect'),
     async () => {
       const allLogs = [];
-      // Shared runtime path — universal localhost sidecar for any client.
-      const runtimeLogs = await installSharedRuntime();
-      allLogs.push(...runtimeLogs);
-      // Claude Code path
-      const claudeLogs = await connectClaudeCode(config, { force });
-      allLogs.push(...claudeLogs);
-      // OpenCode path
-      const opencodeLogs = await connectOpenCode(config);
-      allLogs.push(...opencodeLogs);
-      // Codex path
-      const codexLogs = await connectCodex(config);
-      allLogs.push(...codexLogs);
-      // Cursor path — wire every linked repository
-      if (config.repositories?.length) {
-        for (const repo of config.repositories) {
-          const cursorLogs = await connectCursor(config, repo.path);
-          allLogs.push(...cursorLogs);
+      const phaseResults = [];
+      const runPhase = async (name, required, fn) => {
+        try {
+          const phaseLogs = await fn();
+          phaseResults.push({ name, ok: true, required });
+          allLogs.push(`[phase:${name}] ok`);
+          allLogs.push(...phaseLogs);
+        } catch (err) {
+          const message = err && err.message ? err.message : String(err);
+          phaseResults.push({ name, ok: false, required, error: message });
+          allLogs.push(`[phase:${name}] failed${required ? '' : ' (non-fatal)'}: ${message}`);
+          if (required || effectiveStrict) throw err;
         }
-      } else {
-        // Wire current working directory as fallback
-        const cursorLogs = await connectCursor(config);
-        allLogs.push(...cursorLogs);
+      };
+
+      // Shared runtime path — universal localhost sidecar for any client.
+      if (includeRuntime) await runPhase('runtime', true, () => installSharedRuntime());
+      if (wantsSurface('claude')) await runPhase('claude-hooks', surfaceExplicit || hooksOnly, () => connectClaudeCode(config, { force, installWrapper: withWrappers }));
+      if (wantsSurface('opencode')) await runPhase('opencode-hooks', surfaceExplicit || hooksOnly, () => connectOpenCode(config, { installWrapper: withWrappers }));
+      if (wantsSurface('codex')) await runPhase('codex-hooks', surfaceExplicit || hooksOnly, () => connectCodex(config, { installWrapper: withWrappers }));
+      if (wantsSurface('cursor')) {
+        await runPhase('cursor', surfaceExplicit || hooksOnly, async () => {
+          const cursorLogs = [];
+          if (config.repositories?.length) {
+            for (const repo of config.repositories) {
+              cursorLogs.push(...await connectCursor(config, repo.path));
+            }
+          } else {
+            cursorLogs.push(...await connectCursor(config));
+          }
+          return cursorLogs;
+        });
       }
-      const repoGateLogs = await installRepoDoctrineGitHooks(config, process.cwd());
-      allLogs.push(...repoGateLogs);
-      const repoGuardLogs = await installRepoGuardDaemon(config, process.cwd());
-      allLogs.push(...repoGuardLogs);
-      const codebaseAwarenessLogs = await installCodebaseAwarenessDaemon(config, process.cwd());
-      allLogs.push(...codebaseAwarenessLogs);
-      if (process.env.ARIA_SKIP_SYNCD_INSTALL !== '1') {
-        const syncLogs = await installAriaSyncDaemon({ sourceRoot: process.cwd() });
-        allLogs.push(...syncLogs);
+      if (includeRepoServices) {
+        await runPhase('repo-doctrine-hooks', false, () => installRepoDoctrineGitHooks(config, process.cwd()));
+        await runPhase('repo-guard-daemon', false, () => installRepoGuardDaemon(config, process.cwd()));
+        await runPhase('codebase-awareness-daemon', false, () => installCodebaseAwarenessDaemon(config, process.cwd()));
       }
-      return allLogs;
+      if (includeSyncd) await runPhase('syncd', false, () => installAriaSyncDaemon({ sourceRoot: process.cwd() }));
+
+      allLogs.push(`install-summary=${JSON.stringify({
+        runtime: includeRuntime,
+        wrappers: withWrappers ? 'enabled_by_explicit_flag' : 'skipped_by_default',
+        strict: effectiveStrict,
+        runtimeSidecarOnly,
+        phases: phaseResults,
+      })}`);
+      return { logs: allLogs, phaseResults };
     },
-    { metadata: { force, command: 'connect' } },
-  )).then(({ result: logs }) => {
+    { metadata: { force, command: 'connect', withWrappers, runtimeOnly, hooksOnly, strict: effectiveStrict, runtimeSidecarOnly } },
+  )).then(({ result }) => {
+    const logs = Array.isArray(result) ? result : result.logs;
     for (const line of logs) console.log(`  ${line}`);
-    console.log("Your Claude Code, OpenCode, Codex, and Cursor are now synced from the same harness package. Open a new session to start.");
+    console.log(runtimeSidecarOnly
+      ? 'Install finished in runtime-sidecar-only mode. Shell wrappers were excluded; provider CLIs keep their direct login/default provider path.'
+      : withWrappers
+      ? 'Install finished. Shell wrappers were installed because --with-wrappers was explicit.'
+      : 'Install finished. Shell wrappers were skipped by default; provider CLIs keep their direct login/default provider path.');
     process.exit(0);
   }).catch((err) => {
     console.error(`I hit an unexpected error: ${err && err.message ? err.message : err}`);
@@ -278,6 +360,126 @@ if (command === 'check-update') {
     console.error(`Unknown runtime subcommand: ${subCommand}`);
     process.exit(1);
   }
+} else if (command === 'task') {
+  handleTaskCommand(args, process.cwd()).then(() => {
+    process.exit(0);
+  }).catch((err) => {
+    console.error(`I couldn't complete aria task: ${err && err.message ? err.message : err}`);
+    process.exit(1);
+  });
+} else if (command === 'owner') {
+  const subCommand = args[0] || 'help';
+  if (subCommand === 'help' || subCommand === '--help' || subCommand === '-h') {
+    console.log('');
+    console.log('  aria owner sheets-export  Export read-only owner visibility CSVs for Google Sheets.');
+    console.log('  aria owner airtable-sync  Sync owner runtime ledger into Airtable.');
+    console.log('  aria owner airtable-drain Drain queued owner Airtable sync markers and run one coalesced sync.');
+    console.log('  aria owner action-ledger-replay');
+    console.log('                            Replay queued action-ledger events into Hive/runtime.');
+    console.log('');
+    console.log('  Export options: --task-id ID, --out-dir PATH, --action-ledger-dir PATH.');
+    console.log('  Airtable options: --base-id ID, --secrets-env PATH, --state-path PATH, --dry-run.');
+    console.log('  Airtable drain options: --queue-path PATH, --state-path PATH, --max-records N, --dry-run, --quiet.');
+    console.log('  Replay options: --project-id ID, --task-id ID, --limit N, --runtime-url URL.');
+    console.log('');
+    process.exit(0);
+  }
+  if (subCommand === 'sheets-export') {
+    import('../scripts/export-owner-status-sheets.mjs').then(({ exportOwnerGoogleSheetsCsv }) => {
+      const options = {};
+      const passthrough = args.slice(1);
+      for (let index = 0; index < passthrough.length; index += 1) {
+        const arg = passthrough[index];
+        if (arg === '--task-id') options.taskId = passthrough[++index];
+        else if (arg === '--task-dir') options.taskDir = passthrough[++index];
+        else if (arg === '--runtime-state-dir') options.runtimeStateDir = passthrough[++index];
+        else if (arg === '--action-ledger-dir') options.actionLedgerDir = passthrough[++index];
+        else if (arg === '--out-dir') options.outDir = passthrough[++index];
+      }
+      const result = exportOwnerGoogleSheetsCsv(options);
+      console.log(JSON.stringify(result, null, 2));
+      process.exit(0);
+    }).catch((err) => {
+      console.error(`I couldn't export owner sheets: ${err && err.message ? err.message : err}`);
+      process.exit(1);
+    });
+  } else if (subCommand === 'airtable-sync') {
+    import('../scripts/sync-owner-status-airtable.mjs').then(({ syncOwnerStatusAirtable }) => {
+      const options = {};
+      const passthrough = args.slice(1);
+      for (let index = 0; index < passthrough.length; index += 1) {
+        const arg = passthrough[index];
+        if (arg === '--task-id') options.taskId = passthrough[++index];
+        else if (arg === '--task-dir') options.taskDir = passthrough[++index];
+        else if (arg === '--runtime-state-dir') options.runtimeStateDir = passthrough[++index];
+        else if (arg === '--action-ledger-dir') options.actionLedgerDir = passthrough[++index];
+        else if (arg === '--out-dir') options.outDir = passthrough[++index];
+        else if (arg === '--base-id') options.baseId = passthrough[++index];
+        else if (arg === '--secrets-env') options.secretsEnv = passthrough[++index];
+        else if (arg === '--state-path') options.statePath = passthrough[++index];
+        else if (arg === '--atlas-socket') options.atlasSocket = passthrough[++index];
+        else if (arg === '--dry-run') options.dryRun = true;
+      }
+      return syncOwnerStatusAirtable(options);
+    }).then((result) => {
+      console.log(JSON.stringify(result, null, 2));
+      process.exit(0);
+    }).catch((err) => {
+      console.error(`I couldn't sync owner Airtable: ${err && err.message ? err.message : err}`);
+      process.exit(1);
+    });
+  } else if (subCommand === 'airtable-drain') {
+    import('../scripts/drain-owner-airtable-sync-queue.mjs').then(({ drainOwnerAirtableSyncQueue }) => {
+      const options = {};
+      const passthrough = args.slice(1);
+      for (let index = 0; index < passthrough.length; index += 1) {
+        const arg = passthrough[index];
+        if (arg === '--queue-path') options.queuePath = passthrough[++index];
+        else if (arg === '--state-path') options.statePath = passthrough[++index];
+        else if (arg === '--lock-dir') options.lockDir = passthrough[++index];
+        else if (arg === '--max-records') options.maxRecords = Number(passthrough[++index]);
+        else if (arg === '--dry-run') options.dryRun = true;
+        else if (arg === '--quiet') options.quiet = true;
+      }
+      return drainOwnerAirtableSyncQueue(options);
+    }).then((result) => {
+      if (!args.includes('--quiet') || result.drained || result.consumed || result.skipped) {
+        console.log(JSON.stringify(result, null, 2));
+      }
+      process.exit(0);
+    }).catch((err) => {
+      console.error(`I couldn't drain owner Airtable sync queue: ${err && err.message ? err.message : err}`);
+      process.exit(1);
+    });
+  } else if (subCommand === 'action-ledger-replay') {
+    import('../dist/aria-connector/src/action-ledger-core.js').then(({ replayActionLedgerPublishOutbox }) => {
+      const options = {};
+      const passthrough = args.slice(1);
+      for (let index = 0; index < passthrough.length; index += 1) {
+        const arg = passthrough[index];
+        if (arg === '--project-id') options.projectId = passthrough[++index];
+        else if (arg === '--task-id') options.taskId = passthrough[++index];
+        else if (arg === '--session-id') options.sessionId = passthrough[++index];
+        else if (arg === '--home') options.home = passthrough[++index];
+        else if (arg === '--limit') options.limit = Number(passthrough[++index]);
+        else if (arg === '--runtime-url') options.runtimeUrl = passthrough[++index];
+      }
+      if (!options.projectId) {
+        throw new Error('Missing --project-id. Use owner sheets-export to list ActionLedger project ids.');
+      }
+      return replayActionLedgerPublishOutbox(options);
+    }).then((result) => {
+      console.log(JSON.stringify(result, null, 2));
+      process.exit(result.remaining === 0 && result.failures.length === 0 ? 0 : 2);
+    }).catch((err) => {
+      console.error(`I couldn't replay action ledger outbox: ${err && err.message ? err.message : err}`);
+      process.exit(1);
+    });
+  } else {
+    console.error(`Unknown owner subcommand: ${subCommand}`);
+    console.error('Run: aria owner --help');
+    process.exit(1);
+  }
 } else if (command === 'codebase-awareness') {
   const subCommand = args[0] || 'help';
   const service = 'aria-codebase-awareness.service';