@open-product-primer/cli 2.10.0 → 2.11.0

package/dist/cli.js

@@ -16,6 +16,7 @@ const context_1 = require("./commands/context");
 const list_1 = require("./commands/list");
 const show_1 = require("./commands/show");
 const status_1 = require("./commands/status");
+const claude_mods_1 = require("./commands/claude-mods");
 const package_json_1 = __importDefault(require("../package.json"));
 const program = new commander_1.Command();
 program
@@ -33,4 +34,5 @@ program.addCommand((0, context_1.contextCommand)());
 program.addCommand((0, list_1.listCommand)());
 program.addCommand((0, show_1.showCommand)());
 program.addCommand((0, status_1.statusCommand)());
+program.addCommand((0, claude_mods_1.claudeModsCommand)());
 program.parse();

package/dist/commands/claude-mods.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function claudeModsCommand(): Command;

package/dist/commands/claude-mods.js

@@ -0,0 +1,45 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.claudeModsCommand = claudeModsCommand;
+const commander_1 = require("commander");
+const chalk_1 = __importDefault(require("chalk"));
+const detect_1 = require("../lib/detect");
+const install_agent_1 = require("../lib/install-agent");
+function claudeModsCommand() {
+    return new commander_1.Command('claude-mods')
+        .description('Select which Claude Code function-hook mods are installed')
+        .action(async () => {
+        const projectRoot = process.cwd();
+        const agents = (0, detect_1.readAgentsFromConfig)(projectRoot);
+        if (!agents || !agents.includes('claude')) {
+            console.error(chalk_1.default.red('Claude Code is not installed in this project.') +
+                ' Run ' +
+                chalk_1.default.cyan('oprim init') +
+                ' and select Claude Code first.');
+            process.exitCode = 1;
+            return;
+        }
+        const previousMods = (0, detect_1.readClaudeModsFromConfig)(projectRoot);
+        const selectedMods = await (0, install_agent_1.promptClaudeModsSelection)(previousMods);
+        if (selectedMods.length > 0 && !(0, install_agent_1.isFunctionHooksActive)(projectRoot)) {
+            const enable = await (0, install_agent_1.promptEnableFunctionHooks)();
+            if (enable) {
+                (0, install_agent_1.enableFunctionHooks)(projectRoot);
+                console.log(chalk_1.default.green('✓') + ' .claude/settings.json (function hooks enabled)');
+            }
+            else {
+                (0, install_agent_1.printManualFunctionHooksActivation)();
+            }
+        }
+        (0, install_agent_1.applyClaudeModsSelection)(projectRoot, selectedMods, previousMods);
+        if (selectedMods.length === 0) {
+            console.log(chalk_1.default.dim('  No mods selected — any previously-installed mod hooks were removed.'));
+        }
+        else {
+            console.log(chalk_1.default.green('✓') + ` Claude mods installed: ${selectedMods.join(', ')}`);
+        }
+    });
+}

package/dist/commands/init.js

@@ -147,6 +147,22 @@ function initCommand() {
                 (0, install_agent_1.installAgentSkills)(agent, projectRoot, specFramework, pdrSurfacing);
             }
             console.log('\n' + chalk_1.default.green('✓') + ` Agent skills installed: ${selectedAgents.join(', ')}`);
+            if (selectedAgents.includes('claude')) {
+                const previousMods = (0, detect_1.readClaudeModsFromConfig)(projectRoot);
+                console.log('');
+                const selectedMods = await (0, install_agent_1.promptClaudeModsSelection)(previousMods);
+                if (selectedMods.length > 0 && !(0, install_agent_1.isFunctionHooksActive)(projectRoot)) {
+                    const enable = await (0, install_agent_1.promptEnableFunctionHooks)();
+                    if (enable) {
+                        (0, install_agent_1.enableFunctionHooks)(projectRoot);
+                        console.log(chalk_1.default.green('✓') + ' .claude/settings.json (function hooks enabled)');
+                    }
+                    else {
+                        (0, install_agent_1.printManualFunctionHooksActivation)();
+                    }
+                }
+                (0, install_agent_1.applyClaudeModsSelection)(projectRoot, selectedMods, previousMods);
+            }
         }
         console.log('\nRun ' + chalk_1.default.cyan('oprim doctor') + ' to verify your setup.');
         console.log('\n' +

package/dist/lib/claude-mods.d.ts

@@ -0,0 +1,15 @@
+export interface ClaudeModHookFile {
+    filename: string;
+    content: string;
+    event: 'PreToolUse' | 'PostToolUse' | 'UserPromptSubmit' | 'Stop';
+    matcher?: string;
+    command: string;
+}
+export interface ClaudeMod {
+    id: string;
+    title: string;
+    description: string;
+    hookFiles: ClaudeModHookFile[];
+}
+export declare const CLAUDE_MODS_REGISTRY: ClaudeMod[];
+export declare function getClaudeMod(id: string): ClaudeMod | undefined;

package/dist/lib/claude-mods.js

@@ -0,0 +1,78 @@
+"use strict";
+// Static registry of installable Claude Code function-hook "mods" — see
+// oprim/bets/pending/BET-051-spec-delta-drift-interceptor-mod/design.md. Both `oprim init`'s
+// mod-selection prompt and the `oprim claude-mods` command read from this single registry, so a
+// future mod (BET-052–066) is added here once rather than duplicated per entry point.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CLAUDE_MODS_REGISTRY = void 0;
+exports.getClaudeMod = getClaudeMod;
+// PostToolUse hook: on a Write/Edit to a bet's specs/<capability>/spec.md delta, shells out to
+// `oprim validate --json` (already runs checkSpecDeltaDrift()) and surfaces any MODIFIED/REMOVED
+// drift for that capability inline, at write time instead of only at validate/CI time. Silently
+// no-ops on any failure (oprim not resolvable, malformed hook input, etc.) — this is a
+// write-time convenience on top of `oprim validate`, never a second source of required failures.
+const SPEC_DELTA_DRIFT_INTERCEPTOR_SCRIPT = `#!/usr/bin/env node
+// PostToolUse hook (Write|Edit) — see claude-mods.ts's spec-delta-drift-interceptor entry.
+
+let raw = '';
+process.stdin.on('data', (chunk) => { raw += chunk; });
+process.stdin.on('end', () => {
+  try {
+    const input = JSON.parse(raw || '{}');
+    const filePath = input.tool_input && input.tool_input.file_path;
+    if (!filePath) return;
+
+    const match = String(filePath).replace(/\\\\/g, '/').match(
+      /oprim\\/bets\\/pending\\/[^/]+\\/specs\\/([^/]+)\\/spec\\.md$/
+    );
+    if (!match) return;
+    const capability = match[1];
+
+    const { execSync } = require('child_process');
+    let output;
+    try {
+      output = execSync('npx --no-install oprim validate --json', {
+        encoding: 'utf-8',
+        stdio: ['ignore', 'pipe', 'ignore'],
+      });
+    } catch (err) {
+      // validate exits non-zero when a required check fails — stdout still carries the report
+      output = err && err.stdout ? err.stdout.toString() : null;
+    }
+    if (!output) return;
+
+    const report = JSON.parse(output);
+    const drift = (report.checks || []).filter(
+      (c) => c.name && c.name.startsWith('spec-delta:') && c.name.includes(\`in \${capability} \`) && !c.pass
+    );
+    if (drift.length === 0) return;
+
+    const reason = drift.map((c) => \`- \${c.name}\${c.note ? \` (\${c.note})\` : ''}\`).join('\\n');
+    process.stdout.write(JSON.stringify({
+      decision: 'block',
+      reason: \`Spec-delta drift detected in \${capability}:\\n\${reason}\`,
+    }) + '\\n');
+  } catch {
+    // Graceful degradation — never error or block on interceptor failure.
+  }
+});
+`;
+exports.CLAUDE_MODS_REGISTRY = [
+    {
+        id: 'spec-delta-drift-interceptor',
+        title: 'Spec-delta drift interceptor',
+        description: "Catches a bet's spec-delta MODIFIED/REMOVED requirement drifting from oprim/specs current truth at write time, instead of only at oprim validate/CI time.",
+        hookFiles: [
+            {
+                filename: 'spec-delta-drift-interceptor.js',
+                content: SPEC_DELTA_DRIFT_INTERCEPTOR_SCRIPT,
+                event: 'PostToolUse',
+                matcher: 'Write|Edit',
+                command: 'node ".claude/hooks/spec-delta-drift-interceptor.js"',
+            },
+        ],
+    },
+];
+function getClaudeMod(id) {
+    return exports.CLAUDE_MODS_REGISTRY.find((mod) => mod.id === id);
+}

package/dist/lib/config-merge.js

@@ -12,6 +12,8 @@ const CONFIG_SCHEMA_FIELDS = [
     // merge only adds missing keys, never removes existing ones), but new/updated configs only
     // ever gain `remote_context`.
     { key: 'remote_context', block: 'remote_context:\n  enabled: false\n  sources: []\n' },
+    // bet-051 — installed claude-mods selection, mirroring how `agents:` is stored/rewritten.
+    { key: 'claude_mods', block: 'claude_mods: []\n' },
 ];
 function existingTopLevelKeys(content) {
     const keys = new Set();

package/dist/lib/detect.d.ts

@@ -10,3 +10,5 @@ export declare function readAgentsFromConfig(projectRoot: string): string[] | nu
 export declare function readOkfEnabledFromConfig(projectRoot: string): boolean;
 export declare function detectAvailableAgents(projectRoot: string): string[];
 export declare function writeAgentsToConfig(agents: string[], projectRoot: string): void;
+export declare function readClaudeModsFromConfig(projectRoot: string): string[];
+export declare function writeClaudeModsToConfig(mods: string[], projectRoot: string): void;

package/dist/lib/detect.js

@@ -39,6 +39,8 @@ exports.readAgentsFromConfig = readAgentsFromConfig;
 exports.readOkfEnabledFromConfig = readOkfEnabledFromConfig;
 exports.detectAvailableAgents = detectAvailableAgents;
 exports.writeAgentsToConfig = writeAgentsToConfig;
+exports.readClaudeModsFromConfig = readClaudeModsFromConfig;
+exports.writeClaudeModsToConfig = writeClaudeModsToConfig;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const yaml = __importStar(require("js-yaml"));
@@ -103,3 +105,21 @@ function writeAgentsToConfig(agents, projectRoot) {
     config['agents'] = agents;
     fs.writeFileSync(configPath, yaml.dump(config, { indent: 2 }), 'utf-8');
 }
+function readClaudeModsFromConfig(projectRoot) {
+    const configPath = path.join(projectRoot, 'oprim', 'config.yaml');
+    if (!fs.existsSync(configPath))
+        return [];
+    const content = fs.readFileSync(configPath, 'utf-8');
+    const config = yaml.load(content);
+    const mods = config?.['claude_mods'];
+    return Array.isArray(mods) ? mods : [];
+}
+function writeClaudeModsToConfig(mods, projectRoot) {
+    const configPath = path.join(projectRoot, 'oprim', 'config.yaml');
+    if (!fs.existsSync(configPath))
+        return;
+    const content = fs.readFileSync(configPath, 'utf-8');
+    const config = yaml.load(content);
+    config['claude_mods'] = mods;
+    fs.writeFileSync(configPath, yaml.dump(config, { indent: 2 }), 'utf-8');
+}

package/dist/lib/install-agent.d.ts

@@ -3,6 +3,18 @@ export declare const SUPPORTED_AGENTS: readonly Agent[];
 export declare function promptFrameworkSelection(projectRoot: string): Promise<string>;
 export declare function resolveSpecFramework(projectRoot: string): string;
 export declare function promptAgentSelection(projectRoot: string): Promise<string[]>;
+export declare function promptClaudeModsSelection(preChecked: string[]): Promise<string[]>;
+export declare function isFunctionHooksActive(projectRoot: string): boolean;
+export declare function promptEnableFunctionHooks(): Promise<boolean>;
+export declare function enableFunctionHooks(projectRoot: string): void;
+export declare function printManualFunctionHooksActivation(): void;
+/**
+ * Merges newly-selected mods' hookFiles into .claude/settings.json (additive, non-clobbering —
+ * same convention as mergeClaudeSettingsHooks) and removes deselected mods' entries, writing/
+ * deleting each mod's hook script file(s) to match. Persists the resulting selection to
+ * oprim/config.yaml's claude_mods key.
+ */
+export declare function applyClaudeModsSelection(projectRoot: string, selectedIds: string[], previousIds: string[]): void;
 export declare function promptPdrSurfacing(): Promise<boolean>;
 export declare function promptOkfFrontmatter(): Promise<boolean>;
 export declare function installAgentSkills(agent: Agent, projectRoot: string, framework?: string, pdrSurfacing?: boolean): void;

package/dist/lib/install-agent.js

@@ -40,6 +40,12 @@ exports.CURSOR_COMMANDS = exports.CURSOR_SKILLS = exports.DSH_SKILLS = exports.K
 exports.promptFrameworkSelection = promptFrameworkSelection;
 exports.resolveSpecFramework = resolveSpecFramework;
 exports.promptAgentSelection = promptAgentSelection;
+exports.promptClaudeModsSelection = promptClaudeModsSelection;
+exports.isFunctionHooksActive = isFunctionHooksActive;
+exports.promptEnableFunctionHooks = promptEnableFunctionHooks;
+exports.enableFunctionHooks = enableFunctionHooks;
+exports.printManualFunctionHooksActivation = printManualFunctionHooksActivation;
+exports.applyClaudeModsSelection = applyClaudeModsSelection;
 exports.promptPdrSurfacing = promptPdrSurfacing;
 exports.promptOkfFrontmatter = promptOkfFrontmatter;
 exports.installAgentSkills = installAgentSkills;
@@ -60,6 +66,7 @@ const detect_1 = require("./detect");
 const config_merge_1 = require("./config-merge");
 const workflow_schema_1 = require("./workflow-schema");
 const workflow_renderer_1 = require("./workflow-renderer");
+const claude_mods_1 = require("./claude-mods");
 exports.SUPPORTED_AGENTS = [
     'claude',
     'cursor',
@@ -145,6 +152,140 @@ async function promptAgentSelection(projectRoot) {
         ],
     });
 }
+// ─── claude-mods ───────────────────────────────────────────────────────────
+async function promptClaudeModsSelection(preChecked) {
+    const { checkbox } = await Promise.resolve().then(() => __importStar(require('@inquirer/prompts')));
+    return checkbox({
+        message: 'Which Claude Code mods should be installed?',
+        choices: claude_mods_1.CLAUDE_MODS_REGISTRY.map((mod) => ({
+            name: `${mod.title} — ${mod.description}`,
+            value: mod.id,
+            checked: preChecked.includes(mod.id),
+        })),
+    });
+}
+function isFunctionHooksActive(projectRoot) {
+    if (process.env.CLAUDE_CODE_ENABLE_FUNCTION_HOOKS)
+        return true;
+    const settingsPath = path.join(projectRoot, '.claude', 'settings.json');
+    if (!fs.existsSync(settingsPath))
+        return false;
+    try {
+        const settings = JSON.parse(fs.readFileSync(settingsPath, 'utf-8'));
+        const env = settings.env;
+        return Boolean(env?.CLAUDE_CODE_ENABLE_FUNCTION_HOOKS);
+    }
+    catch {
+        return false;
+    }
+}
+async function promptEnableFunctionHooks() {
+    const { confirm } = await Promise.resolve().then(() => __importStar(require('@inquirer/prompts')));
+    return confirm({ message: 'Enable Claude Code function hooks now? (y/n)', default: true });
+}
+function enableFunctionHooks(projectRoot) {
+    const settingsPath = path.join(projectRoot, '.claude', 'settings.json');
+    const settings = readSettings(settingsPath);
+    if (!settings.env)
+        settings.env = {};
+    settings.env.CLAUDE_CODE_ENABLE_FUNCTION_HOOKS = '1';
+    writeSettings(settingsPath, settings);
+}
+function printManualFunctionHooksActivation() {
+    console.log(chalk_1.default.yellow('  Function hooks are not active.') +
+        ' Selected mod(s) will no-op until you either:\n' +
+        '    - set CLAUDE_CODE_ENABLE_FUNCTION_HOOKS=1 in your shell environment, or\n' +
+        '    - add an "env": { "CLAUDE_CODE_ENABLE_FUNCTION_HOOKS": "1" } block to .claude/settings.json');
+}
+function readSettings(settingsPath) {
+    if (!fs.existsSync(settingsPath))
+        return {};
+    try {
+        return JSON.parse(fs.readFileSync(settingsPath, 'utf-8'));
+    }
+    catch {
+        return {};
+    }
+}
+function writeSettings(settingsPath, settings) {
+    fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + '\n', 'utf-8');
+}
+function addModHookToSettings(settings, hookFile) {
+    if (!settings.hooks)
+        settings.hooks = {};
+    const hooks = settings.hooks;
+    if (!hooks[hookFile.event])
+        hooks[hookFile.event] = [];
+    const entries = hooks[hookFile.event];
+    const present = entries.some((entry) => {
+        const entryHooks = entry.hooks;
+        return entryHooks?.some((h) => h.command === hookFile.command);
+    });
+    if (!present) {
+        const entry = { hooks: [{ type: 'command', command: hookFile.command }] };
+        if (hookFile.matcher)
+            entry.matcher = hookFile.matcher;
+        entries.push(entry);
+    }
+}
+function removeModHookFromSettings(settings, hookFile) {
+    const hooks = settings.hooks;
+    if (!hooks || !hooks[hookFile.event])
+        return;
+    const entries = hooks[hookFile.event];
+    const filtered = entries.filter((entry) => {
+        const entryHooks = entry.hooks;
+        return !entryHooks?.some((h) => h.command === hookFile.command);
+    });
+    if (filtered.length === 0) {
+        delete hooks[hookFile.event];
+    }
+    else {
+        hooks[hookFile.event] = filtered;
+    }
+}
+/**
+ * Merges newly-selected mods' hookFiles into .claude/settings.json (additive, non-clobbering —
+ * same convention as mergeClaudeSettingsHooks) and removes deselected mods' entries, writing/
+ * deleting each mod's hook script file(s) to match. Persists the resulting selection to
+ * oprim/config.yaml's claude_mods key.
+ */
+function applyClaudeModsSelection(projectRoot, selectedIds, previousIds) {
+    const claudeDir = path.join(projectRoot, '.claude');
+    const hooksDir = path.join(claudeDir, 'hooks');
+    const settingsPath = path.join(claudeDir, 'settings.json');
+    const settings = readSettings(settingsPath);
+    const added = selectedIds.filter((id) => !previousIds.includes(id));
+    const removed = previousIds.filter((id) => !selectedIds.includes(id));
+    for (const id of added) {
+        const mod = (0, claude_mods_1.getClaudeMod)(id);
+        if (!mod)
+            continue;
+        for (const hookFile of mod.hookFiles) {
+            const scriptPath = path.join(hooksDir, hookFile.filename);
+            (0, scaffold_1.writeFile)(scriptPath, hookFile.content);
+            fs.chmodSync(scriptPath, 0o755);
+            addModHookToSettings(settings, hookFile);
+            console.log(chalk_1.default.green('✓') + ` .claude/hooks/${hookFile.filename} (${mod.title})`);
+        }
+    }
+    for (const id of removed) {
+        const mod = (0, claude_mods_1.getClaudeMod)(id);
+        if (!mod)
+            continue;
+        for (const hookFile of mod.hookFiles) {
+            const scriptPath = path.join(hooksDir, hookFile.filename);
+            if (fs.existsSync(scriptPath))
+                fs.unlinkSync(scriptPath);
+            removeModHookFromSettings(settings, hookFile);
+            console.log(chalk_1.default.dim(`  removed .claude/hooks/${hookFile.filename} (${mod.title})`));
+        }
+    }
+    if (added.length > 0 || removed.length > 0) {
+        writeSettings(settingsPath, settings);
+    }
+    (0, detect_1.writeClaudeModsToConfig)(selectedIds, projectRoot);
+}
 async function promptPdrSurfacing() {
     const { confirm } = await Promise.resolve().then(() => __importStar(require('@inquirer/prompts')));
     return confirm({ message: 'Enable proactive PDR surfacing in skills? (Y/n)', default: true });

package/dist/lib/templates.js

@@ -10,6 +10,7 @@ function configTemplate(projectName, openspecEnabled, graphifyEnabled, okfEnable
 project:
   name: "${projectName}"
 agents: []
+claude_mods: []
 integrations:
   openspec:
     enabled: ${openspecEnabled}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@open-product-primer/cli",
-  "version": "2.10.0",
+  "version": "2.11.0",
   "description": "Open Product Primer CLI — product decisions, sequencing, and KPI tracking for repositories",
   "keywords": [
     "product",