@soleri/cli 9.15.0 → 9.16.7

package/src/commands/add-domain.ts

@@ -1,15 +1,19 @@
+import { readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
 import type { Command } from 'commander';
 import * as p from '@clack/prompts';
 import { addDomain } from '@soleri/forge/lib';
 import { detectAgent } from '../utils/agent-context.js';
+import { resolveVaultDbPath } from '../utils/vault-db.js';
 
 export function registerAddDomain(program: Command): void {
   program
     .command('add-domain')
     .argument('<domain>', 'Domain name in kebab-case (e.g., "security")')
     .option('--no-build', 'Skip the build step after adding the domain')
+    .option('--yes', 'Auto-seed vault entries into the knowledge bundle without prompting')
     .description('Add a new knowledge domain to the agent in the current directory')
-    .action(async (domain: string, opts: { build: boolean }) => {
+    .action(async (domain: string, opts: { build: boolean; yes?: boolean }) => {
       const ctx = detectAgent();
       if (!ctx) {
         p.log.error('No agent project detected in current directory. Run this from an agent root.');
@@ -38,6 +42,9 @@ export function registerAddDomain(program: Command): void {
         if (!result.success) {
           process.exit(1);
         }
+
+        // ── Vault auto-seed ────────────────────────────────────────────────
+        await trySeedFromVault(ctx.agentId, ctx.agentPath, domain, opts.yes ?? false);
       } catch (err) {
         s.stop('Failed');
         p.log.error(err instanceof Error ? err.message : String(err));
@@ -45,3 +52,84 @@ export function registerAddDomain(program: Command): void {
       }
     });
 }
+
+/**
+ * Query the agent's vault for entries matching the domain.
+ * If found, prompt the user (or auto-seed with --yes) to populate the bundle.
+ */
+async function trySeedFromVault(
+  agentId: string,
+  agentPath: string,
+  domain: string,
+  autoYes: boolean,
+): Promise<void> {
+  const vaultDbPath = resolveVaultDbPath(agentId);
+  if (!vaultDbPath) return; // Vault not initialized yet — skip silently
+
+  try {
+    const { Vault } = await import('@soleri/core');
+    const vault = new Vault(vaultDbPath);
+
+    let entries: Array<{
+      id: string;
+      type: string;
+      domain?: string;
+      title: string;
+      description: string;
+      tags?: string[];
+      severity?: string;
+    }>;
+    try {
+      entries = vault.list({ domain, limit: 200 });
+    } finally {
+      vault.close();
+    }
+
+    if (entries.length === 0) return; // No matching entries
+
+    // Ask user (or auto-seed)
+    let shouldSeed = autoYes;
+    if (!autoYes) {
+      const answer = await p.confirm({
+        message: `Found ${entries.length} vault entries for domain "${domain}". Seed into knowledge bundle?`,
+        initialValue: true,
+      });
+      if (p.isCancel(answer)) return;
+      shouldSeed = answer;
+    }
+
+    if (!shouldSeed) return;
+
+    // Populate knowledge/{domain}.json
+    const bundlePath = join(agentPath, 'knowledge', `${domain}.json`);
+    const bundleEntries = entries.map((e) => ({
+      id: e.id,
+      type: e.type,
+      domain: e.domain,
+      title: e.title,
+      description: e.description,
+      ...(e.severity ? { severity: e.severity } : {}),
+      ...(e.tags?.length ? { tags: e.tags } : {}),
+    }));
+
+    try {
+      const existing = JSON.parse(readFileSync(bundlePath, 'utf-8')) as {
+        domain: string;
+        entries: unknown[];
+      };
+      existing.entries = bundleEntries;
+      writeFileSync(bundlePath, JSON.stringify(existing, null, 2) + '\n', 'utf-8');
+    } catch {
+      // File not readable — write fresh
+      writeFileSync(
+        bundlePath,
+        JSON.stringify({ domain, entries: bundleEntries }, null, 2) + '\n',
+        'utf-8',
+      );
+    }
+
+    p.log.success(`Seeded ${entries.length} entries into knowledge/${domain}.json`);
+  } catch {
+    // Vault query failed — don't block the domain addition
+  }
+}

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/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(', ')}`)