@shahmarasy/prodo 0.1.4 → 0.1.5

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,18 +108,18 @@ 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
@@ -127,7 +128,7 @@ flowchart TD
   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;

package/dist/skills/engine.d.ts

@@ -0,0 +1,10 @@
+import type { Skill, SkillContext, SkillManifest } from "./types";
+export type SkillEngine = {
+    register(skill: Skill): void;
+    getSkill(name: string): Skill | undefined;
+    listSkills(): SkillManifest[];
+    execute(name: string, context: SkillContext, inputs: Record<string, unknown>): Promise<Record<string, unknown>>;
+};
+export declare function createSkillEngine(): SkillEngine;
+export declare function getGlobalSkillEngine(): SkillEngine;
+export declare function resetGlobalSkillEngine(): void;

package/dist/skills/engine.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSkillEngine = createSkillEngine;
+exports.getGlobalSkillEngine = getGlobalSkillEngine;
+exports.resetGlobalSkillEngine = resetGlobalSkillEngine;
+const errors_1 = require("../core/errors");
+function validateInputs(skill, inputs) {
+    for (const input of skill.manifest.inputs) {
+        if (input.required && !(input.name in inputs)) {
+            throw new errors_1.UserError(`Skill "${skill.manifest.name}" requires input "${input.name}" (${input.description})`);
+        }
+    }
+}
+function createSkillEngine() {
+    const skills = new Map();
+    return {
+        register(skill) {
+            skills.set(skill.manifest.name, skill);
+        },
+        getSkill(name) {
+            return skills.get(name);
+        },
+        listSkills() {
+            return Array.from(skills.values()).map((s) => s.manifest);
+        },
+        async execute(name, context, inputs) {
+            const skill = skills.get(name);
+            if (!skill) {
+                const available = Array.from(skills.keys()).join(", ");
+                throw new errors_1.UserError(`Unknown skill: "${name}". Available: ${available}`);
+            }
+            validateInputs(skill, inputs);
+            return skill.execute(context, inputs);
+        }
+    };
+}
+let globalEngine = null;
+function getGlobalSkillEngine() {
+    if (!globalEngine) {
+        globalEngine = createSkillEngine();
+        loadBuiltinSkills(globalEngine);
+    }
+    return globalEngine;
+}
+function resetGlobalSkillEngine() {
+    globalEngine = null;
+}
+function loadBuiltinSkills(engine) {
+    // Lazy-load to avoid circular dependencies
+    try {
+        const { normalizeSkill } = require("./normalize-skill");
+        engine.register(normalizeSkill);
+    }
+    catch { /* skill not available */ }
+    try {
+        const { validateSkill } = require("./validate-skill");
+        engine.register(validateSkill);
+    }
+    catch { /* skill not available */ }
+    try {
+        const { fixSkill } = require("./fix-skill");
+        engine.register(fixSkill);
+    }
+    catch { /* skill not available */ }
+    try {
+        const { generateArtifactSkill } = require("./generate-artifact-skill");
+        engine.register(generateArtifactSkill);
+    }
+    catch { /* skill not available */ }
+    try {
+        const { generatePipelineSkill } = require("./generate-pipeline-skill");
+        engine.register(generatePipelineSkill);
+    }
+    catch { /* skill not available */ }
+}

package/dist/skills/fix-skill.d.ts

@@ -0,0 +1,2 @@
+import type { Skill } from "./types";
+export declare const fixSkill: Skill;

package/dist/skills/fix-skill.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fixSkill = void 0;
+const fix_1 = require("../core/fix");
+exports.fixSkill = {
+    manifest: {
+        name: "fix",
+        description: "Auto-regenerate artifacts that failed validation with backup and rollback",
+        category: "validation",
+        inputs: [
+            { name: "cwd", type: "path", required: true, description: "Project working directory" },
+            { name: "agent", type: "string", required: false, description: "Agent profile name" },
+            { name: "strict", type: "boolean", required: false, description: "Treat warnings as errors" },
+            { name: "dryRun", type: "boolean", required: false, description: "Preview without applying" }
+        ],
+        outputs: [
+            { name: "applied", type: "string", description: "Whether fix was applied" },
+            { name: "finalPass", type: "string", description: "Whether validation passed after fix" },
+            { name: "reportPath", type: "path", description: "Path to validation report" }
+        ]
+    },
+    async execute(context, inputs) {
+        const cwd = inputs.cwd ?? context.cwd;
+        const result = await (0, fix_1.runFix)({
+            cwd,
+            agent: inputs.agent ?? context.agent,
+            strict: Boolean(inputs.strict),
+            dryRun: Boolean(inputs.dryRun),
+            log: context.log
+        });
+        return {
+            applied: result.applied,
+            finalPass: result.finalPass,
+            reportPath: result.reportPath,
+            targetCount: result.proposal.targets.length
+        };
+    }
+};

package/dist/skills/generate-artifact-skill.d.ts

@@ -0,0 +1,2 @@
+import type { Skill } from "./types";
+export declare const generateArtifactSkill: Skill;

package/dist/skills/generate-artifact-skill.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateArtifactSkill = void 0;
+const artifacts_1 = require("../core/artifacts");
+exports.generateArtifactSkill = {
+    manifest: {
+        name: "generate-artifact",
+        description: "Generate a single artifact (PRD, workflow, wireframe, stories, techspec)",
+        category: "artifact",
+        inputs: [
+            { name: "cwd", type: "path", required: true, description: "Project working directory" },
+            { name: "artifactType", type: "string", required: true, description: "Artifact type to generate" },
+            { name: "from", type: "path", required: false, description: "Override path to normalized-brief.json" },
+            { name: "out", type: "path", required: false, description: "Override output path" }
+        ],
+        outputs: [
+            { name: "filePath", type: "path", description: "Path to generated artifact" }
+        ]
+    },
+    async execute(context, inputs) {
+        const cwd = inputs.cwd ?? context.cwd;
+        const filePath = await (0, artifacts_1.generateArtifact)({
+            artifactType: inputs.artifactType,
+            cwd,
+            normalizedBriefOverride: inputs.from,
+            outPath: inputs.out,
+            agent: context.agent
+        });
+        context.log(`${inputs.artifactType.toUpperCase()} generated: ${filePath}`);
+        return { filePath };
+    }
+};

package/dist/skills/generate-pipeline-skill.d.ts

@@ -0,0 +1,2 @@
+import type { Skill } from "./types";
+export declare const generatePipelineSkill: Skill;

package/dist/skills/generate-pipeline-skill.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generatePipelineSkill = void 0;
+const artifact_registry_1 = require("../core/artifact-registry");
+const artifacts_1 = require("../core/artifacts");
+const normalize_1 = require("../core/normalize");
+const validate_1 = require("../core/validate");
+exports.generatePipelineSkill = {
+    manifest: {
+        name: "generate-pipeline",
+        description: "Run end-to-end pipeline: normalize → generate all artifacts → validate",
+        category: "core",
+        inputs: [
+            { name: "cwd", type: "path", required: true, description: "Project working directory" },
+            { name: "strict", type: "boolean", required: false, description: "Treat warnings as errors" }
+        ],
+        outputs: [
+            { name: "pass", type: "string", description: "Whether validation passed" },
+            { name: "reportPath", type: "path", description: "Path to validation report" },
+            { name: "artifactCount", type: "string", description: "Number of artifacts generated" }
+        ]
+    },
+    async execute(context, inputs) {
+        const cwd = inputs.cwd ?? context.cwd;
+        const normalizedPath = await (0, normalize_1.runNormalize)({ cwd });
+        context.log(`Normalized brief: ${normalizedPath}`);
+        const artifactTypes = await (0, artifact_registry_1.listArtifactTypes)(cwd);
+        for (const type of artifactTypes) {
+            const file = await (0, artifacts_1.generateArtifact)({
+                artifactType: type,
+                cwd,
+                normalizedBriefOverride: normalizedPath,
+                agent: context.agent
+            });
+            context.log(`${type.toUpperCase()} generated: ${file}`);
+        }
+        const result = await (0, validate_1.runValidate)(cwd, { strict: Boolean(inputs.strict) });
+        context.log(`Validation ${result.pass ? "passed" : "failed"}: ${result.reportPath}`);
+        return {
+            pass: result.pass,
+            reportPath: result.reportPath,
+            artifactCount: artifactTypes.length
+        };
+    }
+};

package/dist/skills/normalize-skill.d.ts

@@ -0,0 +1,2 @@
+import type { Skill } from "./types";
+export declare const normalizeSkill: Skill;

package/dist/skills/normalize-skill.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeSkill = void 0;
+const normalize_1 = require("../core/normalize");
+exports.normalizeSkill = {
+    manifest: {
+        name: "normalize",
+        description: "Normalize a product brief into structured JSON with contracts and confidence scores",
+        category: "core",
+        inputs: [
+            { name: "cwd", type: "path", required: true, description: "Project working directory" },
+            { name: "brief", type: "path", required: false, description: "Override path to brief.md" },
+            { name: "out", type: "path", required: false, description: "Override output path" }
+        ],
+        outputs: [
+            { name: "normalizedBriefPath", type: "path", description: "Path to normalized-brief.json" }
+        ]
+    },
+    async execute(context, inputs) {
+        const cwd = inputs.cwd ?? context.cwd;
+        const outPath = await (0, normalize_1.runNormalize)({
+            cwd,
+            brief: inputs.brief,
+            out: inputs.out
+        });
+        context.log(`Normalized brief written to: ${outPath}`);
+        return { normalizedBriefPath: outPath };
+    }
+};

package/dist/skills/types.d.ts

@@ -0,0 +1,28 @@
+export type SkillInput = {
+    name: string;
+    type: "path" | "string" | "boolean" | "json";
+    required: boolean;
+    description: string;
+};
+export type SkillOutput = {
+    name: string;
+    type: "path" | "string" | "json";
+    description: string;
+};
+export type SkillManifest = {
+    name: string;
+    description: string;
+    category: "core" | "artifact" | "validation" | "custom";
+    inputs: SkillInput[];
+    outputs: SkillOutput[];
+};
+export type SkillContext = {
+    cwd: string;
+    log: (message: string) => void;
+    agent?: string;
+};
+export type SkillFunction = (context: SkillContext, inputs: Record<string, unknown>) => Promise<Record<string, unknown>>;
+export type Skill = {
+    manifest: SkillManifest;
+    execute: SkillFunction;
+};

package/dist/skills/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/skills/validate-skill.d.ts

@@ -0,0 +1,2 @@
+import type { Skill } from "./types";
+export declare const validateSkill: Skill;

package/dist/skills/validate-skill.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateSkill = void 0;
+const validate_1 = require("../core/validate");
+exports.validateSkill = {
+    manifest: {
+        name: "validate",
+        description: "Run cross-artifact validation and generate a report",
+        category: "validation",
+        inputs: [
+            { name: "cwd", type: "path", required: true, description: "Project working directory" },
+            { name: "strict", type: "boolean", required: false, description: "Treat warnings as errors" },
+            { name: "report", type: "path", required: false, description: "Override report output path" }
+        ],
+        outputs: [
+            { name: "pass", type: "string", description: "Whether validation passed" },
+            { name: "reportPath", type: "path", description: "Path to validation report" }
+        ]
+    },
+    async execute(context, inputs) {
+        const cwd = inputs.cwd ?? context.cwd;
+        const result = await (0, validate_1.runValidate)(cwd, {
+            strict: Boolean(inputs.strict),
+            report: inputs.report
+        });
+        context.log(`Validation ${result.pass ? "passed" : "failed"}: ${result.reportPath}`);
+        return { pass: result.pass, reportPath: result.reportPath, issueCount: result.issues.length };
+    }
+};

package/package.json

@@ -1,45 +1,74 @@
-{
-  "name": "@shahmarasy/prodo",
-  "version": "0.1.4",
-  "description": "CLI-first, prompt-powered product artifact kit",
-  "main": "dist/cli.js",
-  "types": "dist/cli.d.ts",
-  "bin": {
-    "prodo": "bin/prodo.cjs"
-  },
-  "files": [
-    "bin/",
-    "dist/",
-    "templates/",
-    "presets/",
-    "src/",
-    "README.md"
-  ],
-  "publishConfig": {
-    "access": "public"
-  },
-  "engines": {
-    "node": ">=20"
-  },
-  "scripts": {
-    "build": "tsc -p tsconfig.json",
-    "test": "npm run build && node --test tests/*.test.cjs",
-    "verify:release": "npm run build && node scripts/verify-release-build.cjs"
-  },
-  "keywords": [],
-  "author": "",
-  "license": "ISC",
-  "dependencies": {
-    "@clack/prompts": "^1.1.0",
-    "ajv": "^8.18.0",
-    "ajv-formats": "^3.0.1",
-    "commander": "^14.0.3",
-    "gray-matter": "^4.0.3",
-    "js-yaml": "^4.1.1"
-  },
-  "devDependencies": {
-    "@types/js-yaml": "^4.0.9",
-    "@types/node": "^25.5.0",
-    "typescript": "^5.9.3"
-  }
-}
+{
+  "name": "@shahmarasy/prodo",
+  "version": "0.1.5",
+  "description": "CLI-first, prompt-powered product artifact kit",
+  "main": "dist/cli/index.js",
+  "types": "dist/cli/index.d.ts",
+  "bin": {
+    "prodo": "bin/prodo.cjs"
+  },
+  "files": [
+    "bin/",
+    "dist/",
+    "templates/",
+    "presets/",
+    "src/",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "build:ts": "tsc -p tsconfig.json",
+    "build:i18n": "node -e \"const fs=require('fs');const p=require('path');['en','tr'].forEach(l=>{const s=p.join('src','i18n',l+'.json');const d=p.join('dist','i18n',l+'.json');fs.copyFileSync(s,d)})\"",
+    "build": "npm run build:ts && npm run build:i18n",
+    "test": "npm run build && node --test tests/*.test.cjs",
+    "verify:release": "npm run build && node scripts/verify-release-build.cjs"
+  },
+  "keywords": [
+    "product-management",
+    "prd",
+    "ai-agents",
+    "codex",
+    "claude",
+    "gemini",
+    "document-generation",
+    "cli"
+  ],
+  "author": "Shahmarasy",
+  "license": "MIT",
+  "dependencies": {
+    "@clack/prompts": "^1.1.0",
+    "ajv": "^8.18.0",
+    "ajv-formats": "^3.0.1",
+    "commander": "^14.0.3",
+    "gray-matter": "^4.0.3",
+    "js-yaml": "^4.1.1",
+    "nunjucks": "^3.2.4"
+  },
+  "peerDependencies": {
+    "openai": ">=4.0.0",
+    "@anthropic-ai/sdk": ">=0.20.0",
+    "@google/generative-ai": ">=0.1.0"
+  },
+  "peerDependenciesMeta": {
+    "openai": {
+      "optional": true
+    },
+    "@anthropic-ai/sdk": {
+      "optional": true
+    },
+    "@google/generative-ai": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@types/js-yaml": "^4.0.9",
+    "@types/node": "^25.5.0",
+    "@types/nunjucks": "^3.2.6",
+    "typescript": "^5.9.3"
+  }
+}