@workerstack/repo 0.0.0-stage → 0.1.0

package/cli/sync/stock-history.test.ts

@@ -0,0 +1,66 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+import {
+  HOOK_COMMANDS_KEY,
+  STOCK_HISTORY_FILE,
+  STOCK_PREFIXES,
+  hashText,
+  hookCommands,
+  readStockHistory,
+} from "./stock-history.ts";
+
+const temps: string[] = [];
+afterEach(() => {
+  for (const dir of temps.splice(0)) fs.rmSync(dir, { recursive: true, force: true });
+});
+
+describe("hashText", () => {
+  it("is 16 hex digits and reads CRLF text as LF", () => {
+    expect(hashText("a\nb\n")).toMatch(/^[0-9a-f]{16}$/);
+    expect(hashText("a\r\nb\r\n")).toBe(hashText("a\nb\n"));
+    expect(hashText(Buffer.from("a\nb\n"))).toBe(hashText("a\nb\n"));
+    expect(hashText("a\nb")).not.toBe(hashText("a\nb\n"));
+  });
+});
+
+describe("readStockHistory", () => {
+  it("reads a table from a file", () => {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "workerstack-history-"));
+    temps.push(dir);
+    fs.writeFileSync(path.join(dir, "h.json"), '{ "a.md": ["0123456789abcdef"] }');
+    expect(readStockHistory(path.join(dir, "h.json"))).toEqual({ "a.md": ["0123456789abcdef"] });
+  });
+
+  it("ships a sorted table of 16-hex hashes under stock paths", () => {
+    const table = readStockHistory();
+    expect(STOCK_HISTORY_FILE.split(path.sep).join("/").endsWith("cli/sync/stock-history.json")).toBe(true);
+    const paths = Object.keys(table);
+    expect(paths.length).toBeGreaterThan(50);
+    expect(paths).toEqual([...paths].sort());
+    for (const [rel, hashes] of Object.entries(table)) {
+      if (rel === HOOK_COMMANDS_KEY) continue;
+      expect(STOCK_PREFIXES.some((prefix) => rel === prefix || (prefix.endsWith("/") && rel.startsWith(prefix)))).toBe(
+        true,
+      );
+      expect(hashes).toEqual([...hashes].sort());
+      for (const hash of hashes) expect(hash).toMatch(/^[0-9a-f]{16}$/);
+    }
+  });
+});
+
+describe("hookCommands", () => {
+  it("lists every command under hooks, whatever the nesting, and nothing else", () => {
+    const settings = {
+      env: { command: "not a hook" },
+      hooks: {
+        A: [{ matcher: "x", hooks: [{ type: "command", command: "one" }, { type: "prompt", command: 5 }, "text"] }],
+        B: [{ hooks: [{ command: "two" }] }],
+      },
+    };
+    expect(hookCommands(settings)).toEqual(["one", "two"]);
+    expect(hookCommands(null)).toEqual([]);
+    expect(hookCommands({})).toEqual([]);
+  });
+});

package/cli/sync/stock-history.ts

@@ -0,0 +1,84 @@
+import { createHash } from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+/** Hashes of every version of each stock path a copied install can hold, by repo-relative path; see `dev/stock-history.ts`. */
+export type StockHistory = Record<string, readonly string[]>;
+
+/**
+ * The stock paths the migration compares a copy against: rules, subagents, the generated agent files, skills, hooks, MCP policy, scripts, global
+ * settings, the old reference dir and its successor, the Claude settings and AGENTS.md. A prefix ending in `/`
+ * covers a dir; any other entry is one file.
+ */
+export const STOCK_PREFIXES = [
+  ".rulesync/rules/",
+  ".rulesync/subagents/",
+  ".rulesync/hooks.jsonc",
+  ".rulesync/mcp-policy.jsonc",
+  ".rulesync/global-settings/",
+  ".rulesync/settings/",
+  ".rulesync/repo.pipeline.jsonc",
+  ".rulesync/scripts/",
+  ".rulesync/reference/",
+  "references/",
+  ".agents/agents/",
+  ".claude/agents/",
+  ".codex/agents/",
+  ".cursor/agents/",
+  ".grok/agents/",
+  ".agents/skills/",
+  ".claude/settings.json",
+  "AGENTS.md",
+  // The other generated tree files: the package no longer ships them, so only their hashes tell a copy from an edit.
+  ".agents/hooks.json",
+  ".agents/mcp_config.json",
+  ".codex/config.toml",
+  ".codex/hooks.json",
+  ".cursor/hooks.json",
+  ".grok/config.toml",
+  ".grok/hooks/",
+  ".grok/roles/",
+  ".mcp.json",
+  // Where the stock sources live since they moved out of `.rulesync/` and `.agents/skills/`.
+  "agents/rules/",
+  "agents/subagents/",
+  "agents/hooks.jsonc",
+  "agents/mcp-policy.jsonc",
+  "agents/global-settings/",
+  "agents/settings/",
+  "agents/skills/",
+  "cli/scripts/",
+] as const;
+
+/** The table key for the hashes of every hook command any stock `.claude/settings.json` ever held. */
+export const HOOK_COMMANDS_KEY = ".claude/settings.json#commands";
+
+/** Every hook `command` string under the `hooks` of a parsed settings file. */
+export function hookCommands(settings: unknown): string[] {
+  const found: string[] = [];
+  const walk = (value: unknown): void => {
+    if (Array.isArray(value)) value.forEach(walk);
+    else if (typeof value === "object" && value !== null) {
+      for (const [key, entry] of Object.entries(value)) {
+        if (key === "command" && typeof entry === "string") found.push(entry);
+        else walk(entry);
+      }
+    }
+  };
+  walk((settings as { hooks?: unknown } | null)?.hooks);
+  return found;
+}
+
+export const STOCK_HISTORY_FILE: string = path.join(path.dirname(fileURLToPath(import.meta.url)), "stock-history.json");
+
+/** The first 16 hex digits of the sha256 of `bytes` read as text with LF line endings, so a CRLF checkout hashes alike. */
+export function hashText(bytes: Buffer | string): string {
+  const text = typeof bytes === "string" ? bytes : bytes.toString("utf8");
+  return createHash("sha256").update(text.replaceAll("\r\n", "\n")).digest("hex").slice(0, 16);
+}
+
+/** The shipped table of stock file hashes. */
+export function readStockHistory(file: string = STOCK_HISTORY_FILE): StockHistory {
+  return JSON.parse(fs.readFileSync(file, "utf8")) as StockHistory;
+}

package/cli/sync/stock.test.ts

@@ -0,0 +1,47 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+import { PACKAGE_NAME, isSelf, isSelfName, stockRoot } from "./stock.ts";
+
+const temps: string[] = [];
+afterEach(() => {
+  for (const dir of temps.splice(0)) fs.rmSync(dir, { recursive: true, force: true });
+});
+
+function withPackage(text: string | null): string {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), "workerstack-stock-"));
+  temps.push(root);
+  if (text !== null) fs.writeFileSync(path.join(root, "package.json"), text);
+  return root;
+}
+
+describe("stockRoot", () => {
+  it("is the package under the root's installed modules", () => {
+    expect(stockRoot(path.join("a", "b"))).toBe(path.join("a", "b", "node_modules", "@workerstack", "repo"));
+  });
+});
+
+describe("isSelf", () => {
+  it("is true for a package named @workerstack/repo", () => {
+    expect(isSelf(withPackage('{"name":"@workerstack/repo"}'))).toBe(true);
+  });
+
+  it.each([
+    ["another name", '{"name":"fixture"}'],
+    ["invalid JSON", "{"],
+    ["a non-object", "[]"],
+    ["null", "null"],
+    ["no package.json", null],
+  ])("is false for %s", (_label, text) => {
+    expect(isSelf(withPackage(text))).toBe(false);
+  });
+});
+
+describe("isSelfName", () => {
+  it("is true only for the package's own name", () => {
+    expect(isSelfName(PACKAGE_NAME)).toBe(true);
+    expect(isSelfName("fixture")).toBe(false);
+    expect(isSelfName(undefined)).toBe(false);
+  });
+});

package/cli/sync/stock.ts

@@ -0,0 +1,24 @@
+import fs from "node:fs";
+import path from "node:path";
+
+export const PACKAGE_NAME = "@workerstack/repo";
+
+/** Whether a package.json `name` is this package's own. */
+export function isSelfName(name: unknown): boolean {
+  return name === PACKAGE_NAME;
+}
+
+/** The installed stock package under `root`; in this repo it is the self link back to the root. */
+export function stockRoot(root: string): string {
+  return path.join(root, "node_modules", "@workerstack", "repo");
+}
+
+/** Whether the package at `root` is `@workerstack/repo` itself, by its package.json name. */
+export function isSelf(root: string): boolean {
+  try {
+    const pkg: unknown = JSON.parse(fs.readFileSync(path.join(root, "package.json"), "utf8"));
+    return typeof pkg === "object" && pkg !== null && isSelfName((pkg as { name?: unknown }).name);
+  } catch {
+    return false;
+  }
+}