@shrkcrft/inspector 0.1.0-alpha.1

package/dist/entrypoint-matrix.js

@@ -0,0 +1,221 @@
+/**
+ * Entrypoint matrix.
+ *
+ * Classifies SharkCraft's many "get me context" / "what should I do?" surfaces
+ * into four discrete entrypoint classes:
+ *
+ *   - human-interactive    — shells / TTY use; primary first answer.
+ *   - agent-mcp            — what an AI coding agent should call first.
+ *   - machine-json         — non-human, machine-consumable JSON packets.
+ *   - debug-explainability — ranker / boundary / search debugging.
+ *
+ * This is pure curated data. The CLI exposes it via `shrk commands matrix`,
+ * and individual commands (`shrk task`, `shrk context`, `shrk recommend`)
+ * include a one-line banner referencing this matrix so the operator sees
+ * which class they reached.
+ */
+export const ENTRYPOINT_MATRIX_SCHEMA = 'sharkcraft.entrypoint-matrix/v1';
+export var EntrypointClass;
+(function (EntrypointClass) {
+    EntrypointClass["HumanInteractive"] = "human-interactive";
+    EntrypointClass["AgentMcp"] = "agent-mcp";
+    EntrypointClass["MachineJson"] = "machine-json";
+    EntrypointClass["DebugExplainability"] = "debug-explainability";
+})(EntrypointClass || (EntrypointClass = {}));
+const MATRIX_ENTRIES = [
+    {
+        id: 'recommend',
+        class: EntrypointClass.HumanInteractive,
+        callShape: 'shrk recommend "<task>"',
+        whenToUse: 'You are a human at a terminal and want "what should I do?" — primary interactive entrypoint.',
+        safety: 'read-only',
+        docs: 'docs/recommend.md',
+        seeAlso: ['start-here', 'task-context'],
+    },
+    {
+        id: 'start-here',
+        class: EntrypointClass.HumanInteractive,
+        callShape: 'shrk start-here [--flow <name>]',
+        whenToUse: 'First-time onboarding overview — 30-second explanation, primary flows, safety pledge.',
+        safety: 'read-only',
+        docs: 'docs/start-here.md',
+        seeAlso: ['recommend'],
+    },
+    {
+        id: 'context',
+        class: EntrypointClass.HumanInteractive,
+        callShape: 'shrk context --task "<task>"',
+        whenToUse: 'Build a focused, token-budgeted context bundle for a specific task. For action-like tasks, commands surface first.',
+        safety: 'read-only',
+        docs: 'docs/context.md',
+        seeAlso: ['recommend', 'task-context'],
+    },
+    {
+        id: 'prepare-agent-task',
+        class: EntrypointClass.AgentMcp,
+        callShape: 'mcp__sharkcraft__prepare_agent_task',
+        whenToUse: 'An AI agent\'s first MCP call for a task — returns brief + plan + verification commands. Read-only.',
+        safety: 'read-only',
+        docs: 'docs/agent-task-prep.md',
+        seeAlso: ['get-relevant-context', 'get-task-packet'],
+    },
+    {
+        id: 'get-relevant-context',
+        class: EntrypointClass.AgentMcp,
+        callShape: 'mcp__sharkcraft__get_relevant_context',
+        whenToUse: 'Agent-side equivalent of `shrk context`. Token-budgeted, read-only.',
+        safety: 'read-only',
+    },
+    {
+        id: 'get-task-packet',
+        class: EntrypointClass.AgentMcp,
+        callShape: 'mcp__sharkcraft__get_task_packet',
+        whenToUse: 'Agent-side equivalent of `shrk task` — full task packet.',
+        safety: 'read-only',
+    },
+    {
+        id: 'task',
+        class: EntrypointClass.MachineJson,
+        callShape: 'shrk task "<task>" --json',
+        whenToUse: 'Machine-readable JSON envelope of rules + templates + pipelines + commands. Pipe into another tool.',
+        safety: 'read-only',
+        seeAlso: ['get-task-packet', 'context'],
+    },
+    {
+        id: 'search',
+        class: EntrypointClass.MachineJson,
+        callShape: 'shrk search "<query>" [--json]',
+        whenToUse: 'Registry search across knowledge, rules, templates, playbooks, etc. JSON for piping; text for humans.',
+        safety: 'read-only',
+    },
+    {
+        id: 'why',
+        class: EntrypointClass.DebugExplainability,
+        callShape: 'shrk why <id> | shrk why-not <id>',
+        whenToUse: 'Debug the ranker — why a registry entry was / was not surfaced for a task.',
+        safety: 'read-only',
+        docs: 'docs/why.md',
+        seeAlso: ['recommend', 'context'],
+    },
+    {
+        id: 'graph-why',
+        class: EntrypointClass.DebugExplainability,
+        callShape: 'shrk graph why <a> <b>',
+        whenToUse: 'Shortest-path explanation between two graph nodes.',
+        safety: 'read-only',
+        seeAlso: ['why'],
+    },
+    {
+        id: 'apply-explain-dispatch',
+        class: EntrypointClass.DebugExplainability,
+        callShape: 'shrk apply <plan> --explain-dispatch',
+        whenToUse: 'Describe which dispatch path apply would take (template / helper / plugin-lifecycle / registration-hint / synthetic) without applying anything.',
+        safety: 'read-only',
+    },
+    // Distinguish `shrk task` text output (machine packet) from
+    // `task --json` (the canonical machine surface).
+    {
+        id: 'task-text',
+        class: EntrypointClass.MachineJson,
+        callShape: 'shrk task "<task>"',
+        whenToUse: 'Machine packet rendered as text. For a human answer prefer `shrk recommend`; for piping prefer `shrk task --json`.',
+        safety: 'read-only',
+        seeAlso: ['recommend', 'task', 'get-task-packet'],
+    },
+    // Make `shrk search` self-evidently a registry search, not
+    // "what should I do?".
+    {
+        id: 'search-registry',
+        class: EntrypointClass.MachineJson,
+        callShape: 'shrk search "<query>"',
+        whenToUse: 'Registry search over knowledge / rules / templates / playbooks. NOT "what should I do?" — for that use `shrk recommend`.',
+        safety: 'read-only',
+        seeAlso: ['recommend', 'context'],
+    },
+];
+const DECISION_TREE = [
+    {
+        when: 'You are a HUMAN in a terminal asking "what should I do?"',
+        use: 'shrk recommend "<task>"',
+    },
+    {
+        when: 'You are a HUMAN exploring SharkCraft for the first time',
+        use: 'shrk start-here',
+    },
+    {
+        when: 'You are an AGENT making your first MCP call for a task',
+        use: 'mcp__sharkcraft__prepare_agent_task',
+    },
+    {
+        when: 'You want a MACHINE-readable JSON packet',
+        use: 'shrk task "<task>" --json',
+    },
+    {
+        when: 'You are DEBUGGING the ranker / boundary / dispatch',
+        use: 'shrk why <id> / shrk graph why <a> <b> / shrk apply <plan> --explain-dispatch',
+    },
+];
+export function buildEntrypointMatrix() {
+    return {
+        schema: ENTRYPOINT_MATRIX_SCHEMA,
+        entries: MATRIX_ENTRIES,
+        decisionTree: DECISION_TREE,
+    };
+}
+export function renderEntrypointMatrixText(report) {
+    const lines = [];
+    lines.push('# SharkCraft entrypoint matrix');
+    lines.push('');
+    lines.push('## When you are …');
+    for (const d of report.decisionTree)
+        lines.push(`  • ${d.when}\n      → ${d.use}`);
+    lines.push('');
+    lines.push('## By class');
+    const grouped = new Map();
+    for (const e of report.entries) {
+        const arr = grouped.get(e.class) ?? [];
+        arr.push(e);
+        grouped.set(e.class, arr);
+    }
+    for (const [cls, list] of grouped) {
+        lines.push('');
+        lines.push(`### ${cls}`);
+        for (const e of list) {
+            lines.push(`  $ ${e.callShape}`);
+            lines.push(`    ${e.whenToUse}`);
+            lines.push(`    safety: ${e.safety}${e.docs ? `  docs: ${e.docs}` : ''}`);
+            if (e.seeAlso && e.seeAlso.length > 0) {
+                lines.push(`    see also: ${e.seeAlso.join(', ')}`);
+            }
+        }
+    }
+    return lines.join('\n') + '\n';
+}
+/**
+ * Short banner each command can print to make its role explicit.
+ * Wording aligned with the canonical-entrypoint message so every
+ * overlapping surface points back at `shrk recommend` for the
+ * "what should I do?" question.
+ *
+ *   shrk recommend  — canonical human entrypoint.
+ *   shrk context    — context for doing the task; recommend is the workflow.
+ *   shrk task       — machine/task-packet surface; recommend is the workflow.
+ *   shrk search     — registry search; recommend is the workflow.
+ *   shrk why        — ranker reasoning; recommend is the workflow.
+ */
+export function entrypointBanner(id) {
+    switch (id) {
+        case 'task':
+            return 'Entrypoint class: machine-json — task packet for agents / JSON pipes. For human workflow guidance run `shrk recommend "<task>"`. For agent grounding prefer `prepare_agent_task`.';
+        case 'task-json':
+            return 'Entrypoint class: machine-json (--json). Pipe into another tool; humans usually want `shrk recommend` or `shrk context`.';
+        case 'context':
+            return 'Entrypoint class: human-interactive — context for doing the task. For step-by-step workflow guidance run `shrk recommend "<task>"`.';
+        case 'recommend':
+            return 'Entrypoint class: human-interactive — canonical human entrypoint for "what should I do?".';
+        case 'search':
+            return 'Entrypoint class: machine-json — searches registries/contributions. For workflow guidance run `shrk recommend "<query>"`; for ranking explanation run `shrk why <id> --for-task "<query>"`.';
+        case 'why':
+            return 'Entrypoint class: debug-explainability — explains ranker decisions. Not the main workflow entrypoint — for that run `shrk recommend`.';
+    }
+}

package/dist/examples-check.d.ts

@@ -0,0 +1,36 @@
+/**
+ * `shrk examples check` — verify the examples/ tree is sound.
+ *
+ * Read-only. Verifies:
+ *  - examples/ exists
+ *  - each example directory has a package.json
+ *  - example commands referenced in known scripts are present in the catalog
+ *    (best-effort)
+ *  - no destructive commands in any included demo script
+ */
+export declare const EXAMPLES_CHECK_SCHEMA = "sharkcraft.examples-check/v1";
+export interface IExamplesCheckFinding {
+    code: 'examples-dir-missing' | 'example-missing-package-json' | 'destructive-command-detected' | 'unknown-command-reference' | 'demo-script-unsafe';
+    severity: 'info' | 'warning' | 'error';
+    message: string;
+    file?: string;
+    suggestion?: string;
+}
+export interface IExamplesCheckReport {
+    schema: typeof EXAMPLES_CHECK_SCHEMA;
+    generatedAt: string;
+    projectRoot: string;
+    examples: readonly {
+        name: string;
+        path: string;
+        hasPackageJson: boolean;
+    }[];
+    findings: readonly IExamplesCheckFinding[];
+    ok: boolean;
+}
+export interface IBuildExamplesCheckOptions {
+    knownCommands?: readonly string[];
+}
+export declare function buildExamplesCheck(projectRoot: string, options?: IBuildExamplesCheckOptions): IExamplesCheckReport;
+export declare function renderExamplesCheckText(report: IExamplesCheckReport): string;
+//# sourceMappingURL=examples-check.d.ts.map

package/dist/examples-check.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"examples-check.d.ts","sourceRoot":"","sources":["../src/examples-check.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAKH,eAAO,MAAM,qBAAqB,iCAAiC,CAAC;AAEpE,MAAM,WAAW,qBAAqB;IACpC,IAAI,EACA,sBAAsB,GACtB,8BAA8B,GAC9B,8BAA8B,GAC9B,2BAA2B,GAC3B,oBAAoB,CAAC;IACzB,QAAQ,EAAE,MAAM,GAAG,SAAS,GAAG,OAAO,CAAC;IACvC,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,oBAAoB;IACnC,MAAM,EAAE,OAAO,qBAAqB,CAAC;IACrC,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,SAAS;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,cAAc,EAAE,OAAO,CAAA;KAAE,EAAE,CAAC;IAC7E,QAAQ,EAAE,SAAS,qBAAqB,EAAE,CAAC;IAC3C,EAAE,EAAE,OAAO,CAAC;CACb;AAiCD,MAAM,WAAW,0BAA0B;IACzC,aAAa,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CACnC;AAED,wBAAgB,kBAAkB,CAChC,WAAW,EAAE,MAAM,EACnB,OAAO,GAAE,0BAA+B,GACvC,oBAAoB,CAmGtB;AAED,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,oBAAoB,GAAG,MAAM,CAgB5E"}

package/dist/examples-check.js

@@ -0,0 +1,168 @@
+/**
+ * `shrk examples check` — verify the examples/ tree is sound.
+ *
+ * Read-only. Verifies:
+ *  - examples/ exists
+ *  - each example directory has a package.json
+ *  - example commands referenced in known scripts are present in the catalog
+ *    (best-effort)
+ *  - no destructive commands in any included demo script
+ */
+import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
+import * as nodePath from 'node:path';
+export const EXAMPLES_CHECK_SCHEMA = 'sharkcraft.examples-check/v1';
+const DESTRUCTIVE_PATTERNS = [
+    /\brm\s+-rf\b/,
+    /\brm\s+-fr\b/,
+    />\s*\/dev\/null\s*2>&1\s*&&\s*rm\b/,
+    /\bdd\s+if=/,
+    /\bmkfs\b/,
+];
+function safeReaddir(dir) {
+    try {
+        return readdirSync(dir);
+    }
+    catch {
+        return [];
+    }
+}
+function listScriptFiles(dir) {
+    const out = [];
+    for (const entry of safeReaddir(dir)) {
+        const full = nodePath.join(dir, entry);
+        try {
+            const stat = statSync(full);
+            if (stat.isDirectory())
+                out.push(...listScriptFiles(full));
+            else if (entry.endsWith('.sh') || entry.endsWith('.bash'))
+                out.push(full);
+        }
+        catch {
+            /* skip */
+        }
+    }
+    return out;
+}
+export function buildExamplesCheck(projectRoot, options = {}) {
+    const findings = [];
+    const examplesDir = nodePath.join(projectRoot, 'examples');
+    const examples = [];
+    if (!existsSync(examplesDir)) {
+        findings.push({
+            code: 'examples-dir-missing',
+            severity: 'warning',
+            message: 'No examples/ directory found at the project root.',
+            suggestion: 'Create at least one example so the demo flow has a target.',
+        });
+        return {
+            schema: EXAMPLES_CHECK_SCHEMA,
+            generatedAt: new Date().toISOString(),
+            projectRoot,
+            examples: [],
+            findings,
+            ok: false,
+        };
+    }
+    for (const entry of safeReaddir(examplesDir)) {
+        const full = nodePath.join(examplesDir, entry);
+        try {
+            if (!statSync(full).isDirectory())
+                continue;
+        }
+        catch {
+            continue;
+        }
+        const pkg = nodePath.join(full, 'package.json');
+        const hasPackageJson = existsSync(pkg);
+        if (!hasPackageJson) {
+            findings.push({
+                code: 'example-missing-package-json',
+                severity: 'warning',
+                message: `examples/${entry}/ has no package.json.`,
+                file: `examples/${entry}/package.json`,
+                suggestion: 'Add a package.json so the example resolves as a workspace.',
+            });
+        }
+        examples.push({
+            name: entry,
+            path: `examples/${entry}`,
+            hasPackageJson,
+        });
+    }
+    const scriptFiles = listScriptFiles(examplesDir);
+    for (const file of scriptFiles) {
+        let body = '';
+        try {
+            body = readFileSync(file, 'utf8');
+        }
+        catch {
+            continue;
+        }
+        for (const re of DESTRUCTIVE_PATTERNS) {
+            if (re.test(body)) {
+                findings.push({
+                    code: 'destructive-command-detected',
+                    severity: 'error',
+                    message: `Destructive command pattern in ${nodePath.relative(projectRoot, file)}`,
+                    file: nodePath.relative(projectRoot, file),
+                    suggestion: 'Remove or comment out destructive lines. SharkCraft demos must be safe to run.',
+                });
+                break;
+            }
+        }
+        if (options.knownCommands && options.knownCommands.length > 0) {
+            const re = /\bshrk\s+([\w-]+(?:\s+[\w-]+)?)/g;
+            const seen = new Set();
+            let m;
+            while ((m = re.exec(body))) {
+                const cmd = `shrk ${m[1].trim()}`;
+                if (seen.has(cmd))
+                    continue;
+                seen.add(cmd);
+                let known = false;
+                for (const k of options.knownCommands) {
+                    if (k === cmd || k.startsWith(cmd) || cmd.startsWith(k)) {
+                        known = true;
+                        break;
+                    }
+                }
+                if (!known) {
+                    findings.push({
+                        code: 'unknown-command-reference',
+                        severity: 'info',
+                        message: `${nodePath.relative(projectRoot, file)} references "${cmd}" which is not in the command catalog.`,
+                        file: nodePath.relative(projectRoot, file),
+                    });
+                }
+            }
+        }
+    }
+    const ok = findings.filter((f) => f.severity === 'error').length === 0;
+    return {
+        schema: EXAMPLES_CHECK_SCHEMA,
+        generatedAt: new Date().toISOString(),
+        projectRoot,
+        examples,
+        findings,
+        ok,
+    };
+}
+export function renderExamplesCheckText(report) {
+    const lines = [];
+    lines.push('# Examples check');
+    lines.push(`OK: ${report.ok ? 'yes' : 'no'}  · examples: ${report.examples.length}`);
+    for (const e of report.examples) {
+        lines.push(`  - ${e.name}  [${e.hasPackageJson ? 'pkg' : 'no pkg'}]`);
+    }
+    if (report.findings.length === 0)
+        lines.push('No findings.');
+    else {
+        lines.push('Findings:');
+        for (const f of report.findings) {
+            lines.push(`  [${f.severity}] ${f.code}: ${f.message}`);
+            if (f.suggestion)
+                lines.push(`     → ${f.suggestion}`);
+        }
+    }
+    return lines.join('\n') + '\n';
+}

package/dist/execution-graph.d.ts

@@ -0,0 +1,98 @@
+/**
+ * Task execution graph.
+ *
+ * Combine intent, risk, memory (when present), contract, constructs,
+ * policies, boundaries, playbooks, templates, plans, gates, validations,
+ * and reports into a structured graph (nodes + edges). Pure data — no
+ * execution, no writes.
+ */
+import { type IAgentContract } from './agent-contract.js';
+import { type IMemoryRiskReport } from './repo-memory.js';
+import { type IChangeIntent } from './change-intent.js';
+import { type ITaskRiskReport } from './task-risk.js';
+import type { ISharkcraftInspection } from './sharkcraft-inspector.js';
+export declare const EXECUTION_GRAPH_SCHEMA = "sharkcraft.execution-graph/v1";
+export declare enum ExecutionNodeKind {
+    Task = "task",
+    Intent = "intent",
+    Risk = "risk",
+    Memory = "memory",
+    Contract = "contract",
+    Construct = "construct",
+    Policy = "policy",
+    Boundary = "boundary",
+    Playbook = "playbook",
+    Template = "template",
+    Plan = "plan",
+    ReviewGate = "review-gate",
+    HumanApproval = "human-approval",
+    Validation = "validation",
+    ReportArtifact = "report-artifact",
+    Done = "done"
+}
+export declare enum ExecutionEdgeKind {
+    Requires = "requires",
+    Informs = "informs",
+    Blocks = "blocks",
+    Validates = "validates",
+    Produces = "produces",
+    Reviews = "reviews",
+    Forbids = "forbids",
+    Recommends = "recommends"
+}
+export interface IExecutionNode {
+    id: string;
+    kind: ExecutionNodeKind;
+    label: string;
+    detail?: string;
+}
+export interface IExecutionEdge {
+    from: string;
+    to: string;
+    kind: ExecutionEdgeKind;
+    detail?: string;
+}
+export interface ITaskExecutionGraph {
+    schema: typeof EXECUTION_GRAPH_SCHEMA;
+    generatedAt: string;
+    task: string;
+    role: string;
+    mode: string;
+    intent: IChangeIntent;
+    taskRisk: ITaskRiskReport;
+    contract: IAgentContract;
+    memoryRisk?: IMemoryRiskReport;
+    nodes: readonly IExecutionNode[];
+    edges: readonly IExecutionEdge[];
+    notes: readonly string[];
+}
+export interface IBuildExecutionGraphOptions {
+    role?: string;
+    mode?: string;
+    files?: readonly string[];
+    since?: string;
+    staged?: boolean;
+}
+export declare function buildTaskExecutionGraph(task: string, inspection: ISharkcraftInspection, options?: IBuildExecutionGraphOptions): Promise<ITaskExecutionGraph>;
+export declare function renderExecutionGraphText(g: ITaskExecutionGraph): string;
+export declare function renderExecutionGraphMarkdown(g: ITaskExecutionGraph): string;
+export declare function renderExecutionGraphMermaid(g: ITaskExecutionGraph): string;
+export declare function renderExecutionGraphDot(g: ITaskExecutionGraph): string;
+export declare function renderExecutionGraphClusteredDot(g: ITaskExecutionGraph): string;
+export interface IExecutionGraphQueryResult {
+    schema: typeof EXECUTION_GRAPH_SCHEMA;
+    query: string;
+    matchedNodes: readonly IExecutionNode[];
+    matchedEdges: readonly IExecutionEdge[];
+    notes: readonly string[];
+}
+/**
+ * Query syntax (lowercased token before ':'):
+ *  - blocks:<nodeId>       → nodes/edges blocking the named node
+ *  - kind:<kind>           → nodes of that kind
+ *  - edge:<kind>           → edges of that kind
+ *  - text:<substring>      → nodes whose id/label/detail contains substring
+ */
+export declare function queryExecutionGraph(graph: ITaskExecutionGraph, query: string): IExecutionGraphQueryResult;
+export declare function renderExecutionGraphHtml(g: ITaskExecutionGraph): string;
+//# sourceMappingURL=execution-graph.d.ts.map

package/dist/execution-graph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"execution-graph.d.ts","sourceRoot":"","sources":["../src/execution-graph.ts"],"names":[],"mappings":"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"}