@shrkcrft/presets 0.1.0-alpha.1

package/dist/registry/load-presets.js

@@ -0,0 +1,33 @@
+import { existsSync } from 'node:fs';
+import { safeImport } from '@shrkcrft/core';
+import { validatePreset } from "../model/preset.js";
+export async function loadPresetsFromFile(absPath, options = {}) {
+    const out = { source: absPath, presets: [], warnings: [] };
+    if (!existsSync(absPath)) {
+        out.warnings.push(`preset file not found: ${absPath}`);
+        return out;
+    }
+    const result = options.importContext
+        ? await options.importContext.load(absPath)
+        : await safeImport(absPath, { skipExistsCheck: true });
+    if (!result.ok) {
+        const label = result.timedOut ? 'timed out loading presets from' : 'failed to load presets from';
+        out.warnings.push(`${label} ${absPath}: ${result.error.message}`);
+        return out;
+    }
+    const candidates = pickArray(result.module.default) ?? pickArray(result.module.presets) ?? [];
+    for (const candidate of candidates) {
+        const v = validatePreset(candidate);
+        if (!v.valid) {
+            out.warnings.push(`${absPath}: skipping invalid preset (${v.issues.map((i) => i.field).join(', ')})`);
+            continue;
+        }
+        out.presets.push(candidate);
+    }
+    return out;
+}
+function pickArray(v) {
+    if (Array.isArray(v))
+        return v;
+    return null;
+}

package/dist/registry/preset-registry.d.ts

@@ -0,0 +1,11 @@
+import type { IPreset } from '../model/preset.js';
+export declare class PresetRegistry {
+    private readonly byId;
+    constructor(presets?: readonly IPreset[]);
+    add(preset: IPreset): void;
+    has(id: string): boolean;
+    get(id: string): IPreset | undefined;
+    list(): readonly IPreset[];
+    size(): number;
+}
+//# sourceMappingURL=preset-registry.d.ts.map

package/dist/registry/preset-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"preset-registry.d.ts","sourceRoot":"","sources":["../../src/registry/preset-registry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAElD,qBAAa,cAAc;IACzB,OAAO,CAAC,QAAQ,CAAC,IAAI,CAA8B;gBAEvC,OAAO,GAAE,SAAS,OAAO,EAAO;IAI5C,GAAG,CAAC,MAAM,EAAE,OAAO,GAAG,IAAI;IAI1B,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO;IAIxB,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,GAAG,SAAS;IAIpC,IAAI,IAAI,SAAS,OAAO,EAAE;IAI1B,IAAI,IAAI,MAAM;CAGf"}

package/dist/registry/preset-registry.js

@@ -0,0 +1,22 @@
+export class PresetRegistry {
+    byId = new Map();
+    constructor(presets = []) {
+        for (const p of presets)
+            this.add(p);
+    }
+    add(preset) {
+        this.byId.set(preset.id, preset);
+    }
+    has(id) {
+        return this.byId.has(id);
+    }
+    get(id) {
+        return this.byId.get(id);
+    }
+    list() {
+        return [...this.byId.values()];
+    }
+    size() {
+        return this.byId.size;
+    }
+}

package/dist/registry/recommend.d.ts

@@ -0,0 +1,30 @@
+import type { WorkspaceProfile } from '@shrkcrft/workspace';
+import type { IPreset } from '../model/preset.js';
+export interface IPresetRecommendation {
+    preset: IPreset;
+    score: number;
+    confidence: 'high' | 'medium' | 'low';
+    reasons: string[];
+}
+export interface IRecommendOptions {
+    profiles: readonly WorkspaceProfile[];
+    /** Optional list of preset ids to exclude (e.g. already applied). */
+    exclude?: readonly string[];
+    /** Max number of recommendations. Default: 5. */
+    limit?: number;
+}
+/**
+ * Rank presets against detected workspace profiles. Pure function:
+ *  - +5 for each profile in appliesTo that is present
+ *  - −3 for each profile in appliesTo that is missing
+ *    (so a preset that lists `[HasNext, HasReact, IsFrontend]` does
+ *    not outrank `[HasReact, IsFrontend]` on a pure-React repo just
+ *    because of its base weight). The penalty is intentionally
+ *    smaller than the +5 match so a partial match still beats no
+ *    match.
+ *  - −5 per profile in notAppropriateFor that is present (drops the
+ *    preset entirely)
+ *  - +base weight (default 5) to break ties
+ */
+export declare function recommendPresets(presets: readonly IPreset[], options: IRecommendOptions): IPresetRecommendation[];
+//# sourceMappingURL=recommend.d.ts.map

package/dist/registry/recommend.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"recommend.d.ts","sourceRoot":"","sources":["../../src/registry/recommend.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAC5D,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAElD,MAAM,WAAW,qBAAqB;IACpC,MAAM,EAAE,OAAO,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,GAAG,QAAQ,GAAG,KAAK,CAAC;IACtC,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB;AAED,MAAM,WAAW,iBAAiB;IAChC,QAAQ,EAAE,SAAS,gBAAgB,EAAE,CAAC;IACtC,qEAAqE;IACrE,OAAO,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC5B,iDAAiD;IACjD,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,SAAS,OAAO,EAAE,EAC3B,OAAO,EAAE,iBAAiB,GACzB,qBAAqB,EAAE,CA2CzB"}

package/dist/registry/recommend.js

@@ -0,0 +1,59 @@
+/**
+ * Rank presets against detected workspace profiles. Pure function:
+ *  - +5 for each profile in appliesTo that is present
+ *  - −3 for each profile in appliesTo that is missing
+ *    (so a preset that lists `[HasNext, HasReact, IsFrontend]` does
+ *    not outrank `[HasReact, IsFrontend]` on a pure-React repo just
+ *    because of its base weight). The penalty is intentionally
+ *    smaller than the +5 match so a partial match still beats no
+ *    match.
+ *  - −5 per profile in notAppropriateFor that is present (drops the
+ *    preset entirely)
+ *  - +base weight (default 5) to break ties
+ */
+export function recommendPresets(presets, options) {
+    const profileSet = new Set(options.profiles);
+    const exclude = new Set(options.exclude ?? []);
+    const out = [];
+    for (const preset of presets) {
+        if (exclude.has(preset.id))
+            continue;
+        const reasons = [];
+        let score = preset.weight ?? 5;
+        let dq = false;
+        let matchedCount = 0;
+        for (const need of preset.appliesTo ?? []) {
+            if (profileSet.has(need)) {
+                score += 5;
+                matchedCount += 1;
+                reasons.push(`matches profile: ${need}`);
+            }
+            else {
+                // Small miss penalty so longer / more-specific appliesTo
+                // lists do not falsely dominate shorter, more-targeted ones.
+                score -= 3;
+                reasons.push(`missing profile: ${need}`);
+            }
+        }
+        for (const block of preset.notAppropriateFor ?? []) {
+            if (profileSet.has(block)) {
+                score -= 5;
+                reasons.push(`not appropriate (profile: ${block})`);
+                dq = true;
+            }
+        }
+        if (dq)
+            continue;
+        if ((preset.appliesTo?.length ?? 0) === 0 && reasons.length === 0) {
+            reasons.push('universal preset');
+        }
+        const confidence = score >= 15 ? 'high' : score >= 9 ? 'medium' : 'low';
+        out.push({ preset, score, confidence, reasons });
+        // matchedCount is reserved for future tie-breaking; surface in reasons
+        // for now so the explanation captures it.
+        void matchedCount;
+    }
+    out.sort((a, b) => b.score - a.score);
+    const limit = options.limit ?? 5;
+    return out.slice(0, limit);
+}

package/dist/registry/resolve-preset.d.ts

@@ -0,0 +1,75 @@
+import type { IPreset, IPresetFile, IPresetIncludes } from '../model/preset.js';
+import type { PresetRegistry } from './preset-registry.js';
+export interface IResolvedPresetIssue {
+    severity: 'error' | 'warning';
+    code: 'composition-cycle' | 'composed-not-found' | 'invalid-self-compose';
+    message: string;
+    presetId: string;
+}
+export interface IProvenanceEntry {
+    /** The id of the preset that contributed this item. */
+    presetId: string;
+    /** Path through the composition graph: root → … → contributor. */
+    chain: readonly string[];
+}
+/**
+ * A flattened preset with composition resolved. Arrays are merged, deduped,
+ * and provenance is recorded so callers can show "this entry came from
+ * preset X via composition through Y".
+ */
+export interface IResolvedPreset {
+    /** The root preset id that was requested. */
+    rootId: string;
+    /** Every preset id visited, in resolution order (root first, deepest last). */
+    composedFrom: readonly string[];
+    /** Final merged metadata (title/description/tags/etc. come from the root). */
+    preset: IPreset;
+    /** Merged includes block; arrays deduplicated. */
+    includes: IPresetIncludes & {
+        knowledgeIds?: readonly string[];
+        ruleIds?: readonly string[];
+        pathConventionIds?: readonly string[];
+        templateIds?: readonly string[];
+        pipelineIds?: readonly string[];
+        knowledge?: readonly string[];
+        rules?: readonly string[];
+        paths?: readonly string[];
+        templates?: readonly string[];
+        pipelines?: readonly string[];
+    };
+    /** Files to create — local preset wins on path conflict. */
+    filesToCreate: readonly IPresetFile[];
+    /** Merged recommendedNextCommands (deduped, root order preserved). */
+    recommendedNextCommands: readonly string[];
+    /** Merged postInstallNotes. */
+    postInstallNotes: readonly string[];
+    /** Merged safetyNotes. */
+    safetyNotes: readonly string[];
+    /** Per-item provenance for arrays. */
+    provenance: {
+        knowledge: ReadonlyMap<string, IProvenanceEntry>;
+        rules: ReadonlyMap<string, IProvenanceEntry>;
+        paths: ReadonlyMap<string, IProvenanceEntry>;
+        templates: ReadonlyMap<string, IProvenanceEntry>;
+        pipelines: ReadonlyMap<string, IProvenanceEntry>;
+        knowledgeIds: ReadonlyMap<string, IProvenanceEntry>;
+        ruleIds: ReadonlyMap<string, IProvenanceEntry>;
+        pathConventionIds: ReadonlyMap<string, IProvenanceEntry>;
+        templateIds: ReadonlyMap<string, IProvenanceEntry>;
+        pipelineIds: ReadonlyMap<string, IProvenanceEntry>;
+        files: ReadonlyMap<string, IProvenanceEntry>;
+    };
+    issues: readonly IResolvedPresetIssue[];
+}
+/**
+ * Resolve a preset by id, recursively expanding `composes`. Returns:
+ *  - the merged preset shape (with provenance per array entry),
+ *  - a list of issues (cycle, missing-composed, …).
+ *
+ * Resolution order: the **root** preset's local items come first, then each
+ * composed preset's items are appended depth-first (post-order). "First
+ * contributor wins" — so the root naturally overrides composed presets on
+ * duplicate ids.
+ */
+export declare function resolvePreset(registry: PresetRegistry, rootId: string): IResolvedPreset;
+//# sourceMappingURL=resolve-preset.d.ts.map

package/dist/registry/resolve-preset.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve-preset.d.ts","sourceRoot":"","sources":["../../src/registry/resolve-preset.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,WAAW,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAChF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAE3D,MAAM,WAAW,oBAAoB;IACnC,QAAQ,EAAE,OAAO,GAAG,SAAS,CAAC;IAC9B,IAAI,EACA,mBAAmB,GACnB,oBAAoB,GACpB,sBAAsB,CAAC;IAC3B,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,gBAAgB;IAC/B,uDAAuD;IACvD,QAAQ,EAAE,MAAM,CAAC;IACjB,kEAAkE;IAClE,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;CAC1B;AAED;;;;GAIG;AACH,MAAM,WAAW,eAAe;IAC9B,6CAA6C;IAC7C,MAAM,EAAE,MAAM,CAAC;IACf,+EAA+E;IAC/E,YAAY,EAAE,SAAS,MAAM,EAAE,CAAC;IAChC,8EAA8E;IAC9E,MAAM,EAAE,OAAO,CAAC;IAChB,kDAAkD;IAClD,QAAQ,EAAE,eAAe,GAAG;QAC1B,YAAY,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;QACjC,OAAO,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;QAC5B,iBAAiB,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;QACtC,WAAW,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;QAChC,WAAW,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;QAChC,SAAS,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;QAC9B,KAAK,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;QAC1B,KAAK,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;QAC1B,SAAS,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;QAC9B,SAAS,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;KAC/B,CAAC;IACF,4DAA4D;IAC5D,aAAa,EAAE,SAAS,WAAW,EAAE,CAAC;IACtC,sEAAsE;IACtE,uBAAuB,EAAE,SAAS,MAAM,EAAE,CAAC;IAC3C,+BAA+B;IAC/B,gBAAgB,EAAE,SAAS,MAAM,EAAE,CAAC;IACpC,0BAA0B;IAC1B,WAAW,EAAE,SAAS,MAAM,EAAE,CAAC;IAC/B,sCAAsC;IACtC,UAAU,EAAE;QACV,SAAS,EAAE,WAAW,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC;QACjD,KAAK,EAAE,WAAW,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC;QAC7C,KAAK,EAAE,WAAW,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC;QAC7C,SAAS,EAAE,WAAW,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC;QACjD,SAAS,EAAE,WAAW,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC;QACjD,YAAY,EAAE,WAAW,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC;QACpD,OAAO,EAAE,WAAW,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC;QAC/C,iBAAiB,EAAE,WAAW,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC;QACzD,WAAW,EAAE,WAAW,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC;QACnD,WAAW,EAAE,WAAW,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC;QACnD,KAAK,EAAE,WAAW,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC;KAC9C,CAAC;IACF,MAAM,EAAE,SAAS,oBAAoB,EAAE,CAAC;CACzC;AAoDD;;;;;;;;;GASG;AACH,wBAAgB,aAAa,CAC3B,QAAQ,EAAE,cAAc,EACxB,MAAM,EAAE,MAAM,GACb,eAAe,CAqLjB"}

package/dist/registry/resolve-preset.js

@@ -0,0 +1,207 @@
+/** Stable-key for a TS-source array item: the slug between `id:` and the next `,`. */
+function snippetKey(snippet, fallback) {
+    const m = snippet.match(/id:\s*['"`]([^'"`]+)['"`]/);
+    return m?.[1] ?? fallback;
+}
+function recordWithProvenance(items, bucket, prov, chain, presetId) {
+    if (!items)
+        return;
+    for (let i = 0; i < items.length; i += 1) {
+        const value = items[i];
+        const key = snippetKey(value, `${presetId}:${i}`);
+        if (prov.has(key))
+            continue; // first contributor wins (root → composed depth-first)
+        bucket.push(value);
+        prov.set(key, { presetId, chain });
+    }
+}
+function recordIds(items, bucket, prov, chain, presetId) {
+    if (!items)
+        return;
+    for (const id of items) {
+        if (prov.has(id))
+            continue;
+        bucket.push(id);
+        prov.set(id, { presetId, chain });
+    }
+}
+function recordKvMap(v, out) {
+    if (!v)
+        return;
+    const it = v instanceof Map ? v.entries() : Object.entries(v);
+    for (const [k, val] of it) {
+        if (out.has(k))
+            continue;
+        out.set(k, val);
+    }
+}
+/**
+ * Resolve a preset by id, recursively expanding `composes`. Returns:
+ *  - the merged preset shape (with provenance per array entry),
+ *  - a list of issues (cycle, missing-composed, …).
+ *
+ * Resolution order: the **root** preset's local items come first, then each
+ * composed preset's items are appended depth-first (post-order). "First
+ * contributor wins" — so the root naturally overrides composed presets on
+ * duplicate ids.
+ */
+export function resolvePreset(registry, rootId) {
+    const root = registry.get(rootId);
+    if (!root) {
+        throw new Error(`Cannot resolve preset "${rootId}" — not found in registry.`);
+    }
+    const issues = [];
+    const composedFrom = [];
+    const visited = new Set();
+    // Accumulators.
+    const knowledge = [];
+    const rules = [];
+    const paths = [];
+    const templates = [];
+    const pipelines = [];
+    const knowledgeIds = [];
+    const ruleIds = [];
+    const pathConventionIds = [];
+    const templateIds = [];
+    const pipelineIds = [];
+    const docsMap = new Map();
+    const tasksMap = new Map();
+    const filePaths = new Map();
+    const provFiles = new Map();
+    const provKnowledge = new Map();
+    const provRules = new Map();
+    const provPaths = new Map();
+    const provTemplates = new Map();
+    const provPipelines = new Map();
+    const provKnowledgeIds = new Map();
+    const provRuleIds = new Map();
+    const provPathConventionIds = new Map();
+    const provTemplateIds = new Map();
+    const provPipelineIds = new Map();
+    const recommendedNextCommands = [];
+    const seenCommands = new Set();
+    const postInstallNotes = [];
+    const seenNotes = new Set();
+    const safetyNotes = [];
+    const seenSafety = new Set();
+    function visit(presetId, chain) {
+        // Cycle check FIRST — otherwise the visited-cache below would silently
+        // swallow a back-edge cycle (e.g. a → b → a) and we'd never report it.
+        if (chain.includes(presetId)) {
+            issues.push({
+                severity: 'error',
+                code: 'composition-cycle',
+                message: `Cycle detected: ${[...chain, presetId].join(' → ')}`,
+                presetId,
+            });
+            return;
+        }
+        if (visited.has(presetId))
+            return;
+        if (presetId === rootId && chain.length > 0) {
+            issues.push({
+                severity: 'error',
+                code: 'invalid-self-compose',
+                message: `Preset "${presetId}" composes itself`,
+                presetId,
+            });
+            return;
+        }
+        const preset = registry.get(presetId);
+        if (!preset) {
+            issues.push({
+                severity: 'error',
+                code: 'composed-not-found',
+                message: `Preset "${chain[chain.length - 1] ?? rootId}" composes unknown preset "${presetId}"`,
+                presetId,
+            });
+            return;
+        }
+        visited.add(presetId);
+        composedFrom.push(presetId);
+        // First: visit composed presets so the root keeps "first contributor wins"
+        // priority over composed entries. We do this by recording the ROOT's
+        // contributions before recursing. Composed presets append after.
+        const includes = preset.includes;
+        recordWithProvenance(includes.knowledge, knowledge, provKnowledge, chain, presetId);
+        recordWithProvenance(includes.rules, rules, provRules, chain, presetId);
+        recordWithProvenance(includes.paths, paths, provPaths, chain, presetId);
+        recordWithProvenance(includes.templates, templates, provTemplates, chain, presetId);
+        recordWithProvenance(includes.pipelines, pipelines, provPipelines, chain, presetId);
+        recordIds(includes.knowledgeIds, knowledgeIds, provKnowledgeIds, chain, presetId);
+        recordIds(includes.ruleIds, ruleIds, provRuleIds, chain, presetId);
+        recordIds(includes.pathConventionIds, pathConventionIds, provPathConventionIds, chain, presetId);
+        recordIds(includes.templateIds, templateIds, provTemplateIds, chain, presetId);
+        recordIds(includes.pipelineIds, pipelineIds, provPipelineIds, chain, presetId);
+        recordKvMap(includes.docs, docsMap);
+        recordKvMap(includes.tasks, tasksMap);
+        for (const f of preset.filesToCreate ?? []) {
+            if (!filePaths.has(f.path)) {
+                filePaths.set(f.path, f);
+                provFiles.set(f.path, { presetId, chain });
+            }
+        }
+        for (const cmd of preset.recommendedNextCommands ?? []) {
+            if (seenCommands.has(cmd))
+                continue;
+            seenCommands.add(cmd);
+            recommendedNextCommands.push(cmd);
+        }
+        for (const note of preset.postInstallNotes ?? []) {
+            if (seenNotes.has(note))
+                continue;
+            seenNotes.add(note);
+            postInstallNotes.push(note);
+        }
+        for (const sn of preset.safetyNotes ?? []) {
+            if (seenSafety.has(sn))
+                continue;
+            seenSafety.add(sn);
+            safetyNotes.push(sn);
+        }
+        // Recurse into composed presets.
+        const nextChain = [...chain, presetId];
+        for (const dep of preset.composes ?? []) {
+            visit(dep, nextChain);
+        }
+    }
+    visit(rootId, []);
+    const resolvedIncludes = {
+        ...(knowledge.length ? { knowledge } : {}),
+        ...(rules.length ? { rules } : {}),
+        ...(paths.length ? { paths } : {}),
+        ...(templates.length ? { templates } : {}),
+        ...(pipelines.length ? { pipelines } : {}),
+        ...(knowledgeIds.length ? { knowledgeIds } : {}),
+        ...(ruleIds.length ? { ruleIds } : {}),
+        ...(pathConventionIds.length ? { pathConventionIds } : {}),
+        ...(templateIds.length ? { templateIds } : {}),
+        ...(pipelineIds.length ? { pipelineIds } : {}),
+        ...(docsMap.size ? { docs: docsMap } : {}),
+        ...(tasksMap.size ? { tasks: tasksMap } : {}),
+    };
+    return {
+        rootId,
+        composedFrom,
+        preset: root,
+        includes: resolvedIncludes,
+        filesToCreate: [...filePaths.values()],
+        recommendedNextCommands,
+        postInstallNotes,
+        safetyNotes,
+        provenance: {
+            knowledge: provKnowledge,
+            rules: provRules,
+            paths: provPaths,
+            templates: provTemplates,
+            pipelines: provPipelines,
+            knowledgeIds: provKnowledgeIds,
+            ruleIds: provRuleIds,
+            pathConventionIds: provPathConventionIds,
+            templateIds: provTemplateIds,
+            pipelineIds: provPipelineIds,
+            files: provFiles,
+        },
+        issues,
+    };
+}

package/dist/registry/resolve-references.d.ts

@@ -0,0 +1,49 @@
+import type { IResolvedPreset } from './resolve-preset.js';
+/**
+ * The minimal shape the reference-resolver needs from the inspection. This
+ * lets the presets package stay independent of @shrkcrft/inspector at the
+ * type level.
+ */
+export interface IReferenceLookup {
+    hasKnowledge(id: string): boolean;
+    hasRule(id: string): boolean;
+    hasPath(id: string): boolean;
+    hasTemplate(id: string): boolean;
+    hasPipeline(id: string): boolean;
+}
+export interface IReferenceMissing {
+    kind: 'knowledge' | 'rule' | 'path' | 'template' | 'pipeline';
+    id: string;
+}
+export interface IResolvedReferences {
+    knowledge: {
+        resolved: string[];
+        missing: string[];
+    };
+    rules: {
+        resolved: string[];
+        missing: string[];
+    };
+    paths: {
+        resolved: string[];
+        missing: string[];
+    };
+    templates: {
+        resolved: string[];
+        missing: string[];
+    };
+    pipelines: {
+        resolved: string[];
+        missing: string[];
+    };
+    /** Flat list of every missing reference for convenience. */
+    missing: readonly IReferenceMissing[];
+    totalReferenced: number;
+    totalMissing: number;
+}
+/**
+ * Resolve the *Ids fields on a resolved preset against the inspection's
+ * registries. Returns which references exist and which are missing.
+ */
+export declare function resolvePresetReferences(resolved: IResolvedPreset, lookup: IReferenceLookup): IResolvedReferences;
+//# sourceMappingURL=resolve-references.d.ts.map

package/dist/registry/resolve-references.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve-references.d.ts","sourceRoot":"","sources":["../../src/registry/resolve-references.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAE3D;;;;GAIG;AACH,MAAM,WAAW,gBAAgB;IAC/B,YAAY,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC;IAClC,OAAO,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC;IAC7B,OAAO,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC;IAC7B,WAAW,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC;IACjC,WAAW,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC;CAClC;AAED,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,WAAW,GAAG,MAAM,GAAG,MAAM,GAAG,UAAU,GAAG,UAAU,CAAC;IAC9D,EAAE,EAAE,MAAM,CAAC;CACZ;AAED,MAAM,WAAW,mBAAmB;IAClC,SAAS,EAAE;QAAE,QAAQ,EAAE,MAAM,EAAE,CAAC;QAAC,OAAO,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC;IACrD,KAAK,EAAE;QAAE,QAAQ,EAAE,MAAM,EAAE,CAAC;QAAC,OAAO,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC;IACjD,KAAK,EAAE;QAAE,QAAQ,EAAE,MAAM,EAAE,CAAC;QAAC,OAAO,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC;IACjD,SAAS,EAAE;QAAE,QAAQ,EAAE,MAAM,EAAE,CAAC;QAAC,OAAO,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC;IACrD,SAAS,EAAE;QAAE,QAAQ,EAAE,MAAM,EAAE,CAAC;QAAC,OAAO,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC;IACrD,4DAA4D;IAC5D,OAAO,EAAE,SAAS,iBAAiB,EAAE,CAAC;IACtC,eAAe,EAAE,MAAM,CAAC;IACxB,YAAY,EAAE,MAAM,CAAC;CACtB;AAED;;;GAGG;AACH,wBAAgB,uBAAuB,CACrC,QAAQ,EAAE,eAAe,EACzB,MAAM,EAAE,gBAAgB,GACvB,mBAAmB,CAoCrB"}

package/dist/registry/resolve-references.js

@@ -0,0 +1,38 @@
+/**
+ * Resolve the *Ids fields on a resolved preset against the inspection's
+ * registries. Returns which references exist and which are missing.
+ */
+export function resolvePresetReferences(resolved, lookup) {
+    const inc = resolved.includes;
+    const out = {
+        knowledge: { resolved: [], missing: [] },
+        rules: { resolved: [], missing: [] },
+        paths: { resolved: [], missing: [] },
+        templates: { resolved: [], missing: [] },
+        pipelines: { resolved: [], missing: [] },
+        missing: [],
+        totalReferenced: 0,
+        totalMissing: 0,
+    };
+    function check(ids, bucket, kind, has) {
+        if (!ids)
+            return;
+        for (const id of ids) {
+            out.totalReferenced += 1;
+            if (has(id)) {
+                bucket.resolved.push(id);
+            }
+            else {
+                bucket.missing.push(id);
+                out.missing.push({ kind, id });
+                out.totalMissing += 1;
+            }
+        }
+    }
+    check(inc.knowledgeIds, out.knowledge, 'knowledge', (id) => lookup.hasKnowledge(id));
+    check(inc.ruleIds, out.rules, 'rule', (id) => lookup.hasRule(id));
+    check(inc.pathConventionIds, out.paths, 'path', (id) => lookup.hasPath(id));
+    check(inc.templateIds, out.templates, 'template', (id) => lookup.hasTemplate(id));
+    check(inc.pipelineIds, out.pipelines, 'pipeline', (id) => lookup.hasPipeline(id));
+    return out;
+}

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@shrkcrft/presets",
+  "version": "0.1.0-alpha.1",
+  "description": "SharkCraft presets: reusable project setups (knowledge/rules/paths/templates/pipelines/docs) that can be applied to a target repo through the CLI.",
+  "license": "MIT",
+  "author": "SharkCraft contributors",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/sharkcraft/sharkcraft.git",
+    "directory": "packages/presets"
+  },
+  "homepage": "https://github.com/sharkcraft/sharkcraft",
+  "bugs": {
+    "url": "https://github.com/sharkcraft/sharkcraft/issues"
+  },
+  "keywords": [
+    "sharkcraft",
+    "presets",
+    "ai-agent"
+  ],
+  "engines": {
+    "bun": ">=1.1.0",
+    "node": ">=18"
+  },
+  "scripts": {
+    "typecheck": "tsc --noEmit -p tsconfig.json"
+  },
+  "dependencies": {
+    "@shrkcrft/core": "^0.1.0-alpha.1",
+    "@shrkcrft/knowledge": "^0.1.0-alpha.1",
+    "@shrkcrft/workspace": "^0.1.0-alpha.1"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}