@soleri/cli 9.0.2 → 9.3.0

package/src/hook-packs/installer.ts

@@ -1,29 +1,33 @@
 /**
- * Hook pack installer — copies hookify files to ~/.claude/ (global) or project .claude/ (local).
+ * Hook pack installer — copies hookify files and scripts to ~/.claude/ (global) or project .claude/ (local).
+ * Also manages lifecycle hooks in ~/.claude/settings.json.
  */
-import { existsSync, copyFileSync, unlinkSync, mkdirSync } from 'node:fs';
+import {
+  existsSync,
+  copyFileSync,
+  unlinkSync,
+  mkdirSync,
+  readFileSync,
+  writeFileSync,
+  chmodSync,
+} from 'node:fs';
 import { join } from 'node:path';
 import { homedir } from 'node:os';
 import { getPack } from './registry.js';
+import type { HookPackLifecycleHook } from './registry.js';
+
+const PACK_MARKER = '_soleriPack';
 
-/** Resolve the target .claude/ directory. */
 function resolveClaudeDir(projectDir?: string): string {
   if (projectDir) return join(projectDir, '.claude');
   return join(homedir(), '.claude');
 }
 
-/**
- * Resolve all hookify file paths for a pack, handling composed packs.
- * Returns a map of hook name → source file path.
- */
 function resolveHookFiles(packName: string): Map<string, string> {
   const pack = getPack(packName);
   if (!pack) return new Map();
-
   const files = new Map<string, string>();
-
   if (pack.manifest.composedFrom) {
-    // Composed pack: gather files from constituent packs
     for (const subPackName of pack.manifest.composedFrom) {
       const subFiles = resolveHookFiles(subPackName);
       for (const [hook, path] of subFiles) {
@@ -31,7 +35,6 @@ function resolveHookFiles(packName: string): Map<string, string> {
       }
     }
   } else {
-    // Direct pack: look for hookify files in the pack directory
     for (const hook of pack.manifest.hooks) {
       const filePath = join(pack.dir, `hookify.${hook}.local.md`);
       if (existsSync(filePath)) {
@@ -39,30 +42,143 @@ function resolveHookFiles(packName: string): Map<string, string> {
       }
     }
   }
-
   return files;
 }
 
-/**
- * Install a hook pack to ~/.claude/ (default) or project .claude/ (--project).
- * Skips files that already exist (idempotent).
- */
+function resolveScripts(
+  packName: string,
+): Map<string, { sourcePath: string; targetDir: string; file: string }> {
+  const pack = getPack(packName);
+  if (!pack) return new Map();
+  const scripts = new Map<string, { sourcePath: string; targetDir: string; file: string }>();
+  if (pack.manifest.composedFrom) {
+    for (const subPackName of pack.manifest.composedFrom) {
+      const subScripts = resolveScripts(subPackName);
+      for (const [name, info] of subScripts) {
+        scripts.set(name, info);
+      }
+    }
+  } else if (pack.manifest.scripts) {
+    for (const script of pack.manifest.scripts) {
+      const sourcePath = join(pack.dir, 'scripts', script.file);
+      if (existsSync(sourcePath)) {
+        scripts.set(script.name, { sourcePath, targetDir: script.targetDir, file: script.file });
+      }
+    }
+  }
+  return scripts;
+}
+
+function resolveLifecycleHooks(
+  packName: string,
+): { packName: string; hook: HookPackLifecycleHook }[] {
+  const pack = getPack(packName);
+  if (!pack) return [];
+  const hooks: { packName: string; hook: HookPackLifecycleHook }[] = [];
+  if (pack.manifest.composedFrom) {
+    for (const subPackName of pack.manifest.composedFrom) {
+      hooks.push(...resolveLifecycleHooks(subPackName));
+    }
+  } else if (pack.manifest.lifecycleHooks) {
+    for (const hook of pack.manifest.lifecycleHooks) {
+      hooks.push({ packName: pack.manifest.name, hook });
+    }
+  }
+  return hooks;
+}
+
+interface SettingsHookEntry {
+  type: 'command';
+  command: string;
+  timeout?: number;
+  [key: string]: unknown;
+}
+
+function readClaudeSettings(claudeDir: string): Record<string, unknown> {
+  const settingsPath = join(claudeDir, 'settings.json');
+  if (!existsSync(settingsPath)) return {};
+  try {
+    return JSON.parse(readFileSync(settingsPath, 'utf-8'));
+  } catch {
+    return {};
+  }
+}
+
+function writeClaudeSettings(claudeDir: string, settings: Record<string, unknown>): void {
+  const settingsPath = join(claudeDir, 'settings.json');
+  writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + '\n', 'utf-8');
+}
+
+function addLifecycleHooks(
+  claudeDir: string,
+  lifecycleHooks: { packName: string; hook: HookPackLifecycleHook }[],
+): string[] {
+  if (lifecycleHooks.length === 0) return [];
+  const settings = readClaudeSettings(claudeDir);
+  const hooks = (settings['hooks'] ?? {}) as Record<string, unknown>;
+  const added: string[] = [];
+  for (const { packName: sourcePack, hook } of lifecycleHooks) {
+    const eventKey = hook.event;
+    const eventHooks = (hooks[eventKey] ?? []) as SettingsHookEntry[];
+    const alreadyExists = eventHooks.some(
+      (h) => h.command === hook.command && h[PACK_MARKER] === sourcePack,
+    );
+    if (!alreadyExists) {
+      const entry: SettingsHookEntry = {
+        type: hook.type,
+        command: hook.command,
+        [PACK_MARKER]: sourcePack,
+      };
+      if (hook.timeout) {
+        entry.timeout = hook.timeout;
+      }
+      eventHooks.push(entry);
+      hooks[eventKey] = eventHooks;
+      added.push(`${eventKey}:${hook.matcher}`);
+    }
+  }
+  settings['hooks'] = hooks;
+  writeClaudeSettings(claudeDir, settings);
+  return added;
+}
+
+function removeLifecycleHooks(claudeDir: string, packName: string): string[] {
+  const settings = readClaudeSettings(claudeDir);
+  const hooks = (settings['hooks'] ?? {}) as Record<string, SettingsHookEntry[]>;
+  const removed: string[] = [];
+  for (const [eventKey, eventHooks] of Object.entries(hooks)) {
+    if (!Array.isArray(eventHooks)) continue;
+    const before = eventHooks.length;
+    const filtered = eventHooks.filter((h) => h[PACK_MARKER] !== packName);
+    if (filtered.length < before) {
+      removed.push(eventKey);
+      if (filtered.length === 0) {
+        delete hooks[eventKey];
+      } else {
+        hooks[eventKey] = filtered;
+      }
+    }
+  }
+  if (removed.length > 0) {
+    settings['hooks'] = hooks;
+    writeClaudeSettings(claudeDir, settings);
+  }
+  return removed;
+}
+
 export function installPack(
   packName: string,
   options?: { projectDir?: string },
-): { installed: string[]; skipped: string[] } {
+): { installed: string[]; skipped: string[]; scripts: string[]; lifecycleHooks: string[] } {
   const pack = getPack(packName);
   if (!pack) {
     throw new Error(`Unknown hook pack: "${packName}"`);
   }
-
   const claudeDir = resolveClaudeDir(options?.projectDir);
   mkdirSync(claudeDir, { recursive: true });
-
   const hookFiles = resolveHookFiles(packName);
   const installed: string[] = [];
   const skipped: string[] = [];
-
   for (const [hook, sourcePath] of hookFiles) {
     const destPath = join(claudeDir, `hookify.${hook}.local.md`);
     if (existsSync(destPath)) {
@@ -72,25 +188,31 @@ export function installPack(
       installed.push(hook);
     }
   }
-
-  return { installed, skipped };
+  const scriptFiles = resolveScripts(packName);
+  const installedScripts: string[] = [];
+  for (const [, { sourcePath, targetDir, file }] of scriptFiles) {
+    const destDir = join(claudeDir, targetDir);
+    mkdirSync(destDir, { recursive: true });
+    const destPath = join(destDir, file);
+    copyFileSync(sourcePath, destPath);
+    chmodSync(destPath, 0o755);
+    installedScripts.push(`${targetDir}/${file}`);
+  }
+  const lcHooks = resolveLifecycleHooks(packName);
+  const addedHooks = addLifecycleHooks(claudeDir, lcHooks);
+  return { installed, skipped, scripts: installedScripts, lifecycleHooks: addedHooks };
 }
 
-/**
- * Remove a hook pack's files from target directory.
- */
 export function removePack(
   packName: string,
   options?: { projectDir?: string },
-): { removed: string[] } {
+): { removed: string[]; scripts: string[]; lifecycleHooks: string[] } {
   const pack = getPack(packName);
   if (!pack) {
     throw new Error(`Unknown hook pack: "${packName}"`);
   }
-
   const claudeDir = resolveClaudeDir(options?.projectDir);
   const removed: string[] = [];
-
   for (const hook of pack.manifest.hooks) {
     const filePath = join(claudeDir, `hookify.${hook}.local.md`);
     if (existsSync(filePath)) {
@@ -98,31 +220,94 @@ export function removePack(
       removed.push(hook);
     }
   }
-
-  return { removed };
+  const removedScripts: string[] = [];
+  if (pack.manifest.scripts) {
+    for (const script of pack.manifest.scripts) {
+      const filePath = join(claudeDir, script.targetDir, script.file);
+      if (existsSync(filePath)) {
+        unlinkSync(filePath);
+        removedScripts.push(`${script.targetDir}/${script.file}`);
+      }
+    }
+  }
+  if (pack.manifest.composedFrom) {
+    for (const subPackName of pack.manifest.composedFrom) {
+      const subPack = getPack(subPackName);
+      if (subPack?.manifest.scripts) {
+        for (const script of subPack.manifest.scripts) {
+          const filePath = join(claudeDir, script.targetDir, script.file);
+          if (existsSync(filePath)) {
+            unlinkSync(filePath);
+            removedScripts.push(`${script.targetDir}/${script.file}`);
+          }
+        }
+      }
+    }
+  }
+  const removedHooks = removeLifecycleHooks(claudeDir, packName);
+  if (pack.manifest.composedFrom) {
+    for (const subPackName of pack.manifest.composedFrom) {
+      removedHooks.push(...removeLifecycleHooks(claudeDir, subPackName));
+    }
+  }
+  return { removed, scripts: removedScripts, lifecycleHooks: removedHooks };
 }
 
-/**
- * Check if a pack is installed.
- * Returns true (all hooks present), false (none present), or 'partial'.
- */
 export function isPackInstalled(
   packName: string,
   options?: { projectDir?: string },
 ): boolean | 'partial' {
   const pack = getPack(packName);
   if (!pack) return false;
-
   const claudeDir = resolveClaudeDir(options?.projectDir);
+  let total = 0;
   let present = 0;
-
   for (const hook of pack.manifest.hooks) {
+    total++;
     if (existsSync(join(claudeDir, `hookify.${hook}.local.md`))) {
       present++;
     }
   }
-
+  if (pack.manifest.scripts) {
+    for (const script of pack.manifest.scripts) {
+      total++;
+      if (existsSync(join(claudeDir, script.targetDir, script.file))) {
+        present++;
+      }
+    }
+  }
+  if (pack.manifest.composedFrom) {
+    for (const subPackName of pack.manifest.composedFrom) {
+      const subPack = getPack(subPackName);
+      if (subPack?.manifest.scripts) {
+        for (const script of subPack.manifest.scripts) {
+          total++;
+          if (existsSync(join(claudeDir, script.targetDir, script.file))) {
+            present++;
+          }
+        }
+      }
+    }
+  }
+  if (total === 0) {
+    const lcHooks = resolveLifecycleHooks(packName);
+    if (lcHooks.length > 0) {
+      const settings = readClaudeSettings(claudeDir);
+      const hooksObj = (settings['hooks'] ?? {}) as Record<string, SettingsHookEntry[]>;
+      for (const { packName: sourcePack, hook } of lcHooks) {
+        total++;
+        const eventHooks = hooksObj[hook.event];
+        if (
+          Array.isArray(eventHooks) &&
+          eventHooks.some((h) => h.command === hook.command && h[PACK_MARKER] === sourcePack)
+        ) {
+          present++;
+        }
+      }
+    }
+  }
+  if (total === 0) return false;
   if (present === 0) return false;
-  if (present === pack.manifest.hooks.length) return true;
+  if (present === total) return true;
   return 'partial';
 }

package/src/hook-packs/registry.ts

@@ -6,73 +6,71 @@ import { join, dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { homedir } from 'node:os';
 
-interface HookPackManifest {
+export interface HookPackScript {
+  name: string;
+  file: string;
+  targetDir: string;
+}
+
+export interface HookPackLifecycleHook {
+  event: string;
+  matcher: string;
+  type: 'command';
+  command: string;
+  timeout?: number;
+  statusMessage?: string;
+}
+
+export interface HookPackManifest {
   name: string;
   description: string;
   hooks: string[];
   composedFrom?: string[];
   version?: string;
-  /** Whether this pack is built-in or user-defined */
+  scripts?: HookPackScript[];
+  lifecycleHooks?: HookPackLifecycleHook[];
   source?: 'built-in' | 'local';
 }
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 
-/** Root directory containing all built-in hook packs. */
 function getBuiltinRoot(): string {
   return __dirname;
 }
-
-/** Local custom packs directory. */
 function getLocalRoot(): string {
   return join(process.cwd(), '.soleri', 'hook-packs');
 }
 
-/** Scan a directory for pack manifests. */
 function scanPacksDir(root: string, source: 'built-in' | 'local'): HookPackManifest[] {
   if (!existsSync(root)) return [];
   const entries = readdirSync(root, { withFileTypes: true });
   const packs: HookPackManifest[] = [];
-
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
     const manifestPath = join(root, entry.name, 'manifest.json');
     if (!existsSync(manifestPath)) continue;
-
     try {
       const manifest = JSON.parse(readFileSync(manifestPath, 'utf-8')) as HookPackManifest;
       manifest.source = source;
       packs.push(manifest);
     } catch {
-      // Skip malformed manifests
+      /* Skip malformed manifests */
     }
   }
-
   return packs;
 }
 
-/**
- * List all available hook packs (built-in + local custom).
- * Local packs in .soleri/hook-packs/ override built-in packs with the same name.
- */
 export function listPacks(): HookPackManifest[] {
   const builtIn = scanPacksDir(getBuiltinRoot(), 'built-in');
   const local = scanPacksDir(getLocalRoot(), 'local');
-
-  // Local packs override built-in packs with same name
   const byName = new Map<string, HookPackManifest>();
   for (const pack of builtIn) byName.set(pack.name, pack);
   for (const pack of local) byName.set(pack.name, pack);
-
   return Array.from(byName.values());
 }
 
-/**
- * Get a specific pack by name. Local packs take precedence.
- */
 export function getPack(name: string): { manifest: HookPackManifest; dir: string } | null {
-  // Check local first
   const localDir = join(getLocalRoot(), name);
   const localManifest = join(localDir, 'manifest.json');
   if (existsSync(localManifest)) {
@@ -81,15 +79,12 @@ export function getPack(name: string): { manifest: HookPackManifest; dir: string
       manifest.source = 'local';
       return { manifest, dir: localDir };
     } catch {
-      // Fall through to built-in
+      /* Fall through */
     }
   }
-
-  // Then built-in
   const builtinDir = join(getBuiltinRoot(), name);
   const builtinManifest = join(builtinDir, 'manifest.json');
   if (!existsSync(builtinManifest)) return null;
-
   try {
     const manifest = JSON.parse(readFileSync(builtinManifest, 'utf-8')) as HookPackManifest;
     manifest.source = 'built-in';
@@ -99,15 +94,22 @@ export function getPack(name: string): { manifest: HookPackManifest; dir: string
   }
 }
 
-/**
- * Get names of packs that are fully installed in ~/.claude/.
- */
 export function getInstalledPacks(): string[] {
   const claudeDir = join(homedir(), '.claude');
   const packs = listPacks();
   const installed: string[] = [];
-
   for (const pack of packs) {
+    if (pack.hooks.length === 0) {
+      if (pack.scripts && pack.scripts.length > 0) {
+        const allScripts = pack.scripts.every((script) =>
+          existsSync(join(claudeDir, script.targetDir, script.file)),
+        );
+        if (allScripts) {
+          installed.push(pack.name);
+        }
+      }
+      continue;
+    }
     const allPresent = pack.hooks.every((hook) =>
       existsSync(join(claudeDir, `hookify.${hook}.local.md`)),
     );
@@ -115,6 +117,5 @@ export function getInstalledPacks(): string[] {
       installed.push(pack.name);
     }
   }
-
   return installed;
 }

package/src/hook-packs/yolo-safety/manifest.json

@@ -0,0 +1,23 @@
+{
+  "name": "yolo-safety",
+  "version": "1.0.0",
+  "description": "Anti-deletion guardrail for YOLO mode — intercepts destructive commands, stages files for review",
+  "hooks": [],
+  "scripts": [
+    {
+      "name": "anti-deletion",
+      "file": "anti-deletion.sh",
+      "targetDir": "hooks"
+    }
+  ],
+  "lifecycleHooks": [
+    {
+      "event": "PreToolUse",
+      "matcher": "Bash",
+      "type": "command",
+      "command": "bash ~/.claude/hooks/anti-deletion.sh",
+      "timeout": 10,
+      "statusMessage": "Checking for destructive commands..."
+    }
+  ]
+}