@soleri/cli 1.1.0 → 1.3.0

package/src/hook-packs/installer.ts

@@ -1,11 +1,17 @@
 /**
- * Hook pack installer — copies hookify files to ~/.claude/ for global enforcement.
+ * Hook pack installer — copies hookify files to ~/.claude/ (global) or project .claude/ (local).
  */
-import { existsSync, copyFileSync, unlinkSync, mkdirSync } from 'node:fs';
+import { existsSync, copyFileSync, unlinkSync, mkdirSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { homedir } from 'node:os';
 import { getPack } from './registry.js';
 
+/** 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.
@@ -38,16 +44,19 @@ function resolveHookFiles(packName: string): Map<string, string> {
 }
 
 /**
- * Install a hook pack globally to ~/.claude/.
+ * Install a hook pack to ~/.claude/ (default) or project .claude/ (--project).
  * Skips files that already exist (idempotent).
  */
-export function installPack(packName: string): { installed: string[]; skipped: string[] } {
+export function installPack(
+  packName: string,
+  options?: { projectDir?: string },
+): { installed: string[]; skipped: string[] } {
   const pack = getPack(packName);
   if (!pack) {
     throw new Error(`Unknown hook pack: "${packName}"`);
   }
 
-  const claudeDir = join(homedir(), '.claude');
+  const claudeDir = resolveClaudeDir(options?.projectDir);
   mkdirSync(claudeDir, { recursive: true });
 
   const hookFiles = resolveHookFiles(packName);
@@ -68,15 +77,18 @@ export function installPack(packName: string): { installed: string[]; skipped: s
 }
 
 /**
- * Remove a hook pack's files from ~/.claude/.
+ * Remove a hook pack's files from target directory.
  */
-export function removePack(packName: string): { removed: string[] } {
+export function removePack(
+  packName: string,
+  options?: { projectDir?: string },
+): { removed: string[] } {
   const pack = getPack(packName);
   if (!pack) {
     throw new Error(`Unknown hook pack: "${packName}"`);
   }
 
-  const claudeDir = join(homedir(), '.claude');
+  const claudeDir = resolveClaudeDir(options?.projectDir);
   const removed: string[] = [];
 
   for (const hook of pack.manifest.hooks) {
@@ -94,11 +106,14 @@ export function removePack(packName: string): { removed: string[] } {
  * Check if a pack is installed.
  * Returns true (all hooks present), false (none present), or 'partial'.
  */
-export function isPackInstalled(packName: string): boolean | 'partial' {
+export function isPackInstalled(
+  packName: string,
+  options?: { projectDir?: string },
+): boolean | 'partial' {
   const pack = getPack(packName);
   if (!pack) return false;
 
-  const claudeDir = join(homedir(), '.claude');
+  const claudeDir = resolveClaudeDir(options?.projectDir);
   let present = 0;
 
   for (const hook of pack.manifest.hooks) {
@@ -111,3 +126,20 @@ export function isPackInstalled(packName: string): boolean | 'partial' {
   if (present === pack.manifest.hooks.length) return true;
   return 'partial';
 }
+
+/**
+ * Get the installed version of a hook from its file header.
+ * Returns null if no version found or file doesn't exist.
+ */
+export function getInstalledHookVersion(
+  hook: string,
+  options?: { projectDir?: string },
+): string | null {
+  const claudeDir = resolveClaudeDir(options?.projectDir);
+  const filePath = join(claudeDir, `hookify.${hook}.local.md`);
+  if (!existsSync(filePath)) return null;
+
+  const content = readFileSync(filePath, 'utf-8');
+  const match = content.match(/^# Version: (.+)$/m);
+  return match ? match[1] : null;
+}

package/src/hook-packs/registry.ts

@@ -11,21 +11,27 @@ export interface HookPackManifest {
   description: string;
   hooks: string[];
   composedFrom?: string[];
+  version?: string;
+  /** Whether this pack is built-in or user-defined */
+  source?: 'built-in' | 'local';
 }
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 
 /** Root directory containing all built-in hook packs. */
-function getPacksRoot(): string {
+function getBuiltinRoot(): string {
   return __dirname;
 }
 
-/**
- * List all available built-in hook packs.
- */
-export function listPacks(): HookPackManifest[] {
-  const root = getPacksRoot();
+/** 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[] = [];
 
@@ -36,6 +42,7 @@ export function listPacks(): HookPackManifest[] {
 
     try {
       const manifest = JSON.parse(readFileSync(manifestPath, 'utf-8')) as HookPackManifest;
+      manifest.source = source;
       packs.push(manifest);
     } catch {
       // Skip malformed manifests
@@ -46,18 +53,47 @@ export function listPacks(): HookPackManifest[] {
 }
 
 /**
- * Get a specific pack by name.
+ * 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 {
-  const root = getPacksRoot();
-  const dir = join(root, name);
-  const manifestPath = join(dir, 'manifest.json');
+  // Check local first
+  const localDir = join(getLocalRoot(), name);
+  const localManifest = join(localDir, 'manifest.json');
+  if (existsSync(localManifest)) {
+    try {
+      const manifest = JSON.parse(readFileSync(localManifest, 'utf-8')) as HookPackManifest;
+      manifest.source = 'local';
+      return { manifest, dir: localDir };
+    } catch {
+      // Fall through to built-in
+    }
+  }
 
-  if (!existsSync(manifestPath)) return null;
+  // 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(manifestPath, 'utf-8')) as HookPackManifest;
-    return { manifest, dir };
+    const manifest = JSON.parse(readFileSync(builtinManifest, 'utf-8')) as HookPackManifest;
+    manifest.source = 'built-in';
+    return { manifest, dir: builtinDir };
   } catch {
     return null;
   }

package/src/hook-packs/typescript-safety/hookify.no-any-types.local.md

@@ -1,5 +1,6 @@
 ---
 # Soleri Hook Pack: typescript-safety
+# Version: 1.0.0
 # Rule: no-any-types
 name: no-any-types
 enabled: true

package/src/hook-packs/typescript-safety/hookify.no-console-log.local.md

@@ -1,5 +1,6 @@
 ---
 # Soleri Hook Pack: typescript-safety
+# Version: 1.0.0
 # Rule: no-console-log
 name: no-console-log
 enabled: true

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

@@ -1,5 +1,6 @@
 {
   "name": "typescript-safety",
+  "version": "1.0.0",
   "description": "Block unsafe TypeScript patterns",
   "hooks": ["no-any-types", "no-console-log"]
 }

package/src/utils/checks.ts

@@ -6,6 +6,7 @@ import { join } from 'node:path';
 import { execFileSync } from 'node:child_process';
 import { homedir } from 'node:os';
 import { detectAgent } from './agent-context.js';
+import { getInstalledPacks } from '../hook-packs/registry.js';
 
 interface CheckResult {
   status: 'pass' | 'fail' | 'warn';
@@ -134,6 +135,22 @@ function checkCognee(): CheckResult {
   }
 }
 
+export function checkHookPacks(): CheckResult {
+  const installed = getInstalledPacks();
+  if (installed.length === 0) {
+    return {
+      status: 'warn',
+      label: 'Hook packs',
+      detail: 'none installed — run soleri hooks list-packs',
+    };
+  }
+  return {
+    status: 'pass',
+    label: 'Hook packs',
+    detail: installed.join(', '),
+  };
+}
+
 export function runAllChecks(dir?: string): CheckResult[] {
   return [
     checkNodeVersion(),
@@ -143,6 +160,7 @@ export function runAllChecks(dir?: string): CheckResult[] {
     checkNodeModules(dir),
     checkAgentBuild(dir),
     checkMcpRegistration(dir),
+    checkHookPacks(),
     checkCognee(),
   ];
 }