ac-framework 1.9.6 → 1.9.8

package/src/commands/agents.js

@@ -1,7 +1,8 @@
 import { Command } from 'commander';
 import chalk from 'chalk';
+import inquirer from 'inquirer';
 import { existsSync } from 'node:fs';
-import { mkdir, writeFile } from 'node:fs/promises';
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
 import { readFileSync } from 'node:fs';
 import { dirname, resolve } from 'node:path';
 import {
@@ -9,8 +10,10 @@ import {
   COLLAB_SYSTEM_NAME,
   CURRENT_SESSION_FILE,
   DEFAULT_MAX_ROUNDS,
+  DEFAULT_SYNAPSE_MODEL,
   SESSION_ROOT_DIR,
 } from '../agents/constants.js';
+import { listOpenCodeModels, runOpenCodePrompt } from '../agents/opencode-client.js';
 import { runWorkerIteration } from '../agents/orchestrator.js';
 import {
   addUserMessage,
@@ -125,6 +128,55 @@ function printModelConfig(state) {
   }
 }
 
+function groupModelsByProvider(models) {
+  const grouped = new Map();
+  for (const model of models) {
+    const [provider, ...rest] = model.split('/');
+    if (!provider || rest.length === 0) continue;
+    const modelName = rest.join('/');
+    if (!grouped.has(provider)) grouped.set(provider, []);
+    grouped.get(provider).push(modelName);
+  }
+  for (const [provider, modelNames] of grouped.entries()) {
+    grouped.set(provider, [...new Set(modelNames)].sort((a, b) => a.localeCompare(b)));
+  }
+  return grouped;
+}
+
+function runSummary(state) {
+  const run = state.run || {};
+  const events = Array.isArray(run.events) ? run.events.length : 0;
+  return {
+    status: run.status || 'idle',
+    runId: run.runId || null,
+    currentRole: run.currentRole || null,
+    lastError: run.lastError || null,
+    events,
+  };
+}
+
+async function readSessionArtifact(sessionId, filename) {
+  const path = resolve(getSessionDir(sessionId), filename);
+  if (!existsSync(path)) return null;
+  return readFile(path, 'utf8');
+}
+
+async function preflightModel({ opencodeBin, model, cwd }) {
+  const selected = normalizeModelId(model) || DEFAULT_SYNAPSE_MODEL;
+  try {
+    await runOpenCodePrompt({
+      prompt: 'Reply with exactly: OK',
+      cwd,
+      model: selected,
+      binaryPath: opencodeBin,
+      timeoutMs: 45000,
+    });
+    return { ok: true, model: selected };
+  } catch (error) {
+    return { ok: false, model: selected, error: error.message };
+  }
+}
+
 export function agentsCommand() {
   const agents = new Command('agents')
     .description(`${COLLAB_SYSTEM_NAME} — collaborative multi-agent system powered by OpenCode`);
@@ -276,6 +328,10 @@ export function agentsCommand() {
         if (!state.tmuxSessionName) {
           throw new Error('No tmux session registered for active collaborative session');
         }
+        const tmuxExists = await tmuxSessionExists(state.tmuxSessionName);
+        if (!tmuxExists) {
+          throw new Error(`tmux session ${state.tmuxSessionName} no longer exists. Run: acfm agents resume`);
+        }
         const args = ['attach'];
         if (opts.readonly) args.push('-r');
         args.push('-t', state.tmuxSessionName);
@@ -397,6 +453,52 @@ export function agentsCommand() {
     .command('model')
     .description('Manage default SynapseGrid model configuration');
 
+  model
+    .command('list')
+    .description('List available OpenCode models grouped by provider')
+    .option('--refresh', 'Refresh model cache from providers', false)
+    .option('--json', 'Output as JSON')
+    .action(async (opts) => {
+      try {
+        const opencodeBin = resolveCommandPath('opencode');
+        if (!opencodeBin) {
+          throw new Error('OpenCode binary not found. Run: acfm agents setup');
+        }
+
+        const models = await listOpenCodeModels({
+          binaryPath: opencodeBin,
+          refresh: Boolean(opts.refresh),
+        });
+        const grouped = groupModelsByProvider(models);
+        const providers = [...grouped.keys()].sort((a, b) => a.localeCompare(b));
+
+        const payload = {
+          count: models.length,
+          providers: providers.map((provider) => ({
+            provider,
+            models: grouped.get(provider).map((name) => `${provider}/${name}`),
+          })),
+        };
+
+        output(payload, opts.json);
+        if (!opts.json) {
+          console.log(chalk.bold('Available OpenCode models'));
+          console.log(chalk.dim(`Total: ${models.length}`));
+          for (const provider of providers) {
+            const providerModels = grouped.get(provider) || [];
+            console.log(chalk.cyan(`\n${provider}`));
+            for (const modelName of providerModels) {
+              console.log(chalk.dim(`- ${provider}/${modelName}`));
+            }
+          }
+        }
+      } catch (error) {
+        output({ error: error.message }, opts.json);
+        if (!opts.json) console.error(chalk.red(`Error: ${error.message}`));
+        process.exit(1);
+      }
+    });
+
   model
     .command('get')
     .description('Show configured default global/per-role models')
@@ -425,6 +527,114 @@ export function agentsCommand() {
       }
     });
 
+  model
+    .command('choose')
+    .description('Interactively choose a default model by provider and role')
+    .option('--refresh', 'Refresh model cache from providers', false)
+    .option('--json', 'Output as JSON')
+    .action(async (opts) => {
+      try {
+        const opencodeBin = resolveCommandPath('opencode');
+        if (!opencodeBin) {
+          throw new Error('OpenCode binary not found. Run: acfm agents setup');
+        }
+
+        const models = await listOpenCodeModels({
+          binaryPath: opencodeBin,
+          refresh: Boolean(opts.refresh),
+        });
+        if (models.length === 0) {
+          throw new Error('No models returned by OpenCode. Run: opencode auth list, opencode models --refresh');
+        }
+
+        const grouped = groupModelsByProvider(models);
+        const providerChoices = [...grouped.keys()]
+          .sort((a, b) => a.localeCompare(b))
+          .map((provider) => ({
+            name: `${provider} (${(grouped.get(provider) || []).length})`,
+            value: provider,
+          }));
+
+        const { provider } = await inquirer.prompt([
+          {
+            type: 'list',
+            name: 'provider',
+            message: 'Select model provider',
+            choices: providerChoices,
+          },
+        ]);
+
+        const selectedProviderModels = grouped.get(provider) || [];
+        const { modelName } = await inquirer.prompt([
+          {
+            type: 'list',
+            name: 'modelName',
+            message: `Select model from ${provider}`,
+            pageSize: 20,
+            choices: selectedProviderModels.map((name) => ({ name, value: name })),
+          },
+        ]);
+
+        const roleChoices = [
+          { name: 'Global fallback (all roles)', value: 'all' },
+          ...COLLAB_ROLES.map((role) => ({ name: `Role: ${role}`, value: role })),
+        ];
+        const { role } = await inquirer.prompt([
+          {
+            type: 'list',
+            name: 'role',
+            message: 'Apply model to',
+            choices: roleChoices,
+          },
+        ]);
+
+        const modelId = `${provider}/${modelName}`;
+        const updated = await updateAgentsConfig((current) => {
+          const next = {
+            agents: {
+              defaultModel: current.agents.defaultModel,
+              defaultRoleModels: { ...current.agents.defaultRoleModels },
+            },
+          };
+
+          if (role === 'all') {
+            next.agents.defaultModel = modelId;
+          } else {
+            next.agents.defaultRoleModels = {
+              ...next.agents.defaultRoleModels,
+              [role]: modelId,
+            };
+          }
+
+          return next;
+        });
+
+        const payload = {
+          success: true,
+          selected: {
+            role,
+            provider,
+            model: modelId,
+          },
+          configPath: getAgentsConfigPath(),
+          defaultModel: updated.agents.defaultModel,
+          defaultRoleModels: updated.agents.defaultRoleModels,
+        };
+
+        output(payload, opts.json);
+        if (!opts.json) {
+          console.log(chalk.green('✓ SynapseGrid model selected and saved'));
+          console.log(chalk.dim(`  Target: ${role === 'all' ? 'global fallback' : `role ${role}`}`));
+          console.log(chalk.dim(`  Model: ${modelId}`));
+          console.log(chalk.dim(`  Config: ${payload.configPath}`));
+        }
+      } catch (error) {
+        output({ error: error.message }, opts.json);
+        if (!opts.json) console.error(chalk.red(`Error: ${error.message}`));
+        process.exit(1);
+      }
+    });
+
   model
     .command('set <modelId>')
     .description('Set default model globally or for a specific role')
@@ -495,7 +705,7 @@ export function agentsCommand() {
             },
           };
           if (role === 'all') {
-            next.agents.defaultModel = null;
+            next.agents.defaultModel = DEFAULT_SYNAPSE_MODEL;
             next.agents.defaultRoleModels = {};
           } else {
             const currentRoles = { ...next.agents.defaultRoleModels };
@@ -523,6 +733,83 @@ export function agentsCommand() {
       }
     });
 
+  agents
+    .command('transcript')
+    .description('Show collaborative transcript (optionally filtered by role)')
+    .option('--session <id>', 'Session ID (defaults to current)')
+    .option('--role <role>', 'Role filter (planner|critic|coder|reviewer|all)', 'all')
+    .option('--limit <n>', 'Max messages to display', '40')
+    .option('--json', 'Output as JSON')
+    .action(async (opts) => {
+      try {
+        const sessionId = opts.session || await ensureSessionId(true);
+        const role = String(opts.role || 'all');
+        const limit = Number.parseInt(opts.limit, 10);
+        if (!Number.isInteger(limit) || limit <= 0) {
+          throw new Error('--limit must be a positive integer');
+        }
+        if (role !== 'all' && !COLLAB_ROLES.includes(role)) {
+          throw new Error('--role must be planner|critic|coder|reviewer|all');
+        }
+
+        const transcript = await loadTranscript(sessionId);
+        const filtered = transcript
+          .filter((msg) => role === 'all' || msg.from === role)
+          .slice(-limit);
+
+        output({ sessionId, count: filtered.length, transcript: filtered }, opts.json);
+        if (!opts.json) {
+          console.log(chalk.bold(`SynapseGrid transcript (${filtered.length})`));
+          for (const msg of filtered) {
+            console.log(chalk.cyan(`\n[${msg.from}] ${msg.timestamp || ''}`));
+            console.log(String(msg.content || '').trim() || chalk.dim('(empty)'));
+          }
+        }
+      } catch (error) {
+        output({ error: error.message }, opts.json);
+        if (!opts.json) console.error(chalk.red(`Error: ${error.message}`));
+        process.exit(1);
+      }
+    });
+
+  agents
+    .command('summary')
+    .description('Show meeting summary generated from collaborative run')
+    .option('--session <id>', 'Session ID (defaults to current)')
+    .option('--json', 'Output as JSON')
+    .action(async (opts) => {
+      try {
+        const sessionId = opts.session || await ensureSessionId(true);
+        const state = await loadSessionState(sessionId);
+        const summaryFile = await readSessionArtifact(sessionId, 'meeting-summary.md');
+        const meetingLogFile = await readSessionArtifact(sessionId, 'meeting-log.md');
+        const payload = {
+          sessionId,
+          status: state.status,
+          finalSummary: state.run?.finalSummary || null,
+          sharedContext: state.run?.sharedContext || null,
+          summaryFile,
+          meetingLogFile,
+        };
+
+        output(payload, opts.json);
+        if (!opts.json) {
+          console.log(chalk.bold('SynapseGrid meeting summary'));
+          if (summaryFile) {
+            process.stdout.write(summaryFile.endsWith('\n') ? summaryFile : `${summaryFile}\n`);
+          } else if (payload.finalSummary) {
+            process.stdout.write(`${payload.finalSummary}\n`);
+          } else {
+            console.log(chalk.dim('No summary generated yet.'));
+          }
+        }
+      } catch (error) {
+        output({ error: error.message }, opts.json);
+        if (!opts.json) console.error(chalk.red(`Error: ${error.message}`));
+        process.exit(1);
+      }
+    });
+
   agents
     .command('export')
     .description('Export collaborative transcript')
@@ -540,9 +827,11 @@ export function agentsCommand() {
           throw new Error('--format must be md or json');
         }
 
+        const meetingSummary = await readSessionArtifact(sessionId, 'meeting-summary.md');
+        const meetingLog = await readSessionArtifact(sessionId, 'meeting-log.md');
         const payload = format === 'json'
-          ? JSON.stringify({ state, transcript }, null, 2) + '\n'
-          : toMarkdownTranscript(state, transcript) + '\n';
+          ? JSON.stringify({ state, transcript, meetingSummary, meetingLog }, null, 2) + '\n'
+          : `${toMarkdownTranscript(state, transcript)}\n\n## Meeting Summary\n\n${meetingSummary || state.run?.finalSummary || 'No summary generated yet.'}\n\n## Meeting Log\n\n${meetingLog || 'No meeting log generated yet.'}\n`;
 
         if (opts.out) {
           const outputPath = resolve(opts.out);
@@ -611,7 +900,22 @@ export function agentsCommand() {
           ...defaultRoleModels,
           ...cliRoleModels,
         };
-        const globalModel = cliModel || config.agents.defaultModel || null;
+        const globalModel = cliModel || config.agents.defaultModel || DEFAULT_SYNAPSE_MODEL;
+
+        const modelsToCheck = new Set([globalModel, ...Object.values(roleModels)]);
+        for (const modelToCheck of modelsToCheck) {
+          const preflight = await preflightModel({
+            opencodeBin,
+            model: modelToCheck,
+            cwd: resolve(opts.cwd),
+          });
+          if (!preflight.ok) {
+            throw new Error(
+              `Model preflight failed for ${preflight.model}: ${preflight.error}. ` +
+              'Check OpenCode auth/providers with: opencode auth list, opencode models'
+            );
+          }
+        }
 
         const state = await createSession(opts.task, {
           roles: COLLAB_ROLES,
@@ -686,6 +990,11 @@ export function agentsCommand() {
           console.log(chalk.dim(`Round: ${Math.min(state.round, state.maxRounds)}/${state.maxRounds}`));
           console.log(chalk.dim(`Active agent: ${state.activeAgent || 'none'}`));
           console.log(chalk.dim(`Messages: ${state.messages.length}`));
+          const summary = runSummary(state);
+          console.log(chalk.dim(`Run: ${summary.status}${summary.currentRole ? ` (role=${summary.currentRole})` : ''}, events=${summary.events}`));
+          if (summary.lastError?.message) {
+            console.log(chalk.dim(`Run error: ${summary.lastError.message}`));
+          }
           console.log(chalk.dim(`Global model: ${state.model || '(opencode default)'}`));
           for (const role of COLLAB_ROLES) {
             const configured = state.roleModels?.[role] || '-';
@@ -712,6 +1021,21 @@ export function agentsCommand() {
         const sessionId = await ensureSessionId(true);
         let state = await loadSessionState(sessionId);
         state = await stopSession(state, 'stopped');
+        if (state.run && state.run.status === 'running') {
+          state = await saveSessionState({
+            ...state,
+            run: {
+              ...state.run,
+              status: 'cancelled',
+              finishedAt: new Date().toISOString(),
+              currentRole: null,
+              lastError: {
+                code: 'RUN_CANCELLED',
+                message: 'Run cancelled by user',
+              },
+            },
+          });
+        }
         if (state.tmuxSessionName && hasCommand('tmux')) {
           try {
             await runTmux('tmux', ['kill-session', '-t', state.tmuxSessionName]);
@@ -728,6 +1052,33 @@ export function agentsCommand() {
       }
     });
 
+  agents
+    .command('autopilot')
+    .description('Internal headless collaborative driver (non-tmux)')
+    .requiredOption('--session <id>', 'Session id')
+    .option('--poll-ms <n>', 'Polling interval in ms', '900')
+    .action(async (opts) => {
+      const pollMs = Number.parseInt(opts.pollMs, 10);
+      while (true) {
+        try {
+          const state = await loadSessionState(opts.session);
+          if (state.status !== 'running') process.exit(0);
+
+          for (const role of state.roles || COLLAB_ROLES) {
+            await runWorkerIteration(opts.session, role, {
+              cwd: state.workingDirectory || process.cwd(),
+              model: state.model || null,
+              opencodeBin: state.opencodeBin || resolveCommandPath('opencode') || undefined,
+              timeoutMs: state.run?.policy?.timeoutPerRoleMs || 180000,
+            });
+          }
+        } catch (error) {
+          console.error(`[autopilot] ${error.message}`);
+        }
+        await new Promise((resolvePromise) => setTimeout(resolvePromise, Number.isInteger(pollMs) ? pollMs : 900));
+      }
+    });
+
   agents
     .command('worker')
     .description('Internal worker loop for a single collaborative role')
@@ -749,6 +1100,7 @@ export function agentsCommand() {
 
       while (true) {
         try {
+          console.log(`[${role}] polling session ${opts.session}`);
           const state = await loadSessionState(opts.session);
           if (!state.roles.includes(role)) {
             console.log(`[${role}] role not configured in session. exiting.`);
@@ -759,14 +1111,20 @@ export function agentsCommand() {
             process.exit(0);
           }
 
+          if (state.activeAgent === role) {
+            console.log(`[${role}] executing turn with model=${state.roleModels?.[role] || state.model || DEFAULT_SYNAPSE_MODEL}`);
+          }
           const nextState = await runWorkerIteration(opts.session, role, {
             cwd: state.workingDirectory || process.cwd(),
             model: state.model || null,
             opencodeBin: state.opencodeBin || resolveCommandPath('opencode') || undefined,
+            timeoutMs: 180000,
           });
           const latest = nextState.messages[nextState.messages.length - 1];
           if (latest?.from === role) {
             console.log(`[${role}] message emitted (${latest.content.length} chars)`);
+          } else if (nextState.activeAgent && nextState.activeAgent !== role) {
+            console.log(`[${role}] waiting for active role=${nextState.activeAgent}`);
           }
         } catch (error) {
           console.error(`[${role}] loop error: ${error.message}`);
@@ -776,5 +1134,50 @@ export function agentsCommand() {
       }
     });
 
+  agents
+    .command('doctor')
+    .description('Run diagnostics for SynapseGrid/OpenCode runtime')
+    .option('--json', 'Output as JSON')
+    .action(async (opts) => {
+      try {
+        const opencodeBin = resolveCommandPath('opencode');
+        const tmuxInstalled = hasCommand('tmux');
+        const cfg = await loadAgentsConfig();
+        const defaultModel = cfg.agents.defaultModel || DEFAULT_SYNAPSE_MODEL;
+        const result = {
+          opencodeBin,
+          tmuxInstalled,
+          defaultModel,
+          defaultRoleModels: cfg.agents.defaultRoleModels,
+          preflight: null,
+        };
+
+        if (opencodeBin) {
+          result.preflight = await preflightModel({
+            opencodeBin,
+            model: defaultModel,
+            cwd: process.cwd(),
+          });
+        } else {
+          result.preflight = { ok: false, error: 'OpenCode binary not found' };
+        }
+
+        output(result, opts.json);
+        if (!opts.json) {
+          console.log(chalk.bold('SynapseGrid doctor'));
+          console.log(chalk.dim(`opencode: ${opencodeBin || 'not found'}`));
+          console.log(chalk.dim(`tmux: ${tmuxInstalled ? 'installed' : 'not installed'}`));
+          console.log(chalk.dim(`default model: ${defaultModel}`));
+          console.log(chalk.dim(`preflight: ${result.preflight?.ok ? 'ok' : `failed - ${result.preflight?.error || 'unknown error'}`}`));
+        }
+
+        if (!result.preflight?.ok) process.exit(1);
+      } catch (error) {
+        output({ error: error.message }, opts.json);
+        if (!opts.json) console.error(chalk.red(`Error: ${error.message}`));
+        process.exit(1);
+      }
+    });
+
   return agents;
 }