@shahmarasy/prodo 0.1.3 → 0.1.5

package/src/core/normalize.ts

@@ -0,0 +1,145 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { UserError } from "./errors";
+import {
+  buildContractsFromArrays,
+  parseNormalizedBriefOrThrow,
+  requireConfidenceOrThrow
+} from "./normalized-brief";
+import { briefPath, normalizedBriefPath, prodoPath } from "./paths";
+import { createProvider } from "../providers";
+import { readSettings } from "./settings";
+import { fileExists, isPathInside } from "./utils";
+
+type NormalizeOptions = {
+  cwd: string;
+  brief?: string;
+  out?: string;
+  additionalContext?: Record<string, 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);
+  const candidate = fenced ? fenced[1] : trimmed;
+  try {
+    return JSON.parse(candidate) as Record<string, unknown>;
+  } catch {
+    throw new UserError("Normalizer provider did not return valid JSON.");
+  }
+}
+
+export async function runNormalize(options: NormalizeOptions): Promise<string> {
+  const { cwd } = options;
+  const root = prodoPath(cwd);
+  if (!(await fileExists(root))) {
+    throw new UserError("Missing .prodo directory. Run `prodo init .` first.");
+  }
+
+  const inPath = options.brief ? path.resolve(cwd, options.brief) : briefPath(cwd);
+  if (!(await fileExists(inPath))) {
+    throw new UserError(`Brief file not found: ${inPath}`);
+  }
+
+  const rawBrief = await fs.readFile(inPath, "utf8");
+  const normalizePromptPath = path.join(root, "prompts", "normalize.md");
+  const normalizePrompt = await fs.readFile(normalizePromptPath, "utf8");
+  const settings = await readSettings(cwd);
+  const provider = createProvider();
+
+  const inputContext: Record<string, unknown> = {
+    briefMarkdown: rawBrief,
+    sourceBriefPath: inPath,
+    outputLanguage: settings.lang
+  };
+  if (options.additionalContext && Object.keys(options.additionalContext).length > 0) {
+    inputContext.userClarifications = options.additionalContext;
+  }
+
+  const generated = await provider.generate(
+    normalizePrompt,
+    inputContext,
+    {
+      artifactType: "normalize",
+      requiredHeadings: [],
+      requiredContracts: []
+    }
+  );
+
+  const parsed = extractJsonObject(generated.body);
+  const preserved = preserveOriginalProductName(parsed, rawBrief);
+  const withContracts = {
+    ...preserved,
+    contracts:
+      preserved.contracts ??
+      buildContractsFromArrays({
+        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(preserved.constraints)
+          ? preserved.constraints.filter((x): x is string => typeof x === "string")
+          : []
+      })
+  };
+
+  const normalized = parseNormalizedBriefOrThrow(withContracts);
+
+  const outPath = options.out ? path.resolve(cwd, options.out) : normalizedBriefPath(cwd);
+  if (!isPathInside(prodoPath(cwd), outPath)) {
+    throw new UserError("Normalize output must be inside `.prodo/`.");
+  }
+  await fs.mkdir(path.dirname(outPath), { recursive: true });
+  await fs.writeFile(outPath, `${JSON.stringify(normalized, null, 2)}\n`, "utf8");
+
+  requireConfidenceOrThrow(normalized, ["product_name", "problem", "audience", "goals", "core_features"], 0.7);
+
+  return outPath;
+}

package/src/{normalized-brief.ts → core/normalized-brief.ts}

@@ -1,206 +1,227 @@
-import Ajv2020 from "ajv/dist/2020";
-import { UserError } from "./errors";
-import type { ValidationIssue } from "./types";
-
-export type BriefContractItem = {
-  id: string;
-  text: string;
-};
-
-export type NormalizedBrief = {
-  schema_version: string;
-  product_name: string;
-  problem: string;
-  audience: string[];
-  goals: string[];
-  core_features: string[];
-  constraints: string[];
-  assumptions: string[];
-  contracts: {
-    goals: BriefContractItem[];
-    core_features: BriefContractItem[];
-    constraints: BriefContractItem[];
-  };
-  confidence?: Record<string, number>;
-};
-
-type BriefContracts = NormalizedBrief["contracts"];
-
-const schema: Record<string, unknown> = {
-  $schema: "https://json-schema.org/draft/2020-12/schema",
-  type: "object",
-  required: [
-    "schema_version",
-    "product_name",
-    "problem",
-    "audience",
-    "goals",
-    "core_features",
-    "constraints",
-    "assumptions",
-    "contracts"
-  ],
-  properties: {
-    schema_version: { type: "string", minLength: 1 },
-    product_name: { type: "string", minLength: 2 },
-    problem: { type: "string", minLength: 10 },
-    audience: { type: "array", minItems: 1, items: { type: "string", minLength: 2 } },
-    goals: { type: "array", minItems: 1, items: { type: "string", minLength: 2 } },
-    core_features: { type: "array", minItems: 1, items: { type: "string", minLength: 2 } },
-    constraints: { type: "array", items: { type: "string", minLength: 2 } },
-    assumptions: { type: "array", items: { type: "string", minLength: 2 } },
-    contracts: {
-      type: "object",
-      required: ["goals", "core_features", "constraints"],
-      properties: {
-        goals: { $ref: "#/$defs/contractArray" },
-        core_features: { $ref: "#/$defs/contractArray" },
-        constraints: { $ref: "#/$defs/contractArray" }
-      },
-      additionalProperties: false
-    },
-    confidence: {
-      type: "object",
-      additionalProperties: { type: "number", minimum: 0, maximum: 1 }
-    }
-  },
-  $defs: {
-    contractItem: {
-      type: "object",
-      required: ["id", "text"],
-      properties: {
-        id: { type: "string", pattern: "^[A-Z]+[0-9]+$" },
-        text: { type: "string", minLength: 2 }
-      },
-      additionalProperties: false
-    },
-    contractArray: { type: "array", items: { $ref: "#/$defs/contractItem" } }
-  },
-  additionalProperties: false
-};
-
-const ajv = new Ajv2020({ allErrors: true, strict: false });
-const validateFn = ajv.compile(schema);
-
-function asString(value: unknown): string | undefined {
-  if (typeof value !== "string") return undefined;
-  const trimmed = value.trim();
-  return trimmed.length > 0 ? trimmed : undefined;
-}
-
-function asStringArray(value: unknown): string[] {
-  if (!Array.isArray(value)) return [];
-  return value
-    .map((item) => asString(item))
-    .filter((item): item is string => typeof item === "string");
-}
-
-function asContracts(value: unknown): BriefContractItem[] {
-  if (!Array.isArray(value)) return [];
-  return value
-    .map((item) => {
-      if (!item || typeof item !== "object") return null;
-      const record = item as Record<string, unknown>;
-      const id = asString(record.id);
-      const text = asString(record.text);
-      if (!id || !text) return null;
-      return { id, text };
-    })
-    .filter((item): item is BriefContractItem => item !== null);
-}
-
-function asConfidence(value: unknown): Record<string, number> | undefined {
-  if (!value || typeof value !== "object") return undefined;
-  const result: Record<string, number> = {};
-  for (const [key, raw] of Object.entries(value as Record<string, unknown>)) {
-    if (typeof raw !== "number" || Number.isNaN(raw)) continue;
-    result[key] = raw;
-  }
-  return Object.keys(result).length > 0 ? result : undefined;
-}
-
-function normalizeInput(input: Record<string, unknown>): NormalizedBrief {
-  const rawContracts = (input.contracts as Record<string, unknown> | undefined) ?? {};
-  return {
-    schema_version: asString(input.schema_version) ?? "1.0",
-    product_name: asString(input.product_name) ?? "",
-    problem: asString(input.problem) ?? "",
-    audience: asStringArray(input.audience),
-    goals: asStringArray(input.goals),
-    core_features: asStringArray(input.core_features),
-    constraints: asStringArray(input.constraints),
-    assumptions: asStringArray(input.assumptions),
-    contracts: {
-      goals: asContracts(rawContracts.goals),
-      core_features: asContracts(rawContracts.core_features),
-      constraints: asContracts(rawContracts.constraints)
-    },
-    confidence: asConfidence(input.confidence)
-  };
-}
-
-export function buildContractsFromArrays(input: {
-  goals: string[];
-  core_features: string[];
-  constraints: string[];
-}): BriefContracts {
-  return {
-    goals: input.goals.map((text, index) => ({ id: `G${index + 1}`, text })),
-    core_features: input.core_features.map((text, index) => ({ id: `F${index + 1}`, text })),
-    constraints: input.constraints.map((text, index) => ({ id: `C${index + 1}`, text }))
-  };
-}
-
-export function parseNormalizedBrief(input: Record<string, unknown>): {
-  brief: NormalizedBrief;
-  issues: ValidationIssue[];
-} {
-  const normalized = normalizeInput(input);
-  const valid = validateFn(normalized);
-  if (valid) return { brief: normalized, issues: [] };
-  const errors = validateFn.errors ?? [];
-  const issues = errors.map((error) => ({
-    level: "error" as const,
-    code: "normalized_brief_invalid",
-    check: "schema" as const,
-    field: error.instancePath || error.schemaPath,
-    message: `Normalized brief schema error: ${error.message ?? "unknown error"}`,
-    suggestion: "Fix missing content in start brief and rerun `prodo normalize`."
-  }));
-  return { brief: normalized, issues };
-}
-
-export function parseNormalizedBriefOrThrow(input: Record<string, unknown>): NormalizedBrief {
-  const { brief, issues } = parseNormalizedBrief(input);
-  if (issues.length > 0) {
-    const detail = issues.map((issue) => `- ${issue.message}`).join("\n");
-    throw new UserError(`Normalized brief is invalid:\n${detail}`);
-  }
-  return brief;
-}
-
-export function requireConfidenceOrThrow(
-  brief: NormalizedBrief,
-  fields: Array<keyof Pick<NormalizedBrief, "product_name" | "problem" | "audience" | "goals" | "core_features">>,
-  threshold = 0.7
-): void {
-  const confidence = brief.confidence ?? {};
-  const missing = fields.filter((field) => (confidence[field] ?? 0) < threshold);
-  if (missing.length > 0) {
-    throw new UserError(
-      `Normalization confidence too low for: ${missing.join(", ")}. Improve brief clarity and rerun \`prodo normalize\`.`
-    );
-  }
-}
-
-export function contractIds(contracts: BriefContracts): {
-  goals: string[];
-  core_features: string[];
-  constraints: string[];
-} {
-  return {
-    goals: contracts.goals.map((item) => item.id),
-    core_features: contracts.core_features.map((item) => item.id),
-    constraints: contracts.constraints.map((item) => item.id)
-  };
-}
+import Ajv2020 from "ajv/dist/2020";
+import { UserError } from "./errors";
+import type { ValidationIssue } from "./types";
+
+export type BriefContractItem = {
+  id: string;
+  text: string;
+};
+
+export type NormalizedBrief = {
+  schema_version: string;
+  product_name: string;
+  problem: string;
+  audience: string[];
+  goals: string[];
+  core_features: string[];
+  constraints: string[];
+  assumptions: string[];
+  contracts: {
+    goals: BriefContractItem[];
+    core_features: BriefContractItem[];
+    constraints: BriefContractItem[];
+  };
+  confidence?: Record<string, number>;
+};
+
+type BriefContracts = NormalizedBrief["contracts"];
+
+const schema: Record<string, unknown> = {
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  type: "object",
+  required: [
+    "schema_version",
+    "product_name",
+    "problem",
+    "audience",
+    "goals",
+    "core_features",
+    "constraints",
+    "assumptions",
+    "contracts"
+  ],
+  properties: {
+    schema_version: { type: "string", minLength: 1 },
+    product_name: { type: "string", minLength: 2 },
+    problem: { type: "string", minLength: 10 },
+    audience: { type: "array", minItems: 1, items: { type: "string", minLength: 2 } },
+    goals: { type: "array", minItems: 1, items: { type: "string", minLength: 2 } },
+    core_features: { type: "array", minItems: 1, items: { type: "string", minLength: 2 } },
+    constraints: { type: "array", items: { type: "string", minLength: 2 } },
+    assumptions: { type: "array", items: { type: "string", minLength: 2 } },
+    contracts: {
+      type: "object",
+      required: ["goals", "core_features", "constraints"],
+      properties: {
+        goals: { $ref: "#/$defs/contractArray" },
+        core_features: { $ref: "#/$defs/contractArray" },
+        constraints: { $ref: "#/$defs/contractArray" }
+      },
+      additionalProperties: false
+    },
+    confidence: {
+      type: "object",
+      additionalProperties: { type: "number", minimum: 0, maximum: 1 }
+    }
+  },
+  $defs: {
+    contractItem: {
+      type: "object",
+      required: ["id", "text"],
+      properties: {
+        id: { type: "string", pattern: "^[A-Z]+[0-9]+$" },
+        text: { type: "string", minLength: 2 }
+      },
+      additionalProperties: false
+    },
+    contractArray: { type: "array", items: { $ref: "#/$defs/contractItem" } }
+  },
+  additionalProperties: false
+};
+
+const ajv = new Ajv2020({ allErrors: true, strict: false });
+const validateFn = ajv.compile(schema);
+
+function asString(value: unknown): string | undefined {
+  if (typeof value !== "string") return undefined;
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : undefined;
+}
+
+function asStringArray(value: unknown): string[] {
+  if (!Array.isArray(value)) return [];
+  return value
+    .map((item) => asString(item))
+    .filter((item): item is string => typeof item === "string");
+}
+
+function asContracts(value: unknown): BriefContractItem[] {
+  if (!Array.isArray(value)) return [];
+  return value
+    .map((item) => {
+      if (!item || typeof item !== "object") return null;
+      const record = item as Record<string, unknown>;
+      const id = asString(record.id);
+      const text = asString(record.text);
+      if (!id || !text) return null;
+      return { id, text };
+    })
+    .filter((item): item is BriefContractItem => item !== null);
+}
+
+function asConfidence(value: unknown): Record<string, number> | undefined {
+  if (!value || typeof value !== "object") return undefined;
+  const result: Record<string, number> = {};
+  for (const [key, raw] of Object.entries(value as Record<string, unknown>)) {
+    if (typeof raw !== "number" || Number.isNaN(raw)) continue;
+    result[key] = raw;
+  }
+  return Object.keys(result).length > 0 ? result : undefined;
+}
+
+function normalizeInput(input: Record<string, unknown>): NormalizedBrief {
+  const rawContracts = (input.contracts as Record<string, unknown> | undefined) ?? {};
+  return {
+    schema_version: asString(input.schema_version) ?? "1.0",
+    product_name: asString(input.product_name) ?? "",
+    problem: asString(input.problem) ?? "",
+    audience: asStringArray(input.audience),
+    goals: asStringArray(input.goals),
+    core_features: asStringArray(input.core_features),
+    constraints: asStringArray(input.constraints),
+    assumptions: asStringArray(input.assumptions),
+    contracts: {
+      goals: asContracts(rawContracts.goals),
+      core_features: asContracts(rawContracts.core_features),
+      constraints: asContracts(rawContracts.constraints)
+    },
+    confidence: asConfidence(input.confidence)
+  };
+}
+
+export function buildContractsFromArrays(input: {
+  goals: string[];
+  core_features: string[];
+  constraints: string[];
+}): BriefContracts {
+  return {
+    goals: input.goals.map((text, index) => ({ id: `G${index + 1}`, text })),
+    core_features: input.core_features.map((text, index) => ({ id: `F${index + 1}`, text })),
+    constraints: input.constraints.map((text, index) => ({ id: `C${index + 1}`, text }))
+  };
+}
+
+export function parseNormalizedBrief(input: Record<string, unknown>): {
+  brief: NormalizedBrief;
+  issues: ValidationIssue[];
+} {
+  const normalized = normalizeInput(input);
+  const valid = validateFn(normalized);
+  if (valid) return { brief: normalized, issues: [] };
+  const errors = validateFn.errors ?? [];
+  const issues = errors.map((error) => ({
+    level: "error" as const,
+    code: "normalized_brief_invalid",
+    check: "schema" as const,
+    field: error.instancePath || error.schemaPath,
+    message: `Normalized brief schema error: ${error.message ?? "unknown error"}`,
+    suggestion: "Fix missing content in start brief and rerun `prodo normalize`."
+  }));
+  return { brief: normalized, issues };
+}
+
+export function parseNormalizedBriefOrThrow(input: Record<string, unknown>): NormalizedBrief {
+  const { brief, issues } = parseNormalizedBrief(input);
+  if (issues.length > 0) {
+    const detail = issues.map((issue) => `- ${issue.message}`).join("\n");
+    throw new UserError(`Normalized brief is invalid:\n${detail}`);
+  }
+  return brief;
+}
+
+export function requireConfidenceOrThrow(
+  brief: NormalizedBrief,
+  fields: Array<keyof Pick<NormalizedBrief, "product_name" | "problem" | "audience" | "goals" | "core_features">>,
+  threshold = 0.7
+): void {
+  const confidence = brief.confidence ?? {};
+  const missing = fields.filter((field) => (confidence[field] ?? 0) < threshold);
+  if (missing.length > 0) {
+    throw new UserError(
+      `Normalization confidence too low for: ${missing.join(", ")}. Improve brief clarity and rerun \`prodo normalize\`.`
+    );
+  }
+}
+
+export type ConfidenceCheckResult = {
+  pass: boolean;
+  lowFields: Array<{ field: string; confidence: number; threshold: number }>;
+};
+
+export function checkConfidence(
+  brief: NormalizedBrief,
+  fields: Array<keyof Pick<NormalizedBrief, "product_name" | "problem" | "audience" | "goals" | "core_features">>,
+  threshold = 0.7
+): ConfidenceCheckResult {
+  const confidence = brief.confidence ?? {};
+  const lowFields = fields
+    .filter((field) => (confidence[field] ?? 0) < threshold)
+    .map((field) => ({
+      field,
+      confidence: confidence[field] ?? 0,
+      threshold
+    }));
+  return { pass: lowFields.length === 0, lowFields };
+}
+
+export function contractIds(contracts: BriefContracts): {
+  goals: string[];
+  core_features: string[];
+  constraints: string[];
+} {
+  return {
+    goals: contracts.goals.map((item) => item.id),
+    core_features: contracts.core_features.map((item) => item.id),
+    constraints: contracts.constraints.map((item) => item.id)
+  };
+}