triflux 10.9.21 → 10.9.23

package/scripts/release/lib.mjs

@@ -0,0 +1,303 @@
+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

@@ -0,0 +1,85 @@
+#!/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));
+  }
+}

package/scripts/release/publish.mjs

@@ -0,0 +1,87 @@
+#!/usr/bin/env node
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { assertVersionSync, parseArgs, ROOT, runCommand } from "./lib.mjs";
+
+export async function publishRelease({
+  version,
+  rootDir = ROOT,
+  channel = "stable",
+  dryRun = true,
+  createGithubRelease = true,
+  execFileSyncFn,
+} = {}) {
+  const sync = assertVersionSync({ rootDir });
+  if (!sync.ok) {
+    throw new Error("Version sync failed. Refusing to publish.");
+  }
+
+  const releaseVersion = version || sync.rootVersion;
+  const npmTag = channel === "canary" ? "canary" : "latest";
+  const notesPath = join(
+    rootDir,
+    ".omx",
+    "plans",
+    `release-notes-v${releaseVersion}.md`,
+  );
+  const steps = [
+    {
+      label: "npm publish",
+      command: "npm",
+      args: ["publish", "--tag", npmTag],
+    },
+    { label: "git tag", command: "git", args: ["tag", `v${releaseVersion}`] },
+    {
+      label: "git push",
+      command: "git",
+      args: ["push", "origin", "HEAD", "--tags"],
+    },
+  ];
+
+  if (createGithubRelease) {
+    steps.push({
+      label: "gh release create",
+      command: "gh",
+      args: [
+        "release",
+        "create",
+        `v${releaseVersion}`,
+        "--title",
+        `v${releaseVersion}`,
+        "--notes-file",
+        notesPath,
+      ],
+    });
+  }
+
+  if (!dryRun) {
+    for (const step of steps) {
+      runCommand(step.command, step.args, { cwd: rootDir, execFileSyncFn });
+    }
+  }
+
+  return {
+    ok: true,
+    version: releaseVersion,
+    channel,
+    npmTag,
+    dryRun,
+    notesPath,
+    steps: steps.map((step) => ({
+      label: step.label,
+      command: [step.command, ...step.args].join(" "),
+    })),
+  };
+}
+
+if (process.argv[1] && fileURLToPath(import.meta.url) === process.argv[1]) {
+  const args = parseArgs(process.argv.slice(2));
+  const result = await publishRelease({
+    version: args.version,
+    rootDir: args.root,
+    channel: args.channel || "stable",
+    dryRun: !args.execute,
+    createGithubRelease: !args["skip-gh-release"],
+  });
+  console.log(JSON.stringify(result, null, 2));
+}

package/scripts/release/verify.mjs

@@ -0,0 +1,81 @@
+#!/usr/bin/env node
+import { execFileSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { assertVersionSync, parseArgs, ROOT } from "./lib.mjs";
+
+export async function verifyRelease({
+  version,
+  rootDir = ROOT,
+  dryRun = true,
+  execFileSyncFn = execFileSync,
+} = {}) {
+  const sync = assertVersionSync({ rootDir });
+  if (!sync.ok) {
+    throw new Error("Version sync failed. Fix metadata before verify.");
+  }
+  const releaseVersion = version || sync.rootVersion;
+  const checks = [
+    {
+      name: "version-sync",
+      ok: true,
+      detail: `repo metadata matches ${releaseVersion}`,
+    },
+  ];
+
+  if (!dryRun) {
+    const npmVersion = execFileSyncFn("npm", ["view", "triflux", "version"], {
+      cwd: rootDir,
+      encoding: "utf8",
+    }).trim();
+    checks.push({
+      name: "npm-view",
+      ok: npmVersion === releaseVersion,
+      detail: npmVersion,
+    });
+
+    const ghRelease = execFileSyncFn(
+      "gh",
+      ["release", "view", `v${releaseVersion}`, "--json", "tagName"],
+      {
+        cwd: rootDir,
+        encoding: "utf8",
+      },
+    ).trim();
+    checks.push({
+      name: "github-release",
+      ok: ghRelease.length > 0,
+      detail: ghRelease,
+    });
+  } else {
+    checks.push(
+      {
+        name: "npm-view",
+        ok: null,
+        detail: `would run: npm view triflux version`,
+      },
+      {
+        name: "github-release",
+        ok: null,
+        detail: `would run: gh release view v${releaseVersion} --json tagName`,
+      },
+    );
+  }
+
+  return {
+    ok: checks.every((check) => check.ok !== false),
+    version: releaseVersion,
+    dryRun,
+    checks,
+  };
+}
+
+if (process.argv[1] && fileURLToPath(import.meta.url) === process.argv[1]) {
+  const args = parseArgs(process.argv.slice(2));
+  const result = await verifyRelease({
+    version: args.version,
+    rootDir: args.root,
+    dryRun: !args.execute,
+  });
+  console.log(JSON.stringify(result, null, 2));
+  process.exitCode = result.ok ? 0 : 1;
+}

package/scripts/release/version-manifest.json

@@ -0,0 +1,26 @@
+{
+  "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"]]
+    }
+  ]
+}

package/scripts/remote-spawn.mjs

@@ -591,7 +591,7 @@ function rewritePromptPaths(prompt, stagedFiles) {
   return rewritten;
 }
 
-function spawnLocalFallback(args, claudePath, prompt) {
+async function spawnLocalFallback(args, claudePath, prompt) {
   const dir = args.dir ? resolve(args.dir) : process.cwd();
 
   if (!IS_WINDOWS_LOCAL) {
@@ -626,7 +626,7 @@ function spawnLocalFallback(args, claudePath, prompt) {
   }
 }
 
-function spawnRemoteFallback(args, promptContext) {
+async function spawnRemoteFallback(args, promptContext) {
   const { host } = args;
   if (!host) {
     console.error("--host required for remote spawn");
@@ -999,7 +999,7 @@ function listSpawnSessions() {
   }
 }
 
-function openAttachTab(sessionName, title = null) {
+async function openAttachTab(sessionName, title = null) {
   if (IS_WINDOWS_LOCAL) {
     const wtArgs = title
     try {

package/scripts/setup.mjs

@@ -64,6 +64,23 @@ const REQUIRED_CODEX_PROFILES = [
 
 const HUD_SYNC_EXCLUDES = new Set(["omc-hud.mjs", "omc-hud.mjs.bak"]);
 
+/**
+ * scripts/lib/*.mjs 자동 스캔.
+ * 수동 리스트 대신 glob으로 탐색하여 lib 파일 추가 시 sync 누락 방지.
+ */
+function scanLibFiles(pluginRoot, claudeDir) {
+  const libDir = join(pluginRoot, "scripts", "lib");
+  if (!existsSync(libDir)) return [];
+  return readdirSync(libDir)
+    .sort()
+    .filter((f) => f.endsWith(".mjs"))
+    .map((f) => ({
+      src: join(libDir, f),
+      dst: join(claudeDir, "scripts", "lib", f),
+      label: `lib/${f}`,
+    }));
+}
+
 /**
  * hub/workers/*.mjs + hub/ 루트의 worker 의존성 파일을 자동 스캔.
  * 수동 리스트 대신 glob으로 탐색하여 파일 추가 시 sync 누락 방지.
@@ -173,21 +190,7 @@ const SYNC_MAP = [
     dst: join(CLAUDE_DIR, "scripts", "tfx-batch-stats.mjs"),
     label: "tfx-batch-stats.mjs",
   },
-  {
-    src: join(PLUGIN_ROOT, "scripts", "lib", "mcp-filter.mjs"),
-    dst: join(CLAUDE_DIR, "scripts", "lib", "mcp-filter.mjs"),
-    label: "lib/mcp-filter.mjs",
-  },
-  {
-    src: join(PLUGIN_ROOT, "scripts", "lib", "mcp-server-catalog.mjs"),
-    dst: join(CLAUDE_DIR, "scripts", "lib", "mcp-server-catalog.mjs"),
-    label: "lib/mcp-server-catalog.mjs",
-  },
-  {
-    src: join(PLUGIN_ROOT, "scripts", "lib", "keyword-rules.mjs"),
-    dst: join(CLAUDE_DIR, "scripts", "lib", "keyword-rules.mjs"),
-    label: "lib/keyword-rules.mjs",
-  },
+  ...scanLibFiles(PLUGIN_ROOT, CLAUDE_DIR),
   {
     src: join(PLUGIN_ROOT, "hub", "team", "agent-map.json"),
     dst: join(CLAUDE_DIR, "hub", "team", "agent-map.json"),