@open-product-primer/cli 2.10.0 → 2.12.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,29 @@
+export interface ClaudeModHookFile {
+    filename: string;
+    content: string;
+    event: 'PreToolUse' | 'PostToolUse' | 'UserPromptSubmit' | 'Stop';
+    matcher?: string;
+    command: string;
+}
+export interface ClaudeModPluginFile {
+    path: string;
+    content: string;
+}
+interface ClaudeModBase {
+    id: string;
+    title: string;
+    description: string;
+}
+export interface ClaudeModClassic extends ClaudeModBase {
+    shape: 'classic';
+    hookFiles: ClaudeModHookFile[];
+}
+export interface ClaudeModPlugin extends ClaudeModBase {
+    shape: 'plugin';
+    pluginFiles: ClaudeModPluginFile[];
+}
+export type ClaudeMod = ClaudeModClassic | ClaudeModPlugin;
+export declare function isPluginMod(mod: ClaudeMod): mod is ClaudeModPlugin;
+export declare const CLAUDE_MODS_REGISTRY: ClaudeMod[];
+export declare function getClaudeMod(id: string): ClaudeMod | undefined;
+export {};

package/dist/lib/claude-mods.js

@@ -0,0 +1,103 @@
+"use strict";
+// Static registry of installable Claude Code "mods" — see
+// oprim/bets/pending/BET-074-migrate-claude-mods-to-function-hooks/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–073) is added here once rather than duplicated per entry point.
+//
+// A registry entry declares one of two shapes:
+//   - 'classic': a shell-command hook merged into .claude/settings.json's `hooks` block (text-only
+//     {decision, reason} protocol — cannot draw UI).
+//   - 'plugin': a Claude Code function-hooks plugin (manifest + hooks.json + a register(on) module)
+//     installed at .claude/skills/<id>/, loaded via the project-scope skills-directory auto-load
+//     convention. Can draw UI ($.ui.toast, $.ui.render) but requires
+//     CLAUDE_CODE_ENABLE_FUNCTION_HOOKS and is early access — its API may move between releases.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CLAUDE_MODS_REGISTRY = void 0;
+exports.isPluginMod = isPluginMod;
+exports.getClaudeMod = getClaudeMod;
+function isPluginMod(mod) {
+    return mod.shape === 'plugin';
+}
+// register(on) module: on a Write/Edit tool.call 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 via a toast, at write time instead of only at
+// validate/CI time. Never denies the call — this is a write-time convenience on top of
+// `oprim validate`, never a second source of required failures. Silently no-ops on any failure
+// (oprim not resolvable, malformed report, etc.).
+const SPEC_DELTA_DRIFT_INTERCEPTOR_REGISTER = `// Function-hooks module for the spec-delta-drift-interceptor mod — see claude-mods.ts.
+// EARLY ACCESS: register(on)/$.ui.toast are gated behind CLAUDE_CODE_ENABLE_FUNCTION_HOOKS and
+// may change shape between Claude Code releases.
+
+import { execSync } from 'node:child_process';
+
+export function register(on) {
+  on('tool.call', async ($, e, next) => {
+    const result = await next(e);
+    if (e.tool !== 'Write' && e.tool !== 'Edit') return result;
+
+    try {
+      const filePath = String(e.file_path || '').replace(/\\\\/g, '/');
+      const match = filePath.match(/oprim\\/bets\\/pending\\/[^/]+\\/specs\\/([^/]+)\\/spec\\.md$/);
+      if (!match) return result;
+      const capability = match[1];
+
+      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 result;
+
+      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 result;
+
+      const reason = drift.map((c) => \`\${c.name}\${c.note ? \` (\${c.note})\` : ''}\`).join('; ');
+      $.ui.toast(\`Spec-delta drift in \${capability}: \${reason}\`, { timeoutMs: 8000 });
+    } catch {
+      // Graceful degradation — never error or block on interceptor failure.
+    }
+
+    return result;
+  });
+}
+`;
+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.",
+        shape: 'plugin',
+        pluginFiles: [
+            {
+                path: '.claude-plugin/plugin.json',
+                content: JSON.stringify({
+                    name: 'spec-delta-drift-interceptor',
+                    description: "Catches a bet's spec-delta MODIFIED/REMOVED requirement drifting from oprim/specs current truth at write time.",
+                    version: '1.0.0',
+                }, null, 2) + '\n',
+            },
+            {
+                path: 'hooks/hooks.json',
+                content: JSON.stringify({
+                    description: 'Runs checkSpecDeltaDrift() on a bet spec-delta write and surfaces drift via a toast, at write time.',
+                    modules: ['./register.js'],
+                }, null, 2) + '\n',
+            },
+            {
+                path: 'hooks/register.js',
+                content: SPEC_DELTA_DRIFT_INTERCEPTOR_REGISTER,
+            },
+        ],
+    },
+];
+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,20 @@ 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 into the project and removes deselected mods' entries, writing/
+ * deleting each mod's files to match. A classic mod's hookFiles merge into .claude/settings.json
+ * (additive, non-clobbering — same convention as mergeClaudeSettingsHooks); a plugin mod's
+ * pluginFiles are written under .claude/skills/<mod.id>/ instead, where the skills-directory
+ * auto-load convention picks it up as a function-hooks plugin — settings.json is untouched for
+ * these. 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,161 @@ 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 into the project and removes deselected mods' entries, writing/
+ * deleting each mod's files to match. A classic mod's hookFiles merge into .claude/settings.json
+ * (additive, non-clobbering — same convention as mergeClaudeSettingsHooks); a plugin mod's
+ * pluginFiles are written under .claude/skills/<mod.id>/ instead, where the skills-directory
+ * auto-load convention picks it up as a function-hooks plugin — settings.json is untouched for
+ * these. 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 skillsDir = path.join(claudeDir, 'skills');
+    const settingsPath = path.join(claudeDir, 'settings.json');
+    const settings = readSettings(settingsPath);
+    let settingsChanged = false;
+    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;
+        if ((0, claude_mods_1.isPluginMod)(mod)) {
+            const pluginDir = path.join(skillsDir, mod.id);
+            for (const file of mod.pluginFiles) {
+                (0, scaffold_1.writeFile)(path.join(pluginDir, file.path), file.content);
+            }
+            console.log(chalk_1.default.green('✓') + ` .claude/skills/${mod.id}/ (${mod.title})`);
+            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);
+            settingsChanged = true;
+            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;
+        if ((0, claude_mods_1.isPluginMod)(mod)) {
+            const pluginDir = path.join(skillsDir, mod.id);
+            if (fs.existsSync(pluginDir))
+                fs.rmSync(pluginDir, { recursive: true, force: true });
+            console.log(chalk_1.default.dim(`  removed .claude/skills/${mod.id}/ (${mod.title})`));
+            continue;
+        }
+        for (const hookFile of mod.hookFiles) {
+            const scriptPath = path.join(hooksDir, hookFile.filename);
+            if (fs.existsSync(scriptPath))
+                fs.unlinkSync(scriptPath);
+            removeModHookFromSettings(settings, hookFile);
+            settingsChanged = true;
+            console.log(chalk_1.default.dim(`  removed .claude/hooks/${hookFile.filename} (${mod.title})`));
+        }
+    }
+    if (settingsChanged) {
+        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.12.0",
   "description": "Open Product Primer CLI — product decisions, sequencing, and KPI tracking for repositories",
   "keywords": [
     "product",