@lovrozagar/grunt 0.5.0 → 0.5.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lovrozagar/grunt",
-  "version": "0.5.0",
+  "version": "0.5.2",
   "description": "Multi-agent orchestrator SoT — deep-merge rulesync trees, product scripts, and generate pipeline into a consumer repo",
   "keywords": [
     "agents",
@@ -34,8 +34,10 @@
     "scripts/hooks-union.mjs",
     "scripts/pipeline.mjs",
     "scripts/grunt-job.mjs",
+    "scripts/grunt-config.mjs",
     "scripts/parse-need.mjs",
     "scripts/persist-handoff.mjs",
+    "scripts/persist-tmp.mjs",
     "scripts/persist-plan.mjs",
     "scripts/purge-global-mcps.mjs",
     "scripts/scrub-spawn-prompt.mjs",
@@ -77,6 +79,11 @@
     "sync:globals:apply": "node scripts/sync-global-settings.mjs --apply",
     "purge:global-mcps": "node scripts/purge-global-mcps.mjs",
     "purge:global-mcps:apply": "node scripts/purge-global-mcps.mjs --apply",
+    "antigravity": "antigravity --dangerously-skip-permissions",
+    "claude": "claude --dangerously-skip-permissions",
+    "codex": "codex --dangerously-bypass-approvals-and-sandbox",
+    "gemini": "gemini --yolo",
+    "grok": "grok --yolo",
     "test": "vitest run --coverage"
   },
   "devDependencies": {

package/scripts/gate-fat-tools.mjs

@@ -439,7 +439,7 @@ function resolveWriteAbs(filePath, workspaceRoot) {
 
 function isUnderPlansDir(abs, workspaceRoot) {
   if (!abs || !workspaceRoot) return false;
-  const dir = path.resolve(workspaceRoot, ".tmp", "plans");
+  const dir = path.resolve(workspaceRoot, ".tmp", "grunt", "plans");
   if (abs === dir) return true;
   const rel = path.relative(dir, abs);
   return rel !== "" && !rel.startsWith("..") && !path.isAbsolute(rel);
@@ -487,7 +487,7 @@ function inProgressStatus(text) {
 }
 
 function loadInProgressPlans(workspaceRoot) {
-  const dir = path.resolve(workspaceRoot, ".tmp", "plans");
+  const dir = path.resolve(workspaceRoot, ".tmp", "grunt", "plans");
   let names;
   try {
     names = fs.readdirSync(dir);

package/scripts/grunt-config.mjs

@@ -0,0 +1,50 @@
+/** Load leftoverGate + spawnMode from `.rulesync/grunt.config.jsonc`. leftover fail-closed `"ask"`; spawn fail-closed `"cascade"`. Keys independent. */
+import fs from "node:fs";
+import path from "node:path";
+
+export const CONFIG_REL = ".rulesync/grunt.config.jsonc";
+export const LEFTOVER_GATES = new Set(["auto", "ask"]);
+export const SPAWN_MODES = new Set(["solo", "cascade"]);
+
+export function stripJsonc(text) {
+  return String(text ?? "")
+    .replace(/\/\*[\s\S]*?\*\//g, "")
+    .replace(/\/\/.*$/gm, "");
+}
+
+function readConfigObject(workspaceRoot) {
+  if (!workspaceRoot) return null;
+  const raw = fs.readFileSync(path.join(workspaceRoot, CONFIG_REL), "utf8");
+  const obj = JSON.parse(stripJsonc(raw));
+  if (!obj || typeof obj !== "object" || Array.isArray(obj)) return null;
+  if (obj.version !== 1) return null;
+  return obj;
+}
+
+/** @returns {"auto"|"ask"} */
+export function loadLeftoverGate(workspaceRoot) {
+  try {
+    const obj = readConfigObject(workspaceRoot);
+    if (!obj) return "ask";
+    if (obj.leftoverGate === "auto" || obj.leftoverGate === "ask") {
+      return obj.leftoverGate;
+    }
+    return "ask";
+  } catch {
+    return "ask";
+  }
+}
+
+/** @returns {"solo"|"cascade"} */
+export function loadSpawnMode(workspaceRoot) {
+  try {
+    const obj = readConfigObject(workspaceRoot);
+    if (!obj) return "cascade";
+    if (obj.spawnMode === "solo" || obj.spawnMode === "cascade") {
+      return obj.spawnMode;
+    }
+    return "cascade";
+  } catch {
+    return "cascade";
+  }
+}

package/scripts/persist-plan.mjs

@@ -1,10 +1,24 @@
 #!/usr/bin/env node
-/** Allocate/slugify/validate/write a local plan under .tmp/plans/. */
+/** Allocate/slugify/validate/write a local plan under .tmp/grunt/plans/. */
 import fs from "node:fs";
 import path from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 
-export const PLAN_DIR = ".tmp/plans";
+export const PLAN_DIR = ".tmp/grunt/plans";
+/** One-shot rename source; drop next release. */
+export const LEGACY_PLAN_DIR = ".tmp/plans";
+
+/** If `.tmp/plans` exists and `.tmp/grunt/plans` is missing, rename. Both exist: leave old. */
+export function migrateLegacyPlansDir(workspaceRoot) {
+  const ws = workspaceRoot || process.cwd();
+  const legacy = path.join(ws, LEGACY_PLAN_DIR);
+  const next = path.join(ws, PLAN_DIR);
+  if (fs.existsSync(legacy) && !fs.existsSync(next)) {
+    fs.mkdirSync(path.dirname(next), { recursive: true });
+    fs.renameSync(legacy, next);
+  }
+  return next;
+}
 /** Old unstamped names and new `{serial}-{slug}-{YYYYMMDDTHHMMSSZ}.md`. */
 export const FILENAME_RE =
   /^[0-9]+-[a-z0-9]+(-[a-z0-9]+)*(-\d{8}T\d{6}Z)?\.md$/;
@@ -237,6 +251,7 @@ export function persistPlan({
     source ||
     (raw.match(/^\s*source:\s*(.+)$/m) ? undefined : planName);
   const body = stripPlanName(raw);
+  migrateLegacyPlansDir(ws);
   const plansDir = path.join(ws, PLAN_DIR);
   fs.mkdirSync(plansDir, { recursive: true });
   const createdAt =

package/scripts/persist-tmp.mjs

@@ -0,0 +1,123 @@
+#!/usr/bin/env node
+/** Allocate/slugify/write a one-off convo artifact under .tmp/grunt/. */
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import {
+  DATETIME_RE,
+  compactCreatedStamp,
+  ensureGitignore,
+  slugify,
+  utcDateTime,
+} from "./persist-plan.mjs";
+
+export const TMP_DIR = ".tmp/grunt";
+/** `{serial}-{slug}-{YYYYMMDDTHHMMSSZ}.{ext}`; stamp required. */
+export const FILENAME_RE =
+  /^[1-9][0-9]*-[a-z0-9]+(-[a-z0-9]+)*-\d{8}T\d{6}Z\.[a-z0-9]+$/;
+export const FILENAME_STAMP_RE = /-\d{8}T\d{6}Z$/;
+const META_LINE_RE = /^\s*TMP_(NAME|EXT):\s*.+\s*$/;
+const NAME_RE = /^\s*TMP_NAME:\s*(.+?)\s*$/m;
+const EXT_RE = /^\s*TMP_EXT:\s*(.+?)\s*$/m;
+
+export function extractTmpName(content) {
+  const m = String(content).match(NAME_RE);
+  return m ? m[1].trim() : "";
+}
+
+export function extractTmpExt(content) {
+  const m = String(content).match(EXT_RE);
+  return m ? m[1].trim() : "";
+}
+
+export function stripTmpMeta(content) {
+  return String(content)
+    .replace(/^\uFEFF/, "")
+    .split(/\r?\n/)
+    .filter((line) => !META_LINE_RE.test(line))
+    .join("\n");
+}
+
+export function normalizeTmpExt(raw) {
+  let e = String(raw || "")
+    .trim()
+    .toLowerCase();
+  if (e.startsWith(".")) e = e.slice(1);
+  if (!/^[a-z0-9]+$/.test(e) || e.length > 16) return "";
+  return e;
+}
+
+function nextTmpSerial(dir) {
+  let next = 1;
+  if (!fs.existsSync(dir)) return next;
+  for (const ent of fs.readdirSync(dir, { withFileTypes: true })) {
+    if (!ent.isFile()) continue;
+    const m = ent.name.match(/^([0-9]+)-/);
+    if (!m) continue;
+    const n = parseInt(m[1], 10);
+    if (Number.isFinite(n) && n >= next) next = n + 1;
+  }
+  return next;
+}
+
+export function persistTmp({ workspaceRoot, content, created } = {}) {
+  const ws = workspaceRoot || process.cwd();
+  const raw = String(content || "");
+  if (raw.includes("\0")) return { ok: false, error: "binary" };
+  const name = extractTmpName(raw);
+  if (!name) return { ok: false, error: "missing TMP_NAME" };
+  const extRaw = extractTmpExt(raw);
+  const ext = extRaw ? normalizeTmpExt(extRaw) : "md";
+  if (!ext) return { ok: false, error: "ext" };
+  const slug = slugify(name);
+  const body = stripTmpMeta(raw);
+  const dir = path.join(ws, TMP_DIR);
+  fs.mkdirSync(dir, { recursive: true });
+  const createdAt = created && DATETIME_RE.test(created) ? created : utcDateTime();
+  const stamp = compactCreatedStamp(createdAt);
+  let serial = nextTmpSerial(dir);
+  let filename = `${serial}-${slug}-${stamp}.${ext}`;
+  let dest = path.join(dir, filename);
+  let tries = 0;
+  while (fs.existsSync(dest) && tries < 5) {
+    serial += 1;
+    filename = `${serial}-${slug}-${stamp}.${ext}`;
+    dest = path.join(dir, filename);
+    tries += 1;
+  }
+  if (fs.existsSync(dest)) return { ok: false, error: "serial collision" };
+  if (!FILENAME_RE.test(filename)) return { ok: false, error: "filename" };
+  ensureGitignore(ws);
+  fs.writeFileSync(dest, body);
+  return { ok: true, path: dest, serial, slug, ext, content: body, filename };
+}
+
+function main() {
+  try {
+    const wsIdx = process.argv.indexOf("--workspace");
+    const workspaceRoot = wsIdx >= 0 ? process.argv[wsIdx + 1] : process.cwd();
+    const content = fs.readFileSync(0, "utf8");
+    const result = persistTmp({ workspaceRoot, content });
+    if (!result.ok) {
+      process.stderr.write((result.error || "invalid tmp") + "\n");
+      return 1;
+    }
+    process.stdout.write(
+      JSON.stringify({
+        serial: result.serial,
+        path: result.path,
+        filename: result.filename,
+      }) + "\n",
+    );
+    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/scrub-spawn-prompt.mjs

@@ -90,7 +90,7 @@ export function workspaceRootOf(data) {
 export function spawnCapReason(workspaceRoot) {
   const root = workspaceRoot || process.cwd() || "";
   return (
-    `spawn prompt exceeds ${MAX_PROMPT_CHARS} chars after scrub; write it under ${root}/.tmp/plans/ and re-spawn with that abs path`
+    `spawn prompt exceeds ${MAX_PROMPT_CHARS} chars after scrub; write it under ${root}/.tmp/grunt/plans/ and re-spawn with that abs path`
   );
 }