@shahmarasy/prodo 0.1.3 → 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/init-tui.d.ts

@@ -3,12 +3,14 @@ export type InitSelections = {
     ai?: SupportedAi;
     script: "sh" | "ps";
     lang: "tr" | "en";
+    author: string;
     interactive: boolean;
 };
 type GatherInitUiOptions = {
     projectRoot: string;
     aiInput?: string;
     langInput?: string;
+    authorInput?: string;
 };
 export declare function gatherInitSelections(options: GatherInitUiOptions): Promise<InitSelections>;
 export declare function finishInitInteractive(summary: {
@@ -16,5 +18,6 @@ export declare function finishInitInteractive(summary: {
     settingsPath: string;
     ai?: SupportedAi;
     lang: "tr" | "en";
+    author: string;
 }): Promise<void>;
 export {};

package/dist/init-tui.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.gatherInitSelections = gatherInitSelections;
 exports.finishInitInteractive = finishInitInteractive;
 const node_path_1 = __importDefault(require("node:path"));
+const node_os_1 = __importDefault(require("node:os"));
 const agent_command_installer_1 = require("./agent-command-installer");
 const errors_1 = require("./errors");
 const utils_1 = require("./utils");
@@ -75,16 +76,32 @@ function modelChoiceFromAi(ai) {
         return "gemini";
     return "auto-detect";
 }
+function defaultAuthorName(authorInput) {
+    const explicit = (authorInput ?? "").trim();
+    if (explicit.length > 0)
+        return explicit;
+    try {
+        const username = node_os_1.default.userInfo().username.trim();
+        if (username.length > 0)
+            return username;
+    }
+    catch {
+        // ignore lookup errors and continue with fallback
+    }
+    return "Product Author";
+}
 async function gatherInitSelections(options) {
     const clack = await loadClack();
     const defaultLang = normalizeLang(options.langInput);
     const fallbackScript = process.platform === "win32" ? "ps" : "sh";
     const parsedAi = (0, agent_command_installer_1.resolveAi)(options.aiInput);
+    const defaultAuthor = defaultAuthorName(options.authorInput);
     if (!isInteractiveTerminal()) {
         return {
             ai: parsedAi,
             script: fallbackScript,
             lang: defaultLang,
+            author: defaultAuthor,
             interactive: false
         };
     }
@@ -129,6 +146,15 @@ async function gatherInitSelections(options) {
         clack.cancel("Initialization cancelled.");
         throw new errors_1.UserError("Initialization cancelled.");
     }
+    const author = await clack.text({
+        message: "Author name",
+        placeholder: "Shahmarasy",
+        defaultValue: defaultAuthor
+    });
+    if (clack.isCancel(author)) {
+        clack.cancel("Initialization cancelled.");
+        throw new errors_1.UserError("Initialization cancelled.");
+    }
     let selectedAi;
     if (model === "codex")
         selectedAi = "codex";
@@ -140,10 +166,11 @@ async function gatherInitSelections(options) {
         ai: selectedAi,
         script: fallbackScript,
         lang,
+        author: String(author).trim() || defaultAuthor,
         interactive: true
     };
 }
 function finishInitInteractive(summary) {
     const aiText = summary.ai ?? "none";
-    return loadClack().then((clack) => clack.outro(`Scaffold complete.\nAI: ${aiText}\nLanguage: ${summary.lang}\nSettings: ${summary.settingsPath}\nNext: edit brief.md`));
+    return loadClack().then((clack) => clack.outro(`Scaffold complete.\nAI: ${aiText}\nLanguage: ${summary.lang}\nAuthor: ${summary.author}\nSettings: ${summary.settingsPath}\nNext: edit brief.md`));
 }

package/dist/init.d.ts

@@ -2,6 +2,7 @@ import { type SupportedAi } from "./agent-command-installer";
 export declare function runInit(cwd: string, options?: {
     ai?: SupportedAi;
     lang?: string;
+    author?: string;
     preset?: string;
     script?: "sh" | "ps";
 }): Promise<{

package/dist/init.js

@@ -15,6 +15,7 @@ const paths_1 = require("./paths");
 const preset_loader_1 = require("./preset-loader");
 const registry_1 = require("./registry");
 const settings_1 = require("./settings");
+const template_resolver_1 = require("./template-resolver");
 const workflow_commands_1 = require("./workflow-commands");
 const templates_1 = require("./templates");
 function templateFileName(artifactType) {
@@ -272,12 +273,16 @@ async function runInit(cwd, options) {
     await writeFileIfMissing(node_path_1.default.join(root, "hooks.yml"), templates_1.HOOKS_TEMPLATE);
     await writeFileIfMissing(node_path_1.default.join(root, "prompts", "normalize.md"), `${templates_1.NORMALIZE_PROMPT_TEMPLATE}\n`);
     const scriptType = options?.script ?? (process.platform === "win32" ? "ps" : "sh");
-    await promises_1.default.writeFile(node_path_1.default.join(root, "init-options.json"), `${JSON.stringify({ ai: options?.ai ?? null, lang: options?.lang ?? "en", preset: options?.preset ?? null, script: scriptType }, null, 2)}\n`, "utf8");
+    await promises_1.default.writeFile(node_path_1.default.join(root, "init-options.json"), `${JSON.stringify({ ai: options?.ai ?? null, lang: options?.lang ?? "en", author: options?.author ?? null, preset: options?.preset ?? null, script: scriptType }, null, 2)}\n`, "utf8");
     await copyDirIfMissing(node_path_1.default.join(projectScaffoldTemplates, "artifacts"), node_path_1.default.join(root, "templates"), copiedAssets);
     for (const artifact of artifactDefs) {
+        const markdownTemplatePath = node_path_1.default.join(root, "templates", `${artifact.name}.md`);
+        const templateHeadings = (await (0, utils_1.fileExists)(markdownTemplatePath))
+            ? (0, template_resolver_1.extractRequiredHeadingsFromTemplate)(await promises_1.default.readFile(markdownTemplatePath, "utf8"))
+            : [];
         const schema = {
             ...(0, templates_1.schemaTemplate)(artifact.name),
-            x_required_headings: artifact.required_headings
+            x_required_headings: templateHeadings.length > 0 ? templateHeadings : artifact.required_headings
         };
         await writeFileIfMissing(node_path_1.default.join(root, "schemas", `${artifact.name}.yaml`), js_yaml_1.default.dump(schema));
         await writeFileIfMissing(node_path_1.default.join(root, "prompts", `${artifact.name}.md`), `${(0, templates_1.promptTemplate)(artifact.name, options?.lang ?? "en")}\n`);
@@ -322,7 +327,8 @@ async function runInit(cwd, options) {
     await (0, registry_1.syncRegistry)(cwd);
     const settingsPath = await (0, settings_1.writeSettings)(cwd, {
         lang: (options?.lang ?? "en").trim() || "en",
-        ai: options?.ai
+        ai: options?.ai,
+        author: (options?.author ?? "").trim() || undefined
     });
     return { installedAgentFiles, settingsPath };
 }

package/dist/normalize.js

@@ -12,6 +12,53 @@ const paths_1 = require("./paths");
 const providers_1 = require("./providers");
 const settings_1 = require("./settings");
 const utils_1 = require("./utils");
+function normalizedKey(value) {
+    return value
+        .normalize("NFD")
+        .replace(/[\u0300-\u036f]/g, "")
+        .replace(/ı/g, "i")
+        .replace(/İ/g, "I")
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, " ")
+        .trim();
+}
+function extractBriefProductName(rawBrief) {
+    const lines = rawBrief.split(/\r?\n/);
+    for (let index = 0; index < lines.length; index += 1) {
+        const headingMatch = lines[index].match(/^\s*#{1,6}\s+(.+?)\s*$/);
+        if (!headingMatch)
+            continue;
+        const headingKey = normalizedKey(headingMatch[1]);
+        const isProductHeading = headingKey === "product name" ||
+            headingKey === "project name" ||
+            headingKey === "urun adi" ||
+            headingKey === "urun ismi";
+        if (!isProductHeading)
+            continue;
+        for (let cursor = index + 1; cursor < lines.length; cursor += 1) {
+            const rawLine = lines[cursor].trim();
+            if (!rawLine)
+                continue;
+            if (/^\s*#{1,6}\s+/.test(rawLine))
+                break;
+            const cleaned = rawLine.replace(/^\s*[-*]\s*/, "").trim();
+            if (cleaned.length > 0)
+                return cleaned;
+        }
+    }
+    return undefined;
+}
+function preserveOriginalProductName(parsed, rawBrief) {
+    const briefProductName = extractBriefProductName(rawBrief);
+    if (!briefProductName)
+        return parsed;
+    const generated = typeof parsed.product_name === "string" ? parsed.product_name : "";
+    if (!generated.trim())
+        return { ...parsed, product_name: briefProductName };
+    if (normalizedKey(generated) !== normalizedKey(briefProductName))
+        return parsed;
+    return { ...parsed, product_name: briefProductName };
+}
 function extractJsonObject(raw) {
     const trimmed = raw.trim();
     const fenced = trimmed.match(/```(?:json)?\s*([\s\S]*?)```/i);
@@ -48,16 +95,17 @@ async function runNormalize(options) {
         requiredContracts: []
     });
     const parsed = extractJsonObject(generated.body);
+    const preserved = preserveOriginalProductName(parsed, rawBrief);
     const withContracts = {
-        ...parsed,
-        contracts: parsed.contracts ??
+        ...preserved,
+        contracts: preserved.contracts ??
             (0, normalized_brief_1.buildContractsFromArrays)({
-                goals: Array.isArray(parsed.goals) ? parsed.goals.filter((x) => typeof x === "string") : [],
-                core_features: Array.isArray(parsed.core_features)
-                    ? parsed.core_features.filter((x) => typeof x === "string")
+                goals: Array.isArray(preserved.goals) ? preserved.goals.filter((x) => typeof x === "string") : [],
+                core_features: Array.isArray(preserved.core_features)
+                    ? preserved.core_features.filter((x) => typeof x === "string")
                     : [],
-                constraints: Array.isArray(parsed.constraints)
-                    ? parsed.constraints.filter((x) => typeof x === "string")
+                constraints: Array.isArray(preserved.constraints)
+                    ? preserved.constraints.filter((x) => typeof x === "string")
                     : []
             })
     };

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;
@@ -22,7 +22,8 @@ class OpenAIProvider {
         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.`
+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.
 Return valid JSON only: { "issues": [{level, code, check, contract_id, file, message, suggestion}] }.`

package/dist/settings.d.ts

@@ -1,6 +1,7 @@
 export type ProdoSettings = {
     lang: string;
     ai?: string;
+    author?: string;
 };
 export declare function readSettings(cwd: string): Promise<ProdoSettings>;
 export declare function writeSettings(cwd: string, settings: ProdoSettings): Promise<string>;

package/dist/settings.js

@@ -20,7 +20,8 @@ async function readSettings(cwd) {
         const parsed = JSON.parse(raw);
         return {
             lang: typeof parsed.lang === "string" && parsed.lang.trim() ? parsed.lang.trim() : "en",
-            ai: typeof parsed.ai === "string" && parsed.ai.trim() ? parsed.ai.trim() : undefined
+            ai: typeof parsed.ai === "string" && parsed.ai.trim() ? parsed.ai.trim() : undefined,
+            author: typeof parsed.author === "string" && parsed.author.trim() ? parsed.author.trim() : undefined
         };
     }
     catch {

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;