@shahmarasy/prodo 0.1.3 → 0.1.5

package/dist/core/normalized-brief.js

@@ -0,0 +1,182 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildContractsFromArrays = buildContractsFromArrays;
+exports.parseNormalizedBrief = parseNormalizedBrief;
+exports.parseNormalizedBriefOrThrow = parseNormalizedBriefOrThrow;
+exports.requireConfidenceOrThrow = requireConfidenceOrThrow;
+exports.checkConfidence = checkConfidence;
+exports.contractIds = contractIds;
+const _2020_1 = __importDefault(require("ajv/dist/2020"));
+const errors_1 = require("./errors");
+const schema = {
+    $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 _2020_1.default({ allErrors: true, strict: false });
+const validateFn = ajv.compile(schema);
+function asString(value) {
+    if (typeof value !== "string")
+        return undefined;
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : undefined;
+}
+function asStringArray(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value
+        .map((item) => asString(item))
+        .filter((item) => typeof item === "string");
+}
+function asContracts(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value
+        .map((item) => {
+        if (!item || typeof item !== "object")
+            return null;
+        const record = item;
+        const id = asString(record.id);
+        const text = asString(record.text);
+        if (!id || !text)
+            return null;
+        return { id, text };
+    })
+        .filter((item) => item !== null);
+}
+function asConfidence(value) {
+    if (!value || typeof value !== "object")
+        return undefined;
+    const result = {};
+    for (const [key, raw] of Object.entries(value)) {
+        if (typeof raw !== "number" || Number.isNaN(raw))
+            continue;
+        result[key] = raw;
+    }
+    return Object.keys(result).length > 0 ? result : undefined;
+}
+function normalizeInput(input) {
+    const rawContracts = input.contracts ?? {};
+    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)
+    };
+}
+function buildContractsFromArrays(input) {
+    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 }))
+    };
+}
+function parseNormalizedBrief(input) {
+    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",
+        code: "normalized_brief_invalid",
+        check: "schema",
+        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 };
+}
+function parseNormalizedBriefOrThrow(input) {
+    const { brief, issues } = parseNormalizedBrief(input);
+    if (issues.length > 0) {
+        const detail = issues.map((issue) => `- ${issue.message}`).join("\n");
+        throw new errors_1.UserError(`Normalized brief is invalid:\n${detail}`);
+    }
+    return brief;
+}
+function requireConfidenceOrThrow(brief, fields, threshold = 0.7) {
+    const confidence = brief.confidence ?? {};
+    const missing = fields.filter((field) => (confidence[field] ?? 0) < threshold);
+    if (missing.length > 0) {
+        throw new errors_1.UserError(`Normalization confidence too low for: ${missing.join(", ")}. Improve brief clarity and rerun \`prodo normalize\`.`);
+    }
+}
+function checkConfidence(brief, fields, threshold = 0.7) {
+    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 };
+}
+function contractIds(contracts) {
+    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/dist/core/output-index.d.ts

@@ -0,0 +1,13 @@
+import type { ArtifactType } from "./types";
+type ArtifactMap = Partial<Record<ArtifactType, string>>;
+type ArtifactHistoryMap = Partial<Record<ArtifactType, string[]>>;
+export type OutputIndex = {
+    active: ArtifactMap;
+    history: ArtifactHistoryMap;
+    updated_at: string;
+};
+export declare function loadOutputIndex(cwd: string): Promise<OutputIndex>;
+export declare function saveOutputIndex(cwd: string, index: OutputIndex): Promise<void>;
+export declare function setActiveArtifact(cwd: string, type: ArtifactType, filePath: string): Promise<void>;
+export declare function getActiveArtifactPath(cwd: string, type: ArtifactType): Promise<string | undefined>;
+export {};

package/dist/core/output-index.js

@@ -0,0 +1,55 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadOutputIndex = loadOutputIndex;
+exports.saveOutputIndex = saveOutputIndex;
+exports.setActiveArtifact = setActiveArtifact;
+exports.getActiveArtifactPath = getActiveArtifactPath;
+const promises_1 = __importDefault(require("node:fs/promises"));
+const node_path_1 = __importDefault(require("node:path"));
+const paths_1 = require("./paths");
+const utils_1 = require("./utils");
+function defaultIndex() {
+    return {
+        active: {},
+        history: {},
+        updated_at: new Date(0).toISOString()
+    };
+}
+async function loadOutputIndex(cwd) {
+    const indexPath = (0, paths_1.outputIndexPath)(cwd);
+    if (!(await (0, utils_1.fileExists)(indexPath)))
+        return defaultIndex();
+    const raw = await promises_1.default.readFile(indexPath, "utf8");
+    const parsed = JSON.parse(raw);
+    return {
+        active: parsed.active ?? {},
+        history: parsed.history ?? {},
+        updated_at: parsed.updated_at ?? new Date(0).toISOString()
+    };
+}
+async function saveOutputIndex(cwd, index) {
+    const indexPath = (0, paths_1.outputIndexPath)(cwd);
+    await (0, utils_1.ensureDir)(node_path_1.default.dirname(indexPath));
+    await promises_1.default.writeFile(indexPath, `${JSON.stringify(index, null, 2)}\n`, "utf8");
+}
+async function setActiveArtifact(cwd, type, filePath) {
+    const index = await loadOutputIndex(cwd);
+    const normalizedPath = node_path_1.default.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);
+}
+async function getActiveArtifactPath(cwd, type) {
+    const index = await loadOutputIndex(cwd);
+    const candidate = index.active[type];
+    if (!candidate)
+        return undefined;
+    if (await (0, utils_1.fileExists)(candidate))
+        return candidate;
+    return undefined;
+}

package/dist/core/paths.d.ts

@@ -0,0 +1,17 @@
+import type { ArtifactType } from "./types";
+export declare function prodoPath(cwd: string): string;
+export declare function briefPath(cwd: string): string;
+export declare function normalizedBriefPath(cwd: string): string;
+export declare function settingsPath(cwd: string): string;
+export declare function registryPath(cwd: string): string;
+export declare function promptPath(cwd: string, artifactType: ArtifactType): string;
+export declare function templatePath(cwd: string, artifactType: ArtifactType): string;
+export declare function overrideTemplatePath(cwd: string, artifactType: ArtifactType): string;
+export declare function templateCandidatePaths(cwd: string, artifactType: ArtifactType): string[];
+export declare function overrideTemplateCandidatePaths(cwd: string, artifactType: ArtifactType): string[];
+export declare function schemaPath(cwd: string, artifactType: ArtifactType): string;
+export declare function outputDirPath(cwd: string, artifactType: ArtifactType, outputDirOverride?: string): string;
+export declare function reportPath(cwd: string): string;
+export declare function outputIndexPath(cwd: string): string;
+export declare function outputContextDirPath(cwd: string): string;
+export declare function normHistoryPath(cwd: string): string;

package/dist/core/paths.js

@@ -0,0 +1,80 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prodoPath = prodoPath;
+exports.briefPath = briefPath;
+exports.normalizedBriefPath = normalizedBriefPath;
+exports.settingsPath = settingsPath;
+exports.registryPath = registryPath;
+exports.promptPath = promptPath;
+exports.templatePath = templatePath;
+exports.overrideTemplatePath = overrideTemplatePath;
+exports.templateCandidatePaths = templateCandidatePaths;
+exports.overrideTemplateCandidatePaths = overrideTemplateCandidatePaths;
+exports.schemaPath = schemaPath;
+exports.outputDirPath = outputDirPath;
+exports.reportPath = reportPath;
+exports.outputIndexPath = outputIndexPath;
+exports.outputContextDirPath = outputContextDirPath;
+exports.normHistoryPath = normHistoryPath;
+const node_path_1 = __importDefault(require("node:path"));
+const constants_1 = require("./constants");
+function prodoPath(cwd) {
+    return node_path_1.default.join(cwd, constants_1.PRODO_DIR);
+}
+function briefPath(cwd) {
+    return node_path_1.default.join(cwd, "brief.md");
+}
+function normalizedBriefPath(cwd) {
+    return node_path_1.default.join(prodoPath(cwd), "briefs", "normalized-brief.json");
+}
+function settingsPath(cwd) {
+    return node_path_1.default.join(prodoPath(cwd), "settings.json");
+}
+function registryPath(cwd) {
+    return node_path_1.default.join(prodoPath(cwd), "registry.json");
+}
+function promptPath(cwd, artifactType) {
+    return node_path_1.default.join(prodoPath(cwd), "prompts", `${artifactType}.md`);
+}
+function templatePath(cwd, artifactType) {
+    return node_path_1.default.join(prodoPath(cwd), "templates", `${artifactType}.md`);
+}
+function overrideTemplatePath(cwd, artifactType) {
+    return node_path_1.default.join(prodoPath(cwd), "templates", "overrides", `${artifactType}.md`);
+}
+function templateExtensionsForArtifact(artifactType) {
+    if (artifactType === "workflow")
+        return ["md", "mmd"];
+    if (artifactType === "wireframe")
+        return ["md", "html"];
+    return ["md"];
+}
+function templateCandidatePaths(cwd, artifactType) {
+    const root = node_path_1.default.join(prodoPath(cwd), "templates");
+    return templateExtensionsForArtifact(artifactType).map((ext) => node_path_1.default.join(root, `${artifactType}.${ext}`));
+}
+function overrideTemplateCandidatePaths(cwd, artifactType) {
+    const root = node_path_1.default.join(prodoPath(cwd), "templates", "overrides");
+    return templateExtensionsForArtifact(artifactType).map((ext) => node_path_1.default.join(root, `${artifactType}.${ext}`));
+}
+function schemaPath(cwd, artifactType) {
+    return node_path_1.default.join(prodoPath(cwd), "schemas", `${artifactType}.yaml`);
+}
+function outputDirPath(cwd, artifactType, outputDirOverride) {
+    return node_path_1.default.join(cwd, "product-docs", outputDirOverride ?? (0, constants_1.defaultOutputDir)(artifactType));
+}
+function reportPath(cwd) {
+    return node_path_1.default.join(cwd, "product-docs", "reports", "latest-validation.md");
+}
+function outputIndexPath(cwd) {
+    return node_path_1.default.join(prodoPath(cwd), "state", "index.json");
+}
+function outputContextDirPath(cwd) {
+    return node_path_1.default.join(prodoPath(cwd), "state", "context");
+}
+function normHistoryPath(cwd) {
+    return node_path_1.default.join(prodoPath(cwd), "_norm_history.json");
+}

package/dist/core/project-config.d.ts

@@ -0,0 +1,14 @@
+import type { ContractCoverage } from "./types";
+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[];
+};
+export declare function readProjectConfig(cwd: string): Promise<ProdoProjectConfig>;

package/dist/core/project-config.js

@@ -0,0 +1,69 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readProjectConfig = readProjectConfig;
+const promises_1 = __importDefault(require("node:fs/promises"));
+const node_path_1 = __importDefault(require("node:path"));
+const errors_1 = require("./errors");
+const utils_1 = require("./utils");
+function sanitizeStringArray(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value
+        .filter((item) => typeof item === "string")
+        .map((item) => item.trim())
+        .filter((item) => item.length > 0);
+}
+function sanitizeArtifact(raw) {
+    if (!raw || typeof raw !== "object")
+        return null;
+    const rec = raw;
+    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 === "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) {
+    if (!raw || typeof raw !== "object")
+        return {};
+    const rec = raw;
+    const artifacts = Array.isArray(rec.artifacts)
+        ? rec.artifacts.map(sanitizeArtifact).filter((item) => item !== null)
+        : [];
+    return {
+        presets: sanitizeStringArray(rec.presets),
+        command_packs: sanitizeStringArray(rec.command_packs),
+        ...(artifacts.length > 0 ? { artifacts } : {})
+    };
+}
+async function readProjectConfig(cwd) {
+    const candidates = [
+        node_path_1.default.join(cwd, ".prodo", "config.json"),
+        node_path_1.default.join(cwd, "prodo.config.json")
+    ];
+    for (const candidate of candidates) {
+        if (!(await (0, utils_1.fileExists)(candidate)))
+            continue;
+        try {
+            const parsed = JSON.parse(await promises_1.default.readFile(candidate, "utf8"));
+            return sanitizeConfig(parsed);
+        }
+        catch {
+            throw new errors_1.UserError(`Invalid project config JSON: ${candidate}`);
+        }
+    }
+    return {};
+}

package/dist/core/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/core/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/core/settings.d.ts

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

package/dist/core/settings.js

@@ -0,0 +1,35 @@
+"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,
+            author: typeof parsed.author === "string" && parsed.author.trim() ? parsed.author.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/core/template-engine.d.ts

@@ -0,0 +1,3 @@
+import nunjucks from "nunjucks";
+export declare function renderTemplate(content: string, context: Record<string, unknown>): string;
+export declare function getTemplateEnv(): nunjucks.Environment;

package/dist/core/template-engine.js

@@ -0,0 +1,43 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderTemplate = renderTemplate;
+exports.getTemplateEnv = getTemplateEnv;
+const nunjucks_1 = __importDefault(require("nunjucks"));
+const env = new nunjucks_1.default.Environment(null, {
+    autoescape: false,
+    throwOnUndefined: false,
+    trimBlocks: false,
+    lstripBlocks: false
+});
+env.addFilter("slug", (value) => {
+    return (value || "")
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "") || "item";
+});
+env.addFilter("bold", (value) => {
+    return `**${value ?? ""}**`;
+});
+env.addFilter("dateFormat", (value) => {
+    if (!value)
+        return new Date().toISOString().split("T")[0];
+    const d = typeof value === "string" ? new Date(value) : value;
+    return d.toISOString().split("T")[0];
+});
+env.addFilter("upper", (value) => {
+    return (value ?? "").toUpperCase();
+});
+env.addFilter("default", (value, fallback) => {
+    if (value === null || value === undefined || value === "")
+        return fallback;
+    return String(value);
+});
+function renderTemplate(content, context) {
+    return env.renderString(content, context);
+}
+function getTemplateEnv() {
+    return env;
+}

package/dist/core/template-resolver.d.ts

@@ -0,0 +1,15 @@
+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 resolveCompanionTemplate(options: ResolveOptions): Promise<{
+    path: string;
+    content: string;
+} | null>;
+export declare function extractRequiredHeadingsFromTemplate(content: string): string[];
+export {};