@shrkcrft/cli 0.1.0-alpha.2

package/dist/dashboard/live-session-server.js

@@ -0,0 +1,133 @@
+/**
+ * Live session server v2: serves an HTML view for one dev session, optionally
+ * with SSE-based "updated" notifications. Read-only — GET/HEAD only, no
+ * source writes, no apply endpoints, no shell execution.
+ *
+ * Extracted from dev.command.ts so it can be tested directly.
+ */
+import * as http from 'node:http';
+import * as fs from 'node:fs';
+import * as nodePath from 'node:path';
+import { renderDevSessionHtml, scanDevSession } from '@shrkcrft/inspector';
+const LIVE_SCRIPT = `<script>(function(){try{var es=new EventSource('/events');es.onmessage=function(){location.reload()};es.addEventListener('change',function(){location.reload()})}catch(e){}})();</script><meta http-equiv="refresh" content="30">`;
+export async function startLiveSessionServer(opts) {
+    const host = opts.host ?? '127.0.0.1';
+    const port = opts.port ?? 0;
+    const live = opts.live === true;
+    if (host !== '127.0.0.1' && host !== 'localhost' && host !== '::1') {
+        process.stderr.write(`WARNING: --host ${host} exposes the session server beyond localhost. Press Ctrl+C to abort if unintended.\n`);
+    }
+    const subscribers = new Set();
+    let lastVersion = 0;
+    let debounceTimer = null;
+    const broadcast = (event) => {
+        for (const s of [...subscribers]) {
+            try {
+                s(event);
+            }
+            catch {
+                subscribers.delete(s);
+            }
+        }
+    };
+    const scheduleBroadcast = (event) => {
+        if (debounceTimer)
+            clearTimeout(debounceTimer);
+        debounceTimer = setTimeout(() => {
+            lastVersion += 1;
+            broadcast(event);
+        }, 200);
+    };
+    const watchers = [];
+    if (live) {
+        for (const sub of ['session.json', 'plans', 'reports']) {
+            const target = nodePath.join(opts.load.dir, sub);
+            if (fs.existsSync(target)) {
+                try {
+                    const w = fs.watch(target, { recursive: true }, () => scheduleBroadcast(sub));
+                    watchers.push(w);
+                }
+                catch {
+                    try {
+                        const w = fs.watch(target, () => scheduleBroadcast(sub));
+                        watchers.push(w);
+                    }
+                    catch {
+                        /* ignore */
+                    }
+                }
+            }
+        }
+    }
+    const server = http.createServer((req, res) => {
+        try {
+            if (live && req.url === '/events') {
+                if (req.method !== 'GET') {
+                    res.statusCode = 405;
+                    res.setHeader('allow', 'GET');
+                    res.end();
+                    return;
+                }
+                res.writeHead(200, {
+                    'content-type': 'text/event-stream',
+                    'cache-control': 'no-store',
+                    connection: 'keep-alive',
+                });
+                const send = (event) => res.write(`event: change\ndata: ${event}\nid: ${lastVersion}\n\n`);
+                subscribers.add(send);
+                send('hello');
+                req.on('close', () => {
+                    subscribers.delete(send);
+                });
+                return;
+            }
+            if (req.method !== 'GET' && req.method !== 'HEAD') {
+                res.statusCode = 405;
+                res.setHeader('allow', 'GET, HEAD');
+                res.end('Method not allowed');
+                return;
+            }
+            const reload = scanDevSession(opts.cwd, opts.load.id) ?? opts.load;
+            let html = renderDevSessionHtml(reload, {
+                nextActionLine: reload.state?.nextAction ?? undefined,
+            });
+            if (live)
+                html = html.replace('</head>', LIVE_SCRIPT + '</head>');
+            res.statusCode = 200;
+            res.setHeader('content-type', 'text/html; charset=utf-8');
+            res.setHeader('cache-control', 'no-store');
+            if (req.method === 'HEAD') {
+                res.end();
+                return;
+            }
+            res.end(html);
+        }
+        catch (e) {
+            res.statusCode = 500;
+            res.end(`Error: ${e.message}`);
+        }
+    });
+    await new Promise((resolve) => server.listen(port, host, () => resolve()));
+    const addr = server.address();
+    const realPort = typeof addr === 'object' && addr ? addr.port : port;
+    return {
+        url: `http://${host}:${realPort}`,
+        host,
+        port: realPort,
+        triggerEvent: (event) => {
+            lastVersion += 1;
+            broadcast(event);
+        },
+        close: () => new Promise((resolve) => {
+            for (const w of watchers) {
+                try {
+                    w.close();
+                }
+                catch {
+                    /* ignore */
+                }
+            }
+            server.close(() => resolve());
+        }),
+    };
+}

package/dist/diff/collect-changed-paths.d.ts

@@ -0,0 +1,27 @@
+/**
+ * CLI-side `--since <ref>` helper. Thin wrapper over `git diff
+ * --name-status <ref>...HEAD` that returns the changed file set + a
+ * deleted file set + an `isAvailable` flag so callers can fall back
+ * to whole-tree mode cleanly.
+ *
+ * Default ref resolution when `--since` is passed without a value:
+ *   - `origin/main` if it resolves,
+ *   - else `main` if it resolves,
+ *   - else `undefined` (caller errors out).
+ *
+ * The function NEVER throws — git failures degrade to
+ * `isAvailable: false` with an error message.
+ */
+export interface IChangedPaths {
+    ref: string;
+    changed: readonly string[];
+    deleted: readonly string[];
+    isAvailable: boolean;
+    error?: string;
+}
+export declare function resolveDefaultSinceRef(cwd: string): string | undefined;
+export declare function collectChangedPaths(opts: {
+    cwd: string;
+    ref?: string;
+}): IChangedPaths;
+//# sourceMappingURL=collect-changed-paths.d.ts.map

package/dist/diff/collect-changed-paths.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"collect-changed-paths.d.ts","sourceRoot":"","sources":["../../src/diff/collect-changed-paths.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;GAaG;AACH,MAAM,WAAW,aAAa;IAC5B,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;IAC3B,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;IAC3B,WAAW,EAAE,OAAO,CAAC;IACrB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAMD,wBAAgB,sBAAsB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAYtE;AAED,wBAAgB,mBAAmB,CAAC,IAAI,EAAE;IACxC,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,CAAC,EAAE,MAAM,CAAC;CACd,GAAG,aAAa,CA+ChB"}

package/dist/diff/collect-changed-paths.js

@@ -0,0 +1,68 @@
+import { execSync } from 'node:child_process';
+import * as nodePath from 'node:path';
+const DEFAULT_REF_CANDIDATES = ['origin/main', 'main', 'origin/master', 'master'];
+const PER_PROCESS_CACHE = new Map();
+export function resolveDefaultSinceRef(cwd) {
+    for (const candidate of DEFAULT_REF_CANDIDATES) {
+        try {
+            execSync(`git -C "${cwd}" rev-parse --verify --quiet "${candidate}"`, {
+                stdio: 'pipe',
+            });
+            return candidate;
+        }
+        catch {
+            // try next
+        }
+    }
+    return undefined;
+}
+export function collectChangedPaths(opts) {
+    const ref = opts.ref ?? resolveDefaultSinceRef(opts.cwd);
+    if (!ref) {
+        return {
+            ref: '',
+            changed: [],
+            deleted: [],
+            isAvailable: false,
+            error: 'no resolvable default branch (tried origin/main, main, origin/master, master)',
+        };
+    }
+    const cacheKey = `${opts.cwd}::${ref}`;
+    const cached = PER_PROCESS_CACHE.get(cacheKey);
+    if (cached)
+        return cached;
+    try {
+        // Two-dot diff against the ref to match the inspector's
+        // `getChangedFiles({ since })` behavior — includes both committed
+        // changes and the working tree relative to <ref>.
+        const stdout = execSync(`git -C "${opts.cwd}" diff --name-status "${ref}"`, { stdio: ['ignore', 'pipe', 'pipe'], encoding: 'utf8' });
+        const changed = [];
+        const deleted = [];
+        for (const line of stdout.split('\n')) {
+            const trimmed = line.trim();
+            if (!trimmed)
+                continue;
+            const m = trimmed.match(/^(\w)\s+(.+)$/);
+            if (!m)
+                continue;
+            const [, status, path] = m;
+            const norm = nodePath.normalize(path).split(nodePath.sep).join('/');
+            if (status === 'D')
+                deleted.push(norm);
+            else
+                changed.push(norm);
+        }
+        const result = { ref, changed, deleted, isAvailable: true };
+        PER_PROCESS_CACHE.set(cacheKey, result);
+        return result;
+    }
+    catch (e) {
+        return {
+            ref,
+            changed: [],
+            deleted: [],
+            isAvailable: false,
+            error: e instanceof Error ? e.message : String(e),
+        };
+    }
+}

package/dist/doctor/doctor-tags.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Doctor warning source + state tagging.
+ *
+ * The default `shrk doctor` render used to be a wall: every warning,
+ * advisory or not, listed inline. Doctor folds advisory + acknowledged
+ * warnings into a summary line so the default view shows only what's
+ * actionable. `--show-advisory` (or `--strict`) restores the full view.
+ *
+ * The classifier is derived from the check id and severity — no upstream
+ * inspector schema change. If a future inspector adds a real `source` /
+ * `state` field, the helper can read it preferentially.
+ */
+import { type IDoctorCheck, type IDoctorSuppressionEntry } from '@shrkcrft/inspector';
+export declare enum DoctorSource {
+    Local = "local",
+    Pack = "pack",
+    BuiltIn = "built-in",
+    Generated = "generated",
+    Legacy = "legacy",
+    Unknown = "unknown"
+}
+export declare enum DoctorState {
+    Blocker = "blocker",
+    Active = "active",
+    Advisory = "advisory",
+    Acknowledged = "acknowledged",
+    ExpiredAcknowledgement = "expired-acknowledgement"
+}
+export declare function classifySource(check: IDoctorCheck): DoctorSource;
+export interface IClassifyStateInput {
+    /** Acknowledgement summary as produced by `summarizeAcknowledgements`. */
+    readonly acknowledgements: ReadonlyArray<IDoctorSuppressionEntry>;
+    /** Acknowledgements whose expiresAt is in the past. */
+    readonly expiredAcknowledgements: ReadonlyArray<IDoctorSuppressionEntry>;
+}
+export declare function classifyState(check: IDoctorCheck, ack: IClassifyStateInput): DoctorState;
+export interface IDoctorTagged {
+    readonly check: IDoctorCheck;
+    readonly source: DoctorSource;
+    readonly state: DoctorState;
+}
+export interface IDoctorFoldedView {
+    /** Tagged checks in input order. */
+    readonly tagged: ReadonlyArray<IDoctorTagged>;
+    /** Checks the default render should show (blockers + active warnings). */
+    readonly visible: ReadonlyArray<IDoctorTagged>;
+    /** Checks folded into the summary line. */
+    readonly folded: ReadonlyArray<IDoctorTagged>;
+    /** Per-state counts for the summary line. */
+    readonly counts: Readonly<Record<DoctorState, number>>;
+}
+export interface IFoldOptions {
+    /** When true, every advisory/acknowledged check stays visible. Default false. */
+    readonly showAdvisory?: boolean;
+    /** When true, all checks regardless of state stay visible. Default false. */
+    readonly showAll?: boolean;
+    /** Acknowledgement payload for state classification. */
+    readonly ack: IClassifyStateInput;
+}
+export declare function foldDoctorChecks(checks: ReadonlyArray<IDoctorCheck>, options: IFoldOptions): IDoctorFoldedView;
+/** Render the one-line fold summary for the default doctor view. */
+export declare function renderFoldedSummary(view: IDoctorFoldedView): string;
+//# sourceMappingURL=doctor-tags.d.ts.map

package/dist/doctor/doctor-tags.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"doctor-tags.d.ts","sourceRoot":"","sources":["../../src/doctor/doctor-tags.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,OAAO,EAEL,KAAK,YAAY,EACjB,KAAK,uBAAuB,EAC7B,MAAM,qBAAqB,CAAC;AAE7B,oBAAY,YAAY;IACtB,KAAK,UAAU;IACf,IAAI,SAAS;IACb,OAAO,aAAa;IACpB,SAAS,cAAc;IACvB,MAAM,WAAW;IACjB,OAAO,YAAY;CACpB;AAED,oBAAY,WAAW;IACrB,OAAO,YAAY;IACnB,MAAM,WAAW;IACjB,QAAQ,aAAa;IACrB,YAAY,iBAAiB;IAC7B,sBAAsB,4BAA4B;CACnD;AAsBD,wBAAgB,cAAc,CAAC,KAAK,EAAE,YAAY,GAAG,YAAY,CAKhE;AAED,MAAM,WAAW,mBAAmB;IAClC,0EAA0E;IAC1E,QAAQ,CAAC,gBAAgB,EAAE,aAAa,CAAC,uBAAuB,CAAC,CAAC;IAClE,uDAAuD;IACvD,QAAQ,CAAC,uBAAuB,EAAE,aAAa,CAAC,uBAAuB,CAAC,CAAC;CAC1E;AAYD,wBAAgB,aAAa,CAC3B,KAAK,EAAE,YAAY,EACnB,GAAG,EAAE,mBAAmB,GACvB,WAAW,CAeb;AAED,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,KAAK,EAAE,YAAY,CAAC;IAC7B,QAAQ,CAAC,MAAM,EAAE,YAAY,CAAC;IAC9B,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAC;CAC7B;AAED,MAAM,WAAW,iBAAiB;IAChC,oCAAoC;IACpC,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC,aAAa,CAAC,CAAC;IAC9C,0EAA0E;IAC1E,QAAQ,CAAC,OAAO,EAAE,aAAa,CAAC,aAAa,CAAC,CAAC;IAC/C,2CAA2C;IAC3C,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC,aAAa,CAAC,CAAC;IAC9C,6CAA6C;IAC7C,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,WAAW,EAAE,MAAM,CAAC,CAAC,CAAC;CACxD;AAED,MAAM,WAAW,YAAY;IAC3B,iFAAiF;IACjF,QAAQ,CAAC,YAAY,CAAC,EAAE,OAAO,CAAC;IAChC,6EAA6E;IAC7E,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC;IAC3B,wDAAwD;IACxD,QAAQ,CAAC,GAAG,EAAE,mBAAmB,CAAC;CACnC;AAED,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,aAAa,CAAC,YAAY,CAAC,EACnC,OAAO,EAAE,YAAY,GACpB,iBAAiB,CAiDnB;AAED,oEAAoE;AACpE,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,iBAAiB,GAAG,MAAM,CAenE"}

package/dist/doctor/doctor-tags.js

@@ -0,0 +1,146 @@
+/**
+ * Doctor warning source + state tagging.
+ *
+ * The default `shrk doctor` render used to be a wall: every warning,
+ * advisory or not, listed inline. Doctor folds advisory + acknowledged
+ * warnings into a summary line so the default view shows only what's
+ * actionable. `--show-advisory` (or `--strict`) restores the full view.
+ *
+ * The classifier is derived from the check id and severity — no upstream
+ * inspector schema change. If a future inspector adds a real `source` /
+ * `state` field, the helper can read it preferentially.
+ */
+import { DoctorSeverity, } from '@shrkcrft/inspector';
+export var DoctorSource;
+(function (DoctorSource) {
+    DoctorSource["Local"] = "local";
+    DoctorSource["Pack"] = "pack";
+    DoctorSource["BuiltIn"] = "built-in";
+    DoctorSource["Generated"] = "generated";
+    DoctorSource["Legacy"] = "legacy";
+    DoctorSource["Unknown"] = "unknown";
+})(DoctorSource || (DoctorSource = {}));
+export var DoctorState;
+(function (DoctorState) {
+    DoctorState["Blocker"] = "blocker";
+    DoctorState["Active"] = "active";
+    DoctorState["Advisory"] = "advisory";
+    DoctorState["Acknowledged"] = "acknowledged";
+    DoctorState["ExpiredAcknowledgement"] = "expired-acknowledgement";
+})(DoctorState || (DoctorState = {}));
+const SOURCE_PREFIX_MAP = [
+    [/^pack-/i, DoctorSource.Pack],
+    [/^packs-/i, DoctorSource.Pack],
+    [/^stale-pack-signature/i, DoctorSource.Pack],
+    [/^generated-/i, DoctorSource.Generated],
+    [/^legacy-/i, DoctorSource.Legacy],
+    [/^config-/i, DoctorSource.BuiltIn],
+    [/^self-config/i, DoctorSource.BuiltIn],
+    [/^sharkcraft-folder/i, DoctorSource.BuiltIn],
+    [/^runtime-/i, DoctorSource.BuiltIn],
+    [/^actionhints-/i, DoctorSource.Local],
+    [/^action-hint/i, DoctorSource.Local],
+    [/^knowledge-/i, DoctorSource.Local],
+    [/^template-/i, DoctorSource.Local],
+    [/^rule(s)?-/i, DoctorSource.Local],
+    [/^path(s)?-/i, DoctorSource.Local],
+    [/^pipeline(s)?-/i, DoctorSource.Local],
+    [/^boundar(y|ies)/i, DoctorSource.Local],
+];
+export function classifySource(check) {
+    for (const [re, src] of SOURCE_PREFIX_MAP) {
+        if (re.test(check.id))
+            return src;
+    }
+    return DoctorSource.Unknown;
+}
+function suppressionMatches(check, entry) {
+    if (entry.id && entry.id === check.id)
+        return true;
+    if (entry.code && entry.code === check.code)
+        return true;
+    if (entry.category && check.category && entry.category === check.category)
+        return true;
+    return false;
+}
+export function classifyState(check, ack) {
+    // Expired acknowledgements take priority over the advisory tag — they
+    // need attention.
+    for (const e of ack.expiredAcknowledgements) {
+        if (suppressionMatches(check, e))
+            return DoctorState.ExpiredAcknowledgement;
+    }
+    for (const a of ack.acknowledgements) {
+        if (suppressionMatches(check, a))
+            return DoctorState.Acknowledged;
+    }
+    if (check.advisory === true)
+        return DoctorState.Advisory;
+    if (check.severity === DoctorSeverity.Error)
+        return DoctorState.Blocker;
+    if (check.severity === DoctorSeverity.Warning)
+        return DoctorState.Active;
+    // Info / Ok stay as Active for the purpose of folding (they're not
+    // blockers but they're also not advisory).
+    return DoctorState.Active;
+}
+export function foldDoctorChecks(checks, options) {
+    const counts = {
+        [DoctorState.Blocker]: 0,
+        [DoctorState.Active]: 0,
+        [DoctorState.Advisory]: 0,
+        [DoctorState.Acknowledged]: 0,
+        [DoctorState.ExpiredAcknowledgement]: 0,
+    };
+    const tagged = [];
+    const visible = [];
+    const folded = [];
+    const okSeverities = new Set([
+        DoctorSeverity.Ok,
+        DoctorSeverity.Info,
+    ]);
+    for (const check of checks) {
+        const source = classifySource(check);
+        const state = classifyState(check, options.ack);
+        const entry = { check, source, state };
+        tagged.push(entry);
+        counts[state] += 1;
+        if (options.showAll) {
+            visible.push(entry);
+            continue;
+        }
+        // Always show OK / Info regardless of state (they're rendered as the
+        // header strip in doctor output).
+        if (okSeverities.has(check.severity)) {
+            visible.push(entry);
+            continue;
+        }
+        if (options.showAdvisory) {
+            visible.push(entry);
+            continue;
+        }
+        if (state === DoctorState.Advisory ||
+            state === DoctorState.Acknowledged) {
+            folded.push(entry);
+            continue;
+        }
+        visible.push(entry);
+    }
+    return { tagged, visible, folded, counts };
+}
+/** Render the one-line fold summary for the default doctor view. */
+export function renderFoldedSummary(view) {
+    const parts = [];
+    if (view.counts[DoctorState.Advisory] > 0) {
+        parts.push(`${view.counts[DoctorState.Advisory]} advisory`);
+    }
+    if (view.counts[DoctorState.Acknowledged] > 0) {
+        parts.push(`${view.counts[DoctorState.Acknowledged]} acknowledged`);
+    }
+    if (view.counts[DoctorState.ExpiredAcknowledgement] > 0) {
+        parts.push(`${view.counts[DoctorState.ExpiredAcknowledgement]} expired-acknowledgement`);
+    }
+    if (parts.length === 0)
+        return '';
+    return `Folded: ${parts.join(', ')} (run with --show-advisory or --strict to expand)\n`;
+}

package/dist/export/export-formats.d.ts

@@ -0,0 +1,22 @@
+import type { ISharkcraftInspection } from '@shrkcrft/inspector';
+export type ExportFormat = 'agents-md' | 'claude-md' | 'cursor-rules' | 'copilot-instructions';
+export interface ExportOptions {
+    format: ExportFormat;
+    /** Optional task to scope the export. */
+    task?: string;
+    /** Max number of rules to include. Default 12. */
+    maxRules?: number;
+    /** Max number of path conventions to include. Default 10. */
+    maxPaths?: number;
+}
+export interface ExportResult {
+    format: ExportFormat;
+    /** Suggested relative output path within the project. */
+    suggestedPath: string;
+    /** Rendered content. */
+    content: string;
+}
+export declare function renderExport(inspection: ISharkcraftInspection, options: ExportOptions): ExportResult;
+export declare function isExportFormat(value: string): value is ExportFormat;
+export declare const ALL_EXPORT_FORMATS: readonly ExportFormat[];
+//# sourceMappingURL=export-formats.d.ts.map

package/dist/export/export-formats.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"export-formats.d.ts","sourceRoot":"","sources":["../../src/export/export-formats.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,qBAAqB,CAAC;AAIjE,MAAM,MAAM,YAAY,GACpB,WAAW,GACX,WAAW,GACX,cAAc,GACd,sBAAsB,CAAC;AAE3B,MAAM,WAAW,aAAa;IAC5B,MAAM,EAAE,YAAY,CAAC;IACrB,yCAAyC;IACzC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,kDAAkD;IAClD,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,6DAA6D;IAC7D,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,YAAY;IAC3B,MAAM,EAAE,YAAY,CAAC;IACrB,yDAAyD;IACzD,aAAa,EAAE,MAAM,CAAC;IACtB,wBAAwB;IACxB,OAAO,EAAE,MAAM,CAAC;CACjB;AAqHD,wBAAgB,YAAY,CAC1B,UAAU,EAAE,qBAAqB,EACjC,OAAO,EAAE,aAAa,GACrB,YAAY,CAsBd;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK,IAAI,YAAY,CAOnE;AAED,eAAO,MAAM,kBAAkB,EAAE,SAAS,YAAY,EAKpD,CAAC"}

package/dist/export/export-formats.js

@@ -0,0 +1,135 @@
+import { aggregateActionHints, KnowledgeType } from '@shrkcrft/knowledge';
+import { priorityWeight } from '@shrkcrft/knowledge';
+const DEFAULT_OUTPUT_PATH = {
+    'agents-md': 'AGENTS.md',
+    'claude-md': 'CLAUDE.md',
+    'cursor-rules': '.cursor/rules/sharkcraft.mdc',
+    'copilot-instructions': '.github/copilot-instructions.md',
+};
+function selectTopByPriority(entries, limit) {
+    return [...entries]
+        .sort((a, b) => priorityWeight(b.priority) - priorityWeight(a.priority))
+        .slice(0, limit);
+}
+function shortBullet(text, maxLen = 160) {
+    const single = text.replace(/\s+/g, ' ').trim();
+    if (single.length <= maxLen)
+        return single;
+    return single.slice(0, maxLen - 1) + '…';
+}
+function gatherRulesAndPaths(inspection, options) {
+    const allRules = inspection.knowledgeEntries.filter((e) => String(e.type) === KnowledgeType.Rule);
+    const allPaths = inspection.knowledgeEntries.filter((e) => String(e.type) === KnowledgeType.Path);
+    const rules = selectTopByPriority(allRules, options.maxRules ?? 12);
+    const paths = selectTopByPriority(allPaths, options.maxPaths ?? 10);
+    return { rules, paths };
+}
+function renderRulesSection(rules) {
+    if (rules.length === 0)
+        return '';
+    const lines = [];
+    for (const r of rules) {
+        lines.push(`- **${r.title}** (\`${r.id}\`, ${r.priority}) — ${shortBullet(r.summary ?? r.content)}`);
+    }
+    return lines.join('\n');
+}
+function renderPathsSection(paths) {
+    if (paths.length === 0)
+        return '';
+    const lines = [];
+    for (const p of paths) {
+        const path = p.metadata?.path ?? '';
+        lines.push(`- \`${p.id}\` → \`${path}\` — ${shortBullet(p.metadata?.description ?? p.title)}`);
+    }
+    return lines.join('\n');
+}
+function renderAgentActions(inspection) {
+    const agg = aggregateActionHints(inspection.knowledgeEntries);
+    const lines = [];
+    if (agg.commands.length) {
+        lines.push('Run these commands when relevant:');
+        for (const c of agg.commands.slice(0, 8)) {
+            const purpose = c.purpose ? ` — ${c.purpose}` : '';
+            lines.push(`- \`${c.command}\`${purpose}`);
+        }
+        lines.push('');
+    }
+    if (agg.mcpTools.length) {
+        lines.push('Prefer these MCP tools (when an MCP server is connected):');
+        for (const t of agg.mcpTools.slice(0, 8)) {
+            lines.push(`- \`${t.tool}\``);
+        }
+        lines.push('');
+    }
+    if (agg.forbiddenActions.length) {
+        lines.push('Do not:');
+        for (const f of agg.forbiddenActions.slice(0, 8))
+            lines.push(`- ${f}`);
+        lines.push('');
+    }
+    if (agg.verificationCommands.length) {
+        lines.push('Verify your work with:');
+        for (const c of agg.verificationCommands.slice(0, 6))
+            lines.push(`- \`${c}\``);
+        lines.push('');
+    }
+    return lines.join('\n').trim();
+}
+const PREAMBLE = `> Generated by \`shrk export\`. SharkCraft (structured knowledge + MCP) is the source of truth; this file is a compatibility shim for clients that read flat markdown.`;
+function renderBody(inspection, options) {
+    const { rules, paths } = gatherRulesAndPaths(inspection, options);
+    const sections = [];
+    if (inspection.config?.projectName) {
+        sections.push(`## Project\n\n${inspection.config.projectName}${inspection.config.description ? ` — ${inspection.config.description}` : ''}`);
+    }
+    if (options.task) {
+        sections.push(`## Task focus\n\n_${options.task}_`);
+    }
+    const rulesBody = renderRulesSection(rules);
+    if (rulesBody)
+        sections.push(`## Rules to follow\n\n${rulesBody}`);
+    const pathsBody = renderPathsSection(paths);
+    if (pathsBody)
+        sections.push(`## Where files belong\n\n${pathsBody}`);
+    const actions = renderAgentActions(inspection);
+    if (actions)
+        sections.push(`## Agent actions\n\n${actions}`);
+    if (inspection.pipelines.length) {
+        const pipelines = inspection.pipelines.slice(0, 5).map((p) => `- \`${p.id}\` — ${p.description}`);
+        sections.push(`## Pipelines (declarative workflows)\n\n${pipelines.join('\n')}\n\nRun \`shrk pipelines get <id>\` for full step lists.`);
+    }
+    return sections.join('\n\n');
+}
+export function renderExport(inspection, options) {
+    const body = renderBody(inspection, options);
+    const suggestedPath = DEFAULT_OUTPUT_PATH[options.format];
+    let content = '';
+    switch (options.format) {
+        case 'agents-md':
+            content = `# Agents Guide\n\n${PREAMBLE}\n\n${body}\n`;
+            break;
+        case 'claude-md':
+            content = `# CLAUDE.md\n\n${PREAMBLE}\n\nThis file is read by Claude Code (claude.ai/code) at session start. Treat it as a compatibility view of the project's SharkCraft knowledge — use the MCP server (\`shrk mcp serve\`) for the live, queryable source of truth.\n\n${body}\n`;
+            break;
+        case 'cursor-rules':
+            // Cursor MDC frontmatter: leave alwaysApply off so the user can tune.
+            content = `---\ndescription: SharkCraft project rules (auto-generated)\nalwaysApply: false\n---\n\n${PREAMBLE}\n\n${body}\n`;
+            break;
+        case 'copilot-instructions':
+            content = `# Copilot instructions\n\n${PREAMBLE}\n\n${body}\n`;
+            break;
+    }
+    return { format: options.format, suggestedPath, content };
+}
+export function isExportFormat(value) {
+    return (value === 'agents-md' ||
+        value === 'claude-md' ||
+        value === 'cursor-rules' ||
+        value === 'copilot-instructions');
+}
+export const ALL_EXPORT_FORMATS = Object.freeze([
+    'agents-md',
+    'claude-md',
+    'cursor-rules',
+    'copilot-instructions',
+]);

package/dist/index.d.ts

@@ -0,0 +1,22 @@
+export * from './command-registry.js';
+export { initCommand } from './commands/init.command.js';
+export { inspectCommand } from './commands/inspect.command.js';
+export { doctorCommand } from './commands/doctor.command.js';
+export { knowledgeListCommand, knowledgeGetCommand, knowledgeSearchCommand, } from './commands/knowledge.command.js';
+export { rulesListCommand, rulesGetCommand, rulesRelevantCommand, } from './commands/rules.command.js';
+export { pathsListCommand, pathsGetCommand, pathsSearchCommand, pathsBestCommand, } from './commands/paths.command.js';
+export { templatesListCommand, templatesGetCommand, templatesSearchCommand, templatesPreviewCommand, } from './commands/templates.command.js';
+export { contextCommand } from './commands/context.command.js';
+export { genCommand } from './commands/gen.command.js';
+export { applyCommand } from './commands/apply.command.js';
+export { askCommand } from './commands/ask.command.js';
+export { exportCommand } from './commands/export.command.js';
+export { importCommand } from './commands/import.command.js';
+export { mcpCommand } from './commands/mcp.command.js';
+export { packsListCommand, packsGetCommand, packsInspectCommand, packsDoctorCommand, packsSignCommand, packsVerifyCommand, } from './commands/packs.command.js';
+export { pipelinesListCommand, pipelinesGetCommand, pipelinesContextCommand, pipelinesPlanCommand, pipelinesScriptCommand, pipelinesNextCommand, } from './commands/pipelines.command.js';
+export { schemasListCommand, schemasGetCommand, schemasWriteCommand, } from './commands/schemas.command.js';
+export { versionCommand } from './commands/version.command.js';
+export { makeHelpCommand } from './commands/help.command.js';
+export { buildRegistry, runCli } from './main.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC;AACtC,OAAO,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AACzD,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC/D,OAAO,EAAE,aAAa,EAAE,MAAM,8BAA8B,CAAC;AAC7D,OAAO,EACL,oBAAoB,EACpB,mBAAmB,EACnB,sBAAsB,GACvB,MAAM,iCAAiC,CAAC;AACzC,OAAO,EACL,gBAAgB,EAChB,eAAe,EACf,oBAAoB,GACrB,MAAM,6BAA6B,CAAC;AACrC,OAAO,EACL,gBAAgB,EAChB,eAAe,EACf,kBAAkB,EAClB,gBAAgB,GACjB,MAAM,6BAA6B,CAAC;AACrC,OAAO,EACL,oBAAoB,EACpB,mBAAmB,EACnB,sBAAsB,EACtB,uBAAuB,GACxB,MAAM,iCAAiC,CAAC;AACzC,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC/D,OAAO,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAC;AACvD,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAC3D,OAAO,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAC;AACvD,OAAO,EAAE,aAAa,EAAE,MAAM,8BAA8B,CAAC;AAC7D,OAAO,EAAE,aAAa,EAAE,MAAM,8BAA8B,CAAC;AAC7D,OAAO,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAC;AACvD,OAAO,EACL,gBAAgB,EAChB,eAAe,EACf,mBAAmB,EACnB,kBAAkB,EAClB,gBAAgB,EAChB,kBAAkB,GACnB,MAAM,6BAA6B,CAAC;AACrC,OAAO,EACL,oBAAoB,EACpB,mBAAmB,EACnB,uBAAuB,EACvB,oBAAoB,EACpB,sBAAsB,EACtB,oBAAoB,GACrB,MAAM,iCAAiC,CAAC;AACzC,OAAO,EACL,kBAAkB,EAClB,iBAAiB,EACjB,mBAAmB,GACpB,MAAM,+BAA+B,CAAC;AACvC,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC/D,OAAO,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAC7D,OAAO,EAAE,aAAa,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC"}

package/dist/index.js

@@ -0,0 +1,21 @@
+export * from "./command-registry.js";
+export { initCommand } from "./commands/init.command.js";
+export { inspectCommand } from "./commands/inspect.command.js";
+export { doctorCommand } from "./commands/doctor.command.js";
+export { knowledgeListCommand, knowledgeGetCommand, knowledgeSearchCommand, } from "./commands/knowledge.command.js";
+export { rulesListCommand, rulesGetCommand, rulesRelevantCommand, } from "./commands/rules.command.js";
+export { pathsListCommand, pathsGetCommand, pathsSearchCommand, pathsBestCommand, } from "./commands/paths.command.js";
+export { templatesListCommand, templatesGetCommand, templatesSearchCommand, templatesPreviewCommand, } from "./commands/templates.command.js";
+export { contextCommand } from "./commands/context.command.js";
+export { genCommand } from "./commands/gen.command.js";
+export { applyCommand } from "./commands/apply.command.js";
+export { askCommand } from "./commands/ask.command.js";
+export { exportCommand } from "./commands/export.command.js";
+export { importCommand } from "./commands/import.command.js";
+export { mcpCommand } from "./commands/mcp.command.js";
+export { packsListCommand, packsGetCommand, packsInspectCommand, packsDoctorCommand, packsSignCommand, packsVerifyCommand, } from "./commands/packs.command.js";
+export { pipelinesListCommand, pipelinesGetCommand, pipelinesContextCommand, pipelinesPlanCommand, pipelinesScriptCommand, pipelinesNextCommand, } from "./commands/pipelines.command.js";
+export { schemasListCommand, schemasGetCommand, schemasWriteCommand, } from "./commands/schemas.command.js";
+export { versionCommand } from "./commands/version.command.js";
+export { makeHelpCommand } from "./commands/help.command.js";
+export { buildRegistry, runCli } from "./main.js";