@productbrain/cli 0.1.0-beta.1419 → 0.1.0-beta.14196

package/dist/commands/method.js

@@ -1,787 +1,67 @@
 /**
- * pb method ls / pb method show <name> / pb method diff <name> / pb method publish <name>
- * WP-329 S1-S3: Method visibility CLI + publish.
+ * `pb method draft <file> [--score <file>]` and `pb method show <method>[@<version>]` (TASK-1214, WP-874): the fast loop's verbs.
  *
- * Lists all .productbrain/ skills and rules with per-surface adapter status,
- * shows detailed fork-detection output for a single method, diffs against
- * the Chain, and publishes to the Chain methods collection.
- *
- * Chain: WP-329 (Method Publish + Visibility), DEC-299 (JSON-default output),
- *        DEC-598 (local-only monotonic versioning, Option B).
+ * The draft file: { "id": "direction", "parts": { "applies", "expect", "steps", "limits", "teach" }, "note" }, each line a string or
+ * { "line", "rung" }. The score file: the grader's numbers (methodId, version, graderConversationId, graderModel, scoredAt,
+ * inventedFacts, overTwoSentences, quiz, notes). The engine checks every line and the score; this prints the words it sends.
  */
-import { createHash } from 'node:crypto';
-import { existsSync, readdirSync, readFileSync } from 'node:fs';
-import { join, resolve } from 'node:path';
-import { cwd } from 'node:process';
+import { readFileSync } from 'node:fs';
+import { getConfigOrGuide } from '../lib/config.js';
 import { kernelCall, kernelCallWithSession } from '../lib/client.js';
 import { readSession } from '../lib/session.js';
 import { runCliCommand } from '../lib/runner.js';
 import { CLIError, ErrorCode } from '../lib/errors.js';
-// ---------------------------------------------------------------------------
-// Constants
-// ---------------------------------------------------------------------------
-const CODEX_MARKER_PREFIX = '<!-- auto-generated by pb handshake — source: .productbrain/';
-/**
- * Normalize path references in Claude adapter bodies before comparison.
- * pb handshake rewrites .productbrain/rules/ → .claude/rules/ in .claude/ adapters.
- * Reverting here lets us compare body content without false-positive "forked" reports.
- */
-function normalizeClaudeAdapterBody(body) {
-    return body.replace(/\.claude\/rules\//g, '.productbrain/rules/');
-}
-/**
- * Normalize path references in Cursor adapter bodies before comparison.
- * pb handshake rewrites .productbrain/rules/ → .cursor/rules/ in .cursor/ adapters.
- */
-function normalizeCursorAdapterBody(body) {
-    return body.replace(/\.cursor\/rules\//g, '.productbrain/rules/');
-}
-// ---------------------------------------------------------------------------
-// Filesystem helpers
-// ---------------------------------------------------------------------------
-/** Returns project root (the directory containing .productbrain/). */
-function projectRoot() {
-    // Walk up from cwd until we find .productbrain/, or fall back to cwd
-    let dir = cwd();
-    for (let i = 0; i < 8; i++) {
-        if (existsSync(join(dir, '.productbrain')))
-            return dir;
-        const parent = resolve(dir, '..');
-        if (parent === dir)
-            break;
-        dir = parent;
-    }
-    return cwd();
-}
-// Intentionally NOT folded into lib/frontmatter.ts (parseSetupFrontmatter): this
-// parser has different semantics (multi-line value support, MethodFrontmatter shape).
-/** Parse YAML-ish frontmatter block from a .md file (simple key: value, supports multi-line values). */
-function parseFrontmatter(content) {
-    if (!content.startsWith('---')) {
-        return { frontmatter: {}, body: content };
-    }
-    const end = content.indexOf('\n---', 3);
-    if (end === -1) {
-        return { frontmatter: {}, body: content };
-    }
-    const fmBlock = content.slice(4, end); // skip the opening ---\n
-    const body = content.slice(end + 4); // skip the closing ---
-    const frontmatter = {};
-    let i = 0;
-    const lines = fmBlock.split('\n');
-    while (i < lines.length) {
-        const line = lines[i];
-        const colonIdx = line.indexOf(':');
-        if (colonIdx < 1) {
-            i++;
-            continue;
-        }
-        const key = line.slice(0, colonIdx).trim();
-        let value = line.slice(colonIdx + 1).trim();
-        // Multi-line value: starts with >- or |
-        if (value === '>-' || value === '>' || value === '|') {
-            const parts = [];
-            i++;
-            while (i < lines.length && (lines[i].startsWith('  ') || lines[i] === '')) {
-                parts.push(lines[i].trim());
-                i++;
-            }
-            frontmatter[key] = parts.join(' ').trim();
-            continue;
-        }
-        // Boolean values
-        if (value === 'true') {
-            frontmatter[key] = true;
-            i++;
-            continue;
-        }
-        if (value === 'false') {
-            frontmatter[key] = false;
-            i++;
-            continue;
-        }
-        // Strip surrounding quotes
-        if ((value.startsWith('"') && value.endsWith('"')) ||
-            (value.startsWith("'") && value.endsWith("'"))) {
-            value = value.slice(1, -1);
-        }
-        frontmatter[key] = value;
-        i++;
-    }
-    return { frontmatter, body: body.trimStart() };
-}
-/**
- * Strip frontmatter from adapter files so we can compare body content.
- * Also strip CODEX MARKER comment line if present.
- */
-function extractAdapterBody(content) {
-    // Strip frontmatter block if present
-    let text = content;
-    if (text.startsWith('---')) {
-        const end = text.indexOf('\n---', 3);
-        if (end !== -1) {
-            text = text.slice(end + 4).trimStart();
-        }
-    }
-    // Strip MARKER comment line (first line if it matches)
-    const firstNewline = text.indexOf('\n');
-    if (firstNewline !== -1) {
-        const firstLine = text.slice(0, firstNewline).trim();
-        if (firstLine.startsWith('<!--') && firstLine.includes('auto-generated by pb handshake')) {
-            text = text.slice(firstNewline + 1).trimStart();
-        }
-    }
-    return text.trim();
-}
-/** Load all methods from .productbrain/skills/ and .productbrain/rules/. */
-function loadAllSources(root) {
-    const sources = [];
-    const skillsDir = join(root, '.productbrain', 'skills');
-    const rulesDir = join(root, '.productbrain', 'rules');
-    for (const [dir, type] of [[skillsDir, 'skill'], [rulesDir, 'rule']]) {
-        if (!existsSync(dir))
-            continue;
-        const files = readdirSync(dir).filter((f) => f.endsWith('.md'));
-        for (const file of files) {
-            const filePath = join(dir, file);
-            let content;
-            try {
-                content = readFileSync(filePath, 'utf8');
-            }
-            catch {
-                continue;
-            }
-            const { frontmatter, body } = parseFrontmatter(content);
-            const stem = file.replace(/\.md$/, '');
-            sources.push({
-                name: stem,
-                type,
-                sourcePath: filePath,
-                frontmatter,
-                body,
-            });
-        }
-    }
-    return sources;
-}
-// ---------------------------------------------------------------------------
-// Adapter status detection
-// ---------------------------------------------------------------------------
-function checkClaude(root, source) {
-    // Rules have adapters in .claude/rules/; skills do NOT have a direct claude adapter
-    if (source.type === 'skill')
-        return 'missing';
-    const adapterPath = join(root, '.claude', 'rules', `${source.name}.md`);
-    if (!existsSync(adapterPath))
-        return 'missing';
-    let adapterContent;
-    try {
-        adapterContent = readFileSync(adapterPath, 'utf8');
-    }
-    catch {
-        return 'missing';
-    }
-    const adapterBody = normalizeClaudeAdapterBody(extractAdapterBody(adapterContent));
-    const sourceBody = source.body.trim();
-    return adapterBody === sourceBody ? 'ok' : 'forked';
-}
-function checkCursor(root, source) {
-    // Rules have adapters in .cursor/rules/<name>.mdc; skills do NOT have cursor adapters
-    if (source.type === 'skill')
-        return 'missing';
-    const adapterPath = join(root, '.cursor', 'rules', `${source.name}.mdc`);
-    if (!existsSync(adapterPath))
-        return 'missing';
-    let adapterContent;
+import { copy } from '../lib/style.js';
+const step = (value) => (typeof value === 'string' ? { line: value } : value);
+function readJson(path, what) {
     try {
-        adapterContent = readFileSync(adapterPath, 'utf8');
-    }
-    catch {
-        return 'missing';
-    }
-    const adapterBody = normalizeCursorAdapterBody(extractAdapterBody(adapterContent));
-    const sourceBody = source.body.trim();
-    return adapterBody === sourceBody ? 'ok' : 'forked';
-}
-function checkCodex(root, source) {
-    // Only skills have codex adapters in .codex/skills/
-    if (source.type === 'rule')
-        return 'missing';
-    const adapterPath = join(root, '.codex', 'skills', `${source.name}.md`);
-    if (!existsSync(adapterPath))
-        return 'missing';
-    let adapterContent;
-    try {
-        adapterContent = readFileSync(adapterPath, 'utf8');
-    }
-    catch {
-        return 'missing';
+        return JSON.parse(readFileSync(path, 'utf8'));
     }
-    // Check MARKER presence
-    if (!adapterContent.includes(CODEX_MARKER_PREFIX))
-        return 'forked';
-    const adapterBody = extractAdapterBody(adapterContent);
-    const sourceBody = source.body.trim();
-    return adapterBody === sourceBody ? 'ok' : 'forked';
-}
-function checkCopilot(root, source) {
-    // Only rules contribute to copilot-instructions.md (skills are not included)
-    if (source.type === 'skill')
-        return 'missing';
-    const copilotPath = join(root, '.github', 'copilot-instructions.md');
-    if (!existsSync(copilotPath))
-        return 'missing';
-    let copilotContent;
-    try {
-        copilotContent = readFileSync(copilotPath, 'utf8');
-    }
-    catch {
-        return 'missing';
-    }
-    // copilot-instructions.md stores summaries (### name\ndescription), not full bodies
-    return copilotContent.includes(`### ${source.name}`) ? 'ok' : 'forked';
-}
-function checkAdapters(root, source) {
-    return {
-        claude: checkClaude(root, source),
-        cursor: checkCursor(root, source),
-        codex: checkCodex(root, source),
-        copilot: checkCopilot(root, source),
-    };
-}
-// ---------------------------------------------------------------------------
-// Chain query helper
-// ---------------------------------------------------------------------------
-/** Attempt to fetch published Chain entry for a method by name. Returns null on failure. */
-async function fetchChainMethod(name) {
-    try {
-        const results = await kernelCall('chain.searchEntries', { query: name, collectionSlug: 'methods' });
-        if (!Array.isArray(results))
-            return null;
-        // Find exact name match in results
-        const match = results.find((r) => {
-            const entryName = (r.data?.name ?? r.name);
-            return entryName === name;
+    catch (err) {
+        throw new CLIError(`The ${what} file could not be read as JSON.`, {
+            code: ErrorCode.VALIDATION_FAILED, category: 'validation', guidance: `${path}: ${err instanceof Error ? err.message : String(err)}`,
         });
-        if (!match)
-            return null;
-        const data = match.data ?? {};
-        const fmRaw = data.frontmatter;
-        let frontmatter;
-        if (fmRaw) {
-            try {
-                frontmatter = JSON.parse(fmRaw);
-            }
-            catch { /* ignore */ }
-        }
-        return {
-            _id: match._id,
-            version: data.version != null ? String(data.version) : undefined,
-            publishedAt: data.publishedAt,
-            publishedBy: data.publishedBy,
-            manifestHash: data.manifestHash,
-            body: data.body,
-            frontmatter,
-        };
-    }
-    catch {
-        // Chain unreachable or collection doesn't exist yet — not fatal
-        return null;
-    }
-}
-// ---------------------------------------------------------------------------
-// Diff helpers
-// ---------------------------------------------------------------------------
-/**
- * Produce a minimal unified diff between two texts.
- * Returns an array of diff lines (context lines prefixed with space,
- * removals prefixed with -, additions prefixed with +).
- * Context window: 3 lines around each change.
- */
-function computeUnifiedDiff(oldText, newText, context = 3) {
-    const oldLines = oldText.split('\n');
-    const newLines = newText.split('\n');
-    // Myers-style LCS — compute edit script via DP table
-    const m = oldLines.length;
-    const n = newLines.length;
-    // dp[i][j] = length of LCS for oldLines[0..i-1] and newLines[0..j-1]
-    const dp = Array.from({ length: m + 1 }, () => new Array(n + 1).fill(0));
-    for (let i = 1; i <= m; i++) {
-        for (let j = 1; j <= n; j++) {
-            if (oldLines[i - 1] === newLines[j - 1]) {
-                dp[i][j] = dp[i - 1][j - 1] + 1;
-            }
-            else {
-                dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
-            }
-        }
-    }
-    const edits = [];
-    let i = m;
-    let j = n;
-    while (i > 0 || j > 0) {
-        if (i > 0 && j > 0 && oldLines[i - 1] === newLines[j - 1]) {
-            edits.unshift({ op: ' ', line: oldLines[i - 1], oldIdx: i - 1, newIdx: j - 1 });
-            i--;
-            j--;
-        }
-        else if (j > 0 && (i === 0 || dp[i][j - 1] >= dp[i - 1][j])) {
-            edits.unshift({ op: '+', line: newLines[j - 1], newIdx: j - 1 });
-            j--;
-        }
-        else {
-            edits.unshift({ op: '-', line: oldLines[i - 1], oldIdx: i - 1 });
-            i--;
-        }
-    }
-    if (edits.length === 0)
-        return [];
-    // Find indices of changed lines
-    const changedAt = new Set();
-    for (let k = 0; k < edits.length; k++) {
-        if (edits[k].op !== ' ')
-            changedAt.add(k);
-    }
-    if (changedAt.size === 0)
-        return []; // identical
-    // Build context windows — include context lines around changes
-    const included = new Set();
-    for (const idx of changedAt) {
-        for (let d = -context; d <= context; d++) {
-            const pos = idx + d;
-            if (pos >= 0 && pos < edits.length)
-                included.add(pos);
-        }
-    }
-    const output = [];
-    let prevIncluded = false;
-    for (let k = 0; k < edits.length; k++) {
-        if (included.has(k)) {
-            if (!prevIncluded && k > 0) {
-                output.push('...');
-            }
-            output.push(`${edits[k].op}${edits[k].line}`);
-            prevIncluded = true;
-        }
-        else {
-            prevIncluded = false;
-        }
-    }
-    return output;
-}
-/** Count hook-related diff lines in the edit script (lines with changes touching hooks). */
-function countHookChanges(diffLines, localAlwaysApply, chainAlwaysApply) {
-    const HOOK_KEYWORDS = /hook|settings\.json|alwaysApply/i;
-    let count = 0;
-    for (const line of diffLines) {
-        if ((line.startsWith('+') || line.startsWith('-')) && HOOK_KEYWORDS.test(line)) {
-            count++;
-        }
-    }
-    // If alwaysApply changed between local and chain, count that as at least 1
-    if (count === 0 && localAlwaysApply !== chainAlwaysApply) {
-        count = 1;
     }
-    return count;
 }
-// ---------------------------------------------------------------------------
-// pb method ls
-// ---------------------------------------------------------------------------
-export async function runMethodList() {
+/** The draft file's parts in the stored shape: every line an object, the three lists present. */
+function draftParts(raw) {
+    const parts = (raw.parts ?? {});
+    const list = (name) => (parts[name] ?? []).map(step);
+    const one = (name) => (parts[name] === undefined ? {} : { [name]: step(parts[name]) });
+    return { ...one('applies'), ...one('expect'), steps: list('steps'), limits: list('limits'), teach: list('teach') };
+}
+export async function runMethodDraft(file, options) {
+    await getConfigOrGuide();
+    const session = readSession();
+    if (!session)
+        throw new CLIError(copy.noSession, { code: ErrorCode.SESSION_REQUIRED, category: 'session', guidance: copy.noSessionGuidance });
+    const raw = readJson(file, 'draft');
+    const score = options.score ? readJson(options.score, 'score') : undefined;
     await runCliCommand({
-        fn: async () => {
-            const root = projectRoot();
-            const sources = loadAllSources(root);
-            if (sources.length === 0) {
-                return { methods: [], total: 0 };
-            }
-            // Sort: rules first (alpha), then skills (alpha)
-            sources.sort((a, b) => {
-                if (a.type !== b.type)
-                    return a.type === 'rule' ? -1 : 1;
-                return a.name.localeCompare(b.name);
-            });
-            // Batch Chain lookups in parallel (best-effort)
-            const chainResults = await Promise.allSettled(sources.map((s) => fetchChainMethod(s.name)));
-            const methods = sources.map((source, i) => {
-                const chainEntry = chainResults[i].status === 'fulfilled' ? chainResults[i].value : null;
-                const adapters = checkAdapters(root, source);
-                return {
-                    name: source.name,
-                    type: source.type,
-                    version: chainEntry?.version != null ? String(chainEntry.version) : '-',
-                    published: chainEntry !== null,
-                    claude: adapters.claude === 'ok',
-                    cursor: adapters.cursor === 'ok',
-                    codex: adapters.codex === 'ok',
-                };
-            });
-            return { methods, total: methods.length };
-        },
-        formatPretty: (result) => formatMethodList(result),
+        fn: () => kernelCallWithSession('method.draft', {
+            sessionId: session.sessionId, methodId: String(raw.id ?? ''), parts: draftParts(raw),
+            ...(typeof raw.note === 'string' ? { note: raw.note } : {}), ...(score ? { score } : {}),
+        }),
+        formatPretty: (data) => `${data.line}\nNext: pb session close, then pb session start --preview-method ${data.methodId}@${data.version}`,
     });
 }
-// ---------------------------------------------------------------------------
-// pb method show <name>
-// ---------------------------------------------------------------------------
-export async function runMethodShow(options) {
+export async function runMethodShow(ref) {
+    await getConfigOrGuide();
     await runCliCommand({
-        fn: async () => {
-            const root = projectRoot();
-            const sources = loadAllSources(root);
-            const source = sources.find((s) => s.name === options.name);
-            if (!source) {
-                throw new CLIError(`Method '${options.name}' not found in .productbrain/skills/ or .productbrain/rules/.`, {
-                    code: ErrorCode.VALIDATION_FAILED,
-                    category: 'validation',
-                    guidance: `Run 'pb method ls' to see available methods.`,
-                });
-            }
-            const [chainEntry, adapters] = await Promise.all([
-                fetchChainMethod(source.name),
-                Promise.resolve(checkAdapters(root, source)),
-            ]);
-            return {
-                name: source.name,
-                type: source.type,
-                frontmatter: source.frontmatter,
-                chain: chainEntry,
-                adapters,
-            };
-        },
-        formatPretty: (result) => formatMethodDetail(result),
+        fn: () => kernelCall('method.get', { ref: ref.trim() }), // the engine reads and refuses the ref
+        formatPretty: (data) => data.lines.join('\n'),
     });
 }
-// ---------------------------------------------------------------------------
-// pb method diff <name>
-// ---------------------------------------------------------------------------
-export async function runMethodDiff(options) {
-    await runCliCommand({
-        fn: async () => {
-            const root = projectRoot();
-            const sources = loadAllSources(root);
-            const source = sources.find((s) => s.name === options.name);
-            if (!source) {
-                throw new CLIError(`Method '${options.name}' not found in .productbrain/skills/ or .productbrain/rules/.`, {
-                    code: ErrorCode.VALIDATION_FAILED,
-                    category: 'validation',
-                    guidance: `Run 'pb method ls' to see available methods.`,
-                });
-            }
-            const chainEntry = await fetchChainMethod(source.name);
-            if (!chainEntry || chainEntry.body === undefined) {
-                return {
-                    name: source.name,
-                    published: false,
-                };
-            }
-            const localBody = source.body.trim();
-            const chainBody = (chainEntry.body ?? '').trim();
-            const diffLines = computeUnifiedDiff(chainBody, localBody);
-            // Detect hook-related changes — read alwaysApply from stored frontmatter JSON
-            const chainAlwaysApply = chainEntry.frontmatter?.alwaysApply;
-            const hookChanges = countHookChanges(diffLines, source.frontmatter.alwaysApply, chainAlwaysApply);
-            const hasFanOut = hookChanges > 0;
-            return {
-                name: source.name,
-                published: true,
-                diffLines,
-                hookChanges,
-                hasFanOut,
-            };
-        },
-        formatPretty: (result) => formatMethodDiff(result),
-    });
-}
-// ---------------------------------------------------------------------------
-// pb method publish <name>
-// ---------------------------------------------------------------------------
-export async function runMethodPublish(options) {
-    await runCliCommand({
-        fn: async () => {
-            // 1. Require active session — publish is a write operation (DEC-9, BR-8)
-            const session = readSession();
-            if (!session) {
-                throw new CLIError('No active session.', {
-                    code: ErrorCode.SESSION_REQUIRED,
-                    category: 'session',
-                    // DEC-9
-                    guidance: 'Run `pb session start` first. Write access requires a tracked session.',
-                });
-            }
-            // 2. Find local source file
-            const root = projectRoot();
-            const sources = loadAllSources(root);
-            const source = sources.find((s) => s.name === options.name);
-            if (!source) {
-                throw new CLIError(`Method '${options.name}' not found in .productbrain/skills/ or .productbrain/rules/.`, {
-                    code: ErrorCode.VALIDATION_FAILED,
-                    category: 'validation',
-                    guidance: `Run 'pb method ls' to see available methods.`,
-                });
-            }
-            // 3. Compute SHA-256 hash of the local body (everything after frontmatter)
-            const localBody = source.body.trim();
-            const manifestHash = createHash('sha256').update(localBody, 'utf8').digest('hex');
-            // 4. Query Chain for existing published entry
-            const existing = await fetchChainMethod(source.name);
-            // 5. D4 check — refuse on no-op (unless --force)
-            if (!options.force && existing && existing.manifestHash === manifestHash) {
-                const existingVersion = typeof existing.version === 'string'
-                    ? parseInt(existing.version, 10)
-                    : existing.version ?? 1;
-                throw new CLIError(`No changes to publish. Local body matches last-published version (v${existingVersion}). Use --force to override.`, {
-                    code: ErrorCode.VALIDATION_FAILED,
-                    category: 'validation',
-                    guidance: `Run 'pb method diff ${options.name}' to inspect differences.`,
-                });
-            }
-            // 6. Compute new version
-            const existingVersion = existing
-                ? (typeof existing.version === 'string'
-                    ? parseInt(existing.version, 10)
-                    : existing.version ?? 0)
-                : 0;
-            const newVersion = existingVersion + 1;
-            // 7. Serialize frontmatter for storage
-            const fm = source.frontmatter;
-            const frontmatterJson = JSON.stringify({
-                alwaysApply: fm.alwaysApply,
-                globs: fm.globs,
-                description: fm.description,
-            });
-            const publishedAt = new Date().toISOString();
-            const publishedBy = session.sessionId;
-            const entryData = {
-                name: source.name,
-                version: String(newVersion),
-                sourceType: source.type,
-                body: localBody,
-                frontmatter: frontmatterJson,
-                publishedAt,
-                publishedBy,
-                manifestHash,
-            };
-            // 8. Write to Chain — create or update
-            let created;
-            if (!existing || !existing._id) {
-                // No existing entry — createEntry
-                await kernelCallWithSession('chain.createEntry', {
-                    collectionSlug: 'methods',
-                    name: source.name,
-                    // `pb method publish` is an explicit publish action — bypasses governance-mode
-                    // resolution and commits directly (DEC-896 intentional, mirrors UI publish at
-                    // src/routes/api/brain/capture/+server.ts).
-                    status: 'active',
-                    data: entryData,
-                    sessionId: session.sessionId,
-                    createdBy: `agent:${session.sessionId}`,
-                });
-                created = true;
-            }
-            else {
-                // Existing entry — updateEntry (LWW: last-write-wins)
-                await kernelCallWithSession('chain.updateEntry', {
-                    entryId: existing._id,
-                    data: entryData,
-                    changedBy: `agent:${session.sessionId}`,
-                    changeNote: `Publish v${newVersion} via pb method publish`,
-                });
-                created = false;
-            }
-            return {
-                name: source.name,
-                version: newVersion,
-                manifestHash,
-                created,
-                previousVersion: newVersion > 1 ? existingVersion : undefined,
-            };
-        },
-        formatPretty: (result) => formatMethodPublish(result),
-    });
-}
-// ---------------------------------------------------------------------------
-// Formatters
-// ---------------------------------------------------------------------------
-function statusIcon(published) {
-    return published ? 'yes' : 'no ';
-}
-function adapterIcon(ok) {
-    return ok ? '\u2713' : '-';
-}
-function adapterStatusLabel(status) {
-    if (status === 'ok')
-        return 'ok';
-    if (status === 'forked')
-        return 'forked';
-    return 'missing';
-}
-function formatMethodList(result) {
-    if (result.total === 0) {
-        return 'No methods found. Expected .productbrain/skills/ and .productbrain/rules/ directories.';
-    }
-    const lines = [];
-    lines.push(`Methods (${result.total}):`);
-    lines.push('');
-    const maxName = Math.max(...result.methods.map((m) => m.name.length), 4);
-    const maxVersion = Math.max(...result.methods.map((m) => m.version.length), 7);
-    const header = [
-        'Name'.padEnd(maxName),
-        'Type '.padEnd(6),
-        'Version'.padEnd(maxVersion),
-        'Published',
-        'Claude',
-        'Cursor',
-        'Codex',
-    ].join('  ');
-    lines.push(`  ${header}`);
-    lines.push(`  ${'-'.repeat(header.length)}`);
-    // Group by type
-    const rules = result.methods.filter((m) => m.type === 'rule');
-    const skills = result.methods.filter((m) => m.type === 'skill');
-    const renderRow = (m) => {
-        return '  ' + [
-            m.name.padEnd(maxName),
-            m.type.padEnd(6),
-            m.version.padEnd(maxVersion),
-            statusIcon(m.published).padEnd(10),
-            adapterIcon(m.claude).padEnd(7),
-            adapterIcon(m.cursor).padEnd(7),
-            adapterIcon(m.codex),
-        ].join('  ');
-    };
-    if (rules.length > 0) {
-        lines.push('');
-        lines.push('  Rules:');
-        for (const m of rules) {
-            lines.push(renderRow(m));
-        }
-    }
-    if (skills.length > 0) {
-        lines.push('');
-        lines.push('  Skills:');
-        for (const m of skills) {
-            lines.push(renderRow(m));
-        }
-    }
-    lines.push('');
-    lines.push(`  ${rules.length} rules, ${skills.length} skills`);
-    lines.push('  Run `pb method show <name>` for fork status and Chain details.');
-    return lines.join('\n');
-}
-function formatMethodDetail(result) {
-    const lines = [];
-    const { name, type, frontmatter, chain, adapters } = result;
-    lines.push('');
-    lines.push(`Method: ${name}`);
-    lines.push(`Type:   ${type}`);
-    if (frontmatter.description) {
-        lines.push(`Desc:   ${frontmatter.description}`);
-    }
-    if (frontmatter.alwaysApply !== undefined) {
-        lines.push(`Always: ${frontmatter.alwaysApply}`);
-    }
-    if (frontmatter.globs) {
-        lines.push(`Globs:  ${frontmatter.globs}`);
-    }
-    if (frontmatter.level) {
-        lines.push(`Level:  ${frontmatter.level}`);
-    }
-    lines.push('');
-    if (chain) {
-        lines.push('Published:');
-        if (chain.version)
-            lines.push(`  Version:   ${chain.version}`);
-        if (chain.publishedAt)
-            lines.push(`  Published: ${chain.publishedAt}`);
-        if (chain.publishedBy)
-            lines.push(`  By:        ${chain.publishedBy}`);
-        if (chain.manifestHash)
-            lines.push(`  Hash:      ${chain.manifestHash}`);
-    }
-    else {
-        lines.push('Published: no (not in Chain methods collection)');
-    }
-    lines.push('');
-    lines.push('Adapter status:');
-    lines.push(`  claude:  ${adapterStatusLabel(adapters.claude)}`);
-    lines.push(`  cursor:  ${adapterStatusLabel(adapters.cursor)}`);
-    lines.push(`  codex:   ${adapterStatusLabel(adapters.codex)}`);
-    lines.push(`  copilot: ${adapterStatusLabel(adapters.copilot)}`);
-    const forked = Object.entries(adapters).filter(([, v]) => v === 'forked').map(([k]) => k);
-    const missing = Object.entries(adapters).filter(([, v]) => v === 'missing').map(([k]) => k);
-    if (forked.length > 0 || missing.length > 0) {
-        lines.push('');
-        if (forked.length > 0) {
-            lines.push(`  ! Forked adapters (out of sync): ${forked.join(', ')}`);
-            lines.push('    Run `pb handshake` to regenerate adapter files.');
-        }
-        if (missing.length > 0) {
-            lines.push(`  - Missing adapters: ${missing.join(', ')}`);
-            lines.push('    Run `pb handshake` to generate adapter files.');
-        }
-    }
-    else {
-        lines.push('');
-        lines.push('  All adapters in sync.');
-    }
-    return lines.join('\n');
-}
-function formatMethodPublish(result) {
-    const lines = [];
-    lines.push('');
-    lines.push(`Published: ${result.name} v${result.version}`);
-    lines.push(`Action:    ${result.created ? 'created' : 'updated'}`);
-    lines.push(`Hash:      ${result.manifestHash.slice(0, 16)}...`);
-    if (result.previousVersion !== undefined) {
-        lines.push('');
-        lines.push(`rollback with: pb method publish ${result.name} --version ${result.previousVersion}`);
-    }
-    lines.push('');
-    return lines.join('\n');
-}
-function formatMethodDiff(result) {
-    const lines = [];
-    if (!result.published) {
-        lines.push('');
-        lines.push(`Not published yet. Run \`pb method publish ${result.name}\` to publish.`);
-        lines.push('');
-        return lines.join('\n');
-    }
-    const diffLines = result.diffLines ?? [];
-    if (diffLines.length === 0) {
-        lines.push('');
-        lines.push(`Method: ${result.name}`);
-        lines.push('');
-        lines.push('  No changes. Local matches published version.');
-        lines.push('');
-        return lines.join('\n');
-    }
-    lines.push('');
-    lines.push(`Method: ${result.name}`);
-    lines.push('--- chain (published)');
-    lines.push('+++ local');
-    lines.push('');
-    for (const dl of diffLines) {
-        if (dl === '...') {
-            lines.push('  ...');
-        }
-        else if (dl.startsWith('+')) {
-            lines.push(`+ ${dl.slice(1)}`);
-        }
-        else if (dl.startsWith('-')) {
-            lines.push(`- ${dl.slice(1)}`);
-        }
-        else {
-            lines.push(`  ${dl.slice(1)}`);
-        }
-    }
-    if (result.hasFanOut) {
-        const n = result.hookChanges ?? 0;
-        lines.push('');
-        lines.push(`hooks: +${n} (claude-native, +fan-out to cursor,copilot via .claude/settings.json per INS-740)`);
-    }
-    lines.push('');
-    return lines.join('\n');
+export function registerMethodCommands(program) {
+    const methodCmd = program.command('method').description('The words an agent is served for its situation, by version');
+    methodCmd
+        .command('draft <file>')
+        .description('Write a draft version of a method from a JSON file; only sessions in this workspace can preview it')
+        .option('--score <file>', 'The score a grader in another conversation wrote for this draft, as JSON')
+        .action(runMethodDraft);
+    methodCmd
+        .command('show <method>')
+        .description('Print a method with its score: direction prints the live version, else the words in code; direction@4 prints version 4')
+        .action(runMethodShow);
 }
 //# sourceMappingURL=method.js.map