@shrkcrft/cli 0.1.0-alpha.2 → 0.1.0-alpha.20

package/dist/audit/knowledge-fix-plan.js

@@ -0,0 +1,125 @@
+const SOURCE_HINT = 'Edit knowledge entries via the files registered in `sharkcraft/sharkcraft.config.ts` (knowledgeFiles / ruleFiles / pathFiles). Locate the entry literal by its `id`.';
+export function buildKnowledgeFixPlan(report) {
+    const fixes = [];
+    const skipped = [];
+    for (const entry of report.entries) {
+        for (const f of entry.deterministicFindings) {
+            const out = dispatchDeterministic(entry, f);
+            if (out.kind === 'fix')
+                fixes.push(out.fix);
+            else
+                skipped.push(out.skip);
+        }
+        for (const f of entry.llmFindings) {
+            fixes.push(makeLlmFix(entry, f));
+        }
+    }
+    const summary = {
+        fixCount: fixes.length,
+        highConfidence: fixes.filter((f) => f.confidence === 'high').length,
+        mediumConfidence: fixes.filter((f) => f.confidence === 'medium').length,
+        lowConfidence: fixes.filter((f) => f.confidence === 'low').length,
+        skipped: skipped.length,
+    };
+    const generatedAt = new Date().toISOString();
+    return {
+        fixPlanId: `fix-${generatedAt.replace(/[:.]/g, '-')}`,
+        generatedAt,
+        auditId: report.auditId,
+        sourceHint: SOURCE_HINT,
+        fixes,
+        skipped,
+        summary,
+    };
+}
+function dispatchDeterministic(entry, f) {
+    // Stale-reference family: high-confidence fixes — the deterministic engine
+    // already names the bad reference and (often) a replacement candidate.
+    if (f.category.startsWith('knowledge-stale.')) {
+        return makeFix(entry, f, f.severity === 'error' ? 'high' : 'medium', 'Repair a stale or missing reference in this entry.', [
+            `Locate knowledge entry "${entry.entryId}" (${SOURCE_HINT}).`,
+            `Deterministic finding: ${f.message}`,
+            f.fixSuggestion ? `Inspector-suggested fix: ${f.fixSuggestion}` : 'No automated fix candidate — verify the new symbol/file path manually.',
+            `If a replacement exists, update the reference in place. Otherwise remove the stale reference. Verify the entry still parses.`,
+        ].join('\n'));
+    }
+    switch (f.category) {
+        case 'knowledge.summary-missing':
+            return makeFix(entry, f, 'high', 'Add a one-sentence summary.', [
+                `Locate knowledge entry "${entry.entryId}" (${SOURCE_HINT}).`,
+                f.stubSuggestion
+                    ? `Inspector-suggested stub: ${f.stubSuggestion}`
+                    : `Add a \`summary\` field — one sentence that lets a reader grok the entry without opening it.`,
+                'Verify the entry still parses.',
+            ].join('\n'));
+        case 'knowledge.tags-missing':
+            return makeFix(entry, f, 'high', 'Add tags so the entry surfaces in tag-based searches.', [
+                `Locate knowledge entry "${entry.entryId}" (${SOURCE_HINT}).`,
+                'Add a `tags` array with 1–3 short kebab-case tags reflecting topic + scope.',
+                'Verify the entry still parses.',
+            ].join('\n'));
+        case 'knowledge.title-missing':
+            return makeFix(entry, f, 'high', 'Add a `title` field.', [
+                `Locate knowledge entry "${entry.entryId}" (${SOURCE_HINT}).`,
+                'Add a `title: "<short human-readable name>"` field — used in lists and reports.',
+                'Verify the entry still parses.',
+            ].join('\n'));
+        case 'knowledge.summary-too-long':
+            return makeFix(entry, f, 'medium', 'Tighten the summary.', [
+                `Locate knowledge entry "${entry.entryId}" (${SOURCE_HINT}).`,
+                `Trim the \`summary\` to ≤ 320 chars. If you can't, move detail into \`body\` instead.`,
+            ].join('\n'));
+        default:
+            if (f.category.includes('obsolete-entry')) {
+                return {
+                    kind: 'skip',
+                    skip: {
+                        entryId: entry.entryId,
+                        findingCategory: f.category,
+                        finding: f.message,
+                        reason: 'obsolete-entry — human/agent must decide to retire or refresh; do not auto-remove.',
+                    },
+                };
+            }
+            return makeFix(entry, f, 'low', `Address finding "${f.category}".`, [
+                `Locate knowledge entry "${entry.entryId}" (${SOURCE_HINT}).`,
+                `The audit reported: ${f.message}`,
+                f.fixSuggestion ?? f.stubSuggestion
+                    ? `Inspector-suggested fix: ${f.fixSuggestion ?? f.stubSuggestion}`
+                    : 'No specific suggestion was supplied — use judgment.',
+                `Apply a minimal change that resolves the finding without touching unrelated fields. Verify the entry still parses.`,
+            ].filter(Boolean).join('\n'));
+    }
+}
+function makeFix(entry, f, confidence, intent, agentPrompt) {
+    return {
+        kind: 'fix',
+        fix: {
+            entryId: entry.entryId,
+            findingCategory: f.category,
+            finding: f.message,
+            severity: f.severity,
+            intent,
+            agentPrompt,
+            confidence,
+            source: 'deterministic',
+        },
+    };
+}
+function makeLlmFix(entry, f) {
+    return {
+        entryId: entry.entryId,
+        findingCategory: f.category,
+        finding: f.message,
+        severity: f.severity,
+        intent: `Review the LLM-flagged "${f.category}" finding and decide whether to act.`,
+        agentPrompt: [
+            `Locate knowledge entry "${entry.entryId}" (${SOURCE_HINT}).`,
+            `An LLM critique flagged (confidence ${f.confidence.toFixed(2)}): ${f.message}`,
+            `LLM findings are advisory — verify against the entry body and sibling entries before acting.`,
+            `If you choose to act, keep the change minimal. If you don't, record the decision in your response.`,
+        ].join('\n'),
+        confidence: 'low',
+        source: 'llm',
+    };
+}

package/dist/audit/pipeline-audit-llm.d.ts

@@ -0,0 +1,11 @@
+import { type IAiProvider } from '@shrkcrft/ai';
+import type { ISharkcraftInspection } from '@shrkcrft/inspector';
+import type { IPipelineAuditReport } from './pipeline-audit.js';
+export interface IEnrichPipelineAuditOptions {
+    provider: IAiProvider;
+    inspection: ISharkcraftInspection;
+    maxTokensPerPipeline?: number;
+    onPerPipelineError?: (pipelineId: string, error: Error) => void;
+}
+export declare function enrichPipelineAuditWithLlm(report: IPipelineAuditReport, options: IEnrichPipelineAuditOptions): Promise<IPipelineAuditReport>;
+//# sourceMappingURL=pipeline-audit-llm.d.ts.map

package/dist/audit/pipeline-audit-llm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pipeline-audit-llm.d.ts","sourceRoot":"","sources":["../../src/audit/pipeline-audit-llm.ts"],"names":[],"mappings":"AAAA,OAAO,EAAkC,KAAK,WAAW,EAAE,MAAM,cAAc,CAAC;AAChF,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,qBAAqB,CAAC;AACjE,OAAO,KAAK,EAGV,oBAAoB,EAErB,MAAM,qBAAqB,CAAC;AAE7B,MAAM,WAAW,2BAA2B;IAC1C,QAAQ,EAAE,WAAW,CAAC;IACtB,UAAU,EAAE,qBAAqB,CAAC;IAClC,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,kBAAkB,CAAC,EAAE,CAAC,UAAU,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;CACjE;AAED,wBAAsB,0BAA0B,CAC9C,MAAM,EAAE,oBAAoB,EAC5B,OAAO,EAAE,2BAA2B,GACnC,OAAO,CAAC,oBAAoB,CAAC,CAiC/B"}

package/dist/audit/pipeline-audit-llm.js

@@ -0,0 +1,134 @@
+import { AiMessageRole } from '@shrkcrft/ai';
+export async function enrichPipelineAuditWithLlm(report, options) {
+    const enriched = [];
+    for (const entry of report.pipelines) {
+        const pipeline = options.inspection.pipelineRegistry.get(entry.pipelineId);
+        if (!pipeline) {
+            enriched.push(entry);
+            continue;
+        }
+        try {
+            const messages = buildEnrichmentMessages(pipeline, entry);
+            const res = await options.provider.send({
+                messages,
+                maxTokens: options.maxTokensPerPipeline ?? 1024,
+            });
+            if (!res.ok) {
+                options.onPerPipelineError?.(entry.pipelineId, res.error);
+                enriched.push(entry);
+                continue;
+            }
+            const parsed = parseLlmFindings(res.value.content);
+            enriched.push({ ...entry, llmFindings: parsed });
+        }
+        catch (e) {
+            options.onPerPipelineError?.(entry.pipelineId, e);
+            enriched.push(entry);
+        }
+    }
+    return {
+        ...report,
+        llmEnriched: true,
+        llmProviderId: options.provider.id,
+        pipelines: enriched,
+    };
+}
+function buildEnrichmentMessages(pipeline, entry) {
+    const system = {
+        role: AiMessageRole.System,
+        content: [
+            'You are a critic auditing a SharkCraft pipeline definition for staleness, content quality, and step-ordering issues.',
+            '',
+            'CRITICAL DISTINCTION:',
+            '- You are auditing the PIPELINE itself, not its target domain. A pipeline that orchestrates a release is fine even if the release process changes; only flag it if the pipeline now executes the wrong steps.',
+            '- A step referencing a tool you do not recognise is NOT necessarily wrong — flag it only if the deterministic layer has already marked the reference as unresolved or if the name is clearly a typo of a real tool.',
+            '',
+            'STRICT silence bias: emit a finding only if a senior maintainer would change something on the strength of it. Better silence than ceremony.',
+            '',
+            'Look for issues the deterministic layer (pipelines lint) CANNOT see:',
+            '  1. **step-order-bug**       — steps that depend on each other are in the wrong order.',
+            '  2. **review-gap**           — a writing step lacks proper review/handoff context.',
+            '  3. **missing-precondition** — a step that assumes state a prior step does not establish.',
+            '  4. **stale-step**           — a step references a workflow or tool that has changed.',
+            '  5. **dead-step**            — a step that no longer does anything useful.',
+            '  6. **other**                — only if none of the above fit.',
+            '',
+            'Return ONLY a JSON object, no preface, no fences:',
+            '{',
+            '  "findings": [',
+            '    { "severity": "info"|"warn"|"error", "category": "<one of the above>", "message": "<one sentence>", "confidence": 0.0 }',
+            '  ]',
+            '}',
+            'If nothing new is worth flagging, return {"findings": []}.',
+        ].join('\n'),
+    };
+    const user = {
+        role: AiMessageRole.User,
+        content: [
+            `# Pipeline under audit`,
+            `id: ${pipeline.id}`,
+            ``,
+            `## Steps`,
+            JSON.stringify(pipeline.steps, null, 2).slice(0, 4096),
+            ``,
+            `## Deterministic findings already produced`,
+            entry.deterministicFindings.length === 0
+                ? '(none)'
+                : entry.deterministicFindings
+                    .map((f) => `- [${f.severity}] ${f.category}${f.stepId ? ` (${f.stepId})` : ''}: ${f.message}`)
+                    .join('\n'),
+        ].join('\n'),
+    };
+    return [system, user];
+}
+function parseLlmFindings(raw) {
+    const trimmed = raw.trim();
+    let jsonText = trimmed;
+    const fenced = trimmed.match(/```(?:json)?\s*([\s\S]*?)```/);
+    if (fenced)
+        jsonText = fenced[1].trim();
+    let parsed;
+    try {
+        parsed = JSON.parse(jsonText);
+    }
+    catch {
+        const first = jsonText.indexOf('{');
+        const last = jsonText.lastIndexOf('}');
+        if (first < 0 || last <= first)
+            return [];
+        try {
+            parsed = JSON.parse(jsonText.slice(first, last + 1));
+        }
+        catch {
+            return [];
+        }
+    }
+    if (!parsed || typeof parsed !== 'object')
+        return [];
+    const list = parsed.findings;
+    if (!Array.isArray(list))
+        return [];
+    const out = [];
+    for (const item of list) {
+        if (!item || typeof item !== 'object')
+            continue;
+        const obj = item;
+        const severity = coerceSeverity(obj.severity);
+        const category = typeof obj.category === 'string' && obj.category.trim() ? obj.category.trim() : 'other';
+        const message = typeof obj.message === 'string' ? obj.message.trim() : '';
+        const confidence = typeof obj.confidence === 'number' && obj.confidence >= 0 && obj.confidence <= 1
+            ? obj.confidence
+            : 0.5;
+        if (!message)
+            continue;
+        out.push({ severity, category, message, confidence });
+    }
+    return out;
+}
+function coerceSeverity(value) {
+    if (value === 'error' || value === 'warn' || value === 'info')
+        return value;
+    if (value === 'warning')
+        return 'warn';
+    return 'info';
+}

package/dist/audit/pipeline-audit.d.ts

@@ -0,0 +1,69 @@
+import { type ISharkcraftInspection } from '@shrkcrft/inspector';
+import type { IAiBlock } from '@shrkcrft/ai';
+export type PipelineAuditFindingSeverity = 'info' | 'warn' | 'error';
+export interface IPipelineAuditFinding {
+    severity: PipelineAuditFindingSeverity;
+    category: string;
+    stepId?: string;
+    message: string;
+    sources: readonly string[];
+}
+export interface ILlmPipelineAuditFinding {
+    severity: PipelineAuditFindingSeverity;
+    category: string;
+    message: string;
+    confidence: number;
+}
+export type PipelineAuditVerdict = 'ok' | 'minor' | 'stale' | 'broken';
+export interface IPipelineAuditEntry {
+    pipelineId: string;
+    verdict: PipelineAuditVerdict;
+    deterministicFindings: readonly IPipelineAuditFinding[];
+    llmFindings: readonly ILlmPipelineAuditFinding[];
+}
+export interface IPipelineAuditReport {
+    auditId: string;
+    generatedAt: string;
+    llmEnriched: boolean;
+    llmProviderId: string | null;
+    pipelines: readonly IPipelineAuditEntry[];
+    summary: {
+        ok: number;
+        minor: number;
+        stale: number;
+        broken: number;
+        total: number;
+    };
+    ai?: IAiBlock;
+}
+export interface IBuildPipelineAuditOptions {
+    pipelineId?: string;
+}
+export declare function buildPipelineAudit(inspection: ISharkcraftInspection, options?: IBuildPipelineAuditOptions): IPipelineAuditReport;
+export interface IPipelineFixInstruction {
+    pipelineId: string;
+    stepId?: string;
+    findingCategory: string;
+    finding: string;
+    severity: PipelineAuditFindingSeverity;
+    intent: string;
+    agentPrompt: string;
+    confidence: 'high' | 'medium' | 'low';
+    source: 'deterministic' | 'llm';
+    llmSuggestion?: string;
+}
+export interface IPipelineFixPlan {
+    fixPlanId: string;
+    generatedAt: string;
+    auditId: string;
+    sourceHint: string;
+    fixes: readonly IPipelineFixInstruction[];
+    summary: {
+        fixCount: number;
+        highConfidence: number;
+        mediumConfidence: number;
+        lowConfidence: number;
+    };
+}
+export declare function buildPipelineFixPlan(report: IPipelineAuditReport): IPipelineFixPlan;
+//# sourceMappingURL=pipeline-audit.d.ts.map

package/dist/audit/pipeline-audit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pipeline-audit.d.ts","sourceRoot":"","sources":["../../src/audit/pipeline-audit.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,qBAAqB,EAC3B,MAAM,qBAAqB,CAAC;AAC7B,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AAE7C,MAAM,MAAM,4BAA4B,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC;AAErE,MAAM,WAAW,qBAAqB;IACpC,QAAQ,EAAE,4BAA4B,CAAC;IACvC,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;CAC5B;AAED,MAAM,WAAW,wBAAwB;IACvC,QAAQ,EAAE,4BAA4B,CAAC;IACvC,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,MAAM,oBAAoB,GAAG,IAAI,GAAG,OAAO,GAAG,OAAO,GAAG,QAAQ,CAAC;AAEvE,MAAM,WAAW,mBAAmB;IAClC,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,oBAAoB,CAAC;IAC9B,qBAAqB,EAAE,SAAS,qBAAqB,EAAE,CAAC;IACxD,WAAW,EAAE,SAAS,wBAAwB,EAAE,CAAC;CAClD;AAED,MAAM,WAAW,oBAAoB;IACnC,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,OAAO,CAAC;IACrB,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,SAAS,EAAE,SAAS,mBAAmB,EAAE,CAAC;IAC1C,OAAO,EAAE;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;IACrF,EAAE,CAAC,EAAE,QAAQ,CAAC;CACf;AAED,MAAM,WAAW,0BAA0B;IACzC,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,wBAAgB,kBAAkB,CAChC,UAAU,EAAE,qBAAqB,EACjC,OAAO,GAAE,0BAA+B,GACvC,oBAAoB,CA0CtB;AAED,MAAM,WAAW,uBAAuB;IACtC,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,eAAe,EAAE,MAAM,CAAC;IACxB,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,4BAA4B,CAAC;IACvC,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,GAAG,QAAQ,GAAG,KAAK,CAAC;IACtC,MAAM,EAAE,eAAe,GAAG,KAAK,CAAC;IAChC,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,WAAW,gBAAgB;IAC/B,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,SAAS,uBAAuB,EAAE,CAAC;IAC1C,OAAO,EAAE;QACP,QAAQ,EAAE,MAAM,CAAC;QACjB,cAAc,EAAE,MAAM,CAAC;QACvB,gBAAgB,EAAE,MAAM,CAAC;QACzB,aAAa,EAAE,MAAM,CAAC;KACvB,CAAC;CACH;AAKD,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,oBAAoB,GAAG,gBAAgB,CAyBnF"}

package/dist/audit/pipeline-audit.js

@@ -0,0 +1,166 @@
+import { lintPipelines, } from '@shrkcrft/inspector';
+export function buildPipelineAudit(inspection, options = {}) {
+    const targetIds = options.pipelineId ? [options.pipelineId] : undefined;
+    const lint = lintPipelines(inspection, targetIds);
+    const byPipeline = new Map();
+    for (const r of lint.results)
+        byPipeline.set(r.pipelineId, [...r.issues]);
+    const pipelines = [];
+    for (const [pipelineId, issues] of byPipeline.entries()) {
+        const det = issues.map((i) => ({
+            severity: normaliseSeverity(i.severity),
+            category: i.code,
+            ...(i.stepId ? { stepId: i.stepId } : {}),
+            message: i.message,
+            sources: ['pipelines lint'],
+        }));
+        pipelines.push({
+            pipelineId,
+            verdict: deriveVerdict(det),
+            deterministicFindings: det,
+            llmFindings: [],
+        });
+    }
+    const summary = pipelines.reduce((acc, p) => {
+        acc[p.verdict] += 1;
+        acc.total += 1;
+        return acc;
+    }, { ok: 0, minor: 0, stale: 0, broken: 0, total: 0 });
+    const generatedAt = new Date().toISOString();
+    return {
+        auditId: `audit-${generatedAt.replace(/[:.]/g, '-')}`,
+        generatedAt,
+        llmEnriched: false,
+        llmProviderId: null,
+        pipelines,
+        summary,
+    };
+}
+const SOURCE_HINT = 'Edit pipelines via the files registered in `sharkcraft/sharkcraft.config.ts` (pipelineFiles). Locate the pipeline literal by its `id`.';
+export function buildPipelineFixPlan(report) {
+    const fixes = [];
+    for (const p of report.pipelines) {
+        for (const f of p.deterministicFindings) {
+            fixes.push(dispatchDeterministic(p.pipelineId, f));
+        }
+        for (const f of p.llmFindings) {
+            fixes.push(makeLlmFix(p.pipelineId, f));
+        }
+    }
+    const summary = {
+        fixCount: fixes.length,
+        highConfidence: fixes.filter((f) => f.confidence === 'high').length,
+        mediumConfidence: fixes.filter((f) => f.confidence === 'medium').length,
+        lowConfidence: fixes.filter((f) => f.confidence === 'low').length,
+    };
+    const generatedAt = new Date().toISOString();
+    return {
+        fixPlanId: `fix-${generatedAt.replace(/[:.]/g, '-')}`,
+        generatedAt,
+        auditId: report.auditId,
+        sourceHint: SOURCE_HINT,
+        fixes,
+        summary,
+    };
+}
+function normaliseSeverity(s) {
+    if (s === 'error')
+        return 'error';
+    if (s === 'warning')
+        return 'warn';
+    return 'info';
+}
+function deriveVerdict(findings) {
+    if (findings.some((f) => f.severity === 'error'))
+        return 'broken';
+    if (findings.some((f) => f.severity === 'warn'))
+        return 'stale';
+    if (findings.some((f) => f.severity === 'info'))
+        return 'minor';
+    return 'ok';
+}
+function dispatchDeterministic(pipelineId, f) {
+    const confidenceMap = {
+        'missing-title': 'high',
+        'missing-step-id': 'high',
+        'missing-step-type': 'high',
+        'write-without-review': 'medium',
+        'review-points-missing': 'medium',
+        'unresolved-reference': 'medium',
+        'uncataloged-command': 'low',
+    };
+    const confidence = confidenceMap[f.category] ?? 'low';
+    const stepClause = f.stepId ? ` (step "${f.stepId}")` : '';
+    return {
+        pipelineId,
+        ...(f.stepId ? { stepId: f.stepId } : {}),
+        findingCategory: f.category,
+        finding: f.message,
+        severity: f.severity,
+        intent: intentFor(f.category, stepClause),
+        agentPrompt: [
+            `Locate pipeline "${pipelineId}" (${SOURCE_HINT}).`,
+            `Finding: ${f.message}`,
+            promptFor(f.category, stepClause, pipelineId),
+            'Verify the file still parses.',
+        ].join('\n'),
+        confidence,
+        source: 'deterministic',
+    };
+}
+function intentFor(category, stepClause) {
+    switch (category) {
+        case 'missing-title':
+            return 'Add a title (and/or description) to the pipeline.';
+        case 'missing-step-id':
+            return `Add an \`id\` to the unnamed step${stepClause}.`;
+        case 'missing-step-type':
+            return `Add a \`type\` to the step${stepClause}.`;
+        case 'write-without-review':
+            return `Mark the writing step${stepClause} with \`humanReview: true\`.`;
+        case 'review-points-missing':
+            return 'Add at least one explicit `humanReview` checkpoint to this pipeline.';
+        case 'unresolved-reference':
+            return `Repair an unresolved \`references[]\` id${stepClause}.`;
+        case 'uncataloged-command':
+            return `Either align the cliCommand to a cataloged \`shrk\` verb${stepClause} or document the new command.`;
+        default:
+            return `Address finding "${category}"${stepClause}.`;
+    }
+}
+function promptFor(category, stepClause, pipelineId) {
+    switch (category) {
+        case 'missing-title':
+            return 'Add a `title: "<short name>"` field at the pipeline level. Optional `description` for one-paragraph context.';
+        case 'missing-step-id':
+            return `Each step must have a unique kebab-case \`id\` within pipeline "${pipelineId}". Pick a name that summarises the step's intent.`;
+        case 'missing-step-type':
+            return `The step${stepClause} must have a \`type\` (e.g. shell-command, generation-plan, apply-plan).`;
+        case 'write-without-review':
+            return `Writing steps must declare \`humanReview: true\` so the agent pauses for confirmation.`;
+        case 'review-points-missing':
+            return 'A pipeline that mutates files must include at least one human-review checkpoint.';
+        case 'unresolved-reference':
+            return 'The id in `references[]` does not match any template or rule. Either remove it or correct the spelling.';
+        case 'uncataloged-command':
+            return 'Either replace the command with a known `shrk` verb or extend the catalog if this is a legitimate new command.';
+        default:
+            return 'Apply a minimal change that resolves the finding without touching unrelated fields.';
+    }
+}
+function makeLlmFix(pipelineId, f) {
+    return {
+        pipelineId,
+        findingCategory: f.category,
+        finding: f.message,
+        severity: f.severity,
+        intent: `Review the LLM-flagged "${f.category}" finding and decide whether to act.`,
+        agentPrompt: [
+            `Locate pipeline "${pipelineId}" (${SOURCE_HINT}).`,
+            `An LLM critique flagged (confidence ${f.confidence.toFixed(2)}): ${f.message}`,
+            'LLM findings are advisory — verify against the pipeline body and peers before acting.',
+        ].join('\n'),
+        confidence: 'low',
+        source: 'llm',
+    };
+}

package/dist/audit/templates-audit-llm.d.ts

@@ -0,0 +1,19 @@
+import { type IAiMessage, type IAiProvider } from '@shrkcrft/ai';
+import type { ITemplateDefinition } from '@shrkcrft/templates';
+import type { ISharkcraftInspection } from '@shrkcrft/inspector';
+import type { ILlmAuditFinding, ITemplateAuditEntry, ITemplateAuditReport } from './templates-audit.js';
+export interface IEnrichOptions {
+    provider: IAiProvider;
+    inspection: ISharkcraftInspection;
+    maxTokensPerTemplate?: number;
+    onPerTemplateError?: (templateId: string, error: Error) => void;
+}
+export declare function enrichAuditWithLlm(report: ITemplateAuditReport, options: IEnrichOptions): Promise<ITemplateAuditReport>;
+declare function buildEnrichmentMessages(template: ITemplateDefinition, peers: readonly ITemplateDefinition[], entry: ITemplateAuditEntry): IAiMessage[];
+declare function parseLlmFindings(raw: string): readonly ILlmAuditFinding[];
+export declare const __internals: {
+    parseLlmFindings: typeof parseLlmFindings;
+    buildEnrichmentMessages: typeof buildEnrichmentMessages;
+};
+export {};
+//# sourceMappingURL=templates-audit-llm.d.ts.map

package/dist/audit/templates-audit-llm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"templates-audit-llm.d.ts","sourceRoot":"","sources":["../../src/audit/templates-audit-llm.ts"],"names":[],"mappings":"AAAA,OAAO,EAAiB,KAAK,UAAU,EAAE,KAAK,WAAW,EAAE,MAAM,cAAc,CAAC;AAChF,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AAC/D,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,qBAAqB,CAAC;AACjE,OAAO,KAAK,EAEV,gBAAgB,EAChB,mBAAmB,EACnB,oBAAoB,EACrB,MAAM,sBAAsB,CAAC;AAE9B,MAAM,WAAW,cAAc;IAC7B,QAAQ,EAAE,WAAW,CAAC;IACtB,UAAU,EAAE,qBAAqB,CAAC;IAClC,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,kBAAkB,CAAC,EAAE,CAAC,UAAU,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;CACjE;AAED,wBAAsB,kBAAkB,CACtC,MAAM,EAAE,oBAAoB,EAC5B,OAAO,EAAE,cAAc,GACtB,OAAO,CAAC,oBAAoB,CAAC,CAwC/B;AAED,iBAAS,uBAAuB,CAC9B,QAAQ,EAAE,mBAAmB,EAC7B,KAAK,EAAE,SAAS,mBAAmB,EAAE,EACrC,KAAK,EAAE,mBAAmB,GACzB,UAAU,EAAE,CAsGd;AAuBD,iBAAS,gBAAgB,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,gBAAgB,EAAE,CAoClE;AAQD,eAAO,MAAM,WAAW;;;CAAgD,CAAC"}