@soleri/cli 9.11.0 → 9.13.0

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();

package/src/prompts/create-wizard.ts

@@ -7,7 +7,7 @@
  */
 import * as p from '@clack/prompts';
 import type { AgentConfigInput } from '@soleri/forge/lib';
-import { ITALIAN_CRAFTSPERSON } from '@soleri/core/personas';
+import { ITALIAN_CRAFTSPERSON, NEUTRAL_PERSONA } from '@soleri/core/personas';
 import { isGhInstalled } from '../utils/git.js';
 
 /** Git configuration collected from the wizard. */
@@ -67,52 +67,19 @@ export async function runCreateWizard(initialName?: string): Promise<CreateWizar
       },
       {
         value: 'custom',
-        label: 'Describe your own persona',
-        hint: 'Tell me who your agent should be',
+        label: 'Custom (editable neutral persona)',
+        hint: 'Full persona file — customize later via agent.yaml',
       },
     ],
   });
 
   if (p.isCancel(personaChoice)) return null;
 
-  let personaDescription: string | undefined;
-
-  if (personaChoice === 'custom') {
-    const desc = (await p.text({
-      message: "Describe your agent's personality (we'll generate the persona from this)",
-      placeholder: 'A calm Japanese sensei who speaks in zen metaphors and values harmony in code',
-      validate: (v) => {
-        if (!v || v.trim().length < 10) return 'Give at least a brief description (10+ chars)';
-        if (v.length > 500) return 'Max 500 characters';
-      },
-    })) as string;
-
-    if (p.isCancel(desc)) return null;
-    personaDescription = desc;
-  }
-
   // ─── Build config ───────────────────────────────────────────
-  const persona = personaDescription
-    ? {
-        template: 'custom',
-        name: name.trim(),
-        voice: personaDescription,
-        // Custom personas start with minimal config — the LLM enriches from the voice description
-        inspiration: '',
-        culture: '',
-        metaphors: [] as string[],
-        traits: [] as string[],
-        quirks: [] as string[],
-        opinions: [] as string[],
-        greetings: [`Hello! I'm ${name.trim()}. What are we working on?`],
-        signoffs: ['Until next time!'],
-        languageRule: "Speak the user's language naturally.",
-        nameRule: 'Adapt to name changes but keep character intact.',
-      }
-    : {
-        ...ITALIAN_CRAFTSPERSON,
-        name: name.trim(),
-      };
+  const persona =
+    personaChoice === 'custom'
+      ? { ...NEUTRAL_PERSONA, name: name.trim() }
+      : { ...ITALIAN_CRAFTSPERSON, name: name.trim() };
 
   const greeting = persona.greetings[0] ?? `Ciao! I'm ${name.trim()}. What are we working on?`;