@open-product-primer/cli 1.2.0 → 2.1.0

package/dist/lib/remote-context.js

@@ -0,0 +1,299 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isGitSource = isGitSource;
+exports.isPathSource = isPathSource;
+exports.readRemoteContextConfig = readRemoteContextConfig;
+exports.writeRemoteContextConfig = writeRemoteContextConfig;
+exports.findSourceByName = findSourceByName;
+exports.identityFilePath = identityFilePath;
+exports.readIdentity = readIdentity;
+exports.writeIdentity = writeIdentity;
+exports.resolveIdentityOnly = resolveIdentityOnly;
+exports.hasEverFullyResolved = hasEverFullyResolved;
+exports.resolveFull = resolveFull;
+exports.assembleOprimWorkspaceContent = assembleOprimWorkspaceContent;
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const crypto = __importStar(require("crypto"));
+const child_process_1 = require("child_process");
+const yaml = __importStar(require("js-yaml"));
+function isGitSource(source) {
+    return 'git' in source && typeof source.git === 'string';
+}
+function isPathSource(source) {
+    return 'path' in source && typeof source.path === 'string';
+}
+// ─── oprim/config.yaml — remote_context block ──────────────────────────────
+const REMOTE_CONTEXT_KEY = 'remote_context';
+function configPath(projectRoot) {
+    return path.join(projectRoot, 'oprim', 'config.yaml');
+}
+function readRemoteContextConfig(projectRoot) {
+    const p = configPath(projectRoot);
+    if (!fs.existsSync(p))
+        return { enabled: false, sources: [] };
+    const parsed = yaml.load(fs.readFileSync(p, 'utf-8'));
+    const raw = parsed?.[REMOTE_CONTEXT_KEY];
+    if (!raw)
+        return { enabled: false, sources: [] };
+    return {
+        enabled: raw.enabled ?? false,
+        sources: Array.isArray(raw.sources) ? raw.sources : [],
+    };
+}
+// Surgical replace of just the `remote_context:` top-level block, leaving every other
+// line in oprim/config.yaml byte-for-byte untouched — mirrors the non-destructive approach
+// in config-merge.ts (never parse+re-dump the whole file).
+function replaceTopLevelBlock(content, key, blockContent) {
+    const lines = content.split('\n');
+    const startIdx = lines.findIndex((l) => new RegExp(`^${key}:`).test(l));
+    const blockLines = blockContent.replace(/\n$/, '').split('\n');
+    if (startIdx === -1) {
+        const separator = content.endsWith('\n') || content === '' ? '' : '\n';
+        return content + separator + blockLines.join('\n') + '\n';
+    }
+    let endIdx = lines.length;
+    for (let i = startIdx + 1; i < lines.length; i++) {
+        if (/^[A-Za-z_]/.test(lines[i])) {
+            endIdx = i;
+            break;
+        }
+    }
+    return [...lines.slice(0, startIdx), ...blockLines, ...lines.slice(endIdx)].join('\n');
+}
+function writeRemoteContextConfig(projectRoot, config) {
+    const p = configPath(projectRoot);
+    const existing = fs.existsSync(p) ? fs.readFileSync(p, 'utf-8') : '';
+    const dumped = yaml.dump({ [REMOTE_CONTEXT_KEY]: config }, { lineWidth: -1 });
+    const updated = replaceTopLevelBlock(existing, REMOTE_CONTEXT_KEY, dumped);
+    fs.mkdirSync(path.dirname(p), { recursive: true });
+    fs.writeFileSync(p, updated, 'utf-8');
+}
+function findSourceByName(config, name) {
+    return config.sources.find((s) => s.name === name);
+}
+// ─── Remote context identity (.oprim-context/context.yaml) ─────────────────
+function identityFilePath(rootDir) {
+    return path.join(rootDir, '.oprim-context', 'context.yaml');
+}
+function readIdentity(rootDir) {
+    const p = identityFilePath(rootDir);
+    if (!fs.existsSync(p))
+        return null;
+    try {
+        const parsed = yaml.load(fs.readFileSync(p, 'utf-8'));
+        if (!parsed?.name || !parsed?.version)
+            return null;
+        return { name: parsed.name, version: parsed.version, description: parsed.description };
+    }
+    catch {
+        return null;
+    }
+}
+function writeIdentity(rootDir, identity) {
+    const p = identityFilePath(rootDir);
+    fs.mkdirSync(path.dirname(p), { recursive: true });
+    fs.writeFileSync(p, yaml.dump(identity, { lineWidth: -1 }), 'utf-8');
+}
+// ─── Cache directory layout (git sources only) ─────────────────────────────
+// 5 minutes — see design.md open question. Overridable for tests that need to exercise
+// post-throttle-window behavior without actually waiting.
+function throttleMs() {
+    const override = process.env['OPRIM_REMOTE_CONTEXT_THROTTLE_MS'];
+    return override ? Number(override) : 5 * 60 * 1000;
+}
+// Overridable so tests never write into the real user's home directory.
+function cacheRoot() {
+    return process.env['OPRIM_REMOTE_CONTEXT_CACHE_DIR'] ?? path.join(os.homedir(), '.oprim', 'remote-context-cache');
+}
+function sourceCacheKey(source) {
+    const hash = crypto.createHash('sha1').update(source.git).digest('hex').slice(0, 12);
+    return `${source.name}-${hash}`;
+}
+function fullCacheDir(source) {
+    return path.join(cacheRoot(), sourceCacheKey(source), 'full');
+}
+function identityCacheDir(source) {
+    return path.join(cacheRoot(), sourceCacheKey(source), 'identity');
+}
+function markerPath(dir) {
+    return path.join(dir, '.oprim-last-fetch');
+}
+function isWithinThrottle(dir) {
+    const marker = markerPath(dir);
+    if (!fs.existsSync(marker))
+        return false;
+    const last = Number(fs.readFileSync(marker, 'utf-8').trim() || '0');
+    return Date.now() - last < throttleMs();
+}
+function touchMarker(dir) {
+    fs.writeFileSync(markerPath(dir), String(Date.now()), 'utf-8');
+}
+function git(args, cwd) {
+    (0, child_process_1.execFileSync)('git', args, { cwd, stdio: 'ignore' });
+}
+function withNameMismatch(source, identity) {
+    if (!identity)
+        return undefined;
+    if (identity.name === source.name)
+        return undefined;
+    return { declared: source.name, resolved: identity.name };
+}
+// ─── Git source resolution ─────────────────────────────────────────────────
+function ensureFullGitClone(source) {
+    const dir = fullCacheDir(source);
+    const exists = fs.existsSync(path.join(dir, '.git'));
+    if (exists && isWithinThrottle(dir)) {
+        return { dir, stale: false };
+    }
+    try {
+        if (!exists) {
+            fs.mkdirSync(path.dirname(dir), { recursive: true });
+            git(['clone', '--depth', '1', '--quiet', source.git, dir]);
+        }
+        else {
+            git(['fetch', '--depth', '1', '--quiet', 'origin', 'HEAD'], dir);
+            git(['reset', '--hard', '--quiet', 'FETCH_HEAD'], dir);
+        }
+        touchMarker(dir);
+        return { dir, stale: false };
+    }
+    catch (err) {
+        if (exists) {
+            // Last-known-good fallback — resolution degrades to stale rather than failing outright.
+            return { dir, stale: true };
+        }
+        return { dir, stale: false, error: err instanceof Error ? err.message : String(err) };
+    }
+}
+function ensureIdentityOnlyGitClone(source) {
+    const dir = identityCacheDir(source);
+    const exists = fs.existsSync(path.join(dir, '.git'));
+    if (exists && isWithinThrottle(dir)) {
+        return { dir };
+    }
+    try {
+        if (!exists) {
+            fs.mkdirSync(path.dirname(dir), { recursive: true });
+            // Partial clone (blob:none) + cone sparse-checkout scoped to .oprim-context/ — this is
+            // the "targeted single-file fetch" from design.md decision 5, implemented as an
+            // equivalent narrow fetch: git only downloads the one blob it needs to check out,
+            // not the whole workspace. `git archive --remote` was considered and rejected — GitHub
+            // and most managed git hosts disable the upload-archive service, so it isn't portable.
+            git(['clone', '--filter=blob:none', '--no-checkout', '--depth', '1', '--quiet', source.git, dir]);
+            git(['sparse-checkout', 'init', '--cone'], dir);
+            git(['sparse-checkout', 'set', '.oprim-context'], dir);
+            git(['checkout', '--quiet'], dir);
+        }
+        else {
+            git(['fetch', '--depth', '1', '--quiet', 'origin', 'HEAD'], dir);
+            git(['reset', '--hard', '--quiet', 'FETCH_HEAD'], dir);
+        }
+        touchMarker(dir);
+        return { dir };
+    }
+    catch (err) {
+        return { dir, error: err instanceof Error ? err.message : String(err) };
+    }
+}
+function resolveIdentityOnly(source) {
+    if (isPathSource(source)) {
+        if (!fs.existsSync(source.path)) {
+            return { identity: null, stale: false, error: `path not found: ${source.path}` };
+        }
+        const identity = readIdentity(source.path);
+        return { identity, stale: false, nameMismatch: withNameMismatch(source, identity) };
+    }
+    const { dir, error } = ensureIdentityOnlyGitClone(source);
+    if (error)
+        return { identity: null, stale: false, error };
+    const identity = readIdentity(dir);
+    return { identity, stale: false, nameMismatch: withNameMismatch(source, identity) };
+}
+// Local-path sources are always read live (no persistent cache), so "has this ever been
+// resolved" is only a meaningful question for git sources, where full resolution populates
+// a durable cache directory that outlives any single command invocation.
+function hasEverFullyResolved(source) {
+    if (isPathSource(source))
+        return true;
+    return fs.existsSync(path.join(fullCacheDir(source), '.git'));
+}
+function resolveFull(source) {
+    if (isPathSource(source)) {
+        if (!fs.existsSync(source.path)) {
+            return { workspaceRoot: source.path, stale: false, error: `path not found: ${source.path}` };
+        }
+        const identity = readIdentity(source.path);
+        return {
+            workspaceRoot: source.path,
+            stale: false,
+            nameMismatch: withNameMismatch(source, identity),
+        };
+    }
+    const { dir, stale, error } = ensureFullGitClone(source);
+    if (error)
+        return { workspaceRoot: dir, stale: false, error };
+    const identity = readIdentity(dir);
+    return { workspaceRoot: dir, stale, nameMismatch: withNameMismatch(source, identity) };
+}
+// ─── Assembling oprim/ workspace content for printing ──────────────────────
+function walkTextFiles(dir, base, out) {
+    if (!fs.existsSync(dir))
+        return;
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+        const full = path.join(dir, entry.name);
+        const rel = path.join(base, entry.name);
+        if (entry.isDirectory()) {
+            walkTextFiles(full, rel, out);
+        }
+        else if (entry.isFile() && /\.(md|yaml|yml)$/.test(entry.name)) {
+            out.push(rel);
+        }
+    }
+}
+function assembleOprimWorkspaceContent(workspaceRoot) {
+    const oprimDir = path.join(workspaceRoot, 'oprim');
+    const files = [];
+    walkTextFiles(oprimDir, 'oprim', files);
+    files.sort();
+    return files
+        .map((rel) => {
+        const content = fs.readFileSync(path.join(workspaceRoot, rel), 'utf-8');
+        return `─── ${rel} ───\n${content}`;
+    })
+        .join('\n\n');
+}

package/dist/lib/templates.d.ts

@@ -1,4 +1,4 @@
-export declare function configTemplate(projectName: string, openspecEnabled: boolean, graphifyEnabled: boolean, okfEnabled: boolean): string;
+export declare function configTemplate(projectName: string, openspecEnabled: boolean, graphifyEnabled: boolean, okfEnabled: boolean, specFramework?: string): string;
 export declare function okfFrontmatter(type: string, titleHint: string): string;
 export declare function noteMinimalFrontmatter(titleHint: string): string;
 export declare function indexTemplate(projectName: string): string;

package/dist/lib/templates.js

@@ -5,7 +5,7 @@ exports.configTemplate = configTemplate;
 exports.okfFrontmatter = okfFrontmatter;
 exports.noteMinimalFrontmatter = noteMinimalFrontmatter;
 exports.indexTemplate = indexTemplate;
-function configTemplate(projectName, openspecEnabled, graphifyEnabled, okfEnabled) {
+function configTemplate(projectName, openspecEnabled, graphifyEnabled, okfEnabled, specFramework = openspecEnabled ? 'openspec' : 'none') {
     return `version: 1
 project:
   name: "${projectName}"
@@ -17,6 +17,7 @@ integrations:
   graphify:
     enabled: ${graphifyEnabled}
     graph_dir: graphify-out
+  spec_framework: ${specFramework}
 okf:
   enabled: ${okfEnabled}
 measurement:
@@ -28,6 +29,11 @@ measurement:
 sequencing:
   wip_limits:
     now: 2
+context: ""
+rules: {}
+remote_context:
+  enabled: false
+  sources: []
 `;
 }
 // OKF (Open Knowledge Format) — https://github.com/GoogleCloudPlatform/okf

package/package.json

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