@workerstack/repo 0.0.0-stage → 0.1.0

package/cli/scripts/hook-command.ts

@@ -0,0 +1,72 @@
+/**
+ * The repo hooks and the one command every host runs for each. Pure and dependency free, because consumers that still
+ * copy `cli/scripts/` import it from `hooks-union.ts`, where `cli/` does not exist.
+ */
+
+/** Each repo hook, and the file its command ran before it went through `repo hook`. */
+export const HOOK_SCRIPTS = {
+  "gate-fat-tools": "gate-fat-tools.ts",
+  "orchestrate-parent": "orchestrate-parent.ts",
+  "rtk-grok": "rtk-grok.ts",
+  "scrub-spawn-prompt": "scrub-spawn-prompt.ts",
+  "session-map": "session-map.ts",
+  worktree: "worktree.ts",
+} as const;
+
+export type HookName = keyof typeof HOOK_SCRIPTS;
+
+export const HOOK_NAMES: (
+  | "gate-fat-tools"
+  | "orchestrate-parent"
+  | "rtk-grok"
+  | "scrub-spawn-prompt"
+  | "session-map"
+  | "worktree"
+)[] = (Object.keys(HOOK_SCRIPTS) as HookName[]).sort();
+
+export function isHookName(name: string | undefined): name is HookName {
+  return name !== undefined && Object.hasOwn(HOOK_SCRIPTS, name);
+}
+
+export const HOOK_USAGE: string = `use ${HOOK_NAMES.slice(0, -1).join(", ")} or ${HOOK_NAMES.at(-1)}`;
+
+/**
+ * Shell text that sets `$r` to the installed bin, which bun links as `repo` on POSIX and as `repo.exe` on Windows,
+ * starting from `start` (shell text, expanded once). The start, its git toplevel, then the main checkout of a linked
+ * worktree are probed in that order, so an uninstalled worktree runs the main checkout's bin; the root stays the
+ * worktree. A checkout with no install anywhere gets a message and exit 1; exit 2 would block the `bun install` that
+ * fixes it. `resolveRepoBin` in `gate-fat-tools.ts` keeps the same order.
+ */
+export function repoBinLookup(start: string): string {
+  return (
+    `d="${start}"; b=node_modules/.bin/repo; ` +
+    `[ -e "$d/$b" ] || [ -e "$d/$b.exe" ] || d="$(git -C "$d" rev-parse --show-toplevel 2>/dev/null || echo "$d")"; ` +
+    `m="$(git -C "$d" rev-parse --path-format=absolute --git-common-dir 2>/dev/null)"; m="\${m%/*}"; r=; ` +
+    `for c in "$d" "$m"; do for e in "" .exe; do [ -n "$c" ] && [ -e "$c/$b$e" ] && { r="$c/$b$e"; break 2; }; done; done; ` +
+    `[ -x "$r" ] || { echo "repo: $d/$b is missing; run bun install" >&2; exit 1; }`
+  );
+}
+
+/** The hook command every host runs: the bin found from the agent's project dir, the way hooks always have. */
+export function hookCommand(name: HookName): string {
+  return `${repoBinLookup("${GROK_WORKSPACE_ROOT:-${CLAUDE_PROJECT_DIR:-.}}")}; "$r" hook ${name}`;
+}
+
+/** The short form stock sources use for a repo hook command, `repo hook <name>`. */
+const SHORT_FORM = /^repo hook ([\w-]+)$/;
+
+/** `hookCommand(name)` for a `repo hook <name>` source command; any other command comes back unchanged. */
+export function expandHookCommand(command: string): string {
+  const name = SHORT_FORM.exec(command)?.[1];
+  return isHookName(name) ? hookCommand(name) : command;
+}
+
+/** The repo hook a command runs, in the `repo hook <name>` form or the older direct script form; null for any other command. */
+export function hookNameOf(command: string): HookName | null {
+  const viaBin = /(?:\$r"|[\s"'/]repo"?|^repo)\s+hook\s+([\w-]+)\s*$/.exec(command);
+  if (viaBin) return isHookName(viaBin[1]) ? viaBin[1] : null;
+  for (const name of HOOK_NAMES) {
+    if (new RegExp(`[\\\\/"'\\s]${HOOK_SCRIPTS[name].replace(".", "\\.")}(?:["'\\s]|$)`).test(command)) return name;
+  }
+  return null;
+}

package/cli/scripts/hook-input.ts

@@ -0,0 +1,178 @@
+/** The stdin payload every hook entry receives. Claude, Codex, Cursor, Grok and Antigravity spell the same facts differently, so each spelling is its own optional field. */
+
+/** Antigravity's tool call: the tool name and its arguments. */
+interface HookToolCall {
+  name?: string;
+  args?: Record<string, unknown>;
+}
+
+/** The nested agent object some harnesses send in place of flat agent fields. */
+export interface HookAgent {
+  id?: string;
+  type?: string;
+  name?: string;
+  subagentType?: string;
+  subagent_type?: string;
+  agentType?: string;
+  agentId?: string;
+  agent_id?: string;
+  spawnedBy?: string;
+  spawned_by?: string;
+}
+
+export interface HookInput {
+  session_id?: string;
+  sessionId?: string;
+  conversationId?: string;
+  cwd?: string;
+  /** The workspace the harness works in: Grok and Cursor send one string, Antigravity a list. */
+  workspaceRoot?: string;
+  workspace_root?: string;
+  workspacePaths?: string[];
+  hook_event_name?: string;
+  hookEventName?: string;
+  tool_name?: string;
+  toolName?: string;
+  /** Shape varies per tool; callers narrow it. */
+  tool_input?: Record<string, unknown>;
+  toolInput?: Record<string, unknown>;
+  /** Antigravity's call, instead of the tool name and input fields. */
+  toolCall?: HookToolCall;
+  transcript_path?: string;
+  transcriptPath?: string;
+  prompt?: string;
+  userPrompt?: string;
+  user_prompt?: string;
+  content?: string;
+  lastUserInput?: string;
+  last_assistant_message?: string;
+  lastAssistantMessage?: string;
+  reason?: string;
+  stop_hook_active?: boolean;
+  stopHookActive?: boolean;
+  agent_type?: string;
+  agentType?: string;
+  agent_name?: string;
+  agentName?: string;
+  subagent_type?: string;
+  subagentType?: string;
+  agent_id?: string;
+  agentId?: string;
+  spawned_by?: string;
+  spawnedBy?: string;
+  /** A name string (Grok) or a nested object (Cursor). */
+  agent?: string | HookAgent;
+  /** Present only on Cursor payloads. */
+  cursor_version?: string;
+  /** Codex sends turn_id and model on every tool hook. */
+  turn_id?: string;
+  model?: string;
+  /** Claude WorktreeCreate: the requested worktree name. */
+  name?: string;
+  /** Claude WorktreeRemove: the worktree directory. */
+  worktree_path?: string;
+}
+
+const STRING_FIELDS = [
+  "session_id",
+  "sessionId",
+  "conversationId",
+  "cwd",
+  "workspaceRoot",
+  "workspace_root",
+  "hook_event_name",
+  "hookEventName",
+  "tool_name",
+  "toolName",
+  "transcript_path",
+  "transcriptPath",
+  "prompt",
+  "userPrompt",
+  "user_prompt",
+  "content",
+  "lastUserInput",
+  "last_assistant_message",
+  "lastAssistantMessage",
+  "reason",
+  "agent_type",
+  "agentType",
+  "agent_name",
+  "agentName",
+  "subagent_type",
+  "subagentType",
+  "agent_id",
+  "agentId",
+  "spawned_by",
+  "spawnedBy",
+  "cursor_version",
+  "turn_id",
+  "model",
+  "name",
+  "worktree_path",
+] as const;
+
+const AGENT_FIELDS = [
+  "id",
+  "type",
+  "name",
+  "subagentType",
+  "subagent_type",
+  "agentType",
+  "agentId",
+  "agent_id",
+  "spawnedBy",
+  "spawned_by",
+] as const;
+
+const BOOLEAN_FIELDS = ["stop_hook_active", "stopHookActive"] as const;
+
+const TOOL_INPUT_FIELDS = ["tool_input", "toolInput"] as const;
+
+export function isRecord(v: unknown): v is Record<string, unknown> {
+  return v !== null && typeof v === "object" && !Array.isArray(v);
+}
+
+/** Parses stdin text into a HookInput, or null when it is not JSON or not an object. A field whose type is wrong is dropped; the rest are kept. */
+export function parseHookInput(raw: string): HookInput | null {
+  let value: unknown;
+  try {
+    value = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  if (!isRecord(value)) return null;
+  const out: HookInput = {};
+  for (const key of STRING_FIELDS) {
+    const v = value[key];
+    if (typeof v === "string") out[key] = v;
+  }
+  if (Array.isArray(value.workspacePaths)) {
+    out.workspacePaths = value.workspacePaths.filter((p): p is string => typeof p === "string");
+  }
+  for (const key of BOOLEAN_FIELDS) {
+    const v = value[key];
+    if (typeof v === "boolean") out[key] = v;
+  }
+  for (const key of TOOL_INPUT_FIELDS) {
+    const v = value[key];
+    if (isRecord(v)) out[key] = v;
+  }
+  const call = value.toolCall;
+  if (isRecord(call)) {
+    const toolCall: HookToolCall = {};
+    if (typeof call.name === "string") toolCall.name = call.name;
+    if (isRecord(call.args)) toolCall.args = call.args;
+    out.toolCall = toolCall;
+  }
+  const agent = value.agent;
+  if (typeof agent === "string") out.agent = agent;
+  else if (isRecord(agent)) {
+    const nested: HookAgent = {};
+    for (const key of AGENT_FIELDS) {
+      const v = agent[key];
+      if (typeof v === "string") nested[key] = v;
+    }
+    out.agent = nested;
+  }
+  return out;
+}

package/cli/scripts/hook-io.constants.ts

@@ -0,0 +1,5 @@
+/** Bytes a hook asks the OS for per read of stdin. */
+export const HOOK_READ_CHUNK_BYTES = 8192;
+
+/** File descriptor of stdin. */
+export const STDIN_FD = 0;

package/cli/scripts/hook-io.ts

@@ -0,0 +1,46 @@
+/** The edge every hook reads its payload from and writes its reply to; tests pass a fake in place of the process. */
+import fs from "node:fs";
+import { parseHookInput, type HookInput } from "./hook-input.ts";
+import { HOOK_READ_CHUNK_BYTES, STDIN_FD } from "./hook-io.constants.ts";
+
+export interface HookIo {
+  /** The next bytes of the payload; null once the stream is closed or unreadable. */
+  readChunk(): Uint8Array | null;
+  write(text: string): void;
+}
+
+/** Reads `fd` (stdin unless a test plants a file) and writes stdout. */
+export function processHookIo(fd: number = STDIN_FD): HookIo {
+  const chunk = Buffer.alloc(HOOK_READ_CHUNK_BYTES);
+  return {
+    readChunk: () => {
+      try {
+        const n = fs.readSync(fd, chunk, 0, chunk.length, null);
+        return n === 0 ? null : chunk.subarray(0, n);
+      } catch {
+        return null;
+      }
+    },
+    write: (text) => {
+      process.stdout.write(text);
+    },
+  };
+}
+
+/** Read until the bytes parse as one JSON object, without waiting for EOF (some hosts keep stdin open); null when they never do. */
+export function readHookInput(io: HookIo): HookInput | null {
+  let buf = Buffer.alloc(0);
+  for (let chunk = io.readChunk(); chunk; chunk = io.readChunk()) {
+    buf = Buffer.concat([buf, chunk]);
+    const parsed = parseHookInput(buf.toString("utf8"));
+    if (parsed) return parsed;
+  }
+  return null;
+}
+
+/** Read to EOF and decode as utf8, for a body such as markdown that is never one JSON object. */
+export function readAllText(io: HookIo): string {
+  const chunks: Uint8Array[] = [];
+  for (let chunk = io.readChunk(); chunk; chunk = io.readChunk()) chunks.push(Uint8Array.from(chunk));
+  return Buffer.concat(chunks).toString("utf8");
+}