@shahmarasy/prodo 0.1.4 → 0.1.6

package/dist/core/version.d.ts

@@ -0,0 +1 @@
+export declare function readCliVersion(cwd: string): Promise<string>;

package/dist/core/version.js

@@ -0,0 +1,30 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readCliVersion = readCliVersion;
+const promises_1 = __importDefault(require("node:fs/promises"));
+const node_path_1 = __importDefault(require("node:path"));
+const utils_1 = require("./utils");
+async function readCliVersion(cwd) {
+    const candidates = [
+        node_path_1.default.join(cwd, "package.json"),
+        node_path_1.default.resolve(__dirname, "..", "..", "package.json")
+    ];
+    for (const candidate of candidates) {
+        if (!(await (0, utils_1.fileExists)(candidate)))
+            continue;
+        try {
+            const raw = await promises_1.default.readFile(candidate, "utf8");
+            const parsed = JSON.parse(raw);
+            if (typeof parsed.version === "string" && parsed.version.trim().length > 0) {
+                return parsed.version.trim();
+            }
+        }
+        catch {
+            // ignore and continue
+        }
+    }
+    return "0.0.0";
+}

package/dist/core/workflow-commands.d.ts

@@ -0,0 +1,7 @@
+export type WorkflowCommand = {
+    name: string;
+    cliSubcommand: string;
+    description: string;
+};
+export declare const WORKFLOW_COMMANDS: WorkflowCommand[];
+export declare function buildWorkflowCommands(artifactTypes: string[]): WorkflowCommand[];

package/dist/core/workflow-commands.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WORKFLOW_COMMANDS = void 0;
+exports.buildWorkflowCommands = buildWorkflowCommands;
+const BASE_WORKFLOW_COMMANDS = [
+    { name: "prodo-normalize", cliSubcommand: "normalize", description: "Normalize start brief into normalized brief JSON." },
+    { name: "prodo-prd", cliSubcommand: "prd", description: "Generate PRD artifact from normalized brief." },
+    { name: "prodo-workflow", cliSubcommand: "workflow", description: "Generate workflow artifact." },
+    { name: "prodo-wireframe", cliSubcommand: "wireframe", description: "Generate wireframe artifact." },
+    { name: "prodo-stories", cliSubcommand: "stories", description: "Generate stories artifact." },
+    { name: "prodo-techspec", cliSubcommand: "techspec", description: "Generate technical specification artifact." },
+    { name: "prodo-validate", cliSubcommand: "validate", description: "Run schema and cross-artifact consistency validation." },
+    { name: "prodo-fix", cliSubcommand: "fix", description: "Auto-fix artifacts based on validation report and brief." }
+];
+exports.WORKFLOW_COMMANDS = BASE_WORKFLOW_COMMANDS;
+function buildWorkflowCommands(artifactTypes) {
+    const commandByName = new Map(BASE_WORKFLOW_COMMANDS.map((item) => [item.name, item]));
+    for (const type of artifactTypes) {
+        const name = `prodo-${type}`;
+        if (commandByName.has(name))
+            continue;
+        commandByName.set(name, {
+            name,
+            cliSubcommand: type,
+            description: `Generate ${type} artifact from normalized brief.`
+        });
+    }
+    return Array.from(commandByName.values());
+}

package/dist/i18n/en.json

@@ -0,0 +1,45 @@
+{
+  "user_action": "User action",
+  "main_flow": "Main Flow",
+  "user": "User",
+  "success": "Success",
+  "error": "Error",
+  "flow_focus": "Flow Focus",
+  "initial_version": "Initial version",
+  "fix_revision": "Post-validation fix revision",
+  "primary_user": "Primary user",
+  "back": "Back",
+  "next": "Next",
+  "save": "Save",
+  "content": "Content",
+  "primary_info_area": "Primary information area",
+  "status_indicator": "Status indicator",
+  "form": "Form",
+  "field": "Field",
+  "description": "Description",
+  "contract": "Contract",
+  "actor": "Actor",
+  "detailed_input_area": "Detailed Input Area",
+  "upload_area": "Upload Area",
+  "low_fidelity_wireframe": "Low-fidelity wireframe.",
+  "confirmation_text": "Confirmation text",
+  "header_and_navigation": "Header and navigation",
+  "content_section": "Content section",
+  "form_section": "Form section",
+  "text_input": "Text input",
+  "to_be_refined": "To be refined.",
+  "note": "Note",
+  "requirement_item": "Requirement item",
+  "contract_coverage": "Contract coverage",
+  "screen": "Screen",
+  "for_artifact": "for",
+  "fix_proposal": "Fix Proposal",
+  "fix_complete": "Fix complete — validation passed.",
+  "fix_still_failing": "Fix applied but validation still failing.",
+  "fix_cancelled": "Fix cancelled.",
+  "no_issues": "No blocking issues found. Nothing to fix.",
+  "issues_found": "Issues found",
+  "artifacts_to_regenerate": "Artifacts to regenerate",
+  "general": "General",
+  "suggestion_prefix": "→"
+}

package/dist/i18n/index.d.ts

@@ -0,0 +1,5 @@
+type TranslationMap = Record<string, string>;
+export declare function t(key: string, lang?: string): string;
+export declare function loadTranslations(lang: string): TranslationMap;
+export declare function availableLanguages(): string[];
+export {};

package/dist/i18n/index.js

@@ -0,0 +1,63 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.t = t;
+exports.loadTranslations = loadTranslations;
+exports.availableLanguages = availableLanguages;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const cache = new Map();
+function loadJson(lang) {
+    if (cache.has(lang))
+        return cache.get(lang);
+    const filePath = node_path_1.default.resolve(__dirname, `${lang}.json`);
+    try {
+        const raw = node_fs_1.default.readFileSync(filePath, "utf8");
+        const parsed = JSON.parse(raw);
+        cache.set(lang, parsed);
+        return parsed;
+    }
+    catch {
+        cache.set(lang, {});
+        return {};
+    }
+}
+function normalizeLang(lang) {
+    if (!lang)
+        return "en";
+    const code = lang.toLowerCase().trim();
+    if (code.startsWith("tr"))
+        return "tr";
+    if (code.startsWith("en"))
+        return "en";
+    return code;
+}
+function t(key, lang) {
+    const normalized = normalizeLang(lang);
+    const translations = loadJson(normalized);
+    if (key in translations)
+        return translations[key];
+    if (normalized !== "en") {
+        const fallback = loadJson("en");
+        if (key in fallback)
+            return fallback[key];
+    }
+    return key;
+}
+function loadTranslations(lang) {
+    return { ...loadJson(normalizeLang(lang)) };
+}
+function availableLanguages() {
+    const dir = node_path_1.default.resolve(__dirname);
+    try {
+        return node_fs_1.default.readdirSync(dir)
+            .filter((f) => f.endsWith(".json"))
+            .map((f) => f.replace(".json", ""))
+            .sort();
+    }
+    catch {
+        return ["en"];
+    }
+}

package/dist/i18n/tr.json

@@ -0,0 +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": "→"
+}

package/dist/providers/index.d.ts

@@ -1,2 +1,3 @@
-import type { LLMProvider } from "../types";
+import type { LLMProvider } from "../core/types";
 export declare function createProvider(): LLMProvider;
+export { getGlobalRegistry } from "../agents/agent-registry";

package/dist/providers/index.js

@@ -1,12 +1,26 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.getGlobalRegistry = void 0;
 exports.createProvider = createProvider;
-const mock_provider_1 = require("./mock-provider");
-const openai_provider_1 = require("./openai-provider");
+const agent_registry_1 = require("../agents/agent-registry");
+let cachedProvider = null;
+let cachedAgentName = null;
 function createProvider() {
-    const provider = (process.env.PRODO_LLM_PROVIDER ?? "mock").toLowerCase();
-    if (provider === "openai") {
-        return new openai_provider_1.OpenAIProvider();
+    const agentName = process.env.PRODO_AGENT ??
+        process.env.PRODO_LLM_PROVIDER ??
+        "mock";
+    if (cachedProvider && cachedAgentName === agentName) {
+        return cachedProvider;
     }
-    return new mock_provider_1.MockProvider();
+    const registry = (0, agent_registry_1.getGlobalRegistry)();
+    const agent = registry.get(agentName);
+    if (!agent) {
+        const available = registry.list().map((a) => a.name).join(", ");
+        throw new Error(`Unknown agent: "${agentName}". Available: ${available}`);
+    }
+    cachedProvider = registry.toProvider(agent);
+    cachedAgentName = agentName;
+    return cachedProvider;
 }
+var agent_registry_2 = require("../agents/agent-registry");
+Object.defineProperty(exports, "getGlobalRegistry", { enumerable: true, get: function () { return agent_registry_2.getGlobalRegistry; } });

package/dist/providers/mock-provider.d.ts

@@ -1,4 +1,4 @@
-import type { LLMProvider, ProviderSchemaHint } from "../types";
+import type { LLMProvider, ProviderSchemaHint } from "../core/types";
 export declare class MockProvider implements LLMProvider {
     generate(_prompt: string, inputContext: Record<string, unknown>, schemaHint: ProviderSchemaHint): Promise<{
         body: string;

package/dist/providers/mock-provider.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MockProvider = void 0;
+const i18n_1 = require("../i18n");
 function asStringArray(value) {
     if (!Array.isArray(value))
         return [];
@@ -107,27 +108,27 @@ function buildArtifactBody(schemaHint, inputContext) {
     const lang = typeof inputContext.outputLanguage === "string" ? inputContext.outputLanguage.toLowerCase() : "en";
     const items = normalizeSectionItems(inputContext);
     const coverage = coverageItems(schemaHint, inputContext);
-    const localizedItems = lang === "tr" ? items.map((_, index) => `Gereksinim maddesi ${index + 1}`) : items;
+    const localizedItems = lang === "tr" ? items.map((_, index) => `${(0, i18n_1.t)("requirement_item", lang)} ${index + 1}`) : items;
     const localizedCoverage = lang === "tr"
         ? coverage.map((item, index) => ({
             id: item.id,
-            text: `Kontrat kapsami ${index + 1}`
+            text: `${(0, i18n_1.t)("contract_coverage", lang)} ${index + 1}`
         }))
         : coverage;
-    const fallback = lang === "tr" ? "Detay daha sonra netlestirilecek." : "To be refined.";
+    const fallback = (0, i18n_1.t)("to_be_refined", lang);
     const sections = schemaHint.requiredHeadings.map((heading) => headingBlock(heading, localizedItems, fallback, localizedCoverage));
     const title = lang === "tr"
-        ? `# ${productName} icin ${schemaHint.artifactType.toUpperCase()}`
-        : `# ${schemaHint.artifactType.toUpperCase()} for ${productName}`;
+        ? `# ${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${lang === "tr" ? "Not" : "Note"}: ${fallback}`.trim();
+    return `${title}\n\n${sections.join("\n")}\n\n${(0, i18n_1.t)("note", lang)}: ${fallback}`.trim();
 }
 function semanticIssuesWithMock(inputContext) {
     const pair = inputContext.pair;

package/dist/providers/openai-provider.d.ts

@@ -1,4 +1,4 @@
-import type { LLMProvider, ProviderSchemaHint } from "../types";
+import type { LLMProvider, ProviderSchemaHint } from "../core/types";
 export declare class OpenAIProvider implements LLMProvider {
     private readonly apiKey;
     private readonly model;

package/dist/providers/openai-provider.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OpenAIProvider = void 0;
-const errors_1 = require("../errors");
+const errors_1 = require("../core/errors");
 class OpenAIProvider {
     apiKey;
     model;
@@ -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";