@shrkcrft/inspector 0.1.0-alpha.2

package/dist/construct-adoption.d.ts

@@ -0,0 +1,71 @@
+import { InferredConstructConfidence, type IInferredConstruct } from './construct-inference.js';
+import type { ISharkcraftInspection } from './sharkcraft-inspector.js';
+export declare const CONSTRUCT_ADOPTION_SCHEMA = "sharkcraft.construct-adoption-plan/v1";
+export declare enum ConstructAdoptionCategory {
+    SafeToAdopt = "safe-to-adopt",
+    ManualReview = "manual-review",
+    LowConfidence = "low-confidence",
+    AlreadyCovered = "already-covered",
+    Conflict = "conflict"
+}
+export interface IConstructAdoptionEntry {
+    id: string;
+    type: string;
+    title: string;
+    category: ConstructAdoptionCategory;
+    confidence: InferredConstructConfidence;
+    reasons: readonly string[];
+    /** A short pseudo-diff body for the patch file. */
+    diff: string;
+    /** The full inferred construct payload. */
+    inferred: IInferredConstruct;
+}
+export interface IConstructAdoptionPlan {
+    schema: typeof CONSTRUCT_ADOPTION_SCHEMA;
+    generatedAt: string;
+    projectRoot: string;
+    draftsFile: string | null;
+    entries: readonly IConstructAdoptionEntry[];
+    summary: {
+        total: number;
+        safeToAdopt: number;
+        manualReview: number;
+        lowConfidence: number;
+        alreadyCovered: number;
+        conflict: number;
+    };
+    warnings: readonly string[];
+}
+export type ConstructAdoptionIncludes = 'facets' | 'publicApi' | 'events' | 'tokens';
+export interface IConstructAdoptionInput {
+    /** Minimum confidence required for safe-to-adopt classification. */
+    minConfidence?: InferredConstructConfidence;
+    /** Optional subset of payload fields to include in the diff. */
+    include?: readonly ConstructAdoptionIncludes[];
+}
+export interface IConstructAdoptionPaths {
+    /** Absolute path to `construct-drafts/adoption/`. */
+    adoptionDir: string;
+    planFile: string;
+    patchFile: string;
+    summaryFile: string;
+}
+export declare function constructAdoptionPaths(inspection: ISharkcraftInspection): IConstructAdoptionPaths | null;
+export declare function buildConstructAdoptionPlan(inspection: ISharkcraftInspection, options?: IConstructAdoptionInput): Promise<IConstructAdoptionPlan>;
+export declare function renderConstructAdoptionMarkdown(plan: IConstructAdoptionPlan): string;
+export declare function renderConstructAdoptionPatch(plan: IConstructAdoptionPlan): string;
+export interface IConstructAdoptionWriteResult {
+    written: boolean;
+    paths: IConstructAdoptionPaths;
+    files: readonly string[];
+}
+export declare function writeConstructAdoption(inspection: ISharkcraftInspection, plan: IConstructAdoptionPlan): IConstructAdoptionWriteResult;
+export interface IConstructAdoptionStatus {
+    schema: 'sharkcraft.construct-adoption-status/v1';
+    exists: boolean;
+    paths: IConstructAdoptionPaths | null;
+    planAgeMs: number | null;
+    summary: IConstructAdoptionPlan['summary'] | null;
+}
+export declare function readConstructAdoptionStatus(inspection: ISharkcraftInspection): IConstructAdoptionStatus;
+//# sourceMappingURL=construct-adoption.d.ts.map

package/dist/construct-adoption.d.ts.map

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

package/dist/construct-adoption.js

@@ -0,0 +1,331 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+import { existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from 'node:fs';
+import * as nodePath from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { listConstructs } from "./construct-registry.js";
+import { InferredConstructConfidence, } from "./construct-inference.js";
+export const CONSTRUCT_ADOPTION_SCHEMA = 'sharkcraft.construct-adoption-plan/v1';
+export var ConstructAdoptionCategory;
+(function (ConstructAdoptionCategory) {
+    ConstructAdoptionCategory["SafeToAdopt"] = "safe-to-adopt";
+    ConstructAdoptionCategory["ManualReview"] = "manual-review";
+    ConstructAdoptionCategory["LowConfidence"] = "low-confidence";
+    ConstructAdoptionCategory["AlreadyCovered"] = "already-covered";
+    ConstructAdoptionCategory["Conflict"] = "conflict";
+})(ConstructAdoptionCategory || (ConstructAdoptionCategory = {}));
+const DEFAULT_DRAFTS_PATH = 'construct-drafts/constructs.draft.ts';
+const ADOPTION_DIR = 'construct-drafts/adoption';
+function confidenceRank(c) {
+    if (c === InferredConstructConfidence.High)
+        return 3;
+    if (c === InferredConstructConfidence.Medium)
+        return 2;
+    return 1;
+}
+async function loadDrafts(file) {
+    if (!existsSync(file))
+        return [];
+    try {
+        const mod = (await import(__rewriteRelativeImportExtension(pathToFileURL(file).href)));
+        if (Array.isArray(mod.default))
+            return mod.default;
+        if (Array.isArray(mod.constructs))
+            return mod.constructs;
+        return [];
+    }
+    catch {
+        return [];
+    }
+}
+function safeJsonStringify(value) {
+    return JSON.stringify(value, null, 2);
+}
+function buildDiff(inferred, existing, include = ['facets', 'publicApi', 'events', 'tokens']) {
+    const lines = [];
+    const files = inferred.files ?? [];
+    const publicApi = inferred.publicApi ?? [];
+    const events = inferred.events ?? [];
+    const tokens = inferred.tokens ?? [];
+    if (!existing) {
+        lines.push(`+ Add construct: ${inferred.id} (${inferred.type})`);
+        if (files.length > 0)
+            lines.push(`+   files: ${files.slice(0, 6).join(', ')}`);
+        if (include.includes('publicApi') && publicApi.length > 0) {
+            lines.push(`+   publicApi: ${publicApi.slice(0, 4).join(', ')}`);
+        }
+        if (include.includes('events') && events.length > 0) {
+            lines.push(`+   events: ${events.join(', ')}`);
+        }
+        if (include.includes('tokens') && tokens.length > 0) {
+            lines.push(`+   tokens: ${tokens.join(', ')}`);
+        }
+        return lines.join('\n') + '\n';
+    }
+    lines.push(`~ Construct already exists: ${existing.id}`);
+    const existingFiles = new Set(existing.files ?? []);
+    for (const f of files) {
+        if (!existingFiles.has(f))
+            lines.push(`+   file: ${f}`);
+    }
+    if (include.includes('publicApi')) {
+        const existingApi = new Set(existing.publicApi ?? []);
+        for (const a of publicApi) {
+            if (!existingApi.has(a))
+                lines.push(`+   publicApi: ${a}`);
+        }
+    }
+    if (include.includes('events')) {
+        const existingEv = new Set(existing.events ?? []);
+        for (const e of events) {
+            if (!existingEv.has(e))
+                lines.push(`+   event: ${e}`);
+        }
+    }
+    if (include.includes('tokens')) {
+        const existingTok = new Set(existing.tokens ?? []);
+        for (const t of tokens) {
+            if (!existingTok.has(t))
+                lines.push(`+   token: ${t}`);
+        }
+    }
+    return lines.join('\n') + '\n';
+}
+function classify(inferred, existing, options) {
+    const reasons = [];
+    const files = inferred.files ?? [];
+    if (existing) {
+        const sameType = existing.type === inferred.type;
+        const existingFiles = existing.files ?? [];
+        const filesOverlap = existingFiles.some((f) => files.includes(f));
+        if (sameType &&
+            filesOverlap &&
+            files.every((f) => existingFiles.includes(f)) &&
+            files.length > 0) {
+            reasons.push('construct already registered with identical files');
+            return { category: ConstructAdoptionCategory.AlreadyCovered, reasons };
+        }
+        if (!sameType) {
+            reasons.push(`id collision: existing type "${existing.type}" vs inferred "${inferred.type}"`);
+            return { category: ConstructAdoptionCategory.Conflict, reasons };
+        }
+        reasons.push('existing construct may need merging');
+        return { category: ConstructAdoptionCategory.ManualReview, reasons };
+    }
+    const min = options.minConfidence ?? InferredConstructConfidence.Medium;
+    const rank = confidenceRank(inferred.confidence ?? InferredConstructConfidence.Low);
+    if (rank < confidenceRank(min)) {
+        reasons.push(`confidence ${inferred.confidence ?? '(unknown)'} below required ${min}`);
+        return { category: ConstructAdoptionCategory.LowConfidence, reasons };
+    }
+    if (rank === confidenceRank(InferredConstructConfidence.High)) {
+        return { category: ConstructAdoptionCategory.SafeToAdopt, reasons: ['high confidence'] };
+    }
+    return {
+        category: ConstructAdoptionCategory.ManualReview,
+        reasons: [`medium confidence — review files: ${files.slice(0, 3).join(', ')}`],
+    };
+}
+export function constructAdoptionPaths(inspection) {
+    if (!inspection.sharkcraftDir)
+        return null;
+    const adoptionDir = nodePath.join(inspection.sharkcraftDir, ADOPTION_DIR);
+    return {
+        adoptionDir,
+        planFile: nodePath.join(adoptionDir, 'construct-adoption-plan.md'),
+        patchFile: nodePath.join(adoptionDir, 'construct-adopt.patch'),
+        summaryFile: nodePath.join(adoptionDir, 'construct-adopt-summary.json'),
+    };
+}
+export async function buildConstructAdoptionPlan(inspection, options = {}) {
+    const warnings = [];
+    const draftsFile = inspection.sharkcraftDir
+        ? nodePath.join(inspection.sharkcraftDir, DEFAULT_DRAFTS_PATH)
+        : null;
+    const rawDrafts = draftsFile ? await loadDrafts(draftsFile) : [];
+    // Drafts written by `shrk constructs infer --write-drafts` strip the
+    // inference-only fields. Fill defaults so adoption can still classify.
+    const drafts = rawDrafts.map((d) => ({
+        ...d,
+        confidence: d.confidence ?? InferredConstructConfidence.Medium,
+        evidence: d.evidence ?? [],
+        files: d.files ?? [],
+        publicApi: d.publicApi ?? [],
+        draft: d.draft ?? '',
+    }));
+    if (drafts.length === 0) {
+        warnings.push(`No construct drafts found at ${draftsFile ?? '(no sharkcraft dir)'} — run \`shrk constructs infer --write-drafts\` first.`);
+    }
+    const existing = listConstructs(inspection);
+    const byId = new Map(existing.map((c) => [c.id, c]));
+    const include = options.include ?? ['facets', 'publicApi', 'events', 'tokens'];
+    const entries = [];
+    for (const inferred of drafts) {
+        const ex = byId.get(inferred.id) ?? null;
+        const { category, reasons } = classify(inferred, ex, options);
+        entries.push({
+            id: inferred.id,
+            type: inferred.type,
+            title: inferred.title,
+            category,
+            confidence: inferred.confidence,
+            reasons,
+            diff: buildDiff(inferred, ex, include),
+            inferred,
+        });
+    }
+    const summary = {
+        total: entries.length,
+        safeToAdopt: entries.filter((e) => e.category === ConstructAdoptionCategory.SafeToAdopt).length,
+        manualReview: entries.filter((e) => e.category === ConstructAdoptionCategory.ManualReview).length,
+        lowConfidence: entries.filter((e) => e.category === ConstructAdoptionCategory.LowConfidence).length,
+        alreadyCovered: entries.filter((e) => e.category === ConstructAdoptionCategory.AlreadyCovered).length,
+        conflict: entries.filter((e) => e.category === ConstructAdoptionCategory.Conflict).length,
+    };
+    return {
+        schema: CONSTRUCT_ADOPTION_SCHEMA,
+        generatedAt: new Date().toISOString(),
+        projectRoot: inspection.projectRoot,
+        draftsFile,
+        entries,
+        summary,
+        warnings,
+    };
+}
+export function renderConstructAdoptionMarkdown(plan) {
+    const lines = [];
+    lines.push('# Construct adoption plan');
+    lines.push('');
+    lines.push(`Generated: ${plan.generatedAt}`);
+    lines.push(`Drafts: ${plan.draftsFile ?? '(none)'}`);
+    lines.push('');
+    lines.push('## Summary');
+    lines.push('');
+    lines.push(`- Total: ${plan.summary.total}`);
+    lines.push(`- Safe to adopt: ${plan.summary.safeToAdopt}`);
+    lines.push(`- Manual review: ${plan.summary.manualReview}`);
+    lines.push(`- Low confidence: ${plan.summary.lowConfidence}`);
+    lines.push(`- Already covered: ${plan.summary.alreadyCovered}`);
+    lines.push(`- Conflict: ${plan.summary.conflict}`);
+    lines.push('');
+    if (plan.warnings.length > 0) {
+        lines.push('## Warnings');
+        lines.push('');
+        for (const w of plan.warnings)
+            lines.push(`- ${w}`);
+        lines.push('');
+    }
+    const groups = [
+        ConstructAdoptionCategory.SafeToAdopt,
+        ConstructAdoptionCategory.ManualReview,
+        ConstructAdoptionCategory.LowConfidence,
+        ConstructAdoptionCategory.AlreadyCovered,
+        ConstructAdoptionCategory.Conflict,
+    ];
+    for (const cat of groups) {
+        const items = plan.entries.filter((e) => e.category === cat);
+        if (items.length === 0)
+            continue;
+        lines.push(`## ${cat} (${items.length})`);
+        lines.push('');
+        for (const e of items) {
+            lines.push(`### ${e.id} \`${e.type}\` — ${e.confidence}`);
+            for (const r of e.reasons)
+                lines.push(`- ${r}`);
+            lines.push('');
+            lines.push('```');
+            lines.push(e.diff.trim());
+            lines.push('```');
+            lines.push('');
+        }
+    }
+    lines.push('## Next step');
+    lines.push('');
+    lines.push('Copy approved entries from `construct-adopt.patch` into `sharkcraft/constructs.ts`.');
+    lines.push('SharkCraft never modifies `constructs.ts` automatically.');
+    return lines.join('\n') + '\n';
+}
+export function renderConstructAdoptionPatch(plan) {
+    const lines = [];
+    lines.push('# SharkCraft construct adoption pseudo-patch');
+    lines.push(`# Generated: ${plan.generatedAt}`);
+    lines.push('# Apply manually — SharkCraft never writes constructs.ts.');
+    lines.push('');
+    const groups = [
+        ConstructAdoptionCategory.SafeToAdopt,
+        ConstructAdoptionCategory.ManualReview,
+        ConstructAdoptionCategory.LowConfidence,
+        ConstructAdoptionCategory.AlreadyCovered,
+        ConstructAdoptionCategory.Conflict,
+    ];
+    for (const cat of groups) {
+        const items = plan.entries.filter((e) => e.category === cat);
+        if (items.length === 0)
+            continue;
+        lines.push(`## ${cat}`);
+        for (const e of items) {
+            lines.push(`### ${e.id}`);
+            lines.push(e.diff);
+        }
+        lines.push('');
+    }
+    return lines.join('\n') + '\n';
+}
+export function writeConstructAdoption(inspection, plan) {
+    const paths = constructAdoptionPaths(inspection);
+    if (!paths) {
+        throw new Error('No sharkcraft/ directory — cannot write adoption files.');
+    }
+    mkdirSync(paths.adoptionDir, { recursive: true });
+    const wrote = [];
+    writeFileSync(paths.planFile, renderConstructAdoptionMarkdown(plan), 'utf8');
+    wrote.push(paths.planFile);
+    writeFileSync(paths.patchFile, renderConstructAdoptionPatch(plan), 'utf8');
+    wrote.push(paths.patchFile);
+    writeFileSync(paths.summaryFile, safeJsonStringify(plan.summary) + '\n', 'utf8');
+    wrote.push(paths.summaryFile);
+    return { written: true, paths, files: wrote };
+}
+export function readConstructAdoptionStatus(inspection) {
+    const paths = constructAdoptionPaths(inspection);
+    if (!paths) {
+        return {
+            schema: 'sharkcraft.construct-adoption-status/v1',
+            exists: false,
+            paths: null,
+            planAgeMs: null,
+            summary: null,
+        };
+    }
+    let summary = null;
+    if (existsSync(paths.summaryFile)) {
+        try {
+            summary = JSON.parse(readFileSync(paths.summaryFile, 'utf8'));
+        }
+        catch {
+            summary = null;
+        }
+    }
+    let planAgeMs = null;
+    if (existsSync(paths.planFile)) {
+        try {
+            planAgeMs = Date.now() - statSync(paths.planFile).mtimeMs;
+        }
+        catch {
+            /* ignore */
+        }
+    }
+    return {
+        schema: 'sharkcraft.construct-adoption-status/v1',
+        exists: existsSync(paths.planFile),
+        paths,
+        planAgeMs,
+        summary,
+    };
+}

package/dist/construct-inference.d.ts

@@ -0,0 +1,44 @@
+import type { ISharkcraftInspection } from './sharkcraft-inspector.js';
+export declare const CONSTRUCT_INFERENCE_SCHEMA = "sharkcraft.construct-inference/v1";
+export declare enum InferredConstructConfidence {
+    High = "high",
+    Medium = "medium",
+    Low = "low"
+}
+export interface IInferredConstructFacet {
+    kind: string;
+    value: string;
+    evidence: string;
+}
+export interface IInferredConstruct {
+    id: string;
+    type: string;
+    title: string;
+    confidence: InferredConstructConfidence;
+    evidence: readonly string[];
+    files: readonly string[];
+    publicApi: readonly string[];
+    events?: readonly string[];
+    tokens?: readonly string[];
+    relatedTemplates?: readonly string[];
+    relatedPipelines?: readonly string[];
+    relatedPathConventions?: readonly string[];
+    facets?: readonly IInferredConstructFacet[];
+    /** Pretty-printed `defineConstruct({...})` source. */
+    draft: string;
+}
+export interface IConstructInferenceInput {
+    type?: string;
+    minConfidence?: InferredConstructConfidence;
+    limit?: number;
+}
+export interface IConstructInferenceResult {
+    schema: typeof CONSTRUCT_INFERENCE_SCHEMA;
+    generatedAt: string;
+    projectRoot: string;
+    candidates: readonly IInferredConstruct[];
+    warnings: readonly string[];
+}
+export declare function inferConstructs(inspection: ISharkcraftInspection, input?: IConstructInferenceInput): Promise<IConstructInferenceResult>;
+export declare function renderConstructDraftsModule(result: IConstructInferenceResult): string;
+//# sourceMappingURL=construct-inference.d.ts.map

package/dist/construct-inference.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"construct-inference.d.ts","sourceRoot":"","sources":["../src/construct-inference.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,2BAA2B,CAAC;AAGvE,eAAO,MAAM,0BAA0B,sCAAsC,CAAC;AAE9E,oBAAY,2BAA2B;IACrC,IAAI,SAAS;IACb,MAAM,WAAW;IACjB,GAAG,QAAQ;CACZ;AAED,MAAM,WAAW,uBAAuB;IACtC,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,kBAAkB;IACjC,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,2BAA2B,CAAC;IACxC,QAAQ,EAAE,SAAS,MAAM,EAAE,CAAC;IAC5B,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;IACzB,SAAS,EAAE,SAAS,MAAM,EAAE,CAAC;IAC7B,MAAM,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC3B,MAAM,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC3B,gBAAgB,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACrC,gBAAgB,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACrC,sBAAsB,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC3C,MAAM,CAAC,EAAE,SAAS,uBAAuB,EAAE,CAAC;IAC5C,sDAAsD;IACtD,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,wBAAwB;IACvC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,aAAa,CAAC,EAAE,2BAA2B,CAAC;IAC5C,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,yBAAyB;IACxC,MAAM,EAAE,OAAO,0BAA0B,CAAC;IAC1C,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,SAAS,kBAAkB,EAAE,CAAC;IAC1C,QAAQ,EAAE,SAAS,MAAM,EAAE,CAAC;CAC7B;AA0OD,wBAAsB,eAAe,CACnC,UAAU,EAAE,qBAAqB,EACjC,KAAK,GAAE,wBAA6B,GACnC,OAAO,CAAC,yBAAyB,CAAC,CAuJpC;AAED,wBAAgB,2BAA2B,CACzC,MAAM,EAAE,yBAAyB,GAChC,MAAM,CAkBR"}