@shahmarasy/prodo 0.1.0

package/src/normalized-brief.ts

@@ -0,0 +1,206 @@
+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)
+  };
+}

package/src/output-index.ts

@@ -0,0 +1,59 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { outputIndexPath } from "./paths";
+import type { ArtifactType } from "./types";
+import { ensureDir, fileExists } from "./utils";
+
+type ArtifactMap = Partial<Record<ArtifactType, string>>;
+type ArtifactHistoryMap = Partial<Record<ArtifactType, string[]>>;
+
+export type OutputIndex = {
+  active: ArtifactMap;
+  history: ArtifactHistoryMap;
+  updated_at: string;
+};
+
+function defaultIndex(): OutputIndex {
+  return {
+    active: {},
+    history: {},
+    updated_at: new Date(0).toISOString()
+  };
+}
+
+export async function loadOutputIndex(cwd: string): Promise<OutputIndex> {
+  const indexPath = outputIndexPath(cwd);
+  if (!(await fileExists(indexPath))) return defaultIndex();
+  const raw = await fs.readFile(indexPath, "utf8");
+  const parsed = JSON.parse(raw) as Partial<OutputIndex>;
+  return {
+    active: parsed.active ?? {},
+    history: parsed.history ?? {},
+    updated_at: parsed.updated_at ?? new Date(0).toISOString()
+  };
+}
+
+export async function saveOutputIndex(cwd: string, index: OutputIndex): Promise<void> {
+  const indexPath = outputIndexPath(cwd);
+  await ensureDir(path.dirname(indexPath));
+  await fs.writeFile(indexPath, `${JSON.stringify(index, null, 2)}\n`, "utf8");
+}
+
+export async function setActiveArtifact(cwd: string, type: ArtifactType, filePath: string): Promise<void> {
+  const index = await loadOutputIndex(cwd);
+  const normalizedPath = path.resolve(filePath);
+  const existing = index.history[type] ?? [];
+  index.active[type] = normalizedPath;
+  index.history[type] = [normalizedPath, ...existing.filter((item) => item !== normalizedPath)].slice(0, 100);
+  index.updated_at = new Date().toISOString();
+  await saveOutputIndex(cwd, index);
+}
+
+export async function getActiveArtifactPath(cwd: string, type: ArtifactType): Promise<string | undefined> {
+  const index = await loadOutputIndex(cwd);
+  const candidate = index.active[type];
+  if (!candidate) return undefined;
+  if (await fileExists(candidate)) return candidate;
+  return undefined;
+}
+

package/src/paths.ts

@@ -0,0 +1,72 @@
+import path from "node:path";
+import { defaultOutputDir, PRODO_DIR } from "./constants";
+import type { ArtifactType } from "./types";
+
+export function prodoPath(cwd: string): string {
+  return path.join(cwd, PRODO_DIR);
+}
+
+export function briefPath(cwd: string): string {
+  return path.join(cwd, "brief.md");
+}
+
+export function normalizedBriefPath(cwd: string): string {
+  return path.join(prodoPath(cwd), "briefs", "normalized-brief.json");
+}
+
+export function settingsPath(cwd: string): string {
+  return path.join(prodoPath(cwd), "settings.json");
+}
+
+export function registryPath(cwd: string): string {
+  return path.join(prodoPath(cwd), "registry.json");
+}
+
+export function promptPath(cwd: string, artifactType: ArtifactType): string {
+  return path.join(prodoPath(cwd), "prompts", `${artifactType}.md`);
+}
+
+export function templatePath(cwd: string, artifactType: ArtifactType): string {
+  return path.join(prodoPath(cwd), "templates", `${artifactType}.md`);
+}
+
+export function overrideTemplatePath(cwd: string, artifactType: ArtifactType): string {
+  return path.join(prodoPath(cwd), "templates", "overrides", `${artifactType}.md`);
+}
+
+function templateExtensionsForArtifact(artifactType: ArtifactType): string[] {
+  if (artifactType === "workflow") return ["md", "mmd"];
+  if (artifactType === "wireframe") return ["md", "html"];
+  return ["md"];
+}
+
+export function templateCandidatePaths(cwd: string, artifactType: ArtifactType): string[] {
+  const root = path.join(prodoPath(cwd), "templates");
+  return templateExtensionsForArtifact(artifactType).map((ext) => path.join(root, `${artifactType}.${ext}`));
+}
+
+export function overrideTemplateCandidatePaths(cwd: string, artifactType: ArtifactType): string[] {
+  const root = path.join(prodoPath(cwd), "templates", "overrides");
+  return templateExtensionsForArtifact(artifactType).map((ext) => path.join(root, `${artifactType}.${ext}`));
+}
+
+export function schemaPath(cwd: string, artifactType: ArtifactType): string {
+  return path.join(prodoPath(cwd), "schemas", `${artifactType}.yaml`);
+}
+
+export function outputDirPath(cwd: string, artifactType: ArtifactType, outputDirOverride?: string): string {
+  return path.join(cwd, "product-docs", outputDirOverride ?? defaultOutputDir(artifactType));
+}
+
+export function reportPath(cwd: string): string {
+  return path.join(cwd, "product-docs", "reports", "latest-validation.md");
+}
+
+export function outputIndexPath(cwd: string): string {
+  return path.join(prodoPath(cwd), "state", "index.json");
+}
+
+export function outputContextDirPath(cwd: string): string {
+  return path.join(prodoPath(cwd), "state", "context");
+}
+

package/src/preset-loader.ts

@@ -0,0 +1,237 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import yaml from "js-yaml";
+import { UserError } from "./errors";
+import { readProjectConfig } from "./project-config";
+import { ensureDir, fileExists } from "./utils";
+
+type PresetManifest = {
+  name: string;
+  version?: string;
+  priority?: number;
+  min_prodo_version?: string;
+  max_prodo_version?: string;
+  command_packs?: string[];
+};
+
+type CopyOp = {
+  source: string;
+  target: string;
+  priority: number;
+  order: number;
+};
+
+function parseVersion(version: string): number[] {
+  return version.split(".").map((part) => Number(part.replace(/[^0-9]/g, "")) || 0).slice(0, 3);
+}
+
+function cmpVersion(a: string, b: string): number {
+  const left = parseVersion(a);
+  const right = parseVersion(b);
+  for (let i = 0; i < 3; i++) {
+    if ((left[i] ?? 0) > (right[i] ?? 0)) return 1;
+    if ((left[i] ?? 0) < (right[i] ?? 0)) return -1;
+  }
+  return 0;
+}
+
+async function readPresetManifest(presetDir: string): Promise<PresetManifest> {
+  const candidates = ["preset.yaml", "preset.yml", "preset.json"];
+  for (const name of candidates) {
+    const file = path.join(presetDir, name);
+    if (!(await fileExists(file))) continue;
+    if (name.endsWith(".json")) {
+      const parsed = JSON.parse(await fs.readFile(file, "utf8")) as Record<string, unknown>;
+      const presetName = typeof parsed.name === "string" ? parsed.name.trim() : path.basename(presetDir);
+      return {
+        name: presetName,
+        version: typeof parsed.version === "string" ? parsed.version : undefined,
+        priority: typeof parsed.priority === "number" ? parsed.priority : 0,
+        min_prodo_version: typeof parsed.min_prodo_version === "string" ? parsed.min_prodo_version : undefined,
+        max_prodo_version: typeof parsed.max_prodo_version === "string" ? parsed.max_prodo_version : undefined,
+        command_packs: Array.isArray(parsed.command_packs)
+          ? parsed.command_packs.filter((item): item is string => typeof item === "string")
+          : []
+      };
+    }
+    const parsed = (yaml.load(await fs.readFile(file, "utf8")) as Record<string, unknown>) ?? {};
+    const presetName = typeof parsed.name === "string" ? parsed.name.trim() : path.basename(presetDir);
+    return {
+      name: presetName,
+      version: typeof parsed.version === "string" ? parsed.version : undefined,
+      priority: typeof parsed.priority === "number" ? parsed.priority : 0,
+      min_prodo_version: typeof parsed.min_prodo_version === "string" ? parsed.min_prodo_version : undefined,
+      max_prodo_version: typeof parsed.max_prodo_version === "string" ? parsed.max_prodo_version : undefined,
+      command_packs: Array.isArray(parsed.command_packs)
+        ? parsed.command_packs.filter((item): item is string => typeof item === "string")
+        : []
+    };
+  }
+  throw new UserError(`Preset manifest is missing in ${presetDir} (expected preset.yaml or preset.json).`);
+}
+
+async function collectFilesRecursive(rootDir: string): Promise<string[]> {
+  if (!(await fileExists(rootDir))) return [];
+  const out: string[] = [];
+  const walk = async (current: string): Promise<void> => {
+    const entries = await fs.readdir(current, { withFileTypes: true });
+    for (const entry of entries) {
+      const full = path.join(current, entry.name);
+      if (entry.isDirectory()) {
+        await walk(full);
+      } else {
+        out.push(full);
+      }
+    }
+  };
+  await walk(rootDir);
+  return out;
+}
+
+async function collectPresetOps(
+  presetDir: string,
+  prodoRoot: string,
+  priority: number,
+  order: number
+): Promise<CopyOp[]> {
+  const lanes = ["prompts", "schemas", "templates", "commands"];
+  const ops: CopyOp[] = [];
+  for (const lane of lanes) {
+    const sourceBase = path.join(presetDir, lane);
+    const files = await collectFilesRecursive(sourceBase);
+    for (const source of files) {
+      const relative = path.relative(sourceBase, source);
+      ops.push({
+        source,
+        target: path.join(prodoRoot, lane, relative),
+        priority,
+        order
+      });
+    }
+  }
+  return ops;
+}
+
+async function resolvePresetDir(projectRoot: string, presetName: string): Promise<string> {
+  const candidates = [
+    path.join(projectRoot, "presets", presetName),
+    path.resolve(__dirname, "..", "presets", presetName)
+  ];
+  for (const candidate of candidates) {
+    if (await fileExists(candidate)) return candidate;
+  }
+  throw new UserError(`Preset not found: ${presetName}. Create presets/${presetName} with a preset manifest.`);
+}
+
+async function writeInstalledPresets(prodoRoot: string, names: string[]): Promise<void> {
+  const file = path.join(prodoRoot, "presets", "installed.json");
+  await ensureDir(path.dirname(file));
+  await fs.writeFile(file, `${JSON.stringify(Array.from(new Set(names)).sort(), null, 2)}\n`, "utf8");
+}
+
+async function readInstalledPresets(prodoRoot: string): Promise<string[]> {
+  const file = path.join(prodoRoot, "presets", "installed.json");
+  if (!(await fileExists(file))) return [];
+  try {
+    const parsed = JSON.parse(await fs.readFile(file, "utf8")) as unknown;
+    if (!Array.isArray(parsed)) return [];
+    return parsed
+      .filter((item): item is string => typeof item === "string")
+      .map((item) => item.trim())
+      .filter((item) => item.length > 0);
+  } catch {
+    return [];
+  }
+}
+
+async function applyCopyOps(ops: CopyOp[]): Promise<void> {
+  const selected = new Map<string, CopyOp>();
+  for (const op of ops) {
+    const current = selected.get(op.target);
+    if (!current) {
+      selected.set(op.target, op);
+      continue;
+    }
+    if (op.priority > current.priority || (op.priority === current.priority && op.order > current.order)) {
+      selected.set(op.target, op);
+    }
+  }
+  for (const op of selected.values()) {
+    await ensureDir(path.dirname(op.target));
+    await fs.copyFile(op.source, op.target);
+  }
+}
+
+async function collectCommandPackOps(projectRoot: string, prodoRoot: string, names: string[]): Promise<CopyOp[]> {
+  const ops: CopyOp[] = [];
+  for (const [index, name] of names.entries()) {
+    const base = path.join(projectRoot, "command-packs", name);
+    if (!(await fileExists(base))) {
+      throw new UserError(`Command pack not found: command-packs/${name}`);
+    }
+    const laneMap: Record<string, string> = {
+      commands: "commands"
+    };
+    for (const [sourceLane, targetLane] of Object.entries(laneMap)) {
+      const sourceBase = path.join(base, sourceLane);
+      const files = await collectFilesRecursive(sourceBase);
+      for (const source of files) {
+        const relative = path.relative(sourceBase, source);
+        ops.push({
+          source,
+          target: path.join(prodoRoot, targetLane, relative),
+          priority: 100,
+          order: index
+        });
+      }
+    }
+  }
+  return ops;
+}
+
+export async function applyConfiguredPresets(
+  projectRoot: string,
+  prodoRoot: string,
+  prodoVersion: string,
+  presetOverride?: string
+): Promise<{ installedPresets: string[]; appliedFiles: string[] }> {
+  const config = await readProjectConfig(projectRoot);
+  const presets = Array.from(new Set([...(config.presets ?? []), ...(presetOverride ? [presetOverride] : [])]));
+  const existingInstalled = await readInstalledPresets(prodoRoot);
+  const allOps: CopyOp[] = [];
+  const installedNames: string[] = [...existingInstalled];
+  const commandPacks = new Set<string>(config.command_packs ?? []);
+
+  for (const [order, presetName] of presets.entries()) {
+    const presetDir = await resolvePresetDir(projectRoot, presetName);
+    const manifest = await readPresetManifest(presetDir);
+    if (manifest.min_prodo_version && cmpVersion(prodoVersion, manifest.min_prodo_version) < 0) {
+      throw new UserError(
+        `Preset ${presetName} requires prodo >= ${manifest.min_prodo_version}, current is ${prodoVersion}.`
+      );
+    }
+    if (manifest.max_prodo_version && cmpVersion(prodoVersion, manifest.max_prodo_version) > 0) {
+      throw new UserError(
+        `Preset ${presetName} supports prodo <= ${manifest.max_prodo_version}, current is ${prodoVersion}.`
+      );
+    }
+    for (const pack of manifest.command_packs ?? []) {
+      if (pack.trim()) commandPacks.add(pack.trim());
+    }
+    installedNames.push(manifest.name || presetName);
+    allOps.push(...(await collectPresetOps(presetDir, prodoRoot, manifest.priority ?? 0, order)));
+  }
+
+  const commandPackList = Array.from(commandPacks);
+  if (commandPackList.length > 0) {
+    const commandPackOps = await collectCommandPackOps(projectRoot, prodoRoot, commandPackList);
+    allOps.push(...commandPackOps);
+  }
+  if (allOps.length > 0) await applyCopyOps(allOps);
+  await writeInstalledPresets(prodoRoot, installedNames);
+
+  return {
+    installedPresets: Array.from(new Set(installedNames)),
+    appliedFiles: Array.from(new Set(allOps.map((item) => item.target)))
+  };
+}

package/src/project-config.ts

@@ -0,0 +1,78 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import type { ContractCoverage } from "./types";
+import { UserError } from "./errors";
+import { fileExists } from "./utils";
+
+export type ArtifactConfig = {
+  name: string;
+  output_dir?: string;
+  required_headings?: string[];
+  upstream?: string[];
+  required_contracts?: Array<keyof ContractCoverage>;
+};
+
+export type ProdoProjectConfig = {
+  presets?: string[];
+  artifacts?: ArtifactConfig[];
+  command_packs?: string[];
+};
+
+function sanitizeStringArray(value: unknown): string[] {
+  if (!Array.isArray(value)) return [];
+  return value
+    .filter((item): item is string => typeof item === "string")
+    .map((item) => item.trim())
+    .filter((item) => item.length > 0);
+}
+
+function sanitizeArtifact(raw: unknown): ArtifactConfig | null {
+  if (!raw || typeof raw !== "object") return null;
+  const rec = raw as Record<string, unknown>;
+  const name = typeof rec.name === "string" ? rec.name.trim() : "";
+  if (!name) return null;
+  const outputDir = typeof rec.output_dir === "string" ? rec.output_dir.trim() : undefined;
+  const requiredHeadings = sanitizeStringArray(rec.required_headings);
+  const upstream = sanitizeStringArray(rec.upstream);
+  const requiredContracts = sanitizeStringArray(rec.required_contracts)
+    .filter((value): value is keyof ContractCoverage =>
+      value === "goals" || value === "core_features" || value === "constraints");
+  return {
+    name,
+    ...(outputDir ? { output_dir: outputDir } : {}),
+    ...(requiredHeadings.length > 0 ? { required_headings: requiredHeadings } : {}),
+    ...(upstream.length > 0 ? { upstream } : {}),
+    ...(requiredContracts.length > 0 ? { required_contracts: requiredContracts } : {})
+  };
+}
+
+function sanitizeConfig(raw: unknown): ProdoProjectConfig {
+  if (!raw || typeof raw !== "object") return {};
+  const rec = raw as Record<string, unknown>;
+  const artifacts = Array.isArray(rec.artifacts)
+    ? rec.artifacts.map(sanitizeArtifact).filter((item): item is ArtifactConfig => item !== null)
+    : [];
+  return {
+    presets: sanitizeStringArray(rec.presets),
+    command_packs: sanitizeStringArray(rec.command_packs),
+    ...(artifacts.length > 0 ? { artifacts } : {})
+  };
+}
+
+export async function readProjectConfig(cwd: string): Promise<ProdoProjectConfig> {
+  const candidates = [
+    path.join(cwd, ".prodo", "config.json"),
+    path.join(cwd, "prodo.config.json")
+  ];
+  for (const candidate of candidates) {
+    if (!(await fileExists(candidate))) continue;
+    try {
+      const parsed = JSON.parse(await fs.readFile(candidate, "utf8")) as unknown;
+      return sanitizeConfig(parsed);
+    } catch {
+      throw new UserError(`Invalid project config JSON: ${candidate}`);
+    }
+  }
+  return {};
+}
+

package/src/providers/index.ts

@@ -0,0 +1,12 @@
+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();
+}
+