@shahmarasy/prodo 0.1.5 → 0.1.7

package/dist/agents/system-prompts.js

@@ -5,26 +5,26 @@ exports.buildUserMessage = buildUserMessage;
 function buildSystemPrompt(schemaHint, outputLanguage) {
     const mode = schemaHint.artifactType;
     if (mode === "normalize") {
-        return `You normalize messy human product briefs into strict JSON.
-Return valid JSON only, no markdown. Include confidence scores (0..1) for critical fields.
+        return `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.`;
     }
     if (mode === "semantic_consistency") {
-        return `You detect semantic inconsistencies between paired artifacts.
+        return `You detect semantic inconsistencies between paired artifacts.
 Return valid JSON only: { "issues": [{level, code, check, contract_id, file, message, suggestion}] }.`;
     }
     if (mode === "contract_relevance") {
-        return `You verify whether tagged content actually matches the referenced contract text.
+        return `You verify whether tagged content actually matches the referenced contract text.
 Return valid JSON only: { "relevant": boolean, "score": number, "reason": string }.`;
     }
-    return `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}
+    return `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.`;
 }
 function buildUserMessage(prompt, inputContext) {

package/dist/cli/agent-command-installer.d.ts

@@ -1,4 +1,4 @@
 export declare const AI_ALIASES: Record<string, "codex" | "gemini-cli" | "claude-cli">;
 export type SupportedAi = "codex" | "gemini-cli" | "claude-cli";
 export declare function resolveAi(ai?: string): SupportedAi | undefined;
-export declare function installAgentCommands(projectRoot: string, ai: SupportedAi): Promise<string[]>;
+export declare function installAgentCommands(projectRoot: string, ai: SupportedAi, lang?: string): Promise<string[]>;

package/dist/cli/agent-command-installer.js

@@ -65,28 +65,28 @@ function sanitizeFrontmatter(frontmatter) {
 function toTomlPrompt(body, frontmatter, argsPlaceholder) {
     const description = String(frontmatter.description ?? "Prodo command");
     const promptBody = body.replaceAll("$ARGUMENTS", argsPlaceholder);
-    return `description = "${description.replace(/"/g, '\\"')}"
-
-prompt = """
-Important execution rule:
-- This is an agent slash command, not a shell command.
-- Do NOT run \`prodo-normalize\`, \`prodo-prd\`, or \`prodo ...\` in shell.
-- Execute the workflow directly using workspace files.
-
-${promptBody}
+    return `description = "${description.replace(/"/g, '\\"')}"
+
+prompt = """
+Important execution rule:
+- This is an agent slash command, not a shell command.
+- Do NOT run \`prodo-normalize\`, \`prodo-prd\`, or \`prodo ...\` in shell.
+- Execute the workflow directly using workspace files.
+
+${promptBody}
 """`;
 }
 function toSkill(name, body, frontmatter) {
     const description = String(frontmatter.description ?? "Prodo workflow command");
-    return `---
-name: ${name}
-description: ${description}
-compatibility: Requires Prodo project scaffold (.prodo)
-metadata:
-  author: prodo
-  source: .prodo/commands/${name}.md
----
-
+    return `---
+name: ${name}
+description: ${description}
+compatibility: Requires Prodo project scaffold (.prodo)
+metadata:
+  author: prodo
+  source: .prodo/commands/${name}.md
+---
+
 ${body}`;
 }
 function resolveAi(ai) {
@@ -110,13 +110,119 @@ async function loadCommandTemplateNames(commandTemplatesDir) {
         .map((name) => name.replace(/\.md$/, ""))
         .sort();
 }
-async function installAgentCommands(projectRoot, ai) {
+function generateClaudeMd(projectRoot, lang) {
+    const projectName = node_path_1.default.basename(projectRoot) || "Product";
+    return `# Prodo — Product Artifact Workspace
+
+This project uses **Prodo** to generate product documentation from a brief.
+
+## Project Structure
+
+- \`brief.md\` — Product brief (INPUT — read-only during generation)
+- \`product-docs/\` — Generated artifacts (OUTPUT)
+- \`.prodo/\` — Internal scaffold (templates, schemas, prompts, state)
+
+## Workflow
+
+Run commands in this sequence:
+
+1. \`/prodo-normalize\` — Parse brief into structured JSON
+2. \`/prodo-prd\` — Generate Product Requirements Document
+3. \`/prodo-workflow\` — Generate workflow diagrams (Markdown + Mermaid)
+4. \`/prodo-wireframe\` — Generate wireframes (Markdown + HTML)
+5. \`/prodo-stories\` — Generate user stories with Gherkin scenarios
+6. \`/prodo-techspec\` — Generate technical specification
+7. \`/prodo-validate\` — Cross-artifact validation (7 gates)
+
+## Rules
+
+- **Never modify \`brief.md\` during command execution** — it is read-only input
+- **All artifacts must include contract tags** like \`[G1]\`, \`[F2]\`, \`[C1]\` for traceability
+- **Output language is \`${lang}\`** — do not mix languages in generated content
+- **Follow templates strictly** — each artifact has a template in \`.prodo/templates/\`
+- **Validate after generation** — run \`/prodo-validate\` to check consistency
+`;
+}
+function generateArtifactRules(lang) {
+    return `# Artifact Format Rules
+
+## Contract Tags
+Every artifact must reference brief requirements using tags:
+- \`[G1]\`, \`[G2]\` — Goal references
+- \`[F1]\`, \`[F2]\` — Feature references
+- \`[C1]\`, \`[C2]\` — Constraint references
+
+Tags must appear inline where the requirement is addressed.
+
+## Frontmatter
+Every generated artifact must include YAML frontmatter:
+\`\`\`yaml
+artifact_type: prd | workflow | wireframe | stories | techspec
+version: <timestamp>
+source_brief: <path to normalized-brief.json>
+generated_at: <ISO timestamp>
+status: draft
+contract_coverage:
+  goals: [G1, G2]
+  core_features: [F1, F2]
+  constraints: [C1]
+\`\`\`
+
+## Paired Outputs
+- **Workflow**: Produces \`.md\` (narrative) + \`.mmd\` (Mermaid diagram)
+- **Wireframe**: Produces \`.md\` (description) + \`.html\` (low-fidelity prototype)
+
+## Language
+Output language: **${lang}**. Do not mix languages. Required heading names stay in English.
+`;
+}
+function generateBriefRules() {
+    return `# Brief Writing Rules
+
+## Structure
+The brief (\`brief.md\`) should contain these sections:
+
+- **Product Name** — Clear, specific product name
+- **Problem** — Core problem the product solves (be specific)
+- **Audience** — Target users (list distinct personas)
+- **Goals** — Measurable objectives (not vague aspirations)
+- **Core Features** — One capability per bullet point
+- **Constraints** — Technical, business, or regulatory limits
+- **Assumptions** — Open questions or working assumptions
+
+## Tips
+- Be specific: "Reduce checkout abandonment by 30%" not "Improve UX"
+- Use consistent terminology throughout
+- Each feature should be distinct and independently describable
+- Constraints should be concrete: "Node.js 20+", "GDPR compliant"
+`;
+}
+async function installAgentCommands(projectRoot, ai, lang) {
     const cfg = AGENT_CONFIG[ai];
     const target = node_path_1.default.join(projectRoot, cfg.baseDir);
     const commandTemplatesDir = node_path_1.default.join(projectRoot, ".prodo", "commands");
     const commandNames = await loadCommandTemplateNames(commandTemplatesDir);
     await (0, utils_1.ensureDir)(target);
     const written = [];
+    if (ai === "claude-cli") {
+        const claudeMdPath = node_path_1.default.join(projectRoot, "CLAUDE.md");
+        if (!(await (0, utils_1.fileExists)(claudeMdPath))) {
+            await promises_1.default.writeFile(claudeMdPath, generateClaudeMd(projectRoot, lang ?? "en"), "utf8");
+            written.push(claudeMdPath);
+        }
+        const rulesDir = node_path_1.default.join(projectRoot, ".claude", "rules");
+        await (0, utils_1.ensureDir)(rulesDir);
+        const artifactRulesPath = node_path_1.default.join(rulesDir, "artifact-format.md");
+        if (!(await (0, utils_1.fileExists)(artifactRulesPath))) {
+            await promises_1.default.writeFile(artifactRulesPath, generateArtifactRules(lang ?? "en"), "utf8");
+            written.push(artifactRulesPath);
+        }
+        const briefRulesPath = node_path_1.default.join(rulesDir, "brief-rules.md");
+        if (!(await (0, utils_1.fileExists)(briefRulesPath))) {
+            await promises_1.default.writeFile(briefRulesPath, generateBriefRules(), "utf8");
+            written.push(briefRulesPath);
+        }
+    }
     for (const commandName of commandNames) {
         const templatePath = node_path_1.default.join(commandTemplatesDir, `${commandName}.md`);
         if (!(await (0, utils_1.fileExists)(templatePath))) {

package/dist/cli/doctor.js

@@ -120,8 +120,8 @@ async function runDoctor(cwd, out) {
     out("");
     out(renderLogo(width));
     out("");
-    out(center(color("Prodo — Product Artifact Toolkit", "\u001B[1;37m"), width));
-    out(center(color("Crafted by Codex, guided by Shahmarasy intelligence", "\u001B[2;37m"), width));
+    out(center(color("Prodo — AI-Powered Product Owner", "\u001B[1;37m"), width));
+    out(center(color("Built by Shahmarasy · Works with Claude, Codex, and Gemini", "\u001B[2;37m"), width));
     out("");
     out("Checking environment...");
     out("");

package/dist/cli/index.js

@@ -138,7 +138,7 @@ async function runCli(options = {}) {
     const artifactTypes = await (0, artifact_registry_1.listArtifactTypes)(cwd);
     program
         .command("init [target]")
-        .option("--ai <name>", "agent integration: codex | gemini-cli | claude-cli")
+        .option("--ai <name>", "agent: codex | gemini-cli | claude-cli")
         .option("--lang <code>", "document language (e.g. en, tr)")
         .option("--author <name>", "document author name")
         .option("--preset <name>", "preset to install during initialization")
@@ -181,16 +181,15 @@ async function runCli(options = {}) {
         });
         out(`Initialized Prodo scaffold at ${node_path_1.default.join(projectRoot, ".prodo")}`);
         if (selectedAi) {
-            out(`Agent command set installed for ${selectedAi}.`);
+            const label = selectedAi === "claude-cli" ? "Claude Code"
+                : selectedAi === "codex" ? "Codex" : "Gemini CLI";
+            out(`Agent commands installed for ${label}.`);
             out(`Installed ${result.installedAgentFiles.length} command files.`);
-            out("Agent workflow: edit brief.md, then run slash commands in your agent.");
+            out(`Next: edit brief.md, open in ${label}, run /prodo-normalize`);
         }
         else {
-            out("No agent selected. Use `prodo generate` for end-to-end generation.");
+            out("Next: edit brief.md, then run `prodo generate`.");
         }
-        out(`Settings file: ${result.settingsPath}`);
-        out(`Author: ${selected.author}`);
-        out("Next: edit brief.md.");
     });
     program
         .command("generate")
@@ -213,26 +212,26 @@ async function runCli(options = {}) {
             return;
         }
         await withBriefReadOnlyGuard(cwd, async () => {
+            const { createEngine, createPipelineState } = await Promise.resolve().then(() => __importStar(require("../skill-engine")));
+            const engine = await createEngine(cwd, out);
+            const state = createPipelineState(cwd);
+            const pipelineSkills = ["normalize", ...artifactTypes, "validate"];
             await (0, hook_executor_1.runHookPhase)(cwd, "before_normalize", out);
-            const normalizedPath = await (0, normalize_1.runNormalize)({ cwd });
-            out(`Normalized brief written to: ${normalizedPath}`);
-            await (0, hook_executor_1.runHookPhase)(cwd, "after_normalize", out);
-            for (const type of artifactTypes) {
-                await runArtifactCommand(type, { from: normalizedPath, agent: opts.agent }, cwd, out, {
-                    suggestValidate: false
-                });
-            }
-            await (0, hook_executor_1.runHookPhase)(cwd, "before_validate", out);
-            const result = await (0, validate_1.runValidate)(cwd, {
-                strict: Boolean(opts.strict),
-                report: opts.report
+            const finalState = await engine.runPipeline(pipelineSkills, state, {
+                log: (msg) => {
+                    out(msg);
+                },
+                agent: opts.agent
             });
-            out(`Validation report written to: ${result.reportPath}`);
-            if (!result.pass) {
+            await (0, hook_executor_1.runHookPhase)(cwd, "after_validate", out);
+            if (finalState.validationResult && !finalState.validationResult.pass) {
+                out(`Validation report written to: ${finalState.validationResult.reportPath}`);
                 throw new errors_1.UserError("Validation failed. Review report and fix issues.");
             }
+            if (finalState.validationResult) {
+                out(`Validation report written to: ${finalState.validationResult.reportPath}`);
+            }
             out("Generation pipeline completed. Validation passed.");
-            await (0, hook_executor_1.runHookPhase)(cwd, "after_validate", out);
         });
     });
     program
@@ -393,34 +392,37 @@ async function runCli(options = {}) {
         });
     });
     program
-        .command("skills", { hidden: true })
-        .description("Advanced: manage and run skills")
+        .command("skills")
+        .description("Manage and run skills")
         .argument("[action]", "list or run", "list")
         .argument("[name]", "skill name (for run)")
         .option("--input <json>", "JSON input for skill execution")
         .action(async (action, name, opts) => {
-        const { getGlobalSkillEngine } = await Promise.resolve().then(() => __importStar(require("../skills/engine")));
-        const engine = getGlobalSkillEngine();
+        const { createEngine, createHydratedState } = await Promise.resolve().then(() => __importStar(require("../skill-engine")));
+        const engine = await createEngine(cwd, out);
+        const registry = engine.getRegistry();
         if (action === "list") {
-            const manifests = engine.listSkills();
+            const manifests = registry.listManifests();
             if (manifests.length === 0) {
                 out("No skills registered.");
                 return;
             }
             out("Available skills:\n");
             for (const m of manifests) {
-                out(`  ${m.name.padEnd(25)} [${m.category}] ${m.description}`);
+                const deps = m.depends_on.length > 0 ? ` (deps: ${m.depends_on.join(", ")})` : "";
+                out(`  ${m.name.padEnd(25)} [${m.category}] v${m.version} ${m.description}${deps}`);
             }
             return;
         }
         if (action === "run") {
             if (!name)
                 throw new errors_1.UserError("Skill name is required. Usage: prodo skills run <name>");
+            const state = await createHydratedState(cwd);
             const inputs = opts.input ? JSON.parse(opts.input) : {};
             inputs.cwd = inputs.cwd ?? cwd;
-            const result = await engine.execute(name, { cwd, log: out }, inputs);
+            const result = await engine.runSkill(name, state, { log: out });
             out(`\nSkill "${name}" completed.`);
-            out(JSON.stringify(result, null, 2));
+            out(`Completed skills: ${result.completedSkills.join(" → ")}`);
             return;
         }
         throw new errors_1.UserError(`Unknown skills action: "${action}". Use: list or run`);

package/dist/cli/init-tui.d.ts

@@ -2,7 +2,7 @@ import { type SupportedAi } from "./agent-command-installer";
 export type InitSelections = {
     ai?: SupportedAi;
     script: "sh" | "ps";
-    lang: "tr" | "en";
+    lang: string;
     author: string;
     interactive: boolean;
 };
@@ -17,7 +17,7 @@ export declare function finishInitInteractive(summary: {
     projectRoot: string;
     settingsPath: string;
     ai?: SupportedAi;
-    lang: "tr" | "en";
+    lang: string;
     author: string;
 }): Promise<void>;
 export {};

package/dist/cli/init-tui.js

@@ -56,26 +56,20 @@ function renderProjectBox(projectName, projectRoot) {
     return [top, ...rows, bottom].join("\n");
 }
 async function detectAi(projectRoot) {
+    if (await (0, utils_1.fileExists)(node_path_1.default.join(projectRoot, ".claude")))
+        return "claude-cli";
     if (await (0, utils_1.fileExists)(node_path_1.default.join(projectRoot, ".agents")))
         return "codex";
     if (await (0, utils_1.fileExists)(node_path_1.default.join(projectRoot, ".gemini")))
         return "gemini-cli";
-    if (await (0, utils_1.fileExists)(node_path_1.default.join(projectRoot, ".claude")))
-        return "claude-cli";
     return undefined;
 }
 function normalizeLang(lang) {
-    if ((lang ?? "").trim().toLowerCase().startsWith("tr"))
+    const raw = (lang ?? "").trim().toLowerCase();
+    if (raw.startsWith("tr"))
         return "tr";
     return "en";
 }
-function modelChoiceFromAi(ai) {
-    if (ai === "codex")
-        return "codex";
-    if (ai === "gemini-cli")
-        return "gemini";
-    return "auto-detect";
-}
 function defaultAuthorName(authorInput) {
     const explicit = (authorInput ?? "").trim();
     if (explicit.length > 0)
@@ -86,7 +80,7 @@ function defaultAuthorName(authorInput) {
             return username;
     }
     catch {
-        // ignore lookup errors and continue with fallback
+        // ignore
     }
     return "Product Author";
 }
@@ -106,11 +100,10 @@ async function gatherInitSelections(options) {
         };
     }
     const detectedAi = await detectAi(options.projectRoot);
-    const initialModel = modelChoiceFromAi(parsedAi ?? detectedAi);
     const projectName = node_path_1.default.basename(options.projectRoot) || ".";
     const width = terminalWidth();
-    const subtitle = color("Prodo — Product Artifact Toolkit", "\u001B[1;37m");
-    const signature = color("Crafted by Codex, guided by Shahmarasy intelligence", "\u001B[38;5;244m");
+    const subtitle = color("Prodo — AI-Powered Product Owner", "\u001B[1;37m");
+    const signature = color("Built by Shahmarasy · Works with Claude, Codex, and Gemini", "\u001B[38;5;244m");
     const hero = [
         "",
         centerBlock(renderLogo().split("\n"), width),
@@ -121,25 +114,25 @@ async function gatherInitSelections(options) {
     ].join("\n");
     clack.intro(hero);
     clack.note(renderProjectBox(projectName, options.projectRoot), "Project Setup");
-    const model = await clack.select({
-        message: "Select model",
-        initialValue: initialModel,
+    const agentChoice = await clack.select({
+        message: "Which AI agent will you use?",
+        initialValue: parsedAi ?? detectedAi ?? "claude-cli",
         options: [
-            { value: "codex", label: "codex", hint: "Native Codex flow" },
-            { value: "gemini", label: "gemini", hint: "Gemini CLI command set" },
-            { value: "auto-detect", label: "auto-detect", hint: "Detect from local agent directories" }
+            { value: "claude-cli", label: "Claude Code", hint: "Slash commands → .claude/commands/" },
+            { value: "codex", label: "Codex", hint: "Skills → .agents/skills/" },
+            { value: "gemini-cli", label: "Gemini CLI", hint: "Commands → .gemini/commands/" }
         ]
     });
-    if (clack.isCancel(model)) {
+    if (clack.isCancel(agentChoice)) {
         clack.cancel("Initialization cancelled.");
         throw new errors_1.UserError("Initialization cancelled.");
     }
     const lang = await clack.select({
-        message: "Select language",
+        message: "Document language",
         initialValue: defaultLang,
         options: [
-            { value: "tr", label: "tr", hint: "Turkish" },
-            { value: "en", label: "en", hint: "English" }
+            { value: "en", label: "English" },
+            { value: "tr", label: "Türkçe" }
         ]
     });
     if (clack.isCancel(lang)) {
@@ -148,29 +141,43 @@ async function gatherInitSelections(options) {
     }
     const author = await clack.text({
         message: "Author name",
-        placeholder: "Shahmarasy",
+        placeholder: "Your name",
         defaultValue: defaultAuthor
     });
     if (clack.isCancel(author)) {
         clack.cancel("Initialization cancelled.");
         throw new errors_1.UserError("Initialization cancelled.");
     }
-    let selectedAi;
-    if (model === "codex")
-        selectedAi = "codex";
-    else if (model === "gemini")
-        selectedAi = "gemini-cli";
-    else
-        selectedAi = detectedAi;
     return {
-        ai: selectedAi,
+        ai: agentChoice,
         script: fallbackScript,
-        lang,
+        lang: String(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}\nAuthor: ${summary.author}\nSettings: ${summary.settingsPath}\nNext: edit brief.md`));
+    const agentLabel = summary.ai === "claude-cli" ? "Claude Code"
+        : summary.ai === "codex" ? "Codex"
+            : summary.ai === "gemini-cli" ? "Gemini CLI"
+                : "none";
+    const commandPrefix = summary.ai === "codex" ? "$" : "/";
+    const commands = [
+        `${commandPrefix}prodo-normalize`,
+        `${commandPrefix}prodo-prd`,
+        `${commandPrefix}prodo-workflow`,
+        `${commandPrefix}prodo-wireframe`,
+        `${commandPrefix}prodo-stories`,
+        `${commandPrefix}prodo-techspec`,
+        `${commandPrefix}prodo-validate`
+    ];
+    return loadClack().then((clack) => clack.outro(`Scaffold complete!\n\n` +
+        `  Agent:    ${agentLabel}\n` +
+        `  Language: ${summary.lang}\n` +
+        `  Author:   ${summary.author}\n\n` +
+        `Next steps:\n` +
+        `  1. Edit brief.md with your product description\n` +
+        `  2. Open this folder in ${agentLabel}\n` +
+        `  3. Run commands in sequence:\n` +
+        `     ${commands.join("\n     ")}`));
 }

package/dist/cli/init.d.ts

@@ -5,6 +5,7 @@ export declare function runInit(cwd: string, options?: {
     author?: string;
     preset?: string;
     script?: "sh" | "ps";
+    provider?: string;
 }): Promise<{
     installedAgentFiles: string[];
     settingsPath: string;

package/dist/cli/init.js

@@ -312,7 +312,7 @@ async function runInit(cwd, options) {
         await rollbackFiles(backup);
         throw error;
     }
-    const installedAgentFiles = options?.ai ? await (0, agent_command_installer_1.installAgentCommands)(cwd, options.ai) : [];
+    const installedAgentFiles = options?.ai ? await (0, agent_command_installer_1.installAgentCommands)(cwd, options.ai, options?.lang) : [];
     const manifest = {
         schema_version: "1.0",
         generated_at: new Date().toISOString(),
@@ -328,7 +328,8 @@ async function runInit(cwd, options) {
     const settingsPath = await (0, settings_1.writeSettings)(cwd, {
         lang: (options?.lang ?? "en").trim() || "en",
         ai: options?.ai,
-        author: (options?.author ?? "").trim() || undefined
+        author: (options?.author ?? "").trim() || undefined,
+        provider: options?.provider
     });
     return { installedAgentFiles, settingsPath };
 }