@soleri/cli 1.0.4 → 1.1.0

package/dist/hook-packs/registry.ts

@@ -0,0 +1,84 @@
+/**
+ * Hook pack registry — discovers built-in packs and checks installation status.
+ */
+import { readdirSync, readFileSync, existsSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { homedir } from 'node:os';
+
+export interface HookPackManifest {
+  name: string;
+  description: string;
+  hooks: string[];
+  composedFrom?: string[];
+}
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+/** Root directory containing all built-in hook packs. */
+function getPacksRoot(): string {
+  return __dirname;
+}
+
+/**
+ * List all available built-in hook packs.
+ */
+export function listPacks(): HookPackManifest[] {
+  const root = getPacksRoot();
+  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;
+      packs.push(manifest);
+    } catch {
+      // Skip malformed manifests
+    }
+  }
+
+  return packs;
+}
+
+/**
+ * Get a specific pack by name.
+ */
+export function getPack(name: string): { manifest: HookPackManifest; dir: string } | null {
+  const root = getPacksRoot();
+  const dir = join(root, name);
+  const manifestPath = join(dir, 'manifest.json');
+
+  if (!existsSync(manifestPath)) return null;
+
+  try {
+    const manifest = JSON.parse(readFileSync(manifestPath, 'utf-8')) as HookPackManifest;
+    return { manifest, dir };
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * 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) {
+    const allPresent = pack.hooks.every((hook) =>
+      existsSync(join(claudeDir, `hookify.${hook}.local.md`)),
+    );
+    if (allPresent) {
+      installed.push(pack.name);
+    }
+  }
+
+  return installed;
+}

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

@@ -0,0 +1,17 @@
+---
+# Soleri Hook Pack: typescript-safety
+# Rule: no-any-types
+name: no-any-types
+enabled: true
+event: file
+action: block
+conditions:
+  - field: file_path
+    operator: regex_match
+    pattern: \.(tsx?|jsx?)$
+  - field: content
+    operator: regex_match
+    pattern: (:\s*any(?![a-zA-Z])|as\s+any(?![a-zA-Z])|<any>|Record<string,\s*any>)
+---
+
+🚫 **Type bypass blocked.** Replace `:any` with specific type or `unknown`. Fix `as any` at the source.

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

@@ -0,0 +1,20 @@
+---
+# Soleri Hook Pack: typescript-safety
+# Rule: no-console-log
+name: no-console-log
+enabled: true
+event: file
+action: warn
+conditions:
+  - field: file_path
+    operator: regex_match
+    pattern: src/.*\.(tsx?|jsx?)$
+  - field: file_path
+    operator: not_regex_match
+    pattern: (\.test\.|\.spec\.|\.stories\.)
+  - field: content
+    operator: regex_match
+    pattern: console\.(log|debug|info)\(
+---
+
+⚠️ **Debug code detected.** Remove `console.log/debug/info` before commit. `console.error/warn` allowed.

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

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@soleri/cli",
-  "version": "1.0.4",
+  "version": "1.1.0",
   "description": "Developer CLI for creating and managing Soleri AI agents.",
   "keywords": [
     "agent",
@@ -28,7 +28,7 @@
   },
   "scripts": {
     "dev": "tsx src/main.ts",
-    "build": "tsc",
+    "build": "tsc && cp -r src/hook-packs dist/",
     "start": "node dist/main.js",
     "typecheck": "tsc --noEmit",
     "test": "vitest run",

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

@@ -0,0 +1,195 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { mkdirSync, rmSync, existsSync, readFileSync, writeFileSync } from 'node:fs';
+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 () => {
+  const actual = await vi.importActual<typeof import('node:os')>('node:os');
+  return { ...actual, homedir: () => tempHome };
+});
+
+import { listPacks, getPack, getInstalledPacks } from '../hook-packs/registry.js';
+import { installPack, removePack, isPackInstalled } from '../hook-packs/installer.js';
+
+describe('hook-packs', () => {
+  beforeEach(() => {
+    mkdirSync(join(tempHome, '.claude'), { recursive: true });
+  });
+
+  afterEach(() => {
+    rmSync(tempHome, { recursive: true, force: true });
+  });
+
+  describe('registry', () => {
+    it('should list all 5 built-in packs', () => {
+      const packs = listPacks();
+      expect(packs.length).toBe(5);
+
+      const names = packs.map((p) => p.name).sort();
+      expect(names).toEqual([
+        'a11y',
+        'clean-commits',
+        'css-discipline',
+        'full',
+        'typescript-safety',
+      ]);
+    });
+
+    it('should get a specific pack by name', () => {
+      const pack = getPack('typescript-safety');
+      expect(pack).not.toBeNull();
+      expect(pack!.manifest.name).toBe('typescript-safety');
+      expect(pack!.manifest.hooks).toEqual(['no-any-types', 'no-console-log']);
+      expect(pack!.manifest.description).toBe('Block unsafe TypeScript patterns');
+    });
+
+    it('should return null for unknown pack', () => {
+      expect(getPack('nonexistent')).toBeNull();
+    });
+
+    it('should return full pack with composedFrom', () => {
+      const pack = getPack('full');
+      expect(pack).not.toBeNull();
+      expect(pack!.manifest.composedFrom).toEqual([
+        'typescript-safety',
+        'a11y',
+        'css-discipline',
+        'clean-commits',
+      ]);
+      expect(pack!.manifest.hooks).toHaveLength(8);
+    });
+
+    it('should return empty installed packs when none installed', () => {
+      expect(getInstalledPacks()).toEqual([]);
+    });
+  });
+
+  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');
+    });
+
+    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) {
+        expect(existsSync(join(claudeDir, `hookify.${hook}.local.md`))).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
+    });
+
+    it('should throw for unknown pack', () => {
+      expect(() => installPack('nonexistent')).toThrow('Unknown hook pack: "nonexistent"');
+    });
+
+    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);
+    });
+
+    it('should return empty removed list when pack not installed', () => {
+      const result = removePack('a11y');
+      expect(result.removed).toEqual([]);
+    });
+
+    it('should throw for unknown pack on remove', () => {
+      expect(() => removePack('nonexistent')).toThrow('Unknown hook pack: "nonexistent"');
+    });
+  });
+
+  describe('isPackInstalled', () => {
+    it('should return false when nothing installed', () => {
+      expect(isPackInstalled('typescript-safety')).toBe(false);
+    });
+
+    it('should return true when fully installed', () => {
+      installPack('typescript-safety');
+      expect(isPackInstalled('typescript-safety')).toBe(true);
+    });
+
+    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');
+    });
+
+    it('should return false for unknown pack', () => {
+      expect(isPackInstalled('nonexistent')).toBe(false);
+    });
+  });
+
+  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', () => {
+      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');
+    });
+  });
+});

package/src/commands/hooks.ts

@@ -2,10 +2,12 @@ import type { Command } from 'commander';
 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 * as log from '../utils/logger.js';
 
 export function registerHooks(program: Command): void {
-  const hooks = program.command('hooks').description('Manage editor hooks for this agent');
+  const hooks = program.command('hooks').description('Manage editor hooks and hook packs');
 
   hooks
     .command('add')
@@ -79,6 +81,78 @@ export function registerHooks(program: Command): void {
         }
       }
     });
+
+  // ── Hook Pack subcommands ──
+
+  hooks
+    .command('add-pack')
+    .argument('<pack>', 'Hook pack name')
+    .description('Install a hook pack globally (~/.claude/)')
+    .action((packName: string) => {
+      const pack = getPack(packName);
+      if (!pack) {
+        const available = listPacks().map((p) => p.name);
+        log.fail(`Unknown pack "${packName}". Available: ${available.join(', ')}`);
+        process.exit(1);
+      }
+
+      const { installed, skipped } = installPack(packName);
+      for (const hook of installed) {
+        log.pass(`Installed hookify.${hook}.local.md`);
+      }
+      for (const hook of skipped) {
+        log.dim(`  hookify.${hook}.local.md — already exists, skipped`);
+      }
+      if (installed.length > 0) {
+        log.info(`Pack "${packName}" installed (${installed.length} hooks)`);
+      } else {
+        log.info(`Pack "${packName}" — all hooks already installed`);
+      }
+    });
+
+  hooks
+    .command('remove-pack')
+    .argument('<pack>', 'Hook pack name')
+    .description('Remove a hook pack from ~/.claude/')
+    .action((packName: string) => {
+      const pack = getPack(packName);
+      if (!pack) {
+        const available = listPacks().map((p) => p.name);
+        log.fail(`Unknown pack "${packName}". Available: ${available.join(', ')}`);
+        process.exit(1);
+      }
+
+      const { removed } = removePack(packName);
+      if (removed.length === 0) {
+        log.info(`No hooks from pack "${packName}" found to remove.`);
+      } else {
+        for (const hook of removed) {
+          log.warn(`Removed hookify.${hook}.local.md`);
+        }
+        log.info(`Pack "${packName}" removed (${removed.length} hooks)`);
+      }
+    });
+
+  hooks
+    .command('list-packs')
+    .description('Show available hook packs and their status')
+    .action(() => {
+      const packs = listPacks();
+
+      log.heading('Hook Packs');
+
+      for (const pack of packs) {
+        const status = isPackInstalled(pack.name);
+
+        if (status === true) {
+          log.pass(`${pack.name}`, `${pack.description} (${pack.hooks.length} hooks)`);
+        } else if (status === 'partial') {
+          log.warn(`${pack.name}`, `${pack.description} (${pack.hooks.length} hooks) — partial`);
+        } else {
+          log.dim(`  ${pack.name} — ${pack.description} (${pack.hooks.length} hooks)`);
+        }
+      }
+    });
 }
 
 function isValidEditor(editor: string): editor is EditorId {

package/src/hook-packs/a11y/hookify.focus-ring-required.local.md

@@ -0,0 +1,20 @@
+---
+# Soleri Hook Pack: a11y
+# Rule: focus-ring-required
+name: focus-ring-required
+enabled: true
+event: file
+action: warn
+conditions:
+  - field: file_path
+    operator: regex_match
+    pattern: src/components/ui/.*\.tsx$
+  - field: content
+    operator: regex_match
+    pattern: (<button|<Button|<a\s+href)
+  - field: content
+    operator: not_regex_match
+    pattern: (focus:ring|focus-visible:ring|focus:outline)
+---
+
+⚠️ **A11y:** Add focus ring for keyboard navigation: `focus:ring-2 focus:ring-accent focus:ring-offset-2`

package/src/hook-packs/a11y/hookify.semantic-html.local.md

@@ -0,0 +1,17 @@
+---
+# Soleri Hook Pack: a11y
+# Rule: semantic-html
+name: semantic-html
+enabled: true
+event: file
+action: warn
+conditions:
+  - field: file_path
+    operator: regex_match
+    pattern: src/components/.*\.tsx$
+  - field: content
+    operator: regex_match
+    pattern: (<div\s+onClick(?!=)|<span\s+onClick(?!=))
+---
+
+⚠️ **A11y:** Use `<button>` instead of `<div onClick>`. Semantic HTML provides keyboard support.

package/src/hook-packs/a11y/hookify.ux-touch-targets.local.md

@@ -0,0 +1,17 @@
+---
+# Soleri Hook Pack: a11y
+# Rule: ux-touch-targets
+name: ux-touch-targets
+enabled: true
+event: file
+action: warn
+conditions:
+  - field: file_path
+    operator: regex_match
+    pattern: src/components/.*\.tsx$
+  - field: content
+    operator: regex_match
+    pattern: (<button[^>]*className="[^"]*(?:p-1|p-2|h-6|h-7|h-8|w-6|w-7|w-8)[^"]*"[^>]*>|className="[^"]*(?:p-1|p-2)[^"]*"[^>]*onClick)
+---
+
+⚠️ **Touch target too small.** Min 44x44px required. Add `min-h-11 min-w-11` to small interactive elements.

package/src/hook-packs/a11y/manifest.json

@@ -0,0 +1,5 @@
+{
+  "name": "a11y",
+  "description": "Accessibility enforcement",
+  "hooks": ["semantic-html", "focus-ring-required", "ux-touch-targets"]
+}

package/src/hook-packs/clean-commits/hookify.no-ai-attribution.local.md

@@ -0,0 +1,17 @@
+---
+# Soleri Hook Pack: clean-commits
+# Rule: no-ai-attribution
+name: no-ai-attribution
+enabled: true
+event: bash
+action: block
+conditions:
+  - field: command
+    operator: regex_match
+    pattern: git\s+commit.*(-m|--message)
+  - field: command
+    operator: regex_match
+    pattern: (🤖|Co-Authored-By|Generated with|AI-generated|by Claude|Claude Code|with Claude|noreply@anthropic\.com|Anthropic|Claude\s+(Opus|Sonnet|Haiku))
+---
+
+🚫 **AI attribution blocked.** Use clean conventional commits: `feat:`, `fix:`, `refactor:`. No 🤖, Claude, Co-Authored-By, or Anthropic references.

package/src/hook-packs/clean-commits/manifest.json

@@ -0,0 +1,5 @@
+{
+  "name": "clean-commits",
+  "description": "No AI attribution in git commits",
+  "hooks": ["no-ai-attribution"]
+}

package/src/hook-packs/css-discipline/hookify.no-important.local.md

@@ -0,0 +1,17 @@
+---
+# Soleri Hook Pack: css-discipline
+# Rule: no-important
+name: no-important
+enabled: true
+event: file
+action: block
+conditions:
+  - field: file_path
+    operator: regex_match
+    pattern: \.(tsx?|jsx?|css)$
+  - field: content
+    operator: regex_match
+    pattern: "!important"
+---
+
+🚫 **!important blocked.** Fix specificity instead. Use Tailwind `!` prefix (`!text-error`) only if needed.

package/src/hook-packs/css-discipline/hookify.no-inline-styles.local.md

@@ -0,0 +1,20 @@
+---
+# Soleri Hook Pack: css-discipline
+# Rule: no-inline-styles
+name: no-inline-styles
+enabled: true
+event: file
+action: warn
+conditions:
+  - field: file_path
+    operator: regex_match
+    pattern: src/components/.*\.tsx$
+  - field: file_path
+    operator: not_contains
+    pattern: .stories.tsx
+  - field: content
+    operator: regex_match
+    pattern: style=\{\{[^}]*(padding|margin|width|height|fontSize|color|background)[^}]*\}\}
+---
+
+⚠️ **Inline style detected.** Use Tailwind: `p-4` not `style={{ padding: '16px' }}`. Exception: CSS variables.

package/src/hook-packs/css-discipline/manifest.json

@@ -0,0 +1,5 @@
+{
+  "name": "css-discipline",
+  "description": "CSS best practices",
+  "hooks": ["no-important", "no-inline-styles"]
+}

package/src/hook-packs/full/manifest.json

@@ -0,0 +1,6 @@
+{
+  "name": "full",
+  "description": "Complete quality suite — all 8 hooks",
+  "hooks": ["no-any-types", "no-console-log", "no-important", "no-inline-styles", "semantic-html", "focus-ring-required", "ux-touch-targets", "no-ai-attribution"],
+  "composedFrom": ["typescript-safety", "a11y", "css-discipline", "clean-commits"]
+}