@shahmarasy/prodo 0.1.3 → 0.1.5

package/src/{validator.ts → core/validator.ts}

@@ -1,96 +1,92 @@
-import fs from "node:fs/promises";
-import Ajv2020 from "ajv/dist/2020";
-import addFormats from "ajv-formats";
-import yaml from "js-yaml";
-import { sectionTextMap } from "./markdown";
-import type { ArtifactDoc, ArtifactType, ValidationIssue } from "./types";
-import { schemaPath } from "./paths";
-
-type SchemaWithHeading = Record<string, unknown> & {
-  x_required_headings?: unknown;
-};
-
-const ajv = new Ajv2020({ allErrors: true, strict: false });
-addFormats(ajv);
-
-async function resolveSchema(
-  cwd: string,
-  artifactType: ArtifactType
-): Promise<SchemaWithHeading> {
-  const raw = await fs.readFile(schemaPath(cwd, artifactType), "utf8");
-  return yaml.load(raw) as SchemaWithHeading;
-}
-
-function requiredHeadingsFromSchema(schema: SchemaWithHeading): string[] {
-  if (!Array.isArray(schema.x_required_headings)) return [];
-  return schema.x_required_headings.filter((item): item is string => typeof item === "string");
-}
-
-export async function validateSchema(
-  cwd: string,
-  artifactType: ArtifactType,
-  doc: ArtifactDoc,
-  requiredHeadingsOverride?: string[]
-): Promise<{ issues: ValidationIssue[]; requiredHeadings: string[] }> {
-  const schema = await resolveSchema(cwd, artifactType);
-  const requiredHeadings =
-    requiredHeadingsOverride && requiredHeadingsOverride.length > 0
-      ? requiredHeadingsOverride
-      : requiredHeadingsFromSchema(schema);
-  const workingSchema: Record<string, unknown> = { ...schema };
-  delete workingSchema.x_required_headings;
-
-  const validate = ajv.compile(workingSchema);
-  const valid = validate(doc);
-  const issues: ValidationIssue[] = [];
-
-  if (!valid && validate.errors) {
-    for (const err of validate.errors) {
-      issues.push({
-        level: "error",
-        code: "schema_validation_failed",
-        check: "schema",
-        artifactType,
-        field: err.instancePath || err.schemaPath,
-        message: `Schema validation error: ${err.message ?? "unknown error"}`,
-        suggestion: "Adjust the generated content to satisfy schema requirements."
-      });
-    }
-  }
-
-  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({
-        level: "error",
-        code: "missing_required_heading",
-        check: "schema",
-        artifactType,
-        field: heading,
-        message: `Required section missing: ${heading}`,
-        suggestion: "Regenerate or manually edit the artifact to include all required headings."
-      });
-      continue;
-    }
-
-    const content = sections.get(heading) ?? "";
-    const isPlaceholder = /(tbd|to be defined|i don't know|unknown|n\/a)/i.test(content);
-    if (content.trim().length < 20 || isPlaceholder) {
-      issues.push({
-        level: "error",
-        code: "weak_required_heading_content",
-        check: "schema",
-        artifactType,
-        field: heading,
-        message: `Section has weak or placeholder content: ${heading}`,
-        suggestion: "Replace placeholders with concrete, actionable details."
-      });
-    }
-  }
-
-  return { issues, requiredHeadings };
-}
+import fs from "node:fs/promises";
+import Ajv2020 from "ajv/dist/2020";
+import addFormats from "ajv-formats";
+import yaml from "js-yaml";
+import { sectionTextMap } from "./markdown";
+import type { ArtifactDoc, ArtifactType, ValidationIssue } from "./types";
+import { schemaPath } from "./paths";
+
+type SchemaWithHeading = Record<string, unknown> & {
+  x_required_headings?: unknown;
+};
+
+const ajv = new Ajv2020({ allErrors: true, strict: false });
+addFormats(ajv);
+
+async function resolveSchema(
+  cwd: string,
+  artifactType: ArtifactType
+): Promise<SchemaWithHeading> {
+  const raw = await fs.readFile(schemaPath(cwd, artifactType), "utf8");
+  return yaml.load(raw) as SchemaWithHeading;
+}
+
+function requiredHeadingsFromSchema(schema: SchemaWithHeading): string[] {
+  if (!Array.isArray(schema.x_required_headings)) return [];
+  return schema.x_required_headings.filter((item): item is string => typeof item === "string");
+}
+
+export async function validateSchema(
+  cwd: string,
+  artifactType: ArtifactType,
+  doc: ArtifactDoc,
+  requiredHeadingsOverride?: string[]
+): Promise<{ issues: ValidationIssue[]; requiredHeadings: string[] }> {
+  const schema = await resolveSchema(cwd, artifactType);
+  const requiredHeadings =
+    requiredHeadingsOverride && requiredHeadingsOverride.length > 0
+      ? requiredHeadingsOverride
+      : requiredHeadingsFromSchema(schema);
+  const workingSchema: Record<string, unknown> = { ...schema };
+  delete workingSchema.x_required_headings;
+
+  const validate = ajv.compile(workingSchema);
+  const valid = validate(doc);
+  const issues: ValidationIssue[] = [];
+
+  if (!valid && validate.errors) {
+    for (const err of validate.errors) {
+      issues.push({
+        level: "error",
+        code: "schema_validation_failed",
+        check: "schema",
+        artifactType,
+        field: err.instancePath || err.schemaPath,
+        message: `Schema validation error: ${err.message ?? "unknown error"}`,
+        suggestion: "Adjust the generated content to satisfy schema requirements."
+      });
+    }
+  }
+
+  const sections = sectionTextMap(doc.body);
+  for (const heading of requiredHeadings) {
+    if (!doc.body.includes(heading)) {
+      issues.push({
+        level: "error",
+        code: "missing_required_heading",
+        check: "schema",
+        artifactType,
+        field: heading,
+        message: `Required section missing: ${heading}`,
+        suggestion: "Regenerate or manually edit the artifact to include all required headings."
+      });
+      continue;
+    }
+
+    const content = sections.get(heading) ?? "";
+    const isPlaceholder = /(tbd|to be defined|i don't know|unknown|n\/a)/i.test(content);
+    if (content.trim().length < 20 || isPlaceholder) {
+      issues.push({
+        level: "error",
+        code: "weak_required_heading_content",
+        check: "schema",
+        artifactType,
+        field: heading,
+        message: `Section has weak or placeholder content: ${heading}`,
+        suggestion: "Replace placeholders with concrete, actionable details."
+      });
+    }
+  }
+
+  return { issues, requiredHeadings };
+}

package/src/{version.ts → core/version.ts}

@@ -1,24 +1,24 @@
-import fs from "node:fs/promises";
-import path from "node:path";
-import { fileExists } from "./utils";
-
-export async function readCliVersion(cwd: string): Promise<string> {
-  const candidates = [
-    path.join(cwd, "package.json"),
-    path.resolve(__dirname, "..", "package.json")
-  ];
-  for (const candidate of candidates) {
-    if (!(await fileExists(candidate))) continue;
-    try {
-      const raw = await fs.readFile(candidate, "utf8");
-      const parsed = JSON.parse(raw) as { version?: unknown };
-      if (typeof parsed.version === "string" && parsed.version.trim().length > 0) {
-        return parsed.version.trim();
-      }
-    } catch {
-      // ignore and continue
-    }
-  }
-  return "0.0.0";
-}
-
+import fs from "node:fs/promises";
+import path from "node:path";
+import { fileExists } from "./utils";
+
+export async function readCliVersion(cwd: string): Promise<string> {
+  const candidates = [
+    path.join(cwd, "package.json"),
+    path.resolve(__dirname, "..", "..", "package.json")
+  ];
+  for (const candidate of candidates) {
+    if (!(await fileExists(candidate))) continue;
+    try {
+      const raw = await fs.readFile(candidate, "utf8");
+      const parsed = JSON.parse(raw) as { version?: unknown };
+      if (typeof parsed.version === "string" && parsed.version.trim().length > 0) {
+        return parsed.version.trim();
+      }
+    } catch {
+      // ignore and continue
+    }
+  }
+  return "0.0.0";
+}
+

package/src/{workflow-commands.ts → core/workflow-commands.ts}

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

package/src/i18n/en.json

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

package/src/i18n/index.ts

@@ -0,0 +1,58 @@
+import fs from "node:fs";
+import path from "node:path";
+
+type TranslationMap = Record<string, string>;
+
+const cache = new Map<string, TranslationMap>();
+
+function loadJson(lang: string): TranslationMap {
+  if (cache.has(lang)) return cache.get(lang)!;
+  const filePath = path.resolve(__dirname, `${lang}.json`);
+  try {
+    const raw = fs.readFileSync(filePath, "utf8");
+    const parsed = JSON.parse(raw) as TranslationMap;
+    cache.set(lang, parsed);
+    return parsed;
+  } catch {
+    cache.set(lang, {});
+    return {};
+  }
+}
+
+function normalizeLang(lang?: string): string {
+  if (!lang) return "en";
+  const code = lang.toLowerCase().trim();
+  if (code.startsWith("tr")) return "tr";
+  if (code.startsWith("en")) return "en";
+  return code;
+}
+
+export function t(key: string, lang?: string): string {
+  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;
+}
+
+export function loadTranslations(lang: string): TranslationMap {
+  return { ...loadJson(normalizeLang(lang)) };
+}
+
+export function availableLanguages(): string[] {
+  const dir = path.resolve(__dirname);
+  try {
+    return fs.readdirSync(dir)
+      .filter((f) => f.endsWith(".json"))
+      .map((f) => f.replace(".json", ""))
+      .sort();
+  } catch {
+    return ["en"];
+  }
+}

package/src/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/src/providers/index.ts

@@ -1,12 +1,29 @@
-import type { LLMProvider } from "../types";
-import { MockProvider } from "./mock-provider";
-import { OpenAIProvider } from "./openai-provider";
-
-export function createProvider(): LLMProvider {
-  const provider = (process.env.PRODO_LLM_PROVIDER ?? "mock").toLowerCase();
-  if (provider === "openai") {
-    return new OpenAIProvider();
-  }
-  return new MockProvider();
-}
-
+import type { LLMProvider } from "../core/types";
+import { getGlobalRegistry } from "../agents/agent-registry";
+
+let cachedProvider: LLMProvider | null = null;
+let cachedAgentName: string | null = null;
+
+export function createProvider(): LLMProvider {
+  const agentName =
+    process.env.PRODO_AGENT ??
+    process.env.PRODO_LLM_PROVIDER ??
+    "mock";
+
+  if (cachedProvider && cachedAgentName === agentName) {
+    return cachedProvider;
+  }
+
+  const registry = 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;
+}
+
+export { getGlobalRegistry } from "../agents/agent-registry";