@soleri/cli 9.0.2 → 9.3.0

package/src/__tests__/wizard-e2e.mjs

@@ -35,11 +35,13 @@ function assert(cond, msg, ctx = '') {
 }
 
 function stripAnsi(s) {
+  /* oxlint-disable eslint(no-control-regex) -- intentional ANSI control char stripping */
   // eslint-disable-next-line no-control-regex
   return s
     .replace(new RegExp('\x1B\\[[0-9;]*[A-Za-z]', 'g'), '')
     .replace(new RegExp('\x1B\\].*?\x07', 'g'), '')
     .replace(new RegExp('\r', 'g'), '');
+  /* oxlint-enable eslint(no-control-regex) */
 }
 
 function sleep(ms) {
@@ -68,8 +70,12 @@ function runWizard(name, actions, opts = {}) {
       stdio: ['pipe', 'pipe', 'pipe'],
     });
 
-    proc.stdout.on('data', (d) => { buffer += d.toString(); });
-    proc.stderr.on('data', (d) => { buffer += d.toString(); });
+    proc.stdout.on('data', (d) => {
+      buffer += d.toString();
+    });
+    proc.stderr.on('data', (d) => {
+      buffer += d.toString();
+    });
 
     async function drive() {
       while (actionIndex < actions.length && !state.completed) {
@@ -82,6 +88,7 @@ function runWizard(name, actions, opts = {}) {
 
         if (matched) {
           actionIndex++;
+          // oxlint-disable-next-line eslint(no-await-in-loop)
           await sleep(a.delay || 150);
           if (!state.completed) {
             try {
@@ -89,6 +96,7 @@ function runWizard(name, actions, opts = {}) {
             } catch {}
           }
         } else {
+          // oxlint-disable-next-line eslint(no-await-in-loop)
           await sleep(100);
         }
       }
@@ -116,7 +124,9 @@ function runWizard(name, actions, opts = {}) {
         clearInterval(poller);
         proc.kill('SIGTERM');
         setTimeout(() => {
-          try { proc.kill('SIGKILL'); } catch {}
+          try {
+            proc.kill('SIGKILL');
+          } catch {}
           resolve({
             exitCode: -1,
             output: stripAnsi(buffer) + '\n[TIMEOUT]',
@@ -153,13 +163,62 @@ function archetypeActions(outDir, { downCount = 0 } = {}) {
 // Note: agentId is slugify(label), not the archetype value.
 // e.g., "Full-Stack Assistant" → "full-stack-assistant"
 const ARCHETYPES = [
-  { value: 'code-reviewer', agentId: 'code-reviewer', label: 'Code Reviewer', tone: 'mentor', totalSkills: 10, downCount: 0 },
-  { value: 'security-auditor', agentId: 'security-auditor', label: 'Security Auditor', tone: 'precise', totalSkills: 10, downCount: 1 },
-  { value: 'api-architect', agentId: 'api-architect', label: 'API Architect', tone: 'pragmatic', totalSkills: 10, downCount: 2 },
-  { value: 'test-engineer', agentId: 'test-engineer', label: 'Test Engineer', tone: 'mentor', totalSkills: 10, downCount: 3 },
-  { value: 'devops-pilot', agentId: 'devops-pilot', label: 'DevOps Pilot', tone: 'pragmatic', totalSkills: 10, downCount: 4 },
-  { value: 'database-architect', agentId: 'database-architect', label: 'Database Architect', tone: 'precise', totalSkills: 10, downCount: 5 },
-  { value: 'full-stack', agentId: 'full-stack-assistant', label: 'Full-Stack Assistant', tone: 'mentor', totalSkills: 11, downCount: 6 },
+  {
+    value: 'code-reviewer',
+    agentId: 'code-reviewer',
+    label: 'Code Reviewer',
+    tone: 'mentor',
+    totalSkills: 10,
+    downCount: 0,
+  },
+  {
+    value: 'security-auditor',
+    agentId: 'security-auditor',
+    label: 'Security Auditor',
+    tone: 'precise',
+    totalSkills: 10,
+    downCount: 1,
+  },
+  {
+    value: 'api-architect',
+    agentId: 'api-architect',
+    label: 'API Architect',
+    tone: 'pragmatic',
+    totalSkills: 10,
+    downCount: 2,
+  },
+  {
+    value: 'test-engineer',
+    agentId: 'test-engineer',
+    label: 'Test Engineer',
+    tone: 'mentor',
+    totalSkills: 10,
+    downCount: 3,
+  },
+  {
+    value: 'devops-pilot',
+    agentId: 'devops-pilot',
+    label: 'DevOps Pilot',
+    tone: 'pragmatic',
+    totalSkills: 10,
+    downCount: 4,
+  },
+  {
+    value: 'database-architect',
+    agentId: 'database-architect',
+    label: 'Database Architect',
+    tone: 'precise',
+    totalSkills: 10,
+    downCount: 5,
+  },
+  {
+    value: 'full-stack',
+    agentId: 'full-stack-assistant',
+    label: 'Full-Stack Assistant',
+    tone: 'mentor',
+    totalSkills: 11,
+    downCount: 6,
+  },
 ];
 
 // ══════════════════════════════════════════════════════════
@@ -168,43 +227,55 @@ const ARCHETYPES = [
 
 async function testCancelArchetype() {
   console.log('\n  [1/14] Cancel at archetype (Ctrl+C)');
-  const r = await runWizard('cancel-arch', [
-    { waitFor: 'kind of agent', send: CTRL_C },
-  ], { timeout: 15000 });
+  const r = await runWizard('cancel-arch', [{ waitFor: 'kind of agent', send: CTRL_C }], {
+    timeout: 15000,
+  });
   assert(r.actionsCompleted >= 1, 'prompt reached', 'cancel-archetype');
 }
 
 async function testCancelName() {
   console.log('\n  [2/14] Cancel at display name');
-  const r = await runWizard('cancel-name', [
-    { waitFor: 'kind of agent', send: SPACE + ENTER },
-    { waitFor: 'Display name', send: CTRL_C },
-  ], { timeout: 15000 });
+  const r = await runWizard(
+    'cancel-name',
+    [
+      { waitFor: 'kind of agent', send: SPACE + ENTER },
+      { waitFor: 'Display name', send: CTRL_C },
+    ],
+    { timeout: 15000 },
+  );
   assert(r.actionsCompleted >= 2, 'reached name prompt', 'cancel-name');
 }
 
 async function testCancelRole() {
   console.log('\n  [3/14] Cancel at role');
-  const r = await runWizard('cancel-role', [
-    { waitFor: 'kind of agent', send: SPACE + ENTER },
-    { waitFor: 'Display name', send: ENTER },
-    { waitFor: 'Role', send: CTRL_C },
-  ], { timeout: 15000 });
+  const r = await runWizard(
+    'cancel-role',
+    [
+      { waitFor: 'kind of agent', send: SPACE + ENTER },
+      { waitFor: 'Display name', send: ENTER },
+      { waitFor: 'Role', send: CTRL_C },
+    ],
+    { timeout: 15000 },
+  );
   assert(r.actionsCompleted >= 3, 'reached role prompt', 'cancel-role');
 }
 
 async function testCancelSkills() {
   console.log('\n  [4/14] Cancel at skills');
-  const r = await runWizard('cancel-skills', [
-    { waitFor: 'kind of agent', send: SPACE + ENTER },
-    { waitFor: 'Display name', send: ENTER },
-    { waitFor: 'Role', send: ENTER },
-    { waitFor: 'Description', send: ENTER },
-    { waitFor: /domain|expertise/i, send: ENTER },
-    { waitFor: /principle|guiding/i, send: ENTER },
-    { waitFor: /tone/i, send: ENTER },
-    { waitFor: /skill/i, send: CTRL_C },
-  ], { timeout: 15000 });
+  const r = await runWizard(
+    'cancel-skills',
+    [
+      { waitFor: 'kind of agent', send: SPACE + ENTER },
+      { waitFor: 'Display name', send: ENTER },
+      { waitFor: 'Role', send: ENTER },
+      { waitFor: 'Description', send: ENTER },
+      { waitFor: /domain|expertise/i, send: ENTER },
+      { waitFor: /principle|guiding/i, send: ENTER },
+      { waitFor: /tone/i, send: ENTER },
+      { waitFor: /skill/i, send: CTRL_C },
+    ],
+    { timeout: 15000 },
+  );
   assert(r.actionsCompleted >= 8, 'reached skills prompt', 'cancel-skills');
 }
 
@@ -217,20 +288,24 @@ async function testDeclineConfirm() {
   const outDir = join(TEST_ROOT, 'decline');
   mkdirSync(outDir, { recursive: true });
 
-  const r = await runWizard('decline', [
-    { waitFor: 'kind of agent', send: SPACE + ENTER },
-    { waitFor: 'Display name', send: ENTER },
-    { waitFor: 'Role', send: ENTER },
-    { waitFor: 'Description', send: ENTER },
-    { waitFor: /domain|expertise/i, send: ENTER },
-    { waitFor: /principle|guiding/i, send: ENTER },
-    { waitFor: /tone/i, send: ENTER },
-    { waitFor: /skill/i, send: ENTER },
-    { waitFor: /greeting/i, send: ENTER },
-    { waitFor: /output|directory/i, send: CTRL_U + outDir + ENTER, delay: 300 },
-    { waitFor: /hook|pack/i, send: ENTER },
-    { waitFor: /create agent/i, send: LEFT + ENTER },
-  ], { timeout: 15000 });
+  const r = await runWizard(
+    'decline',
+    [
+      { waitFor: 'kind of agent', send: SPACE + ENTER },
+      { waitFor: 'Display name', send: ENTER },
+      { waitFor: 'Role', send: ENTER },
+      { waitFor: 'Description', send: ENTER },
+      { waitFor: /domain|expertise/i, send: ENTER },
+      { waitFor: /principle|guiding/i, send: ENTER },
+      { waitFor: /tone/i, send: ENTER },
+      { waitFor: /skill/i, send: ENTER },
+      { waitFor: /greeting/i, send: ENTER },
+      { waitFor: /output|directory/i, send: CTRL_U + outDir + ENTER, delay: 300 },
+      { waitFor: /hook|pack/i, send: ENTER },
+      { waitFor: /create agent/i, send: LEFT + ENTER },
+    ],
+    { timeout: 15000 },
+  );
 
   assert(r.actionsCompleted >= 12, `all prompts reached (${r.actionsCompleted}/12)`, 'decline');
   assert(!existsSync(join(outDir, 'code-reviewer', 'package.json')), 'no agent created', 'decline');
@@ -260,8 +335,11 @@ async function testArchetype(arch, idx) {
   const personaPath = join(ad, 'src', 'identity', 'persona.ts');
   if (existsSync(personaPath)) {
     const persona = readFileSync(personaPath, 'utf-8');
-    assert(persona.includes(`'${arch.label}'`) || persona.includes(`"${arch.label}"`),
-      `name = ${arch.label}`, ctx);
+    assert(
+      persona.includes(`'${arch.label}'`) || persona.includes(`"${arch.label}"`),
+      `name = ${arch.label}`,
+      ctx,
+    );
     assert(persona.includes(`tone: '${arch.tone}'`), `tone = ${arch.tone}`, ctx);
   } else {
     assert(false, 'persona.ts exists', ctx);
@@ -271,9 +349,21 @@ async function testArchetype(arch, idx) {
   const skillsDir = join(ad, 'skills');
   if (existsSync(skillsDir)) {
     const skills = readdirSync(skillsDir);
-    assert(skills.length === arch.totalSkills, `${arch.totalSkills} skills (got ${skills.length})`, ctx);
+    assert(
+      skills.length === arch.totalSkills,
+      `${arch.totalSkills} skills (got ${skills.length})`,
+      ctx,
+    );
     // Core skills always present
-    for (const core of ['brainstorming', 'systematic-debugging', 'verification-before-completion', 'health-check', 'context-resume', 'writing-plans', 'executing-plans']) {
+    for (const core of [
+      'brainstorming',
+      'systematic-debugging',
+      'verification-before-completion',
+      'health-check',
+      'context-resume',
+      'writing-plans',
+      'executing-plans',
+    ]) {
       assert(skills.includes(core), `core skill: ${core}`, ctx);
     }
   } else {
@@ -310,8 +400,9 @@ async function testCustomArchetype() {
   const customName = 'GraphQL Guardian';
   const customId = 'graphql-guardian';
   const customRole = 'Validates GraphQL schemas against federation rules';
-  const customDesc = 'This agent checks GraphQL schemas for breaking changes, naming conventions, and federation compatibility across subgraphs.';
-  const customGreeting = "Hey! Drop your GraphQL schema and I will check it for issues.";
+  const customDesc =
+    'This agent checks GraphQL schemas for breaking changes, naming conventions, and federation compatibility across subgraphs.';
+  const customGreeting = 'Hey! Drop your GraphQL schema and I will check it for issues.';
 
   const r = await runWizard('custom', [
     // Step 1: Select "✦ Create Custom" (9 downs — 9 archetypes before _custom)
@@ -422,7 +513,11 @@ async function testHookPacks() {
   // Validate hooks were installed
   const output = r.output;
   assert(output.includes('a11y') && output.includes('installed'), 'a11y pack installed', ctx);
-  assert(output.includes('typescript-safety') && output.includes('installed'), 'typescript-safety pack installed', ctx);
+  assert(
+    output.includes('typescript-safety') && output.includes('installed'),
+    'typescript-safety pack installed',
+    ctx,
+  );
 
   // Check .claude directory has hooks
   const claudeDir = join(ad, '.claude');
@@ -431,7 +526,9 @@ async function testHookPacks() {
     assert(files.length > 0, `.claude/ has hook files (${files.length})`, ctx);
   }
 
-  console.log(`      exit=${r.exitCode}, agent=${existsSync(ad)}, hooks=${r.output.includes('installed')}`);
+  console.log(
+    `      exit=${r.exitCode}, agent=${existsSync(ad)}, hooks=${r.output.includes('installed')}`,
+  );
 }
 
 // ══════════════════════════════════════════════════════════
@@ -455,6 +552,7 @@ await testDeclineConfirm();
 
 // All 7 archetypes (each scaffolds + builds, slower)
 for (let i = 0; i < ARCHETYPES.length; i++) {
+  // oxlint-disable-next-line eslint(no-await-in-loop)
   await testArchetype(ARCHETYPES[i], i);
 }
 
@@ -469,10 +567,7 @@ rmSync(TEST_ROOT, { recursive: true, force: true });
 
 // Clean up any MCP registrations
 try {
-  const claudeJson = join(
-    process.env.HOME || process.env.USERPROFILE || '',
-    '.claude.json',
-  );
+  const claudeJson = join(process.env.HOME || process.env.USERPROFILE || '', '.claude.json');
   if (existsSync(claudeJson)) {
     const c = JSON.parse(readFileSync(claudeJson, 'utf-8'));
     let changed = false;

package/src/commands/agent.ts

@@ -5,12 +5,22 @@
  * `soleri agent update` — OTA engine upgrade with migration support.
  */
 
-import { join } from 'node:path';
-import { existsSync, readFileSync, readdirSync, writeFileSync, mkdirSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import {
+  existsSync,
+  readFileSync,
+  readdirSync,
+  writeFileSync,
+  mkdirSync,
+  renameSync,
+  cpSync,
+  rmSync,
+} from 'node:fs';
+import { homedir } from 'node:os';
 import { execFileSync } from 'node:child_process';
 import type { Command } from 'commander';
 import * as p from '@clack/prompts';
-import { PackLockfile, checkNpmVersion, checkVersionCompat } from '@soleri/core';
+import { PackLockfile, checkNpmVersion, checkVersionCompat, SOLERI_HOME } from '@soleri/core';
 import {
   generateClaudeMdTemplate,
   generateInjectClaudeMd,
@@ -18,6 +28,7 @@ import {
 } from '@soleri/forge/lib';
 import type { AgentConfig } from '@soleri/forge/lib';
 import { detectAgent } from '../utils/agent-context.js';
+import { installClaude } from './install.js';
 
 export function registerAgent(program: Command): void {
   const agent = program.command('agent').description('Agent lifecycle management');
@@ -330,6 +341,138 @@ export function registerAgent(program: Command): void {
       }
     });
 
+  // ─── migrate ──────────────────────────────────────────────
+  // Temporary command — moves agent data from ~/.{agentId}/ to ~/.soleri/{agentId}/.
+  // Will be removed in the next major version after all users migrate.
+  agent
+    .command('migrate')
+    .argument('<agentId>', 'Agent ID to migrate (e.g. ernesto, salvador)')
+    .option('--dry-run', 'Preview what would be moved without executing')
+    .description('Move agent data from ~/.{agentId}/ to ~/.soleri/{agentId}/ (one-time migration)')
+    .action((agentId: string, opts: { dryRun?: boolean }) => {
+      const legacyHome = join(homedir(), `.${agentId}`);
+      const newHome = join(SOLERI_HOME, agentId);
+
+      // Data files to migrate (relative to agent home)
+      const dataFiles = [
+        'vault.db',
+        'vault.db-shm',
+        'vault.db-wal',
+        'plans.json',
+        'keys.json',
+        'flags.json',
+      ];
+      const dataDirs = ['templates'];
+
+      // Check if legacy data exists
+      if (!existsSync(legacyHome)) {
+        p.log.info(`No legacy data found at ${legacyHome} — nothing to migrate.`);
+        return;
+      }
+
+      // Check if already migrated
+      if (existsSync(join(newHome, 'vault.db'))) {
+        p.log.warn(`Data already exists at ${newHome}/vault.db — migration may have already run.`);
+        p.log.info('If you want to force re-migration, remove the new directory first.');
+        return;
+      }
+
+      // Discover what to move
+      const toMove: Array<{ src: string; dst: string; type: 'file' | 'dir' }> = [];
+
+      for (const file of dataFiles) {
+        const src = join(legacyHome, file);
+        if (existsSync(src)) {
+          toMove.push({ src, dst: join(newHome, file), type: 'file' });
+        }
+      }
+
+      for (const dir of dataDirs) {
+        const src = join(legacyHome, dir);
+        if (existsSync(src)) {
+          toMove.push({ src, dst: join(newHome, dir), type: 'dir' });
+        }
+      }
+
+      if (toMove.length === 0) {
+        p.log.info(`No data files found in ${legacyHome} — nothing to migrate.`);
+        return;
+      }
+
+      // Preview
+      console.log(`\n  Migration: ${legacyHome} → ${newHome}\n`);
+      for (const item of toMove) {
+        const label = item.type === 'dir' ? '(dir) ' : '';
+        console.log(`  ${label}${item.src} → ${item.dst}`);
+      }
+      console.log('');
+
+      if (opts.dryRun) {
+        p.log.info(
+          `Dry run — ${toMove.length} items would be moved. Run without --dry-run to execute.`,
+        );
+        return;
+      }
+
+      // Execute migration
+      const s = p.spinner();
+      s.start('Migrating agent data...');
+
+      try {
+        // Create new home directory
+        mkdirSync(newHome, { recursive: true });
+
+        let moved = 0;
+        for (const item of toMove) {
+          mkdirSync(dirname(item.dst), { recursive: true });
+          try {
+            // Try atomic rename first (same filesystem)
+            renameSync(item.src, item.dst);
+          } catch {
+            // Cross-filesystem: copy then remove
+            if (item.type === 'dir') {
+              cpSync(item.src, item.dst, { recursive: true });
+              rmSync(item.src, { recursive: true });
+            } else {
+              cpSync(item.src, item.dst);
+              rmSync(item.src);
+            }
+          }
+          moved++;
+        }
+
+        s.stop(`Migrated ${moved} items to ${newHome}`);
+
+        // Detect agent definition (agent.yaml) to re-register MCP
+        const agentYaml = join(newHome, 'agent.yaml');
+        const legacyAgentYaml = join(legacyHome, 'agent.yaml');
+
+        if (existsSync(agentYaml) || existsSync(legacyAgentYaml)) {
+          // If agent.yaml is still in legacy dir, move it too
+          if (!existsSync(agentYaml) && existsSync(legacyAgentYaml)) {
+            p.log.info(
+              'Note: agent.yaml is still at the old location. Move the entire agent folder if needed.',
+            );
+          }
+        }
+
+        // Re-register MCP pointing to new location
+        const agentDir = existsSync(agentYaml) ? newHome : legacyHome;
+        if (existsSync(join(agentDir, 'agent.yaml'))) {
+          installClaude(agentId, agentDir, true);
+          p.log.success('MCP registration updated to new path.');
+        }
+
+        p.log.info(
+          `Legacy directory preserved at ${legacyHome} (safe to remove manually after verifying).`,
+        );
+      } catch (err) {
+        s.stop('Migration failed');
+        p.log.error(err instanceof Error ? err.message : String(err));
+        process.exit(1);
+      }
+    });
+
   // ─── validate ──────────────────────────────────────────────
   agent
     .command('validate')

package/src/commands/create.ts

@@ -1,5 +1,6 @@
 import { readFileSync, existsSync } from 'node:fs';
-import { resolve } from 'node:path';
+import { resolve, join } from 'node:path';
+import { homedir } from 'node:os';
 import type { Command } from 'commander';
 import * as p from '@clack/prompts';
 import {
@@ -14,6 +15,9 @@ import { runCreateWizard } from '../prompts/create-wizard.js';
 import { listPacks } from '../hook-packs/registry.js';
 import { installPack } from '../hook-packs/installer.js';
 
+/** Default parent directory for new agents: ~/.soleri/ */
+const SOLERI_HOME = process.env.SOLERI_HOME ?? join(homedir(), '.soleri');
+
 function parseSetupTarget(value?: string): SetupTarget | undefined {
   if (!value) return undefined;
   if ((SETUP_TARGETS as readonly string[]).includes(value)) {
@@ -37,6 +41,7 @@ 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('--dir <path>', `Parent directory for the agent (default: ~/.soleri/)`)
     .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')
@@ -46,6 +51,7 @@ export function registerCreate(program: Command): void {
         opts?: {
           config?: string;
           yes?: boolean;
+          dir?: string;
           setupTarget?: string;
           filetree?: boolean;
           legacy?: boolean;
@@ -148,7 +154,7 @@ export function registerCreate(program: Command): void {
               })),
             };
 
-            const outputDir = config.outputDir ?? process.cwd();
+            const outputDir = opts?.dir ? resolve(opts.dir) : (config.outputDir ?? SOLERI_HOME);
             const nonInteractive = !!(opts?.yes || opts?.config);
 
             if (!nonInteractive) {