@open-product-primer/cli 0.11.0 → 0.12.0

package/dist/cli.js

@@ -10,6 +10,7 @@ const update_1 = require("./commands/update");
 const doctor_1 = require("./commands/doctor");
 const migrate_1 = require("./commands/migrate");
 const measure_1 = require("./commands/measure");
+const ovw_1 = require("./commands/ovw");
 const package_json_1 = __importDefault(require("../package.json"));
 const program = new commander_1.Command();
 program
@@ -21,4 +22,5 @@ program.addCommand((0, update_1.updateCommand)());
 program.addCommand((0, doctor_1.doctorCommand)());
 program.addCommand((0, migrate_1.migrateCommand)());
 program.addCommand((0, measure_1.measureCommand)());
+program.addCommand((0, ovw_1.ovwCommand)());
 program.parse();

package/dist/commands/ovw.d.ts

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

package/dist/commands/ovw.js

@@ -0,0 +1,263 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ovwCommand = ovwCommand;
+const commander_1 = require("commander");
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+const chalk_1 = __importDefault(require("chalk"));
+const yaml = __importStar(require("js-yaml"));
+function resolveBetDecisionPath(betsDir, betId) {
+    if (!fs.existsSync(betsDir))
+        return null;
+    const entries = fs.readdirSync(betsDir, { withFileTypes: true });
+    for (const entry of entries) {
+        if (entry.isDirectory() && entry.name.startsWith(betId)) {
+            const candidate = path.join(betsDir, entry.name, 'bet-decision.md');
+            if (fs.existsSync(candidate))
+                return candidate;
+        }
+    }
+    return null;
+}
+function extractDoorType(content) {
+    if (/\[x\]\s*2-way door/i.test(content))
+        return '2-way';
+    if (/\[x\]\s*1-way door/i.test(content))
+        return '1-way';
+    return null;
+}
+function extractRiskLevel(content, label) {
+    const match = content.match(new RegExp(`\\*\\*${label}\\*\\*:\\s*(Low|Medium|High)`, 'i'));
+    if (!match)
+        return null;
+    const raw = match[1];
+    if (raw.toLowerCase() === 'low')
+        return 'Low';
+    if (raw.toLowerCase() === 'medium')
+        return 'Medium';
+    if (raw.toLowerCase() === 'high')
+        return 'High';
+    return null;
+}
+function extractRiskProfile(content) {
+    return {
+        value: extractRiskLevel(content, 'Value risk'),
+        usability: extractRiskLevel(content, 'Usability risk'),
+        feasibility: extractRiskLevel(content, 'Feasibility risk'),
+        viability: extractRiskLevel(content, 'Business viability risk'),
+    };
+}
+function loadBetMeta(betsDir, betId) {
+    const decisionPath = resolveBetDecisionPath(betsDir, betId);
+    if (!decisionPath)
+        return { doorType: null, risks: null };
+    try {
+        const content = fs.readFileSync(decisionPath, 'utf-8');
+        return {
+            doorType: extractDoorType(content),
+            risks: extractRiskProfile(content),
+        };
+    }
+    catch {
+        return { doorType: null, risks: null };
+    }
+}
+function abbreviate(level) {
+    if (level === 'Low')
+        return 'L';
+    if (level === 'Medium')
+        return 'M';
+    if (level === 'High')
+        return 'H';
+    return '?';
+}
+function renderInlineMeta(meta) {
+    if (!meta.doorType && !meta.risks)
+        return '[risk: unknown]';
+    const door = meta.doorType ?? '?-way';
+    if (!meta.risks)
+        return `[${door} | risk: unknown]`;
+    const { value, usability, feasibility, viability } = meta.risks;
+    return `[${door} | value:${abbreviate(value)} usability:${abbreviate(usability)} feasibility:${abbreviate(feasibility)} viability:${abbreviate(viability)}]`;
+}
+function renderBlockers(bet) {
+    if (!bet.blocked_by || bet.blocked_by.length === 0)
+        return '';
+    return ` [blocked by: ${bet.blocked_by.join(', ')}]`;
+}
+function renderLane(label, bets, betsDir, showMeta) {
+    console.log(chalk_1.default.bold.cyan(`\n── ${label.toUpperCase()} ──`));
+    if (bets.length === 0) {
+        console.log('  (empty)');
+        return;
+    }
+    for (const bet of bets) {
+        if (showMeta) {
+            const meta = loadBetMeta(betsDir, bet.id);
+            const inline = renderInlineMeta(meta);
+            const blockers = renderBlockers(bet);
+            console.log(`  ${bet.id}  ${bet.title}  ${inline}${blockers}`);
+        }
+        else {
+            const blockers = renderBlockers(bet);
+            console.log(`  ${bet.id}  ${bet.title}${blockers}`);
+        }
+    }
+}
+function isElevated(level) {
+    return level === 'Medium' || level === 'High';
+}
+function buildAdvisory(board, betsDir) {
+    const nudges = [];
+    const now = board.now ?? [];
+    const next = board.next ?? [];
+    // Board-shape rules
+    if (now.length === 0) {
+        nudges.push('Now lane is empty — consider promoting a bet from next');
+    }
+    if (now.length > 3) {
+        nudges.push(`Focus risk: now lane has ${now.length} active bets — consider narrowing`);
+    }
+    for (const bet of now) {
+        const blockers = bet.blocked_by ?? [];
+        const inFlightIds = new Set([...now.map((b) => b.id), ...next.map((b) => b.id)]);
+        for (const blocker of blockers) {
+            if (!inFlightIds.has(blocker)) {
+                nudges.push(`${bet.id} may be stuck — its blocker ${blocker} is not in a flight lane`);
+            }
+        }
+    }
+    // Door-type sequencing rules
+    const inFlightIds = new Set([...now.map((b) => b.id), ...next.map((b) => b.id)]);
+    const metaCache = new Map();
+    const getMeta = (betId) => {
+        if (!metaCache.has(betId))
+            metaCache.set(betId, loadBetMeta(betsDir, betId));
+        return metaCache.get(betId);
+    };
+    const nowMetas = now.map((b) => ({ bet: b, meta: getMeta(b.id) }));
+    const nextMetas = next.map((b) => ({ bet: b, meta: getMeta(b.id) }));
+    const inFlightMetas = [...nowMetas, ...nextMetas];
+    // 2-way bets in flight that unlock 1-way bets (used to check unrisker presence)
+    const twowayUnlocks = new Set();
+    for (const { bet, meta } of inFlightMetas) {
+        if (meta.doorType === '2-way') {
+            for (const unlockedId of bet.unlocks ?? [])
+                twowayUnlocks.add(unlockedId);
+        }
+    }
+    const allNow1Way = nowMetas.length > 0 && nowMetas.every(({ meta }) => meta.doorType === '1-way');
+    if (allNow1Way) {
+        nudges.push('Your now lane has no 2-way door bets — you are in full-commitment mode with no reversible fallback');
+    }
+    for (const { bet, meta } of nowMetas) {
+        if (meta.doorType === '1-way' && !twowayUnlocks.has(bet.id)) {
+            nudges.push(`${bet.id} is a 1-way door with no 2-way door unrisker in flight — consider sequencing a reversible spike first`);
+        }
+    }
+    // 2-way door blocked by a 1-way door (inverted order)
+    for (const { bet, meta } of inFlightMetas) {
+        if (meta.doorType === '2-way') {
+            for (const blockerId of bet.blocked_by ?? []) {
+                const blockerMeta = getMeta(blockerId);
+                if (blockerMeta.doorType === '1-way') {
+                    nudges.push(`${bet.id} (2-way) is blocked by ${blockerId} (1-way) — order may be inverted; 2-way doors should precede 1-way doors`);
+                }
+            }
+        }
+    }
+    // Risk advisory rules for now lane
+    for (const { bet, meta } of nowMetas) {
+        if (!meta.risks)
+            continue;
+        const { value, usability, feasibility, viability } = meta.risks;
+        if (isElevated(value) && meta.doorType === '1-way') {
+            nudges.push(`${bet.id}: high commitment with unvalidated value — consider a 2-way door discovery bet first`);
+        }
+        if (isElevated(feasibility)) {
+            nudges.push(`${bet.id}: feasibility risk is elevated — ensure a spike or prototype is in plan before full build`);
+        }
+        if (isElevated(usability)) {
+            nudges.push(`${bet.id}: usability risk is elevated — plan for user testing before shipping`);
+        }
+        if (isElevated(viability)) {
+            nudges.push(`${bet.id}: business viability risk is elevated — align with stakeholders before committing`);
+        }
+    }
+    return nudges;
+}
+function ovwCommand() {
+    return new commander_1.Command('ovw')
+        .description('Show the sequencing board with door type, risk profile, and advisory guidance')
+        .action(() => {
+        const projectRoot = process.cwd();
+        const sequencePath = path.join(projectRoot, 'oprim', 'sequence.yaml');
+        const betsDir = path.join(projectRoot, 'oprim', 'bets');
+        if (!fs.existsSync(sequencePath)) {
+            console.error("No oprim/sequence.yaml found — run 'oprim init' first");
+            process.exit(1);
+            return;
+        }
+        let board;
+        try {
+            board = yaml.load(fs.readFileSync(sequencePath, 'utf-8')) ?? {};
+        }
+        catch {
+            console.error('Failed to parse oprim/sequence.yaml');
+            process.exit(1);
+            return;
+        }
+        const lanes = [
+            { key: 'now', label: 'now', showMeta: true },
+            { key: 'next', label: 'next', showMeta: true },
+            { key: 'later', label: 'later', showMeta: false },
+            { key: 'backlog', label: 'backlog', showMeta: false },
+        ];
+        for (const { key, label, showMeta } of lanes) {
+            renderLane(label, board[key] ?? [], betsDir, showMeta);
+        }
+        const nudges = buildAdvisory(board, betsDir);
+        if (nudges.length > 0) {
+            console.log(chalk_1.default.bold.yellow('\n── ADVISORY ──'));
+            for (const nudge of nudges) {
+                console.log(`  • ${nudge}`);
+            }
+        }
+    });
+}

package/dist/lib/install-agent.js

@@ -426,6 +426,15 @@ If \`oprim/sequence.yaml\` not found: report and stop — advise \`oprim init\`.
 ### 4. Gather content
 Ask: Decision (Build now / Defer / Kill, default Build now), Owner, Review date (YYYY-MM-DD), Why now, Alternatives considered, Expected outcomes (metric: baseline → target in timeframe), Kill criteria / rollback trigger, PDR links (optional).
 
+Then ask about reversibility:
+- "Is this a **2-way door** (reversible — easy to undo, safe to try) or a **1-way door** (hard to reverse — requires high confidence)?"
+
+Then ask about each of the four risk dimensions (Low / Medium / High + short rationale):
+- "**Value risk**: Will users/customers actually use or buy this? (Low / Medium / High — and why?)"
+- "**Usability risk**: Can users figure out how to use it without help? (Low / Medium / High — and why?)"
+- "**Feasibility risk**: Can we build this with our current skills, time, and technology? (Low / Medium / High — and why?)"
+- "**Business viability risk**: Does this solution work for the business (revenue, legal, ops)? (Low / Medium / High — and why?)"
+
 ### 5. Write oprim/bets/BET-NNN-<slug>/bet-decision.md
 \`\`\`
 # Decision: BET-NNN <title>
@@ -437,6 +446,16 @@ Ask: Decision (Build now / Defer / Kill, default Build now), Owner, Review date
 - Owner: <owner>
 - Review date: <review date>
 
+## Door type
+- [<x if 2-way>] 2-way door (reversible — safe to try, easy to undo)
+- [<x if 1-way>] 1-way door (hard to reverse — requires higher confidence before committing)
+
+## Risk profile
+- **Value risk**: <Low / Medium / High> — <rationale>
+- **Usability risk**: <Low / Medium / High> — <rationale>
+- **Feasibility risk**: <Low / Medium / High> — <rationale>
+- **Business viability risk**: <Low / Medium / High> — <rationale>
+
 ## Why now
 <why-now as bullet list>
 

package/package.json

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