@deftai/directive-core 0.61.2 → 0.63.0

package/dist/release/build-dist.js

@@ -0,0 +1,171 @@
+import { createWriteStream, existsSync, mkdirSync, readdirSync, statSync, unlinkSync, } from "node:fs";
+import { createRequire } from "node:module";
+import { platform } from "node:os";
+import { dirname, join, relative, resolve } from "node:path";
+const { ZipArchive, TarArchive } = createRequire(import.meta.url)("archiver");
+export const DEFAULT_EXCLUDES = new Set([
+    ".git",
+    "dist",
+    "backup",
+    "node_modules",
+    "__pycache__",
+    ".venv",
+    "htmlcov",
+    ".pytest_cache",
+    ".mypy_cache",
+    ".ruff_cache",
+    ".coverage",
+]);
+export const DEFAULT_EXCLUDED_PATH_PREFIXES = [
+    "history/archive",
+    "vbrief/completed",
+    "vbrief/cancelled",
+];
+export const ARCHIVE_ROOT = "deft";
+export const CONTENT_PREFIX = "content/";
+const VENDORED_TS_TEST_RE = /\.(test|spec)\.(c|m)?[jt]sx?$/i;
+function flattenContentPrefix(relPosix) {
+    if (relPosix === "content")
+        return relPosix;
+    if (relPosix.startsWith(CONTENT_PREFIX)) {
+        return relPosix.slice(CONTENT_PREFIX.length);
+    }
+    return relPosix;
+}
+function matchesExcludedPrefix(relPosix, prefixes) {
+    return prefixes.some((prefix) => relPosix === prefix || relPosix.startsWith(`${prefix}/`));
+}
+function isVendoredTsTest(relPosix) {
+    if (relPosix !== "packages" && !relPosix.startsWith("packages/")) {
+        return false;
+    }
+    const basename = relPosix.split("/").pop() ?? "";
+    return VENDORED_TS_TEST_RE.test(basename);
+}
+export function iterSourceFiles(root, excludes = DEFAULT_EXCLUDES, excludedPrefixes = DEFAULT_EXCLUDED_PATH_PREFIXES) {
+    const entries = [];
+    const walk = (dir) => {
+        let names;
+        try {
+            names = readdirSync(dir).sort();
+        }
+        catch {
+            return;
+        }
+        for (const name of names) {
+            if (excludes.has(name))
+                continue;
+            const absPath = join(dir, name);
+            let relPosix;
+            try {
+                relPosix = relative(root, absPath).split("\\").join("/");
+            }
+            catch {
+                continue;
+            }
+            if (matchesExcludedPrefix(relPosix, excludedPrefixes))
+                continue;
+            let st;
+            try {
+                st = statSync(absPath);
+            }
+            catch {
+                continue;
+            }
+            if (st.isDirectory()) {
+                walk(absPath);
+                continue;
+            }
+            if (!st.isFile())
+                continue;
+            if (isVendoredTsTest(relPosix))
+                continue;
+            entries.push({ absPath, archiveRel: flattenContentPrefix(relPosix) });
+        }
+    };
+    walk(root);
+    entries.sort((a, b) => a.archiveRel.localeCompare(b.archiveRel));
+    return entries;
+}
+export function selectFormat(arg) {
+    if (arg)
+        return arg.toLowerCase() === "zip" ? "zip" : "tar";
+    return platform().startsWith("win") ? "zip" : "tar";
+}
+export function outputPath(root, version, fmt) {
+    const suffix = fmt === "zip" ? "zip" : "tar.gz";
+    return join(root, "dist", `deft-${version}.${suffix}`);
+}
+export async function buildArchive(root, version, fmt, extraExcludes = []) {
+    const excludes = new Set([...DEFAULT_EXCLUDES, ...extraExcludes]);
+    const output = outputPath(root, version, fmt);
+    mkdirSync(dirname(output), { recursive: true });
+    if (existsSync(output)) {
+        unlinkSync(output);
+    }
+    const entries = iterSourceFiles(root, excludes);
+    await new Promise((resolvePromise, reject) => {
+        const out = createWriteStream(output);
+        const archive = fmt === "zip"
+            ? new ZipArchive({ zlib: { level: 9 } })
+            : new TarArchive({ gzip: true, gzipOptions: { level: 9 } });
+        out.on("close", () => resolvePromise());
+        out.on("error", (err) => reject(err));
+        archive.on("error", (err) => reject(err));
+        archive.pipe(out);
+        for (const { absPath, archiveRel } of entries) {
+            archive.file(absPath, { name: `${ARCHIVE_ROOT}/${archiveRel}` });
+        }
+        void archive.finalize();
+    });
+    return output;
+}
+export function parseExtraExcludes(raw) {
+    return raw
+        .split(",")
+        .map((p) => p.trim())
+        .filter(Boolean);
+}
+export async function main(argv) {
+    const args = [...argv];
+    let version = null;
+    let fmtArg = null;
+    let root = null;
+    let extra = "";
+    for (let i = 0; i < args.length; i += 1) {
+        const arg = args[i];
+        if (arg === "--version")
+            version = args[++i];
+        else if (arg === "--format")
+            fmtArg = args[++i];
+        else if (arg === "--root")
+            root = args[++i];
+        else if (arg === "--exclude-extra")
+            extra = args[++i];
+        else if (arg === "-h" || arg === "--help") {
+            process.stderr.write("usage: build-dist --version X.Y.Z [--format tar|zip] [--root PATH] [--exclude-extra a,b]\n");
+            return 2;
+        }
+    }
+    if (!version) {
+        process.stderr.write("error: --version is required\n");
+        return 2;
+    }
+    const projectRoot = resolve(root ?? process.cwd());
+    if (!existsSync(projectRoot)) {
+        process.stderr.write(`error: root not found: ${projectRoot}\n`);
+        return 2;
+    }
+    const fmt = selectFormat(fmtArg);
+    try {
+        const out = await buildArchive(projectRoot, version, fmt, parseExtraExcludes(extra));
+        const printable = relative(projectRoot, out) || out;
+        process.stdout.write(`Created ${printable}\n`);
+        return 0;
+    }
+    catch (err) {
+        process.stderr.write(`error: ${String(err)}\n`);
+        return 1;
+    }
+}
+//# sourceMappingURL=build-dist.js.map

package/dist/release/constants.d.ts

@@ -13,7 +13,7 @@ export declare const FRESH_UNRELEASED_BLOCK: string;
 export declare const TOTAL_STEPS = 13;
 export declare const VERIFY_DRAFT_MAX_ATTEMPTS = 5;
 export declare const VERIFY_DRAFT_INTERVAL_SECONDS = 1;
-export declare const RELEASE_ARTIFACTS: readonly ["CHANGELOG.md", "ROADMAP.md", "pyproject.toml", "uv.lock"];
+export declare const RELEASE_ARTIFACTS: readonly ["CHANGELOG.md", "ROADMAP.md"];
 export declare const BRANCH_GATE_BYPASS_ENV = "DEFT_ALLOW_DEFAULT_BRANCH_COMMIT";
 export declare const DESTRUCTIVE_GH_GATE_BYPASS_ENV = "DEFT_ALLOW_DESTRUCTIVE_GH_VERBS";
 export declare const PYPROJECT_VERSION_LINE_RE: RegExp;

package/dist/release/constants.js

@@ -21,12 +21,7 @@ export const FRESH_UNRELEASED_BLOCK = "## [Unreleased]\n" +
 export const TOTAL_STEPS = 13;
 export const VERIFY_DRAFT_MAX_ATTEMPTS = 5;
 export const VERIFY_DRAFT_INTERVAL_SECONDS = 1.0;
-export const RELEASE_ARTIFACTS = [
-    "CHANGELOG.md",
-    "ROADMAP.md",
-    "pyproject.toml",
-    "uv.lock",
-];
+export const RELEASE_ARTIFACTS = ["CHANGELOG.md", "ROADMAP.md"];
 export const BRANCH_GATE_BYPASS_ENV = "DEFT_ALLOW_DEFAULT_BRANCH_COMMIT";
 export const DESTRUCTIVE_GH_GATE_BYPASS_ENV = "DEFT_ALLOW_DESTRUCTIVE_GH_VERBS";
 export const PYPROJECT_VERSION_LINE_RE = /version\s*=\s*"[^"]*"/;

package/dist/release/index.d.ts

@@ -1,14 +1,13 @@
+export * from "./build-dist.js";
 export * from "./constants.js";
 export * from "./flags.js";
 export * from "./gh.js";
 export * from "./git.js";
 export * from "./main.js";
+export * from "./native-steps.js";
 export * from "./paths.js";
 export * from "./pipeline.js";
 export * from "./preflight.js";
-export * from "./pyproject.js";
-export * from "./pyproject-sync.js";
-export * from "./python-steps.js";
 export * from "./spawn.js";
 export * from "./types.js";
 export * from "./version.js";

package/dist/release/index.js

@@ -1,15 +1,14 @@
 /* v8 ignore file -- re-export barrel; covered via main.ts */
+export * from "./build-dist.js";
 export * from "./constants.js";
 export * from "./flags.js";
 export * from "./gh.js";
 export * from "./git.js";
 export * from "./main.js";
+export * from "./native-steps.js";
 export * from "./paths.js";
 export * from "./pipeline.js";
 export * from "./preflight.js";
-export * from "./pyproject.js";
-export * from "./pyproject-sync.js";
-export * from "./python-steps.js";
 export * from "./spawn.js";
 export * from "./types.js";
 export * from "./version.js";

package/dist/release/native-steps.d.ts

@@ -0,0 +1,5 @@
+import type { ReleaseSeams } from "./types.js";
+export declare function refreshRoadmapNative(projectRoot: string): [boolean, string];
+export declare function checkVbriefLifecycleSyncNative(projectRoot: string, repo: string): [boolean, number, string];
+export declare function runBuildNative(projectRoot: string, version: string | null, _seams?: ReleaseSeams): [boolean, string];
+//# sourceMappingURL=native-steps.d.ts.map

package/dist/release/native-steps.js

@@ -0,0 +1,72 @@
+/**
+ * Native TypeScript release pipeline steps (#1860).
+ * Replaces python-steps.ts (scripts/ roadmap_render, reconcile_issues, build_dist).
+ */
+import { spawnSync } from "node:child_process";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { fetchIssueStates, isTerminalLifecyclePath, reconcile, scanVbriefDir, } from "../intake/reconcile-issues.js";
+import { renderRoadmap } from "../render/roadmap-render.js";
+const BUILD_DIST_RUNNER = join(dirname(fileURLToPath(import.meta.url)), "build-dist-runner.js");
+export function refreshRoadmapNative(projectRoot) {
+    const pending = join(projectRoot, "vbrief", "pending");
+    const completed = join(projectRoot, "vbrief", "completed");
+    const roadmap = join(projectRoot, "ROADMAP.md");
+    const [ok, msg] = renderRoadmap(pending, roadmap, completed);
+    if (!ok) {
+        return [false, `roadmap:render failed: ${msg}`];
+    }
+    return [true, "ROADMAP.md re-rendered"];
+}
+export function checkVbriefLifecycleSyncNative(projectRoot, repo) {
+    const vbriefDir = join(projectRoot, "vbrief");
+    try {
+        const issueToVbriefs = scanVbriefDir(vbriefDir);
+        const issueStateMap = fetchIssueStates(repo, new Set(issueToVbriefs.keys()), {
+            cwd: projectRoot,
+        });
+        if (issueStateMap === null) {
+            return [false, -1, "failed to fetch issue states from gh"];
+        }
+        const report = reconcile(issueToVbriefs, issueStateMap);
+        const mismatches = [];
+        for (const entry of report.no_open_issue) {
+            const files = (entry.vbrief_files ?? []);
+            for (const rel of files) {
+                if (!isTerminalLifecyclePath(rel)) {
+                    mismatches.push(rel);
+                }
+            }
+        }
+        const count = mismatches.length;
+        if (count === 0) {
+            return [true, 0, "no mismatches"];
+        }
+        const suffix = count > 5 ? " ..." : "";
+        const preview = mismatches.slice(0, 5).join(", ");
+        const reason = `${count} closed-issue vBRIEF(s) not in completed/ or cancelled/: ${preview}${suffix}`;
+        return [false, count, reason];
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return [false, -1, msg];
+    }
+}
+export function runBuildNative(projectRoot, version, _seams = {}) {
+    if (!version) {
+        return [false, "build requires a release version"];
+    }
+    const env = { ...process.env, DEFT_RELEASE_VERSION: version };
+    const result = spawnSync(process.execPath, [BUILD_DIST_RUNNER, version, projectRoot], {
+        cwd: projectRoot,
+        encoding: "utf8",
+        env,
+    });
+    if (result.status !== 0) {
+        const msg = (result.stderr ?? result.stdout ?? "").trim() || `exit ${result.status ?? 1}`;
+        return [false, `build failed: ${msg}`];
+    }
+    const out = (result.stdout ?? "").trim();
+    return [true, `build ran clean (DEFT_RELEASE_VERSION=${version}) -> ${out}`];
+}
+//# sourceMappingURL=native-steps.js.map

package/dist/release/pipeline.js

@@ -4,10 +4,9 @@ import { prependUpgradeBanner, promoteChangelog, sectionForVersion } from "./cha
 import { EXIT_CONFIG_ERROR, EXIT_OK, EXIT_VIOLATION, RELEASE_ARTIFACTS, TOTAL_STEPS, VERIFY_DRAFT_INTERVAL_SECONDS, VERIFY_DRAFT_MAX_ATTEMPTS, } from "./constants.js";
 import { checkTagAvailable, createGithubRelease, readTextFile, verifyReleaseDraft } from "./gh.js";
 import { checkGitClean, commitReleaseArtifacts, createTag, currentBranch, pushRelease, releaseCommitSubject, } from "./git.js";
-import { resolveScriptsDir, todayIso } from "./paths.js";
+import { checkVbriefLifecycleSyncNative, refreshRoadmapNative, runBuildNative, } from "./native-steps.js";
+import { todayIso } from "./paths.js";
 import { runReleaseCheck } from "./preflight.js";
-import { pyprojectPathFor, syncPyprojectForRelease } from "./pyproject-sync.js";
-import { checkVbriefLifecycleSync, refreshRoadmap, runBuild, runUvLock } from "./python-steps.js";
 import { isPrereleaseTag } from "./version.js";
 export function emit(step, label, status, target = process.stderr) {
     target.write(`[${step}/${TOTAL_STEPS}] ${label}... ${status}\n`);
@@ -17,16 +16,14 @@ export function runPipeline(config, seams = {}) {
     const version = config.version;
     const today = (seams.todayIso ?? todayIso)();
     const changelogPath = join(projectRoot, "CHANGELOG.md");
-    const scriptsDir = resolveScriptsDir();
     const readFile = seams.readFile ?? ((p) => readFileSync(p, "utf8"));
     const writeFile = seams.writeFile ?? ((p, c) => writeFileSync(p, c, "utf8"));
     const fileExists = seams.fileExists ?? ((p) => existsSync(p));
     const runCiFn = seams.runCi ?? ((root) => runReleaseCheck(root));
-    const refreshRoadmapFn = seams.refreshRoadmap ?? ((root) => refreshRoadmap(root, scriptsDir, seams));
+    const refreshRoadmapFn = seams.refreshRoadmap ?? ((root) => refreshRoadmapNative(root));
     const checkVbriefFn = seams.checkVbriefLifecycleSync ??
-        ((root, repo) => checkVbriefLifecycleSync(root, repo, scriptsDir, seams));
-    const runBuildFn = seams.runBuild ?? ((root, v) => runBuild(root, scriptsDir, v, seams));
-    const runUvLockFn = seams.runUvLock ?? ((root) => runUvLock(root, seams));
+        ((root, repo) => checkVbriefLifecycleSyncNative(root, repo));
+    const runBuildFn = seams.runBuild ?? ((root, v) => runBuildNative(root, v, seams));
     // Step 1: dirty-tree guard.
     let label = "Pre-flight git status";
     if (config.dryRun) {
@@ -123,7 +120,7 @@ export function runPipeline(config, seams = {}) {
             return EXIT_VIOLATION;
         }
     }
-    // Step 6: CHANGELOG promotion + pyproject sync.
+    // Step 6: CHANGELOG promotion.
     label = "CHANGELOG promotion";
     if (!fileExists(changelogPath)) {
         emit(6, label, `FAIL (CHANGELOG.md not found at ${changelogPath})`);
@@ -148,28 +145,12 @@ export function runPipeline(config, seams = {}) {
     else {
         summaryNote = " no summary";
     }
-    const pyprojectPath = pyprojectPathFor(projectRoot);
-    const [pyprojectNote, promotedPyproject] = syncPyprojectForRelease(pyprojectPath, version, { dryRun: config.dryRun }, seams);
-    if (pyprojectNote.startsWith("FAIL")) {
-        emit(6, label, pyprojectNote);
-        return EXIT_CONFIG_ERROR;
-    }
     if (config.dryRun) {
-        emit(6, label, `DRYRUN (would rewrite CHANGELOG.md: ## [Unreleased] -> ## [${version}] - ${today}; new compare link added;${summaryNote}; ${pyprojectNote}; would run \`uv lock\` to refresh uv.lock to ${version})`);
+        emit(6, label, `DRYRUN (would rewrite CHANGELOG.md: ## [Unreleased] -> ## [${version}] - ${today}; new compare link added;${summaryNote})`);
     }
     else {
         writeFile(changelogPath, promotedChangelog);
-        let uvLockNote = "uv.lock unchanged (pyproject not modified)";
-        if (promotedPyproject !== null) {
-            writeFile(pyprojectPath, promotedPyproject);
-            const [uvOk, uvNote] = runUvLockFn(projectRoot);
-            uvLockNote = uvNote;
-            if (!uvOk) {
-                emit(6, label, `FAIL (${uvLockNote})`);
-                return EXIT_VIOLATION;
-            }
-        }
-        emit(6, label, `OK (## [${version}] - ${today};${summaryNote}; ${pyprojectNote}; ${uvLockNote})`);
+        emit(6, label, `OK (## [${version}] - ${today};${summaryNote})`);
     }
     // Step 7: ROADMAP refresh.
     label = "ROADMAP refresh (task roadmap:render)";

package/dist/release-e2e/rollback-bridge.d.ts

@@ -1,3 +1,3 @@
-/** Invoke release_rollback.main via Python until the TS rollback module lands (#1729). */
+/** Native TypeScript release rollback (#1860). */
 export declare function rollbackMain(argv: string[]): number;
 //# sourceMappingURL=rollback-bridge.d.ts.map

package/dist/release-e2e/rollback-bridge.js

@@ -1,20 +1,6 @@
-import { resolveScriptsDir } from "../release/paths.js";
-import { spawnText } from "../release/spawn.js";
-/** Invoke release_rollback.main via Python until the TS rollback module lands (#1729). */
+import { cmdRollback } from "../release-rollback/main.js";
+/** Native TypeScript release rollback (#1860). */
 export function rollbackMain(argv) {
-    const scriptsDir = resolveScriptsDir();
-    const code = [
-        "import sys",
-        `sys.path.insert(0, ${JSON.stringify(scriptsDir)})`,
-        "import release_rollback",
-        `sys.exit(release_rollback.main(${JSON.stringify(argv)}))`,
-    ].join("\n");
-    const frameworkRoot = scriptsDir.replace(/[/\\]scripts$/, "") || process.cwd();
-    const result = spawnText("uv", ["run", "python", "-c", code], {
-        cwd: frameworkRoot,
-        env: { ...process.env, PYTHONUTF8: "1" },
-        timeoutMs: 300_000,
-    });
-    return result.status ?? 1;
+    return cmdRollback(argv);
 }
 //# sourceMappingURL=rollback-bridge.js.map

package/dist/render/framework-commands.d.ts

@@ -26,8 +26,8 @@ export declare function formatFrameworkCommand(args: readonly string[], options?
     taskPrefix?: string | null;
 }): string;
 export declare function cmdCoreValidate(argv: readonly string[]): number;
-export declare function cmdCoreLint(argv: readonly string[]): number;
-export declare function cmdCoreTest(argv: readonly string[]): number;
+export declare function cmdCoreLint(_argv: readonly string[]): number;
+export declare function cmdCoreTest(_argv: readonly string[]): number;
 export declare function resolveFrameworkRoot(): string;
 export interface RunFrameworkCommandOptions {
     readonly projectRoot?: string;