@shrkcrft/inspector 0.1.0-alpha.1

package/dist/quality-report.js

@@ -0,0 +1,296 @@
+import { evaluateBoundaries, loadTsconfigPaths, scanImports, } from '@shrkcrft/boundaries';
+import { buildAiReadinessReport } from "./ai-readiness.js";
+import { buildCoverageReport } from "./coverage-report.js";
+import { buildDriftReport } from "./drift.js";
+import { buildPackDoctorReport } from "./pack-doctor.js";
+import { runDoctor } from "./sharkcraft-inspector.js";
+import { loadAgentContractTests, loadContextTests, runAgentContractTest, runContextTest, } from "./test-runner.js";
+/**
+ * Build a quality report from an inspection. Pure orchestration over the
+ * existing inspector helpers — no IO outside what those helpers already do.
+ */
+export async function buildQualityReport(input) {
+    const { inspection, config, strict = false, skipShell = false } = input;
+    const gates = [];
+    // 1. Doctor.
+    const doctor = runDoctor(inspection);
+    gates.push({
+        id: 'doctor',
+        label: 'Project doctor',
+        passed: doctor.summary.errors === 0,
+        blocking: true,
+        runsShell: false,
+        executed: true,
+        notes: doctor.checks
+            .filter((c) => c.severity === 'error')
+            .map((c) => `${c.title}: ${c.message}`),
+        data: {
+            errors: doctor.summary.errors,
+            warnings: doctor.summary.warnings,
+            ok: doctor.summary.ok,
+        },
+    });
+    // 2. Readiness threshold.
+    const readiness = buildAiReadinessReport(inspection);
+    const readinessMin = config.minReadiness ?? 0;
+    gates.push({
+        id: 'readiness',
+        label: 'AI readiness',
+        passed: readiness.score >= readinessMin,
+        blocking: readinessMin > 0 || strict,
+        runsShell: false,
+        executed: true,
+        notes: readiness.score < readinessMin
+            ? [`Readiness ${readiness.score} below threshold ${readinessMin}`]
+            : [],
+        data: { score: readiness.score, min: readinessMin, grade: readiness.grade },
+    });
+    // 3. Boundaries. The boundary scan reads files from disk but does not run
+    // shell commands; safe for MCP.
+    const boundaries = checkBoundaries(inspection);
+    gates.push({
+        id: 'boundaries',
+        label: 'Boundary check',
+        passed: boundaries.errors === 0,
+        blocking: config.requireBoundaryClean === true || strict,
+        runsShell: false,
+        executed: true,
+        notes: boundaries.notes,
+        data: { errors: boundaries.errors, warnings: boundaries.warnings },
+    });
+    // 4. Coverage.
+    const cov = buildCoverageReport(inspection);
+    const coverageGaps = cov.categories.filter((c) => c.score < 80).length;
+    gates.push({
+        id: 'coverage',
+        label: 'Coverage report',
+        passed: coverageGaps === 0,
+        blocking: strict,
+        runsShell: false,
+        executed: true,
+        notes: coverageGaps > 0
+            ? cov.categories.filter((c) => c.score < 80).slice(0, 3).map((c) => `${c.id} at ${c.score}%`)
+            : [],
+        data: { gaps: coverageGaps, overall: cov.overall },
+    });
+    // 5. Drift gate. Pure deterministic check — no shell.
+    let drift;
+    try {
+        drift = buildDriftReport(inspection);
+        const errors = drift.counts.error;
+        const warnings = drift.counts.warning;
+        const passed = errors === 0 && (config.requireDriftClean !== true || warnings === 0);
+        gates.push({
+            id: 'drift',
+            label: 'Drift report',
+            passed,
+            blocking: config.requireDriftClean === true || strict,
+            runsShell: false,
+            executed: true,
+            notes: drift.findings
+                .filter((f) => f.severity === 'error' || (config.requireDriftClean && f.severity === 'warning'))
+                .slice(0, 5)
+                .map((f) => `${f.severity}: ${f.category} — ${f.message}`),
+            data: {
+                errors,
+                warnings,
+                info: drift.counts.info,
+                findings: drift.findings.length,
+            },
+        });
+    }
+    catch (e) {
+        gates.push({
+            id: 'drift',
+            label: 'Drift report',
+            passed: true,
+            blocking: false,
+            runsShell: false,
+            executed: false,
+            notes: [`could not run drift report: ${e.message}`],
+        });
+    }
+    // 6. Context tests. These don't run shell — they just evaluate retrieval
+    // results against expectations.
+    try {
+        const all = await loadContextTests(inspection);
+        const results = all.map((t) => runContextTest(inspection, t));
+        const failed = results.filter((r) => !r.passed).length;
+        gates.push({
+            id: 'context-tests',
+            label: 'Context tests',
+            passed: failed === 0,
+            blocking: config.requireContextTests === true || strict,
+            runsShell: false,
+            executed: true,
+            notes: failed > 0 ? [`${failed}/${results.length} context tests failed`] : [],
+            data: { total: results.length, failed },
+        });
+    }
+    catch (e) {
+        gates.push({
+            id: 'context-tests',
+            label: 'Context tests',
+            passed: true,
+            blocking: false,
+            runsShell: false,
+            executed: false,
+            notes: [`could not load context tests: ${e.message}`],
+        });
+    }
+    // 7. Agent tests. Likewise, pure orchestration.
+    try {
+        const all = await loadAgentContractTests(inspection);
+        const results = all.map((t) => runAgentContractTest(inspection, t));
+        const failed = results.filter((r) => !r.passed).length;
+        gates.push({
+            id: 'agent-tests',
+            label: 'Agent contract tests',
+            passed: failed === 0,
+            blocking: config.requireAgentTests === true || strict,
+            runsShell: false,
+            executed: true,
+            notes: failed > 0 ? [`${failed}/${results.length} agent tests failed`] : [],
+            data: { total: results.length, failed },
+        });
+    }
+    catch (e) {
+        gates.push({
+            id: 'agent-tests',
+            label: 'Agent contract tests',
+            passed: true,
+            blocking: false,
+            runsShell: false,
+            executed: false,
+            notes: [`could not load agent tests: ${e.message}`],
+        });
+    }
+    // 8. Packs doctor. Signature verification reads files but does not exec.
+    try {
+        const report = buildPackDoctorReport(inspection, {
+            requireSignatures: config.requirePackSignatures === true,
+        });
+        gates.push({
+            id: 'packs',
+            label: 'Packs doctor',
+            passed: report.passed,
+            blocking: config.requirePackSignatures === true || strict,
+            runsShell: false,
+            executed: true,
+            notes: report.issues
+                .filter((i) => i.severity === 'error')
+                .slice(0, 5)
+                .map((i) => `${i.packageName}: ${i.message}`),
+            data: {
+                errors: report.summary.errors,
+                warnings: report.summary.warnings,
+            },
+        });
+    }
+    catch (e) {
+        gates.push({
+            id: 'packs',
+            label: 'Packs doctor',
+            passed: true,
+            blocking: false,
+            runsShell: false,
+            executed: false,
+            notes: [`could not run pack doctor: ${e.message}`],
+        });
+    }
+    // If `skipShell` were true and any gate listed runsShell=true, we'd record
+    // it as skipped here. Today every gate is pure inspection — no shell. The
+    // flag is kept so MCP callers can pre-declare the intent and future gates
+    // (e.g. a real "verification commands" gate) can honour it.
+    if (skipShell) {
+        for (const g of gates) {
+            if (g.runsShell) {
+                // Force skip: don't pretend it passed; mark not executed.
+                const idx = gates.indexOf(g);
+                gates[idx] = {
+                    ...g,
+                    executed: false,
+                    notes: [...g.notes, 'skipped: MCP does not execute shell commands. Run via CLI.'],
+                    passed: false,
+                };
+            }
+        }
+    }
+    const blockers = gates.filter((g) => g.blocking && !g.passed).length;
+    const warnings = gates.filter((g) => !g.blocking && !g.passed).length;
+    const executed = gates.filter((g) => g.executed).length;
+    const passCount = gates.filter((g) => g.passed).length;
+    const score = executed > 0 ? Math.round((passCount / executed) * 100) : 100;
+    const overall = blockers > 0 ? 'fail' : warnings > 0 ? 'warn' : 'pass';
+    const nextRecommendations = buildRecommendations(gates);
+    const report = {
+        overall,
+        blockers,
+        warnings,
+        score,
+        gates,
+        nextRecommendations,
+    };
+    if (drift)
+        report.drift = drift;
+    return report;
+}
+function checkBoundaries(inspection) {
+    const rules = inspection.boundaryRegistry.list();
+    if (rules.length === 0) {
+        return { errors: 0, warnings: 0, notes: ['no boundary rules configured'] };
+    }
+    try {
+        const scan = scanImports({ projectRoot: inspection.projectRoot });
+        const tsconfigPaths = loadTsconfigPaths(inspection.projectRoot);
+        const evalResult = evaluateBoundaries(scan, rules, {
+            ...(tsconfigPaths.aliases.size > 0 ? { tsconfigPaths } : {}),
+        });
+        return {
+            errors: evalResult.counts.error,
+            warnings: evalResult.counts.warning,
+            notes: evalResult.violations
+                .slice(0, 5)
+                .map((v) => `${v.severity}: ${v.file}:${v.line} → ${v.importSpecifier}`),
+        };
+    }
+    catch (e) {
+        return { errors: 0, warnings: 0, notes: [`boundary scan failed: ${e.message}`] };
+    }
+}
+function buildRecommendations(gates) {
+    const out = [];
+    for (const g of gates) {
+        if (g.passed)
+            continue;
+        switch (g.id) {
+            case 'doctor':
+                out.push('Run `shrk doctor` and fix the errors before opening a PR.');
+                break;
+            case 'readiness':
+                out.push('Improve AI readiness — `shrk coverage` to see missing dimensions.');
+                break;
+            case 'boundaries':
+                out.push('Run `shrk check boundaries` to inspect cross-layer imports.');
+                break;
+            case 'coverage':
+                out.push('Run `shrk coverage` to see what knowledge axes are missing.');
+                break;
+            case 'drift':
+                out.push('Run `shrk drift --json` to inspect drift findings in detail.');
+                break;
+            case 'context-tests':
+                out.push('Run `shrk test context` to inspect failing retrieval contracts.');
+                break;
+            case 'agent-tests':
+                out.push('Run `shrk test agent` to inspect failing task-packet contracts.');
+                break;
+            case 'packs':
+                out.push('Run `shrk packs doctor --require-signatures` to inspect pack issues.');
+                break;
+            default:
+                break;
+        }
+    }
+    return out;
+}

package/dist/query-resolver.d.ts

@@ -0,0 +1,38 @@
+import type { ISharkcraftInspection } from './sharkcraft-inspector.js';
+export declare const QUERY_RESOLUTION_SCHEMA = "sharkcraft.query-resolution/v1";
+export declare enum QueryMatchKind {
+    File = "file",
+    Construct = "construct",
+    Knowledge = "knowledge",
+    Template = "template",
+    Helper = "helper",
+    Playbook = "playbook",
+    Policy = "policy",
+    Command = "command",
+    Symbol = "symbol",
+    PluginKey = "plugin-key",
+    EventToken = "event-token",
+    DIToken = "di-token"
+}
+export interface IQueryMatch {
+    kind: QueryMatchKind;
+    id: string;
+    label: string;
+    score: number;
+    reason: string;
+}
+export interface IQueryResolution {
+    schema: typeof QUERY_RESOLUTION_SCHEMA;
+    query: string;
+    bestMatch?: IQueryMatch;
+    alternatives: ReadonlyArray<IQueryMatch>;
+    confidence: 'exact' | 'high' | 'medium' | 'low' | 'unknown';
+}
+export interface IQueryResolveOptions {
+    /** Limit number of alternatives returned. */
+    limit?: number;
+    /** Restrict to a subset of match kinds. */
+    kinds?: ReadonlyArray<QueryMatchKind>;
+}
+export declare function resolveQuery(inspection: ISharkcraftInspection, query: string, options?: IQueryResolveOptions): IQueryResolution;
+//# sourceMappingURL=query-resolver.d.ts.map

package/dist/query-resolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"query-resolver.d.ts","sourceRoot":"","sources":["../src/query-resolver.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,2BAA2B,CAAC;AAGvE,eAAO,MAAM,uBAAuB,mCAAmC,CAAC;AAExE,oBAAY,cAAc;IACxB,IAAI,SAAS;IACb,SAAS,cAAc;IACvB,SAAS,cAAc;IACvB,QAAQ,aAAa;IACrB,MAAM,WAAW;IACjB,QAAQ,aAAa;IACrB,MAAM,WAAW;IACjB,OAAO,YAAY;IACnB,MAAM,WAAW;IACjB,SAAS,eAAe;IACxB,UAAU,gBAAgB;IAC1B,OAAO,aAAa;CACrB;AAED,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,cAAc,CAAC;IACrB,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,gBAAgB;IAC/B,MAAM,EAAE,OAAO,uBAAuB,CAAC;IACvC,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,CAAC,EAAE,WAAW,CAAC;IACxB,YAAY,EAAE,aAAa,CAAC,WAAW,CAAC,CAAC;IACzC,UAAU,EAAE,OAAO,GAAG,MAAM,GAAG,QAAQ,GAAG,KAAK,GAAG,SAAS,CAAC;CAC7D;AAED,MAAM,WAAW,oBAAoB;IACnC,6CAA6C;IAC7C,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,2CAA2C;IAC3C,KAAK,CAAC,EAAE,aAAa,CAAC,cAAc,CAAC,CAAC;CACvC;AAoID,wBAAgB,YAAY,CAC1B,UAAU,EAAE,qBAAqB,EACjC,KAAK,EAAE,MAAM,EACb,OAAO,GAAE,oBAAyB,GACjC,gBAAgB,CA8BlB"}

package/dist/query-resolver.js

@@ -0,0 +1,163 @@
+/**
+ * Query resolver for fuzzy trace / impact.
+ *
+ * Resolves a free-form query against multiple registries — files,
+ * constructs, knowledge entries, templates, helpers, playbooks,
+ * policies, commands, and best-effort symbol matches. The caller decides
+ * how to render the result; this module returns the structured match set
+ * plus a confidence rating.
+ *
+ * Schema: sharkcraft.query-resolution/v1
+ */
+import { existsSync } from 'node:fs';
+import * as nodePath from 'node:path';
+import { HELPERS } from "./helper-registry.js";
+export const QUERY_RESOLUTION_SCHEMA = 'sharkcraft.query-resolution/v1';
+export var QueryMatchKind;
+(function (QueryMatchKind) {
+    QueryMatchKind["File"] = "file";
+    QueryMatchKind["Construct"] = "construct";
+    QueryMatchKind["Knowledge"] = "knowledge";
+    QueryMatchKind["Template"] = "template";
+    QueryMatchKind["Helper"] = "helper";
+    QueryMatchKind["Playbook"] = "playbook";
+    QueryMatchKind["Policy"] = "policy";
+    QueryMatchKind["Command"] = "command";
+    QueryMatchKind["Symbol"] = "symbol";
+    QueryMatchKind["PluginKey"] = "plugin-key";
+    QueryMatchKind["EventToken"] = "event-token";
+    QueryMatchKind["DIToken"] = "di-token";
+})(QueryMatchKind || (QueryMatchKind = {}));
+function normalize(s) {
+    return s.toLowerCase().trim();
+}
+function scoreText(haystack, query) {
+    if (!haystack)
+        return 0;
+    const h = normalize(haystack);
+    const q = normalize(query);
+    if (!q)
+        return 0;
+    if (h === q)
+        return 100;
+    if (h.startsWith(q))
+        return 80;
+    if (h.endsWith(q))
+        return 70;
+    if (h.includes(q))
+        return 60;
+    // token overlap
+    const hTokens = new Set(h.split(/[^a-z0-9]+/).filter(Boolean));
+    const qTokens = q.split(/[^a-z0-9]+/).filter(Boolean);
+    let overlap = 0;
+    for (const t of qTokens)
+        if (hTokens.has(t))
+            overlap += 1;
+    if (overlap === 0)
+        return 0;
+    return Math.min(50, 10 + overlap * 10);
+}
+function fileMatches(query, projectRoot) {
+    // If `query` looks like a path AND the file exists, mark exact.
+    if (query.includes('/') || query.includes('.')) {
+        if (existsSync(nodePath.join(projectRoot, query))) {
+            return {
+                kind: QueryMatchKind.File,
+                id: query,
+                label: query,
+                score: 100,
+                reason: 'file path exists',
+            };
+        }
+    }
+    return null;
+}
+function getList(obj, fnName) {
+    const reg = obj;
+    if (typeof reg?.[fnName] === 'function') {
+        try {
+            return reg[fnName]();
+        }
+        catch {
+            return [];
+        }
+    }
+    return [];
+}
+function rankList(list, query, kind, reason = (t) => `${kind} id matched`) {
+    const out = [];
+    for (const item of list) {
+        const idScore = scoreText(item.id, query);
+        const nameScore = Math.max(scoreText(item.name ?? '', query), scoreText(item.title ?? '', query));
+        const score = Math.max(idScore, nameScore * 0.9);
+        if (score >= 10) {
+            out.push({
+                kind,
+                id: item.id,
+                label: item.name ?? item.title ?? item.id,
+                score,
+                reason: reason(item),
+            });
+        }
+    }
+    return out;
+}
+function rankConstructs(inspection, query) {
+    const reg = inspection.constructRegistry;
+    const list = getList(reg, 'list');
+    return rankList(list, query, QueryMatchKind.Construct);
+}
+function rankKnowledge(inspection, query) {
+    return rankList(inspection.knowledgeEntries.map((e) => ({ id: e.id, title: e.title })), query, QueryMatchKind.Knowledge);
+}
+function rankTemplates(inspection, query) {
+    return rankList(inspection.templates.map((t) => ({ id: t.id, name: t.name })), query, QueryMatchKind.Template);
+}
+function rankHelpers(query) {
+    return rankList(HELPERS, query, QueryMatchKind.Helper);
+}
+function rankPlaybooks(inspection, query) {
+    const reg = inspection.playbookRegistry;
+    const list = getList(reg, 'list');
+    return rankList(list, query, QueryMatchKind.Playbook);
+}
+function rankPolicies(inspection, query) {
+    const checks = inspection.policyChecks ?? [];
+    return rankList(checks, query, QueryMatchKind.Policy);
+}
+function rankCommands(inspection, query) {
+    const cat = inspection.commandCatalog ?? [];
+    return rankList(cat, query, QueryMatchKind.Command);
+}
+function pickConfidence(top) {
+    if (!top)
+        return 'unknown';
+    if (top.score >= 95)
+        return 'exact';
+    if (top.score >= 70)
+        return 'high';
+    if (top.score >= 40)
+        return 'medium';
+    return 'low';
+}
+export function resolveQuery(inspection, query, options = {}) {
+    const matches = [];
+    // 1) file path → exact match wins.
+    const file = fileMatches(query, inspection.projectRoot);
+    if (file)
+        matches.push(file);
+    matches.push(...rankConstructs(inspection, query), ...rankKnowledge(inspection, query), ...rankTemplates(inspection, query), ...rankHelpers(query), ...rankPlaybooks(inspection, query), ...rankPolicies(inspection, query), ...rankCommands(inspection, query));
+    const filtered = options.kinds && options.kinds.length > 0
+        ? matches.filter((m) => options.kinds.includes(m.kind))
+        : matches;
+    filtered.sort((a, b) => b.score - a.score);
+    const limit = options.limit ?? 10;
+    const top = filtered[0];
+    return {
+        schema: QUERY_RESOLUTION_SCHEMA,
+        query,
+        ...(top ? { bestMatch: top } : {}),
+        alternatives: filtered.slice(1, limit + 1),
+        confidence: pickConfidence(top),
+    };
+}

package/dist/ranker-explainability.d.ts

@@ -0,0 +1,91 @@
+import type { ISharkcraftInspection } from './sharkcraft-inspector.js';
+export declare const RANKER_EXPLAINABILITY_SCHEMA = "sharkcraft.ranker-explainability/v1";
+export declare enum RankerExplainKind {
+    Knowledge = "knowledge",
+    Template = "template",
+    Rule = "rule",
+    Helper = "helper",
+    Playbook = "playbook",
+    Construct = "construct",
+    Policy = "policy",
+    Command = "command",
+    Path = "path",
+    Preset = "preset",
+    Pipeline = "pipeline"
+}
+export interface IRankerExplainRequest {
+    /** Target id to explain. Required. */
+    id: string;
+    /** Either a task or a query — at least one. */
+    task?: string;
+    query?: string;
+    /** Optional kind hint. */
+    kind?: RankerExplainKind;
+}
+export interface IRankerOutrankedBy {
+    id: string;
+    kind: string;
+    score: number;
+    /** First few reasons surfaced by the ranker. */
+    reasons: readonly string[];
+}
+export interface IRankerExplainNearestId {
+    id: string;
+    kind: string;
+    /** Edit-distance / similarity. Lower is closer. */
+    distance: number;
+}
+export interface IRankerExplainSignal {
+    signal: string;
+    matched: boolean;
+    detail?: string;
+}
+export interface IRankerExplainTuningTrace {
+    tuningId: string;
+    reasons: readonly string[];
+    delta: number;
+}
+export interface IRankerExplainReport {
+    schema: typeof RANKER_EXPLAINABILITY_SCHEMA;
+    generatedAt: string;
+    request: IRankerExplainRequest;
+    /** Whether the id was found in any registry. */
+    found: boolean;
+    /** Detected registry/kind when found. */
+    resolvedKind?: string;
+    /** Whether the entry was included in the rendered top-N when ranking for the given task. */
+    included: boolean;
+    /** Position in the top-N (1-based) when included; undefined otherwise. */
+    rank?: number;
+    /** Final score (post-tuning where applicable). */
+    score?: number;
+    /** Threshold the entry would have to clear to make the top-N for this task. */
+    threshold?: number;
+    /** Signals that matched (e.g. token hits, domain tags, appliesWhen, …). */
+    matchedSignals: readonly IRankerExplainSignal[];
+    /** Signals that did NOT match (i.e. what the entry is missing to rank higher). */
+    missingSignals: readonly IRankerExplainSignal[];
+    /** Items that outranked the target for this task. */
+    outrankedBy: readonly IRankerOutrankedBy[];
+    /** Tuning trace (which tuning entries touched this id and by how much). */
+    tuningTrace: readonly IRankerExplainTuningTrace[];
+    /** Suggested metadata fixes — concrete editorial guidance. */
+    suggestedMetadataFixes: readonly string[];
+    /** Suggested follow-up commands. */
+    suggestedCommands: readonly string[];
+    /** Nearest ids (used when the target id is missing entirely). */
+    nearestIds: readonly IRankerExplainNearestId[];
+    /** Free-form diagnostics. */
+    diagnostics: readonly string[];
+}
+export interface IExplainRankerOptions {
+    /** If true, return why-not behaviour. */
+    whyNot?: boolean;
+    /** Top-N considered for ranking. Default 10. */
+    topN?: number;
+}
+export declare function explainRankerDecision(inspection: ISharkcraftInspection, request: IRankerExplainRequest, options?: IExplainRankerOptions): IRankerExplainReport;
+export declare function renderRankerExplainText(report: IRankerExplainReport, whyNot: boolean): string;
+export declare function renderRankerExplainMarkdown(report: IRankerExplainReport, whyNot: boolean): string;
+export declare function renderRankerExplainHtml(report: IRankerExplainReport, whyNot: boolean): string;
+//# sourceMappingURL=ranker-explainability.d.ts.map

package/dist/ranker-explainability.d.ts.map

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