@shahmarasy/prodo 0.1.3 → 0.1.5

package/dist/cli/preset-loader.js

@@ -0,0 +1,210 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyConfiguredPresets = applyConfiguredPresets;
+const promises_1 = __importDefault(require("node:fs/promises"));
+const node_path_1 = __importDefault(require("node:path"));
+const js_yaml_1 = __importDefault(require("js-yaml"));
+const errors_1 = require("../core/errors");
+const project_config_1 = require("../core/project-config");
+const utils_1 = require("../core/utils");
+function parseVersion(version) {
+    return version.split(".").map((part) => Number(part.replace(/[^0-9]/g, "")) || 0).slice(0, 3);
+}
+function cmpVersion(a, b) {
+    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) {
+    const candidates = ["preset.yaml", "preset.yml", "preset.json"];
+    for (const name of candidates) {
+        const file = node_path_1.default.join(presetDir, name);
+        if (!(await (0, utils_1.fileExists)(file)))
+            continue;
+        if (name.endsWith(".json")) {
+            const parsed = JSON.parse(await promises_1.default.readFile(file, "utf8"));
+            const presetName = typeof parsed.name === "string" ? parsed.name.trim() : node_path_1.default.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) => typeof item === "string")
+                    : []
+            };
+        }
+        const parsed = js_yaml_1.default.load(await promises_1.default.readFile(file, "utf8")) ?? {};
+        const presetName = typeof parsed.name === "string" ? parsed.name.trim() : node_path_1.default.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) => typeof item === "string")
+                : []
+        };
+    }
+    throw new errors_1.UserError(`Preset manifest is missing in ${presetDir} (expected preset.yaml or preset.json).`);
+}
+async function collectFilesRecursive(rootDir) {
+    if (!(await (0, utils_1.fileExists)(rootDir)))
+        return [];
+    const out = [];
+    const walk = async (current) => {
+        const entries = await promises_1.default.readdir(current, { withFileTypes: true });
+        for (const entry of entries) {
+            const full = node_path_1.default.join(current, entry.name);
+            if (entry.isDirectory()) {
+                await walk(full);
+            }
+            else {
+                out.push(full);
+            }
+        }
+    };
+    await walk(rootDir);
+    return out;
+}
+async function collectPresetOps(presetDir, prodoRoot, priority, order) {
+    const lanes = ["prompts", "schemas", "templates", "commands"];
+    const ops = [];
+    for (const lane of lanes) {
+        const sourceBase = node_path_1.default.join(presetDir, lane);
+        const files = await collectFilesRecursive(sourceBase);
+        for (const source of files) {
+            const relative = node_path_1.default.relative(sourceBase, source);
+            ops.push({
+                source,
+                target: node_path_1.default.join(prodoRoot, lane, relative),
+                priority,
+                order
+            });
+        }
+    }
+    return ops;
+}
+async function resolvePresetDir(projectRoot, presetName) {
+    const candidates = [
+        node_path_1.default.join(projectRoot, "presets", presetName),
+        node_path_1.default.resolve(__dirname, "..", "..", "presets", presetName)
+    ];
+    for (const candidate of candidates) {
+        if (await (0, utils_1.fileExists)(candidate))
+            return candidate;
+    }
+    throw new errors_1.UserError(`Preset not found: ${presetName}. Create presets/${presetName} with a preset manifest.`);
+}
+async function writeInstalledPresets(prodoRoot, names) {
+    const file = node_path_1.default.join(prodoRoot, "presets", "installed.json");
+    await (0, utils_1.ensureDir)(node_path_1.default.dirname(file));
+    await promises_1.default.writeFile(file, `${JSON.stringify(Array.from(new Set(names)).sort(), null, 2)}\n`, "utf8");
+}
+async function readInstalledPresets(prodoRoot) {
+    const file = node_path_1.default.join(prodoRoot, "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((item) => typeof item === "string")
+            .map((item) => item.trim())
+            .filter((item) => item.length > 0);
+    }
+    catch {
+        return [];
+    }
+}
+async function applyCopyOps(ops) {
+    const selected = new Map();
+    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 (0, utils_1.ensureDir)(node_path_1.default.dirname(op.target));
+        await promises_1.default.copyFile(op.source, op.target);
+    }
+}
+async function collectCommandPackOps(projectRoot, prodoRoot, names) {
+    const ops = [];
+    for (const [index, name] of names.entries()) {
+        const base = node_path_1.default.join(projectRoot, "command-packs", name);
+        if (!(await (0, utils_1.fileExists)(base))) {
+            throw new errors_1.UserError(`Command pack not found: command-packs/${name}`);
+        }
+        const laneMap = {
+            commands: "commands"
+        };
+        for (const [sourceLane, targetLane] of Object.entries(laneMap)) {
+            const sourceBase = node_path_1.default.join(base, sourceLane);
+            const files = await collectFilesRecursive(sourceBase);
+            for (const source of files) {
+                const relative = node_path_1.default.relative(sourceBase, source);
+                ops.push({
+                    source,
+                    target: node_path_1.default.join(prodoRoot, targetLane, relative),
+                    priority: 100,
+                    order: index
+                });
+            }
+        }
+    }
+    return ops;
+}
+async function applyConfiguredPresets(projectRoot, prodoRoot, prodoVersion, presetOverride) {
+    const config = await (0, project_config_1.readProjectConfig)(projectRoot);
+    const presets = Array.from(new Set([...(config.presets ?? []), ...(presetOverride ? [presetOverride] : [])]));
+    const existingInstalled = await readInstalledPresets(prodoRoot);
+    const allOps = [];
+    const installedNames = [...existingInstalled];
+    const commandPacks = new Set(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 errors_1.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 errors_1.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/dist/cli.js

@@ -29,6 +29,8 @@ function mapForcedCommand(forcedCommand) {
         return "validate";
     if (forcedCommand === "prodo-normalize")
         return "normalize";
+    if (forcedCommand === "prodo-fix")
+        return "fix";
     if (forcedCommand === "prodo-prd")
         return "prd";
     if (forcedCommand === "prodo-workflow")
@@ -49,7 +51,8 @@ async function runArtifactCommand(type, opts, cwd, log, options) {
         cwd,
         normalizedBriefOverride: opts.from,
         outPath: opts.out,
-        agent
+        agent,
+        revisionType: opts.revisionType
     });
     const agentMsg = agent ? ` [agent=${agent}]` : "";
     log(`${type.toUpperCase()} generated${agentMsg}: ${file}`);
@@ -100,13 +103,15 @@ async function runCli(options = {}) {
         .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 = node_path_1.default.resolve(cwd, target ?? ".");
         const selected = await (0, init_tui_1.gatherInitSelections)({
             projectRoot,
             aiInput: opts.ai,
-            langInput: opts.lang
+            langInput: opts.lang,
+            authorInput: opts.author
         });
         const selectedAi = selected.ai;
         if (selected.interactive) {
@@ -116,6 +121,7 @@ async function runCli(options = {}) {
             const result = await (0, init_1.runInit)(projectRoot, {
                 ai: selectedAi,
                 lang: selected.lang,
+                author: selected.author,
                 preset: opts.preset,
                 script: selected.script
             });
@@ -124,13 +130,15 @@ async function runCli(options = {}) {
                 projectRoot,
                 settingsPath: result.settingsPath,
                 ai: selectedAi,
-                lang: selected.lang
+                lang: selected.lang,
+                author: selected.author
             });
             return;
         }
         const result = await (0, init_1.runInit)(projectRoot, {
             ai: selectedAi,
             lang: selected.lang,
+            author: selected.author,
             preset: opts.preset,
             script: selected.script
         });
@@ -144,6 +152,7 @@ async function runCli(options = {}) {
             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.");
     });
     program
@@ -178,6 +187,51 @@ async function runCli(options = {}) {
             await (0, hook_executor_1.runHookPhase)(cwd, "after_validate", out);
         });
     });
+    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)
+            (0, agents_1.resolveAgent)(opts.agent);
+        await withBriefReadOnlyGuard(cwd, async () => {
+            await (0, hook_executor_1.runHookPhase)(cwd, "before_validate", out);
+            const initial = await (0, validate_1.runValidate)(cwd, {
+                strict: Boolean(opts.strict),
+                report: opts.report
+            });
+            out(`Validation report written to: ${initial.reportPath}`);
+            await (0, hook_executor_1.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 (0, hook_executor_1.runHookPhase)(cwd, "before_normalize", out);
+            const normalizedPath = await (0, normalize_1.runNormalize)({ cwd });
+            out(`Normalized brief refreshed: ${normalizedPath}`);
+            await (0, hook_executor_1.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 (0, hook_executor_1.runHookPhase)(cwd, "before_validate", out);
+            const final = await (0, validate_1.runValidate)(cwd, {
+                strict: Boolean(opts.strict),
+                report: opts.report
+            });
+            out(`Validation report written to: ${final.reportPath}`);
+            if (!final.pass) {
+                throw new errors_1.UserError("Fix completed but validation is still failing. Review report and retry.");
+            }
+            out("Fix pipeline completed. Validation passed.");
+            await (0, hook_executor_1.runHookPhase)(cwd, "after_validate", out);
+        });
+    });
     program
         .command("normalize", { hidden: true })
         .description("Advanced: normalize brief without full pipeline")
@@ -276,6 +330,9 @@ async function runCli(options = {}) {
             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)]);
             }
@@ -300,3 +357,23 @@ if (require.main === module) {
         process.exitCode = code;
     });
 }
+async function resolveFixTargets(cwd, artifactTypes, issues) {
+    const direct = new Set(issues
+        .map((issue) => issue.artifactType)
+        .filter((artifactType) => typeof artifactType === "string" && artifactTypes.includes(artifactType)));
+    if (direct.size === 0)
+        return artifactTypes;
+    const defs = await (0, artifact_registry_1.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/dist/core/artifact-registry.d.ts

@@ -0,0 +1,11 @@
+import type { ArtifactType, ContractCoverage } from "./types";
+export type ArtifactDefinition = {
+    name: ArtifactType;
+    output_dir: string;
+    required_headings: string[];
+    upstream: ArtifactType[];
+    required_contracts: Array<keyof ContractCoverage>;
+};
+export declare function listArtifactDefinitions(cwd: string): Promise<ArtifactDefinition[]>;
+export declare function listArtifactTypes(cwd: string): Promise<ArtifactType[]>;
+export declare function getArtifactDefinition(cwd: string, artifactType: string): Promise<ArtifactDefinition>;

package/dist/core/artifact-registry.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listArtifactDefinitions = listArtifactDefinitions;
+exports.listArtifactTypes = listArtifactTypes;
+exports.getArtifactDefinition = getArtifactDefinition;
+const constants_1 = require("./constants");
+const project_config_1 = require("./project-config");
+const types_1 = require("./types");
+function normalizeName(name) {
+    return name.trim().toLowerCase().replace(/[^a-z0-9_-]/g, "-");
+}
+function toDefinition(partial) {
+    const name = normalizeName(partial.name);
+    const outputDir = partial.output_dir?.trim() || (0, constants_1.defaultOutputDir)(name);
+    const requiredHeadings = partial.required_headings?.length ? partial.required_headings : (0, constants_1.defaultRequiredHeadings)(name);
+    const upstream = (partial.upstream?.length ? partial.upstream : (0, constants_1.defaultUpstreamByArtifact)(name)).map(normalizeName);
+    const requiredContracts = partial.required_contracts?.length
+        ? partial.required_contracts
+        : (0, constants_1.defaultRequiredContractsByArtifact)(name);
+    return {
+        name,
+        output_dir: outputDir,
+        required_headings: requiredHeadings,
+        upstream,
+        required_contracts: requiredContracts
+    };
+}
+async function listArtifactDefinitions(cwd) {
+    const config = await (0, project_config_1.readProjectConfig)(cwd);
+    const base = types_1.ARTIFACT_TYPES.map((name) => toDefinition({ name }));
+    const byName = new Map(base.map((item) => [item.name, item]));
+    for (const extra of config.artifacts ?? []) {
+        const merged = toDefinition(extra);
+        byName.set(merged.name, merged);
+    }
+    return Array.from(byName.values());
+}
+async function listArtifactTypes(cwd) {
+    const defs = await listArtifactDefinitions(cwd);
+    return defs.map((item) => item.name);
+}
+async function getArtifactDefinition(cwd, artifactType) {
+    const normalized = normalizeName(artifactType);
+    const defs = await listArtifactDefinitions(cwd);
+    const found = defs.find((item) => item.name === normalized);
+    if (found)
+        return found;
+    return toDefinition({ name: normalized });
+}

package/dist/core/artifacts.d.ts

@@ -0,0 +1,10 @@
+import type { ArtifactType } from "./types";
+export type GenerateOptions = {
+    artifactType: ArtifactType;
+    cwd: string;
+    normalizedBriefOverride?: string;
+    outPath?: string;
+    agent?: string;
+    revisionType?: "default" | "fix";
+};
+export declare function generateArtifact(options: GenerateOptions): Promise<string>;