@shahmarasy/prodo 0.1.5 → 0.1.7

package/dist/i18n/tr.json

@@ -1,45 +1,45 @@
-{
-  "user_action": "Kullanıcı işlemi",
-  "main_flow": "Ana Akış",
-  "user": "Kullanıcı",
-  "success": "Başarı",
-  "error": "Hata",
-  "flow_focus": "Akış Odağı",
-  "initial_version": "İlk sürüm",
-  "fix_revision": "Doğrulama sonrası düzeltme revizyonu",
-  "primary_user": "Birincil kullanıcı",
-  "back": "Geri",
-  "next": "Devam",
-  "save": "Kaydet",
-  "content": "İçerik",
-  "primary_info_area": "Birincil bilgi alanı",
-  "status_indicator": "Durum göstergesi",
-  "form": "Form",
-  "field": "Alan",
-  "description": "Açıklama",
-  "contract": "Kontrat",
-  "actor": "Aktör",
-  "detailed_input_area": "Detaylı Giriş Alanı",
-  "upload_area": "Dosya Alanı",
-  "low_fidelity_wireframe": "Düşük sadakatli wireframe.",
-  "confirmation_text": "Onay metni",
-  "header_and_navigation": "Başlık ve gezinme",
-  "content_section": "İçerik bölümü",
-  "form_section": "Form bölümü",
-  "text_input": "Metin alanı",
-  "to_be_refined": "Detay daha sonra netleştirilecek.",
-  "note": "Not",
-  "requirement_item": "Gereksinim maddesi",
-  "contract_coverage": "Kontrat kapsamı",
-  "screen": "Ekran",
-  "for_artifact": "için",
-  "fix_proposal": "Düzeltme Önerisi",
-  "fix_complete": "Düzeltme tamamlandı — doğrulama geçti.",
-  "fix_still_failing": "Düzeltme uygulandı ama doğrulama hâlâ başarısız.",
-  "fix_cancelled": "Düzeltme iptal edildi.",
-  "no_issues": "Engel teşkil eden sorun bulunamadı. Düzeltilecek bir şey yok.",
-  "issues_found": "Bulunan sorunlar",
-  "artifacts_to_regenerate": "Yeniden oluşturulacak artefaktlar",
-  "general": "Genel",
-  "suggestion_prefix": "→"
-}
+{
+  "user_action": "Kullanıcı işlemi",
+  "main_flow": "Ana Akış",
+  "user": "Kullanıcı",
+  "success": "Başarı",
+  "error": "Hata",
+  "flow_focus": "Akış Odağı",
+  "initial_version": "İlk sürüm",
+  "fix_revision": "Doğrulama sonrası düzeltme revizyonu",
+  "primary_user": "Birincil kullanıcı",
+  "back": "Geri",
+  "next": "Devam",
+  "save": "Kaydet",
+  "content": "İçerik",
+  "primary_info_area": "Birincil bilgi alanı",
+  "status_indicator": "Durum göstergesi",
+  "form": "Form",
+  "field": "Alan",
+  "description": "Açıklama",
+  "contract": "Kontrat",
+  "actor": "Aktör",
+  "detailed_input_area": "Detaylı Giriş Alanı",
+  "upload_area": "Dosya Alanı",
+  "low_fidelity_wireframe": "Düşük sadakatli wireframe.",
+  "confirmation_text": "Onay metni",
+  "header_and_navigation": "Başlık ve gezinme",
+  "content_section": "İçerik bölümü",
+  "form_section": "Form bölümü",
+  "text_input": "Metin alanı",
+  "to_be_refined": "Detay daha sonra netleştirilecek.",
+  "note": "Not",
+  "requirement_item": "Gereksinim maddesi",
+  "contract_coverage": "Kontrat kapsamı",
+  "screen": "Ekran",
+  "for_artifact": "için",
+  "fix_proposal": "Düzeltme Önerisi",
+  "fix_complete": "Düzeltme tamamlandı — doğrulama geçti.",
+  "fix_still_failing": "Düzeltme uygulandı ama doğrulama hâlâ başarısız.",
+  "fix_cancelled": "Düzeltme iptal edildi.",
+  "no_issues": "Engel teşkil eden sorun bulunamadı. Düzeltilecek bir şey yok.",
+  "issues_found": "Bulunan sorunlar",
+  "artifacts_to_regenerate": "Yeniden oluşturulacak artefaktlar",
+  "general": "Genel",
+  "suggestion_prefix": "→"
+}

package/dist/providers/mock-provider.js

@@ -121,11 +121,11 @@ function buildArtifactBody(schemaHint, inputContext) {
         ? `# ${productName} ${(0, i18n_1.t)("for_artifact", lang)} ${schemaHint.artifactType.toUpperCase()}`
         : `# ${schemaHint.artifactType.toUpperCase()} ${(0, i18n_1.t)("for_artifact", lang)} ${productName}`;
     if (schemaHint.artifactType === "workflow") {
-        return `${title}\n\n${sections.join("\n")}\n\n\`\`\`mermaid
-flowchart TD
-  A[Start] --> B[[F1] User Action]
-  B --> C[System Step]
-  C --> D[Done]
+        return `${title}\n\n${sections.join("\n")}\n\n\`\`\`mermaid
+flowchart TD
+  A[Start] --> B[[F1] User Action]
+  B --> C[System Step]
+  C --> D[Done]
 \`\`\``.trim();
     }
     return `${title}\n\n${sections.join("\n")}\n\n${(0, i18n_1.t)("note", lang)}: ${fallback}`.trim();

package/dist/providers/openai-provider.js

@@ -21,23 +21,23 @@ class OpenAIProvider {
             : "en";
         const mode = schemaHint.artifactType;
         const system = mode === "normalize"
-            ? `You normalize messy human product briefs into strict JSON.
-Return valid JSON only, no markdown. Include confidence scores (0..1) for critical fields.
+            ? `You normalize messy human product briefs into strict JSON.
+Return valid JSON only, no markdown. Include confidence scores (0..1) for critical fields.
 Preserve source language and Unicode characters exactly; never transliterate Turkish letters to ASCII.`
             : mode === "semantic_consistency"
-                ? `You detect semantic inconsistencies between paired artifacts.
+                ? `You detect semantic inconsistencies between paired artifacts.
 Return valid JSON only: { "issues": [{level, code, check, contract_id, file, message, suggestion}] }.`
                 : mode === "contract_relevance"
-                    ? `You verify whether tagged content actually matches the referenced contract text.
+                    ? `You verify whether tagged content actually matches the referenced contract text.
 Return valid JSON only: { "relevant": boolean, "score": number, "reason": string }.`
-                    : `You are a product-document generator.
-Return only Markdown body content.
-Headings required:
-${schemaHint.requiredHeadings.join("\n")}
-Required contract tags:
-${schemaHint.requiredContracts.join(", ")}
-Use tags like [G1], [F2], [C1] where relevant.
-Output language: ${outputLanguage}
+                    : `You are a product-document generator.
+Return only Markdown body content.
+Headings required:
+${schemaHint.requiredHeadings.join("\n")}
+Required contract tags:
+${schemaHint.requiredContracts.join(", ")}
+Use tags like [G1], [F2], [C1] where relevant.
+Output language: ${outputLanguage}
 Do not translate required headings.`;
         const user = `${prompt}\n\nContext JSON:\n${JSON.stringify(inputContext, null, 2)}`;
         const response = await fetch(`${this.baseUrl}/chat/completions`, {

package/dist/skill-engine/context.d.ts

@@ -0,0 +1,7 @@
+import type { ArtifactType } from "../core/types";
+import type { PipelineState } from "./types";
+export declare function createPipelineState(cwd: string): PipelineState;
+export declare function hydrateStateFromDisk(cwd: string, state: PipelineState, artifactTypes: ArtifactType[]): Promise<void>;
+export declare function isOutputSatisfied(outputName: string, state: PipelineState, artifactType?: string): boolean;
+export declare function wireInputsFromState(inputNames: string[], state: PipelineState): Record<string, unknown>;
+export declare function wireOutputsToState(outputs: Record<string, unknown>, state: PipelineState, skillName: string): void;

package/dist/skill-engine/context.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPipelineState = createPipelineState;
+exports.hydrateStateFromDisk = hydrateStateFromDisk;
+exports.isOutputSatisfied = isOutputSatisfied;
+exports.wireInputsFromState = wireInputsFromState;
+exports.wireOutputsToState = wireOutputsToState;
+const paths_1 = require("../core/paths");
+const output_index_1 = require("../core/output-index");
+const utils_1 = require("../core/utils");
+function createPipelineState(cwd) {
+    return {
+        cwd,
+        normalizedBriefPath: undefined,
+        generatedArtifacts: new Map(),
+        validationResult: undefined,
+        custom: {},
+        startedAt: new Date().toISOString(),
+        completedSkills: []
+    };
+}
+async function hydrateStateFromDisk(cwd, state, artifactTypes) {
+    const nbPath = (0, paths_1.normalizedBriefPath)(cwd);
+    if (!state.normalizedBriefPath && (await (0, utils_1.fileExists)(nbPath))) {
+        state.normalizedBriefPath = nbPath;
+    }
+    for (const type of artifactTypes) {
+        if (!state.generatedArtifacts.has(type)) {
+            const active = await (0, output_index_1.getActiveArtifactPath)(cwd, type);
+            if (active) {
+                state.generatedArtifacts.set(type, active);
+            }
+        }
+    }
+}
+function isOutputSatisfied(outputName, state, artifactType) {
+    if (outputName === "normalizedBriefPath") {
+        return typeof state.normalizedBriefPath === "string" && state.normalizedBriefPath.length > 0;
+    }
+    if (outputName === "artifactPath" && artifactType) {
+        return state.generatedArtifacts.has(artifactType);
+    }
+    if (outputName === "validationResult") {
+        return state.validationResult !== undefined;
+    }
+    return false;
+}
+function wireInputsFromState(inputNames, state) {
+    const inputs = {};
+    for (const name of inputNames) {
+        if (name === "cwd")
+            inputs.cwd = state.cwd;
+        else if (name === "normalizedBriefPath")
+            inputs.normalizedBriefPath = state.normalizedBriefPath;
+        else if (name in state.custom)
+            inputs[name] = state.custom[name];
+    }
+    return inputs;
+}
+function wireOutputsToState(outputs, state, skillName) {
+    if ("normalizedBriefPath" in outputs && typeof outputs.normalizedBriefPath === "string") {
+        state.normalizedBriefPath = outputs.normalizedBriefPath;
+    }
+    if ("artifactPath" in outputs && typeof outputs.artifactPath === "string") {
+        const artifactType = skillName;
+        state.generatedArtifacts.set(artifactType, outputs.artifactPath);
+    }
+    if ("validationResult" in outputs && outputs.validationResult && typeof outputs.validationResult === "object") {
+        state.validationResult = outputs.validationResult;
+    }
+    for (const [key, value] of Object.entries(outputs)) {
+        if (!["normalizedBriefPath", "artifactPath", "validationResult"].includes(key)) {
+            state.custom[key] = value;
+        }
+    }
+}

package/dist/skill-engine/discovery.d.ts

@@ -0,0 +1,2 @@
+import type { Skill } from "./types";
+export declare function discoverSkills(cwd: string, log?: (message: string) => void): Promise<Skill[]>;

package/dist/skill-engine/discovery.js

@@ -0,0 +1,52 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.discoverSkills = discoverSkills;
+const promises_1 = __importDefault(require("node:fs/promises"));
+const node_path_1 = __importDefault(require("node:path"));
+const paths_1 = require("../core/paths");
+const utils_1 = require("../core/utils");
+function isValidManifest(obj) {
+    if (!obj || typeof obj !== "object")
+        return false;
+    const m = obj;
+    return (typeof m.name === "string" &&
+        typeof m.version === "string" &&
+        typeof m.description === "string" &&
+        Array.isArray(m.depends_on) &&
+        Array.isArray(m.inputs) &&
+        Array.isArray(m.outputs));
+}
+async function discoverSkills(cwd, log) {
+    const skillsDir = node_path_1.default.join((0, paths_1.prodoPath)(cwd), "skills");
+    if (!(await (0, utils_1.fileExists)(skillsDir)))
+        return [];
+    const entries = await promises_1.default.readdir(skillsDir);
+    const jsFiles = entries.filter((e) => e.endsWith(".js"));
+    const skills = [];
+    for (const file of jsFiles) {
+        const fullPath = node_path_1.default.resolve(skillsDir, file);
+        try {
+            const mod = require(fullPath);
+            const manifest = mod.manifest;
+            const execute = mod.execute;
+            if (!isValidManifest(manifest)) {
+                log?.(`[Skill Discovery] Skipping ${file}: invalid or missing manifest`);
+                continue;
+            }
+            if (typeof execute !== "function") {
+                log?.(`[Skill Discovery] Skipping ${file}: missing execute function`);
+                continue;
+            }
+            skills.push({ manifest, execute: execute });
+            log?.(`[Skill Discovery] Loaded plugin: ${manifest.name} v${manifest.version}`);
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            log?.(`[Skill Discovery] Failed to load ${file}: ${message}`);
+        }
+    }
+    return skills;
+}

package/dist/skill-engine/graph.d.ts

@@ -0,0 +1,4 @@
+import type { ExecutionTier, SkillManifest } from "./types";
+export declare function detectCycles(manifests: Map<string, SkillManifest>): string[][] | null;
+export declare function buildExecutionPlan(manifests: Map<string, SkillManifest>, targetSkills: string[]): ExecutionTier[];
+export declare function getExecutionOrder(manifests: Map<string, SkillManifest>, targetSkills: string[]): string[];

package/dist/skill-engine/graph.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectCycles = detectCycles;
+exports.buildExecutionPlan = buildExecutionPlan;
+exports.getExecutionOrder = getExecutionOrder;
+const errors_1 = require("../core/errors");
+function detectCycles(manifests) {
+    const WHITE = 0;
+    const GRAY = 1;
+    const BLACK = 2;
+    const color = new Map();
+    const cycles = [];
+    for (const name of manifests.keys()) {
+        color.set(name, WHITE);
+    }
+    function dfs(node, path) {
+        color.set(node, GRAY);
+        path.push(node);
+        const manifest = manifests.get(node);
+        if (manifest) {
+            for (const dep of manifest.depends_on) {
+                if (!manifests.has(dep))
+                    continue;
+                const c = color.get(dep) ?? WHITE;
+                if (c === GRAY) {
+                    const cycleStart = path.indexOf(dep);
+                    cycles.push([...path.slice(cycleStart), dep]);
+                }
+                else if (c === WHITE) {
+                    dfs(dep, path);
+                }
+            }
+        }
+        path.pop();
+        color.set(node, BLACK);
+    }
+    for (const name of manifests.keys()) {
+        if (color.get(name) === WHITE) {
+            dfs(name, []);
+        }
+    }
+    return cycles.length > 0 ? cycles : null;
+}
+function collectTransitiveDeps(target, manifests, collected) {
+    if (collected.has(target))
+        return;
+    collected.add(target);
+    const manifest = manifests.get(target);
+    if (!manifest)
+        return;
+    for (const dep of manifest.depends_on) {
+        if (manifests.has(dep)) {
+            collectTransitiveDeps(dep, manifests, collected);
+        }
+    }
+}
+function buildExecutionPlan(manifests, targetSkills) {
+    const needed = new Set();
+    for (const target of targetSkills) {
+        collectTransitiveDeps(target, manifests, needed);
+    }
+    const filteredManifests = new Map();
+    for (const name of needed) {
+        const m = manifests.get(name);
+        if (m)
+            filteredManifests.set(name, m);
+    }
+    const cycles = detectCycles(filteredManifests);
+    if (cycles) {
+        const cycleStr = cycles.map((c) => c.join(" → ")).join("; ");
+        throw new errors_1.UserError(`Dependency cycle detected: ${cycleStr}`);
+    }
+    const inDegree = new Map();
+    for (const name of filteredManifests.keys()) {
+        inDegree.set(name, 0);
+    }
+    for (const [, manifest] of filteredManifests) {
+        for (const dep of manifest.depends_on) {
+            if (filteredManifests.has(dep)) {
+                inDegree.set(manifest.name, (inDegree.get(manifest.name) ?? 0) + 1);
+            }
+        }
+    }
+    const tiers = [];
+    const remaining = new Set(filteredManifests.keys());
+    let tierNum = 0;
+    while (remaining.size > 0) {
+        const ready = [];
+        for (const name of remaining) {
+            if ((inDegree.get(name) ?? 0) === 0) {
+                ready.push(name);
+            }
+        }
+        if (ready.length === 0) {
+            throw new errors_1.UserError(`Cannot resolve execution order for: ${Array.from(remaining).join(", ")}`);
+        }
+        ready.sort();
+        tiers.push({ tier: tierNum, skills: ready });
+        for (const name of ready) {
+            remaining.delete(name);
+            for (const [otherName, manifest] of filteredManifests) {
+                if (manifest.depends_on.includes(name) && remaining.has(otherName)) {
+                    inDegree.set(otherName, (inDegree.get(otherName) ?? 0) - 1);
+                }
+            }
+        }
+        tierNum += 1;
+    }
+    return tiers;
+}
+function getExecutionOrder(manifests, targetSkills) {
+    const tiers = buildExecutionPlan(manifests, targetSkills);
+    return tiers.flatMap((t) => t.skills);
+}

package/dist/skill-engine/index.d.ts

@@ -0,0 +1,11 @@
+import { SkillPipeline } from "./pipeline";
+import type { PipelineState } from "./types";
+export declare function createEngine(cwd: string, log?: (message: string) => void): Promise<SkillPipeline>;
+export declare function createHydratedState(cwd: string): Promise<PipelineState>;
+export { SkillPipeline } from "./pipeline";
+export { SkillRegistry } from "./registry";
+export { createPipelineState, hydrateStateFromDisk } from "./context";
+export { buildExecutionPlan, detectCycles, getExecutionOrder } from "./graph";
+export { discoverSkills } from "./discovery";
+export { validateInputs, validateOutputs, validateInputPaths } from "./validator";
+export type { Skill, SkillManifest, SkillInput, SkillOutput, SkillContext, SkillExecuteFn, PipelineState, PipelineOptions, ExecutionTier, SkillError, ProgressCallback } from "./types";

package/dist/skill-engine/index.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateInputPaths = exports.validateOutputs = exports.validateInputs = exports.discoverSkills = exports.getExecutionOrder = exports.detectCycles = exports.buildExecutionPlan = exports.hydrateStateFromDisk = exports.createPipelineState = exports.SkillRegistry = exports.SkillPipeline = void 0;
+exports.createEngine = createEngine;
+exports.createHydratedState = createHydratedState;
+const registry_1 = require("./registry");
+const pipeline_1 = require("./pipeline");
+const discovery_1 = require("./discovery");
+const register_core_1 = require("../skills/register-core");
+const context_1 = require("./context");
+const artifact_registry_1 = require("../core/artifact-registry");
+async function createEngine(cwd, log) {
+    const registry = new registry_1.SkillRegistry();
+    await (0, register_core_1.registerCoreSkills)(registry, cwd);
+    const plugins = await (0, discovery_1.discoverSkills)(cwd, log);
+    for (const plugin of plugins) {
+        try {
+            registry.register(plugin);
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            log?.(`[Skill Engine] Plugin registration failed: ${message}`);
+        }
+    }
+    return new pipeline_1.SkillPipeline(registry);
+}
+async function createHydratedState(cwd) {
+    const state = (0, context_1.createPipelineState)(cwd);
+    const artifactTypes = await (0, artifact_registry_1.listArtifactTypes)(cwd);
+    await (0, context_1.hydrateStateFromDisk)(cwd, state, artifactTypes);
+    return state;
+}
+var pipeline_2 = require("./pipeline");
+Object.defineProperty(exports, "SkillPipeline", { enumerable: true, get: function () { return pipeline_2.SkillPipeline; } });
+var registry_2 = require("./registry");
+Object.defineProperty(exports, "SkillRegistry", { enumerable: true, get: function () { return registry_2.SkillRegistry; } });
+var context_2 = require("./context");
+Object.defineProperty(exports, "createPipelineState", { enumerable: true, get: function () { return context_2.createPipelineState; } });
+Object.defineProperty(exports, "hydrateStateFromDisk", { enumerable: true, get: function () { return context_2.hydrateStateFromDisk; } });
+var graph_1 = require("./graph");
+Object.defineProperty(exports, "buildExecutionPlan", { enumerable: true, get: function () { return graph_1.buildExecutionPlan; } });
+Object.defineProperty(exports, "detectCycles", { enumerable: true, get: function () { return graph_1.detectCycles; } });
+Object.defineProperty(exports, "getExecutionOrder", { enumerable: true, get: function () { return graph_1.getExecutionOrder; } });
+var discovery_2 = require("./discovery");
+Object.defineProperty(exports, "discoverSkills", { enumerable: true, get: function () { return discovery_2.discoverSkills; } });
+var validator_1 = require("./validator");
+Object.defineProperty(exports, "validateInputs", { enumerable: true, get: function () { return validator_1.validateInputs; } });
+Object.defineProperty(exports, "validateOutputs", { enumerable: true, get: function () { return validator_1.validateOutputs; } });
+Object.defineProperty(exports, "validateInputPaths", { enumerable: true, get: function () { return validator_1.validateInputPaths; } });

package/dist/skill-engine/pipeline.d.ts

@@ -0,0 +1,9 @@
+import type { SkillRegistry } from "./registry";
+import type { PipelineOptions, PipelineState } from "./types";
+export declare class SkillPipeline {
+    private registry;
+    constructor(registry: SkillRegistry);
+    runPipeline(skillNames: string[], state: PipelineState, options?: PipelineOptions): Promise<PipelineState>;
+    runSkill(name: string, state: PipelineState, options?: PipelineOptions): Promise<PipelineState>;
+    getRegistry(): SkillRegistry;
+}

package/dist/skill-engine/pipeline.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SkillPipeline = void 0;
+const errors_1 = require("../core/errors");
+const context_1 = require("./context");
+const graph_1 = require("./graph");
+const validator_1 = require("./validator");
+function createSkillError(skillName, phase, error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const stack = error instanceof Error ? error.stack : undefined;
+    return {
+        skillName,
+        phase,
+        message,
+        stack,
+        recoveryHints: [`Skill "${skillName}" failed during ${phase}. Check inputs and retry.`]
+    };
+}
+class SkillPipeline {
+    registry;
+    constructor(registry) {
+        this.registry = registry;
+    }
+    async runPipeline(skillNames, state, options = {}) {
+        const { log = console.log, progress, agent } = options;
+        for (const name of skillNames) {
+            if (!this.registry.has(name)) {
+                const available = this.registry.list().map((s) => s.manifest.name).join(", ");
+                throw new errors_1.UserError(`Unknown skill: "${name}". Available: ${available}`);
+            }
+        }
+        const manifests = new Map(this.registry.list().map((s) => [s.manifest.name, s.manifest]));
+        const executionOrder = (0, graph_1.getExecutionOrder)(manifests, skillNames);
+        const totalSteps = executionOrder.length;
+        for (let i = 0; i < executionOrder.length; i++) {
+            const skillName = executionOrder[i];
+            if (state.completedSkills.includes(skillName)) {
+                log(`[Skip] ${skillName} — already completed`);
+                continue;
+            }
+            const skill = this.registry.get(skillName);
+            if (!skill)
+                continue;
+            progress?.(i + 1, totalSteps, `Running ${skillName}...`);
+            log(`[${i + 1}/${totalSteps}] ${skillName}`);
+            const inputNames = skill.manifest.inputs.map((inp) => inp.name);
+            const wiredInputs = (0, context_1.wireInputsFromState)(inputNames, state);
+            const inputError = (0, validator_1.validateInputs)(skill.manifest, wiredInputs);
+            if (inputError) {
+                throw new errors_1.UserError(`Skill "${skillName}" input validation failed: ${inputError.message}\n` +
+                    inputError.recoveryHints.join("\n"));
+            }
+            let outputs;
+            try {
+                const context = {
+                    state,
+                    progress: progress ?? (() => { }),
+                    log,
+                    agent
+                };
+                outputs = await skill.execute(context, wiredInputs);
+            }
+            catch (error) {
+                const skillError = createSkillError(skillName, "execution", error);
+                throw new errors_1.UserError(`Skill "${skillName}" execution failed: ${skillError.message}\n` +
+                    skillError.recoveryHints.join("\n"));
+            }
+            const outputError = (0, validator_1.validateOutputs)(skill.manifest, outputs);
+            if (outputError) {
+                log(`[Warning] Skill "${skillName}" output validation: ${outputError.message}`);
+            }
+            (0, context_1.wireOutputsToState)(outputs, state, skillName);
+            state.completedSkills.push(skillName);
+        }
+        return state;
+    }
+    async runSkill(name, state, options = {}) {
+        return this.runPipeline([name], state, options);
+    }
+    getRegistry() {
+        return this.registry;
+    }
+}
+exports.SkillPipeline = SkillPipeline;

package/dist/skill-engine/registry.d.ts

@@ -0,0 +1,12 @@
+import type { Skill, SkillManifest } from "./types";
+export declare class SkillRegistry {
+    private skills;
+    register(skill: Skill): void;
+    get(name: string): Skill | undefined;
+    has(name: string): boolean;
+    list(): Skill[];
+    listByCategory(category: string): Skill[];
+    listManifests(): SkillManifest[];
+    unregister(name: string): boolean;
+    size(): number;
+}

package/dist/skill-engine/registry.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SkillRegistry = void 0;
+const errors_1 = require("../core/errors");
+function validateManifest(manifest) {
+    if (!manifest.name || typeof manifest.name !== "string")
+        return "Skill name is required";
+    if (!manifest.version || typeof manifest.version !== "string")
+        return "Skill version is required";
+    if (!manifest.description || typeof manifest.description !== "string")
+        return "Skill description is required";
+    const validCategories = ["core", "artifact", "validation", "custom"];
+    if (!validCategories.includes(manifest.category)) {
+        return `Invalid category "${manifest.category}". Must be: ${validCategories.join(", ")}`;
+    }
+    if (!Array.isArray(manifest.depends_on))
+        return "depends_on must be an array";
+    if (!Array.isArray(manifest.inputs))
+        return "inputs must be an array";
+    if (!Array.isArray(manifest.outputs))
+        return "outputs must be an array";
+    const validTypes = ["string", "path", "boolean", "json", "number"];
+    for (const input of manifest.inputs) {
+        if (!input.name || typeof input.name !== "string")
+            return "Input name is required";
+        if (!validTypes.includes(input.type))
+            return `Invalid input type "${input.type}" for "${input.name}"`;
+    }
+    for (const output of manifest.outputs) {
+        if (!output.name || typeof output.name !== "string")
+            return "Output name is required";
+        if (!validTypes.includes(output.type))
+            return `Invalid output type "${output.type}" for "${output.name}"`;
+    }
+    return null;
+}
+class SkillRegistry {
+    skills = new Map();
+    register(skill) {
+        const error = validateManifest(skill.manifest);
+        if (error) {
+            throw new errors_1.UserError(`Invalid skill manifest for "${skill.manifest?.name ?? "unknown"}": ${error}`);
+        }
+        if (typeof skill.execute !== "function") {
+            throw new errors_1.UserError(`Skill "${skill.manifest.name}" must export an execute function`);
+        }
+        if (this.skills.has(skill.manifest.name)) {
+            throw new errors_1.UserError(`Skill "${skill.manifest.name}" is already registered`);
+        }
+        this.skills.set(skill.manifest.name, skill);
+    }
+    get(name) {
+        return this.skills.get(name);
+    }
+    has(name) {
+        return this.skills.has(name);
+    }
+    list() {
+        return Array.from(this.skills.values());
+    }
+    listByCategory(category) {
+        return this.list().filter((s) => s.manifest.category === category);
+    }
+    listManifests() {
+        return this.list().map((s) => s.manifest);
+    }
+    unregister(name) {
+        return this.skills.delete(name);
+    }
+    size() {
+        return this.skills.size;
+    }
+}
+exports.SkillRegistry = SkillRegistry;