@deftai/directive-core 0.55.0

package/dist/render/framework-commands.js

@@ -0,0 +1,416 @@
+import { execFileSync } from "node:child_process";
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { cmdDoctor } from "../doctor/main.js";
+function spec(name, entrypoint, opts = {}) {
+    return { name, entrypoint, ...opts };
+}
+function aggregate(name, commands, description = "") {
+    return { name, aggregate: commands, description };
+}
+export const COMMANDS = {
+    "core:validate": spec("core:validate", "framework_commands:_cmd_core_validate", {
+        cwd: "framework",
+    }),
+    "core:lint": spec("core:lint", "framework_commands:_cmd_core_lint", { cwd: "framework" }),
+    "core:test": spec("core:test", "framework_commands:_cmd_core_test", { cwd: "framework" }),
+    doctor: spec("doctor", "doctor:cmd_doctor"),
+    "session:start": spec("session:start", "session_start:main", {
+        projectRootArg: "--project-root",
+    }),
+    "triage:welcome": spec("triage:welcome", "triage_welcome:main", {
+        projectRootArg: "--project-root",
+    }),
+    "triage:bootstrap": spec("triage:bootstrap", "triage_bootstrap:main", {
+        projectRootArg: "--project-root",
+    }),
+    "triage:summary": spec("triage:summary", "triage_summary:main", {
+        projectRootArg: "--project-root",
+    }),
+    "triage:queue": spec("triage:queue", "triage_queue:main", {
+        defaultArgs: ["queue"],
+        projectRootArg: "--project-root",
+    }),
+    "triage:show": spec("triage:show", "triage_queue:main", {
+        defaultArgs: ["show"],
+        projectRootArg: "--project-root",
+    }),
+    "triage:audit": spec("triage:audit", "triage_queue:main", {
+        defaultArgs: ["audit"],
+        projectRootArg: "--project-root",
+    }),
+    "triage:accept": spec("triage:accept", "triage_actions:main", { defaultArgs: ["accept"] }),
+    "triage:status": spec("triage:status", "triage_actions:main", { defaultArgs: ["status"] }),
+    "triage:scope": spec("triage:scope", "triage_scope:main"),
+    "migrate:vbrief": spec("migrate:vbrief", "framework_commands:_cmd_migrate_vbrief"),
+    "cache:fetch-all": spec("cache:fetch-all", "cache:main", { defaultArgs: ["fetch-all"] }),
+    "capacity:show": spec("capacity:show", "capacity_show:main", {
+        projectRootArg: "--project-root",
+    }),
+    "scope:demote": spec("scope:demote", "scope_demote:main", { projectRootArg: "--project-root" }),
+    "toolchain:check": spec("toolchain:check", "toolchain-check.py:main", { noArgv: true }),
+    "verify:stubs": spec("verify:stubs", "verify-stubs.py:main", { noArgv: true }),
+    "verify:links": spec("verify:links", "validate-links.py:main", { noArgv: true }),
+    "verify:rule-ownership": spec("verify:rule-ownership", "rule_ownership_lint:main", {
+        rootArg: "--root",
+        cwd: "framework",
+    }),
+    "verify:branch": spec("verify:branch", "preflight_branch:main", {
+        defaultArgs: ["--allow-missing-project-definition"],
+        projectRootArg: "--project-root",
+    }),
+    "verify:encoding": spec("verify:encoding", "verify_encoding:main", {
+        projectRootArg: "--project-root",
+    }),
+    "verify:vbrief-conformance": spec("verify:vbrief-conformance", "verify_vbrief_conformance:main", {
+        projectRootArg: "--project-root",
+    }),
+    "verify:destructive-gh-verbs": spec("verify:destructive-gh-verbs", "preflight_gh:main", {
+        defaultArgs: ["--self-test"],
+        projectRootArg: "--project-root",
+    }),
+    "verify:scm-boundary": spec("verify:scm-boundary", "verify_scm_boundary:main", {
+        projectRootArg: "--project-root",
+    }),
+    "verify:no-task-runtime": spec("verify:no-task-runtime", "verify_no_task_runtime:main", {
+        noArgv: true,
+        cwd: "framework",
+    }),
+    "verify:cache-fresh": spec("verify:cache-fresh", "preflight_cache:main", {
+        defaultArgs: ["--allow-missing-bootstrap"],
+        projectRootArg: "--project-root",
+    }),
+    "verify:wip-cap": spec("verify:wip-cap", "preflight_wip_cap:main", {
+        projectRootArg: "--project-root",
+    }),
+    "verify:pack-drift": spec("verify:pack-drift", "pack_render:main", {
+        defaultArgs: ["--check"],
+        cwd: "framework",
+    }),
+    "verify-strategy-output": spec("verify-strategy-output", "validate_strategy_output:main", {
+        projectRootArg: "--project-root",
+    }),
+    "vbrief:validate": spec("vbrief:validate", "vbrief_validate:main", {
+        vbriefDirArg: "--vbrief-dir",
+    }),
+    build: spec("build", "build_dist:main", {
+        defaultArgs: ["--version", "__DEFT_VERSION__"],
+        cwd: "framework",
+    }),
+    "check:consumer": aggregate("check:consumer", [
+        "doctor",
+        "toolchain:check",
+        "verify:branch",
+        "verify:cache-fresh",
+        "verify:wip-cap",
+        "vbrief:validate",
+        "verify-strategy-output",
+    ]),
+    "check:framework-source": aggregate("check:framework-source", [
+        "core:validate",
+        "core:lint",
+        "core:test",
+        "toolchain:check",
+        "verify:stubs",
+        "verify:links",
+        "verify:rule-ownership",
+        "verify:branch",
+        "verify:encoding",
+        "verify:vbrief-conformance",
+        "verify:destructive-gh-verbs",
+        "verify:scm-boundary",
+        "verify:no-task-runtime",
+        "verify:cache-fresh",
+        "verify:pack-drift",
+        "verify:wip-cap",
+        "vbrief:validate",
+        "verify-strategy-output",
+    ]),
+};
+export function availableCommands() {
+    return Object.keys(COMMANDS).sort();
+}
+export function hasCommand(name) {
+    return name in COMMANDS;
+}
+export function normalizeTaskSeparator(argv) {
+    const args = [...argv];
+    if (args[0] === "--")
+        return args.slice(1);
+    return args;
+}
+export function formatFrameworkCommand(args, options = {}) {
+    const surface = options.surface ?? "deft";
+    const parts = [...args];
+    if (surface === "task") {
+        let prefix = (options.taskPrefix ?? "").trim();
+        if (prefix && !prefix.endsWith(":"))
+            prefix = `${prefix}:`;
+        if (parts.length > 0 && parts[0])
+            parts[0] = `${prefix}${parts[0]}`;
+        return ["task", ...parts].join(" ");
+    }
+    return [surface, ...parts].join(" ");
+}
+const EXCLUDE_PARTS = new Set([".git", "backup"]);
+function collectMarkdownFiles(root) {
+    const out = [];
+    const walk = (dir, parts) => {
+        if (parts.some((p) => EXCLUDE_PARTS.has(p)))
+            return;
+        let entries;
+        try {
+            entries = readdirSync(dir).sort();
+        }
+        catch {
+            return;
+        }
+        for (const name of entries) {
+            const full = join(dir, name);
+            const rel = parts.length === 0 ? name : join(...parts, name);
+            const nextParts = [...parts, name];
+            if (nextParts.some((p) => EXCLUDE_PARTS.has(p)))
+                continue;
+            let st;
+            try {
+                st = statSync(full);
+            }
+            catch {
+                continue;
+            }
+            if (st.isDirectory())
+                walk(full, nextParts);
+            else if (name.endsWith(".md"))
+                out.push(rel);
+        }
+    };
+    walk(root, []);
+    return out.sort();
+}
+export function cmdCoreValidate(argv) {
+    if (argv.length > 0) {
+        process.stderr.write(`error: core:validate does not accept arguments: ${argv.join(" ")}\n`);
+        return 2;
+    }
+    const files = collectMarkdownFiles(".");
+    for (const path of files)
+        process.stdout.write(`✓ ${path}\n`);
+    process.stdout.write(`✓ All ${files.length} markdown files validated\n`);
+    return 0;
+}
+function runUv(args, frameworkRoot) {
+    try {
+        execFileSync("uv", ["--project", frameworkRoot, "run", ...args], {
+            encoding: "utf8",
+            stdio: "inherit",
+        });
+        return 0;
+    }
+    catch (err) {
+        const e = err;
+        return e.status ?? 1;
+    }
+}
+export function cmdCoreLint(argv) {
+    if (argv.length > 0) {
+        process.stderr.write(`error: core:lint does not accept arguments: ${argv.join(" ")}\n`);
+        return 2;
+    }
+    const ruffCode = runUv(["ruff", "check", "."], resolveFrameworkRoot());
+    if (ruffCode !== 0)
+        return ruffCode;
+    const targets = ["run.py"];
+    if (existsSync("tests"))
+        targets.push("tests");
+    return runUv(["python", "-m", "mypy", ...targets], resolveFrameworkRoot());
+}
+export function cmdCoreTest(argv) {
+    if (argv.length > 0) {
+        process.stderr.write(`error: core:test does not accept arguments: ${argv.join(" ")}\n`);
+        return 2;
+    }
+    if (!existsSync("tests")) {
+        process.stdout.write("no tests/ (vendored consumer) -- skipping\n");
+        return 0;
+    }
+    try {
+        execFileSync("python3", ["-m", "pytest", "tests"], { encoding: "utf8", stdio: "inherit" });
+        return 0;
+    }
+    catch (err) {
+        const e = err;
+        return e.status ?? 1;
+    }
+}
+function resolveVersion() {
+    try {
+        const mod = readFileSync(join(resolveFrameworkRoot(), "VERSION"), "utf8").trim();
+        return mod || "0.0.0-dev";
+    }
+    catch {
+        return "0.0.0-dev";
+    }
+}
+export function resolveFrameworkRoot() {
+    if (process.env.DEFT_ROOT && process.env.DEFT_ROOT.length > 0) {
+        return resolve(process.env.DEFT_ROOT);
+    }
+    return resolve(import.meta.dirname, "..", "..", "..", "..");
+}
+function argvForSpec(commandSpec, argv, projectRoot, frameworkRoot) {
+    const resolved = [];
+    for (const item of commandSpec.defaultArgs ?? []) {
+        resolved.push(item === "__DEFT_VERSION__" ? resolveVersion() : item);
+    }
+    if (commandSpec.projectRootArg)
+        resolved.push(commandSpec.projectRootArg, projectRoot);
+    if (commandSpec.frameworkRootArg)
+        resolved.push(commandSpec.frameworkRootArg, frameworkRoot);
+    if (commandSpec.vbriefDirArg)
+        resolved.push(commandSpec.vbriefDirArg, join(projectRoot, "vbrief"));
+    if (commandSpec.rootArg)
+        resolved.push(commandSpec.rootArg, frameworkRoot);
+    resolved.push(...normalizeTaskSeparator(argv));
+    return resolved;
+}
+const TS_INLINE = {
+    "framework_commands:_cmd_core_validate": (argv) => cmdCoreValidate(argv),
+    "framework_commands:_cmd_core_lint": (argv) => cmdCoreLint(argv),
+    "framework_commands:_cmd_core_test": (argv) => cmdCoreTest(argv),
+    "doctor:cmd_doctor": (argv) => cmdDoctor(argv),
+};
+function spawnPythonEntrypoint(entrypoint, argv, cwd, frameworkRoot, noArgv) {
+    const scriptsDir = join(frameworkRoot, "scripts").replace(/\\/g, "/");
+    const code = [
+        "import sys, importlib, importlib.util, inspect, os",
+        `sys.path.insert(0, ${JSON.stringify(scriptsDir)})`,
+        `os.chdir(${JSON.stringify(cwd.replace(/\\/g, "/"))})`,
+        `entrypoint = ${JSON.stringify(entrypoint)}`,
+        "module_ref, _, func_name = entrypoint.partition(':')",
+        "if module_ref.endswith('.py'):",
+        "    path = __import__('pathlib').Path(module_ref)",
+        "    if not path.is_absolute():",
+        `        path = __import__('pathlib').Path(${JSON.stringify(scriptsDir)}) / module_ref`,
+        "    module_name = '_deft_cmd_' + path.stem.replace('-', '_')",
+        "    spec = importlib.util.spec_from_file_location(module_name, path)",
+        "    mod = importlib.util.module_from_spec(spec)",
+        "    spec.loader.exec_module(mod)",
+        "else:",
+        "    mod = importlib.import_module(module_ref)",
+        "func = getattr(mod, func_name)",
+        `argv = ${JSON.stringify(argv)}`,
+        "if not callable(func):",
+        "    raise TypeError('not callable')",
+        noArgv
+            ? "code = func() if len(inspect.signature(func).parameters) == 0 else func([])"
+            : "code = func() if len(inspect.signature(func).parameters) == 0 else func(argv)",
+        "sys.exit(int(code or 0))",
+    ].join("\n");
+    try {
+        const stdout = execFileSync("uv", ["--project", frameworkRoot, "run", "python", "-c", code], {
+            cwd: frameworkRoot,
+            encoding: "utf8",
+            env: { ...process.env, PYTHONUTF8: "1", DEFT_CACHE_DISABLE: "1" },
+        });
+        return { code: 0, stdout: typeof stdout === "string" ? stdout : "", stderr: "" };
+    }
+    catch (err) {
+        const e = err;
+        return {
+            code: e.status ?? 2,
+            stdout: typeof e.stdout === "string" ? e.stdout : "",
+            stderr: typeof e.stderr === "string" ? e.stderr : "",
+        };
+    }
+}
+function invokeEntrypoint(entrypoint, argv, cwd, frameworkRoot, noArgv, capture) {
+    const inline = TS_INLINE[entrypoint];
+    if (inline) {
+        if (capture) {
+            const chunks = { out: "", err: "" };
+            const prevOut = process.stdout.write.bind(process.stdout);
+            const prevErr = process.stderr.write.bind(process.stderr);
+            process.stdout.write = (chunk) => {
+                chunks.out += String(chunk);
+                return true;
+            };
+            process.stderr.write = (chunk) => {
+                chunks.err += String(chunk);
+                return true;
+            };
+            let code;
+            try {
+                code = inline(argv);
+            }
+            finally {
+                process.stdout.write = prevOut;
+                process.stderr.write = prevErr;
+            }
+            return { code, stdout: chunks.out, stderr: chunks.err };
+        }
+        return { code: inline(argv), stdout: "", stderr: "" };
+    }
+    return spawnPythonEntrypoint(entrypoint, argv, cwd, frameworkRoot, noArgv);
+}
+export function runFrameworkCommand(name, argv = [], options = {}) {
+    const root = resolve(options.projectRoot ?? process.cwd());
+    const framework = resolve(options.frameworkRoot ?? resolveFrameworkRoot());
+    const commandSpec = COMMANDS[name];
+    if (!commandSpec) {
+        return { code: 2, stdout: "", stderr: `unknown framework command: ${name}` };
+    }
+    if (commandSpec.aggregate && commandSpec.aggregate.length > 0) {
+        const stdoutParts = [];
+        const stderrParts = [];
+        for (const child of commandSpec.aggregate) {
+            options.outputFn?.(`[deft] ${child}`);
+            const result = runFrameworkCommand(child, [], {
+                ...options,
+                projectRoot: root,
+                frameworkRoot: framework,
+            });
+            stdoutParts.push(result.stdout);
+            stderrParts.push(result.stderr);
+            if (result.code !== 0) {
+                return { code: result.code, stdout: stdoutParts.join(""), stderr: stderrParts.join("") };
+            }
+        }
+        return { code: 0, stdout: stdoutParts.join(""), stderr: stderrParts.join("") };
+    }
+    if (!commandSpec.entrypoint) {
+        return { code: 2, stdout: "", stderr: `framework command has no entrypoint: ${name}` };
+    }
+    const commandArgv = argvForSpec(commandSpec, argv, root, framework);
+    const cwd = commandSpec.cwd === "framework" ? framework : root;
+    const capture = options.capture ?? false;
+    try {
+        const result = invokeEntrypoint(commandSpec.entrypoint, commandArgv, cwd, framework, commandSpec.noArgv ?? false, capture);
+        if (!capture) {
+            if (result.stdout)
+                process.stdout.write(result.stdout);
+            if (result.stderr)
+                process.stderr.write(result.stderr);
+        }
+        return result;
+    }
+    catch (exc) {
+        const msg = `${exc instanceof Error ? exc.name : "Error"}: ${String(exc)}`;
+        if (capture)
+            return { code: 2, stdout: "", stderr: msg };
+        process.stderr.write(`${msg}\n`);
+        return { code: 2, stdout: "", stderr: msg };
+    }
+}
+/** CLI entry (mirrors ``scripts/framework_commands.main``). */
+export function main(argv) {
+    if (argv.length === 0 || argv[0] === "-h" || argv[0] === "--help" || argv[0] === "help") {
+        process.stdout.write("Usage: framework_commands.py <verb> [args...]\n\nAvailable framework verbs:\n");
+        for (const name of availableCommands())
+            process.stdout.write(`  ${name}\n`);
+        return 0;
+    }
+    const [command, ...rest] = argv;
+    const result = runFrameworkCommand(command ?? "", rest);
+    return result.code;
+}
+//# sourceMappingURL=framework-commands.js.map

package/dist/render/index.d.ts

@@ -0,0 +1,15 @@
+export * from "./constants.js";
+export * as frameworkCommands from "./framework-commands.js";
+export { availableCommands, cmdCoreValidate, formatFrameworkCommand, hasCommand, main as frameworkCommandsMain, normalizeTaskSeparator, runFrameworkCommand, } from "./framework-commands.js";
+export * as prdRender from "./prd-render.js";
+export { main as prdRenderMain, parsePrdArgv, renderPrd } from "./prd-render.js";
+export * as projectRender from "./project-render.js";
+export { flagStaleNarratives, main as projectRenderMain, renderProjectDefinition, scanLifecycleFolders, } from "./project-render.js";
+export * as roadmapRender from "./roadmap-render.js";
+export { checkDrift, generateRoadmapContent, main as roadmapRenderMain, renderRoadmap, } from "./roadmap-render.js";
+export * as specRender from "./spec-render.js";
+export { main as specRenderMain, parseIncludeScopesFlag, renderSpec } from "./spec-render.js";
+export * as specValidate from "./spec-validate.js";
+export { main as specValidateMain, validateSpec } from "./spec-validate.js";
+export { parsePhaseNumber, phaseSortKey, splitCamel, splitWords } from "./text-utils.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/render/index.js

@@ -0,0 +1,15 @@
+export * from "./constants.js";
+export * as frameworkCommands from "./framework-commands.js";
+export { availableCommands, cmdCoreValidate, formatFrameworkCommand, hasCommand, main as frameworkCommandsMain, normalizeTaskSeparator, runFrameworkCommand, } from "./framework-commands.js";
+export * as prdRender from "./prd-render.js";
+export { main as prdRenderMain, parsePrdArgv, renderPrd } from "./prd-render.js";
+export * as projectRender from "./project-render.js";
+export { flagStaleNarratives, main as projectRenderMain, renderProjectDefinition, scanLifecycleFolders, } from "./project-render.js";
+export * as roadmapRender from "./roadmap-render.js";
+export { checkDrift, generateRoadmapContent, main as roadmapRenderMain, renderRoadmap, } from "./roadmap-render.js";
+export * as specRender from "./spec-render.js";
+export { main as specRenderMain, parseIncludeScopesFlag, renderSpec } from "./spec-render.js";
+export * as specValidate from "./spec-validate.js";
+export { main as specValidateMain, validateSpec } from "./spec-validate.js";
+export { parsePhaseNumber, phaseSortKey, splitCamel, splitWords } from "./text-utils.js";
+//# sourceMappingURL=index.js.map

package/dist/render/prd-render.d.ts

@@ -0,0 +1,14 @@
+export interface RenderPrdOptions {
+    readonly force?: boolean;
+}
+/** Read specification.vbrief.json and write PRD.md (mirrors ``scripts/prd_render.render_prd``). */
+export declare function renderPrd(specPath: string, outputPath: string, options?: RenderPrdOptions): void;
+export interface PrdCliArgs {
+    readonly spec?: string;
+    readonly output?: string;
+    readonly force?: boolean;
+}
+/** CLI entry (mirrors ``scripts/prd_render.main``). */
+export declare function main(args?: PrdCliArgs): void;
+export declare function parsePrdArgv(argv: readonly string[]): PrdCliArgs;
+//# sourceMappingURL=prd-render.d.ts.map

package/dist/render/prd-render.js

@@ -0,0 +1,79 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { PRD_BANNER, PRD_GENERATED_SENTINEL, PRD_NARRATIVE_KEY_ORDER } from "./constants.js";
+function isDeftGenerated(path) {
+    if (!existsSync(path))
+        return true;
+    try {
+        const fh = readFileSync(path, "utf8");
+        const head = fh.length > 4096 ? fh.slice(0, 4096) : fh;
+        return head.includes(PRD_GENERATED_SENTINEL);
+    }
+    catch {
+        return false;
+    }
+}
+/** Read specification.vbrief.json and write PRD.md (mirrors ``scripts/prd_render.render_prd``). */
+export function renderPrd(specPath, outputPath, options = {}) {
+    const force = options.force ?? false;
+    if (!existsSync(specPath)) {
+        process.stderr.write(`Error: specification file not found: ${specPath}\n`);
+        process.exit(1);
+    }
+    if (!force && !isDeftGenerated(outputPath)) {
+        process.stderr.write(`Error: refusing to overwrite non-generated PRD at ${outputPath}. ` +
+            `This file lacks the "${PRD_GENERATED_SENTINEL}" banner -- it was likely hand-authored. ` +
+            "Re-run with --force to overwrite, or point --output at a different file (#539).\n");
+        process.exit(2);
+    }
+    const data = JSON.parse(readFileSync(specPath, "utf8"));
+    const plan = (data.plan ?? {});
+    const title = String(plan.title ?? "Project");
+    const narratives = typeof plan.narratives === "object" &&
+        plan.narratives !== null &&
+        !Array.isArray(plan.narratives)
+        ? plan.narratives
+        : {};
+    if (Object.keys(narratives).length === 0) {
+        process.stderr.write(`Warning: no narratives found in ${specPath}\n`);
+    }
+    const lines = [PRD_BANNER, `# ${title} -- Product Requirements Document\n`];
+    const renderedKeys = new Set();
+    for (const key of PRD_NARRATIVE_KEY_ORDER) {
+        if (key in narratives) {
+            lines.push(`## ${key}\n`);
+            lines.push(`${String(narratives[key])}\n`);
+            renderedKeys.add(key);
+        }
+    }
+    for (const key of Object.keys(narratives).sort()) {
+        if (!renderedKeys.has(key)) {
+            lines.push(`## ${key}\n`);
+            lines.push(`${String(narratives[key])}\n`);
+        }
+    }
+    lines.push("---\n" +
+        "*This document is auto-generated from `vbrief/specification.vbrief.json` " +
+        "via `task prd:render`. Do not edit directly.*\n");
+    writeFileSync(outputPath, lines.join("\n"), "utf8");
+    process.stdout.write(`PRD.md written to ${outputPath}\n`);
+}
+/** CLI entry (mirrors ``scripts/prd_render.main``). */
+export function main(args = {}) {
+    renderPrd(args.spec ?? "vbrief/specification.vbrief.json", args.output ?? "PRD.md", {
+        force: args.force ?? false,
+    });
+}
+export function parsePrdArgv(argv) {
+    const out = {};
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i] ?? "";
+        if (arg === "--force")
+            out.force = true;
+        else if (arg === "--spec")
+            out.spec = argv[++i];
+        else if (arg === "--output")
+            out.output = argv[++i];
+    }
+    return out;
+}
+//# sourceMappingURL=prd-render.js.map

package/dist/render/project-render.d.ts

@@ -0,0 +1,20 @@
+type JsonObject = Record<string, unknown>;
+export interface LifecycleItem {
+    id: string;
+    title: string;
+    status: string;
+    metadata: Record<string, unknown>;
+}
+export declare function scanLifecycleFolders(vbriefDir: string): LifecycleItem[];
+export declare function flagStaleNarratives(narratives: Record<string, string>, completedItems: LifecycleItem[]): string[];
+export declare function createSkeleton(items: LifecycleItem[], now: string): JsonObject;
+export interface RenderProjectOptions {
+    readonly now?: Date;
+}
+export type RenderProjectResult = readonly [boolean, string];
+/** Regenerate PROJECT-DEFINITION.vbrief.json (mirrors ``scripts/project_render.render_project_definition``). */
+export declare function renderProjectDefinition(vbriefDir: string, options?: RenderProjectOptions): RenderProjectResult;
+/** CLI entry (mirrors ``scripts/project_render.main``). */
+export declare function main(argv: readonly string[]): number;
+export {};
+//# sourceMappingURL=project-render.d.ts.map