@shahmarasy/prodo 0.1.3 → 0.1.4

package/src/cli.ts

@@ -4,7 +4,7 @@ import fs from "node:fs/promises";
 import path from "node:path";
 import { loadAgentCommandSet, resolveAgent } from "./agents";
 import { resolveAi, type SupportedAi } from "./agent-command-installer";
-import { listArtifactTypes } from "./artifact-registry";
+import { listArtifactDefinitions, listArtifactTypes } from "./artifact-registry";
 import { generateArtifact } from "./artifacts";
 import { runDoctor } from "./doctor";
 import { UserError } from "./errors";
@@ -30,10 +30,11 @@ const dynamicImport = new Function("specifier", "return import(specifier)") as (
   specifier: string
 ) => Promise<unknown>;
 
-function mapForcedCommand(forcedCommand: string): ArtifactType | "init" | "validate" | "normalize" | undefined {
+function mapForcedCommand(forcedCommand: string): ArtifactType | "init" | "validate" | "normalize" | "fix" | undefined {
   if (forcedCommand === "prodo-init") return "init";
   if (forcedCommand === "prodo-validate") return "validate";
   if (forcedCommand === "prodo-normalize") return "normalize";
+  if (forcedCommand === "prodo-fix") return "fix";
   if (forcedCommand === "prodo-prd") return "prd";
   if (forcedCommand === "prodo-workflow") return "workflow";
   if (forcedCommand === "prodo-wireframe") return "wireframe";
@@ -44,7 +45,7 @@ function mapForcedCommand(forcedCommand: string): ArtifactType | "init" | "valid
 
 async function runArtifactCommand(
   type: ArtifactType,
-  opts: { from?: string; out?: string; agent?: string },
+  opts: { from?: string; out?: string; agent?: string; revisionType?: "default" | "fix" },
   cwd: string,
   log: (message: string) => void,
   options?: { suggestValidate?: boolean }
@@ -56,7 +57,8 @@ async function runArtifactCommand(
     cwd,
     normalizedBriefOverride: opts.from,
     outPath: opts.out,
-    agent
+    agent,
+    revisionType: opts.revisionType
   });
   const agentMsg = agent ? ` [agent=${agent}]` : "";
   log(`${type.toUpperCase()} generated${agentMsg}: ${file}`);
@@ -116,13 +118,15 @@ export async function runCli(options: RunOptions = {}): Promise<number> {
     .command("init [target]")
     .option("--ai <name>", "agent integration: 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")
     .action(async (target, opts) => {
       const projectRoot = path.resolve(cwd, target ?? ".");
       const selected = await gatherInitSelections({
         projectRoot,
         aiInput: opts.ai,
-        langInput: opts.lang
+        langInput: opts.lang,
+        authorInput: opts.author
       });
       const selectedAi = selected.ai as SupportedAi | undefined;
 
@@ -133,6 +137,7 @@ export async function runCli(options: RunOptions = {}): Promise<number> {
         const result = await runInit(projectRoot, {
           ai: selectedAi,
           lang: selected.lang,
+          author: selected.author,
           preset: opts.preset,
           script: selected.script
         });
@@ -141,7 +146,8 @@ export async function runCli(options: RunOptions = {}): Promise<number> {
           projectRoot,
           settingsPath: result.settingsPath,
           ai: selectedAi,
-          lang: selected.lang
+          lang: selected.lang,
+          author: selected.author
         });
         return;
       }
@@ -149,6 +155,7 @@ export async function runCli(options: RunOptions = {}): Promise<number> {
       const result = await runInit(projectRoot, {
         ai: selectedAi,
         lang: selected.lang,
+        author: selected.author,
         preset: opts.preset,
         script: selected.script
       });
@@ -161,6 +168,7 @@ export async function runCli(options: RunOptions = {}): Promise<number> {
         out("No agent selected. Use `prodo generate` for end-to-end generation.");
       }
       out(`Settings file: ${result.settingsPath}`);
+      out(`Author: ${selected.author}`);
       out("Next: edit brief.md.");
     });
 
@@ -198,6 +206,56 @@ export async function runCli(options: RunOptions = {}): Promise<number> {
       });
     });
 
+  program
+    .command("fix", { hidden: true })
+    .description("Advanced: auto-regenerate affected artifacts from validation findings")
+    .option("--agent <name>", "agent profile: codex | gemini-cli | claude-cli")
+    .option("--strict", "treat validation warnings as errors")
+    .option("--report <path>", "validation report output path")
+    .action(async (opts) => {
+      if (opts.agent) resolveAgent(opts.agent);
+      await withBriefReadOnlyGuard(cwd, async () => {
+        await runHookPhase(cwd, "before_validate", out);
+        const initial = await runValidate(cwd, {
+          strict: Boolean(opts.strict),
+          report: opts.report
+        });
+        out(`Validation report written to: ${initial.reportPath}`);
+        await runHookPhase(cwd, "after_validate", out);
+
+        if (initial.pass) {
+          out("No blocking issues found. Nothing to fix.");
+          return;
+        }
+
+        const targets = await resolveFixTargets(cwd, artifactTypes, initial.issues);
+        out(`Validation failed. Regenerating impacted artifacts: ${targets.join(", ")}`);
+
+        await runHookPhase(cwd, "before_normalize", out);
+        const normalizedPath = await runNormalize({ cwd });
+        out(`Normalized brief refreshed: ${normalizedPath}`);
+        await runHookPhase(cwd, "after_normalize", out);
+
+        for (const type of targets) {
+          await runArtifactCommand(type, { from: normalizedPath, agent: opts.agent, revisionType: "fix" }, cwd, out, {
+            suggestValidate: false
+          });
+        }
+
+        await runHookPhase(cwd, "before_validate", out);
+        const final = await runValidate(cwd, {
+          strict: Boolean(opts.strict),
+          report: opts.report
+        });
+        out(`Validation report written to: ${final.reportPath}`);
+        if (!final.pass) {
+          throw new UserError("Fix completed but validation is still failing. Review report and retry.");
+        }
+        out("Fix pipeline completed. Validation passed.");
+        await runHookPhase(cwd, "after_validate", out);
+      });
+    });
+
   program
     .command("normalize", { hidden: true })
     .description("Advanced: normalize brief without full pipeline")
@@ -294,6 +352,8 @@ export async function runCli(options: RunOptions = {}): Promise<number> {
         await program.parseAsync(["node", "prodo", "normalize", ...argv.slice(2)]);
       } else if (forced === "validate") {
         await program.parseAsync(["node", "prodo", "validate", ...argv.slice(2)]);
+      } else if (forced === "fix") {
+        await program.parseAsync(["node", "prodo", "fix", ...argv.slice(2)]);
       } else {
         await program.parseAsync(["node", "prodo", forced, ...argv.slice(2)]);
       }
@@ -317,3 +377,34 @@ if (require.main === module) {
     process.exitCode = code;
   });
 }
+
+async function resolveFixTargets(
+  cwd: string,
+  artifactTypes: ArtifactType[],
+  issues: Array<{ artifactType?: ArtifactType }>
+): Promise<ArtifactType[]> {
+  const direct = new Set<ArtifactType>(
+    issues
+      .map((issue) => issue.artifactType)
+      .filter(
+        (artifactType): artifactType is ArtifactType =>
+          typeof artifactType === "string" && artifactTypes.includes(artifactType)
+      )
+  );
+  if (direct.size === 0) return artifactTypes;
+
+  const defs = await listArtifactDefinitions(cwd);
+  let changed = true;
+  while (changed) {
+    changed = false;
+    for (const def of defs) {
+      const needsRefresh = def.upstream.some((upstream) => direct.has(upstream));
+      if (needsRefresh && !direct.has(def.name)) {
+        direct.add(def.name);
+        changed = true;
+      }
+    }
+  }
+
+  return artifactTypes.filter((artifactType) => direct.has(artifactType));
+}

package/src/init-tui.ts

@@ -1,4 +1,5 @@
 import path from "node:path";
+import os from "node:os";
 import { resolveAi, type SupportedAi } from "./agent-command-installer";
 import { UserError } from "./errors";
 import { fileExists } from "./utils";
@@ -7,6 +8,7 @@ export type InitSelections = {
   ai?: SupportedAi;
   script: "sh" | "ps";
   lang: "tr" | "en";
+  author: string;
   interactive: boolean;
 };
 
@@ -14,6 +16,7 @@ type GatherInitUiOptions = {
   projectRoot: string;
   aiInput?: string;
   langInput?: string;
+  authorInput?: string;
 };
 
 type ClackPrompts = typeof import("@clack/prompts");
@@ -93,17 +96,31 @@ function modelChoiceFromAi(ai?: SupportedAi): "codex" | "gemini" | "auto-detect"
   return "auto-detect";
 }
 
+function defaultAuthorName(authorInput?: string): string {
+  const explicit = (authorInput ?? "").trim();
+  if (explicit.length > 0) return explicit;
+  try {
+    const username = os.userInfo().username.trim();
+    if (username.length > 0) return username;
+  } catch {
+    // ignore lookup errors and continue with fallback
+  }
+  return "Product Author";
+}
+
 export async function gatherInitSelections(options: GatherInitUiOptions): Promise<InitSelections> {
   const clack = await loadClack();
   const defaultLang = normalizeLang(options.langInput);
   const fallbackScript: "sh" | "ps" = process.platform === "win32" ? "ps" : "sh";
   const parsedAi = resolveAi(options.aiInput);
+  const defaultAuthor = defaultAuthorName(options.authorInput);
 
   if (!isInteractiveTerminal()) {
     return {
       ai: parsedAi,
       script: fallbackScript,
       lang: defaultLang,
+      author: defaultAuthor,
       interactive: false
     };
   }
@@ -153,6 +170,16 @@ export async function gatherInitSelections(options: GatherInitUiOptions): Promis
     throw new 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 UserError("Initialization cancelled.");
+  }
+
   let selectedAi: SupportedAi | undefined;
   if (model === "codex") selectedAi = "codex";
   else if (model === "gemini") selectedAi = "gemini-cli";
@@ -162,6 +189,7 @@ export async function gatherInitSelections(options: GatherInitUiOptions): Promis
     ai: selectedAi,
     script: fallbackScript,
     lang,
+    author: String(author).trim() || defaultAuthor,
     interactive: true
   };
 }
@@ -171,9 +199,10 @@ export function finishInitInteractive(summary: {
   settingsPath: string;
   ai?: SupportedAi;
   lang: "tr" | "en";
+  author: string;
 }): Promise<void> {
   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`
+    `Scaffold complete.\nAI: ${aiText}\nLanguage: ${summary.lang}\nAuthor: ${summary.author}\nSettings: ${summary.settingsPath}\nNext: edit brief.md`
   ));
 }

package/src/init.ts

@@ -9,6 +9,7 @@ import { briefPath, outputDirPath, outputIndexPath, prodoPath } from "./paths";
 import { applyConfiguredPresets } from "./preset-loader";
 import { syncRegistry } from "./registry";
 import { writeSettings } from "./settings";
+import { extractRequiredHeadingsFromTemplate } from "./template-resolver";
 import { buildWorkflowCommands } from "./workflow-commands";
 import {
   NORMALIZED_BRIEF_TEMPLATE,
@@ -283,7 +284,7 @@ function summarizeParity(items: AssetManifestItem[]): ScaffoldManifest["parity_s
 
 export async function runInit(
   cwd: string,
-  options?: { ai?: SupportedAi; lang?: string; preset?: string; script?: "sh" | "ps" }
+  options?: { ai?: SupportedAi; lang?: string; author?: string; preset?: string; script?: "sh" | "ps" }
 ): Promise<{ installedAgentFiles: string[]; settingsPath: string }> {
   const root = prodoPath(cwd);
   const artifactDefs = await listArtifactDefinitions(cwd);
@@ -325,15 +326,20 @@ export async function runInit(
   const scriptType = options?.script ?? (process.platform === "win32" ? "ps" : "sh");
   await fs.writeFile(
     path.join(root, "init-options.json"),
-    `${JSON.stringify({ ai: options?.ai ?? null, lang: options?.lang ?? "en", preset: options?.preset ?? null, script: scriptType }, null, 2)}\n`,
+    `${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(path.join(projectScaffoldTemplates, "artifacts"), path.join(root, "templates"), copiedAssets);
   for (const artifact of artifactDefs) {
+    const markdownTemplatePath = path.join(root, "templates", `${artifact.name}.md`);
+    const templateHeadings =
+      (await fileExists(markdownTemplatePath))
+        ? extractRequiredHeadingsFromTemplate(await fs.readFile(markdownTemplatePath, "utf8"))
+        : [];
     const schema = {
       ...schemaTemplate(artifact.name),
-      x_required_headings: artifact.required_headings
+      x_required_headings: templateHeadings.length > 0 ? templateHeadings : artifact.required_headings
     };
     await writeFileIfMissing(path.join(root, "schemas", `${artifact.name}.yaml`), yaml.dump(schema));
     await writeFileIfMissing(path.join(root, "prompts", `${artifact.name}.md`), `${promptTemplate(artifact.name, options?.lang ?? "en")}\n`);
@@ -385,7 +391,8 @@ export async function runInit(
   await syncRegistry(cwd);
   const settingsPath = await writeSettings(cwd, {
     lang: (options?.lang ?? "en").trim() || "en",
-    ai: options?.ai
+    ai: options?.ai,
+    author: (options?.author ?? "").trim() || undefined
   });
   return { installedAgentFiles, settingsPath };
 }

package/src/normalize.ts

@@ -17,6 +17,53 @@ type NormalizeOptions = {
   out?: string;
 };
 
+function normalizedKey(value: string): string {
+  return value
+    .normalize("NFD")
+    .replace(/[\u0300-\u036f]/g, "")
+    .replace(/ı/g, "i")
+    .replace(/İ/g, "I")
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, " ")
+    .trim();
+}
+
+function extractBriefProductName(rawBrief: string): string | undefined {
+  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: Record<string, unknown>,
+  rawBrief: string
+): Record<string, unknown> {
+  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: string): Record<string, unknown> {
   const trimmed = raw.trim();
   const fenced = trimmed.match(/```(?:json)?\s*([\s\S]*?)```/i);
@@ -61,17 +108,18 @@ export async function runNormalize(options: NormalizeOptions): Promise<string> {
   );
 
   const parsed = extractJsonObject(generated.body);
+  const preserved = preserveOriginalProductName(parsed, rawBrief);
   const withContracts = {
-    ...parsed,
+    ...preserved,
     contracts:
-      parsed.contracts ??
+      preserved.contracts ??
       buildContractsFromArrays({
-        goals: Array.isArray(parsed.goals) ? parsed.goals.filter((x): x is string => typeof x === "string") : [],
-        core_features: Array.isArray(parsed.core_features)
-          ? parsed.core_features.filter((x): x is string => typeof x === "string")
+        goals: Array.isArray(preserved.goals) ? preserved.goals.filter((x): x is string => typeof x === "string") : [],
+        core_features: Array.isArray(preserved.core_features)
+          ? preserved.core_features.filter((x): x is string => typeof x === "string")
           : [],
-        constraints: Array.isArray(parsed.constraints)
-          ? parsed.constraints.filter((x): x is string => typeof x === "string")
+        constraints: Array.isArray(preserved.constraints)
+          ? preserved.constraints.filter((x): x is string => typeof x === "string")
           : []
       })
   };

package/src/providers/openai-provider.ts

@@ -37,7 +37,8 @@ export class OpenAIProvider implements LLMProvider {
     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/src/settings.ts

@@ -5,6 +5,7 @@ import { fileExists } from "./utils";
 export type ProdoSettings = {
   lang: string;
   ai?: string;
+  author?: string;
 };
 
 const DEFAULT_SETTINGS: ProdoSettings = {
@@ -19,7 +20,8 @@ export async function readSettings(cwd: string): Promise<ProdoSettings> {
     const parsed = JSON.parse(raw) as Partial<ProdoSettings>;
     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 {
     return { ...DEFAULT_SETTINGS };
@@ -31,4 +33,3 @@ export async function writeSettings(cwd: string, settings: ProdoSettings): Promi
   await fs.writeFile(path, `${JSON.stringify(settings, null, 2)}\n`, "utf8");
   return path;
 }
-

package/src/templates.ts

@@ -347,6 +347,8 @@ Return JSON object with keys:
 Rules:
 - do NOT invent missing critical content
 - keep wording concise and concrete
+- preserve original language and Unicode characters exactly from brief
+- never transliterate Turkish letters (ç, ğ, ı, İ, ö, ş, ü) into ASCII
 - if critical field is missing, return empty and low confidence (<0.7)
 - assign deterministic IDs: goals => G1..Gn, features => F1..Fn, constraints => C1..Cn
 - input files are read-only; never modify, summarize, or rewrite \`brief.md\` in-place

package/src/utils.ts

@@ -23,6 +23,20 @@ export function timestampSlug(date = new Date()): string {
   return date.toISOString().replace(/[:.]/g, "-");
 }
 
+function pad2(value: number): string {
+  return String(value).padStart(2, "0");
+}
+
+export function artifactFileStamp(date = new Date()): string {
+  const year = date.getFullYear();
+  const month = pad2(date.getMonth() + 1);
+  const day = pad2(date.getDate());
+  const hour = pad2(date.getHours());
+  const minute = pad2(date.getMinutes());
+  const second = pad2(date.getSeconds());
+  return `${year}${month}${day}-${hour}${minute}${second}`;
+}
+
 export async function listFilesSortedByMtime(dirPath: string): Promise<string[]> {
   const exists = await fileExists(dirPath);
   if (!exists) return [];

package/src/validator.ts

@@ -59,10 +59,6 @@ export async function validateSchema(
   }
 
   const sections = sectionTextMap(doc.body);
-  const trMode = String((doc.frontmatter as Record<string, unknown>).language ?? "").toLowerCase().startsWith("tr");
-  if (trMode) {
-    return { issues, requiredHeadings: [] };
-  }
   for (const heading of requiredHeadings) {
     if (!doc.body.includes(heading)) {
       issues.push({

package/src/workflow-commands.ts

@@ -11,7 +11,8 @@ const BASE_WORKFLOW_COMMANDS: WorkflowCommand[] = [
   { 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-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." }
 ];
 
 export const WORKFLOW_COMMANDS: WorkflowCommand[] = BASE_WORKFLOW_COMMANDS;

package/templates/commands/prodo-fix.md

@@ -0,0 +1,46 @@
+---
+description: Fix failing artifacts using latest validation report and brief-aligned regeneration.
+agent-role: "Recovery Engineer"
+---
+
+## User Input
+
+```text
+$ARGUMENTS
+```
+
+## Execution Policy
+
+- Execute-first, diagnose-second.
+- Do not run shell commands or CLI commands from inside the agent.
+- Never invoke `prodo-fix`, `prodo fix`, or any `prodo ...` command in shell.
+- Input files are read-only; never modify `brief.md`.
+- Write outputs only under `product-docs/` and `.prodo/`.
+- Do not print full artifact bodies in chat.
+
+## Execution
+
+1. Minimum prerequisites only:
+- `.prodo/` exists
+- `brief.md` exists
+- `.prodo/briefs/normalized-brief.json` exists (refresh if stale)
+- Validation report exists in `product-docs/reports/`
+
+2. Execute fix process immediately:
+- Read latest validation report.
+- Identify failing artifact types and regenerate only impacted chain.
+- Use normalized brief + active templates for regeneration.
+
+3. Verify result:
+- Re-run validation.
+- Confirm report status is PASS.
+- Confirm `brief.md` remained unchanged.
+
+4. Diagnose only on failure:
+- Inspect internal hooks/scripts only after fix attempt fails.
+- Return concise root cause + next repair action.
+
+## Handoff
+
+If pass: suggest next command `/prodo-validate`.
+If fail: suggest highest-priority artifact command to regenerate manually.