@shahmarasy/prodo 0.1.0

package/dist/providers/openai-provider.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenAIProvider = void 0;
+const errors_1 = require("../errors");
+class OpenAIProvider {
+    apiKey;
+    model;
+    baseUrl;
+    constructor() {
+        const key = process.env.OPENAI_API_KEY;
+        if (!key) {
+            throw new errors_1.UserError("OPENAI_API_KEY missing. Set it or use PRODO_LLM_PROVIDER=mock.");
+        }
+        this.apiKey = key;
+        this.model = process.env.PRODO_OPENAI_MODEL ?? "gpt-4o-mini";
+        this.baseUrl = process.env.PRODO_OPENAI_BASE_URL ?? "https://api.openai.com/v1";
+    }
+    async generate(prompt, inputContext, schemaHint) {
+        const outputLanguage = typeof inputContext.outputLanguage === "string" && inputContext.outputLanguage.trim()
+            ? inputContext.outputLanguage.trim()
+            : "en";
+        const mode = schemaHint.artifactType;
+        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.`
+            : mode === "semantic_consistency"
+                ? `You detect semantic inconsistencies between paired artifacts.
+Return valid JSON only: { "issues": [{level, code, check, contract_id, file, message, suggestion}] }.`
+                : mode === "contract_relevance"
+                    ? `You verify whether tagged content actually matches the referenced contract text.
+Return valid JSON only: { "relevant": boolean, "score": number, "reason": string }.`
+                    : `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.`;
+        const user = `${prompt}\n\nContext JSON:\n${JSON.stringify(inputContext, null, 2)}`;
+        const response = await fetch(`${this.baseUrl}/chat/completions`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${this.apiKey}`
+            },
+            body: JSON.stringify({
+                model: this.model,
+                messages: [
+                    { role: "system", content: system },
+                    { role: "user", content: user }
+                ],
+                temperature: 0.2
+            })
+        });
+        if (!response.ok) {
+            const text = await response.text();
+            throw new errors_1.UserError(`OpenAI request failed (${response.status}): ${text}`);
+        }
+        const payload = (await response.json());
+        const content = payload.choices?.[0]?.message?.content?.trim();
+        if (!content) {
+            throw new errors_1.UserError("OpenAI provider returned an empty response.");
+        }
+        return { body: content };
+    }
+}
+exports.OpenAIProvider = OpenAIProvider;

package/dist/registry.d.ts

@@ -0,0 +1,13 @@
+export type OverrideRegistryEntry = {
+    artifact_type: string;
+    file: string;
+    sha256: string;
+};
+export type ProdoRegistry = {
+    schema_version: "1.0";
+    updated_at: string;
+    installed_presets: string[];
+    installed_overrides: OverrideRegistryEntry[];
+};
+export declare function readRegistry(cwd: string): Promise<ProdoRegistry>;
+export declare function syncRegistry(cwd: string): Promise<ProdoRegistry>;

package/dist/registry.js

@@ -0,0 +1,115 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readRegistry = readRegistry;
+exports.syncRegistry = syncRegistry;
+const promises_1 = __importDefault(require("node:fs/promises"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_crypto_1 = require("node:crypto");
+const paths_1 = require("./paths");
+const utils_1 = require("./utils");
+const EMPTY_REGISTRY = {
+    schema_version: "1.0",
+    updated_at: new Date(0).toISOString(),
+    installed_presets: [],
+    installed_overrides: []
+};
+async function sha256(filePath) {
+    const raw = await promises_1.default.readFile(filePath);
+    return (0, node_crypto_1.createHash)("sha256").update(raw).digest("hex");
+}
+function sanitizeRegistry(input) {
+    if (!input || typeof input !== "object")
+        return { ...EMPTY_REGISTRY };
+    const raw = input;
+    const installedPresets = Array.isArray(raw.installed_presets)
+        ? raw.installed_presets
+            .filter((value) => typeof value === "string")
+            .map((value) => value.trim())
+            .filter((value) => value.length > 0)
+        : [];
+    const installedOverrides = Array.isArray(raw.installed_overrides)
+        ? raw.installed_overrides
+            .filter((item) => !!item && typeof item === "object")
+            .map((item) => ({
+            artifact_type: typeof item.artifact_type === "string" ? item.artifact_type.trim() : "",
+            file: typeof item.file === "string" ? item.file.trim() : "",
+            sha256: typeof item.sha256 === "string" ? item.sha256.trim() : ""
+        }))
+            .filter((item) => item.artifact_type && item.file && item.sha256)
+        : [];
+    return {
+        schema_version: "1.0",
+        updated_at: typeof raw.updated_at === "string" && raw.updated_at.trim() ? raw.updated_at : EMPTY_REGISTRY.updated_at,
+        installed_presets: Array.from(new Set(installedPresets)),
+        installed_overrides: installedOverrides
+    };
+}
+async function readRegistry(cwd) {
+    const file = (0, paths_1.registryPath)(cwd);
+    if (!(await (0, utils_1.fileExists)(file)))
+        return { ...EMPTY_REGISTRY };
+    try {
+        const parsed = JSON.parse(await promises_1.default.readFile(file, "utf8"));
+        return sanitizeRegistry(parsed);
+    }
+    catch {
+        return { ...EMPTY_REGISTRY };
+    }
+}
+async function readInstalledPresetsFromFile(cwd) {
+    const file = node_path_1.default.join(cwd, ".prodo", "presets", "installed.json");
+    if (!(await (0, utils_1.fileExists)(file)))
+        return [];
+    try {
+        const parsed = JSON.parse(await promises_1.default.readFile(file, "utf8"));
+        if (!Array.isArray(parsed))
+            return [];
+        return parsed
+            .filter((value) => typeof value === "string")
+            .map((value) => value.trim())
+            .filter((value) => value.length > 0);
+    }
+    catch {
+        return [];
+    }
+}
+async function discoverOverrides(cwd) {
+    const overridesDir = node_path_1.default.join(cwd, ".prodo", "templates", "overrides");
+    if (!(await (0, utils_1.fileExists)(overridesDir)))
+        return [];
+    const entries = await promises_1.default.readdir(overridesDir, { withFileTypes: true });
+    const out = [];
+    for (const entry of entries) {
+        if (!entry.isFile())
+            continue;
+        if (!entry.name.endsWith(".md"))
+            continue;
+        const fullPath = node_path_1.default.join(overridesDir, entry.name);
+        out.push({
+            artifact_type: entry.name.replace(/\.md$/, ""),
+            file: fullPath,
+            sha256: await sha256(fullPath)
+        });
+    }
+    out.sort((a, b) => a.artifact_type.localeCompare(b.artifact_type));
+    return out;
+}
+async function syncRegistry(cwd) {
+    const existing = await readRegistry(cwd);
+    const discoveredPresets = await readInstalledPresetsFromFile(cwd);
+    const discoveredOverrides = await discoverOverrides(cwd);
+    const mergedPresets = Array.from(new Set([...existing.installed_presets, ...discoveredPresets])).sort();
+    const merged = {
+        schema_version: "1.0",
+        updated_at: new Date().toISOString(),
+        installed_presets: mergedPresets,
+        installed_overrides: discoveredOverrides
+    };
+    const file = (0, paths_1.registryPath)(cwd);
+    await (0, utils_1.ensureDir)(node_path_1.default.dirname(file));
+    await promises_1.default.writeFile(file, `${JSON.stringify(merged, null, 2)}\n`, "utf8");
+    return merged;
+}

package/dist/settings.d.ts

@@ -0,0 +1,6 @@
+export type ProdoSettings = {
+    lang: string;
+    ai?: string;
+};
+export declare function readSettings(cwd: string): Promise<ProdoSettings>;
+export declare function writeSettings(cwd: string, settings: ProdoSettings): Promise<string>;

package/dist/settings.js

@@ -0,0 +1,34 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readSettings = readSettings;
+exports.writeSettings = writeSettings;
+const promises_1 = __importDefault(require("node:fs/promises"));
+const paths_1 = require("./paths");
+const utils_1 = require("./utils");
+const DEFAULT_SETTINGS = {
+    lang: "en"
+};
+async function readSettings(cwd) {
+    const path = (0, paths_1.settingsPath)(cwd);
+    if (!(await (0, utils_1.fileExists)(path)))
+        return { ...DEFAULT_SETTINGS };
+    try {
+        const raw = await promises_1.default.readFile(path, "utf8");
+        const parsed = JSON.parse(raw);
+        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
+        };
+    }
+    catch {
+        return { ...DEFAULT_SETTINGS };
+    }
+}
+async function writeSettings(cwd, settings) {
+    const path = (0, paths_1.settingsPath)(cwd);
+    await promises_1.default.writeFile(path, `${JSON.stringify(settings, null, 2)}\n`, "utf8");
+    return path;
+}

package/dist/template-resolver.d.ts

@@ -0,0 +1,11 @@
+import type { ArtifactType } from "./types";
+type ResolveOptions = {
+    cwd: string;
+    artifactType: ArtifactType;
+};
+export declare function resolveTemplate(options: ResolveOptions): Promise<{
+    path: string;
+    content: string;
+} | null>;
+export declare function extractRequiredHeadingsFromTemplate(content: string): string[];
+export {};

package/dist/template-resolver.js

@@ -0,0 +1,28 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveTemplate = resolveTemplate;
+exports.extractRequiredHeadingsFromTemplate = extractRequiredHeadingsFromTemplate;
+const promises_1 = __importDefault(require("node:fs/promises"));
+const paths_1 = require("./paths");
+const markdown_1 = require("./markdown");
+const utils_1 = require("./utils");
+async function resolveTemplate(options) {
+    const { cwd, artifactType } = options;
+    const candidates = [
+        ...(0, paths_1.overrideTemplateCandidatePaths)(cwd, artifactType),
+        ...(0, paths_1.templateCandidatePaths)(cwd, artifactType)
+    ];
+    for (const filePath of candidates) {
+        if (await (0, utils_1.fileExists)(filePath)) {
+            const content = await promises_1.default.readFile(filePath, "utf8");
+            return { path: filePath, content };
+        }
+    }
+    return null;
+}
+function extractRequiredHeadingsFromTemplate(content) {
+    return (0, markdown_1.extractRequiredHeadings)(content);
+}

package/dist/templates.d.ts

@@ -0,0 +1,33 @@
+import type { ArtifactType } from "./types";
+import type { WorkflowCommand } from "./workflow-commands";
+export declare function schemaTemplate(artifactType: ArtifactType): Record<string, unknown>;
+export declare function promptTemplate(artifactType: ArtifactType, lang?: string): string;
+export declare function artifactTemplateTemplate(artifactType: ArtifactType, lang?: string): string;
+export declare const START_BRIEF_TEMPLATE = "# Product Brief\n\n## Product Name\nExample Product\n\n## Problem\nDescribe the user problem.\n\n## Audience\nWho this product is for.\n\n## Core Features\n- Feature A\n- Feature B\n\n## Goals\n- Goal 1\n- Goal 2\n\n## Constraints\n- Budget or timeline constraints\n- Compliance or technical constraints\n";
+export declare const NORMALIZED_BRIEF_TEMPLATE: {
+    schema_version: string;
+    product_name: string;
+    problem: string;
+    audience: string[];
+    goals: string[];
+    core_features: string[];
+    constraints: string[];
+    assumptions: string[];
+    contracts: {
+        goals: {
+            id: string;
+            text: string;
+        }[];
+        core_features: {
+            id: string;
+            text: string;
+        }[];
+        constraints: {
+            id: string;
+            text: string;
+        }[];
+    };
+};
+export declare const NORMALIZE_PROMPT_TEMPLATE = "Normalize start-brief content into JSON.\n\nReturn JSON object with keys:\n- schema_version (string)\n- product_name (string)\n- problem (string)\n- audience (string[])\n- goals (string[])\n- core_features (string[])\n- constraints (string[])\n- assumptions (string[])\n- contracts.goals[] ({id,text})\n- contracts.core_features[] ({id,text})\n- contracts.constraints[] ({id,text})\n- confidence.product_name (0..1)\n- confidence.problem (0..1)\n- confidence.audience (0..1)\n- confidence.goals (0..1)\n- confidence.core_features (0..1)\n\nRules:\n- do NOT invent missing critical content\n- keep wording concise and concrete\n- if critical field is missing, return empty and low confidence (<0.7)\n- assign deterministic IDs: goals => G1..Gn, features => F1..Fn, constraints => C1..Cn\n- input files are read-only; never modify, summarize, or rewrite `brief.md` in-place\n- write normalized output as a new JSON object only";
+export declare function commandTemplate(command: WorkflowCommand): string;
+export declare const HOOKS_TEMPLATE = "# Hook item fields:\n# - command: string (required)\n# - optional: boolean (default false)\n# - enabled: boolean (default true)\n# - condition: shell command; run hook only if condition exits 0\n# - timeout_ms: per-attempt timeout in milliseconds (default 30000)\n# - retry: extra retry count after first attempt (default 0)\n# - retry_delay_ms: delay between retries (default 500)\n#\n# Example:\n# hooks:\n#   before_prd:\n#     - command: \"node -e \\\"console.log('lint ok')\\\"\"\n#       optional: false\n#       enabled: true\n#       condition: \"node -e \\\"process.exit(0)\\\"\"\n#       timeout_ms: 15000\n#       retry: 1\n#       retry_delay_ms: 300\n\nhooks:\n  before_normalize: []\n  after_normalize: []\n  before_prd: []\n  after_prd: []\n  before_workflow: []\n  after_workflow: []\n  before_wireframe: []\n  after_wireframe: []\n  before_stories: []\n  after_stories: []\n  before_techspec: []\n  after_techspec: []\n  before_validate: []\n  after_validate: []\n";