@productbrain/cli 0.1.0-beta.30 → 0.1.0-beta.3015

package/dist/commands/method.js

@@ -0,0 +1,804 @@
+/**
+ * pb method ls / pb method show <name> / pb method diff <name> / pb method publish <name>
+ * WP-329 S1-S3: Method visibility CLI + publish.
+ *
+ * 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).
+ */
+import { createHash } from 'node:crypto';
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { cwd } from 'node:process';
+import { MARKER } from '../generators/adapters.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;
+    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';
+    }
+    // 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';
+    }
+    // The Copilot instructions are hand-maintained, COMMITTED SSOT — they carry NO auto-gen MARKER,
+    // so handshake classifies them as user-owned and never projects per-rule summaries into them
+    // (DEC-1343). A markerless file is therefore in-sync by definition: it is not a pb write target,
+    // so it can never be "forked" from the Chain. Reporting `forked` here (and telling the user to run
+    // `pb handshake`) would be a permanent false out-of-sync on every committed Copilot file.
+    if (!copilotContent.includes(MARKER))
+        return 'ok';
+    // pb-generated copilot-instructions.md (MARKER present) stores summaries (### name), not 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;
+        });
+        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() {
+    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),
+    });
+}
+// ---------------------------------------------------------------------------
+// pb method show <name>
+// ---------------------------------------------------------------------------
+export async function runMethodShow(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, 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),
+    });
+}
+// ---------------------------------------------------------------------------
+// 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)
+                const updateResult = await kernelCallWithSession('chain.updateEntry', {
+                    entryId: existing._id,
+                    data: entryData,
+                    changedBy: `agent:${session.sessionId}`,
+                    changeNote: `Publish v${newVersion} via pb method publish`,
+                });
+                // WP-465 slice ⑤ (Option B): a coherency refusal RETURNS a structured payload — the
+                // entry is unchanged, so report a refusal instead of a successful publish.
+                if (updateResult?.outcome === 'refused') {
+                    throw new CLIError(updateResult.refusal?.reason ?? `Publish of '${source.name}' was refused by the coherency gate.`, {
+                        code: ErrorCode.VALIDATION_FAILED,
+                        category: 'validation',
+                        guidance: 'Link the entry to the strategic spine and retry, or resolve the coherency challenge before publishing.',
+                    });
+                }
+                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');
+}
+//# sourceMappingURL=method.js.map