@shrkcrft/inspector 0.1.0-alpha.1

package/dist/task-ranker.js

@@ -0,0 +1,410 @@
+// ── Verb hints (what kind of work) ──────────────────────────────────────
+const VERB_HINTS = [
+    {
+        regex: /\b(create|add|implement|generate|new|build|introduce|provide)\b/,
+        appliesWhen: ['generate-code', 'generate-service', 'generate-utility', 'generate-template'],
+        tags: ['feature', 'generation'],
+    },
+    {
+        regex: /\b(refactor|rewrite|migrate|extract|rename)\b/,
+        appliesWhen: ['refactor'],
+        tags: ['refactor', 'safe', 'generation'],
+    },
+    {
+        regex: /\b(test|spec|coverage)\b/,
+        appliesWhen: ['generate-test'],
+        tags: ['test', 'testing'],
+    },
+    {
+        regex: /\b(fix|bug|broken|crash)\b/,
+        appliesWhen: ['fix-bug'],
+        tags: ['safety'],
+    },
+    {
+        regex: /\b(review|audit|inspect)\b/,
+        appliesWhen: ['review-pr', 'check-boundaries'],
+        tags: ['review'],
+    },
+];
+// ── Domain hints (what *kind of thing* is being worked on) ──────────────
+// These boost rules/templates/pipelines whose own `appliesWhen` or `tags`
+// declare the same domain — much higher signal than verb hints alone for
+// "create a user profile *plugin*" vs "add pagination *capability*".
+const DOMAIN_HINTS = [
+    {
+        token: 'plugin',
+        appliesWhen: ['create-plugin', 'generate-plugin', 'plugin-dev', 'register-plugin'],
+        tags: ['plugin'],
+    },
+    {
+        token: 'defaults',
+        appliesWhen: ['register-defaults', 'create-defaults', 'plugin-defaults'],
+        tags: ['defaults'],
+    },
+    {
+        token: 'capability',
+        appliesWhen: ['create-capability', 'generate-capability'],
+        tags: ['capability'],
+    },
+    {
+        token: 'policy',
+        appliesWhen: ['create-policy', 'generate-policy'],
+        tags: ['policy'],
+    },
+    {
+        token: 'adapter',
+        appliesWhen: ['create-adapter', 'generate-adapter'],
+        tags: ['adapter'],
+    },
+    {
+        token: 'service',
+        appliesWhen: ['generate-service'],
+        tags: ['service'],
+    },
+    {
+        token: 'utility',
+        appliesWhen: ['generate-utility'],
+        tags: ['utility', 'utils'],
+    },
+    {
+        token: 'utilities',
+        appliesWhen: ['generate-utility'],
+        tags: ['utility', 'utils'],
+    },
+    {
+        token: 'pipeline',
+        appliesWhen: ['create-pipeline'],
+        tags: ['pipeline'],
+    },
+    {
+        token: 'route',
+        appliesWhen: ['generate-route'],
+        tags: ['http', 'routes', 'api'],
+    },
+    {
+        token: 'kernel',
+        appliesWhen: ['create-kernel-service'],
+        tags: ['kernel'],
+    },
+];
+function tokenize(s) {
+    return s
+        .toLowerCase()
+        .split(/[^a-z0-9]+/)
+        .filter((t) => t.length >= 3);
+}
+function uniqueTokens(s) {
+    return new Set(tokenize(s));
+}
+function score(reasons, by, why) {
+    reasons.push(why);
+    return by;
+}
+function commonTokens(a, b) {
+    const out = [];
+    for (const t of b)
+        if (a.has(t))
+            out.push(t);
+    return out;
+}
+/** Match free-text task tokens against a string corpus and return a token-hit count. */
+function tokenHits(taskTokens, ...corpus) {
+    let hits = 0;
+    for (const c of corpus) {
+        if (!c)
+            continue;
+        const tokens = tokenize(c);
+        for (const t of tokens)
+            if (taskTokens.has(t))
+                hits += 1;
+    }
+    return hits;
+}
+function deriveContext(task) {
+    const lower = task.toLowerCase();
+    const verbAppliesWhen = new Set();
+    const verbTags = new Set();
+    for (const v of VERB_HINTS) {
+        if (v.regex.test(lower)) {
+            for (const a of v.appliesWhen)
+                verbAppliesWhen.add(a);
+            for (const t of v.tags)
+                verbTags.add(t);
+        }
+    }
+    const taskTokens = uniqueTokens(task);
+    const domainAppliesWhen = new Set();
+    const domainTags = new Set();
+    const domainTokens = new Set();
+    for (const d of DOMAIN_HINTS) {
+        if (taskTokens.has(d.token)) {
+            domainTokens.add(d.token);
+            for (const a of d.appliesWhen)
+                domainAppliesWhen.add(a);
+            for (const t of d.tags)
+                domainTags.add(t);
+        }
+    }
+    return {
+        verbAppliesWhen,
+        verbTags,
+        domainAppliesWhen,
+        domainTags,
+        domainTokens,
+        taskTokens,
+    };
+}
+// Domain-tag matches outweigh generic verb-tag matches. The intent: a rule
+// tagged `plugin` should rank above a generic `feature` rule when the task
+// mentions a plugin.
+const DOMAIN_TAG_WEIGHT = 6;
+const VERB_TAG_WEIGHT = 2;
+const DOMAIN_APPLIES_WEIGHT = 6;
+const VERB_APPLIES_WEIGHT = 4;
+const TITLE_DOMAIN_TOKEN_WEIGHT = 4;
+function applyTagScore(itemTags, ctx, reasons) {
+    let s = 0;
+    const itemTagSet = new Set(itemTags ?? []);
+    const domainHits = commonTokens(ctx.domainTags, itemTagSet);
+    if (domainHits.length) {
+        s += score(reasons, DOMAIN_TAG_WEIGHT * domainHits.length, `domain tags: ${domainHits.join(', ')}`);
+    }
+    const verbHits = commonTokens(ctx.verbTags, itemTagSet);
+    if (verbHits.length) {
+        s += score(reasons, VERB_TAG_WEIGHT * verbHits.length, `tags: ${verbHits.join(', ')}`);
+    }
+    return s;
+}
+function applyAppliesWhenScore(itemAppliesWhen, ctx, reasons) {
+    let s = 0;
+    const set = new Set(itemAppliesWhen ?? []);
+    const domainHits = commonTokens(ctx.domainAppliesWhen, set);
+    if (domainHits.length) {
+        s += score(reasons, DOMAIN_APPLIES_WEIGHT * domainHits.length, `appliesWhen(domain): ${domainHits.join(', ')}`);
+    }
+    const verbHits = commonTokens(ctx.verbAppliesWhen, set);
+    if (verbHits.length) {
+        s += score(reasons, VERB_APPLIES_WEIGHT * verbHits.length, `appliesWhen: ${verbHits.join(', ')}`);
+    }
+    return s;
+}
+function applyTitleDomainBoost(text, ctx, reasons) {
+    if (!text)
+        return 0;
+    let s = 0;
+    const titleTokens = new Set(tokenize(text));
+    for (const dom of ctx.domainTokens) {
+        if (titleTokens.has(dom)) {
+            s += score(reasons, TITLE_DOMAIN_TOKEN_WEIGHT, `title mentions "${dom}"`);
+        }
+    }
+    return s;
+}
+function applyIdDomainBoost(id, ctx, reasons) {
+    let s = 0;
+    const idLower = id.toLowerCase();
+    for (const dom of ctx.domainTokens) {
+        if (idLower.includes(dom)) {
+            s += score(reasons, 3, `id contains "${dom}"`);
+        }
+    }
+    return s;
+}
+// ── Knowledge entries (rules, paths, other) ─────────────────────────────
+export function rankKnowledgeEntries(entries, task) {
+    const ctx = deriveContext(task);
+    const out = [];
+    for (const e of entries) {
+        const reasons = [];
+        let s = 0;
+        // Priority baseline — lower than before to let structured matches dominate.
+        const p = String(e.priority);
+        if (p === 'critical')
+            s += score(reasons, 4, 'priority:critical');
+        else if (p === 'high')
+            s += score(reasons, 3, 'priority:high');
+        else if (p === 'medium')
+            s += score(reasons, 1, 'priority:medium');
+        s += applyAppliesWhenScore(e.appliesWhen, ctx, reasons);
+        s += applyTagScore(e.tags ?? [], ctx, reasons);
+        s += applyTitleDomainBoost(e.title, ctx, reasons);
+        s += applyIdDomainBoost(e.id, ctx, reasons);
+        const hits = tokenHits(ctx.taskTokens, e.title, e.content, (e.tags ?? []).join(' '));
+        if (hits)
+            s += score(reasons, Math.min(6, hits), `token hits: ${hits}`);
+        if (s > 0)
+            out.push({ item: e, score: s, reasons });
+    }
+    out.sort((a, b) => b.score - a.score);
+    return out;
+}
+// ── Templates ───────────────────────────────────────────────────────────
+export function rankTemplates(templates, task) {
+    const ctx = deriveContext(task);
+    const out = [];
+    for (const t of templates) {
+        const reasons = [];
+        let s = 0;
+        s += applyAppliesWhenScore(t.appliesWhen, ctx, reasons);
+        s += applyTagScore(t.tags ?? [], ctx, reasons);
+        s += applyTitleDomainBoost(t.name, ctx, reasons);
+        s += applyTitleDomainBoost(t.description, ctx, reasons);
+        s += applyIdDomainBoost(t.id, ctx, reasons);
+        const hits = tokenHits(ctx.taskTokens, t.id, t.name, t.description, (t.tags ?? []).join(' '));
+        if (hits)
+            s += score(reasons, Math.min(8, hits * 2), `token hits: ${hits}`);
+        if (s > 0)
+            out.push({ item: t, score: s, reasons });
+    }
+    out.sort((a, b) => b.score - a.score);
+    return out;
+}
+// ── Path conventions (treated like knowledge entries with type "path") ──
+export function rankPathConventions(paths, task) {
+    return rankKnowledgeEntries(paths, task);
+}
+// ── Pipelines ───────────────────────────────────────────────────────────
+export function rankPipelines(pipelines, task) {
+    const ctx = deriveContext(task);
+    const out = [];
+    for (const p of pipelines) {
+        const reasons = [];
+        let s = 0;
+        s += applyTagScore(p.tags ?? [], ctx, reasons);
+        s += applyTitleDomainBoost(p.title, ctx, reasons);
+        s += applyTitleDomainBoost(p.description, ctx, reasons);
+        s += applyIdDomainBoost(p.id, ctx, reasons);
+        const stepReasons = [];
+        for (const step of p.steps ?? []) {
+            const stepHits = tokenHits(ctx.taskTokens, step.id, step.description, step.instruction);
+            if (stepHits > 0) {
+                s += Math.min(3, stepHits);
+                stepReasons.push(`${step.id}:${stepHits}`);
+            }
+            // Step references to templates that match the domain.
+            for (const ref of step.references ?? []) {
+                for (const dom of ctx.domainTokens) {
+                    if (ref.toLowerCase().includes(dom)) {
+                        s += score(reasons, 2, `step ${step.id} references ${ref}`);
+                        break;
+                    }
+                }
+            }
+        }
+        if (stepReasons.length)
+            reasons.push(`step hits: ${stepReasons.join(', ')}`);
+        const titleHits = tokenHits(ctx.taskTokens, p.title, p.description);
+        if (titleHits)
+            s += score(reasons, Math.min(8, titleHits * 2), `title/description hits: ${titleHits}`);
+        if (s > 0)
+            out.push({ item: p, score: s, reasons });
+    }
+    out.sort((a, b) => b.score - a.score);
+    return out;
+}
+// ── Presets ─────────────────────────────────────────────────────────────
+export function rankPresets(presets, task, detectedProfiles) {
+    const ctx = deriveContext(task);
+    const profileSet = new Set(detectedProfiles);
+    const out = [];
+    for (const p of presets) {
+        const reasons = [];
+        let s = p.weight ?? 5;
+        if (s > 0)
+            reasons.push(`base weight: ${s}`);
+        let blocked = false;
+        for (const need of p.appliesTo ?? []) {
+            if (profileSet.has(need)) {
+                s += score(reasons, 5, `profile matches: ${need}`);
+            }
+        }
+        for (const block of p.notAppropriateFor ?? []) {
+            if (profileSet.has(block)) {
+                blocked = true;
+                reasons.push(`not appropriate: ${block}`);
+                break;
+            }
+        }
+        if (blocked)
+            continue;
+        s += applyTagScore(p.tags ?? [], ctx, reasons);
+        s += applyTitleDomainBoost(p.title, ctx, reasons);
+        s += applyTitleDomainBoost(p.description, ctx, reasons);
+        s += applyIdDomainBoost(p.id, ctx, reasons);
+        const hits = tokenHits(ctx.taskTokens, p.id, p.title, p.description);
+        if (hits)
+            s += score(reasons, Math.min(6, hits), `token hits: ${hits}`);
+        out.push({ item: p, score: s, reasons });
+    }
+    out.sort((a, b) => b.score - a.score);
+    return out;
+}
+export function rankAll(inspection, task, limit = 10) {
+    const initialRules = rankKnowledgeEntries(inspection.ruleService.list(), task);
+    const initialPaths = rankPathConventions(inspection.pathService.list(), task);
+    const initialTemplates = rankTemplates(inspection.templates, task);
+    const initialPipelines = rankPipelines(inspection.pipelines, task);
+    // Cross-link boost: once we know the top templates and paths, walk the
+    // top entries again and bump rules whose actionHints reference those
+    // ids. This produces the "related-X amplifies Y" signal without making
+    // the per-rule scoring expensive.
+    const topTemplateIds = new Set(initialTemplates.slice(0, 8).map((r) => r.item.id));
+    const topPathIds = new Set(initialPaths.slice(0, 8).map((r) => r.item.id));
+    const rules = initialRules.map((r) => {
+        let extra = 0;
+        const extraReasons = [];
+        const ah = r.item.actionHints;
+        if (ah) {
+            for (const tid of ah.relatedTemplates ?? []) {
+                if (topTemplateIds.has(tid)) {
+                    extra += 4;
+                    extraReasons.push(`relatedTemplate hit: ${tid}`);
+                }
+            }
+            for (const pid of ah.relatedPathConventions ?? []) {
+                if (topPathIds.has(pid)) {
+                    extra += 3;
+                    extraReasons.push(`relatedPath hit: ${pid}`);
+                }
+            }
+        }
+        if (extra === 0)
+            return r;
+        return { item: r.item, score: r.score + extra, reasons: [...r.reasons, ...extraReasons] };
+    });
+    rules.sort((a, b) => b.score - a.score);
+    // Pipeline → template cross-link: bump templates that the top pipeline
+    // references in any step.
+    const topPipeline = initialPipelines[0]?.item;
+    const referencedFromTopPipeline = new Set();
+    if (topPipeline) {
+        for (const step of topPipeline.steps ?? []) {
+            for (const ref of step.references ?? [])
+                referencedFromTopPipeline.add(ref);
+        }
+    }
+    const templates = initialTemplates.map((r) => {
+        if (!referencedFromTopPipeline.has(r.item.id))
+            return r;
+        return {
+            item: r.item,
+            score: r.score + 3,
+            reasons: [...r.reasons, `referenced by top pipeline ${topPipeline?.id}`],
+        };
+    });
+    templates.sort((a, b) => b.score - a.score);
+    return {
+        rules: rules.slice(0, limit),
+        paths: initialPaths.slice(0, limit),
+        templates: templates.slice(0, limit),
+        pipelines: initialPipelines.slice(0, limit),
+        presets: rankPresets(inspection.presetRegistry.list(), task, inspection.workspace.profiles).slice(0, limit),
+    };
+}
+// Expose a small "explain" formatter for CLI/MCP output.
+export function explainRanked(items, describe, limit = 5) {
+    return items
+        .slice(0, limit)
+        .map((r) => `  • [${r.score}] ${describe(r.item)}  — ${r.reasons.join('; ')}`)
+        .join('\n');
+}

package/dist/task-risk.d.ts

@@ -0,0 +1,84 @@
+import { type IChangeIntent } from './change-intent.js';
+import type { ISharkcraftInspection } from './sharkcraft-inspector.js';
+export declare const TASK_RISK_SCHEMA = "sharkcraft.task-risk/v1";
+export declare enum TaskRiskLevel {
+    Low = "low",
+    Medium = "medium",
+    High = "high",
+    Critical = "critical"
+}
+export interface ITaskRiskReason {
+    code: string;
+    message: string;
+    weight: number;
+}
+export interface ITaskRiskMemorySignal {
+    code: string;
+    message: string;
+    weight: number;
+    source: 'file' | 'diagnostic' | 'construct' | 'boundary' | 'policy' | 'plan' | 'pack';
+}
+export interface ITaskRiskMemoryReport {
+    /** True if no memory index was found. */
+    missing: boolean;
+    /** True if the memory index is older than 30 days. */
+    stale: boolean;
+    /** ISO timestamp when the loaded index was generated. */
+    indexGeneratedAt?: string;
+    /** Raw memory adjustment before cap. */
+    rawScore: number;
+    /** Final adjustment after cap. */
+    score: number;
+    /** Memory-derived risk level (low/medium/high/critical). */
+    level: TaskRiskLevel;
+    /** Reasons that fired during memory scoring. */
+    reasons: readonly ITaskRiskReason[];
+    /** Each individual signal (for transparency / explainability). */
+    signals: readonly ITaskRiskMemorySignal[];
+    /** True if the cap was applied. */
+    capped: boolean;
+    /** Cap value used. */
+    cap: number;
+}
+export interface ITaskRiskReport {
+    schema: typeof TASK_RISK_SCHEMA;
+    generatedAt: string;
+    task: string;
+    intent: IChangeIntent;
+    riskLevel: TaskRiskLevel;
+    score: number;
+    reasons: readonly ITaskRiskReason[];
+    affectedFiles: readonly string[];
+    affectedConstructs: readonly string[];
+    highFanInFiles: readonly string[];
+    highFanOutFiles: readonly string[];
+    ownershipGaps: readonly string[];
+    testGaps: readonly string[];
+    boundaryConcerns: readonly string[];
+    policyConcerns: readonly string[];
+    recommendedReviewCommands: readonly string[];
+    humanApprovalRequired: boolean;
+    /** Pre-memory base score. Equals `score` when memory wasn't applied. */
+    baseScore: number;
+    /** Pre-memory base level. */
+    baseRiskLevel: TaskRiskLevel;
+    /** Memory adjustment applied, when --include-memory or includeMemory is set. */
+    memory?: ITaskRiskMemoryReport;
+    /** Convenience — same as `score` post-memory. */
+    adjustedScore: number;
+    /** Convenience — same as `riskLevel` post-memory. */
+    adjustedRiskLevel: TaskRiskLevel;
+}
+export interface IBuildTaskRiskOptions {
+    files?: readonly string[];
+    since?: string;
+    staged?: boolean;
+    /** When true, the memory index (if present) influences the score. */
+    includeMemory?: boolean;
+}
+export declare function buildTaskRiskReport(task: string, inspection: ISharkcraftInspection, options?: IBuildTaskRiskOptions): Promise<ITaskRiskReport>;
+export declare function renderTaskRiskText(r: ITaskRiskReport): string;
+export declare function renderTaskRiskMarkdown(r: ITaskRiskReport): string;
+export declare function summarizeTaskRisk(r: ITaskRiskReport): string;
+export declare function _classifyLevel(score: number): TaskRiskLevel;
+//# sourceMappingURL=task-risk.d.ts.map

package/dist/task-risk.d.ts.map

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