@soleri/cli 1.12.5 → 8.0.0

package/src/commands/dev.ts

@@ -1,4 +1,6 @@
 import { spawn } from 'node:child_process';
+import { watch, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
 import type { Command } from 'commander';
 import * as p from '@clack/prompts';
 import { detectAgent } from '../utils/agent-context.js';
@@ -14,26 +16,120 @@ export function registerDev(program: Command): void {
         process.exit(1);
       }
 
-      p.log.info(`Starting ${ctx.agentId} in dev mode...`);
+      if (ctx.format === 'filetree') {
+        // v7: File-tree agent — watch files and regenerate CLAUDE.md
+        runFileTreeDev(ctx.agentPath, ctx.agentId);
+      } else {
+        // Legacy: TypeScript agent — run via tsx
+        runLegacyDev(ctx.agentPath, ctx.agentId);
+      }
+    });
+}
 
-      const child = spawn('npx', ['tsx', 'src/index.ts'], {
-        cwd: ctx.agentPath,
-        stdio: 'inherit',
-        env: { ...process.env },
-      });
+function runFileTreeDev(agentPath: string, agentId: string): void {
+  p.log.info(`Starting ${agentId} in file-tree dev mode...`);
+  p.log.info('Starting Knowledge Engine + watching for file changes.');
+  p.log.info('CLAUDE.md will be regenerated automatically on changes.');
+  p.log.info('Press Ctrl+C to stop.\n');
 
-      child.on('error', (err) => {
-        p.log.error(`Failed to start: ${err.message}`);
-        p.log.info('Make sure tsx is available: npm install -g tsx');
-        process.exit(1);
-      });
+  regenerateClaudeMd(agentPath);
+
+  // Start the engine server
+  const engineBin = require.resolve('@soleri/core/dist/engine/bin/soleri-engine.js');
+  const engine = spawn('node', [engineBin, '--agent', join(agentPath, 'agent.yaml')], {
+    stdio: ['pipe', 'inherit', 'inherit'],
+    env: { ...process.env },
+  });
+
+  engine.on('error', (err) => {
+    p.log.error(`Engine failed to start: ${err.message}`);
+    p.log.info('Make sure @soleri/core is built: cd packages/core && npm run build');
+  });
+
+  // Watch directories for changes
+  const watchPaths = [
+    join(agentPath, 'agent.yaml'),
+    join(agentPath, 'instructions'),
+    join(agentPath, 'workflows'),
+    join(agentPath, 'skills'),
+  ];
+
+  let debounceTimer: ReturnType<typeof setTimeout> | null = null;
+
+  for (const watchPath of watchPaths) {
+    try {
+      watch(watchPath, { recursive: true }, (_event, filename) => {
+        // Ignore CLAUDE.md changes (we generate it)
+        if (filename === 'CLAUDE.md' || filename === 'AGENTS.md') return;
+        // Ignore _engine.md changes (we generate it)
+        if (filename === '_engine.md') return;
 
-      child.on('exit', (code, signal) => {
-        if (signal) {
-          p.log.warn(`Process terminated by signal ${signal}`);
-          process.exit(1);
-        }
-        process.exit(code ?? 0);
+        // Debounce — regenerate at most once per 200ms
+        if (debounceTimer) clearTimeout(debounceTimer);
+        debounceTimer = setTimeout(() => {
+          const changedFile = filename ? ` (${filename})` : '';
+          p.log.info(`Change detected${changedFile} — regenerating CLAUDE.md`);
+          regenerateClaudeMd(agentPath);
+        }, 200);
       });
-    });
+    } catch {
+      // Directory may not exist yet — that's OK
+    }
+  }
+
+  // Graceful shutdown — kill engine too
+  const shutdown = () => {
+    p.log.info('\nStopping dev mode...');
+    engine.kill();
+    process.exit(0);
+  };
+
+  process.on('SIGINT', shutdown);
+  process.on('SIGTERM', shutdown);
+
+  engine.on('exit', (code) => {
+    if (code !== 0 && code !== null) {
+      p.log.error(`Engine exited with code ${code}`);
+      process.exit(1);
+    }
+  });
+}
+
+function regenerateClaudeMd(agentPath: string): void {
+  try {
+    // Dynamic import to avoid loading forge at CLI startup
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const { composeClaudeMd } = require('@soleri/forge/lib');
+    const { content } = composeClaudeMd(agentPath);
+    writeFileSync(join(agentPath, 'CLAUDE.md'), content, 'utf-8');
+    p.log.success('CLAUDE.md regenerated');
+  } catch (err) {
+    p.log.error(
+      `Failed to regenerate CLAUDE.md: ${err instanceof Error ? err.message : String(err)}`,
+    );
+  }
+}
+
+function runLegacyDev(agentPath: string, agentId: string): void {
+  p.log.info(`Starting ${agentId} in dev mode...`);
+
+  const child = spawn('npx', ['tsx', 'src/index.ts'], {
+    cwd: agentPath,
+    stdio: 'inherit',
+    env: { ...process.env },
+  });
+
+  child.on('error', (err) => {
+    p.log.error(`Failed to start: ${err.message}`);
+    p.log.info('Make sure tsx is available: npm install -g tsx');
+    process.exit(1);
+  });
+
+  child.on('exit', (code, signal) => {
+    if (signal) {
+      p.log.warn(`Process terminated by signal ${signal}`);
+      process.exit(1);
+    }
+    process.exit(code ?? 0);
+  });
 }

package/src/commands/install.ts

@@ -5,9 +5,28 @@ import { homedir } from 'node:os';
 import * as p from '@clack/prompts';
 import { detectAgent } from '../utils/agent-context.js';
 
-type Target = 'claude' | 'codex' | 'both';
+type Target = 'claude' | 'codex' | 'opencode' | 'both' | 'all';
 
-function installClaude(agentId: string, agentDir: string): void {
+/** MCP server entry for file-tree agents (uses npx @soleri/engine) */
+function fileTreeMcpEntry(agentDir: string): Record<string, unknown> {
+  return {
+    type: 'stdio',
+    command: 'npx',
+    args: ['@soleri/engine', '--agent', join(agentDir, 'agent.yaml')],
+  };
+}
+
+/** MCP server entry for legacy TypeScript agents (uses node dist/index.js) */
+function legacyMcpEntry(agentDir: string): Record<string, unknown> {
+  return {
+    type: 'stdio',
+    command: 'node',
+    args: [join(agentDir, 'dist', 'index.js')],
+    env: {},
+  };
+}
+
+function installClaude(agentId: string, agentDir: string, isFileTree: boolean): void {
   const configPath = join(homedir(), '.claude.json');
   let config: Record<string, unknown> = {};
 
@@ -24,18 +43,15 @@ function installClaude(agentId: string, agentDir: string): void {
     config.mcpServers = {};
   }
 
-  (config.mcpServers as Record<string, unknown>)[agentId] = {
-    type: 'stdio',
-    command: 'node',
-    args: [join(agentDir, 'dist', 'index.js')],
-    env: {},
-  };
+  (config.mcpServers as Record<string, unknown>)[agentId] = isFileTree
+    ? fileTreeMcpEntry(agentDir)
+    : legacyMcpEntry(agentDir);
 
   writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n', 'utf-8');
   p.log.success(`Registered ${agentId} in ~/.claude.json`);
 }
 
-function installCodex(agentId: string, agentDir: string): void {
+function installCodex(agentId: string, agentDir: string, isFileTree: boolean): void {
   const codexDir = join(homedir(), '.codex');
   const configPath = join(codexDir, 'config.toml');
 
@@ -53,8 +69,14 @@ function installCodex(agentId: string, agentDir: string): void {
   const sectionRegex = new RegExp(`\\[mcp_servers\\.${escapeRegExp(agentId)}\\][^\\[]*`, 's');
   content = content.replace(sectionRegex, '').trim();
 
-  const entryPoint = join(agentDir, 'dist', 'index.js');
-  const section = `\n\n${sectionHeader}\ncommand = "node"\nargs = ["${entryPoint}"]\n`;
+  let section: string;
+  if (isFileTree) {
+    const agentYamlPath = join(agentDir, 'agent.yaml');
+    section = `\n\n${sectionHeader}\ncommand = "npx"\nargs = ["@soleri/engine", "--agent", "${agentYamlPath}"]\n`;
+  } else {
+    const entryPoint = join(agentDir, 'dist', 'index.js');
+    section = `\n\n${sectionHeader}\ncommand = "node"\nargs = ["${entryPoint}"]\n`;
+  }
 
   content = content + section;
 
@@ -62,15 +84,98 @@ function installCodex(agentId: string, agentDir: string): void {
   p.log.success(`Registered ${agentId} in ~/.codex/config.toml`);
 }
 
+function installOpencode(agentId: string, agentDir: string, isFileTree: boolean): void {
+  // OpenCode uses ~/.config/opencode/opencode.json (not ~/.opencode.json)
+  // Config uses "mcp" (not "mcpServers"), type "local" (not "stdio"), command as array
+  const configDir = join(homedir(), '.config', 'opencode');
+  const configPath = join(configDir, 'opencode.json');
+
+  if (!existsSync(configDir)) {
+    mkdirSync(configDir, { recursive: true });
+  }
+
+  let config: Record<string, unknown> = {};
+  if (existsSync(configPath)) {
+    try {
+      const raw = readFileSync(configPath, 'utf-8');
+      const stripped = raw.replace(/^\s*\/\/.*$/gm, '');
+      config = JSON.parse(stripped);
+    } catch {
+      config = {};
+    }
+  }
+
+  if (!config.mcp || typeof config.mcp !== 'object') {
+    config.mcp = {};
+  }
+
+  const servers = config.mcp as Record<string, unknown>;
+  if (isFileTree) {
+    servers[agentId] = {
+      type: 'local',
+      command: [
+        'node',
+        join(
+          agentDir,
+          '..',
+          'soleri',
+          'packages',
+          'core',
+          'dist',
+          'engine',
+          'bin',
+          'soleri-engine.js',
+        ),
+        '--agent',
+        join(agentDir, 'agent.yaml'),
+      ],
+    };
+  } else {
+    servers[agentId] = {
+      type: 'local',
+      command: ['node', join(agentDir, 'dist', 'index.js')],
+    };
+  }
+
+  writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n', 'utf-8');
+  p.log.success(`Registered ${agentId} in ~/.config/opencode/opencode.json`);
+}
+
 function escapeRegExp(s: string): string {
   return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }
 
+/**
+ * Create a global launcher script so the agent can be invoked by name from any directory.
+ * e.g., typing `ernesto` opens Claude Code with that agent's MCP config.
+ */
+function installLauncher(agentId: string, agentDir: string): void {
+  const binPath = join('/usr/local/bin', agentId);
+
+  const script = [
+    '#!/bin/bash',
+    `# ${agentId} — Soleri second brain launcher`,
+    `# Type "${agentId}" from any directory to open Claude Code with this agent`,
+    `exec claude --mcp-config ${join(agentDir, '.mcp.json')}`,
+    '',
+  ].join('\n');
+
+  try {
+    writeFileSync(binPath, script, { mode: 0o755 });
+    p.log.success(`Launcher created: type "${agentId}" from any directory to start`);
+  } catch {
+    p.log.warn(`Could not create launcher at ${binPath} (may need sudo)`);
+    p.log.info(
+      `To create manually: sudo bash -c 'cat > ${binPath} << "EOF"\\n#!/bin/bash\\nexec claude --mcp-config ${join(agentDir, '.mcp.json')}\\nEOF' && chmod +x ${binPath}`,
+    );
+  }
+}
+
 export function registerInstall(program: Command): void {
   program
     .command('install')
     .argument('[dir]', 'Agent directory (defaults to cwd)')
-    .option('--target <target>', 'Registration target: claude, codex, or both', 'claude')
+    .option('--target <target>', 'Registration target: claude, opencode, codex, or all', 'claude')
     .description('Register agent as MCP server in editor config')
     .action(async (dir?: string, opts?: { target?: string }) => {
       const resolvedDir = dir ? resolve(dir) : undefined;
@@ -82,20 +187,33 @@ export function registerInstall(program: Command): void {
       }
 
       const target = (opts?.target ?? 'claude') as Target;
+      const validTargets: Target[] = ['claude', 'codex', 'opencode', 'both', 'all'];
+      const isFileTree = ctx.format === 'filetree';
 
-      if (target !== 'claude' && target !== 'codex' && target !== 'both') {
-        p.log.error(`Invalid target "${target}". Use: claude, codex, or both`);
+      if (!validTargets.includes(target)) {
+        p.log.error(`Invalid target "${target}". Use: ${validTargets.join(', ')}`);
         process.exit(1);
       }
 
-      if (target === 'claude' || target === 'both') {
-        installClaude(ctx.agentId, ctx.agentPath);
+      if (isFileTree) {
+        p.log.info(`Detected file-tree agent (v7) — registering via @soleri/engine`);
       }
 
-      if (target === 'codex' || target === 'both') {
-        installCodex(ctx.agentId, ctx.agentPath);
+      if (target === 'claude' || target === 'both' || target === 'all') {
+        installClaude(ctx.agentId, ctx.agentPath, isFileTree);
       }
 
+      if (target === 'codex' || target === 'both' || target === 'all') {
+        installCodex(ctx.agentId, ctx.agentPath, isFileTree);
+      }
+
+      if (target === 'opencode' || target === 'all') {
+        installOpencode(ctx.agentId, ctx.agentPath, isFileTree);
+      }
+
+      // Create global launcher script
+      installLauncher(ctx.agentId, ctx.agentPath);
+
       p.log.info(`Agent ${ctx.agentId} is now available as an MCP server.`);
     });
 }