triflux 10.9.19 → 10.9.21

package/scripts/__tests__/release-governance.test.mjs

@@ -1,148 +0,0 @@
-import assert from "node:assert/strict";
-import { mkdirSync, mkdtempSync, readFileSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { describe, it } from "node:test";
-
-import { bumpVersion } from "../release/bump-version.mjs";
-import { assertVersionSync, writeJson } from "../release/lib.mjs";
-import { prepareRelease } from "../release/prepare.mjs";
-import { publishRelease } from "../release/publish.mjs";
-import { verifyRelease } from "../release/verify.mjs";
-
-function makeRepo() {
-  const root = mkdtempSync(join(tmpdir(), "tfx-release-"));
-  mkdirSync(join(root, "scripts", "release"), { recursive: true });
-  mkdirSync(join(root, ".claude-plugin"), { recursive: true });
-  mkdirSync(join(root, "packages", "triflux"), { recursive: true });
-  mkdirSync(join(root, ".omx", "plans"), { recursive: true });
-
-  writeJson(join(root, "package.json"), { name: "triflux", version: "1.2.3" });
-  writeJson(join(root, "packages", "triflux", "package.json"), {
-    name: "triflux",
-    version: "1.2.0",
-  });
-  writeJson(join(root, ".claude-plugin", "plugin.json"), {
-    name: "triflux",
-    version: "1.1.0",
-  });
-  writeJson(join(root, ".claude-plugin", "marketplace.json"), {
-    version: "1.2.0",
-    plugins: [{ name: "triflux", version: "1.0.0" }],
-  });
-  writeJson(join(root, "package-lock.json"), {
-    name: "triflux",
-    version: "1.2.0",
-    packages: {
-      "": {
-        version: "1.0.0",
-      },
-    },
-  });
-  writeJson(join(root, "scripts", "release", "version-manifest.json"), {
-    canonicalFile: "package.json",
-    canonicalPath: ["version"],
-    targets: [
-      { file: "package.json", paths: [["version"]] },
-      { file: "packages/triflux/package.json", paths: [["version"]] },
-      { file: ".claude-plugin/plugin.json", paths: [["version"]] },
-      {
-        file: ".claude-plugin/marketplace.json",
-        paths: [["version"], ["plugins", 0, "version"]],
-      },
-      {
-        file: "package-lock.json",
-        paths: [["version"], ["packages", "", "version"]],
-      },
-    ],
-  });
-  return root;
-}
-
-describe("release governance scripts", () => {
-  it("assertVersionSync detects mismatches and fixes them", () => {
-    const root = makeRepo();
-    try {
-      const before = assertVersionSync({ rootDir: root });
-      assert.equal(before.ok, false);
-      assert.ok(before.mismatches.length >= 4);
-
-      const after = assertVersionSync({ rootDir: root, fix: true });
-      assert.equal(after.ok, true);
-      assert.deepEqual(
-        JSON.parse(readFileSync(join(root, ".claude-plugin", "plugin.json"))),
-        { name: "triflux", version: "1.2.3" },
-      );
-    } finally {
-      rmSync(root, { recursive: true, force: true });
-    }
-  });
-
-  it("bumpVersion writes canonical version and syncs targets", async () => {
-    const root = makeRepo();
-    try {
-      const result = await bumpVersion({
-        rootDir: root,
-        nextVersion: "2.0.0",
-        write: true,
-      });
-      assert.equal(result.ok, true);
-      assert.equal(
-        JSON.parse(readFileSync(join(root, "package.json"), "utf8")).version,
-        "2.0.0",
-      );
-      assert.equal(
-        JSON.parse(
-          readFileSync(
-            join(root, "packages", "triflux", "package.json"),
-            "utf8",
-          ),
-        ).version,
-        "2.0.0",
-      );
-    } finally {
-      rmSync(root, { recursive: true, force: true });
-    }
-  });
-
-  it("prepare/publish/verify support dry-run planning", async () => {
-    const root = makeRepo();
-    try {
-      assertVersionSync({ rootDir: root, fix: true });
-      const execStub = (command, args) => {
-        if (command === "git" && args[0] === "status") return "";
-        if (command === "git" && args[0] === "describe") return "v1.2.2";
-        if (command === "git" && args[0] === "log")
-          return "abc1234 feat: sample\n";
-        return "";
-      };
-
-      const prepare = await prepareRelease({
-        rootDir: root,
-        version: "1.2.3",
-        allowDirty: true,
-        dryRun: true,
-        execFileSyncFn: execStub,
-      });
-      assert.equal(prepare.ok, true);
-      assert.equal(prepare.commands.length, 3);
-
-      const publish = await publishRelease({
-        rootDir: root,
-        version: "1.2.3",
-        dryRun: true,
-      });
-      assert.equal(publish.steps.length >= 3, true);
-
-      const verify = await verifyRelease({
-        rootDir: root,
-        version: "1.2.3",
-        dryRun: true,
-      });
-      assert.equal(verify.ok, true);
-      assert.equal(verify.checks[1].name, "npm-view");
-    } finally {
-      rmSync(root, { recursive: true, force: true });
-    }
-  });
-});

package/scripts/release/bump-version.mjs

@@ -1,77 +0,0 @@
-#!/usr/bin/env node
-import { join } from "node:path";
-import { fileURLToPath } from "node:url";
-import {
-  assertVersionSync,
-  isSemver,
-  parseArgs,
-  ROOT,
-  readJson,
-  syncVersionTargets,
-  writeJson,
-} from "./lib.mjs";
-
-export async function bumpVersion({
-  nextVersion,
-  rootDir = ROOT,
-  write = false,
-} = {}) {
-  if (!isSemver(nextVersion)) {
-    throw new Error(`Invalid semver version: ${nextVersion}`);
-  }
-
-  const packagePath = join(rootDir, "package.json");
-  const packageJson = readJson(packagePath);
-  const previousVersion = packageJson.version;
-  packageJson.version = nextVersion;
-
-  if (write) {
-    writeJson(packagePath, packageJson);
-    const syncedFiles = syncVersionTargets({
-      rootDir,
-      expectedVersion: nextVersion,
-    });
-    const post = assertVersionSync({ rootDir, expectedVersion: nextVersion });
-    return {
-      ok: post.ok,
-      previousVersion,
-      nextVersion,
-      updatedFiles: ["package.json", ...syncedFiles],
-      targets: post.targets,
-    };
-  }
-
-  const preview = assertVersionSync({
-    rootDir,
-    expectedVersion: nextVersion,
-  });
-  return {
-    ok: true,
-    previousVersion,
-    nextVersion,
-    updatedFiles: ["package.json"],
-    targets: preview.targets.map((target) => ({
-      ...target,
-      expected: nextVersion,
-      inSync: target.file === "package.json",
-    })),
-  };
-}
-
-if (process.argv[1] && fileURLToPath(import.meta.url) === process.argv[1]) {
-  const args = parseArgs(process.argv.slice(2));
-  const nextVersion = args.next || args.version;
-  const result = await bumpVersion({
-    nextVersion,
-    rootDir: args.root,
-    write: Boolean(args.write),
-  });
-  if (args.json) {
-    console.log(JSON.stringify(result, null, 2));
-  } else {
-    console.log(
-      `${args.write ? "Bumped" : "Planned"} version ${result.previousVersion} -> ${result.nextVersion}`,
-    );
-    console.log(`Updated files: ${result.updatedFiles.join(", ")}`);
-  }
-}

package/scripts/release/check-sync.mjs

@@ -1,51 +0,0 @@
-#!/usr/bin/env node
-import { fileURLToPath } from "node:url";
-
-import { assertVersionSync, formatPathSegments, parseArgs } from "./lib.mjs";
-
-export { assertVersionSync } from "./lib.mjs";
-
-function toJson(result) {
-  return {
-    ok: result.ok,
-    rootVersion: result.rootVersion,
-    fixedFiles: result.fixedFiles,
-    mismatches: result.mismatches.map((target) => ({
-      file: target.file,
-      path: formatPathSegments(target.path),
-      found: target.found ?? null,
-      expected: target.expected,
-      missing: target.missing,
-    })),
-  };
-}
-
-function printHuman(result) {
-  if (result.ok) {
-    console.log(`Version sync OK (${result.rootVersion})`);
-    return;
-  }
-  console.log(`Version sync mismatch (${result.rootVersion})`);
-  for (const target of result.mismatches) {
-    console.log(
-      `- ${target.file} :: ${formatPathSegments(target.path)} => found=${target.found ?? "missing"}, expected=${target.expected}`,
-    );
-  }
-  if (result.fixedFiles.length) {
-    console.log(`Fixed files: ${result.fixedFiles.join(", ")}`);
-  }
-}
-
-if (process.argv[1] && fileURLToPath(import.meta.url) === process.argv[1]) {
-  const args = parseArgs(process.argv.slice(2));
-  const result = assertVersionSync({
-    rootDir: args.root,
-    fix: Boolean(args.fix),
-  });
-  if (args.json) {
-    console.log(JSON.stringify(toJson(result), null, 2));
-  } else {
-    printHuman(result);
-  }
-  process.exitCode = result.ok ? 0 : 1;
-}

package/scripts/release/lib.mjs

@@ -1,303 +0,0 @@
-import { execFileSync } from "node:child_process";
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { dirname, join, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
-
-export const ROOT = resolve(
-  dirname(fileURLToPath(import.meta.url)),
-  "..",
-  "..",
-);
-export const DEFAULT_MANIFEST_PATH = join(
-  ROOT,
-  "scripts",
-  "release",
-  "version-manifest.json",
-);
-
-export function parseArgs(argv) {
-  const args = {};
-  for (let i = 0; i < argv.length; i++) {
-    const token = argv[i];
-    if (!token.startsWith("--")) continue;
-    const key = token.slice(2);
-    const next = argv[i + 1];
-    if (!next || next.startsWith("--")) {
-      args[key] = true;
-      continue;
-    }
-    args[key] = next;
-    i++;
-  }
-  return args;
-}
-
-export function readJson(filePath) {
-  return JSON.parse(readFileSync(filePath, "utf8"));
-}
-
-export function writeJson(filePath, value) {
-  mkdirSync(dirname(filePath), { recursive: true });
-  writeFileSync(filePath, `${JSON.stringify(value, null, 2)}\n`, "utf8");
-}
-
-export function getValueAtPath(obj, pathSegments) {
-  return pathSegments.reduce((acc, segment) => {
-    if (acc === undefined || acc === null) return undefined;
-    return acc[segment];
-  }, obj);
-}
-
-export function setValueAtPath(obj, pathSegments, value) {
-  if (!pathSegments.length) {
-    throw new Error("pathSegments must not be empty");
-  }
-  let cursor = obj;
-  for (let i = 0; i < pathSegments.length - 1; i++) {
-    const segment = pathSegments[i];
-    const nextSegment = pathSegments[i + 1];
-    if (
-      cursor[segment] === undefined ||
-      cursor[segment] === null ||
-      typeof cursor[segment] !== "object"
-    ) {
-      cursor[segment] = typeof nextSegment === "number" ? [] : {};
-    }
-    cursor = cursor[segment];
-  }
-  cursor[pathSegments.at(-1)] = value;
-}
-
-export function formatPathSegments(pathSegments) {
-  return pathSegments
-    .map((segment) =>
-      typeof segment === "number"
-        ? `[${segment}]`
-        : segment === ""
-          ? '[""]'
-          : `.${segment}`,
-    )
-    .join("")
-    .replace(/^\./, "");
-}
-
-export function isSemver(value) {
-  return /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/.test(String(value || "").trim());
-}
-
-export function loadVersionManifest({
-  rootDir = ROOT,
-  manifestPath = join(rootDir, "scripts", "release", "version-manifest.json"),
-} = {}) {
-  const manifest = readJson(manifestPath);
-  if (!manifest.canonicalFile || !Array.isArray(manifest.targets)) {
-    throw new Error(`Invalid version manifest: ${manifestPath}`);
-  }
-  return manifest;
-}
-
-export function getCanonicalVersion({
-  rootDir = ROOT,
-  manifest = loadVersionManifest({ rootDir }),
-} = {}) {
-  const canonicalPath = join(rootDir, manifest.canonicalFile);
-  const canonicalJson = readJson(canonicalPath);
-  const value = getValueAtPath(
-    canonicalJson,
-    manifest.canonicalPath || ["version"],
-  );
-  if (!isSemver(value)) {
-    throw new Error(
-      `Canonical version is missing or invalid at ${manifest.canonicalFile}`,
-    );
-  }
-  return value;
-}
-
-export function collectVersionTargets({
-  rootDir = ROOT,
-  manifest = loadVersionManifest({ rootDir }),
-  expectedVersion = getCanonicalVersion({ rootDir, manifest }),
-} = {}) {
-  return manifest.targets.flatMap((target) => {
-    const absolutePath = join(rootDir, target.file);
-    if (!existsSync(absolutePath)) {
-      return target.paths.map((pathSegments) => ({
-        file: target.file,
-        absolutePath,
-        path: pathSegments,
-        found: undefined,
-        expected: expectedVersion,
-        inSync: false,
-        missing: true,
-      }));
-    }
-    const json = readJson(absolutePath);
-    return target.paths.map((pathSegments) => {
-      const found = getValueAtPath(json, pathSegments);
-      return {
-        file: target.file,
-        absolutePath,
-        path: pathSegments,
-        found,
-        expected: expectedVersion,
-        inSync: found === expectedVersion,
-        missing: false,
-      };
-    });
-  });
-}
-
-export function syncVersionTargets({
-  rootDir = ROOT,
-  manifest = loadVersionManifest({ rootDir }),
-  expectedVersion = getCanonicalVersion({ rootDir, manifest }),
-} = {}) {
-  const touched = new Set();
-  for (const target of manifest.targets) {
-    const absolutePath = join(rootDir, target.file);
-    if (!existsSync(absolutePath)) {
-      throw new Error(`Cannot sync missing target: ${target.file}`);
-    }
-    const json = readJson(absolutePath);
-    let changed = false;
-    for (const pathSegments of target.paths) {
-      if (getValueAtPath(json, pathSegments) !== expectedVersion) {
-        setValueAtPath(json, pathSegments, expectedVersion);
-        changed = true;
-      }
-    }
-    if (changed) {
-      writeJson(absolutePath, json);
-      touched.add(target.file);
-    }
-  }
-  return [...touched];
-}
-
-export function assertVersionSync({
-  rootDir = ROOT,
-  manifestPath = join(rootDir, "scripts", "release", "version-manifest.json"),
-  expectedVersion,
-  fix = false,
-} = {}) {
-  const manifest = loadVersionManifest({ rootDir, manifestPath });
-  const rootVersion =
-    expectedVersion || getCanonicalVersion({ rootDir, manifest });
-  let targets = collectVersionTargets({
-    rootDir,
-    manifest,
-    expectedVersion: rootVersion,
-  });
-  const mismatches = targets.filter((target) => !target.inSync);
-  let fixedFiles = [];
-
-  if (fix && mismatches.length) {
-    fixedFiles = syncVersionTargets({
-      rootDir,
-      manifest,
-      expectedVersion: rootVersion,
-    });
-    targets = collectVersionTargets({
-      rootDir,
-      manifest,
-      expectedVersion: rootVersion,
-    });
-  }
-
-  return {
-    ok: targets.every((target) => target.inSync),
-    rootVersion,
-    targets,
-    mismatches: targets.filter((target) => !target.inSync),
-    fixedFiles,
-  };
-}
-
-export function ensureGitClean({
-  rootDir = ROOT,
-  execFileSyncFn = execFileSync,
-} = {}) {
-  const output = execFileSyncFn("git", ["status", "--porcelain"], {
-    cwd: rootDir,
-    encoding: "utf8",
-  }).trim();
-  return { clean: output.length === 0, output };
-}
-
-export function getPreviousTag({
-  rootDir = ROOT,
-  execFileSyncFn = execFileSync,
-} = {}) {
-  try {
-    return execFileSyncFn("git", ["describe", "--tags", "--abbrev=0"], {
-      cwd: rootDir,
-      encoding: "utf8",
-    }).trim();
-  } catch {
-    return null;
-  }
-}
-
-export function getCommitSummaries({
-  rootDir = ROOT,
-  previousTag,
-  execFileSyncFn = execFileSync,
-} = {}) {
-  const range = previousTag ? `${previousTag}..HEAD` : "HEAD~10..HEAD";
-  try {
-    return execFileSyncFn("git", ["log", "--oneline", range], {
-      cwd: rootDir,
-      encoding: "utf8",
-    })
-      .trim()
-      .split(/\r?\n/)
-      .filter(Boolean);
-  } catch {
-    return [];
-  }
-}
-
-export function buildReleaseNotes({
-  version,
-  rootDir = ROOT,
-  execFileSyncFn = execFileSync,
-} = {}) {
-  const previousTag = getPreviousTag({ rootDir, execFileSyncFn });
-  const commits = getCommitSummaries({
-    rootDir,
-    previousTag,
-    execFileSyncFn,
-  });
-  const heading = previousTag
-    ? `Changes since ${previousTag}`
-    : "Recent changes (no prior tag found)";
-  const lines = commits.length
-    ? commits.map((commit) => `- ${commit}`)
-    : ["- No commit summary available"];
-
-  return [
-    `# Release v${version}`,
-    "",
-    `## ${heading}`,
-    ...lines,
-    "",
-    "## Install",
-    `- npm: \`npm install -g triflux@${version}\``,
-    "- Claude Code:",
-    "  - `/plugin marketplace add tellang/triflux`",
-    "  - `/plugin install triflux@tellang`",
-    "",
-  ].join("\n");
-}
-
-export function runCommand(
-  command,
-  args,
-  { cwd = ROOT, execFileSyncFn = execFileSync } = {},
-) {
-  execFileSyncFn(command, args, {
-    cwd,
-    stdio: "inherit",
-  });
-}

package/scripts/release/prepare.mjs

@@ -1,85 +0,0 @@
-#!/usr/bin/env node
-import { writeFileSync } from "node:fs";
-import { join } from "node:path";
-import { fileURLToPath } from "node:url";
-import {
-  assertVersionSync,
-  buildReleaseNotes,
-  ensureGitClean,
-  parseArgs,
-  ROOT,
-  runCommand,
-} from "./lib.mjs";
-
-export async function prepareRelease({
-  version,
-  rootDir = ROOT,
-  allowDirty = false,
-  dryRun = true,
-  execFileSyncFn,
-} = {}) {
-  const sync = assertVersionSync({ rootDir });
-  if (!sync.ok) {
-    throw new Error(
-      "Version sync failed. Run scripts/release/check-sync.mjs first.",
-    );
-  }
-
-  const gitState = ensureGitClean({ rootDir, execFileSyncFn });
-  if (!gitState.clean && !allowDirty) {
-    throw new Error(
-      "Working tree is dirty. Re-run with --allow-dirty only for scaffolding.",
-    );
-  }
-
-  const releaseVersion = version || sync.rootVersion;
-  const commands = [
-    ["npm", ["test"]],
-    ["npm", ["run", "lint"]],
-    ["npm", ["pack", "--dry-run"]],
-  ];
-
-  if (!dryRun) {
-    for (const [command, args] of commands) {
-      runCommand(command, args, { cwd: rootDir, execFileSyncFn });
-    }
-  }
-
-  const notes = buildReleaseNotes({
-    version: releaseVersion,
-    rootDir,
-    execFileSyncFn,
-  });
-  const notesPath = join(
-    rootDir,
-    ".omx",
-    "plans",
-    `release-notes-v${releaseVersion}.md`,
-  );
-  writeFileSync(notesPath, notes, "utf8");
-
-  return {
-    ok: true,
-    version: releaseVersion,
-    clean: gitState.clean,
-    allowDirty,
-    dryRun,
-    commands: commands.map(([command, args]) => [command, ...args].join(" ")),
-    releaseNotesPath: notesPath,
-  };
-}
-
-if (process.argv[1] && fileURLToPath(import.meta.url) === process.argv[1]) {
-  const args = parseArgs(process.argv.slice(2));
-  const result = await prepareRelease({
-    version: args.version,
-    rootDir: args.root,
-    allowDirty: Boolean(args["allow-dirty"]),
-    dryRun: !args.execute,
-  });
-  if (args.json) {
-    console.log(JSON.stringify(result, null, 2));
-  } else {
-    console.log(JSON.stringify(result, null, 2));
-  }
-}