@lovrozagar/grunt 0.2.0 → 0.3.1

package/scripts/emit-gemini.mjs

@@ -0,0 +1,219 @@
+#!/usr/bin/env node
+/** Emit Gemini CLI GEMINI.md + .gemini/agents from .rulesync/subagents. */
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+export const AGENT_IDS = ["orchestrator", "implementer", "thinker", "grunt"];
+const SSOT_REL = ".rulesync/subagents";
+const GEMINI_MD_REL = "GEMINI.md";
+const AGENTS_REL = ".gemini/agents";
+const GEMINI_MD_BODY = "@AGENTS.md\n";
+
+function isPlainObject(v) {
+  return v != null && typeof v === "object" && !Array.isArray(v);
+}
+
+export function parseArgv(argv) {
+  const args = Array.isArray(argv) ? argv : [];
+  let check = false;
+  for (const a of args) {
+    if (a === "--check") {
+      check = true;
+      continue;
+    }
+    return { ok: false, error: `unknown flag: ${a}` };
+  }
+  return { ok: true, check };
+}
+
+function unquoteYaml(raw) {
+  const s = String(raw).trim();
+  if (s.length >= 2 && s[0] === '"' && s[s.length - 1] === '"') {
+    try {
+      return JSON.parse(s);
+    } catch {
+      return s.slice(1, -1);
+    }
+  }
+  if (s.length >= 2 && s[0] === "'" && s[s.length - 1] === "'") {
+    return s.slice(1, -1).replace(/''/g, "'");
+  }
+  return s;
+}
+
+function yamlScalar(v) {
+  const s = String(v);
+  if (s === "") return '""';
+  if (/^[A-Za-z0-9_./+-]+$/.test(s)) return s;
+  return JSON.stringify(s);
+}
+
+function splitFrontmatter(text) {
+  const src = String(text ?? "");
+  if (!src.startsWith("---")) return { ok: false, error: "missing frontmatter" };
+  const rest = src.slice(3).replace(/^\r?\n/, "");
+  const m = rest.match(/\r?\n---\s*(?:\r?\n|$)/);
+  if (!m || m.index == null) return { ok: false, error: "missing frontmatter close" };
+  return { ok: true, fm: rest.slice(0, m.index), body: rest.slice(m.index + m[0].length) };
+}
+
+function parseYamlBlock(fm) {
+  const top = {};
+  let cur = null;
+  for (const line of String(fm).split(/\r?\n/)) {
+    if (!line.trim() || /^\s*#/.test(line)) continue;
+    const nested = line.match(/^([ \t]+)([^:#\s][^:]*):\s*(.*?)\s*$/);
+    if (nested && cur) {
+      const key = nested[2].trim();
+      const val = nested[3];
+      if (!isPlainObject(top[cur])) top[cur] = {};
+      if (val !== "") top[cur][key] = unquoteYaml(val);
+      continue;
+    }
+    const topm = line.match(/^([^:#\s][^:]*):\s*(.*?)\s*$/);
+    if (topm && !/^[ \t]/.test(line)) {
+      const key = topm[1].trim();
+      const val = topm[2];
+      cur = key;
+      top[key] = val === "" ? {} : unquoteYaml(val);
+    }
+  }
+  return top;
+}
+
+function geminiModel(parsed) {
+  if (parsed["geminicli.model"] != null && parsed["geminicli.model"] !== "") {
+    return String(parsed["geminicli.model"]);
+  }
+  if (isPlainObject(parsed.geminicli) && parsed.geminicli.model != null && parsed.geminicli.model !== "") {
+    return String(parsed.geminicli.model);
+  }
+  return null;
+}
+
+function readText(abs) {
+  try {
+    return fs.readFileSync(abs, "utf8");
+  } catch (err) {
+    if (err && err.code === "ENOENT") return null;
+    throw err;
+  }
+}
+
+function lstat(abs) {
+  try {
+    return fs.lstatSync(abs);
+  } catch (err) {
+    if (err && err.code === "ENOENT") return null;
+    throw err;
+  }
+}
+
+function agentMarkdown(name, description, model, body) {
+  const fm = ["---", `name: ${yamlScalar(name)}`, `description: ${yamlScalar(description)}`, `model: ${yamlScalar(model)}`, "---"].join(
+    "\n",
+  );
+  const b = body.endsWith("\n") || body === "" ? body : `${body}\n`;
+  return `${fm}\n${b}`;
+}
+
+function collisionRel(id) {
+  return path.join(AGENTS_REL, `${id}.md`);
+}
+
+function ownedRel(id) {
+  return path.join(AGENTS_REL, id, "agent.md");
+}
+
+export function emitGemini({ workspaceRoot, check = false } = {}) {
+  const ws = workspaceRoot || process.cwd();
+  const collisions = [];
+  for (const id of AGENT_IDS) {
+    const flat = path.join(ws, collisionRel(id));
+    const dir = path.join(ws, AGENTS_REL, id);
+    const stFlat = lstat(flat);
+    if (stFlat && stFlat.isFile()) collisions.push(collisionRel(id));
+    const stDir = lstat(dir);
+    if (stDir && stDir.isFile()) collisions.push(path.join(AGENTS_REL, id));
+  }
+  if (collisions.length) {
+    return {
+      ok: false,
+      check,
+      error: `collision: ${collisions.join(", ")}`,
+      collisions,
+    };
+  }
+
+  const files = [{ rel: GEMINI_MD_REL, text: GEMINI_MD_BODY }];
+  for (const id of AGENT_IDS) {
+    const ssotAbs = path.join(ws, SSOT_REL, `${id}.md`);
+    const raw = readText(ssotAbs);
+    if (raw == null) {
+      return { ok: false, check, error: `missing ${path.join(SSOT_REL, `${id}.md`)}` };
+    }
+    const split = splitFrontmatter(raw);
+    if (!split.ok) {
+      return { ok: false, check, error: `${id}: ${split.error}` };
+    }
+    const parsed = parseYamlBlock(split.fm);
+    const model = geminiModel(parsed);
+    if (!model) {
+      return { ok: false, check, error: `${id}: missing geminicli.model` };
+    }
+    const name = parsed.name != null && parsed.name !== "" ? String(parsed.name) : id;
+    const description = parsed.description != null ? String(parsed.description) : "";
+    files.push({
+      rel: ownedRel(id),
+      text: agentMarkdown(name, description, model, split.body),
+    });
+  }
+
+  if (check) {
+    const drift = [];
+    for (const f of files) {
+      const disk = readText(path.join(ws, f.rel));
+      if (disk !== f.text) drift.push(f.rel);
+    }
+    if (drift.length) {
+      return { ok: false, check: true, error: `drift: ${drift.join(", ")}`, drift };
+    }
+    return { ok: true, check: true, drift: [] };
+  }
+
+  for (const f of files) {
+    const abs = path.join(ws, f.rel);
+    fs.mkdirSync(path.dirname(abs), { recursive: true });
+    fs.writeFileSync(abs, f.text);
+  }
+  return { ok: true, check: false };
+}
+
+function main() {
+  try {
+    const parsed = parseArgv(process.argv.slice(2));
+    if (!parsed.ok) {
+      process.stderr.write((parsed.error || "invalid argv") + "\n");
+      return 1;
+    }
+    const result = emitGemini({
+      workspaceRoot: process.cwd(),
+      check: parsed.check,
+    });
+    if (!result.ok) {
+      process.stderr.write((result.error || "emit failed") + "\n");
+      return 1;
+    }
+    return 0;
+  } catch (err) {
+    process.stderr.write(String(err && err.message ? err.message : err) + "\n");
+    return 1;
+  }
+}
+
+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/emit-mcp-policy.mjs

@@ -11,6 +11,7 @@ const CLAUDE_SETTINGS_REL = ".claude/settings.json";
 const MCP_JSON_REL = ".mcp.json";
 const CODEX_REL = ".codex/config.toml";
 const AGENTS_MCP_REL = ".agents/mcp_config.json";
+const GEMINI_SETTINGS_REL = ".gemini/settings.json";
 const AGENT_IDS = ["orchestrator", "implementer", "thinker", "grunt"];
 const MCP_DENY = "mcp__*";
 const AGENT_ORCHESTRATOR_DENY = "Agent(orchestrator)";
@@ -276,6 +277,17 @@ function desiredAgentsMcp(policy) {
   return { mcpServers: pickServers(policy.servers, policy.allow) };
 }
 
+function desiredGeminiSettings(disk, policy) {
+  const obj = isPlainObject(disk) ? { ...disk } : {};
+  obj.mcpServers = pickServers(policy.servers, policy.allow);
+  return obj;
+}
+
+function geminiCheckOk(disk, desired) {
+  if (!isPlainObject(disk)) return false;
+  return deepEqual(disk.mcpServers, desired.mcpServers);
+}
+
 function grokCheckOk(disk, desired, policy) {
   if (!isPlainObject(disk)) return false;
   if (Object.prototype.hasOwnProperty.call(disk, "features")) return false;
@@ -337,24 +349,28 @@ export function emitMcpPolicy({ workspaceRoot, check = false } = {}) {
   const mcpAbs = path.join(ws, MCP_JSON_REL);
   const codexAbs = path.join(ws, CODEX_REL);
   const agentsAbs = path.join(ws, AGENTS_MCP_REL);
+  const geminiAbs = path.join(ws, GEMINI_SETTINGS_REL);
 
   const grokRaw = readText(grokAbs);
   const claudeRaw = readText(claudeAbs);
   const mcpRaw = readText(mcpAbs);
   const codexRaw = readText(codexAbs);
   const agentsRaw = readText(agentsAbs);
+  const geminiRaw = readText(geminiAbs);
 
   const grokDisk = parseTomlFile(grokRaw, {});
   const claudeDisk = parseJsonFile(claudeRaw, {});
   const mcpDisk = mcpRaw == null ? null : parseJsonFile(mcpRaw, {});
   const codexDisk = parseTomlFile(codexRaw, {});
   const agentsDisk = agentsRaw == null ? null : parseJsonFile(agentsRaw, {});
+  const geminiDisk = geminiRaw == null ? null : parseJsonFile(geminiRaw, {});
 
   const grokDesired = desiredGrok(grokDisk, policy);
   const claudeDesired = desiredClaudeSettings(claudeDisk, policy);
   const mcpDesired = desiredMcpJson(policy);
   const codexDesired = desiredCodex(codexDisk, policy);
   const agentsDesired = desiredAgentsMcp(policy);
+  const geminiDesired = desiredGeminiSettings(geminiDisk, policy);
 
   if (check) {
     const drift = [];
@@ -371,6 +387,7 @@ export function emitMcpPolicy({ workspaceRoot, check = false } = {}) {
         : !Object.prototype.hasOwnProperty.call(codexDisk, "mcp_servers"));
     if (!codexOk) drift.push(CODEX_REL);
     if (agentsDisk == null || !deepEqual(agentsDisk, agentsDesired)) drift.push(AGENTS_MCP_REL);
+    if (geminiDisk == null || !geminiCheckOk(geminiDisk, geminiDesired)) drift.push(GEMINI_SETTINGS_REL);
     if (drift.length) {
       return { ok: false, check: true, error: `drift: ${drift.join(", ")}`, drift };
     }
@@ -409,6 +426,12 @@ export function emitMcpPolicy({ workspaceRoot, check = false } = {}) {
     nextText: jsonOut(agentsDesired),
     diskRaw: agentsRaw,
   });
+  writeOrCheck({
+    check: false,
+    abs: geminiAbs,
+    nextText: jsonOut(geminiDesired),
+    diskRaw: geminiRaw,
+  });
   return { ok: true, check: false };
 }
 

package/scripts/gate-fat-tools.mjs

@@ -42,6 +42,14 @@ const READ_TOOLS = new Set(["read", "readfile"]);
 const GREP_TOOLS = new Set(["grep", "grepsearch"]);
 const GLOB_TOOLS = new Set(["glob", "listdir"]);
 const BASH_TOOLS = new Set(["bash", "runterminalcommand"]);
+const WRITE_TOOLS = new Set(["write", "edit", "searchreplace"]);
+const WRITE_PATH_FIELDS = [
+  "path",
+  "file_path",
+  "filePath",
+  "target_file",
+  "targetFile",
+];
 const PATH_FIELDS = [
   "path",
   "file_path",
@@ -124,6 +132,47 @@ export function hookResponse(updated) {
   };
 }
 
+export function rewriteGruntScratchPath(filePath, workspaceRoot) {
+  if (filePath == null) return null;
+  const raw = String(filePath);
+  if (!raw || !workspaceRoot) return null;
+  const posix = raw.replace(/\\/g, "/");
+  const marker = ".tmp/grunt/";
+  const idx = posix.indexOf(marker);
+  if (idx === -1) return null;
+
+  const wsRoot = path.resolve(workspaceRoot);
+  const absIn = path.isAbsolute(raw)
+    ? path.resolve(raw)
+    : path.resolve(wsRoot, raw);
+  const relWs = path.relative(wsRoot, absIn);
+  if (relWs !== "" && !relWs.startsWith("..") && !path.isAbsolute(relWs)) {
+    return null;
+  }
+
+  const rel = posix.slice(idx + marker.length);
+  if (!rel) return null;
+  if (path.posix.isAbsolute(rel) || rel.startsWith("/")) return null;
+  const relNorm = path.posix.normalize(rel);
+  if (
+    !relNorm ||
+    relNorm === "." ||
+    relNorm === ".." ||
+    relNorm.startsWith("../") ||
+    rel.split("/").includes("..") ||
+    relNorm.split("/").includes("..")
+  ) {
+    return null;
+  }
+  if (path.posix.isAbsolute(relNorm)) return null;
+
+  const destRoot = path.resolve(wsRoot, ".tmp", "grunt");
+  const dest = path.resolve(destRoot, relNorm);
+  const check = path.relative(destRoot, dest);
+  if (!check || check.startsWith("..") || path.isAbsolute(check)) return null;
+  return dest;
+}
+
 export function workspaceRootOf(data) {
   return (
     process.env.GROK_WORKSPACE_ROOT ||
@@ -337,6 +386,21 @@ export function processFatTools(data) {
   const toolKey = eventKey(data.toolName || data.tool_name || "");
   const input = toolInputOf(data);
   if (!input) return null;
+  const isWrite = WRITE_TOOLS.has(toolKey);
+  if (isWrite) {
+    const ws = workspaceRootOf(data);
+    const next = Object.assign({}, input);
+    let changed = false;
+    for (const key of WRITE_PATH_FIELDS) {
+      if (typeof next[key] !== "string" || !next[key]) continue;
+      const dest = rewriteGruntScratchPath(next[key], ws);
+      if (dest && dest !== next[key]) {
+        next[key] = dest;
+        changed = true;
+      }
+    }
+    return changed ? { type: "rewrite", updatedInput: next } : null;
+  }
   const sub = subagentTypeOf(data);
   if (sub === "grunt") return null;