@soleri/cli 9.3.1 → 9.5.0

package/src/__tests__/validator.test.ts

@@ -0,0 +1,265 @@
+import { describe, it, expect, vi } from 'vitest';
+import { execSync } from 'node:child_process';
+import { generateFixtures, validateHookScript } from '../hook-packs/validator.js';
+import type { TestFixture } from '../hook-packs/validator.js';
+
+// Mock execSync to avoid needing actual shell scripts in tests
+vi.mock('node:child_process', () => ({
+  execSync: vi.fn(() => ''),
+}));
+
+const mockedExecSync = vi.mocked(execSync);
+
+describe('validator', () => {
+  describe('generateFixtures', () => {
+    it('should return 15 fixtures for PreToolUse (5 matching + 10 non-matching)', () => {
+      const fixtures = generateFixtures('PreToolUse', 'Write');
+      expect(fixtures).toHaveLength(15);
+
+      const matching = fixtures.filter((f) => f.shouldMatch);
+      const nonMatching = fixtures.filter((f) => !f.shouldMatch);
+      expect(matching).toHaveLength(5);
+      expect(nonMatching).toHaveLength(10);
+    });
+
+    it('should return 15 fixtures for PostToolUse', () => {
+      const fixtures = generateFixtures('PostToolUse', 'Edit|Write');
+      expect(fixtures).toHaveLength(15);
+
+      const matching = fixtures.filter((f) => f.shouldMatch);
+      const nonMatching = fixtures.filter((f) => !f.shouldMatch);
+      expect(matching).toHaveLength(5);
+      expect(nonMatching).toHaveLength(10);
+    });
+
+    it('should return 15 fixtures for PreCompact', () => {
+      const fixtures = generateFixtures('PreCompact');
+      expect(fixtures).toHaveLength(15);
+
+      const matching = fixtures.filter((f) => f.shouldMatch);
+      const nonMatching = fixtures.filter((f) => !f.shouldMatch);
+      expect(matching).toHaveLength(5);
+      expect(nonMatching).toHaveLength(10);
+    });
+
+    it('should return 15 fixtures for Notification', () => {
+      const fixtures = generateFixtures('Notification');
+      expect(fixtures).toHaveLength(15);
+    });
+
+    it('should return 15 fixtures for Stop', () => {
+      const fixtures = generateFixtures('Stop');
+      expect(fixtures).toHaveLength(15);
+    });
+
+    it('matching PreToolUse fixtures should have shouldMatch: true', () => {
+      const fixtures = generateFixtures('PreToolUse', 'Bash');
+      const matching = fixtures.filter((f) => f.shouldMatch);
+      for (const f of matching) {
+        expect(f.shouldMatch).toBe(true);
+      }
+    });
+
+    it('non-matching PreToolUse fixtures should have shouldMatch: false', () => {
+      const fixtures = generateFixtures('PreToolUse', 'Write');
+      const nonMatching = fixtures.filter((f) => !f.shouldMatch);
+      for (const f of nonMatching) {
+        expect(f.shouldMatch).toBe(false);
+      }
+    });
+
+    it('PreToolUse matching fixtures should contain tool_name and tool_input', () => {
+      const fixtures = generateFixtures('PreToolUse', 'Write|Edit');
+      const matching = fixtures.filter((f) => f.shouldMatch);
+      for (const f of matching) {
+        expect(f.payload).toHaveProperty('tool_name');
+        expect(f.payload).toHaveProperty('tool_input');
+        const toolInput = f.payload.tool_input as Record<string, unknown>;
+        expect(toolInput).toHaveProperty('file_path');
+        expect(toolInput).toHaveProperty('command');
+      }
+    });
+
+    it('PreToolUse non-matching fixtures should contain tool_name and tool_input', () => {
+      const fixtures = generateFixtures('PreToolUse', 'Write');
+      const nonMatching = fixtures.filter((f) => !f.shouldMatch);
+      for (const f of nonMatching) {
+        expect(f.payload).toHaveProperty('tool_name');
+        expect(f.payload).toHaveProperty('tool_input');
+      }
+    });
+
+    it('should use provided toolMatcher tools in matching fixtures', () => {
+      const fixtures = generateFixtures('PreToolUse', 'Edit|Write');
+      const matching = fixtures.filter((f) => f.shouldMatch);
+      const toolNames = matching.map((f) => f.payload.tool_name);
+      for (const name of toolNames) {
+        expect(['Edit', 'Write']).toContain(name);
+      }
+    });
+
+    it('should default to Write when no toolMatcher provided for PreToolUse', () => {
+      const fixtures = generateFixtures('PreToolUse');
+      const matching = fixtures.filter((f) => f.shouldMatch);
+      for (const f of matching) {
+        expect(f.payload.tool_name).toBe('Write');
+      }
+    });
+
+    it('PreCompact matching fixtures should have session_id', () => {
+      const fixtures = generateFixtures('PreCompact');
+      const matching = fixtures.filter((f) => f.shouldMatch);
+      for (const f of matching) {
+        expect(f.payload).toHaveProperty('session_id');
+        expect(f.payload).toHaveProperty('context');
+      }
+    });
+
+    it('PreCompact non-matching fixtures should have empty payloads', () => {
+      const fixtures = generateFixtures('PreCompact');
+      const nonMatching = fixtures.filter((f) => !f.shouldMatch);
+      for (const f of nonMatching) {
+        expect(Object.keys(f.payload)).toHaveLength(0);
+      }
+    });
+
+    it('all fixtures should have event matching the requested event', () => {
+      for (const event of [
+        'PreToolUse',
+        'PostToolUse',
+        'PreCompact',
+        'Notification',
+        'Stop',
+      ] as const) {
+        const fixtures = generateFixtures(event);
+        for (const f of fixtures) {
+          expect(f.event).toBe(event);
+        }
+      }
+    });
+
+    it('all fixtures should have unique names', () => {
+      const fixtures = generateFixtures('PreToolUse', 'Write|Edit');
+      const names = fixtures.map((f) => f.name);
+      expect(new Set(names).size).toBe(names.length);
+    });
+  });
+
+  describe('validateHookScript', () => {
+    it('should report correctly with a script that produces no output (exit 0)', () => {
+      // execSync mock returns '' (empty string) — no match detected
+      mockedExecSync.mockReturnValue('');
+
+      const fixtures: TestFixture[] = [
+        {
+          name: 'should-match',
+          event: 'PreToolUse',
+          payload: { tool_name: 'Write', tool_input: { file_path: 'test.ts' } },
+          shouldMatch: true,
+        },
+        {
+          name: 'should-not-match',
+          event: 'PreToolUse',
+          payload: { tool_name: 'Read', tool_input: { file_path: 'test.ts' } },
+          shouldMatch: false,
+        },
+      ];
+
+      const report = validateHookScript('/fake/script.sh', fixtures);
+
+      expect(report.total).toBe(2);
+      // Script produces no output, so matched = false for all
+      // should-match expected match but got none -> false negative
+      // should-not-match expected no match and got none -> correct
+      expect(report.falseNegatives).toHaveLength(1);
+      expect(report.falseNegatives[0].fixture.name).toBe('should-match');
+      expect(report.falsePositives).toHaveLength(0);
+      expect(report.passed).toBe(1);
+    });
+
+    it('should detect false positives when script always matches', () => {
+      mockedExecSync.mockReturnValue('{"continue": true, "message": "always matches"}');
+
+      const fixtures: TestFixture[] = [
+        {
+          name: 'should-match',
+          event: 'PreToolUse',
+          payload: { tool_name: 'Write', tool_input: {} },
+          shouldMatch: true,
+        },
+        {
+          name: 'should-not-match',
+          event: 'PreToolUse',
+          payload: { tool_name: 'Read', tool_input: {} },
+          shouldMatch: false,
+        },
+      ];
+
+      const report = validateHookScript('/fake/script.sh', fixtures);
+
+      expect(report.total).toBe(2);
+      // Script always outputs "continue", so matched = true for all
+      // should-not-match expected no match but got one -> false positive
+      expect(report.falsePositives).toHaveLength(1);
+      expect(report.falsePositives[0].fixture.name).toBe('should-not-match');
+      expect(report.falseNegatives).toHaveLength(0);
+      expect(report.passed).toBe(1);
+    });
+
+    it('should report all passed when script matches correctly', () => {
+      mockedExecSync.mockImplementation((cmd: unknown) => {
+        if (typeof cmd === 'string' && cmd.includes('Write')) {
+          return '{"continue": true, "message": "matched"}';
+        }
+        return '';
+      });
+
+      const fixtures: TestFixture[] = [
+        {
+          name: 'should-match',
+          event: 'PreToolUse',
+          payload: { tool_name: 'Write', tool_input: {} },
+          shouldMatch: true,
+        },
+        {
+          name: 'should-not-match',
+          event: 'PreToolUse',
+          payload: { tool_name: 'Read', tool_input: {} },
+          shouldMatch: false,
+        },
+      ];
+
+      const report = validateHookScript('/fake/script.sh', fixtures);
+
+      expect(report.total).toBe(2);
+      expect(report.passed).toBe(2);
+      expect(report.falsePositives).toHaveLength(0);
+      expect(report.falseNegatives).toHaveLength(0);
+    });
+
+    it('should handle script errors gracefully (exit code != 0)', () => {
+      mockedExecSync.mockImplementation(() => {
+        const err = new Error('script failed') as Error & { status: number; stdout: string };
+        err.status = 1;
+        err.stdout = '';
+        throw err;
+      });
+
+      const fixtures: TestFixture[] = [
+        {
+          name: 'error-fixture',
+          event: 'PreToolUse',
+          payload: { tool_name: 'Write', tool_input: {} },
+          shouldMatch: true,
+        },
+      ];
+
+      const report = validateHookScript('/fake/script.sh', fixtures);
+
+      expect(report.total).toBe(1);
+      // Error means matched = false, but shouldMatch = true -> false negative
+      expect(report.falseNegatives).toHaveLength(1);
+      expect(report.passed).toBe(0);
+    });
+  });
+});

package/src/__tests__/wizard-e2e.mjs

@@ -2,7 +2,7 @@
 /**
  * Comprehensive E2E tests for the interactive create wizard.
  *
- * Tests all 7 archetypes, custom path, custom greeting, custom domains/principles,
+ * Tests custom path, custom greeting, custom domains/principles,
  * hook pack selection, cancel flows, and decline flows.
  *
  * Run: node packages/cli/src/__tests__/wizard-e2e.mjs

package/src/commands/agent.ts

@@ -26,6 +26,7 @@ import {
   generateInjectClaudeMd,
   generateSkills,
 } from '@soleri/forge/lib';
+import { composeClaudeMd, getEngineRulesContent } from '@soleri/forge/lib';
 import type { AgentConfig } from '@soleri/forge/lib';
 import { detectAgent } from '../utils/agent-context.js';
 import { installClaude } from './install.js';
@@ -194,7 +195,70 @@ export function registerAgent(program: Command): void {
         return;
       }
 
-      // Reconstruct AgentConfig from the existing agent
+      // ─── File-tree agent (v7+) ────────────────────────────────
+      if (ctx.format === 'filetree') {
+        const enginePath = join(ctx.agentPath, 'instructions', '_engine.md');
+        const claudeMdPath = join(ctx.agentPath, 'CLAUDE.md');
+
+        // Generate skills from latest forge templates
+        const skillFiles = opts.skipSkills
+          ? []
+          : generateSkills({ id: ctx.agentId } as AgentConfig);
+
+        if (opts.dryRun) {
+          p.log.info(`Would regenerate: ${enginePath}`);
+          p.log.info(`Would regenerate: ${claudeMdPath}`);
+          if (skillFiles.length > 0) {
+            const newSkills = skillFiles.filter(
+              ([relPath]) => !existsSync(join(ctx.agentPath, relPath)),
+            );
+            const updatedSkills = skillFiles.filter(([relPath]) =>
+              existsSync(join(ctx.agentPath, relPath)),
+            );
+            p.log.info(
+              `Skills: ${skillFiles.length} total (${newSkills.length} new, ${updatedSkills.length} updated)`,
+            );
+            for (const [relPath] of newSkills) {
+              p.log.info(`  + ${relPath}`);
+            }
+          }
+          p.log.info(`Agent: ${ctx.agentId} (file-tree format)`);
+          return;
+        }
+
+        // 1. Sync skills from forge templates
+        if (skillFiles.length > 0) {
+          let newCount = 0;
+          let updatedCount = 0;
+          for (const [relPath, content] of skillFiles) {
+            const fullPath = join(ctx.agentPath, relPath);
+            const dirPath = dirname(fullPath);
+            const isNew = !existsSync(fullPath);
+            mkdirSync(dirPath, { recursive: true });
+            writeFileSync(fullPath, content, 'utf-8');
+            if (isNew) newCount++;
+            else updatedCount++;
+          }
+          p.log.success(
+            `Synced ${skillFiles.length} skills (${newCount} new, ${updatedCount} updated)`,
+          );
+        }
+
+        // 2. Regenerate _engine.md from latest shared-rules
+        mkdirSync(join(ctx.agentPath, 'instructions'), { recursive: true });
+        writeFileSync(enginePath, getEngineRulesContent(), 'utf-8');
+        p.log.success(`Regenerated ${enginePath}`);
+
+        // 3. Recompose CLAUDE.md from agent.yaml + instructions + workflows + skills
+        const result = composeClaudeMd(ctx.agentPath);
+        writeFileSync(claudeMdPath, result.content, 'utf-8');
+        p.log.success(
+          `Regenerated ${claudeMdPath} (${result.sources.length} sources, ${result.content.length} bytes)`,
+        );
+        return;
+      }
+
+      // ─── Legacy TypeScript agent ──────────────────────────────
       const config = readAgentConfig(ctx.agentPath, ctx.agentId);
       if (!config) {
         p.log.error('Could not read agent config from persona.ts and entry point.');
@@ -216,7 +280,6 @@ export function registerAgent(program: Command): void {
         p.log.info(`Agent: ${config.name} (${config.domains.length} domains)`);
         p.log.info(`Domains: ${config.domains.join(', ')}`);
         if (skillFiles.length > 0) {
-          // Check which skills are new vs existing
           const newSkills = skillFiles.filter(
             ([relPath]) => !existsSync(join(ctx.agentPath, relPath)),
           );

package/src/commands/hooks.ts

@@ -1,9 +1,24 @@
 import type { Command } from 'commander';
+import { mkdirSync, writeFileSync, chmodSync, existsSync } from 'node:fs';
+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 { listPacks, getPack } from '../hook-packs/registry.js';
 import { installPack, removePack, isPackInstalled } from '../hook-packs/installer.js';
+import { promotePack, demotePack } from '../hook-packs/graduation.js';
+import {
+  generateHookScript,
+  generateManifest,
+  HOOK_EVENTS,
+  ACTION_LEVELS,
+} from '../hook-packs/converter/template.js';
+import type {
+  HookEvent,
+  ActionLevel,
+  HookConversionConfig,
+} from '../hook-packs/converter/template.js';
+import { generateFixtures, validateHookScript } from '../hook-packs/validator.js';
 import * as log from '../utils/logger.js';
 
 export function registerHooks(program: Command): void {
@@ -201,6 +216,163 @@ export function registerHooks(program: Command): void {
       const total = installed.length + scripts.length + lifecycleHooks.length;
       log.info(`Pack "${packName}" upgraded to v${packVersion} (${total} items)`);
     });
+
+  hooks
+    .command('convert')
+    .argument('<name>', 'Name for the converted hook pack (kebab-case)')
+    .requiredOption(
+      '--event <event>',
+      'Hook event: PreToolUse, PostToolUse, PreCompact, Notification, Stop',
+    )
+    .option(
+      '--matcher <tools>',
+      'Tool name matcher (e.g., "Write|Edit") — for PreToolUse/PostToolUse',
+    )
+    .option('--pattern <globs...>', 'File glob patterns to match (e.g., "**/marketing/**")')
+    .option('--action <level>', 'Action level: remind (default), warn, block', 'remind')
+    .requiredOption('--message <text>', 'Context message when hook fires')
+    .option('--project', 'Output to .soleri/hook-packs/ instead of built-in packs dir')
+    .description('Convert a skill into an automated hook pack')
+    .action(
+      (
+        name: string,
+        opts: {
+          event: string;
+          matcher?: string;
+          pattern?: string[];
+          action: string;
+          message: string;
+          project?: boolean;
+        },
+      ) => {
+        if (!HOOK_EVENTS.includes(opts.event as HookEvent)) {
+          log.fail(`Invalid event "${opts.event}". Must be one of: ${HOOK_EVENTS.join(', ')}`);
+          process.exit(1);
+        }
+
+        if (!ACTION_LEVELS.includes(opts.action as ActionLevel)) {
+          log.fail(`Invalid action "${opts.action}". Must be one of: ${ACTION_LEVELS.join(', ')}`);
+          process.exit(1);
+        }
+
+        const config: HookConversionConfig = {
+          name,
+          event: opts.event as HookEvent,
+          toolMatcher: opts.matcher,
+          filePatterns: opts.pattern,
+          action: opts.action as ActionLevel,
+          message: opts.message,
+        };
+
+        const script = generateHookScript(config);
+        const manifest = generateManifest(config);
+
+        const baseDir = opts.project
+          ? join(process.cwd(), '.soleri', 'hook-packs', name)
+          : join(process.cwd(), 'packages', 'cli', 'src', 'hook-packs', name);
+
+        const scriptsDir = join(baseDir, 'scripts');
+        mkdirSync(scriptsDir, { recursive: true });
+
+        const manifestPath = join(baseDir, 'manifest.json');
+        writeFileSync(manifestPath, JSON.stringify(manifest, null, 2) + '\n');
+        log.pass(`Created ${manifestPath}`);
+
+        const scriptPath = join(scriptsDir, `${name}.sh`);
+        writeFileSync(scriptPath, script);
+        if (process.platform !== 'win32') {
+          chmodSync(scriptPath, 0o755);
+        }
+        log.pass(`Created ${scriptPath}`);
+
+        log.info(`Hook pack "${name}" generated (event: ${opts.event}, action: ${opts.action})`);
+      },
+    );
+  hooks
+    .command('promote')
+    .argument('<pack>', 'Hook pack name')
+    .description('Promote hook action level: remind → warn → block')
+    .action((packName: string) => {
+      try {
+        const result = promotePack(packName);
+        log.pass(`${packName}: ${result.previousLevel} → ${result.newLevel}`);
+      } catch (err: unknown) {
+        log.fail((err as Error).message);
+        process.exit(1);
+      }
+    });
+
+  hooks
+    .command('demote')
+    .argument('<pack>', 'Hook pack name')
+    .description('Demote hook action level: block → warn → remind')
+    .action((packName: string) => {
+      try {
+        const result = demotePack(packName);
+        log.pass(`${packName}: ${result.previousLevel} → ${result.newLevel}`);
+      } catch (err: unknown) {
+        log.fail((err as Error).message);
+        process.exit(1);
+      }
+    });
+
+  hooks
+    .command('test')
+    .argument('<pack>', 'Hook pack name to test')
+    .description('Run validation tests against a hook pack')
+    .action((packName: string) => {
+      const pack = getPack(packName);
+      if (!pack) {
+        log.fail(`Unknown pack "${packName}"`);
+        process.exit(1);
+      }
+
+      // Find the script
+      const scripts = pack.manifest.scripts;
+      if (!scripts || scripts.length === 0) {
+        log.fail(`Pack "${packName}" has no scripts to test`);
+        process.exit(1);
+      }
+
+      const scriptFile = scripts[0].file;
+      // Resolve script path from pack directory
+      const scriptPath = join(pack.dir, 'scripts', scriptFile);
+
+      if (!existsSync(scriptPath)) {
+        log.fail(`Script not found: ${scriptPath}`);
+        process.exit(1);
+      }
+
+      // Determine event and matcher from lifecycle hooks
+      const lc = pack.manifest.lifecycleHooks?.[0];
+      const event = (lc?.event ?? 'PreToolUse') as HookEvent;
+      const toolMatcher = lc?.matcher;
+
+      // Generate fixtures and run
+      const fixtures = generateFixtures(event, toolMatcher);
+      log.heading(`Testing ${packName} (${fixtures.length} fixtures)`);
+
+      const report = validateHookScript(scriptPath, fixtures);
+      log.info(`Results: ${report.passed}/${report.total} passed`);
+
+      if (report.falsePositives.length > 0) {
+        log.fail(`False positives: ${report.falsePositives.length}`);
+        for (const fp of report.falsePositives) {
+          log.warn(`  ${fp.fixture.name}: expected no match, got output`);
+        }
+      }
+
+      if (report.falseNegatives.length > 0) {
+        log.warn(`False negatives: ${report.falseNegatives.length}`);
+        for (const fn of report.falseNegatives) {
+          log.warn(`  ${fn.fixture.name}: expected match, got no output`);
+        }
+      }
+
+      if (report.falsePositives.length === 0 && report.falseNegatives.length === 0) {
+        log.pass('All fixtures passed — zero false positives');
+      }
+    });
 }
 
 function isValidEditor(editor: string): editor is EditorId {

package/src/commands/install.ts

@@ -170,6 +170,12 @@ function escapeRegExp(s: string): string {
  * e.g., typing `ernesto` opens Claude Code with that agent's MCP config.
  */
 function installLauncher(agentId: string, agentDir: string): void {
+  // Launcher scripts to /usr/local/bin are Unix-only
+  if (process.platform === 'win32') {
+    p.log.info('Launcher scripts are not supported on Windows — skipping');
+    return;
+  }
+
   const binPath = join('/usr/local/bin', agentId);
 
   const script = [