@soleri/cli 1.12.4 → 7.0.0

package/src/commands/create.ts

@@ -8,6 +8,7 @@ import {
   AgentConfigSchema,
   SETUP_TARGETS,
   type SetupTarget,
+  scaffoldFileTree,
 } from '@soleri/forge/lib';
 import { runCreateWizard } from '../prompts/create-wizard.js';
 import { listPacks } from '../hook-packs/registry.js';
@@ -21,9 +22,9 @@ function parseSetupTarget(value?: string): SetupTarget | undefined {
   return undefined;
 }
 
-function includesClaudeSetup(target: SetupTarget | undefined): boolean {
-  const resolved = target ?? 'claude';
-  return resolved === 'claude' || resolved === 'both';
+function includesClaudeSetup(target: SetupTarget | string | undefined): boolean {
+  const resolved = target ?? 'opencode';
+  return resolved === 'claude' || resolved === 'both' || resolved === 'all';
 }
 
 export function registerCreate(program: Command): void {
@@ -36,9 +37,20 @@ export function registerCreate(program: Command): void {
       `Setup target: ${SETUP_TARGETS.join(', ')} (default: claude)`,
     )
     .option('-y, --yes', 'Skip confirmation prompts (use with --config for fully non-interactive)')
+    .option('--filetree', 'Create a file-tree agent (v7 — no TypeScript, no build step)')
+    .option('--legacy', 'Create a legacy TypeScript agent (v6 — requires npm install + build)')
     .description('Create a new Soleri agent')
     .action(
-      async (name?: string, opts?: { config?: string; yes?: boolean; setupTarget?: string }) => {
+      async (
+        name?: string,
+        opts?: {
+          config?: string;
+          yes?: boolean;
+          setupTarget?: string;
+          filetree?: boolean;
+          legacy?: boolean;
+        },
+      ) => {
         try {
           let config;
 
@@ -81,6 +93,78 @@ export function registerCreate(program: Command): void {
           if (setupTarget) {
             config = { ...config, setupTarget };
           }
+          // ─── File-tree agent (v7) ──────────────────────────────
+          // Default to filetree unless --legacy is explicitly passed
+          const useFileTree = opts?.filetree || !opts?.legacy;
+
+          if (useFileTree) {
+            // Convert to AgentYaml format
+            // Cast to Record to access fields that may exist on the parsed config
+            // but aren't in the strict AgentConfig type (model, cognee, vaults, domainPacks)
+            const raw = config as Record<string, unknown>;
+            const agentYamlInput = {
+              id: config.id,
+              name: config.name,
+              role: config.role,
+              description: config.description,
+              domains: config.domains,
+              principles: config.principles,
+              tone: config.tone,
+              greeting: config.greeting,
+              setup: {
+                target: config.setupTarget,
+                model: (raw.model as string) ?? 'claude-code-sonnet-4',
+              },
+              engine: {
+                cognee: (raw.cognee as boolean) ?? false,
+              },
+              vaults: raw.vaults as
+                | Array<{ name: string; path: string; priority?: number }>
+                | undefined,
+              packs: (
+                raw.domainPacks as
+                  | Array<{ name: string; package: string; version?: string }>
+                  | undefined
+              )?.map((dp) => ({
+                name: dp.name,
+                package: dp.package,
+                version: dp.version,
+              })),
+            };
+
+            const outputDir = config.outputDir ?? process.cwd();
+            const nonInteractive = !!(opts?.yes || opts?.config);
+
+            if (!nonInteractive) {
+              p.log.info(
+                `Will create file-tree agent "${config.name}" in ${outputDir}/${config.id}`,
+              );
+              p.log.info(`Domains: ${config.domains.join(', ')}`);
+              p.log.info('No build step — agent is ready to use immediately.');
+
+              const confirmed = await p.confirm({ message: 'Create agent?' });
+              if (p.isCancel(confirmed) || !confirmed) {
+                p.outro('Cancelled.');
+                return;
+              }
+            }
+
+            const s = p.spinner();
+            s.start('Creating file-tree agent...');
+            const result = scaffoldFileTree(agentYamlInput, outputDir);
+            s.stop(result.success ? 'Agent created!' : 'Creation failed');
+
+            if (!result.success) {
+              p.log.error(result.summary);
+              process.exit(1);
+            }
+
+            p.note(result.summary, 'Next steps');
+            p.outro('Done!');
+            return;
+          }
+
+          // ─── Legacy TypeScript agent (v6) ─────────────────────
           const claudeSetup = includesClaudeSetup(config.setupTarget);
 
           const nonInteractive = !!(opts?.yes || opts?.config);
@@ -98,9 +182,9 @@ export function registerCreate(program: Command): void {
             const available = listPacks().map((pk) => pk.name);
             const unknown = selectedPacks.filter((pk) => !available.includes(pk));
             if (unknown.length > 0) {
-              for (const name of unknown) {
+              for (const packName of unknown) {
                 p.log.warn(
-                  `Unknown hook pack "${name}" — skipping. Available: ${available.join(', ')}`,
+                  `Unknown hook pack "${packName}" — skipping. Available: ${available.join(', ')}`,
                 );
               }
               selectedPacks = selectedPacks.filter((pk) => available.includes(pk));

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,6 +84,33 @@ 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 {
+  const configPath = join(homedir(), '.opencode.json');
+
+  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.mcpServers || typeof config.mcpServers !== 'object') {
+    config.mcpServers = {};
+  }
+
+  const servers = config.mcpServers as Record<string, unknown>;
+  servers[agentId] = isFileTree
+    ? fileTreeMcpEntry(agentDir)
+    : { type: 'stdio', command: 'node', args: [join(agentDir, 'dist', 'index.js')] };
+
+  writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n', 'utf-8');
+  p.log.success(`Registered ${agentId} in ~/.opencode.json`);
+}
+
 function escapeRegExp(s: string): string {
   return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }
@@ -70,7 +119,7 @@ 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: opencode, claude, codex, or all', 'opencode')
     .description('Register agent as MCP server in editor config')
     .action(async (dir?: string, opts?: { target?: string }) => {
       const resolvedDir = dir ? resolve(dir) : undefined;
@@ -81,19 +130,29 @@ export function registerInstall(program: Command): void {
         process.exit(1);
       }
 
-      const target = (opts?.target ?? 'claude') as Target;
+      const target = (opts?.target ?? 'opencode') 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 === '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 === 'codex' || target === 'both') {
-        installCodex(ctx.agentId, ctx.agentPath);
+      if (target === 'opencode' || target === 'all') {
+        installOpencode(ctx.agentId, ctx.agentPath, isFileTree);
       }
 
       p.log.info(`Agent ${ctx.agentId} is now available as an MCP server.`);