@bastani/atomic 0.6.8 → 0.7.0-2

package/src/lib/terminal-env.test.ts

@@ -1,343 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import {
-  TERMINAL_ENV_KEYS,
-  buildLauncherEnv,
-  buildSpawnEnv,
-  buildTmuxEnv,
-  mergeTerminalEnv,
-  normalizedTerminalEnv,
-  pickTerminalEnv,
-} from "./terminal-env.ts";
-
-describe("normalizedTerminalEnv", () => {
-  test("missing locale defaults to en_US.UTF-8", () => {
-    const env = normalizedTerminalEnv({});
-    expect(env["LANG"]).toBe("en_US.UTF-8");
-    expect(env["LC_ALL"]).toBe("en_US.UTF-8");
-    expect(env["LC_CTYPE"]).toBe("en_US.UTF-8");
-  });
-
-  test("existing UTF-8 locale is preserved", () => {
-    const base = { LANG: "en_GB.UTF-8", LC_ALL: "fr_FR.utf8", LC_CTYPE: "C.UTF-8" };
-    const env = normalizedTerminalEnv(base);
-    expect(env["LANG"]).toBe("en_GB.UTF-8");
-    expect(env["LC_ALL"]).toBe("fr_FR.utf8");
-    expect(env["LC_CTYPE"]).toBe("C.UTF-8");
-  });
-
-  test("non-UTF-8 locale is replaced with en_US.UTF-8", () => {
-    const base = { LANG: "en_US.ISO-8859-1", LC_ALL: "C", LC_CTYPE: "POSIX" };
-    const env = normalizedTerminalEnv(base);
-    expect(env["LANG"]).toBe("en_US.UTF-8");
-    expect(env["LC_ALL"]).toBe("en_US.UTF-8");
-    expect(env["LC_CTYPE"]).toBe("en_US.UTF-8");
-  });
-
-  test("TERM=dumb becomes xterm-256color", () => {
-    const env = normalizedTerminalEnv({ TERM: "dumb" });
-    expect(env["TERM"]).toBe("xterm-256color");
-  });
-
-  test("missing TERM defaults to xterm-256color", () => {
-    const env = normalizedTerminalEnv({});
-    expect(env["TERM"]).toBe("xterm-256color");
-  });
-
-  test("explicit COLORTERM is preserved", () => {
-    const env = normalizedTerminalEnv({ COLORTERM: "24bit" });
-    expect(env["COLORTERM"]).toBe("24bit");
-  });
-
-  test("missing COLORTERM defaults to truecolor", () => {
-    const env = normalizedTerminalEnv({});
-    expect(env["COLORTERM"]).toBe("truecolor");
-  });
-
-  test("other env vars carried through unchanged", () => {
-    const env = normalizedTerminalEnv({ HOME: "/root", PATH: "/usr/bin" });
-    expect(env["HOME"]).toBe("/root");
-    expect(env["PATH"]).toBe("/usr/bin");
-  });
-
-  test("undefined values dropped", () => {
-    const base: NodeJS.ProcessEnv = { SOME_VAR: undefined };
-    const env = normalizedTerminalEnv(base);
-    expect("SOME_VAR" in env).toBe(false);
-  });
-});
-
-describe("mergeTerminalEnv", () => {
-  test("explicit env vars win over defaults", () => {
-    const env = mergeTerminalEnv(
-      { LANG: "ja_JP.UTF-8", TERM: "screen", COLORTERM: "256" },
-      {},
-    );
-    expect(env["LANG"]).toBe("ja_JP.UTF-8");
-    expect(env["TERM"]).toBe("screen");
-    expect(env["COLORTERM"]).toBe("256");
-  });
-
-  test("missing keys still get sane defaults", () => {
-    const env = mergeTerminalEnv({}, {});
-    expect(env["LANG"]).toBe("en_US.UTF-8");
-    expect(env["TERM"]).toBe("xterm-256color");
-    expect(env["COLORTERM"]).toBe("truecolor");
-  });
-
-  test("explicit vars merged on top of baseEnv normalization", () => {
-    const base = { LANG: "C", TERM: "dumb" };
-    const env = mergeTerminalEnv({ LANG: "de_DE.UTF-8" }, base);
-    // explicit wins
-    expect(env["LANG"]).toBe("de_DE.UTF-8");
-    // TERM=dumb normalized then no override → xterm-256color
-    expect(env["TERM"]).toBe("xterm-256color");
-  });
-});
-
-describe("TERMINAL_ENV_KEYS", () => {
-  test("contains exactly the five expected keys", () => {
-    expect(TERMINAL_ENV_KEYS).toEqual(["LANG", "LC_ALL", "LC_CTYPE", "TERM", "COLORTERM"]);
-  });
-});
-
-describe("pickTerminalEnv", () => {
-  test("picks only TERMINAL_ENV_KEYS", () => {
-    const env = { LANG: "en_US.UTF-8", TERM: "xterm", HOME: "/home/user", PATH: "/usr/bin" };
-    const picked = pickTerminalEnv(env);
-    expect(Object.keys(picked)).toEqual(expect.arrayContaining(["LANG", "TERM"]));
-    expect("HOME" in picked).toBe(false);
-    expect("PATH" in picked).toBe(false);
-  });
-
-  test("omits absent keys rather than setting undefined", () => {
-    const env = { LANG: "en_US.UTF-8" };
-    const picked = pickTerminalEnv(env);
-    expect("LC_ALL" in picked).toBe(false);
-    expect("TERM" in picked).toBe(false);
-    expect("COLORTERM" in picked).toBe(false);
-  });
-
-  test("returns all five when all present", () => {
-    const env = { LANG: "a", LC_ALL: "b", LC_CTYPE: "c", TERM: "d", COLORTERM: "e" };
-    const picked = pickTerminalEnv(env);
-    expect(Object.keys(picked).sort()).toEqual(["COLORTERM", "LANG", "LC_ALL", "LC_CTYPE", "TERM"]);
-  });
-});
-
-describe("buildSpawnEnv", () => {
-  test("includes full normalized baseEnv", () => {
-    const base = { HOME: "/root", PATH: "/usr/bin", TERM: "xterm-256color" };
-    const env = buildSpawnEnv({ MY_VAR: "1" }, base);
-    expect(env["HOME"]).toBe("/root");
-    expect(env["PATH"]).toBe("/usr/bin");
-    expect(env["MY_VAR"]).toBe("1");
-  });
-
-  test("explicit env wins over baseEnv", () => {
-    const base = { LANG: "C", TERM: "dumb" };
-    const env = buildSpawnEnv({ LANG: "ja_JP.UTF-8" }, base);
-    expect(env["LANG"]).toBe("ja_JP.UTF-8");
-  });
-
-  test("applies sane terminal defaults from baseEnv", () => {
-    const env = buildSpawnEnv({}, {});
-    expect(env["TERM"]).toBe("xterm-256color");
-    expect(env["COLORTERM"]).toBe("truecolor");
-  });
-});
-
-describe("buildLauncherEnv", () => {
-  test("does NOT include non-terminal keys from baseEnv", () => {
-    const base = { HOME: "/root", PATH: "/usr/bin", LANG: "en_US.UTF-8", TERM: "xterm-256color", COLORTERM: "truecolor" };
-    const env = buildLauncherEnv({}, base);
-    expect("HOME" in env).toBe(false);
-    expect("PATH" in env).toBe(false);
-  });
-
-  test("includes TERMINAL_ENV_KEYS from normalized baseEnv", () => {
-    const base = { LANG: "C", TERM: "dumb" };
-    const env = buildLauncherEnv({}, base);
-    // normalization applies: C → en_US.UTF-8, dumb → xterm-256color
-    expect(env["LANG"]).toBe("en_US.UTF-8");
-    expect(env["TERM"]).toBe("xterm-256color");
-    expect(env["COLORTERM"]).toBe("truecolor");
-  });
-
-  test("explicit env wins and is included", () => {
-    const base = { LANG: "en_US.UTF-8", TERM: "xterm-256color" };
-    const env = buildLauncherEnv({ LANG: "ja_JP.UTF-8", MY_VAR: "hello" }, base);
-    expect(env["LANG"]).toBe("ja_JP.UTF-8");
-    expect(env["MY_VAR"]).toBe("hello");
-  });
-
-  test("no process.env leakage with empty baseEnv", () => {
-    const env = buildLauncherEnv({}, {});
-    // Only terminal keys + sane defaults, no PATH/HOME from process.env
-    const envKeys = Object.keys(env);
-    const nonTerminalKeys = envKeys.filter(
-      (k) => !(TERMINAL_ENV_KEYS as readonly string[]).includes(k),
-    );
-    expect(nonTerminalKeys).toEqual([]);
-  });
-
-  test("excludes secret env vars: GH_TOKEN, COPILOT_GITHUB_TOKEN, ANTHROPIC_API_KEY", () => {
-    const base = {
-      LANG: "en_US.UTF-8",
-      TERM: "xterm-256color",
-      COLORTERM: "truecolor",
-      GH_TOKEN: "ghp_secret",
-      COPILOT_GITHUB_TOKEN: "ghu_secret",
-      ANTHROPIC_API_KEY: "sk-ant-secret",
-      HOME: "/home/user",
-      PATH: "/usr/bin:/bin",
-    };
-    const env = buildLauncherEnv({}, base);
-    expect("GH_TOKEN" in env).toBe(false);
-    expect("COPILOT_GITHUB_TOKEN" in env).toBe(false);
-    expect("ANTHROPIC_API_KEY" in env).toBe(false);
-    expect("HOME" in env).toBe(false);
-    expect("PATH" in env).toBe(false);
-    // terminal keys still present
-    expect(env["LANG"]).toBe("en_US.UTF-8");
-    expect(env["TERM"]).toBe("xterm-256color");
-    expect(env["COLORTERM"]).toBe("truecolor");
-  });
-
-  test("buildSpawnEnv preserves full inherited env including non-terminal keys", () => {
-    const base = {
-      HOME: "/home/user",
-      PATH: "/usr/bin:/bin",
-      GH_TOKEN: "ghp_secret",
-      LANG: "C",
-      TERM: "dumb",
-    };
-    const env = buildSpawnEnv({ MY_EXPLICIT: "yes" }, base);
-    // full env inherited
-    expect(env["HOME"]).toBe("/home/user");
-    expect(env["PATH"]).toBe("/usr/bin:/bin");
-    expect(env["GH_TOKEN"]).toBe("ghp_secret");
-    // normalization applied
-    expect(env["LANG"]).toBe("en_US.UTF-8");
-    expect(env["TERM"]).toBe("xterm-256color");
-    // explicit override present
-    expect(env["MY_EXPLICIT"]).toBe("yes");
-  });
-});
-
-describe("buildTmuxEnv", () => {
-  const SENSITIVE_BASE = {
-    LANG: "en_US.UTF-8",
-    LC_ALL: "en_US.UTF-8",
-    LC_CTYPE: "en_US.UTF-8",
-    TERM: "xterm-256color",
-    COLORTERM: "truecolor",
-    GH_TOKEN: "ghp_secret",
-    COPILOT_GITHUB_TOKEN: "ghu_secret",
-    ANTHROPIC_API_KEY: "sk-ant-secret",
-    OPENAI_API_KEY: "sk-openai-secret",
-    HOME: "/home/user",
-    PATH: "/usr/bin:/bin",
-    ARBITRARY_VAR: "should-not-appear",
-  };
-
-  test("excludes GH_TOKEN", () => {
-    const env = buildTmuxEnv({}, SENSITIVE_BASE);
-    expect("GH_TOKEN" in env).toBe(false);
-  });
-
-  test("excludes COPILOT_GITHUB_TOKEN", () => {
-    const env = buildTmuxEnv({}, SENSITIVE_BASE);
-    expect("COPILOT_GITHUB_TOKEN" in env).toBe(false);
-  });
-
-  test("excludes ANTHROPIC_API_KEY", () => {
-    const env = buildTmuxEnv({}, SENSITIVE_BASE);
-    expect("ANTHROPIC_API_KEY" in env).toBe(false);
-  });
-
-  test("excludes OPENAI_API_KEY", () => {
-    const env = buildTmuxEnv({}, SENSITIVE_BASE);
-    expect("OPENAI_API_KEY" in env).toBe(false);
-  });
-
-  test("excludes HOME", () => {
-    const env = buildTmuxEnv({}, SENSITIVE_BASE);
-    expect("HOME" in env).toBe(false);
-  });
-
-  test("excludes PATH", () => {
-    const env = buildTmuxEnv({}, SENSITIVE_BASE);
-    expect("PATH" in env).toBe(false);
-  });
-
-  test("excludes arbitrary inherited env vars", () => {
-    const env = buildTmuxEnv({}, SENSITIVE_BASE);
-    expect("ARBITRARY_VAR" in env).toBe(false);
-  });
-
-  test("includes normalized LANG", () => {
-    const env = buildTmuxEnv({}, { LANG: "C" });
-    expect(env["LANG"]).toBe("en_US.UTF-8");
-  });
-
-  test("includes normalized LC_ALL", () => {
-    const env = buildTmuxEnv({}, { LC_ALL: "POSIX" });
-    expect(env["LC_ALL"]).toBe("en_US.UTF-8");
-  });
-
-  test("includes normalized LC_CTYPE", () => {
-    const env = buildTmuxEnv({}, { LC_CTYPE: "en_US.ISO-8859-1" });
-    expect(env["LC_CTYPE"]).toBe("en_US.UTF-8");
-  });
-
-  test("includes normalized TERM (dumb → xterm-256color)", () => {
-    const env = buildTmuxEnv({}, { TERM: "dumb" });
-    expect(env["TERM"]).toBe("xterm-256color");
-  });
-
-  test("includes normalized COLORTERM default", () => {
-    const env = buildTmuxEnv({}, {});
-    expect(env["COLORTERM"]).toBe("truecolor");
-  });
-
-  test("preserves explicit UTF-8 LANG", () => {
-    const env = buildTmuxEnv({}, { LANG: "ja_JP.UTF-8" });
-    expect(env["LANG"]).toBe("ja_JP.UTF-8");
-  });
-
-  test("preserves explicit TERM when not dumb", () => {
-    const env = buildTmuxEnv({}, { TERM: "screen-256color" });
-    expect(env["TERM"]).toBe("screen-256color");
-  });
-
-  test("includes explicit ATOMIC_AGENT", () => {
-    const env = buildTmuxEnv({ ATOMIC_AGENT: "copilot" }, {});
-    expect(env["ATOMIC_AGENT"]).toBe("copilot");
-  });
-
-  test("includes explicit COPILOT_CUSTOM_INSTRUCTIONS_DIRS", () => {
-    const env = buildTmuxEnv({ COPILOT_CUSTOM_INSTRUCTIONS_DIRS: "/a:/b" }, {});
-    expect(env["COPILOT_CUSTOM_INSTRUCTIONS_DIRS"]).toBe("/a:/b");
-  });
-
-  test("explicit env wins over baseEnv for terminal keys", () => {
-    const env = buildTmuxEnv({ LANG: "de_DE.UTF-8", TERM: "screen" }, { LANG: "C", TERM: "dumb" });
-    expect(env["LANG"]).toBe("de_DE.UTF-8");
-    expect(env["TERM"]).toBe("screen");
-  });
-
-  test("only TERMINAL_ENV_KEYS + explicit vars — no leakage", () => {
-    const env = buildTmuxEnv({ ATOMIC_AGENT: "claude" }, SENSITIVE_BASE);
-    const envKeys = Object.keys(env);
-    const allowedKeys = new Set([...(TERMINAL_ENV_KEYS as readonly string[]), "ATOMIC_AGENT"]);
-    const leaked = envKeys.filter((k) => !allowedKeys.has(k));
-    expect(leaked).toEqual([]);
-  });
-
-  test("all TERMINAL_ENV_KEYS present with empty baseEnv", () => {
-    const env = buildTmuxEnv({}, {});
-    for (const key of TERMINAL_ENV_KEYS) {
-      expect(key in env).toBe(true);
-    }
-  });
-});

package/src/lib/terminal-env.ts

@@ -1,100 +0,0 @@
-const UTF8_RE = /utf-?8/i;
-
-function isUtf8(value: string): boolean {
-  return UTF8_RE.test(value);
-}
-
-const DEFAULT_LOCALE = "en_US.UTF-8";
-const DEFAULT_TERM = "xterm-256color";
-const DEFAULT_COLORTERM = "truecolor";
-
-const LOCALE_KEYS = ["LANG", "LC_ALL", "LC_CTYPE"] as const;
-
-export const TERMINAL_ENV_KEYS = [
-  "LANG",
-  "LC_ALL",
-  "LC_CTYPE",
-  "TERM",
-  "COLORTERM",
-] as const;
-
-export type TerminalEnvKey = (typeof TERMINAL_ENV_KEYS)[number];
-
-export function normalizedTerminalEnv(
-  baseEnv: NodeJS.ProcessEnv = process.env,
-): Record<string, string> {
-  const result: Record<string, string> = {};
-
-  for (const [key, value] of Object.entries(baseEnv)) {
-    if (typeof value === "string") {
-      result[key] = value;
-    }
-  }
-
-  for (const key of LOCALE_KEYS) {
-    const existing = result[key];
-    if (!existing || !isUtf8(existing)) {
-      result[key] = DEFAULT_LOCALE;
-    }
-  }
-
-  const term = result["TERM"];
-  if (!term || term === "dumb") {
-    result["TERM"] = DEFAULT_TERM;
-  }
-
-  if (!result["COLORTERM"]) {
-    result["COLORTERM"] = DEFAULT_COLORTERM;
-  }
-
-  return result;
-}
-
-export function mergeTerminalEnv(
-  envVars: Record<string, string> = {},
-  baseEnv: NodeJS.ProcessEnv = process.env,
-): Record<string, string> {
-  const defaults = normalizedTerminalEnv(baseEnv);
-  return { ...defaults, ...envVars };
-}
-
-export function pickTerminalEnv(
-  env: Record<string, string>,
-): Partial<Record<TerminalEnvKey, string>> {
-  const result: Partial<Record<TerminalEnvKey, string>> = {};
-  for (const key of TERMINAL_ENV_KEYS) {
-    if (key in env) {
-      result[key] = env[key];
-    }
-  }
-  return result;
-}
-
-export function buildSpawnEnv(
-  explicitEnv: Record<string, string>,
-  baseEnv: NodeJS.ProcessEnv = process.env,
-): Record<string, string> {
-  return { ...normalizedTerminalEnv(baseEnv), ...explicitEnv };
-}
-
-function buildMinimalEnv(
-  explicitEnv: Record<string, string>,
-  baseEnv: NodeJS.ProcessEnv = process.env,
-): Record<string, string> {
-  const terminalEnv = pickTerminalEnv(normalizedTerminalEnv(baseEnv));
-  return { ...terminalEnv, ...explicitEnv };
-}
-
-export function buildLauncherEnv(
-  explicitEnv: Record<string, string>,
-  baseEnv: NodeJS.ProcessEnv = process.env,
-): Record<string, string> {
-  return buildMinimalEnv(explicitEnv, baseEnv);
-}
-
-export function buildTmuxEnv(
-  explicitEnv: Record<string, string>,
-  baseEnv: NodeJS.ProcessEnv = process.env,
-): Record<string, string> {
-  return buildLauncherEnv(explicitEnv, baseEnv);
-}

package/src/scripts/bump-version.ts

@@ -1,94 +0,0 @@
-#!/usr/bin/env bun
-/**
- * Bumps the package version across all files that need it.
- *
- * Usage:
- *   bun run src/scripts/bump-version.ts <version>
- *   bun run src/scripts/bump-version.ts --from-branch
- *
- * Examples:
- *   bun run src/scripts/bump-version.ts 0.4.46
- *   bun run src/scripts/bump-version.ts 0.4.46-0
- *   bun run src/scripts/bump-version.ts --from-branch   # extracts version from current branch name
- *
- * The --from-branch flag reads the current git branch and extracts the version
- * from branch names matching:
- *   release/v0.4.46     → 0.4.46
- *   prerelease/v0.4.46-0 → 0.4.46-0
- */
-
-import { $ } from "bun";
-import { resolve } from "node:path";
-import { VERSION_FILES } from "./constants-base.ts";
-
-const ROOT = resolve(import.meta.dir, "../..");
-
-function parseVersionFromBranch(branch: string): string {
-  const match = branch.match(/^(?:release|prerelease)\/v(.+)$/);
-  if (!match) {
-    console.error(
-      `Error: branch "${branch}" does not match release/v<version> or prerelease/v<version>`
-    );
-    process.exit(1);
-  }
-  return match[1] as string;
-}
-
-function validateVersion(version: string): void {
-  // Accept semver with optional prerelease suffix: 0.4.46, 0.4.46-0, 1.0.0-1
-  if (!/^\d+\.\d+\.\d+(-[\w.]+)?$/.test(version)) {
-    console.error(
-      `Error: "${version}" is not a valid semver version`
-    );
-    process.exit(1);
-  }
-}
-
-async function getVersion(): Promise<string> {
-  const arg = process.argv[2];
-
-  if (!arg) {
-    console.error(
-      "Usage: bun run src/scripts/bump-version.ts <version|--from-branch>"
-    );
-    process.exit(1);
-  }
-
-  if (arg === "--from-branch") {
-    const branch = (await $`git rev-parse --abbrev-ref HEAD`.text()).trim();
-    return parseVersionFromBranch(branch);
-  }
-
-  // Strip leading 'v' if provided
-  return arg.replace(/^v/, "");
-}
-
-async function bumpFile(filePath: string, version: string): Promise<void> {
-  const fullPath = resolve(ROOT, filePath);
-  const content = await Bun.file(fullPath).json();
-  const oldVersion = content.version;
-
-  if (oldVersion === version) {
-    console.log(`  ${filePath}: already at ${version}`);
-    return;
-  }
-
-  content.version = version;
-  await Bun.write(fullPath, JSON.stringify(content, null, 2) + "\n");
-  console.log(`  ${filePath}: ${oldVersion} → ${version}`);
-}
-
-async function main(): Promise<void> {
-  const version = await getVersion();
-  validateVersion(version);
-
-  console.log(`Bumping version to ${version}\n`);
-
-  for (const file of VERSION_FILES) {
-    await bumpFile(file, version);
-  }
-
-  console.log("\nDone.");
-}
-
-main();

package/src/scripts/bundle-configs.ts

@@ -1,116 +0,0 @@
-#!/usr/bin/env bun
-/**
- * Bundle global configs for a release.
- *
- * Installs curated skills globally, copies bundled agent definitions to
- * each agent's global config root, and packages everything into a zip
- * archive suitable for attaching to a GitHub Release.
- *
- * Usage:
- *   bun run src/scripts/bundle-configs.ts <version> [output-dir]
- *
- * <version>     Semver string (e.g. 0.4.47 or 0.4.47-0).
- * [output-dir]  Directory for the zip file. Defaults to $GITHUB_WORKSPACE
- *               or the current directory.
- */
-
-import { $ } from "bun";
-import { cpSync, existsSync, mkdirSync } from "node:fs";
-import { homedir } from "node:os";
-import { join, resolve } from "node:path";
-
-const ROOT = resolve(import.meta.dir, "../..");
-const HOME = homedir();
-
-/** Source repo for the global skills install. */
-const SKILLS_REPO = "https://github.com/flora131/atomic.git";
-
-/** Agent CLI flags accepted by `bunx skills`. */
-const AGENT_FLAGS = ["claude-code", "opencode", "github-copilot"];
-
-/**
- * Local config root (in repo) → global root (~/) for each agent.
- * Copilot uses `.github` locally but `.copilot` globally.
- */
-const AGENT_ROOTS = {
-  claude: { local: ".claude", global: ".claude" },
-  opencode: { local: ".opencode", global: ".opencode" },
-  copilot: { local: ".github", global: ".copilot" },
-} as const;
-
-/** Paths included in the zip archive (relative to $HOME). */
-const ZIP_INCLUDES = [
-  ".agents/skills",
-  ".claude/agents",
-  ".claude/skills",
-  ".opencode/agents",
-  ".copilot/agents",
-  ".copilot/lsp-config.json",
-];
-
-// ── Steps ──────────────────────────────────────────────────────────────────
-
-async function installGlobalSkills(): Promise<void> {
-  console.log("Installing global skills…");
-
-  const agentArgs = AGENT_FLAGS.flatMap((a) => ["-a", a]);
-  await $`bunx skills add ${SKILLS_REPO} --skill "*" -g ${agentArgs} -y`;
-}
-
-async function copyBundledAgents(): Promise<void> {
-  console.log("Copying bundled agents to global roots…");
-
-  for (const [agent, { local, global: globalDir }] of Object.entries(
-    AGENT_ROOTS,
-  )) {
-    const src = join(ROOT, local, "agents");
-    const dest = join(HOME, globalDir, "agents");
-
-    mkdirSync(dest, { recursive: true });
-    cpSync(src, dest, { recursive: true });
-    console.log(`  ${agent}: ${src} → ${dest}`);
-  }
-
-  const lspSrc = join(ROOT, ".github", "lsp.json");
-  if (existsSync(lspSrc)) {
-    const lspDest = join(HOME, AGENT_ROOTS.copilot.global, "lsp-config.json");
-    cpSync(lspSrc, lspDest);
-    console.log(`  copilot: lsp.json → ${lspDest}`);
-  }
-}
-
-async function packageZip(
-  version: string,
-  outputDir: string,
-): Promise<string> {
-  const zipName = `atomic-configs-v${version}.zip`;
-  const zipPath = resolve(outputDir, zipName);
-
-  console.log(`Packaging ${zipName}…`);
-  await $`cd ${HOME} && zip -r ${zipPath} ${ZIP_INCLUDES} -x '*.DS_Store'`.quiet();
-  console.log(`  → ${zipPath}`);
-
-  return zipPath;
-}
-
-// ── Main ───────────────────────────────────────────────────────────────────
-
-async function main(): Promise<void> {
-  const version = process.argv[2]?.replace(/^v/, "");
-  const outputDir = process.argv[3] ?? process.env.GITHUB_WORKSPACE ?? ".";
-
-  if (!version) {
-    console.error(
-      "Usage: bun run src/scripts/bundle-configs.ts <version> [output-dir]",
-    );
-    process.exit(1);
-  }
-
-  await installGlobalSkills();
-  await copyBundledAgents();
-  await packageZip(version, outputDir);
-
-  console.log("\nDone.");
-}
-
-main();