@lovrozagar/grunt 0.1.0

package/cli/grunt.mjs

@@ -0,0 +1,54 @@
+import { execFileSync } from "node:child_process"
+import { readFileSync } from "node:fs"
+import path from "node:path"
+import { fileURLToPath } from "node:url"
+import { init } from "./init.mjs"
+
+const PKG_ROOT = path.join(path.dirname(fileURLToPath(import.meta.url)), "..")
+
+const USAGE = `Usage: grunt [command]
+
+Default (no command): init — full setup
+
+Commands:
+  init       Full setup: merge SoT, npm install, rulesync:generate, sync:globals:apply, rulesync:check
+  generate   npm run rulesync:generate
+  check      npm run rulesync:check
+  help       Show this help
+  version    Print package version
+`
+
+function pkgVersion() {
+  const pkg = JSON.parse(readFileSync(path.join(PKG_ROOT, "package.json"), "utf8"))
+  return pkg.version
+}
+
+function npmRun(script) {
+  execFileSync("npm", ["run", script], { cwd: process.cwd(), stdio: "inherit" })
+}
+
+export function start() {
+  const [cmd] = process.argv.slice(2)
+  if (cmd === "help" || cmd === "--help" || cmd === "-h") {
+    process.stdout.write(USAGE)
+    return
+  }
+  if (cmd === "version" || cmd === "--version" || cmd === "-v") {
+    process.stdout.write(`${pkgVersion()}\n`)
+    return
+  }
+  if (!cmd || cmd === "init") {
+    init(process.cwd())
+    return
+  }
+  if (cmd === "generate") {
+    npmRun("rulesync:generate")
+    return
+  }
+  if (cmd === "check") {
+    npmRun("rulesync:check")
+    return
+  }
+  process.stdout.write(USAGE)
+  process.exitCode = 1
+}

package/cli/grunt.test.ts

@@ -0,0 +1,117 @@
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+const init = vi.hoisted(() => vi.fn());
+const execFileSync = vi.hoisted(() => vi.fn());
+
+vi.mock("./init.mjs", () => ({ init }));
+vi.mock("node:child_process", () => ({ execFileSync }));
+
+import { start } from "./grunt.mjs";
+
+const USAGE = `Usage: grunt [command]
+
+Default (no command): init — full setup
+
+Commands:
+  init       Full setup: merge SoT, npm install, rulesync:generate, sync:globals:apply, rulesync:check
+  generate   npm run rulesync:generate
+  check      npm run rulesync:check
+  help       Show this help
+  version    Print package version
+`;
+
+const pkgRoot = path.join(path.dirname(fileURLToPath(import.meta.url)), "..");
+const version = JSON.parse(
+  fs.readFileSync(path.join(pkgRoot, "package.json"), "utf8"),
+).version as string;
+
+describe("start", () => {
+  let argv: string[];
+  let exitCode: typeof process.exitCode;
+  let stdoutWrite: typeof process.stdout.write;
+  const chunks: string[] = [];
+
+  beforeEach(() => {
+    argv = process.argv.slice();
+    exitCode = process.exitCode;
+    process.exitCode = 0;
+    chunks.length = 0;
+    stdoutWrite = process.stdout.write.bind(process.stdout);
+    process.stdout.write = ((buf: string | Uint8Array) => {
+      chunks.push(String(buf));
+      return true;
+    }) as typeof process.stdout.write;
+    init.mockReset();
+    execFileSync.mockReset();
+  });
+
+  afterEach(() => {
+    process.argv = argv;
+    process.exitCode = exitCode;
+    process.stdout.write = stdoutWrite;
+  });
+
+  it.each(["help", "--help", "-h"])("%s writes usage", (cmd) => {
+    process.argv = ["node", "grunt", cmd];
+    start();
+    expect(chunks.join("")).toBe(USAGE);
+    expect(process.exitCode).toBe(0);
+    expect(init).not.toHaveBeenCalled();
+    expect(execFileSync).not.toHaveBeenCalled();
+  });
+
+  it.each(["version", "--version", "-v"])("%s writes package version", (cmd) => {
+    process.argv = ["node", "grunt", cmd];
+    start();
+    expect(chunks.join("")).toBe(`${version}\n`);
+    expect(process.exitCode).toBe(0);
+  });
+
+  it("no-arg runs init on cwd", () => {
+    process.argv = ["node", "grunt"];
+    start();
+    expect(init).toHaveBeenCalledOnce();
+    expect(init).toHaveBeenCalledWith(process.cwd());
+    expect(execFileSync).not.toHaveBeenCalled();
+  });
+
+  it("init runs init on cwd", () => {
+    process.argv = ["node", "grunt", "init"];
+    start();
+    expect(init).toHaveBeenCalledOnce();
+    expect(init).toHaveBeenCalledWith(process.cwd());
+  });
+
+  it("generate npm-runs rulesync:generate", () => {
+    process.argv = ["node", "grunt", "generate"];
+    start();
+    expect(execFileSync).toHaveBeenCalledOnce();
+    expect(execFileSync).toHaveBeenCalledWith("npm", ["run", "rulesync:generate"], {
+      cwd: process.cwd(),
+      stdio: "inherit",
+    });
+    expect(init).not.toHaveBeenCalled();
+  });
+
+  it("check npm-runs rulesync:check", () => {
+    process.argv = ["node", "grunt", "check"];
+    start();
+    expect(execFileSync).toHaveBeenCalledOnce();
+    expect(execFileSync).toHaveBeenCalledWith("npm", ["run", "rulesync:check"], {
+      cwd: process.cwd(),
+      stdio: "inherit",
+    });
+  });
+
+  it("unknown writes usage and exitCode 1", () => {
+    process.argv = ["node", "grunt", "nope"];
+    start();
+    expect(chunks.join("")).toBe(USAGE);
+    expect(process.exitCode).toBe(1);
+    expect(init).not.toHaveBeenCalled();
+    expect(execFileSync).not.toHaveBeenCalled();
+  });
+});

package/cli/init.mjs

@@ -0,0 +1,113 @@
+import { execFileSync } from "node:child_process"
+import fs from "node:fs"
+import path from "node:path"
+import { fileURLToPath } from "node:url"
+
+const PKG_ROOT = path.join(path.dirname(fileURLToPath(import.meta.url)), "..")
+
+const PRODUCT_SCRIPTS = [
+  "check-globals.mjs",
+  "emit-mcp-policy.mjs",
+  "gate-fat-tools.mjs",
+  "grunt-job.mjs",
+  "parse-need.mjs",
+  "persist-plan.mjs",
+  "purge-global-mcps.mjs",
+  "scrub-spawn-prompt.mjs",
+  "scrub-text-lib.mjs",
+  "sync-global-settings.mjs",
+  "telemetry.mjs",
+  "scrub-text",
+]
+
+const COPY_DIRS = [".rulesync", ".grok", ".codex", ".claude", ".agents"]
+const COPY_FILES = ["AGENTS.md", "CLAUDE.md", ".mcp.json"]
+
+function sortKeys(obj) {
+  return Object.fromEntries(Object.keys(obj).sort().map((k) => [k, obj[k]]))
+}
+
+export function samePath(a, b) {
+  try {
+    return fs.realpathSync(a) === fs.realpathSync(b)
+  } catch {
+    return path.resolve(a) === path.resolve(b)
+  }
+}
+
+export function mergeGitignore(dest) {
+  const gi = path.join(dest, ".gitignore")
+  if (!fs.existsSync(gi)) {
+    fs.writeFileSync(gi, ".tmp/\n")
+    return
+  }
+  const text = fs.readFileSync(gi, "utf8")
+  const has = text.split(/\r?\n/).some((line) => /^\.tmp\/?$/.test(line))
+  if (has) return
+  const prefix = text.endsWith("\n") || text.length === 0 ? "" : "\n"
+  fs.appendFileSync(gi, `${prefix}.tmp/\n`)
+}
+
+export function mergePackageJson(dest, pkgRoot) {
+  const destPath = path.join(dest, "package.json")
+  let destPkg = {}
+  if (fs.existsSync(destPath)) {
+    destPkg = JSON.parse(fs.readFileSync(destPath, "utf8"))
+  }
+  if (destPkg.name === "@lovrozagar/grunt") return
+
+  const srcPkg = JSON.parse(fs.readFileSync(path.join(pkgRoot, "package.json"), "utf8"))
+  destPkg.scripts = { ...(destPkg.scripts || {}) }
+  for (const [k, v] of Object.entries(srcPkg.scripts || {})) {
+    if (k === "test") continue
+    destPkg.scripts[k] = v
+  }
+  destPkg.devDependencies = { ...(destPkg.devDependencies || {}) }
+  destPkg.devDependencies["smol-toml"] = srcPkg.devDependencies["smol-toml"]
+  destPkg.devDependencies["rulesync"] = srcPkg.devDependencies["rulesync"]
+  destPkg.scripts = sortKeys(destPkg.scripts)
+  destPkg.devDependencies = sortKeys(destPkg.devDependencies)
+  fs.writeFileSync(destPath, `${JSON.stringify(destPkg, null, 2)}\n`)
+}
+
+export function init(dest, { pkgRoot: pkgRootOpt, execFileSync: exec = execFileSync } = {}) {
+  dest = path.resolve(dest)
+  const pkgRoot = path.resolve(pkgRootOpt ?? PKG_ROOT)
+
+  for (const dir of COPY_DIRS) {
+    const src = path.join(pkgRoot, dir)
+    const d = path.join(dest, dir)
+    fs.mkdirSync(d, { recursive: true })
+    if (!samePath(src, d)) fs.cpSync(src, d, { recursive: true, force: true })
+  }
+
+  for (const file of COPY_FILES) {
+    const src = path.join(pkgRoot, file)
+    const d = path.join(dest, file)
+    if (!samePath(src, d)) fs.copyFileSync(src, d)
+  }
+
+  fs.mkdirSync(path.join(dest, "scripts"), { recursive: true })
+  for (const name of PRODUCT_SCRIPTS) {
+    const src = path.join(pkgRoot, "scripts", name)
+    const d = path.join(dest, "scripts", name)
+    if (samePath(src, d)) continue
+    const st = fs.statSync(src)
+    if (st.isDirectory()) fs.cpSync(src, d, { recursive: true, force: true })
+    else fs.copyFileSync(src, d)
+  }
+
+  fs.mkdirSync(path.join(dest, ".tmp"), { recursive: true })
+  mergeGitignore(dest)
+
+  const self = samePath(dest, pkgRoot)
+  // Self-skip: file/dir merge + .tmp + gitignore only. No package.json merge,
+  // npm install, or generate/sync/check (would mutate this package in-place).
+  if (self) return
+
+  mergePackageJson(dest, pkgRoot)
+  exec("npm", ["install"], { cwd: dest, stdio: "inherit" })
+  exec("npm", ["run", "rulesync:generate"], { cwd: dest, stdio: "inherit" })
+  exec("npm", ["run", "sync:globals:apply"], { cwd: dest, stdio: "inherit" })
+  exec("npm", ["run", "rulesync:check"], { cwd: dest, stdio: "inherit" })
+}

package/cli/init.test.ts

@@ -0,0 +1,268 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import {
+  init,
+  mergeGitignore,
+  mergePackageJson,
+  samePath,
+} from "./init.mjs";
+
+const tmpDirs: string[] = [];
+afterEach(() => {
+  for (const d of tmpDirs.splice(0)) {
+    fs.rmSync(d, { recursive: true, force: true });
+  }
+});
+
+function tmp(prefix: string) {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), prefix));
+  tmpDirs.push(dir);
+  return dir;
+}
+
+const COPY_DIRS = [".rulesync", ".grok", ".codex", ".claude", ".agents"];
+const COPY_FILES = ["AGENTS.md", "CLAUDE.md", ".mcp.json"];
+const PRODUCT_FILES = [
+  "check-globals.mjs",
+  "emit-mcp-policy.mjs",
+  "gate-fat-tools.mjs",
+  "grunt-job.mjs",
+  "parse-need.mjs",
+  "persist-plan.mjs",
+  "purge-global-mcps.mjs",
+  "scrub-spawn-prompt.mjs",
+  "scrub-text-lib.mjs",
+  "sync-global-settings.mjs",
+  "telemetry.mjs",
+];
+
+function stubPkgRoot(pkg: Record<string, unknown> = {
+  name: "fixture-pkg",
+  scripts: {
+    test: "skip-me",
+    zeta: "z",
+    alpha: "a",
+    "rulesync:generate": "gen",
+  },
+  devDependencies: {
+    "smol-toml": "^1.8.0",
+    rulesync: "latest",
+    zzz: "1",
+  },
+}) {
+  const root = tmp("grunt-pkg-");
+  for (const d of COPY_DIRS) {
+    fs.mkdirSync(path.join(root, d));
+    fs.writeFileSync(path.join(root, d, "marker"), d);
+  }
+  for (const f of COPY_FILES) {
+    fs.writeFileSync(path.join(root, f), f);
+  }
+  fs.mkdirSync(path.join(root, "scripts"));
+  for (const name of PRODUCT_FILES) {
+    fs.writeFileSync(path.join(root, "scripts", name), name);
+  }
+  fs.mkdirSync(path.join(root, "scripts", "scrub-text"));
+  fs.writeFileSync(path.join(root, "scripts", "scrub-text", "inside"), "dir");
+  fs.writeFileSync(path.join(root, "package.json"), `${JSON.stringify(pkg, null, 2)}\n`);
+  return root;
+}
+
+describe("samePath", () => {
+  it("try: realpath equal vs unequal", () => {
+    const a = tmp("same-a-");
+    const b = tmp("same-b-");
+    expect(samePath(a, a)).toBe(true);
+    expect(samePath(a, b)).toBe(false);
+  });
+
+  it("catch: missing paths fall back to resolve", () => {
+    const missing = path.join(os.tmpdir(), `grunt-missing-${process.pid}-nope`);
+    expect(samePath(missing, missing)).toBe(true);
+    expect(samePath(missing, `${missing}-other`)).toBe(false);
+  });
+});
+
+describe("mergeGitignore", () => {
+  it("creates .tmp/ when missing", () => {
+    const dest = tmp("gi-miss-");
+    mergeGitignore(dest);
+    expect(fs.readFileSync(path.join(dest, ".gitignore"), "utf8")).toBe(".tmp/\n");
+  });
+
+  it("noop when .tmp/ present", () => {
+    const dest = tmp("gi-slash-");
+    fs.writeFileSync(path.join(dest, ".gitignore"), "foo\n.tmp/\nbar\n");
+    mergeGitignore(dest);
+    expect(fs.readFileSync(path.join(dest, ".gitignore"), "utf8")).toBe("foo\n.tmp/\nbar\n");
+  });
+
+  it("noop when .tmp present", () => {
+    const dest = tmp("gi-bare-");
+    fs.writeFileSync(path.join(dest, ".gitignore"), ".tmp\n");
+    mergeGitignore(dest);
+    expect(fs.readFileSync(path.join(dest, ".gitignore"), "utf8")).toBe(".tmp\n");
+  });
+
+  it("appends after trailing newline", () => {
+    const dest = tmp("gi-nl-");
+    fs.writeFileSync(path.join(dest, ".gitignore"), "node_modules/\n");
+    mergeGitignore(dest);
+    expect(fs.readFileSync(path.join(dest, ".gitignore"), "utf8")).toBe(
+      "node_modules/\n.tmp/\n",
+    );
+  });
+
+  it("appends with inserted newline when file lacks one", () => {
+    const dest = tmp("gi-nonl-");
+    fs.writeFileSync(path.join(dest, ".gitignore"), "node_modules/");
+    mergeGitignore(dest);
+    expect(fs.readFileSync(path.join(dest, ".gitignore"), "utf8")).toBe(
+      "node_modules/\n.tmp/\n",
+    );
+  });
+
+  it("appends to empty existing file", () => {
+    const dest = tmp("gi-empty-");
+    fs.writeFileSync(path.join(dest, ".gitignore"), "");
+    mergeGitignore(dest);
+    expect(fs.readFileSync(path.join(dest, ".gitignore"), "utf8")).toBe(".tmp/\n");
+  });
+});
+
+describe("mergePackageJson", () => {
+  it("creates {} dest and merges scripts skipping test, injects deps, sorts keys", () => {
+    const pkgRoot = stubPkgRoot();
+    const dest = tmp("pj-new-");
+    mergePackageJson(dest, pkgRoot);
+    const out = JSON.parse(fs.readFileSync(path.join(dest, "package.json"), "utf8"));
+    expect(out.scripts).toEqual({
+      alpha: "a",
+      "rulesync:generate": "gen",
+      zeta: "z",
+    });
+    expect(Object.keys(out.scripts)).toEqual(["alpha", "rulesync:generate", "zeta"]);
+    expect(out.devDependencies).toEqual({
+      rulesync: "latest",
+      "smol-toml": "^1.8.0",
+    });
+    expect(Object.keys(out.devDependencies)).toEqual(["rulesync", "smol-toml"]);
+    expect(out.scripts.test).toBeUndefined();
+  });
+
+  it("merges over existing dest scripts/deps, keeps dest test", () => {
+    const pkgRoot = stubPkgRoot();
+    const dest = tmp("pj-exist-");
+    fs.writeFileSync(
+      path.join(dest, "package.json"),
+      JSON.stringify({
+        name: "app",
+        scripts: { test: "jest", alpha: "old", foo: "bar" },
+        devDependencies: { lodash: "4" },
+      }),
+    );
+    mergePackageJson(dest, pkgRoot);
+    const out = JSON.parse(fs.readFileSync(path.join(dest, "package.json"), "utf8"));
+    expect(out.scripts.test).toBe("jest");
+    expect(out.scripts.alpha).toBe("a");
+    expect(out.scripts.foo).toBe("bar");
+    expect(out.devDependencies.lodash).toBe("4");
+    expect(out.devDependencies["smol-toml"]).toBe("^1.8.0");
+    expect(out.devDependencies.rulesync).toBe("latest");
+  });
+
+  it("early return when name is @lovrozagar/grunt", () => {
+    const pkgRoot = stubPkgRoot();
+    const dest = tmp("pj-self-");
+    const raw = `${JSON.stringify({ name: "@lovrozagar/grunt", scripts: { test: "x" } }, null, 2)}\n`;
+    fs.writeFileSync(path.join(dest, "package.json"), raw);
+    mergePackageJson(dest, pkgRoot);
+    expect(fs.readFileSync(path.join(dest, "package.json"), "utf8")).toBe(raw);
+  });
+
+  it("src without scripts uses empty object", () => {
+    const pkgRoot = stubPkgRoot({
+      name: "no-scripts",
+      devDependencies: { "smol-toml": "1", rulesync: "2" },
+    });
+    const dest = tmp("pj-noscripts-");
+    mergePackageJson(dest, pkgRoot);
+    const out = JSON.parse(fs.readFileSync(path.join(dest, "package.json"), "utf8"));
+    expect(out.scripts).toEqual({});
+    expect(out.devDependencies).toEqual({ rulesync: "2", "smol-toml": "1" });
+  });
+});
+
+describe("init", () => {
+  it("self-skip: copies + gitignore, no exec, no package merge", () => {
+    const pkgRoot = stubPkgRoot();
+    const exec = vi.fn();
+    init(pkgRoot, { pkgRoot, execFileSync: exec });
+    expect(exec).not.toHaveBeenCalled();
+    const pkg = JSON.parse(fs.readFileSync(path.join(pkgRoot, "package.json"), "utf8"));
+    expect(pkg.name).toBe("fixture-pkg");
+    expect(fs.existsSync(path.join(pkgRoot, ".tmp"))).toBe(true);
+    expect(fs.readFileSync(path.join(pkgRoot, ".gitignore"), "utf8")).toBe(".tmp/\n");
+    expect(fs.readFileSync(path.join(pkgRoot, "scripts", "telemetry.mjs"), "utf8")).toBe(
+      "telemetry.mjs",
+    );
+  });
+
+  it("non-self: file vs dir product scripts, then npm pipeline in order", () => {
+    const pkgRoot = stubPkgRoot();
+    const dest = tmp("grunt-dest-");
+    const exec = vi.fn();
+    init(dest, { pkgRoot, execFileSync: exec });
+
+    for (const d of COPY_DIRS) {
+      expect(fs.readFileSync(path.join(dest, d, "marker"), "utf8")).toBe(d);
+    }
+    for (const f of COPY_FILES) {
+      expect(fs.readFileSync(path.join(dest, f), "utf8")).toBe(f);
+    }
+    for (const name of PRODUCT_FILES) {
+      expect(fs.statSync(path.join(dest, "scripts", name)).isFile()).toBe(true);
+    }
+    expect(fs.statSync(path.join(dest, "scripts", "scrub-text")).isDirectory()).toBe(true);
+    expect(fs.readFileSync(path.join(dest, "scripts", "scrub-text", "inside"), "utf8")).toBe(
+      "dir",
+    );
+
+    const destPkg = JSON.parse(fs.readFileSync(path.join(dest, "package.json"), "utf8"));
+    expect(destPkg.scripts.test).toBeUndefined();
+    expect(destPkg.devDependencies["smol-toml"]).toBe("^1.8.0");
+
+    expect(exec.mock.calls.map((c) => [c[0], c[1]])).toEqual([
+      ["npm", ["install"]],
+      ["npm", ["run", "rulesync:generate"]],
+      ["npm", ["run", "sync:globals:apply"]],
+      ["npm", ["run", "rulesync:check"]],
+    ]);
+    for (const call of exec.mock.calls) {
+      expect(call[2]).toEqual({ cwd: dest, stdio: "inherit" });
+    }
+  });
+
+  it("omitted execFileSync uses default; self-skip never invokes it", () => {
+    const pkgRoot = stubPkgRoot();
+    init(pkgRoot, { pkgRoot });
+    expect(fs.existsSync(path.join(pkgRoot, "AGENTS.md"))).toBe(true);
+    expect(fs.readFileSync(path.join(pkgRoot, ".gitignore"), "utf8")).toBe(".tmp/\n");
+  });
+
+  it("omitted pkgRoot uses built-in PKG_ROOT; exec mocked", () => {
+    const dest = tmp("grunt-realroot-");
+    const exec = vi.fn();
+    init(dest, { execFileSync: exec });
+    expect(fs.existsSync(path.join(dest, "AGENTS.md"))).toBe(true);
+    expect(fs.existsSync(path.join(dest, "scripts", "scrub-text"))).toBe(true);
+    expect(exec.mock.calls.map((c) => c[1])).toEqual([
+      ["install"],
+      ["run", "rulesync:generate"],
+      ["run", "sync:globals:apply"],
+      ["run", "rulesync:check"],
+    ]);
+  });
+});

package/package.json

@@ -0,0 +1,77 @@
+{
+  "name": "@lovrozagar/grunt",
+  "version": "0.1.0",
+  "description": "Multi-agent orchestrator SoT — deep-merge rulesync trees, product scripts, and generate pipeline into a consumer repo",
+  "keywords": [
+    "agents",
+    "grunt",
+    "orchestrator",
+    "rulesync"
+  ],
+  "homepage": "https://github.com/lovrozagar/grunt#readme",
+  "bugs": {
+    "url": "https://github.com/lovrozagar/grunt/issues"
+  },
+  "license": "MIT",
+  "author": "lovrozagar",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/lovrozagar/grunt.git"
+  },
+  "bin": {
+    "grunt": "./bin/grunt.js"
+  },
+  "files": [
+    "bin/grunt.js",
+    "cli",
+    "scripts/check-globals.mjs",
+    "scripts/emit-mcp-policy.mjs",
+    "scripts/gate-fat-tools.mjs",
+    "scripts/grunt-job.mjs",
+    "scripts/parse-need.mjs",
+    "scripts/persist-plan.mjs",
+    "scripts/purge-global-mcps.mjs",
+    "scripts/scrub-spawn-prompt.mjs",
+    "scripts/scrub-text-lib.mjs",
+    "scripts/sync-global-settings.mjs",
+    "scripts/telemetry.mjs",
+    "scripts/scrub-text",
+    ".rulesync",
+    ".grok",
+    ".codex",
+    ".claude",
+    ".agents",
+    "AGENTS.md",
+    "CLAUDE.md",
+    ".mcp.json",
+    "README.md",
+    "LICENSE"
+  ],
+  "type": "module",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "rulesync:generate": "rulesync generate -t claudecode,codexcli,antigravity-cli,grokcli -f rules,subagents && rulesync generate -t claudecode,codexcli,antigravity-cli -f hooks && node scripts/emit-mcp-policy.mjs",
+    "rulesync:watch": "node scripts/emit-mcp-policy.mjs && rulesync generate -t claudecode,codexcli,antigravity-cli,grokcli -f rules,subagents --watch",
+    "rulesync:check": "rulesync generate -t claudecode,codexcli,antigravity-cli,grokcli -f rules,subagents --check && rulesync generate -t claudecode,codexcli,antigravity-cli -f hooks --check && node scripts/emit-mcp-policy.mjs --check && node scripts/check-globals.mjs",
+    "rulesync:doctor": "rulesync doctor",
+    "sync:globals": "node scripts/sync-global-settings.mjs",
+    "sync:globals:check": "node scripts/check-globals.mjs",
+    "sync:globals:apply": "node scripts/sync-global-settings.mjs --apply",
+    "purge:global-mcps": "node scripts/purge-global-mcps.mjs",
+    "purge:global-mcps:apply": "node scripts/purge-global-mcps.mjs --apply",
+    "test": "vitest run --coverage"
+  },
+  "devDependencies": {
+    "@types/node": "^24.13.3",
+    "@vitest/coverage-v8": "^3.2.7",
+    "rulesync": "latest",
+    "smol-toml": "^1.8.0",
+    "typescript": "^5.9.3",
+    "vitest": "^3.2.7"
+  },
+  "engines": {
+    "node": ">=22"
+  }
+}