ac-framework 1.9.3 → 1.9.5

package/src/commands/init.js

@@ -50,6 +50,8 @@ import {
   stepHeader,
   pulseDiamondIntro,
 } from '../ui/animations.js';
+import { COLLAB_SYSTEM_NAME } from '../agents/constants.js';
+import { ensureCollabDependencies, hasCommand } from '../services/dependency-installer.js';
 
 const acGradient = gradient(['#6C5CE7', '#00CEC9', '#0984E3']);
 
@@ -149,6 +151,108 @@ async function setupPersistentMemory() {
   console.log();
 }
 
+// ── Collaborative Agentic Setup ───────────────────────────────────
+
+async function setupCollaborativeSystem() {
+  const hasOpenCode = hasCommand('opencode');
+  const hasTmux = hasCommand('tmux');
+  const alreadyReady = hasOpenCode && hasTmux;
+
+  console.log();
+  await animatedSeparator(60);
+  console.log();
+
+  const badge = chalk.hex('#2D3436').bgHex('#00B894').bold(` ${COLLAB_SYSTEM_NAME} `);
+  console.log(`  ${badge} ${chalk.hex('#B2BEC3').bold('Collaborative Agent System')}`);
+  console.log();
+  console.log(
+    chalk.hex('#636E72')(
+      `  ${COLLAB_SYSTEM_NAME} launches a real-time collaborative agent war-room with\n` +
+      '  4 coordinated roles (planner, critic, coder, reviewer) in tmux panes.\n\n' +
+      '  Each round is turn-based with shared incremental context, so every\n' +
+      '  contribution from one agent is fed to the next, not isolated fan-out.\n\n' +
+      `  Dependencies: ${chalk.hex('#DFE6E9')('OpenCode')} + ${chalk.hex('#DFE6E9')('tmux')}`
+    )
+  );
+  console.log();
+
+  const { enableCollab } = await inquirer.prompt([{
+    type: 'confirm',
+    name: 'enableCollab',
+    message: chalk.hex('#B2BEC3')(`Enable ${COLLAB_SYSTEM_NAME} collaborative agents?`),
+    default: true,
+  }]);
+
+  if (!enableCollab) {
+    console.log();
+    console.log(chalk.hex('#636E72')(`  Skipped. Enable it later with: acfm agents setup`));
+    console.log();
+    return;
+  }
+
+  async function installCollabMcpConnections() {
+    console.log();
+    console.log(chalk.hex('#B2BEC3')(`  Connecting ${COLLAB_SYSTEM_NAME} MCP tools to detected assistants...`));
+    console.log();
+
+    const { detectAndInstallMCPs, ASSISTANTS, isAssistantInstalled } = await import('../services/mcp-installer.js');
+    const { installed, success } = detectAndInstallMCPs({ target: 'collab' });
+
+    if (installed === 0) {
+      console.log(chalk.hex('#636E72')('  No AI assistants detected yet.'));
+      console.log(chalk.hex('#636E72')('  Run ') + chalk.hex('#DFE6E9')('acfm agents install-mcps') + chalk.hex('#636E72')(' after installing an assistant.'));
+      console.log();
+      return;
+    }
+
+    for (const assistant of ASSISTANTS) {
+      if (isAssistantInstalled(assistant)) {
+        console.log(
+          chalk.hex('#00B894')('  ◆ ') +
+          chalk.hex('#DFE6E9').bold(assistant.name) +
+          chalk.hex('#636E72')(` · MCP config → ${assistant.configPath}`)
+        );
+      }
+    }
+
+    console.log();
+    const successBadge = chalk.hex('#2D3436').bgHex('#00B894').bold(` ${success}/${installed} `);
+    console.log(`  ${successBadge} ${chalk.hex('#B2BEC3')(`${COLLAB_SYSTEM_NAME} MCP connections installed`)}`);
+    console.log();
+  }
+
+  if (alreadyReady) {
+    console.log();
+    console.log(chalk.hex('#00B894')('  ◆ OpenCode and tmux are already available.'));
+    await installCollabMcpConnections();
+    console.log(chalk.hex('#636E72')('  Run `acfm agents start --task "..."` to launch collaboration.'));
+    console.log();
+    return;
+  }
+
+  console.log();
+  console.log(chalk.hex('#B2BEC3')(`  Installing ${COLLAB_SYSTEM_NAME} dependencies...`));
+  console.log();
+
+  const result = ensureCollabDependencies();
+
+  const oColor = result.opencode.success ? chalk.hex('#00B894') : chalk.hex('#D63031');
+  const tColor = result.tmux.success ? chalk.hex('#00B894') : chalk.hex('#D63031');
+  console.log(oColor(`  ◆ OpenCode: ${result.opencode.message}`));
+  console.log(tColor(`  ◆ tmux: ${result.tmux.message}`));
+  console.log();
+
+  if (result.success) {
+    await installCollabMcpConnections();
+    console.log(chalk.hex('#00B894').bold(`  ${COLLAB_SYSTEM_NAME} is active.`));
+    console.log(chalk.hex('#636E72')('  Run acfm agents start --task "..." to open the war-room.'));
+  } else {
+    console.log(chalk.hex('#FDCB6E')(`  ${COLLAB_SYSTEM_NAME} setup is partially complete.`));
+    console.log(chalk.hex('#636E72')('  Resolve dependency errors and run: acfm agents setup'));
+  }
+  console.log();
+}
+
 // ── Helpers ──────────────────────────────────────────────────────
 
 function buildChoices(folders) {
@@ -613,6 +717,7 @@ export async function initCommand(options = {}) {
       await saveTemplateSelection(targetDir, template);
       await celebrateSuccess(installed, targetDir);
       await setupPersistentMemory();
+      await setupCollaborativeSystem();
     } else {
       await showFailureSummary(installed, errors);
     }

package/src/mcp/collab-server.js

@@ -0,0 +1,198 @@
+#!/usr/bin/env node
+
+/**
+ * MCP Server for AC Framework SynapseGrid Collaboration System
+ * Exposes collaborative multi-agent session controls via MCP.
+ */
+
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { z } from 'zod';
+import { COLLAB_ROLES } from '../agents/constants.js';
+import { runWorkerIteration } from '../agents/orchestrator.js';
+import {
+  addUserMessage,
+  createSession,
+  loadCurrentSessionId,
+  loadSessionState,
+  loadTranscript,
+  saveSessionState,
+  setCurrentSession,
+  stopSession,
+} from '../agents/state-store.js';
+
+class MCPCollabServer {
+  constructor() {
+    this.server = new McpServer({
+      name: 'ac-framework-collab',
+      version: '1.0.0',
+    });
+
+    this.setupTools();
+  }
+
+  setupTools() {
+    this.server.tool(
+      'collab_start_session',
+      'Start a SynapseGrid collaborative session',
+      {
+        task: z.string().describe('Initial collaborative task'),
+        maxRounds: z.number().int().positive().default(3).describe('Maximum collaboration rounds'),
+        model: z.string().optional().describe('Model id (provider/model) for opencode run'),
+      },
+      async ({ task, maxRounds, model }) => {
+        try {
+          const state = await createSession(task, {
+            roles: COLLAB_ROLES,
+            maxRounds,
+            model: model || null,
+            workingDirectory: process.cwd(),
+          });
+          await setCurrentSession(state.sessionId);
+          return {
+            content: [{
+              type: 'text',
+              text: JSON.stringify({ success: true, sessionId: state.sessionId, status: state.status }, null, 2),
+            }],
+          };
+        } catch (error) {
+          return { content: [{ type: 'text', text: JSON.stringify({ error: error.message }) }], isError: true };
+        }
+      }
+    );
+
+    this.server.tool(
+      'collab_send_message',
+      'Send a user message to the active collaborative session',
+      {
+        message: z.string().describe('User message to add to shared context'),
+        sessionId: z.string().optional().describe('Session ID (defaults to current session)'),
+      },
+      async ({ message, sessionId }) => {
+        try {
+          const id = sessionId || await loadCurrentSessionId();
+          if (!id) {
+            throw new Error('No active session found');
+          }
+          let state = await loadSessionState(id);
+          state = await addUserMessage(state, message);
+          state = await saveSessionState(state);
+          return {
+            content: [{
+              type: 'text',
+              text: JSON.stringify({ success: true, sessionId: id, messages: state.messages.length }, null, 2),
+            }],
+          };
+        } catch (error) {
+          return { content: [{ type: 'text', text: JSON.stringify({ error: error.message }) }], isError: true };
+        }
+      }
+    );
+
+    this.server.tool(
+      'collab_step',
+      'Execute one collaborative worker turn by role',
+      {
+        role: z.enum(COLLAB_ROLES).describe('Role to execute for one step'),
+        sessionId: z.string().optional().describe('Session ID (defaults to current session)'),
+      },
+      async ({ role, sessionId }) => {
+        try {
+          const id = sessionId || await loadCurrentSessionId();
+          if (!id) {
+            throw new Error('No active session found');
+          }
+
+          const state = await runWorkerIteration(id, role, {
+            cwd: process.cwd(),
+          });
+
+          return {
+            content: [{
+              type: 'text',
+              text: JSON.stringify({
+                success: true,
+                sessionId: id,
+                status: state.status,
+                round: state.round,
+                activeAgent: state.activeAgent,
+                messageCount: state.messages.length,
+              }, null, 2),
+            }],
+          };
+        } catch (error) {
+          return { content: [{ type: 'text', text: JSON.stringify({ error: error.message }) }], isError: true };
+        }
+      }
+    );
+
+    this.server.tool(
+      'collab_status',
+      'Get current collaborative session state',
+      {
+        sessionId: z.string().optional().describe('Session ID (defaults to current session)'),
+        includeTranscript: z.boolean().default(false).describe('Include transcript JSONL messages'),
+      },
+      async ({ sessionId, includeTranscript }) => {
+        try {
+          const id = sessionId || await loadCurrentSessionId();
+          if (!id) {
+            throw new Error('No active session found');
+          }
+          const state = await loadSessionState(id);
+          const transcript = includeTranscript ? await loadTranscript(id) : undefined;
+          return {
+            content: [{
+              type: 'text',
+              text: JSON.stringify({ state, transcript }, null, 2),
+            }],
+          };
+        } catch (error) {
+          return { content: [{ type: 'text', text: JSON.stringify({ error: error.message }) }], isError: true };
+        }
+      }
+    );
+
+    this.server.tool(
+      'collab_stop_session',
+      'Stop current collaborative session',
+      {
+        sessionId: z.string().optional().describe('Session ID (defaults to current session)'),
+      },
+      async ({ sessionId }) => {
+        try {
+          const id = sessionId || await loadCurrentSessionId();
+          if (!id) {
+            throw new Error('No active session found');
+          }
+          const state = await loadSessionState(id);
+          const updated = await stopSession(state, 'stopped');
+          return {
+            content: [{
+              type: 'text',
+              text: JSON.stringify({ success: true, sessionId: id, status: updated.status }, null, 2),
+            }],
+          };
+        } catch (error) {
+          return { content: [{ type: 'text', text: JSON.stringify({ error: error.message }) }], isError: true };
+        }
+      }
+    );
+  }
+
+  async run() {
+    const transport = new StdioServerTransport();
+    await this.server.connect(transport);
+    console.error('AC Framework SynapseGrid MCP Server running on stdio');
+  }
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+  const server = new MCPCollabServer();
+  server.run().catch((error) => {
+    console.error('Failed to start SynapseGrid MCP server:', error);
+    process.exit(1);
+  });
+}
+
+export default MCPCollabServer;

package/src/services/dependency-installer.js

@@ -0,0 +1,98 @@
+import { spawnSync } from 'node:child_process';
+import { platform } from 'node:os';
+
+function run(command, args, options = {}) {
+  return spawnSync(command, args, {
+    stdio: options.stdio || 'pipe',
+    env: process.env,
+    ...options,
+  });
+}
+
+export function hasCommand(command) {
+  const locator = platform() === 'win32' ? 'where' : 'which';
+  const result = run(locator, [command]);
+  return result.status === 0;
+}
+
+export function installOpenCode() {
+  if (hasCommand('opencode')) {
+    return { success: true, installed: false, message: 'OpenCode already installed' };
+  }
+
+  if (platform() === 'win32') {
+    return {
+      success: false,
+      installed: false,
+      message: 'Automatic OpenCode installation is not supported on Windows in this flow',
+    };
+  }
+
+  const result = run('bash', ['-lc', 'curl -fsSL https://opencode.ai/install | bash'], { stdio: 'inherit' });
+  if (result.status !== 0) {
+    return { success: false, installed: false, message: 'Failed to install OpenCode using installer script' };
+  }
+
+  return {
+    success: hasCommand('opencode'),
+    installed: true,
+    message: hasCommand('opencode')
+      ? 'OpenCode installed successfully'
+      : 'OpenCode installer finished but binary is not available in PATH yet',
+  };
+}
+
+function resolveTmuxInstallCommand() {
+  if (platform() === 'darwin') {
+    if (hasCommand('brew')) return 'brew install tmux';
+    return null;
+  }
+
+  if (platform() === 'linux') {
+    if (hasCommand('apt-get')) return 'sudo apt-get update && sudo apt-get install -y tmux';
+    if (hasCommand('dnf')) return 'sudo dnf install -y tmux';
+    if (hasCommand('yum')) return 'sudo yum install -y tmux';
+    if (hasCommand('pacman')) return 'sudo pacman -S --noconfirm tmux';
+    if (hasCommand('zypper')) return 'sudo zypper --non-interactive install tmux';
+  }
+
+  return null;
+}
+
+export function installTmux() {
+  if (hasCommand('tmux')) {
+    return { success: true, installed: false, message: 'tmux already installed' };
+  }
+
+  const installCommand = resolveTmuxInstallCommand();
+  if (!installCommand) {
+    return {
+      success: false,
+      installed: false,
+      message: 'No supported package manager detected for automatic tmux installation',
+    };
+  }
+
+  const result = run('bash', ['-lc', installCommand], { stdio: 'inherit' });
+  if (result.status !== 0) {
+    return { success: false, installed: false, message: 'tmux installation command failed' };
+  }
+
+  return {
+    success: hasCommand('tmux'),
+    installed: true,
+    message: hasCommand('tmux')
+      ? 'tmux installed successfully'
+      : 'tmux installer finished but binary is not available in PATH yet',
+  };
+}
+
+export function ensureCollabDependencies() {
+  const opencode = installOpenCode();
+  const tmux = installTmux();
+  return {
+    opencode,
+    tmux,
+    success: opencode.success && tmux.success,
+  };
+}