@soleri/cli 9.14.3 → 9.16.7

package/src/commands/brain.ts

@@ -0,0 +1,93 @@
+/**
+ * Brain CLI — brain session management.
+ *
+ * `soleri brain close-orphans`              — close orphaned sessions (default: --max-age 1h)
+ * `soleri brain close-orphans --max-age 2h` — close sessions older than 2h
+ */
+
+import type { Command } from 'commander';
+import { detectAgent } from '../utils/agent-context.js';
+import { pass, fail, info, heading } from '../utils/logger.js';
+import { resolveVaultDbPath } from '../utils/vault-db.js';
+
+function parseMaxAge(value: string): number {
+  const match = value.match(/^(\d+)(h|m|s)$/);
+  if (!match) throw new Error(`Invalid --max-age format "${value}". Use e.g. 1h, 30m, 90s`);
+  const n = parseInt(match[1], 10);
+  const unit = match[2];
+  if (unit === 'h') return n * 60 * 60 * 1000;
+  if (unit === 'm') return n * 60 * 1000;
+  return n * 1000;
+}
+
+export function registerBrain(program: Command): void {
+  const brain = program.command('brain').description('Brain session management');
+
+  brain
+    .command('close-orphans')
+    .description('Close orphaned brain sessions that were never completed')
+    .option('--max-age <duration>', 'Close sessions older than this age (e.g. 1h, 30m)', '1h')
+    .action(async (opts: { maxAge: string }) => {
+      const agent = detectAgent();
+      if (!agent) {
+        fail('Not in a Soleri agent project', 'Run from an agent directory');
+        process.exit(1);
+      }
+
+      const dbPath = resolveVaultDbPath(agent.agentId);
+      if (!dbPath) {
+        info('Vault DB not found — no sessions to close.');
+        process.exit(0);
+      }
+
+      let maxAgeMs: number;
+      try {
+        maxAgeMs = parseMaxAge(opts.maxAge);
+      } catch (e: unknown) {
+        fail(
+          e instanceof Error ? e.message : String(e),
+          'Example: soleri brain close-orphans --max-age 1h',
+        );
+        process.exit(1);
+      }
+
+      const { Vault, Brain, BrainIntelligence } = await import('@soleri/core');
+      const vault = new Vault(dbPath);
+
+      try {
+        const brainInstance = new Brain(vault);
+        const intelligence = new BrainIntelligence(vault, brainInstance);
+
+        const cutoff = new Date(Date.now() - maxAgeMs).toISOString().replace('T', ' ').slice(0, 19);
+        const activeSessions = intelligence.listSessions({ active: true, limit: 1000 });
+        const orphans = activeSessions.filter((s) => s.startedAt < cutoff);
+
+        if (orphans.length === 0) {
+          info(`No orphaned sessions older than ${opts.maxAge}.`);
+          process.exit(0);
+        }
+
+        heading('Brain — Close Orphans');
+
+        let closed = 0;
+        for (const s of orphans) {
+          try {
+            intelligence.lifecycle({
+              action: 'end',
+              sessionId: s.id,
+              planOutcome: 'abandoned',
+              context: `auto-closed via CLI: no completion after ${opts.maxAge}`,
+            });
+            closed++;
+          } catch {
+            // best-effort — never block on failures
+          }
+        }
+
+        pass(`Closed ${closed} orphaned session${closed === 1 ? '' : 's'}`);
+        process.exit(0);
+      } finally {
+        vault.close();
+      }
+    });
+}

package/src/commands/chat.ts

@@ -0,0 +1,373 @@
+/**
+ * `soleri chat` — interactive terminal chat with your agent.
+ *
+ * Spawns the agent's MCP server, connects via stdio JSON-RPC,
+ * and runs an interactive REPL using the agent loop.
+ *
+ * No external dependencies — MCP client is a minimal JSON-RPC/stdio
+ * implementation, Anthropic API is called via the core agent loop.
+ */
+
+import { spawn } from 'node:child_process';
+import type { ChildProcess } from 'node:child_process';
+import { createInterface } from 'node:readline';
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import type { Command } from 'commander';
+import * as p from '@clack/prompts';
+import { detectAgent } from '../utils/agent-context.js';
+import { runAgentLoop, SOLERI_HOME } from '@soleri/core';
+import type { AgentTool, ChatMessage } from '@soleri/core';
+
+// ─── MCP Types ──────────────────────────────────────────────────────────
+
+interface JsonRpcRequest {
+  jsonrpc: '2.0';
+  id: number;
+  method: string;
+  params?: Record<string, unknown>;
+}
+
+interface JsonRpcNotification {
+  jsonrpc: '2.0';
+  method: string;
+  params?: Record<string, unknown>;
+}
+
+interface JsonRpcResponse {
+  jsonrpc: '2.0';
+  id: number;
+  result?: unknown;
+  error?: { code: number; message: string };
+}
+
+interface McpToolSchema {
+  name: string;
+  description?: string;
+  inputSchema?: { type?: string; properties?: Record<string, unknown>; required?: string[] };
+}
+
+// ─── Minimal MCP Stdio Client ───────────────────────────────────────────
+
+class StdioMcpClient {
+  private proc: ChildProcess;
+  private pending = new Map<
+    number,
+    { resolve: (v: unknown) => void; reject: (e: Error) => void }
+  >();
+  private nextId = 1;
+  private buffer = '';
+
+  constructor(command: string, args: string[], env?: Record<string, string>) {
+    this.proc = spawn(command, args, {
+      stdio: ['pipe', 'pipe', 'inherit'],
+      env: { ...process.env, ...env },
+    });
+
+    this.proc.stdout!.on('data', (chunk: Buffer) => {
+      this.buffer += chunk.toString();
+      const lines = this.buffer.split('\n');
+      this.buffer = lines.pop() ?? '';
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed) continue;
+        try {
+          const msg = JSON.parse(trimmed) as JsonRpcResponse;
+          if ('id' in msg && msg.id !== null && msg.id !== undefined) {
+            const handler = this.pending.get(msg.id);
+            if (handler) {
+              this.pending.delete(msg.id);
+              if (msg.error) {
+                handler.reject(new Error(msg.error.message));
+              } else {
+                handler.resolve(msg.result);
+              }
+            }
+          }
+        } catch {
+          // ignore non-JSON lines
+        }
+      }
+    });
+
+    this.proc.on('exit', () => {
+      for (const handler of this.pending.values()) {
+        handler.reject(new Error('MCP server exited'));
+      }
+      this.pending.clear();
+    });
+  }
+
+  private send(msg: JsonRpcRequest | JsonRpcNotification): void {
+    this.proc.stdin!.write(JSON.stringify(msg) + '\n');
+  }
+
+  private request(method: string, params?: Record<string, unknown>): Promise<unknown> {
+    const id = this.nextId++;
+    return new Promise((resolve, reject) => {
+      this.pending.set(id, { resolve, reject });
+      this.send({ jsonrpc: '2.0', id, method, params: params ?? {} });
+      setTimeout(() => {
+        if (this.pending.has(id)) {
+          this.pending.delete(id);
+          reject(new Error(`MCP request timeout: ${method}`));
+        }
+      }, 30_000);
+    });
+  }
+
+  async initialize(): Promise<void> {
+    await this.request('initialize', {
+      protocolVersion: '2024-11-05',
+      capabilities: {},
+      clientInfo: { name: 'soleri-chat', version: '0.0.1' },
+    });
+    this.send({ jsonrpc: '2.0', method: 'notifications/initialized' });
+  }
+
+  async listTools(): Promise<McpToolSchema[]> {
+    const result = (await this.request('tools/list', {})) as { tools?: McpToolSchema[] };
+    return result.tools ?? [];
+  }
+
+  async callTool(name: string, args: Record<string, unknown>): Promise<string> {
+    const result = (await this.request('tools/call', {
+      name,
+      arguments: args,
+    })) as { content?: Array<{ type: string; text?: string }>; isError?: boolean };
+
+    if (!result?.content) return '';
+    return result.content
+      .filter((c) => c.type === 'text')
+      .map((c) => c.text ?? '')
+      .join('\n');
+  }
+
+  kill(): void {
+    try {
+      this.proc.kill('SIGTERM');
+    } catch {
+      /* ignore */
+    }
+  }
+}
+
+// ─── Helper: Find Agent MCP Command ─────────────────────────────────────
+
+interface McpCommand {
+  command: string;
+  args: string[];
+  env?: Record<string, string>;
+}
+
+function findMcpCommand(agentId: string): McpCommand | null {
+  const claudeConfigPath = join(homedir(), '.claude.json');
+  if (!existsSync(claudeConfigPath)) return null;
+
+  try {
+    const config = JSON.parse(readFileSync(claudeConfigPath, 'utf-8')) as {
+      mcpServers?: Record<
+        string,
+        { command?: string; args?: string[]; env?: Record<string, string> }
+      >;
+    };
+    const servers = config.mcpServers ?? {};
+    for (const [key, srv] of Object.entries(servers)) {
+      if (key === agentId || key.includes(agentId)) {
+        if (srv.command) {
+          return { command: srv.command, args: srv.args ?? [], env: srv.env };
+        }
+      }
+    }
+  } catch {
+    /* ignore */
+  }
+
+  // Fallback: try local dist/agent.js
+  return null;
+}
+
+// ─── Main Command ────────────────────────────────────────────────────────
+
+export function registerChat(program: Command): void {
+  program
+    .command('chat')
+    .option('--model <model>', 'Claude model to use', 'claude-sonnet-4-20250514')
+    .option('--no-tools', 'Disable MCP tools (plain conversation)')
+    .description('Start an interactive chat session with your agent')
+    .action(async (opts: { model: string; tools: boolean }) => {
+      const ctx = detectAgent();
+      if (!ctx) {
+        p.log.error('No agent project detected in current directory.');
+        process.exit(1);
+      }
+
+      // ─── API Key ─────────────────────────────────────────────────
+      const apiKey =
+        process.env.ANTHROPIC_API_KEY ??
+        (() => {
+          try {
+            const keysPath = join(SOLERI_HOME, ctx.agentId, 'keys.json');
+            if (existsSync(keysPath)) {
+              const data = JSON.parse(readFileSync(keysPath, 'utf-8')) as {
+                anthropic?: string[];
+              };
+              return data.anthropic?.[0] ?? null;
+            }
+          } catch {
+            /* ignore */
+          }
+          return null;
+        })();
+
+      if (!apiKey) {
+        p.log.error(
+          'ANTHROPIC_API_KEY is not set. Export it or add it to ' +
+            join(SOLERI_HOME, ctx.agentId, 'keys.json'),
+        );
+        process.exit(1);
+      }
+
+      // ─── System Prompt ────────────────────────────────────────────
+      const claudeMdPath = join(ctx.agentPath, 'CLAUDE.md');
+      const systemPrompt = existsSync(claudeMdPath)
+        ? readFileSync(claudeMdPath, 'utf-8')
+        : `You are ${ctx.agentId}, a helpful AI assistant powered by the Soleri engine.`;
+
+      // ─── MCP Tools ────────────────────────────────────────────────
+      let mcpClient: StdioMcpClient | null = null;
+      let tools: AgentTool[] = [];
+
+      if (opts.tools) {
+        const mcpCmd = findMcpCommand(ctx.agentId);
+
+        if (!mcpCmd) {
+          // Try local dist/agent.js
+          const localAgent = join(ctx.agentPath, 'dist', 'agent.js');
+          if (existsSync(localAgent)) {
+            mcpClient = new StdioMcpClient('node', [localAgent]);
+          }
+        } else {
+          mcpClient = new StdioMcpClient(mcpCmd.command, mcpCmd.args, mcpCmd.env);
+        }
+
+        if (mcpClient) {
+          const s = p.spinner();
+          s.start('Connecting to agent MCP server...');
+          try {
+            await mcpClient.initialize();
+            const mcpTools = await mcpClient.listTools();
+            tools = mcpTools.map((t) => ({
+              name: t.name,
+              description: t.description ?? '',
+              inputSchema: t.inputSchema ?? { type: 'object', properties: {} },
+            }));
+            s.stop(`Connected — ${tools.length} tools available`);
+          } catch (_err) {
+            s.stop('Could not connect to MCP server — running without tools');
+            mcpClient.kill();
+            mcpClient = null;
+          }
+        } else {
+          p.log.warn(
+            `No MCP server found for "${ctx.agentId}". ` +
+              'Run `soleri dev` first, then re-run `soleri chat`. Running without tools.',
+          );
+        }
+      }
+
+      // ─── REPL ─────────────────────────────────────────────────────
+      console.log('');
+      p.intro(`Chat with ${ctx.agentId} (${opts.model})`);
+      console.log('  Type your message and press Enter. Ctrl+C or "exit" to quit.');
+      if (tools.length > 0) {
+        console.log(`  Tools: ${tools.map((t) => t.name).join(', ')}`);
+      }
+      console.log('');
+
+      const history: ChatMessage[] = [];
+
+      const rl = createInterface({
+        input: process.stdin,
+        output: process.stdout,
+        terminal: true,
+      });
+
+      const prompt = (): Promise<string> =>
+        new Promise((resolve) => {
+          rl.question('\x1b[36mYou:\x1b[0m ', resolve);
+        });
+
+      const cleanup = () => {
+        rl.close();
+        if (mcpClient) mcpClient.kill();
+        console.log('\n  Goodbye!');
+        process.exit(0);
+      };
+
+      rl.on('close', () => cleanup());
+      process.on('SIGINT', () => cleanup());
+
+      // eslint-disable-next-line no-constant-condition
+      while (true) {
+        // Sequential await is intentional — this is a REPL loop
+        // eslint-disable-next-line no-await-in-loop
+        const input = await prompt().catch(() => 'exit');
+        const trimmed = input.trim();
+
+        if (!trimmed || trimmed === 'exit' || trimmed === 'quit') {
+          cleanup();
+          return;
+        }
+
+        history.push({ role: 'user', content: trimmed, timestamp: Date.now() });
+
+        const thinking = p.spinner();
+        thinking.start('Thinking...');
+
+        try {
+          // eslint-disable-next-line no-await-in-loop
+          const result = await runAgentLoop(history, {
+            apiKey,
+            model: opts.model,
+            systemPrompt,
+            tools,
+            executor: async (toolName, toolInput) => {
+              if (!mcpClient) return { output: 'No MCP server connected', isError: true };
+              try {
+                const output = await mcpClient.callTool(toolName, toolInput);
+                return { output, isError: false };
+              } catch (err) {
+                return {
+                  output: err instanceof Error ? err.message : String(err),
+                  isError: true,
+                };
+              }
+            },
+            maxIterations: 20,
+          });
+
+          thinking.stop('');
+
+          const response = result.text;
+          if (response) {
+            console.log(`\n\x1b[32m${ctx.agentId}:\x1b[0m ${response}\n`);
+            history.push({
+              role: 'assistant',
+              content: response,
+              timestamp: Date.now(),
+            });
+          }
+
+          if (result.newMessages.length > 0) {
+            history.push(...result.newMessages);
+          }
+        } catch (err) {
+          thinking.stop('Error');
+          p.log.error(err instanceof Error ? err.message : String(err));
+          history.pop(); // remove the failed user message
+        }
+      }
+    });
+}

package/src/commands/create.ts

@@ -187,15 +187,8 @@ export function registerCreate(program: Command): void {
             const outputDir = opts?.dir ? resolve(opts.dir) : (config.outputDir ?? process.cwd());
 
             // Preflight: ensure output directory exists and is writable
-            if (!existsSync(outputDir)) {
-              try {
-                mkdirSync(outputDir, { recursive: true });
-              } catch {
-                p.log.error(`Cannot create ${outputDir} — check permissions`);
-                process.exit(1);
-              }
-            }
             try {
+              mkdirSync(outputDir, { recursive: true });
               accessSync(outputDir, fsConstants.W_OK);
             } catch {
               p.log.error(`Cannot write to ${outputDir} — check permissions`);
@@ -398,6 +391,16 @@ export function registerCreate(program: Command): void {
             }
           }
 
+          // Preflight: ensure output directory exists and is writable
+          const legacyOutputDir = resolve(config.outputDir ?? process.cwd());
+          try {
+            mkdirSync(legacyOutputDir, { recursive: true });
+            accessSync(legacyOutputDir, fsConstants.W_OK);
+          } catch {
+            p.log.error(`Cannot write to ${legacyOutputDir} — check permissions`);
+            process.exit(1);
+          }
+
           // Scaffold + auto-build
           const s = p.spinner();
           s.start('Scaffolding and building agent...');

package/src/commands/dev.ts

@@ -33,6 +33,7 @@ async function runFileTreeDev(agentPath: string, agentId: string): Promise<void>
   p.log.info('Press Ctrl+C to stop.\n');
 
   await regenerateClaudeMd(agentPath);
+  await syncSkills(agentPath, agentId);
 
   // Start the engine server
   let engineBin: string;
@@ -88,6 +89,7 @@ async function runFileTreeDev(agentPath: string, agentId: string): Promise<void>
           const changedFile = filename ? ` (${filename})` : '';
           p.log.info(`Change detected${changedFile} — regenerating CLAUDE.md`);
           await regenerateClaudeMd(agentPath);
+          await syncSkills(agentPath, agentId);
         }, 200);
       });
     } catch (err: unknown) {
@@ -130,6 +132,25 @@ async function regenerateClaudeMd(agentPath: string): Promise<void> {
   }
 }
 
+async function syncSkills(agentPath: string, agentId: string): Promise<void> {
+  try {
+    const { syncSkillsToClaudeCode } = await import('@soleri/core');
+    const skillsDir = join(agentPath, 'skills');
+    const result = syncSkillsToClaudeCode([skillsDir], agentId, { projectRoot: agentPath });
+    const total = result.installed.length + result.updated.length;
+    if (total > 0) {
+      p.log.success(
+        `Skills synced: ${result.installed.length} installed, ${result.updated.length} updated`,
+      );
+    }
+    if (result.removed.length > 0) {
+      p.log.info(`Skills removed: ${result.removed.join(', ')}`);
+    }
+  } catch (err) {
+    p.log.warn(`Skill sync failed: ${err instanceof Error ? err.message : String(err)}`);
+  }
+}
+
 function runLegacyDev(agentPath: string, agentId: string): void {
   p.log.info(`Starting ${agentId} in dev mode...`);
 

package/src/commands/dream.ts

@@ -7,20 +7,10 @@
  * `soleri dream status`                 — show dream status + cron info
  */
 
-import { existsSync } from 'node:fs';
-import { join } from 'node:path';
 import type { Command } from 'commander';
 import { detectAgent } from '../utils/agent-context.js';
 import { pass, fail, info, heading, dim } from '../utils/logger.js';
-import { SOLERI_HOME } from '@soleri/core';
-
-function resolveVaultDbPath(agentId: string): string | null {
-  const newDbPath = join(SOLERI_HOME, agentId, 'vault.db');
-  const legacyDbPath = join(SOLERI_HOME, '..', `.${agentId}`, 'vault.db');
-  if (existsSync(newDbPath)) return newDbPath;
-  if (existsSync(legacyDbPath)) return legacyDbPath;
-  return null;
-}
+import { resolveVaultDbPath } from '../utils/vault-db.js';
 
 export function registerDream(program: Command): void {
   const dream = program.command('dream').description('Vault memory consolidation');

package/src/commands/hooks.ts

@@ -4,6 +4,7 @@ import { join } from 'node:path';
 import { SUPPORTED_EDITORS, type EditorId } from '../hooks/templates.js';
 import { installHooks, removeHooks, detectInstalledHooks } from '../hooks/generator.js';
 import { detectAgent } from '../utils/agent-context.js';
+import { syncHooksToClaudeSettings } from '@soleri/core';
 import { listPacks, getPack } from '../hook-packs/registry.js';
 import { installPack, removePack, isPackInstalled } from '../hook-packs/installer.js';
 import { promotePack, demotePack } from '../hook-packs/graduation.js';
@@ -24,6 +25,37 @@ import * as log from '../utils/logger.js';
 export function registerHooks(program: Command): void {
   const hooks = program.command('hooks').description('Manage editor hooks and hook packs');
 
+  hooks
+    .command('sync')
+    .description(
+      'Sync lifecycle hooks into ~/.claude/settings.json (runs automatically on postinstall)',
+    )
+    .action(() => {
+      const ctx = detectAgent();
+      if (!ctx) {
+        log.fail('No agent project detected. Run from an agent directory.');
+        process.exit(1);
+      }
+      const result = syncHooksToClaudeSettings(ctx.agentId);
+      if (result.error) {
+        log.fail(`Failed to sync hooks for ${ctx.agentId}: ${result.error}`);
+        process.exit(1);
+      }
+      const events = [...result.installed, ...result.updated, ...result.skipped];
+      if (result.installed.length > 0) {
+        log.pass(`Installed hooks for ${ctx.agentId}: ${result.installed.join(', ')}`);
+      }
+      if (result.updated.length > 0) {
+        log.pass(`Updated hooks for ${ctx.agentId}: ${result.updated.join(', ')}`);
+      }
+      if (result.skipped.length > 0) {
+        log.info(`Already up to date: ${result.skipped.join(', ')}`);
+      }
+      if (events.length === 0) {
+        log.info(`No hooks found for ${ctx.agentId}`);
+      }
+    });
+
   hooks
     .command('add')
     .argument('<editor>', `Editor: ${SUPPORTED_EDITORS.join(', ')}`)

package/src/commands/install.ts

@@ -1,5 +1,4 @@
 import type { Command } from 'commander';
-import { createRequire } from 'node:module';
 import {
   accessSync,
   constants as fsConstants,
@@ -13,6 +12,7 @@ import { homedir } from 'node:os';
 import * as p from '@clack/prompts';
 import { detectAgent } from '../utils/agent-context.js';
 import { detectArtifacts } from '../utils/agent-artifacts.js';
+import { resolveInstalledEngineBin } from '../utils/core-resolver.js';
 
 /** Default parent directory for agents: ~/.soleri/ */
 const SOLERI_HOME = process.env.SOLERI_HOME ?? join(homedir(), '.soleri');
@@ -27,13 +27,8 @@ export const toPosix = (p: string): string => p.replace(/\\/g, '/');
  * Falls back to `npx @soleri/engine` if resolution fails (e.g. not installed globally).
  */
 export function resolveEngineBin(): { command: string; bin: string } {
-  try {
-    const require = createRequire(import.meta.url);
-    const bin = require.resolve('@soleri/core/dist/engine/bin/soleri-engine.js');
-    return { command: 'node', bin };
-  } catch {
-    return { command: 'npx', bin: '@soleri/engine' };
-  }
+  const bin = resolveInstalledEngineBin();
+  return bin ? { command: 'node', bin } : { command: 'npx', bin: '@soleri/engine' };
 }
 
 /** MCP server entry for file-tree agents (resolved engine path, no npx) */