@soleri/cli 9.10.0 → 9.12.1

package/src/commands/agent.ts

@@ -55,9 +55,10 @@ export function registerAgent(program: Command): void {
   agent
     .command('status')
     .option('--json', 'Output as JSON')
+    .option('--path <dir>', 'Path to agent directory (default: cwd)')
     .description('Show agent health: version, packs, vault, and update availability')
-    .action((opts: { json?: boolean }) => {
-      const ctx = detectAgent();
+    .action((opts: { json?: boolean; path?: string }) => {
+      const ctx = detectAgent(opts.path);
       if (!ctx) {
         p.log.error('No agent project detected in current directory.');
         process.exit(1);
@@ -104,7 +105,7 @@ export function registerAgent(program: Command): void {
               {
                 agent: agentName,
                 id: agentId,
-                format: 'file-tree (v7)',
+                format: 'file-tree',
                 engine: engineVersion,
                 engineLatest: latestCore,
                 domains,
@@ -120,7 +121,7 @@ export function registerAgent(program: Command): void {
 
         console.log(`\n  Agent: ${agentName}`);
         console.log(`  ID: ${agentId}`);
-        console.log(`  Format: file-tree (v7)`);
+        console.log(`  Format: file-tree`);
         console.log(
           `  Engine: @soleri/core ${engineVersion}${latestCore && latestCore !== engineVersion ? ` (update available: ${latestCore})` : ''}`,
         );
@@ -205,9 +206,10 @@ export function registerAgent(program: Command): void {
     .command('update')
     .option('--check', 'Show what would change without updating')
     .option('--dry-run', 'Preview migration steps')
+    .option('--path <dir>', 'Path to agent directory (default: cwd)')
     .description('Update agent engine to latest compatible version')
-    .action((opts: { check?: boolean; dryRun?: boolean }) => {
-      const ctx = detectAgent();
+    .action((opts: { check?: boolean; dryRun?: boolean; path?: string }) => {
+      const ctx = detectAgent(opts.path);
       if (!ctx) {
         p.log.error('No agent project detected in current directory.');
         process.exit(1);
@@ -366,9 +368,10 @@ export function registerAgent(program: Command): void {
     .command('refresh')
     .option('--dry-run', 'Preview what would change without writing')
     .option('--skip-skills', 'Skip skill sync (only regenerate activation files)')
+    .option('--path <dir>', 'Path to agent directory (default: cwd)')
     .description('Regenerate activation files and sync skills from latest forge templates')
-    .action((opts: { dryRun?: boolean; skipSkills?: boolean }) => {
-      const ctx = detectAgent();
+    .action((opts: { dryRun?: boolean; skipSkills?: boolean; path?: string }) => {
+      const ctx = detectAgent(opts.path);
       if (!ctx) {
         p.log.error('No agent project detected in current directory.');
         process.exit(1);
@@ -510,9 +513,10 @@ export function registerAgent(program: Command): void {
   // ─── diff ───────────────────────────────────────────────────
   agent
     .command('diff')
+    .option('--path <dir>', 'Path to agent directory (default: cwd)')
     .description('Show drift between agent templates and latest engine templates')
-    .action(() => {
-      const ctx = detectAgent();
+    .action((opts: { path?: string }) => {
+      const ctx = detectAgent(opts.path);
       if (!ctx) {
         p.log.error('No agent project detected in current directory.');
         process.exit(1);

package/src/commands/create.ts

@@ -1,4 +1,4 @@
-import { accessSync, constants as fsConstants, readFileSync, existsSync } from 'node:fs';
+import { accessSync, constants as fsConstants, mkdirSync, readFileSync, existsSync } from 'node:fs';
 import { resolve } from 'node:path';
 import type { Command } from 'commander';
 import * as p from '@clack/prompts';
@@ -185,7 +185,15 @@ export function registerCreate(program: Command): void {
 
             const outputDir = opts?.dir ? resolve(opts.dir) : (config.outputDir ?? process.cwd());
 
-            // Preflight: check output directory is writable
+            // 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 {
               accessSync(outputDir, fsConstants.W_OK);
             } catch {

package/src/commands/dev.ts

@@ -1,5 +1,5 @@
 import { spawn } from 'node:child_process';
-import { watch, writeFileSync } from 'node:fs';
+import { existsSync, watch, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 import type { Command } from 'commander';
 import * as p from '@clack/prompts';
@@ -26,18 +26,29 @@ export function registerDev(program: Command): void {
     });
 }
 
-function runFileTreeDev(agentPath: string, agentId: string): void {
+async function runFileTreeDev(agentPath: string, agentId: string): Promise<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');
 
-  regenerateClaudeMd(agentPath);
+  await regenerateClaudeMd(agentPath);
 
   // Start the engine server
   let engineBin: string;
   try {
-    engineBin = require.resolve('@soleri/core/dist/engine/bin/soleri-engine.js');
+    const candidate = join(
+      agentPath,
+      'node_modules',
+      '@soleri',
+      'core',
+      'dist',
+      'engine',
+      'bin',
+      'soleri-engine.js',
+    );
+    if (!existsSync(candidate)) throw new Error('Engine not found at ' + candidate);
+    engineBin = candidate;
   } catch {
     p.log.error('Engine not found. Run: npm install @soleri/core');
     process.exit(1);
@@ -73,10 +84,10 @@ function runFileTreeDev(agentPath: string, agentId: string): void {
 
         // Debounce — regenerate at most once per 200ms
         if (debounceTimer) clearTimeout(debounceTimer);
-        debounceTimer = setTimeout(() => {
+        debounceTimer = setTimeout(async () => {
           const changedFile = filename ? ` (${filename})` : '';
           p.log.info(`Change detected${changedFile} — regenerating CLAUDE.md`);
-          regenerateClaudeMd(agentPath);
+          await regenerateClaudeMd(agentPath);
         }, 200);
       });
     } catch (err: unknown) {
@@ -105,11 +116,10 @@ function runFileTreeDev(agentPath: string, agentId: string): void {
   });
 }
 
-function regenerateClaudeMd(agentPath: string): void {
+async function regenerateClaudeMd(agentPath: string): Promise<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 { composeClaudeMd } = await import('@soleri/forge/lib');
     const { content } = composeClaudeMd(agentPath);
     writeFileSync(join(agentPath, 'CLAUDE.md'), content, 'utf-8');
     p.log.success('CLAUDE.md regenerated');

package/src/commands/dream.ts

@@ -0,0 +1,174 @@
+/**
+ * Dream CLI — vault memory consolidation.
+ *
+ * `soleri dream`                        — run a dream pass immediately
+ * `soleri dream schedule [--time HH:MM]` — schedule daily cron
+ * `soleri dream unschedule`             — remove cron entry
+ * `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;
+}
+
+export function registerDream(program: Command): void {
+  const dream = program.command('dream').description('Vault memory consolidation');
+
+  // ─── soleri dream (no subcommand) — run immediately ─────────
+  dream
+    .command('run', { isDefault: true })
+    .description('Run a dream pass immediately')
+    .action(async () => {
+      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) {
+        fail('Vault DB not found', 'Run the agent once to initialize its vault database.');
+        process.exit(1);
+      }
+
+      const { Vault, Curator, DreamEngine, ensureDreamSchema } = await import('@soleri/core');
+      const vault = new Vault(dbPath);
+
+      try {
+        ensureDreamSchema(vault.getProvider());
+        const curator = new Curator(vault);
+        const engine = new DreamEngine(vault, curator);
+
+        heading('Dream — Memory Consolidation');
+        info('Running dream pass...');
+        console.log();
+
+        const report = engine.run();
+
+        pass('Dream pass complete');
+        console.log();
+        console.log('  Field                  Value');
+        console.log('  ─────────────────────  ──────────────');
+        dim(`  Duration               ${report.durationMs}ms`);
+        dim(`  Duplicates found       ${report.duplicatesFound}`);
+        dim(`  Stale archived         ${report.staleArchived}`);
+        dim(`  Contradictions found   ${report.contradictionsFound}`);
+        dim(`  Total dreams           ${report.totalDreams}`);
+        dim(`  Timestamp              ${report.timestamp}`);
+        console.log();
+      } finally {
+        vault.close();
+      }
+    });
+
+  // ─── soleri dream schedule ──────────────────────────────────
+  dream
+    .command('schedule')
+    .description('Schedule daily dream cron job')
+    .option('--time <HH:MM>', 'Time to run (24h format)', '22:00')
+    .action(async (opts: { time: string }) => {
+      const agent = detectAgent();
+      if (!agent) {
+        fail('Not in a Soleri agent project', 'Run from an agent directory');
+        process.exit(1);
+      }
+
+      const { scheduleDream } = await import('@soleri/core');
+
+      const result = scheduleDream(opts.time, agent.agentPath);
+
+      if (!result.isScheduled) {
+        fail('Failed to schedule dream cron', 'Check time format (HH:MM) and crontab access.');
+        process.exit(1);
+      }
+
+      heading('Dream — Scheduled');
+      pass(`Daily dream scheduled at ${result.time}`);
+      dim(`  Log path: ${result.logPath}`);
+      dim(`  Project:  ${result.projectDir}`);
+      console.log();
+    });
+
+  // ─── soleri dream unschedule ────────────────────────────────
+  dream
+    .command('unschedule')
+    .description('Remove dream cron entry')
+    .action(async () => {
+      const { unscheduleDream } = await import('@soleri/core');
+
+      unscheduleDream();
+
+      heading('Dream — Unscheduled');
+      pass('Dream cron entry removed');
+      console.log();
+    });
+
+  // ─── soleri dream status ────────────────────────────────────
+  dream
+    .command('status')
+    .description('Show dream status and cron info')
+    .action(async () => {
+      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);
+
+      heading('Dream — Status');
+
+      // Dream engine status (only if vault exists)
+      if (dbPath) {
+        const { Vault, Curator, DreamEngine, ensureDreamSchema } = await import('@soleri/core');
+        const vault = new Vault(dbPath);
+
+        try {
+          ensureDreamSchema(vault.getProvider());
+          const curator = new Curator(vault);
+          const engine = new DreamEngine(vault, curator);
+          const status = engine.getStatus();
+
+          console.log('  Field                     Value');
+          console.log('  ────────────────────────  ──────────────');
+          dim(`  Sessions since last       ${status.sessionsSinceLastDream}`);
+          dim(`  Last dream at             ${status.lastDreamAt ?? 'never'}`);
+          dim(
+            `  Last duration             ${status.lastDreamDurationMs !== null ? `${status.lastDreamDurationMs}ms` : 'n/a'}`,
+          );
+          dim(`  Total dreams              ${status.totalDreams}`);
+          dim(`  Gate eligible             ${status.gateEligible ? 'yes' : 'no'}`);
+        } finally {
+          vault.close();
+        }
+      } else {
+        info('Vault DB not found — dream engine status unavailable.');
+      }
+
+      console.log();
+
+      // Cron schedule status
+      const { getDreamSchedule } = await import('@soleri/core');
+      const cron = getDreamSchedule();
+
+      if (cron.isScheduled) {
+        pass(`Cron scheduled at ${cron.time}`);
+        dim(`  Log path: ${cron.logPath}`);
+        dim(`  Project:  ${cron.projectDir}`);
+      } else {
+        info('No cron schedule configured. Run `soleri dream schedule` to set one.');
+      }
+      console.log();
+    });
+}

package/src/commands/uninstall.ts

@@ -4,6 +4,16 @@ import { join, resolve } from 'node:path';
 import { homedir } from 'node:os';
 import * as p from '@clack/prompts';
 import { detectAgent } from '../utils/agent-context.js';
+import {
+  detectArtifacts,
+  removeDirectory,
+  removeClaudeMdBlock,
+  removePermissionEntries,
+  removeLauncherScript,
+  type ArtifactManifest,
+  type RemovalResult,
+} from '../utils/agent-artifacts.js';
+import { pass, fail, warn, skip, heading, dim } from '../utils/logger.js';
 
 type Target = 'claude' | 'codex' | 'opencode' | 'both' | 'all';
 
@@ -89,39 +99,212 @@ function escapeRegExp(s: string): string {
   return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }
 
+// ---------------------------------------------------------------------------
+// Full uninstall helpers
+// ---------------------------------------------------------------------------
+
+function countArtifacts(manifest: ArtifactManifest): number {
+  let count = 0;
+  if (manifest.projectDir?.exists) count++;
+  if (manifest.dataDir?.exists) count++;
+  if (manifest.dataDirLegacy?.exists) count++;
+  count += manifest.claudeMdBlocks.length;
+  count += manifest.mcpServerEntries.length;
+  if (manifest.permissionEntries.length > 0) count++;
+  if (manifest.launcherScript?.exists) count++;
+  return count;
+}
+
+function displayManifest(manifest: ArtifactManifest): void {
+  heading(`Artifacts for "${manifest.agentId}"`);
+
+  const show = (label: string, loc: { path: string; exists: boolean } | null) => {
+    if (loc?.exists) warn(label, loc.path);
+    else dim(`${label} — not found`);
+  };
+
+  show('Project directory', manifest.projectDir);
+  show('Data directory', manifest.dataDir);
+  show('Data directory (legacy)', manifest.dataDirLegacy);
+  show('Launcher script', manifest.launcherScript);
+
+  if (manifest.claudeMdBlocks.length > 0) {
+    for (const block of manifest.claudeMdBlocks) {
+      warn('CLAUDE.md block', `${block.path} (lines ${block.startLine}-${block.endLine})`);
+    }
+  } else {
+    dim('CLAUDE.md blocks — none found');
+  }
+
+  if (manifest.mcpServerEntries.length > 0) {
+    for (const entry of manifest.mcpServerEntries) {
+      warn(`MCP server (${entry.target})`, `${entry.file} → ${entry.key}`);
+    }
+  } else {
+    dim('MCP server entries — none found');
+  }
+
+  if (manifest.permissionEntries.length > 0) {
+    for (const pe of manifest.permissionEntries) {
+      warn(`Permissions (${pe.matches.length} entries)`, pe.file);
+    }
+  } else {
+    dim('Permission entries — none found');
+  }
+}
+
+function reportResult(label: string, result: RemovalResult): void {
+  if (result.removed) pass(label, result.path);
+  else if (result.error) fail(label, result.error);
+  else skip(label, result.path);
+}
+
+async function fullUninstall(
+  agentId: string,
+  agentDir: string | undefined,
+  target: Target,
+  dryRun: boolean,
+  force: boolean,
+): Promise<void> {
+  const manifest = detectArtifacts(agentId, agentDir);
+  const total = countArtifacts(manifest);
+
+  displayManifest(manifest);
+
+  if (total === 0) {
+    p.log.info('Nothing to remove.');
+    process.exit(2);
+  }
+
+  console.log(`\n  Found ${total} artifact(s) to remove.\n`);
+
+  if (dryRun) {
+    p.log.info('Dry run — no changes made.');
+    return;
+  }
+
+  if (!force) {
+    const confirmed = await p.confirm({
+      message: `Remove all artifacts for "${agentId}"? This cannot be undone.`,
+    });
+    if (p.isCancel(confirmed) || !confirmed) {
+      p.log.info('Cancelled.');
+      return;
+    }
+  }
+
+  let removed = 0;
+  heading('Removing artifacts');
+
+  // 1. MCP server entries (existing logic)
+  if (target === 'claude' || target === 'both' || target === 'all') {
+    uninstallClaude(agentId);
+  }
+  if (target === 'codex' || target === 'both' || target === 'all') {
+    uninstallCodex(agentId);
+  }
+  if (target === 'opencode' || target === 'all') {
+    uninstallOpencode(agentId);
+  }
+  removed += manifest.mcpServerEntries.length;
+
+  // 2. Permission entries
+  for (const pe of manifest.permissionEntries) {
+    const result = await removePermissionEntries(pe.file, agentId);
+    reportResult(`Permissions (${pe.matches.length} entries)`, result);
+    if (result.removed) removed++;
+  }
+
+  // 3. CLAUDE.md blocks (reverse order to preserve line numbers)
+  const sortedBlocks = [...manifest.claudeMdBlocks].sort((a, b) => b.startLine - a.startLine);
+  for (const block of sortedBlocks) {
+    const result = await removeClaudeMdBlock(block.path, block.startLine, block.endLine);
+    reportResult('CLAUDE.md block', result);
+    if (result.removed) removed++;
+  }
+
+  // 4. Launcher script
+  if (manifest.launcherScript?.exists) {
+    const result = await removeLauncherScript(manifest.launcherScript.path);
+    reportResult('Launcher script', result);
+    if (result.removed) removed++;
+  }
+
+  // 5. Data directories
+  if (manifest.dataDir?.exists) {
+    const result = await removeDirectory(manifest.dataDir.path);
+    reportResult('Data directory', result);
+    if (result.removed) removed++;
+  }
+  if (manifest.dataDirLegacy?.exists) {
+    const result = await removeDirectory(manifest.dataDirLegacy.path);
+    reportResult('Data directory (legacy)', result);
+    if (result.removed) removed++;
+  }
+
+  // 6. Project directory (last — most destructive)
+  if (manifest.projectDir?.exists) {
+    const result = await removeDirectory(manifest.projectDir.path);
+    reportResult('Project directory', result);
+    if (result.removed) removed++;
+  }
+
+  console.log(`\n  Removed ${removed}/${total} artifacts for "${agentId}".\n`);
+}
+
+// ---------------------------------------------------------------------------
+// Command registration
+// ---------------------------------------------------------------------------
+
 export function registerUninstall(program: Command): void {
   program
     .command('uninstall')
     .argument('[dir]', 'Agent directory (defaults to cwd)')
-    .option('--target <target>', 'Registration target: opencode, claude, codex, or all', 'opencode')
-    .description('Remove agent MCP server entry from editor config')
-    .action(async (dir?: string, opts?: { target?: string }) => {
-      const resolvedDir = dir ? resolve(dir) : undefined;
-      const ctx = detectAgent(resolvedDir);
-
-      if (!ctx) {
-        p.log.error('Not in an agent project. Run from an agent directory or pass its path.');
-        process.exit(1);
-      }
-
-      const target = (opts?.target ?? 'opencode') as Target;
-      const validTargets: Target[] = ['claude', 'codex', 'opencode', 'both', 'all'];
-
-      if (!validTargets.includes(target)) {
-        p.log.error(`Invalid target "${target}". Use: ${validTargets.join(', ')}`);
-        process.exit(1);
-      }
-
-      if (target === 'claude' || target === 'both' || target === 'all') {
-        uninstallClaude(ctx.agentId);
-      }
-
-      if (target === 'codex' || target === 'both' || target === 'all') {
-        uninstallCodex(ctx.agentId);
-      }
-
-      if (target === 'opencode' || target === 'all') {
-        uninstallOpencode(ctx.agentId);
-      }
-    });
+    .option('--target <target>', 'Registration target: opencode, claude, codex, or all')
+    .option('--full', 'Remove all agent artifacts (project, data, configs, permissions, launcher)')
+    .option('--dry-run', 'Show what would be removed without making changes')
+    .option('--force', 'Skip confirmation prompt')
+    .description('Remove agent MCP server entries (or all artifacts with --full)')
+    .action(
+      async (
+        dir?: string,
+        opts?: { target?: string; full?: boolean; dryRun?: boolean; force?: boolean },
+      ) => {
+        const resolvedDir = dir ? resolve(dir) : undefined;
+        const ctx = detectAgent(resolvedDir);
+
+        if (!ctx) {
+          p.log.error('Not in an agent project. Run from an agent directory or pass its path.');
+          process.exit(1);
+        }
+
+        // Default: 'all' when --full, 'opencode' otherwise
+        const defaultTarget = opts?.full ? 'all' : 'opencode';
+        const target = (opts?.target ?? defaultTarget) as Target;
+        const validTargets: Target[] = ['claude', 'codex', 'opencode', 'both', 'all'];
+
+        if (!validTargets.includes(target)) {
+          p.log.error(`Invalid target "${target}". Use: ${validTargets.join(', ')}`);
+          process.exit(1);
+        }
+
+        if (opts?.full) {
+          await fullUninstall(ctx.agentId, resolvedDir, target, !!opts.dryRun, !!opts.force);
+          return;
+        }
+
+        // Default: MCP-only removal (backward compatible)
+        if (target === 'claude' || target === 'both' || target === 'all') {
+          uninstallClaude(ctx.agentId);
+        }
+
+        if (target === 'codex' || target === 'both' || target === 'all') {
+          uninstallCodex(ctx.agentId);
+        }
+
+        if (target === 'opencode' || target === 'all') {
+          uninstallOpencode(ctx.agentId);
+        }
+      },
+    );
 }

package/src/main.ts

@@ -31,6 +31,7 @@ import { registerTelegram } from './commands/telegram.js';
 import { registerStaging } from './commands/staging.js';
 import { registerVault } from './commands/vault.js';
 import { registerYolo } from './commands/yolo.js';
+import { registerDream } from './commands/dream.js';
 
 const require = createRequire(import.meta.url);
 const { version } = require('../package.json');
@@ -94,4 +95,5 @@ registerTelegram(program);
 registerStaging(program);
 registerVault(program);
 registerYolo(program);
+registerDream(program);
 program.parse();