@lovrozagar/grunt 0.1.0 → 0.3.0

package/scripts/emit-agent-shell-tools.mjs

@@ -0,0 +1,118 @@
+#!/usr/bin/env node
+/** After rulesync subagent emit: Claude grunt body uses Bash; other targets keep run_terminal_command. */
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+export const SSOT_REL = ".rulesync/subagents/grunt.md";
+export const CLAUDE_GRUNT_REL = ".claude/agents/grunt.md";
+
+export const GENERIC_TOOL_LIST =
+  "read_file, grep, list_dir, run_terminal_command, write, search_replace, web_search, web_fetch";
+export const CLAUDE_TOOL_LIST = "Read, Grep, Glob, Bash, Write, Edit, Web";
+
+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 };
+}
+
+export 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) };
+}
+
+export function toClaudeShellBody(body) {
+  return String(body)
+    .split(GENERIC_TOOL_LIST)
+    .join(CLAUDE_TOOL_LIST)
+    .split("web_search/web_fetch")
+    .join("WebSearch/WebFetch")
+    .split("run_terminal_command")
+    .join("Bash");
+}
+
+function readText(abs) {
+  try {
+    return fs.readFileSync(abs, "utf8");
+  } catch (err) {
+    if (err && err.code === "ENOENT") return null;
+    throw err;
+  }
+}
+
+function joinMarkdown(fm, body) {
+  const b = body.endsWith("\n") || body === "" ? body : `${body}\n`;
+  return `---\n${fm}\n---\n${b}`;
+}
+
+export function emitAgentShellTools({ workspaceRoot, check = false } = {}) {
+  const ws = workspaceRoot || process.cwd();
+  const ssotAbs = path.join(ws, SSOT_REL);
+  const claudeAbs = path.join(ws, CLAUDE_GRUNT_REL);
+  const ssotRaw = readText(ssotAbs);
+  if (ssotRaw == null) {
+    return { ok: false, check, error: `missing ${SSOT_REL}` };
+  }
+  const ssot = splitFrontmatter(ssotRaw);
+  if (!ssot.ok) {
+    return { ok: false, check, error: `ssot: ${ssot.error}` };
+  }
+  const claudeRaw = readText(claudeAbs);
+  if (claudeRaw == null) {
+    return { ok: false, check, error: `missing ${CLAUDE_GRUNT_REL}` };
+  }
+  const claude = splitFrontmatter(claudeRaw);
+  if (!claude.ok) {
+    return { ok: false, check, error: `claude grunt: ${claude.error}` };
+  }
+  const next = joinMarkdown(claude.fm, toClaudeShellBody(ssot.body));
+  if (check) {
+    if (claudeRaw !== next) {
+      return { ok: false, check: true, error: `drift: ${CLAUDE_GRUNT_REL}`, drift: [CLAUDE_GRUNT_REL] };
+    }
+    return { ok: true, check: true, drift: [] };
+  }
+  fs.mkdirSync(path.dirname(claudeAbs), { recursive: true });
+  fs.writeFileSync(claudeAbs, next);
+  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 = emitAgentShellTools({
+      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-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,8 +11,10 @@ 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)";
 const GROK_HEADER =
   "# Generated by emit-mcp-policy.mjs from .rulesync/mcp-policy.jsonc.\n";
 
@@ -239,6 +241,12 @@ function desiredClaudeSettings(disk, policy) {
   obj.enabledMcpjsonServers = [...policy.allow];
   const permissions = isPlainObject(obj.permissions) ? { ...obj.permissions } : {};
   const deny = Array.isArray(permissions.deny) ? [...permissions.deny] : [];
+  const hasAgentDeny = deny.some(
+    (s) => typeof s === "string" && s.startsWith("Agent("),
+  );
+  if (hasAgentDeny && !deny.includes(AGENT_ORCHESTRATOR_DENY)) {
+    deny.push(AGENT_ORCHESTRATOR_DENY);
+  }
   if (!deny.includes(MCP_DENY)) deny.push(MCP_DENY);
   permissions.deny = deny;
   obj.permissions = permissions;
@@ -269,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;
@@ -330,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 = [];
@@ -364,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 };
     }
@@ -402,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 };
 }