@lovrozagar/grunt 0.1.0

package/scripts/scrub-spawn-prompt.mjs

@@ -0,0 +1,219 @@
+#!/usr/bin/env node
+/** PreToolUse: intent-scrub spawn `prompt`. Fail-open: unchanged/error → empty stdout, exit 0. */
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { scrubText } from "./scrub-text-lib.mjs";
+
+const ALLOWED_TYPES = new Set(["grunt", "implementer", "thinker"]);
+export const MAX_PROMPT_CHARS = 8000;
+export const TRUNCATE_SUFFIX = "…[truncated]";
+/** `router` is a legacy transcript prefix; keep matching it to strip old pastes. */
+const TRANSCRIPT_PREFIX =
+  /^\s*(?:\[(?:orchestrator|router|implementer|thinker|grunt)\]:|Human:|Assistant:)\s*/i;
+const YOU_ARE_SUBAGENT =
+  /^\s*You are (?:grunt|implementer|thinker) subagent\b/;
+const VERDICT_LINE = /^\s*verdict:\s*/;
+
+export function stripTranscripts(text) {
+  const lines = String(text).split(/\n/);
+  const out = [];
+  let keptYouAre = false;
+  for (const line of lines) {
+    if (VERDICT_LINE.test(line)) {
+      out.push(line);
+      continue;
+    }
+    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 extractVerdictBlocks(text) {
+  const rawLines = String(text).split(/\n/);
+  const lines = [];
+  for (const line of rawLines) {
+    const idx = line.search(/(?:^|\s)verdict:\s/);
+    if (idx > 0) {
+      const before = line.slice(0, idx).trimEnd();
+      const after = line.slice(idx).trimStart();
+      if (before) lines.push(before);
+      lines.push(after);
+    } else {
+      lines.push(line);
+    }
+  }
+  const body = [];
+  const blocks = [];
+  let current = null;
+  for (const line of lines) {
+    if (VERDICT_LINE.test(line)) {
+      if (current) blocks.push(current.join("\n"));
+      current = [line];
+      continue;
+    }
+    if (current) {
+      if (current.length < 8) current.push(line);
+      else {
+        blocks.push(current.join("\n"));
+        current = null;
+        body.push(line);
+      }
+      continue;
+    }
+    body.push(line);
+  }
+  if (current) blocks.push(current.join("\n"));
+  return { body: body.join("\n"), blocks };
+}
+
+export function truncatePrompt(text, max = MAX_PROMPT_CHARS) {
+  const s = String(text);
+  if (s.length <= max) return s;
+  const { body, blocks } = extractVerdictBlocks(s);
+  const verdictPart = blocks.length ? "\n" + blocks.join("\n") : "";
+  const budget = max - verdictPart.length - TRUNCATE_SUFFIX.length;
+  const cut = Math.max(0, budget);
+  return body.slice(0, cut) + TRUNCATE_SUFFIX + verdictPart;
+}
+
+const INLINE_TRANSCRIPT =
+  /\s*(?:\[(?:orchestrator|router|implementer|thinker|grunt)\]:|Human:|Assistant:)\s*/gi;
+const EXTRA_YOU_ARE =
+  /\s*You are (?:grunt|implementer|thinker) subagent\b[^.]*\.?/g;
+
+export function stripInlineTranscripts(text) {
+  let s = String(text);
+  const first = s.match(
+    /^\s*You are (?:grunt|implementer|thinker) 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) {
+  let s = stripTranscripts(String(prompt));
+  const extracted = extractVerdictBlocks(s);
+  s = scrubText(extracted.body, { intent: true });
+  s = stripTranscripts(s);
+  s = stripInlineTranscripts(s);
+  const again = extractVerdictBlocks(s);
+  const blocks = extracted.blocks.concat(again.blocks);
+  const verdictPart = blocks.length ? "\n" + blocks.join("\n") : "";
+  const maxCore = Math.max(0, MAX_PROMPT_CHARS - verdictPart.length);
+  let core = again.body;
+  if (core.length > maxCore) {
+    const cut = Math.max(0, maxCore - TRUNCATE_SUFFIX.length);
+    core = core.slice(0, cut) + TRUNCATE_SUFFIX;
+  }
+  return (core + verdictPart).trim();
+}
+
+export function rewriteSpawnToolInput(toolInput, { defaultGrunt = false } = {}) {
+  if (!toolInput || typeof toolInput !== "object" || Array.isArray(toolInput)) {
+    return defaultGrunt ? { subagent_type: "grunt" } : null;
+  }
+
+  const next = Object.assign({}, toolInput);
+  let changed = false;
+
+  if (defaultGrunt) {
+    const cur =
+      toolInput.subagent_type != null
+        ? String(toolInput.subagent_type).trim()
+        : toolInput.subagentType != null
+          ? String(toolInput.subagentType).trim()
+          : "";
+    if (!ALLOWED_TYPES.has(cur)) {
+      next.subagent_type = "grunt";
+      if (Object.prototype.hasOwnProperty.call(toolInput, "subagentType")) {
+        next.subagentType = "grunt";
+      }
+      changed = true;
+    }
+  }
+
+  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 grokDefaultGrunt() {
+  return Boolean(process.env.GROK_HOOK_EVENT);
+}
+
+export function processHookPayload(data) {
+  if (!data || typeof data !== "object" || Array.isArray(data)) return null;
+  let toolInput = data.toolInput;
+  if (toolInput == null) toolInput = data.tool_input;
+  return rewriteSpawnToolInput(toolInput, {
+    defaultGrunt: grokDefaultGrunt(),
+  });
+}
+
+export function hookResponse(updated) {
+  return {
+    hookSpecificOutput: {
+      hookEventName: "PreToolUse",
+      updatedInput: updated,
+    },
+  };
+}
+
+function main() {
+  try {
+    const data = readJsonValue();
+    const updated = processHookPayload(data);
+    if (!updated) return 0;
+    process.stdout.write(JSON.stringify(hookResponse(updated)));
+    return 0;
+  } catch {
+    return 0;
+  }
+}
+
+function readJsonValue() {
+  let buf = Buffer.alloc(0);
+  const tmp = Buffer.alloc(8192);
+  for (;;) {
+    let n;
+    try {
+      n = fs.readSync(0, tmp, 0, tmp.length, null);
+    } catch {
+      break;
+    }
+    if (n === 0) break;
+    buf = Buffer.concat([buf, tmp.subarray(0, n)]);
+    try {
+      return JSON.parse(buf.toString("utf8"));
+    } catch {
+      // incomplete
+    }
+  }
+  if (!buf.length) return undefined;
+  try {
+    return JSON.parse(buf.toString("utf8"));
+  } catch {
+    return undefined;
+  }
+}
+
+const thisFile = fileURLToPath(import.meta.url);
+const invoked = process.argv[1] ? path.resolve(process.argv[1]) : "";
+if (invoked === thisFile || import.meta.url === pathToFileURL(invoked).href) {
+  process.exit(main());
+}

package/scripts/scrub-text

@@ -0,0 +1,58 @@
+#!/usr/bin/env node
+
+import fs from "node:fs";
+import {
+  parseArgs,
+  autoMd,
+  scrubText,
+  helpText,
+  decodeUtf8,
+} from "./scrub-text-lib.mjs";
+
+function readInputs(files) {
+  if (!files.length) {
+    try {
+      return decodeUtf8(fs.readFileSync(0), "stdin");
+    } catch (e) {
+      process.stderr.write(`scrub-text: ${e.message}\n`);
+      process.exit(1);
+    }
+  }
+  const chunks = [];
+  for (const f of files) {
+    try {
+      chunks.push(decodeUtf8(fs.readFileSync(f), f));
+    } catch (e) {
+      process.stderr.write(`scrub-text: ${e.message}\n`);
+      process.exit(1);
+    }
+  }
+  return chunks.join("\n");
+}
+
+function emit(text) {
+  if (!text) return;
+  process.stdout.write(text);
+  if (!text.endsWith("\n")) process.stdout.write("\n");
+}
+
+export function main(argv) {
+  const args = parseArgs(argv);
+  if (args.unknown.length && !args.help) {
+    process.stderr.write(
+      "usage: scrub-text [--help] [--intent] [--md] [--no-md] [FILE ...]\n" +
+        `scrub-text: error: unrecognized arguments: ${args.unknown.join(" ")}\n`,
+    );
+    process.exit(2);
+  }
+  if (args.help) {
+    process.stdout.write(helpText());
+    return 0;
+  }
+  const md = autoMd(args.files, args.md, args.noMd);
+  const raw = readInputs(args.files);
+  emit(scrubText(raw, { md, intent: args.intent }));
+  return 0;
+}
+
+process.exit(main(process.argv.slice(2)));

package/scripts/scrub-text-lib.mjs

@@ -0,0 +1,210 @@
+import path from "node:path";
+
+export const MD_SUFFIXES = new Set([".md", ".markdown"]);
+const FENCE_RE = /^( {0,3})(`{3,}|~{3,})/;
+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.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;
+const decoder = new TextDecoder("utf-8", { fatal: true });
+
+export function helpText() {
+  return `Usage: scrub-text [--intent] [--md] [--no-md] [FILE...]
+Normalize UTF-8 text for agents. Reads stdin if no FILE.
+
+  --intent   One-line paste: drop blanks; strip filler (please / can you /
+             i want / make me a / to , …). Typos kept; no spellcheck.
+  --md       Markdown-aware (preserve fences, headings, lists)
+  --no-md    Disable auto --md for .md/.markdown files
+  -h, --help This help
+
+Default: UTF-8, newlines to \\n, strip trailing whitespace, collapse extra
+blank lines and (plain text) internal whitespace. .md/.markdown files enable
+--md unless --no-md.
+
+Not RTK (shell stdout). Use this for user paste and markdown files.
+`;
+}
+
+export function parseArgs(argv) {
+  const args = {
+    help: false,
+    intent: false,
+    md: false,
+    noMd: false,
+    files: [],
+    unknown: [],
+  };
+  let i = 0;
+  while (i < argv.length) {
+    const a = argv[i];
+    if (a === "--") {
+      args.files.push(...argv.slice(i + 1));
+      break;
+    }
+    if (a === "--help" || a === "-h") {
+      args.help = true;
+    } else if (a === "--intent") {
+      args.intent = true;
+    } else if (a === "--md") {
+      args.md = true;
+    } else if (a === "--no-md") {
+      args.noMd = true;
+    } else if (a.startsWith("-") && a !== "-") {
+      args.unknown.push(a);
+    } else {
+      args.files.push(a);
+    }
+    i += 1;
+  }
+  return args;
+}
+
+export function decodeUtf8(data, label) {
+  try {
+    return decoder.decode(data);
+  } catch (e) {
+    throw new Error(`${label}: ${e.message}`);
+  }
+}
+
+export function autoMd(files, forceMd, noMd) {
+  if (noMd) return false;
+  if (forceMd) return true;
+  if (!files.length) return false;
+  return files.every((f) => MD_SUFFIXES.has(path.extname(f).toLowerCase()));
+}
+
+export function normalizeNewlines(text) {
+  return text.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+}
+
+export function collapseBlankRuns(lines, maxBlank) {
+  const out = [];
+  let blanks = 0;
+  for (const line of lines) {
+    if (line === "") {
+      blanks += 1;
+      if (blanks <= maxBlank) out.push("");
+    } else {
+      blanks = 0;
+      out.push(line);
+    }
+  }
+  return out;
+}
+
+export function trimEdgeBlanks(lines) {
+  let start = 0;
+  let end = lines.length;
+  while (start < end && lines[start] === "") start += 1;
+  while (end > start && lines[end - 1] === "") end -= 1;
+  return lines.slice(start, end);
+}
+
+export function collapseInternalWs(line) {
+  return line.replace(WS_RUN, " ").trim();
+}
+
+export function fenceMatch(line) {
+  return line.match(FENCE_RE);
+}
+
+export function normalizePlain(text) {
+  text = normalizeNewlines(text);
+  let lines = text.split("\n").map((ln) => collapseInternalWs(ln.replace(/[ \t]+$/g, "")));
+  lines = collapseBlankRuns(lines, 1);
+  lines = trimEdgeBlanks(lines);
+  const nonempty = lines.filter((ln) => ln);
+  if (nonempty.length && nonempty.every((ln) => ln.length <= 80)) {
+    lines = nonempty;
+  }
+  return lines.join("\n");
+}
+
+export function normalizeMd(text) {
+  text = normalizeNewlines(text);
+  const rawLines = text.split("\n");
+  const out = [];
+  let fenceMarker = null;
+  for (const line of rawLines) {
+    if (fenceMarker !== null) {
+      out.push(line);
+      const m = fenceMatch(line);
+      if (
+        m &&
+        m[2][0] === fenceMarker[0] &&
+        m[2].length >= fenceMarker.length
+      ) {
+        fenceMarker = null;
+      }
+      continue;
+    }
+    const m = fenceMatch(line);
+    if (m) {
+      fenceMarker = m[2];
+      out.push(line.replace(/[ \t]+$/g, ""));
+      continue;
+    }
+    out.push(line.replace(/[ \t]+$/g, ""));
+  }
+  return trimEdgeBlanks(collapseBlankRuns(out, 2)).join("\n");
+}
+
+export function stripFiller(text) {
+  let prev = 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;
+}
+
+export function intentMode(text) {
+  const lines = text
+    .split("\n")
+    .map((ln) => ln.trim())
+    .filter(Boolean);
+  const joined = lines.join(" ").replace(WS_RUN, " ").trim();
+  return stripFiller(joined);
+}
+
+export function scrubText(raw, { md = false, intent = false } = {}) {
+  let text = md ? normalizeMd(raw) : normalizePlain(raw);
+  if (intent) text = intentMode(text);
+  return text;
+}