@workerstack/repo 0.0.0-stage → 0.1.0

package/cli/scripts/scrub-spawn-prompt.ts

@@ -0,0 +1,103 @@
+#!/usr/bin/env bun
+/** PreToolUse: intent-scrub spawn `prompt`. Fail-open: unchanged/error → empty stdout, exit 0. */
+import type { HookInput } from "./hook-input.ts";
+import { processHookIo, readHookInput, type HookIo } from "./hook-io.ts";
+import { resolveRoots } from "./workspace-root.ts";
+import { scrubText } from "./scrub-text-lib.ts";
+import { answerDeny, answerRewrite, type HookOutput } from "./gate-fat-tools.ts";
+
+/** What the hook prints: a deny or a rewrite, in whichever shape the harness takes. */
+export type SpawnAnswer = HookOutput;
+
+export const MAX_PROMPT_CHARS = 100000;
+export const TRUNCATE_SUFFIX = "…[truncated]";
+const TRANSCRIPT_PREFIX = /^\s*(?:\[(?:orchestrator|scout)\]:|Human:|Assistant:)\s*/i;
+const YOU_ARE_SUBAGENT = /^\s*You are scout subagent\b/;
+
+export function stripTranscripts(text: string): string {
+  const lines = String(text).split(/\n/);
+  const out: string[] = [];
+  let keptYouAre = false;
+  for (const line of lines) {
+    if (TRANSCRIPT_PREFIX.test(line)) continue;
+    if (YOU_ARE_SUBAGENT.test(line)) {
+      if (keptYouAre) continue;
+      keptYouAre = true;
+    }
+    out.push(line);
+  }
+  return out.join("\n");
+}
+
+export function spawnCapReason(workspaceRoot?: string) {
+  const root = workspaceRoot || resolveRoots().root;
+  return `spawn prompt exceeds ${MAX_PROMPT_CHARS} chars after scrub; write it under ${root}/.tmp/repo/plans/ and re-spawn with that abs path`;
+}
+
+const INLINE_TRANSCRIPT = /\s*(?:\[(?:orchestrator|scout)\]:|Human:|Assistant:)\s*/gi;
+const EXTRA_YOU_ARE = /\s*You are scout subagent\b[^.]*\.?/g;
+
+export function stripInlineTranscripts(text: string): string {
+  let s = String(text);
+  const first = s.match(/^\s*You are scout subagent\b[^.]*\.?\s*/);
+  const prefix = first ? first[0] : "";
+  let rest = first ? s.slice(first[0].length) : s;
+  rest = rest.replace(INLINE_TRANSCRIPT, " ");
+  rest = rest.replace(EXTRA_YOU_ARE, " ");
+  return (prefix + rest).replace(/[ \t]{2,}/g, " ").trim();
+}
+
+export function capSpawnPrompt(prompt: string): string {
+  let s = stripTranscripts(String(prompt));
+  s = scrubText(s);
+  s = stripTranscripts(s);
+  s = stripInlineTranscripts(s);
+  return s.trim();
+}
+
+export function rewriteSpawnToolInput(toolInput: unknown): Record<string, unknown> | null {
+  if (!isRecord(toolInput)) {
+    return null;
+  }
+
+  const next: Record<string, unknown> = Object.assign({}, toolInput);
+  let changed = false;
+
+  if (typeof next.prompt === "string") {
+    const scrubbed = capSpawnPrompt(next.prompt);
+    if (scrubbed !== next.prompt) {
+      next.prompt = scrubbed;
+      changed = true;
+    }
+  }
+
+  return changed ? next : null;
+}
+
+export function processHookPayload(data: HookInput | null | undefined): SpawnAnswer | null {
+  if (!data || typeof data !== "object" || Array.isArray(data)) return null;
+  let toolInput: unknown = data.toolInput;
+  if (toolInput == null) toolInput = data.tool_input;
+  const updated = rewriteSpawnToolInput(toolInput);
+  // A rewrite only happens for a string prompt, so `updated.prompt` is that string.
+  const prompt = updated?.prompt ?? (isRecord(toolInput) ? toolInput.prompt : undefined);
+  if (typeof prompt === "string" && prompt.length > MAX_PROMPT_CHARS) {
+    return answerDeny(data, spawnCapReason(resolveRoots(data).root));
+  }
+  return updated ? answerRewrite(data, updated) : null;
+}
+
+export function main(_argv: string[] = [], io: HookIo = processHookIo()): number {
+  try {
+    const data = readHookInput(io);
+    const answer = processHookPayload(data);
+    if (answer) io.write(JSON.stringify(answer));
+    return 0;
+  } catch {
+    return 0;
+  }
+}
+
+function isRecord(v: unknown): v is Record<string, unknown> {
+  return v !== null && typeof v === "object" && !Array.isArray(v);
+}

package/cli/scripts/scrub-text-lib.ts

@@ -0,0 +1,58 @@
+const INTENT_PREFIXES = [
+  "can you please",
+  "could you please",
+  "would you please",
+  "can you",
+  "could you",
+  "would you",
+  "please",
+  "i want you to",
+  "i need you to",
+  "i would like you to",
+  "i'd like you to",
+];
+const INTENT_MID: [string, string][] = [
+  [String.raw`\bmake me an\b`, "make"],
+  [String.raw`\bmake me a\b`, "make"],
+  [String.raw`\bmake me\b`, "make"],
+  [String.raw`\bi want the\b`, ""],
+  [String.raw`\bi need the\b`, ""],
+  [String.raw`\bi want a\b`, ""],
+  [String.raw`\bi need a\b`, ""],
+  [String.raw`\bi want\b`, ""],
+  [String.raw`\bi need\b`, ""],
+  [String.raw`\bto\s*,`, ","],
+];
+const FILLER_PREFIX = new RegExp("^(?:" + INTENT_PREFIXES.join("|") + ")\\s+", "i");
+const FILLER_SUFFIX = /\s+(?:thank you|thanks|please)[.!]*\s*$/i;
+const COMMA_WS = /\s*,\s*/g;
+const WS_RUN = /[ \t]+/g;
+
+function normalizeNewlines(text: string): string {
+  return text.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+}
+
+/** One line with the intent filler cut: polite prefixes, trailing thanks, and "make me a" style phrases. */
+export function stripFiller(text: string): string {
+  let prev: string | null = null;
+  while (prev !== text) {
+    prev = text;
+    text = text.replace(FILLER_PREFIX, "").trim();
+    text = text.replace(FILLER_SUFFIX, "").trim();
+    for (const [pat, repl] of INTENT_MID) {
+      text = text.replace(new RegExp(pat, "gi"), repl);
+    }
+    text = text.replace(COMMA_WS, " ");
+    text = text.replace(WS_RUN, " ").trim();
+  }
+  return text;
+}
+
+/** Joins the non-empty lines of `raw` into one line and strips intent filler from it. */
+export function scrubText(raw: string): string {
+  const lines = normalizeNewlines(raw)
+    .split("\n")
+    .map((ln) => ln.trim())
+    .filter(Boolean);
+  return stripFiller(lines.join(" ").replace(WS_RUN, " ").trim());
+}

package/cli/scripts/session-map.ts

@@ -0,0 +1,69 @@
+#!/usr/bin/env bun
+/**
+ * SessionStart hook: inject the code-only folder map as additionalContext.
+ * Logs { rows, tokens } to .tmp/repo/sessions/<sid>/map.json for tuning.
+ * Fail-open: any error, no git, or an empty map → empty stdout, exit 0.
+ */
+import fs from "node:fs";
+import path from "node:path";
+import type { HookInput } from "./hook-input.ts";
+import { processHookIo, readHookInput, type HookIo } from "./hook-io.ts";
+import { resolveRoots } from "./workspace-root.ts";
+import { recordHook } from "./board.ts";
+import { folderMap, type FolderMapResult } from "./folder-map.ts";
+import { resolveRepoBin } from "./gate-fat-tools.ts";
+import { readEnv } from "../env.ts";
+
+/** First line of the injected map; `depth` = levels per package, null when nothing was cut. */
+export function header(depth: number | null | undefined): string {
+  const scope = depth == null ? "complete" : `${depth} levels per package`;
+  return `Folder map (code folders, ${scope}; \`…\` = deeper, run \`bun repo map <dir>\`):`;
+}
+/** Claude Code caps each hook's additionalContext at 10,000 chars; above it, only a 2KB preview stays inline. */
+export const HOOK_CONTEXT_CHARS = 10000;
+// Covers the header (depth is one or two digits) plus slack.
+const RESERVE = header(99).length + 1 + 100;
+
+function logSize(root: string, data: HookInput, out: FolderMapResult): void {
+  const sid = String(data.session_id || data.sessionId || "").replace(/[^\w-]/g, "");
+  if (!sid) return;
+  const dir = path.join(root, ".tmp", "repo", "sessions", sid);
+  fs.mkdirSync(dir, { recursive: true });
+  const size = { rows: out.rows, tokens: out.tokens, depth: out.depth };
+  fs.writeFileSync(path.join(dir, "map.json"), `${JSON.stringify(size)}\n`);
+}
+
+/** The one line a person reads when an uninstalled worktree runs the main checkout's hooks; "" otherwise. */
+export function fallbackNotice(checkout: string): string {
+  const { bin, fallback } = resolveRepoBin(checkout);
+  return fallback
+    ? `repo: hooks run ${bin} (this worktree has no install); run \`bun install\` here to use its own code\n`
+    : "";
+}
+
+/** The SessionStart context: the fallback notice, then the folder map; "" when there is neither. */
+export function sessionContext(notice: string, out: FolderMapResult | null): string {
+  if (!out?.text) return notice;
+  return `${notice}${header(/ {2}…$/m.test(out.text) ? out.depth : null)}\n${out.text}`;
+}
+
+export function main(_argv: string[] = [], io: HookIo = processHookIo()): number {
+  const data = readHookInput(io) ?? {};
+  recordHook(data, readEnv());
+  try {
+    const roots = resolveRoots(data);
+    const notice = fallbackNotice(roots.checkout);
+    const out = folderMap({ root: roots.checkout, maxChars: HOOK_CONTEXT_CHARS - RESERVE - notice.length });
+    const additionalContext = sessionContext(notice, out);
+    if (!additionalContext) return 0;
+    try {
+      if (out?.text) logSize(roots.root, data, out);
+    } catch {
+      // Logging is best-effort; the map still ships.
+    }
+    io.write(JSON.stringify({ hookSpecificOutput: { hookEventName: "SessionStart", additionalContext } }));
+  } catch {
+    // Fail open.
+  }
+  return 0;
+}