@soleri/cli 9.0.2 → 9.2.0

package/src/__tests__/hook-packs.test.ts

@@ -3,7 +3,6 @@ import { mkdirSync, rmSync, existsSync, readFileSync, writeFileSync } from 'node
 import { join } from 'node:path';
 import { tmpdir } from 'node:os';
 
-// Mock homedir to use a temp directory instead of real ~/.claude/
 const tempHome = join(tmpdir(), `cli-hookpacks-test-${Date.now()}`);
 
 vi.mock('node:os', async () => {
@@ -24,18 +23,11 @@ describe('hook-packs', () => {
   });
 
   describe('registry', () => {
-    it('should list all 5 built-in packs', () => {
+    it('should list all 6 built-in packs', () => {
       const packs = listPacks();
-      expect(packs.length).toBe(5);
-
+      expect(packs.length).toBe(6);
       const names = packs.map((p) => p.name).sort();
-      expect(names).toEqual([
-        'a11y',
-        'clean-commits',
-        'css-discipline',
-        'full',
-        'typescript-safety',
-      ]);
+      expect(names).toEqual(['a11y', 'clean-commits', 'css-discipline', 'full', 'typescript-safety', 'yolo-safety']);
     });
 
     it('should get a specific pack by name', () => {
@@ -50,35 +42,40 @@ describe('hook-packs', () => {
       expect(getPack('nonexistent')).toBeNull();
     });
 
-    it('should return full pack with composedFrom', () => {
+    it('should return full pack with composedFrom including yolo-safety', () => {
       const pack = getPack('full');
       expect(pack).not.toBeNull();
       expect(pack!.manifest.composedFrom).toEqual([
-        'typescript-safety',
-        'a11y',
-        'css-discipline',
-        'clean-commits',
+        'typescript-safety', 'a11y', 'css-discipline', 'clean-commits', 'yolo-safety',
       ]);
       expect(pack!.manifest.hooks).toHaveLength(8);
     });
 
     it('should return empty installed packs when none installed', () => {
-      expect(getInstalledPacks()).toEqual([]);
+      const installed = getInstalledPacks();
+      expect(installed.filter((p) => p !== 'yolo-safety')).toEqual([]);
+    });
+
+    it('should get yolo-safety pack with scripts and lifecycleHooks', () => {
+      const pack = getPack('yolo-safety');
+      expect(pack).not.toBeNull();
+      expect(pack!.manifest.name).toBe('yolo-safety');
+      expect(pack!.manifest.hooks).toEqual([]);
+      expect(pack!.manifest.scripts).toHaveLength(1);
+      expect(pack!.manifest.scripts![0].name).toBe('anti-deletion');
+      expect(pack!.manifest.lifecycleHooks).toHaveLength(1);
+      expect(pack!.manifest.lifecycleHooks![0].event).toBe('PreToolUse');
     });
   });
 
   describe('installer', () => {
     it('should install a simple pack', () => {
       const result = installPack('typescript-safety');
-
       expect(result.installed).toEqual(['no-any-types', 'no-console-log']);
       expect(result.skipped).toEqual([]);
-
       const claudeDir = join(tempHome, '.claude');
       expect(existsSync(join(claudeDir, 'hookify.no-any-types.local.md'))).toBe(true);
       expect(existsSync(join(claudeDir, 'hookify.no-console-log.local.md'))).toBe(true);
-
-      // Verify content was copied correctly
       const content = readFileSync(join(claudeDir, 'hookify.no-any-types.local.md'), 'utf-8');
       expect(content).toContain('name: no-any-types');
       expect(content).toContain('Soleri Hook Pack: typescript-safety');
@@ -87,40 +84,29 @@ describe('hook-packs', () => {
     it('should be idempotent — skip existing files', () => {
       installPack('typescript-safety');
       const result = installPack('typescript-safety');
-
       expect(result.installed).toEqual([]);
       expect(result.skipped).toEqual(['no-any-types', 'no-console-log']);
     });
 
     it('should install composed pack (full)', () => {
       const result = installPack('full');
-
       expect(result.installed).toHaveLength(8);
       expect(result.skipped).toEqual([]);
-
       const claudeDir = join(tempHome, '.claude');
-      const expectedHooks = [
-        'no-any-types',
-        'no-console-log',
-        'no-important',
-        'no-inline-styles',
-        'semantic-html',
-        'focus-ring-required',
-        'ux-touch-targets',
-        'no-ai-attribution',
-      ];
-      for (const hook of expectedHooks) {
+      for (const hook of ['no-any-types', 'no-console-log', 'no-important', 'no-inline-styles', 'semantic-html', 'focus-ring-required', 'ux-touch-targets', 'no-ai-attribution']) {
         expect(existsSync(join(claudeDir, `hookify.${hook}.local.md`))).toBe(true);
       }
+      expect(result.scripts).toHaveLength(1);
+      expect(result.scripts[0]).toBe('hooks/anti-deletion.sh');
+      expect(existsSync(join(claudeDir, 'hooks', 'anti-deletion.sh'))).toBe(true);
     });
 
     it('should skip already-installed hooks when installing full after partial', () => {
       installPack('typescript-safety');
       const result = installPack('full');
-
       expect(result.skipped).toContain('no-any-types');
       expect(result.skipped).toContain('no-console-log');
-      expect(result.installed).toHaveLength(6); // 8 total - 2 already installed
+      expect(result.installed).toHaveLength(6);
     });
 
     it('should throw for unknown pack', () => {
@@ -130,9 +116,7 @@ describe('hook-packs', () => {
     it('should remove a pack', () => {
       installPack('a11y');
       const result = removePack('a11y');
-
       expect(result.removed).toEqual(['semantic-html', 'focus-ring-required', 'ux-touch-targets']);
-
       const claudeDir = join(tempHome, '.claude');
       expect(existsSync(join(claudeDir, 'hookify.semantic-html.local.md'))).toBe(false);
     });
@@ -145,6 +129,42 @@ describe('hook-packs', () => {
     it('should throw for unknown pack on remove', () => {
       expect(() => removePack('nonexistent')).toThrow('Unknown hook pack: "nonexistent"');
     });
+
+    it('should install yolo-safety pack with scripts and lifecycle hooks', () => {
+      const result = installPack('yolo-safety');
+      expect(result.installed).toEqual([]);
+      expect(result.scripts).toHaveLength(1);
+      expect(result.scripts[0]).toBe('hooks/anti-deletion.sh');
+      expect(result.lifecycleHooks).toHaveLength(1);
+      expect(result.lifecycleHooks[0]).toBe('PreToolUse:Bash');
+      const claudeDir = join(tempHome, '.claude');
+      expect(existsSync(join(claudeDir, 'hooks', 'anti-deletion.sh'))).toBe(true);
+      const settings = JSON.parse(readFileSync(join(claudeDir, 'settings.json'), 'utf-8'));
+      expect(settings.hooks).toBeDefined();
+      expect(settings.hooks.PreToolUse).toHaveLength(1);
+      expect(settings.hooks.PreToolUse[0].command).toBe('bash ~/.claude/hooks/anti-deletion.sh');
+      expect(settings.hooks.PreToolUse[0]._soleriPack).toBe('yolo-safety');
+    });
+
+    it('should remove yolo-safety pack including scripts and lifecycle hooks', () => {
+      installPack('yolo-safety');
+      const result = removePack('yolo-safety');
+      expect(result.scripts).toHaveLength(1);
+      expect(result.lifecycleHooks).toHaveLength(1);
+      const claudeDir = join(tempHome, '.claude');
+      expect(existsSync(join(claudeDir, 'hooks', 'anti-deletion.sh'))).toBe(false);
+      const settings = JSON.parse(readFileSync(join(claudeDir, 'settings.json'), 'utf-8'));
+      expect(settings.hooks.PreToolUse).toBeUndefined();
+    });
+
+    it('should be idempotent for yolo-safety lifecycle hooks', () => {
+      installPack('yolo-safety');
+      const result2 = installPack('yolo-safety');
+      expect(result2.lifecycleHooks).toEqual([]);
+      const claudeDir = join(tempHome, '.claude');
+      const settings = JSON.parse(readFileSync(join(claudeDir, 'settings.json'), 'utf-8'));
+      expect(settings.hooks.PreToolUse).toHaveLength(1);
+    });
   });
 
   describe('isPackInstalled', () => {
@@ -158,7 +178,6 @@ describe('hook-packs', () => {
     });
 
     it('should return partial when some hooks present', () => {
-      // Install just one of the two hooks
       const claudeDir = join(tempHome, '.claude');
       writeFileSync(join(claudeDir, 'hookify.no-any-types.local.md'), 'test');
       expect(isPackInstalled('typescript-safety')).toBe('partial');
@@ -167,29 +186,32 @@ describe('hook-packs', () => {
     it('should return false for unknown pack', () => {
       expect(isPackInstalled('nonexistent')).toBe(false);
     });
+
+    it('should detect yolo-safety as installed when script is present', () => {
+      installPack('yolo-safety');
+      expect(isPackInstalled('yolo-safety')).toBe(true);
+    });
   });
 
   describe('getInstalledPacks', () => {
     it('should list installed packs', () => {
       installPack('typescript-safety');
       installPack('a11y');
-
       const installed = getInstalledPacks();
       expect(installed).toContain('typescript-safety');
       expect(installed).toContain('a11y');
       expect(installed).not.toContain('css-discipline');
     });
 
-    it('should include full when all 8 hooks are present', () => {
+    it('should include full when all hooks and scripts are present', () => {
       installPack('full');
-
       const installed = getInstalledPacks();
-      // All packs should show as installed since full installs all hooks
       expect(installed).toContain('full');
       expect(installed).toContain('typescript-safety');
       expect(installed).toContain('a11y');
       expect(installed).toContain('css-discipline');
       expect(installed).toContain('clean-commits');
+      expect(installed).toContain('yolo-safety');
     });
   });
 });

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) {
@@ -82,6 +84,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 +92,7 @@ function runWizard(name, actions, opts = {}) {
             } catch {}
           }
         } else {
+          // oxlint-disable-next-line eslint(no-await-in-loop)
           await sleep(100);
         }
       }
@@ -455,6 +459,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);
 }
 

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) {