@shrkcrft/inspector 0.1.0-alpha.2

package/dist/pack-author.js

@@ -0,0 +1,208 @@
+/**
+ * Pack asset authoring workflow.
+ *
+ * Generic, preview-first orchestrator over the asset kinds a SharkCraft
+ * pack can ship:
+ *   - status (read-only inventory of asset kinds + per-kind counts + signature)
+ *   - preview (delegate to knowledge for the load-bearing kind; other
+ *     kinds return an explicit "not yet implemented" preview with a clear
+ *     next-step list)
+ *   - pending (cross-section: modified files, drafts under .sharkcraft/,
+ *     stale signature, missing-secret state) — composed in `pack-pending.ts`.
+ *
+ * Hard rules:
+ *   - Never mutate pack source. Drafts go under .sharkcraft/authoring/.
+ *   - Honest: refuse to fake an authoring slice we don't yet support.
+ *   - No project-specific logic.
+ */
+import { existsSync, readdirSync } from 'node:fs';
+import * as nodePath from 'node:path';
+export const PACK_AUTHOR_STATUS_SCHEMA = 'sharkcraft.pack-author-status/v1';
+export const PACK_AUTHOR_PREVIEW_SCHEMA = 'sharkcraft.pack-author-preview/v1';
+export const PACK_AUTHOR_VALIDATE_SCHEMA = 'sharkcraft.pack-author-validate/v1';
+export var PackAuthorKind;
+(function (PackAuthorKind) {
+    PackAuthorKind["Knowledge"] = "knowledge";
+    PackAuthorKind["SearchTuning"] = "search-tuning";
+    PackAuthorKind["FeedbackRule"] = "feedback-rule";
+    PackAuthorKind["AgentTest"] = "agent-test";
+    PackAuthorKind["Convention"] = "convention";
+    PackAuthorKind["TaskRoutingHint"] = "task-routing-hint";
+    PackAuthorKind["RegistrationHint"] = "registration-hint";
+    PackAuthorKind["ScaffoldPattern"] = "scaffold-pattern";
+})(PackAuthorKind || (PackAuthorKind = {}));
+const KIND_TO_CONTRIBUTION_SLOT = {
+    [PackAuthorKind.Knowledge]: 'knowledgeFiles',
+    [PackAuthorKind.SearchTuning]: 'searchTuningFiles',
+    [PackAuthorKind.FeedbackRule]: 'feedbackRuleFiles',
+    [PackAuthorKind.AgentTest]: 'agentTestFiles',
+    [PackAuthorKind.Convention]: 'conventionFiles',
+    [PackAuthorKind.TaskRoutingHint]: 'taskRoutingHintFiles',
+    [PackAuthorKind.RegistrationHint]: 'registrationHintFiles',
+    [PackAuthorKind.ScaffoldPattern]: 'scaffoldPatternFiles',
+};
+export function buildPackAuthorStatus(inspection) {
+    const root = inspection.projectRoot;
+    const sharkcraftDir = inspection.sharkcraftDir ?? nodePath.join(root, 'sharkcraft');
+    const contributionCounts = {};
+    const resolvedTargets = {};
+    for (const kind of Object.values(PackAuthorKind)) {
+        contributionCounts[kind] = 0;
+        resolvedTargets[kind] = [];
+    }
+    // Local — sharkcraft/<kind>.ts (best-effort).
+    for (const kind of Object.values(PackAuthorKind)) {
+        const localCandidates = candidateLocalFiles(sharkcraftDir, kind);
+        const targets = resolvedTargets[kind];
+        if (!targets)
+            continue;
+        for (const localPath of localCandidates) {
+            const rel = nodePath.relative(root, localPath);
+            const exists = existsSync(localPath);
+            targets.push({
+                kind: 'local',
+                filePath: rel,
+                exists,
+            });
+            if (exists)
+                contributionCounts[kind] = (contributionCounts[kind] ?? 0) + 1;
+        }
+    }
+    // Packs.
+    for (const pack of (inspection.packs.validPacks ?? [])) {
+        const contributions = (pack.manifest?.contributions ?? {});
+        for (const kind of Object.values(PackAuthorKind)) {
+            const slot = KIND_TO_CONTRIBUTION_SLOT[kind];
+            const rels = contributions[slot] ?? [];
+            const targets = resolvedTargets[kind];
+            if (!targets)
+                continue;
+            for (const rel of rels) {
+                const abs = nodePath.resolve(pack.packageRoot, rel);
+                const projectRel = nodePath.relative(root, abs);
+                const exists = existsSync(abs);
+                targets.push({
+                    kind: 'pack',
+                    packName: pack.packageName,
+                    packageRoot: pack.packageRoot,
+                    filePath: projectRel,
+                    exists,
+                });
+                if (exists)
+                    contributionCounts[kind] = (contributionCounts[kind] ?? 0) + 1;
+            }
+        }
+    }
+    const authoringSupport = {
+        [PackAuthorKind.Knowledge]: 'preview',
+        [PackAuthorKind.SearchTuning]: 'deferred',
+        [PackAuthorKind.FeedbackRule]: 'deferred',
+        [PackAuthorKind.AgentTest]: 'deferred',
+        [PackAuthorKind.Convention]: 'deferred',
+        [PackAuthorKind.TaskRoutingHint]: 'deferred',
+        [PackAuthorKind.RegistrationHint]: 'deferred',
+        [PackAuthorKind.ScaffoldPattern]: 'deferred',
+    };
+    const pendingDir = nodePath.join(root, '.sharkcraft', 'authoring');
+    let pendingDrafts = 0;
+    const pendingDraftFiles = [];
+    if (existsSync(pendingDir)) {
+        for (const f of readdirSync(pendingDir)) {
+            if (f.endsWith('.draft.ts') || f.endsWith('.preview.md') || f.endsWith('.patch') || f.endsWith('.manifest.json')) {
+                pendingDrafts++;
+                pendingDraftFiles.push(nodePath.relative(root, nodePath.join(pendingDir, f)));
+            }
+        }
+    }
+    const provenancePath = nodePath.join(root, '.sharkcraft', 'asset-provenance.jsonl');
+    const provenanceExists = existsSync(provenancePath);
+    const secretAvailable = Boolean(process.env['SHARKCRAFT_PACK_SECRET']);
+    return {
+        schema: PACK_AUTHOR_STATUS_SCHEMA,
+        generatedAt: new Date().toISOString(),
+        projectRoot: root,
+        contributionCounts,
+        pendingDrafts,
+        pendingDraftFiles,
+        provenanceExists,
+        secretAvailable,
+        resolvedTargets,
+        authoringSupport,
+        nextCommands: [
+            'shrk pack author pending',
+            'shrk knowledge stale-check --ci',
+            'shrk self-config doctor',
+            'shrk packs signature-status',
+        ],
+    };
+}
+function candidateLocalFiles(sharkcraftDir, kind) {
+    const ext = '.ts';
+    // Each kind maps to a primary canonical local file. We return one path
+    // — the canonical one — and let the caller mark exists/missing.
+    switch (kind) {
+        case PackAuthorKind.Knowledge:
+            return [nodePath.join(sharkcraftDir, `knowledge${ext}`)];
+        case PackAuthorKind.SearchTuning:
+            return [nodePath.join(sharkcraftDir, `search-tuning${ext}`)];
+        case PackAuthorKind.FeedbackRule:
+            return [nodePath.join(sharkcraftDir, `feedback-rules${ext}`)];
+        case PackAuthorKind.AgentTest:
+            return [nodePath.join(sharkcraftDir, `agent-tests${ext}`)];
+        case PackAuthorKind.Convention:
+            return [nodePath.join(sharkcraftDir, `conventions${ext}`)];
+        case PackAuthorKind.TaskRoutingHint:
+            return [nodePath.join(sharkcraftDir, `task-routing-hints${ext}`)];
+        case PackAuthorKind.RegistrationHint:
+            return [nodePath.join(sharkcraftDir, `registration-hints${ext}`)];
+        case PackAuthorKind.ScaffoldPattern:
+            return [nodePath.join(sharkcraftDir, `scaffold-patterns${ext}`)];
+    }
+}
+export function buildPackAuthorPreview(input) {
+    if (input.kind === PackAuthorKind.Knowledge) {
+        return {
+            schema: PACK_AUTHOR_PREVIEW_SCHEMA,
+            generatedAt: new Date().toISOString(),
+            kind: input.kind,
+            assetId: input.assetId,
+            implemented: true,
+            nextCommands: [
+                `shrk knowledge add --id ${input.assetId}${input.reason ? ` --reason "${input.reason}"` : ''}`,
+                `shrk knowledge stale-check --ci`,
+                `shrk self-config doctor`,
+                `shrk pack author pending`,
+            ],
+        };
+    }
+    return {
+        schema: PACK_AUTHOR_PREVIEW_SCHEMA,
+        generatedAt: new Date().toISOString(),
+        kind: input.kind,
+        assetId: input.assetId,
+        implemented: false,
+        deferralNote: `Only the knowledge kind is implemented for authoring preview. For "${input.kind}", ` +
+            `edit the pack's \`assets/${input.kind}.ts\` file manually; preview support is planned.`,
+        nextCommands: [
+            `# Open the pack file that contributes ${input.kind} entries:`,
+            `shrk packs contributions --kind ${input.kind}`,
+            `# Then validate after the edit:`,
+            `shrk self-config doctor`,
+            `shrk packs signature-status`,
+        ],
+    };
+}
+export function buildPackAuthorValidatePlan() {
+    return {
+        schema: PACK_AUTHOR_VALIDATE_SCHEMA,
+        generatedAt: new Date().toISOString(),
+        ok: true,
+        recommendedCommands: [
+            'shrk knowledge stale-check --ci',
+            'shrk self-config doctor',
+            'shrk packs signature-status',
+            'shrk packs doctor --signature-explain',
+            'shrk packs sign --if-needed',
+        ],
+    };
+}

package/dist/pack-compatibility.d.ts

@@ -0,0 +1,21 @@
+import type { IDiscoveredPack } from '@shrkcrft/packs';
+import type { ISharkcraftInspection } from './sharkcraft-inspector.js';
+export declare const PACK_COMPATIBILITY_SCHEMA = "sharkcraft.pack-compatibility/v1";
+export interface IPackCompatibilityHit {
+    status: 'compatible' | 'incompatible' | 'warning';
+    reason: string;
+}
+export interface IPackCompatibility {
+    schema: typeof PACK_COMPATIBILITY_SCHEMA;
+    packageName: string;
+    packageVersion: string;
+    overall: 'compatible' | 'incompatible' | 'warning';
+    sharkcraftVersion: string;
+    runtime: string;
+    packageManager: string;
+    workspaceProfiles: readonly string[];
+    hits: readonly IPackCompatibilityHit[];
+}
+export declare function checkPackCompatibility(inspection: ISharkcraftInspection, pack: IDiscoveredPack): IPackCompatibility;
+export declare function checkAllPacksCompatibility(inspection: ISharkcraftInspection): IPackCompatibility[];
+//# sourceMappingURL=pack-compatibility.d.ts.map

package/dist/pack-compatibility.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pack-compatibility.d.ts","sourceRoot":"","sources":["../src/pack-compatibility.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AACvD,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,2BAA2B,CAAC;AAEvE,eAAO,MAAM,yBAAyB,qCAAqC,CAAC;AAE5E,MAAM,WAAW,qBAAqB;IACpC,MAAM,EAAE,YAAY,GAAG,cAAc,GAAG,SAAS,CAAC;IAClD,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,kBAAkB;IACjC,MAAM,EAAE,OAAO,yBAAyB,CAAC;IACzC,WAAW,EAAE,MAAM,CAAC;IACpB,cAAc,EAAE,MAAM,CAAC;IACvB,OAAO,EAAE,YAAY,GAAG,cAAc,GAAG,SAAS,CAAC;IACnD,iBAAiB,EAAE,MAAM,CAAC;IAC1B,OAAO,EAAE,MAAM,CAAC;IAChB,cAAc,EAAE,MAAM,CAAC;IACvB,iBAAiB,EAAE,SAAS,MAAM,EAAE,CAAC;IACrC,IAAI,EAAE,SAAS,qBAAqB,EAAE,CAAC;CACxC;AA6DD,wBAAgB,sBAAsB,CACpC,UAAU,EAAE,qBAAqB,EACjC,IAAI,EAAE,eAAe,GACpB,kBAAkB,CAiDpB;AAED,wBAAgB,0BAA0B,CAAC,UAAU,EAAE,qBAAqB,GAAG,kBAAkB,EAAE,CAElG"}

package/dist/pack-compatibility.js

@@ -0,0 +1,114 @@
+import { existsSync, readFileSync } from 'node:fs';
+import * as nodePath from 'node:path';
+export const PACK_COMPATIBILITY_SCHEMA = 'sharkcraft.pack-compatibility/v1';
+function detectRuntime() {
+    if (typeof Bun !== 'undefined')
+        return 'bun';
+    return 'node';
+}
+function detectPackageManager(projectRoot) {
+    if (existsSync(nodePath.join(projectRoot, 'bun.lock')) || existsSync(nodePath.join(projectRoot, 'bun.lockb')))
+        return 'bun';
+    if (existsSync(nodePath.join(projectRoot, 'pnpm-lock.yaml')))
+        return 'pnpm';
+    if (existsSync(nodePath.join(projectRoot, 'yarn.lock')))
+        return 'yarn';
+    if (existsSync(nodePath.join(projectRoot, 'package-lock.json')))
+        return 'npm';
+    return 'unknown';
+}
+function readSharkcraftVersion() {
+    try {
+        const pkg = nodePath.join(import.meta.dir ?? __dirname, '..', 'package.json');
+        if (existsSync(pkg)) {
+            const v = JSON.parse(readFileSync(pkg, 'utf8'));
+            if (v.version)
+                return v.version;
+        }
+    }
+    catch {
+        /* ignore */
+    }
+    return '0.1.0';
+}
+function semverInRange(v, range) {
+    // Very small semver subset: '^X.Y.Z', '~X.Y.Z', or 'X.Y.Z'.
+    const m = /^(\^|~)?(\d+)\.(\d+)\.(\d+)/.exec(range);
+    if (!m)
+        return true;
+    const op = m[1];
+    const major = Number(m[2]);
+    const minor = Number(m[3]);
+    const patch = Number(m[4]);
+    const cm = /^(\d+)\.(\d+)\.(\d+)/.exec(v);
+    if (!cm)
+        return false;
+    const cMajor = Number(cm[1]);
+    const cMinor = Number(cm[2]);
+    const cPatch = Number(cm[3]);
+    if (op === '^') {
+        if (major === 0) {
+            return cMajor === 0 && cMinor === minor && cPatch >= patch;
+        }
+        if (cMajor !== major)
+            return false;
+        return cMinor > minor || (cMinor === minor && cPatch >= patch);
+    }
+    if (op === '~') {
+        return cMajor === major && cMinor === minor && cPatch >= patch;
+    }
+    return cMajor === major && cMinor === minor && cPatch === patch;
+}
+export function checkPackCompatibility(inspection, pack) {
+    const manifest = pack.manifest;
+    const compat = manifest?.compatibility ?? {};
+    const sharkcraftVersion = readSharkcraftVersion();
+    const runtime = detectRuntime();
+    const pm = detectPackageManager(inspection.projectRoot);
+    const profiles = inspection.workspace.profiles ?? [];
+    const hits = [];
+    if (compat.sharkcraft && !semverInRange(sharkcraftVersion, compat.sharkcraft)) {
+        hits.push({ status: 'incompatible', reason: `Pack requires SharkCraft ${compat.sharkcraft} — current ${sharkcraftVersion}` });
+    }
+    else if (compat.sharkcraft) {
+        hits.push({ status: 'compatible', reason: `SharkCraft ${compat.sharkcraft} satisfied by ${sharkcraftVersion}` });
+    }
+    if (compat.runtimes && compat.runtimes.length > 0) {
+        if (compat.runtimes.includes(runtime))
+            hits.push({ status: 'compatible', reason: `Runtime ${runtime} supported` });
+        else
+            hits.push({ status: 'incompatible', reason: `Runtime ${runtime} not in ${compat.runtimes.join(', ')}` });
+    }
+    if (compat.packageManagers && compat.packageManagers.length > 0) {
+        if (compat.packageManagers.includes(pm))
+            hits.push({ status: 'compatible', reason: `Package manager ${pm} supported` });
+        else
+            hits.push({ status: 'warning', reason: `Package manager ${pm} not listed in ${compat.packageManagers.join(', ')}` });
+    }
+    if (compat.frameworks && compat.frameworks.length > 0) {
+        const overlap = profiles.filter((p) => compat.frameworks.includes(p));
+        if (overlap.length > 0)
+            hits.push({ status: 'compatible', reason: `Frameworks match: ${overlap.join(', ')}` });
+        else
+            hits.push({ status: 'warning', reason: `No detected profile matches ${compat.frameworks.join(', ')}` });
+    }
+    let overall = 'compatible';
+    if (hits.some((h) => h.status === 'incompatible'))
+        overall = 'incompatible';
+    else if (hits.some((h) => h.status === 'warning'))
+        overall = 'warning';
+    return {
+        schema: PACK_COMPATIBILITY_SCHEMA,
+        packageName: pack.packageName,
+        packageVersion: pack.packageVersion,
+        overall,
+        sharkcraftVersion,
+        runtime,
+        packageManager: pm,
+        workspaceProfiles: profiles,
+        hits,
+    };
+}
+export function checkAllPacksCompatibility(inspection) {
+    return inspection.packs.validPacks.map((p) => checkPackCompatibility(inspection, p));
+}

package/dist/pack-contributions-inventory.d.ts

@@ -0,0 +1,121 @@
+import type { ISharkcraftInspection } from './sharkcraft-inspector.js';
+export declare const PACK_CONTRIBUTIONS_INVENTORY_SCHEMA = "sharkcraft.pack-contributions-inventory/v1";
+export declare enum ContributionSource {
+    Builtin = "builtin",
+    Local = "local",
+    Pack = "pack",
+    Fixture = "fixture"
+}
+export declare enum ContributionKind {
+    Knowledge = "knowledge",
+    Rule = "rule",
+    Path = "path",
+    PathConvention = "path-convention",
+    Template = "template",
+    Pipeline = "pipeline",
+    Preset = "preset",
+    Boundary = "boundary",
+    ScaffoldPattern = "scaffold-pattern",
+    Policy = "policy",
+    Construct = "construct",
+    Playbook = "playbook",
+    SearchTuning = "search-tuning",
+    FeedbackRule = "feedback-rule",
+    Decision = "decision",
+    ContractTemplate = "contract-template",
+    MigrationProfile = "migration-profile",
+    PluginLifecycleProfile = "plugin-lifecycle-profile",
+    ContextTest = "context-test",
+    AgentTest = "agent-test",
+    Helper = "helper",
+    TaskRoutingHint = "task-routing-hint",
+    Convention = "convention",
+    Docs = "docs"
+}
+/**
+ * How the inventory derived this entry's id.
+ *   - `structural`     — authoritative ids from the loader for this kind.
+ *   - `regex-fallback` — id extracted by regex from the raw source file;
+ *                        nested `id:` fields may produce false positives.
+ *   - `file-only`      — file exists but no id could be extracted; entry
+ *                        represents the file itself, not a contribution id.
+ */
+export type ExtractionMode = 'structural' | 'regex-fallback' | 'file-only';
+export interface IContributionEntry {
+    readonly kind: ContributionKind;
+    readonly id: string;
+    readonly title?: string;
+    readonly source: ContributionSource;
+    readonly packageName?: string;
+    readonly sourceFile?: string;
+    readonly validation: 'ok' | 'warning' | 'error';
+    readonly validationMessage?: string;
+    readonly enabled?: boolean;
+    readonly references?: readonly string[];
+    /** Extraction provenance; informs conflict severity. */
+    readonly extractionMode?: ExtractionMode;
+    /** Low when extracted via regex fallback. */
+    readonly confidence?: 'high' | 'medium' | 'low';
+}
+export declare enum ConflictKind {
+    DuplicateIdSameKind = "duplicate-id-same-kind",
+    DuplicateIdDifferentSource = "duplicate-id-different-source",
+    ShadowedLocalConfig = "shadowed-local-config",
+    ShadowedPackConfig = "shadowed-pack-config",
+    InvalidContribution = "invalid-contribution",
+    MissingReferencedId = "missing-referenced-id",
+    StaleSignature = "stale-signature",
+    IncompatibleSchema = "incompatible-schema",
+    MissingLoader = "missing-loader"
+}
+export interface IContributionConflict {
+    readonly kind: ConflictKind;
+    readonly contributionKind: ContributionKind;
+    readonly id: string;
+    readonly sources: readonly {
+        source: ContributionSource;
+        packageName?: string;
+        sourceFile?: string;
+    }[];
+    readonly severity: 'info' | 'warning' | 'error';
+    readonly message: string;
+    readonly nextCommand?: string;
+}
+export interface IPackContributionsInventory {
+    readonly schema: typeof PACK_CONTRIBUTIONS_INVENTORY_SCHEMA;
+    readonly generatedAt: string;
+    readonly projectRoot: string;
+    readonly entriesByKind: Readonly<Record<string, readonly IContributionEntry[]>>;
+    readonly totals: Readonly<Record<string, number>>;
+    readonly entries: readonly IContributionEntry[];
+    readonly conflicts: readonly IContributionConflict[];
+    readonly packs: readonly {
+        name: string;
+        version: string;
+        root: string;
+        signaturePresent: boolean;
+    }[];
+}
+/**
+ * Build the inventory. Read-only. Never imports pack code beyond the
+ * registry loaders that already do.
+ *
+ * Structural-first extraction. For kinds with a dedicated loader, the
+ * inventory uses the loader's authoritative ids and **suppresses the
+ * regex fallback** for those same source files. This eliminates the
+ * nested-step-id false positives that previously produced duplicate /
+ * conflict noise.
+ */
+export declare function buildPackContributionsInventory(inspection: ISharkcraftInspection): IPackContributionsInventory;
+/**
+ * Async variant that loads structural per-kind entries first.
+ *
+ * Production callers should prefer this over the sync wrapper since it
+ * provides the noise-free output. The sync wrapper exists for backward
+ * compatibility with callers that haven't been awaited yet.
+ */
+export declare function buildPackContributionsInventoryAsync(inspection: ISharkcraftInspection): Promise<IPackContributionsInventory>;
+export declare function renderInventoryText(inv: IPackContributionsInventory): string;
+export declare function renderInventoryMarkdown(inv: IPackContributionsInventory): string;
+export declare function selectConflicts(inv: IPackContributionsInventory): readonly IContributionConflict[];
+//# sourceMappingURL=pack-contributions-inventory.d.ts.map

package/dist/pack-contributions-inventory.d.ts.map

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