@shrkcrft/inspector 0.1.0-alpha.2

package/dist/knowledge-lint.js

@@ -0,0 +1,302 @@
+/**
+ * Knowledge lint + fix-preview.
+ *
+ * Pure inspector — classifies findings on the current knowledge entries.
+ * Never fills meaningful prose with fake content. Stub candidates use
+ * explicit TODO markers so a human / agent must finish the wording.
+ *
+ * Output schemas:
+ *   - sharkcraft.knowledge-lint/v1
+ *   - sharkcraft.knowledge-lint-fix-preview/v1
+ */
+export const KNOWLEDGE_LINT_SCHEMA = 'sharkcraft.knowledge-lint/v1';
+export const KNOWLEDGE_LINT_FIX_PREVIEW_SCHEMA = 'sharkcraft.knowledge-lint-fix-preview/v1';
+export var KnowledgeLintCategory;
+(function (KnowledgeLintCategory) {
+    KnowledgeLintCategory["SafeMechanicalStub"] = "safe-mechanical-stub";
+    KnowledgeLintCategory["NeedsHumanWording"] = "needs-human-wording";
+    KnowledgeLintCategory["ShouldAcknowledge"] = "should-acknowledge";
+    KnowledgeLintCategory["ObsoleteEntry"] = "obsolete-entry";
+    KnowledgeLintCategory["StaleReference"] = "stale-reference";
+    KnowledgeLintCategory["MissingProvenance"] = "missing-provenance";
+    KnowledgeLintCategory["MissingActionHints"] = "missing-action-hints";
+})(KnowledgeLintCategory || (KnowledgeLintCategory = {}));
+export var KnowledgeLintSeverity;
+(function (KnowledgeLintSeverity) {
+    KnowledgeLintSeverity["Info"] = "info";
+    KnowledgeLintSeverity["Warning"] = "warning";
+})(KnowledgeLintSeverity || (KnowledgeLintSeverity = {}));
+export function lintKnowledge(entries, options = {}) {
+    const findings = [];
+    const includeAdvisory = options.includeAdvisory ?? true;
+    const stale = new Set(options.staleReferenceEntryIds ?? []);
+    const entryFilter = options.entryIds && options.entryIds.length > 0 ? new Set(options.entryIds) : null;
+    for (const e of entries) {
+        if (entryFilter && !entryFilter.has(e.id))
+            continue;
+        // 1) Summary is missing — safe mechanical stub.
+        if (!e.summary || e.summary.trim().length === 0) {
+            findings.push({
+                code: 'knowledge.summary-missing',
+                category: KnowledgeLintCategory.SafeMechanicalStub,
+                severity: KnowledgeLintSeverity.Info,
+                entryId: e.id,
+                field: 'summary',
+                message: `Entry "${e.id}" has no summary.`,
+                stubSuggestion: stubSummaryFor(e),
+            });
+        }
+        else if (e.summary.length > 320) {
+            findings.push({
+                code: 'knowledge.summary-too-long',
+                category: KnowledgeLintCategory.NeedsHumanWording,
+                severity: KnowledgeLintSeverity.Info,
+                entryId: e.id,
+                field: 'summary',
+                message: `Summary is ${e.summary.length} chars (> 320). Consider tightening the wording.`,
+            });
+        }
+        // 2) Tags missing — safe mechanical stub.
+        if (!e.tags || e.tags.length === 0) {
+            findings.push({
+                code: 'knowledge.tags-missing',
+                category: KnowledgeLintCategory.SafeMechanicalStub,
+                severity: KnowledgeLintSeverity.Info,
+                entryId: e.id,
+                field: 'tags',
+                message: `Entry "${e.id}" has no tags.`,
+                stubSuggestion: stubTagsFor(e).join(','),
+            });
+        }
+        // 3) Content is a stub.
+        const trimmed = (e.content ?? '').trim();
+        if (trimmed.length === 0 || trimmed.startsWith('TODO') || trimmed === '...') {
+            findings.push({
+                code: 'knowledge.content-stub',
+                category: KnowledgeLintCategory.NeedsHumanWording,
+                severity: KnowledgeLintSeverity.Warning,
+                entryId: e.id,
+                field: 'content',
+                message: `Entry "${e.id}" has placeholder content. Human wording required.`,
+            });
+        }
+        else if (trimmed.length < 60) {
+            findings.push({
+                code: 'knowledge.content-too-short',
+                category: KnowledgeLintCategory.NeedsHumanWording,
+                severity: KnowledgeLintSeverity.Info,
+                entryId: e.id,
+                field: 'content',
+                message: `Entry "${e.id}" has a very short content body (${trimmed.length} chars).`,
+            });
+        }
+        // 4) Stale references — surfaced from external input.
+        if (stale.has(e.id)) {
+            findings.push({
+                code: 'knowledge.stale-reference',
+                category: KnowledgeLintCategory.StaleReference,
+                severity: KnowledgeLintSeverity.Warning,
+                entryId: e.id,
+                field: 'references',
+                message: `Entry "${e.id}" has stale or missing references. Run \`shrk knowledge stale-check\` for details.`,
+            });
+        }
+        // 5) Deprecated marker present.
+        const md = (e.metadata ?? {});
+        if (md.deprecated) {
+            findings.push({
+                code: 'knowledge.obsolete-entry',
+                category: KnowledgeLintCategory.ObsoleteEntry,
+                severity: KnowledgeLintSeverity.Info,
+                entryId: e.id,
+                field: 'metadata.deprecated',
+                message: `Entry "${e.id}" is marked deprecated. Consider removing or migrating its references.`,
+            });
+        }
+        // 6) Missing provenance — advisory.
+        if (includeAdvisory) {
+            const authoring = md.authoring ?? undefined;
+            const source = e.source;
+            if (!authoring && !source) {
+                findings.push({
+                    code: 'knowledge.missing-provenance',
+                    category: KnowledgeLintCategory.MissingProvenance,
+                    severity: KnowledgeLintSeverity.Info,
+                    entryId: e.id,
+                    field: 'metadata.authoring',
+                    message: `Entry "${e.id}" has no provenance metadata. Consider recording who/why on the next update.`,
+                    advisory: true,
+                });
+            }
+        }
+        // 7) Missing action hints — advisory for high-priority entries.
+        if (includeAdvisory && (e.priority === 'critical' || e.priority === 'high')) {
+            if (!e.actionHints) {
+                findings.push({
+                    code: 'knowledge.missing-action-hints',
+                    category: KnowledgeLintCategory.MissingActionHints,
+                    severity: KnowledgeLintSeverity.Info,
+                    entryId: e.id,
+                    field: 'actionHints',
+                    message: `High-priority entry "${e.id}" has no actionHints. Consider adding mcpTools / commands.`,
+                    advisory: true,
+                });
+            }
+        }
+        // 8) appliesWhen missing — should-acknowledge if intentional.
+        if (!e.appliesWhen || e.appliesWhen.length === 0) {
+            findings.push({
+                code: 'knowledge.appliesWhen-missing',
+                category: KnowledgeLintCategory.ShouldAcknowledge,
+                severity: KnowledgeLintSeverity.Info,
+                entryId: e.id,
+                field: 'appliesWhen',
+                message: `Entry "${e.id}" has no appliesWhen markers. If this is intentional (e.g. background reading) consider documenting it.`,
+            });
+        }
+    }
+    const counts = {
+        [KnowledgeLintCategory.SafeMechanicalStub]: 0,
+        [KnowledgeLintCategory.NeedsHumanWording]: 0,
+        [KnowledgeLintCategory.ShouldAcknowledge]: 0,
+        [KnowledgeLintCategory.ObsoleteEntry]: 0,
+        [KnowledgeLintCategory.StaleReference]: 0,
+        [KnowledgeLintCategory.MissingProvenance]: 0,
+        [KnowledgeLintCategory.MissingActionHints]: 0,
+    };
+    for (const f of findings)
+        counts[f.category]++;
+    return {
+        schema: KNOWLEDGE_LINT_SCHEMA,
+        generatedAt: new Date().toISOString(),
+        entries: entries.length,
+        findings,
+        counts,
+    };
+}
+export function buildKnowledgeLintFixPreview(report) {
+    const safeStubs = report.findings
+        .filter((f) => f.category === KnowledgeLintCategory.SafeMechanicalStub && f.stubSuggestion)
+        .map((f) => ({
+        entryId: f.entryId,
+        code: f.code,
+        field: f.field,
+        suggestion: f.stubSuggestion,
+    }));
+    const todos = report.findings
+        .filter((f) => f.category === KnowledgeLintCategory.NeedsHumanWording ||
+        f.category === KnowledgeLintCategory.StaleReference ||
+        f.category === KnowledgeLintCategory.ObsoleteEntry)
+        .map((f) => ({
+        entryId: f.entryId,
+        code: f.code,
+        field: f.field,
+        description: f.message,
+    }));
+    const acknowledgements = report.findings
+        .filter((f) => f.category === KnowledgeLintCategory.ShouldAcknowledge ||
+        f.category === KnowledgeLintCategory.MissingProvenance ||
+        f.category === KnowledgeLintCategory.MissingActionHints)
+        .map((f) => ({
+        entryId: f.entryId,
+        code: f.code,
+        field: f.field,
+        description: f.message,
+    }));
+    return {
+        schema: KNOWLEDGE_LINT_FIX_PREVIEW_SCHEMA,
+        generatedAt: new Date().toISOString(),
+        safeStubs,
+        todos,
+        acknowledgements,
+        basedOn: KNOWLEDGE_LINT_SCHEMA,
+        files: [
+            { path: '.sharkcraft/fixes/knowledge-lint.preview.md', purpose: 'markdown-summary', language: 'markdown' },
+            { path: '.sharkcraft/fixes/knowledge-lint.todos.json', purpose: 'todos-json', language: 'json' },
+            { path: '.sharkcraft/fixes/knowledge-lint.patch', purpose: 'patch', language: 'typescript' },
+        ],
+        nextCommands: [
+            'shrk knowledge lint --json',
+            'shrk knowledge stale-check --ci',
+            'shrk self-config doctor',
+        ],
+    };
+}
+export function renderKnowledgeLintMarkdown(report) {
+    const lines = [];
+    lines.push('# Knowledge lint');
+    lines.push('');
+    lines.push(`Entries scanned: ${report.entries}`);
+    lines.push(`Findings: ${report.findings.length}`);
+    lines.push('');
+    lines.push('## Counts');
+    lines.push('');
+    for (const [cat, n] of Object.entries(report.counts)) {
+        if (n > 0)
+            lines.push(`- ${cat}: ${n}`);
+    }
+    lines.push('');
+    if (report.findings.length > 0) {
+        lines.push('## Findings');
+        lines.push('');
+        for (const f of report.findings) {
+            lines.push(`- **${f.severity.toUpperCase()}** \`${f.code}\` ${f.entryId} → ${f.field}${f.advisory ? ' _(advisory)_' : ''}`);
+            lines.push(`  - ${f.message}`);
+            if (f.stubSuggestion)
+                lines.push(`  - stub: \`${f.stubSuggestion}\``);
+        }
+        lines.push('');
+    }
+    return lines.join('\n');
+}
+export function renderKnowledgeLintFixPreviewMarkdown(preview) {
+    const lines = [];
+    lines.push('# Knowledge lint — fix preview');
+    lines.push('');
+    lines.push(`Safe mechanical stubs: ${preview.safeStubs.length}`);
+    lines.push(`Items needing human wording: ${preview.todos.length}`);
+    lines.push(`Items to acknowledge: ${preview.acknowledgements.length}`);
+    lines.push('');
+    lines.push('## Safe mechanical stubs');
+    lines.push('');
+    if (preview.safeStubs.length === 0)
+        lines.push('_(none)_');
+    for (const s of preview.safeStubs) {
+        lines.push(`- \`${s.entryId}\` → \`${s.field}\`: \`${s.suggestion}\``);
+    }
+    lines.push('');
+    lines.push('## TODOs (human wording required)');
+    lines.push('');
+    if (preview.todos.length === 0)
+        lines.push('_(none)_');
+    for (const t of preview.todos) {
+        lines.push(`- [ ] \`${t.entryId}\` → \`${t.field}\` — ${t.description}`);
+    }
+    lines.push('');
+    lines.push('## Acknowledgements (intentional, advisory)');
+    lines.push('');
+    if (preview.acknowledgements.length === 0)
+        lines.push('_(none)_');
+    for (const a of preview.acknowledgements) {
+        lines.push(`- \`${a.entryId}\` → \`${a.field}\` — ${a.description}`);
+    }
+    lines.push('');
+    lines.push('## Next commands');
+    lines.push('');
+    for (const c of preview.nextCommands)
+        lines.push(`- \`${c}\``);
+    lines.push('');
+    return lines.join('\n');
+}
+function stubSummaryFor(e) {
+    return `TODO(summary): one-line summary of "${e.title || e.id}".`;
+}
+function stubTagsFor(e) {
+    const out = new Set();
+    const idTokens = e.id.split(/[.\-]/g).filter((t) => t.length > 1);
+    for (const t of idTokens.slice(0, 3))
+        out.add(t);
+    if (e.type)
+        out.add(String(e.type));
+    return [...out];
+}

package/dist/knowledge-rename.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Preview only. Source-side rename remains out of scope (would need
+ * an AST pass). Existing `sharkcraft/knowledge-updates/` patch files
+ * on disk are left alone (users may have generated them
+ * deliberately).
+ *
+ * Schema: sharkcraft.knowledge-rename/v2.
+ */
+import type { IKnowledgeAnchor, IKnowledgeReference } from '@shrkcrft/knowledge';
+import type { ISharkcraftInspection } from './sharkcraft-inspector.js';
+export declare const KNOWLEDGE_RENAME_SCHEMA = "sharkcraft.knowledge-rename/v2";
+export interface IKnowledgeRenameMatch {
+    entryId: string;
+    field: 'reference' | 'anchor';
+    before: IKnowledgeReference | IKnowledgeAnchor;
+    after: IKnowledgeReference | IKnowledgeAnchor;
+}
+export interface IKnowledgeRenamePlan {
+    schema: typeof KNOWLEDGE_RENAME_SCHEMA;
+    kind: 'rename-symbol' | 'rename-file' | 'update-anchor';
+    from: string;
+    to: string;
+    matches: ReadonlyArray<IKnowledgeRenameMatch>;
+}
+export interface IKnowledgeRenameOptions {
+    from: string;
+    to: string;
+}
+export declare function buildRenameSymbolPlan(inspection: ISharkcraftInspection, opts: IKnowledgeRenameOptions): IKnowledgeRenamePlan;
+export declare function buildRenameFilePlan(inspection: ISharkcraftInspection, opts: IKnowledgeRenameOptions): IKnowledgeRenamePlan;
+export interface IAnchorUpdateOptions {
+    anchorId: string;
+    toSymbol?: string;
+    toPath?: string;
+    toTargetId?: string;
+}
+export declare function buildAnchorUpdatePlan(inspection: ISharkcraftInspection, opts: IAnchorUpdateOptions): IKnowledgeRenamePlan;
+//# sourceMappingURL=knowledge-rename.d.ts.map

package/dist/knowledge-rename.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"knowledge-rename.d.ts","sourceRoot":"","sources":["../src/knowledge-rename.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EACV,gBAAgB,EAEhB,mBAAmB,EACpB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,2BAA2B,CAAC;AAEvE,eAAO,MAAM,uBAAuB,mCAAmC,CAAC;AAExE,MAAM,WAAW,qBAAqB;IACpC,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,WAAW,GAAG,QAAQ,CAAC;IAC9B,MAAM,EAAE,mBAAmB,GAAG,gBAAgB,CAAC;IAC/C,KAAK,EAAE,mBAAmB,GAAG,gBAAgB,CAAC;CAC/C;AAED,MAAM,WAAW,oBAAoB;IACnC,MAAM,EAAE,OAAO,uBAAuB,CAAC;IACvC,IAAI,EAAE,eAAe,GAAG,aAAa,GAAG,eAAe,CAAC;IACxD,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,EAAE,aAAa,CAAC,qBAAqB,CAAC,CAAC;CAC/C;AAED,MAAM,WAAW,uBAAuB;IACtC,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;CACZ;AAMD,wBAAgB,qBAAqB,CACnC,UAAU,EAAE,qBAAqB,EACjC,IAAI,EAAE,uBAAuB,GAC5B,oBAAoB,CAyBtB;AAED,wBAAgB,mBAAmB,CACjC,UAAU,EAAE,qBAAqB,EACjC,IAAI,EAAE,uBAAuB,GAC5B,oBAAoB,CAyBtB;AAED,MAAM,WAAW,oBAAoB;IACnC,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,wBAAgB,qBAAqB,CACnC,UAAU,EAAE,qBAAqB,EACjC,IAAI,EAAE,oBAAoB,GACzB,oBAAoB,CAmBtB"}

package/dist/knowledge-rename.js

@@ -0,0 +1,88 @@
+/**
+ * Preview only. Source-side rename remains out of scope (would need
+ * an AST pass). Existing `sharkcraft/knowledge-updates/` patch files
+ * on disk are left alone (users may have generated them
+ * deliberately).
+ *
+ * Schema: sharkcraft.knowledge-rename/v2.
+ */
+export const KNOWLEDGE_RENAME_SCHEMA = 'sharkcraft.knowledge-rename/v2';
+function clone(v) {
+    return JSON.parse(JSON.stringify(v));
+}
+export function buildRenameSymbolPlan(inspection, opts) {
+    const matches = [];
+    for (const entry of inspection.knowledgeEntries) {
+        for (const ref of entry.references ?? []) {
+            if (ref.kind === 'symbol' && ref.symbol === opts.from) {
+                const after = clone(ref);
+                after.symbol = opts.to;
+                matches.push({ entryId: entry.id, field: 'reference', before: ref, after });
+            }
+        }
+        for (const anchor of entry.anchors ?? []) {
+            if (anchor.kind === 'symbol' && anchor.symbol === opts.from) {
+                const after = clone(anchor);
+                after.symbol = opts.to;
+                matches.push({ entryId: entry.id, field: 'anchor', before: anchor, after });
+            }
+        }
+    }
+    return {
+        schema: KNOWLEDGE_RENAME_SCHEMA,
+        kind: 'rename-symbol',
+        from: opts.from,
+        to: opts.to,
+        matches,
+    };
+}
+export function buildRenameFilePlan(inspection, opts) {
+    const matches = [];
+    for (const entry of inspection.knowledgeEntries) {
+        for (const ref of entry.references ?? []) {
+            if (ref.path === opts.from) {
+                const after = clone(ref);
+                after.path = opts.to;
+                matches.push({ entryId: entry.id, field: 'reference', before: ref, after });
+            }
+        }
+        for (const anchor of entry.anchors ?? []) {
+            if (anchor.path === opts.from) {
+                const after = clone(anchor);
+                after.path = opts.to;
+                matches.push({ entryId: entry.id, field: 'anchor', before: anchor, after });
+            }
+        }
+    }
+    return {
+        schema: KNOWLEDGE_RENAME_SCHEMA,
+        kind: 'rename-file',
+        from: opts.from,
+        to: opts.to,
+        matches,
+    };
+}
+export function buildAnchorUpdatePlan(inspection, opts) {
+    const matches = [];
+    for (const entry of inspection.knowledgeEntries) {
+        for (const anchor of entry.anchors ?? []) {
+            if (anchor.id !== opts.anchorId)
+                continue;
+            const after = clone(anchor);
+            if (opts.toSymbol !== undefined)
+                after.symbol = opts.toSymbol;
+            if (opts.toPath !== undefined)
+                after.path = opts.toPath;
+            if (opts.toTargetId !== undefined)
+                after.targetId = opts.toTargetId;
+            matches.push({ entryId: entry.id, field: 'anchor', before: anchor, after });
+        }
+    }
+    return {
+        schema: KNOWLEDGE_RENAME_SCHEMA,
+        kind: 'update-anchor',
+        from: opts.anchorId,
+        to: opts.toSymbol ?? opts.toPath ?? opts.toTargetId ?? '?',
+        matches,
+    };
+}

package/dist/knowledge-stale.d.ts

@@ -0,0 +1,124 @@
+/**
+ * Knowledge stale-check.
+ *
+ * Walks every knowledge entry's `references[]` + `anchors[]` and checks
+ * whether each target still resolves against the current workspace.
+ *
+ * Pure file-system + registry lookups — no network, no AST compilation.
+ * Symbol checks are deterministic best-effort text scans so the doctor
+ * stays cheap.
+ *
+ * Schema: sharkcraft.knowledge-stale/v1
+ */
+import type { IKnowledgeAnchor, IKnowledgeReference } from '@shrkcrft/knowledge';
+import type { ISharkcraftInspection } from './sharkcraft-inspector.js';
+export declare const KNOWLEDGE_STALE_SCHEMA = "sharkcraft.knowledge-stale/v1";
+export declare enum ReferenceCheckOutcome {
+    Ok = "ok",
+    Stale = "stale",
+    Missing = "missing",
+    Unknown = "unknown"
+}
+export declare enum SymbolConfidence {
+    Exact = "exact",
+    Probable = "probable",
+    Missing = "missing",
+    Unknown = "unknown"
+}
+/**
+ * Rename detection strategy.
+ *
+ * - `strict` (default): emit `replaceWith.path` only when there is
+ *   exactly one unambiguous candidate.
+ * - `wide`: also surface multiple candidates above a confidence
+ *   threshold. When one candidate is meaningfully ahead of the second,
+ *   it still auto-applies; otherwise the candidate list is returned
+ *   without `path` so the user can disambiguate manually.
+ */
+export declare enum RenameStrategy {
+    Strict = "strict",
+    Wide = "wide"
+}
+/**
+ * One scored candidate in a wide-strategy replacement.
+ *
+ * `score` is 0..1; higher is better. `rationale` is a one-line
+ * human-readable explanation suitable for the preview output.
+ */
+export interface IReplacementCandidate {
+    path?: string;
+    symbol?: string;
+    id?: string;
+    score: number;
+    rationale: string;
+}
+/**
+ * Structured replacement signal.
+ *
+ * When the engine can identify the new location of a moved symbol /
+ * renamed file with high confidence, it emits a structured payload the
+ * apply path can act on without parsing the free-form `suggestion`
+ * text. Strict mode emits `path` (or `id` / `symbol`) only when the
+ * resolution is unambiguous (exactly one candidate match across the
+ * source tree). Wide mode additionally surfaces `candidates[]` for the
+ * ambiguous cases the user previously got nothing for.
+ */
+export interface IReferenceReplacement {
+    /** New path for symbol or file/directory references that moved. */
+    path?: string;
+    /** New id for id-keyed references. */
+    id?: string;
+    /** New symbol for renamed symbols. */
+    symbol?: string;
+    /** One-line "why this is the right replacement" for human review. */
+    rationale: string;
+    /** Under wide strategy, full ranked candidate list. */
+    candidates?: readonly IReplacementCandidate[];
+    /** Strategy that produced this replacement. */
+    strategy?: RenameStrategy;
+}
+export interface IKnowledgeReferenceCheck {
+    entryId: string;
+    reference: IKnowledgeReference;
+    outcome: ReferenceCheckOutcome;
+    /** Confidence for symbol references; undefined for other kinds. */
+    symbolConfidence?: SymbolConfidence;
+    message: string;
+    suggestion?: string;
+    /** Structured replacement when the engine can identify the new location. */
+    replaceWith?: IReferenceReplacement;
+}
+export interface IKnowledgeAnchorCheck {
+    entryId: string;
+    anchor: IKnowledgeAnchor;
+    outcome: ReferenceCheckOutcome;
+    message: string;
+}
+export interface IKnowledgeStaleReport {
+    schema: typeof KNOWLEDGE_STALE_SCHEMA;
+    entries: number;
+    totalReferences: number;
+    totalAnchors: number;
+    counts: {
+        ok: number;
+        stale: number;
+        missing: number;
+        unknown: number;
+    };
+    referenceChecks: ReadonlyArray<IKnowledgeReferenceCheck>;
+    anchorChecks: ReadonlyArray<IKnowledgeAnchorCheck>;
+}
+export interface IKnowledgeStaleCheckOptions {
+    /** When provided, only entries referencing one of these files are checked. */
+    changedFiles?: ReadonlyArray<string>;
+    /**
+     * Rename detection strategy. Default `strict`: only emit a candidate
+     * when one is unambiguous. `wide` surfaces multi-candidate matches
+     * that strict silently drops, and applies a path-overlap score so
+     * the apply path can still auto-select when one candidate clearly
+     * leads.
+     */
+    renameStrategy?: RenameStrategy;
+}
+export declare function buildKnowledgeStaleReport(inspection: ISharkcraftInspection, options?: IKnowledgeStaleCheckOptions): IKnowledgeStaleReport;
+//# sourceMappingURL=knowledge-stale.d.ts.map

package/dist/knowledge-stale.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"knowledge-stale.d.ts","sourceRoot":"","sources":["../src/knowledge-stale.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAIH,OAAO,KAAK,EACV,gBAAgB,EAEhB,mBAAmB,EAEpB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,2BAA2B,CAAC;AAIvE,eAAO,MAAM,sBAAsB,kCAAkC,CAAC;AAEtE,oBAAY,qBAAqB;IAC/B,EAAE,OAAO;IACT,KAAK,UAAU;IACf,OAAO,YAAY;IACnB,OAAO,YAAY;CACpB;AAED,oBAAY,gBAAgB;IAC1B,KAAK,UAAU;IACf,QAAQ,aAAa;IACrB,OAAO,YAAY;IACnB,OAAO,YAAY;CACpB;AAED;;;;;;;;;GASG;AACH,oBAAY,cAAc;IACxB,MAAM,WAAW;IACjB,IAAI,SAAS;CACd;AAED;;;;;GAKG;AACH,MAAM,WAAW,qBAAqB;IACpC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;;;;;;;;;GAUG;AACH,MAAM,WAAW,qBAAqB;IACpC,mEAAmE;IACnE,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,sCAAsC;IACtC,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,sCAAsC;IACtC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,qEAAqE;IACrE,SAAS,EAAE,MAAM,CAAC;IAClB,uDAAuD;IACvD,UAAU,CAAC,EAAE,SAAS,qBAAqB,EAAE,CAAC;IAC9C,+CAA+C;IAC/C,QAAQ,CAAC,EAAE,cAAc,CAAC;CAC3B;AAED,MAAM,WAAW,wBAAwB;IACvC,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,mBAAmB,CAAC;IAC/B,OAAO,EAAE,qBAAqB,CAAC;IAC/B,mEAAmE;IACnE,gBAAgB,CAAC,EAAE,gBAAgB,CAAC;IACpC,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,4EAA4E;IAC5E,WAAW,CAAC,EAAE,qBAAqB,CAAC;CACrC;AAED,MAAM,WAAW,qBAAqB;IACpC,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,gBAAgB,CAAC;IACzB,OAAO,EAAE,qBAAqB,CAAC;IAC/B,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,qBAAqB;IACpC,MAAM,EAAE,OAAO,sBAAsB,CAAC;IACtC,OAAO,EAAE,MAAM,CAAC;IAChB,eAAe,EAAE,MAAM,CAAC;IACxB,YAAY,EAAE,MAAM,CAAC;IACrB,MAAM,EAAE;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC;IACxE,eAAe,EAAE,aAAa,CAAC,wBAAwB,CAAC,CAAC;IACzD,YAAY,EAAE,aAAa,CAAC,qBAAqB,CAAC,CAAC;CACpD;AAED,MAAM,WAAW,2BAA2B;IAC1C,8EAA8E;IAC9E,YAAY,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IACrC;;;;;;OAMG;IACH,cAAc,CAAC,EAAE,cAAc,CAAC;CACjC;AAwWD,wBAAgB,yBAAyB,CACvC,UAAU,EAAE,qBAAqB,EACjC,OAAO,GAAE,2BAAgC,GACxC,qBAAqB,CAgJvB"}