@lovrozagar/grunt 0.4.0 → 0.4.2

package/scripts/emit-gemini.mjs

@@ -3,6 +3,7 @@
 import fs from "node:fs";
 import path from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
+import { guardedMarkdownDrift, writeMergedGuardedFile } from "../cli/init.mjs";
 
 export const AGENT_IDS = ["orchestrator", "implementer", "thinker", "grunt"];
 const SSOT_REL = ".rulesync/subagents";
@@ -173,6 +174,10 @@ export function emitGemini({ workspaceRoot, check = false } = {}) {
   if (check) {
     const drift = [];
     for (const f of files) {
+      if (f.rel === GEMINI_MD_REL) {
+        if (guardedMarkdownDrift(path.join(ws, f.rel), f.text)) drift.push(f.rel);
+        continue;
+      }
       const disk = readText(path.join(ws, f.rel));
       if (disk !== f.text) drift.push(f.rel);
     }
@@ -185,7 +190,8 @@ export function emitGemini({ workspaceRoot, check = false } = {}) {
   for (const f of files) {
     const abs = path.join(ws, f.rel);
     fs.mkdirSync(path.dirname(abs), { recursive: true });
-    fs.writeFileSync(abs, f.text);
+    if (f.rel === GEMINI_MD_REL) writeMergedGuardedFile(abs, f.text);
+    else fs.writeFileSync(abs, f.text);
   }
   return { ok: true, check: false };
 }

package/scripts/grunt-job.mjs

@@ -4,7 +4,6 @@ import { spawnSync } from "node:child_process";
 import fs from "node:fs";
 import path from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
-import { logTelemetry } from "./telemetry.mjs";
 
 export const FALLBACK = "FALLBACK";
 export const SHELL_META = /[|&;`$(){}<>\n\r]/;
@@ -443,14 +442,12 @@ function main() {
   try {
     const parsed = parseArgv(process.argv.slice(2));
     if (parsed.unknown) {
-      logTelemetry("grunt-job", { fallback: true, query: parsed.query }, process.cwd());
       process.stdout.write(FALLBACK + "\n");
       return 2;
     }
     const ws = process.cwd();
     const cwd = parsed.cwd ? resolveJobCwd(parsed.cwd, ws) : ws;
     if (!cwd) {
-      logTelemetry("grunt-job", { fallback: true, query: parsed.query }, ws);
       process.stdout.write(FALLBACK + "\n");
       return 2;
     }
@@ -461,15 +458,9 @@ function main() {
       path: parsed.path,
       glob: parsed.glob,
     });
-    logTelemetry(
-      "grunt-job",
-      { job: parsed.job, fallback: Boolean(result.fallback), query: parsed.query },
-      ws,
-    );
     process.stdout.write(result.text);
     return result.code;
   } catch {
-    logTelemetry("grunt-job", { fallback: true }, process.cwd());
     process.stdout.write(FALLBACK + "\n");
     return 2;
   }

package/scripts/guarded-roots.mjs

@@ -0,0 +1,83 @@
+#!/usr/bin/env node
+/** Snapshot/remerge AGENTS.md CLAUDE.md GEMINI.md around generate/check/watch. */
+import { execSync } from "node:child_process";
+import fs from "node:fs";
+import { fileURLToPath } from "node:url";
+import path from "node:path";
+import {
+  GUARDED_ROOT_FILES,
+  healGuardedRootFile,
+  remergeGuardedRoots,
+  snapshotGuardedRoots,
+  withGuardedCheckInteriors,
+} from "../cli/init.mjs";
+
+const GENERATE_RAW = "rulesync:generate:raw";
+const CHECK_RAW = "rulesync:check:raw";
+const WATCH_RAW = "rulesync:watch:raw";
+
+export function attachGuardedRootWatchers(cwd, heal) {
+  const w = fs.watch(cwd, (_event, filename) => {
+    if (!filename) return;
+    const base = path.basename(String(filename));
+    if (!GUARDED_ROOT_FILES.includes(base)) return;
+    heal(base);
+  });
+  return () => {
+    try {
+      w.close();
+    } catch {
+      /* ignore */
+    }
+  };
+}
+
+export function runGuardedRoots(mode, { cwd = process.cwd(), exec = execSync, attachWatchers } = {}) {
+  if (mode === "generate") {
+    const snap = snapshotGuardedRoots(cwd);
+    try {
+      exec(`npm run ${GENERATE_RAW}`, { cwd, stdio: "inherit", shell: true });
+    } finally {
+      remergeGuardedRoots(cwd, snap);
+    }
+    return;
+  }
+  if (mode === "check") {
+    withGuardedCheckInteriors(cwd, () => {
+      exec(`npm run ${CHECK_RAW}`, { cwd, stdio: "inherit", shell: true });
+    });
+    return;
+  }
+  if (mode === "watch") {
+    const snap = snapshotGuardedRoots(cwd);
+    const heal = (file) => healGuardedRootFile(cwd, file, snap);
+    const attach = attachWatchers || ((opts) => attachGuardedRootWatchers(opts.cwd, opts.heal));
+    const stop = attach({ cwd, snap, heal });
+    try {
+      exec(`npm run ${WATCH_RAW}`, { cwd, stdio: "inherit", shell: true });
+    } finally {
+      try {
+        stop?.();
+      } catch {
+        /* ignore */
+      }
+      remergeGuardedRoots(cwd, snap);
+    }
+    return;
+  }
+  throw new Error("usage: guarded-roots.mjs generate|check|watch");
+}
+
+function main() {
+  try {
+    runGuardedRoots(process.argv[2] || "");
+    return 0;
+  } catch (err) {
+    process.stderr.write((err && err.message ? err.message : String(err)) + "\n");
+    return 1;
+  }
+}
+
+const thisFile = fileURLToPath(import.meta.url);
+const invoked = process.argv[1] ? path.resolve(process.argv[1]) : "";
+if (invoked === thisFile) process.exit(main());

package/scripts/telemetry.mjs

@@ -1,38 +0,0 @@
-#!/usr/bin/env node
-/** Append-only hook sidecar. Never throws. Never writes stdout. */
-import fs from "node:fs";
-import path from "node:path";
-
-const QUERY_MAX = 120;
-
-export const ORCHESTRATOR_LOGS_DIR = ".tmp/orchestrator-logs";
-
-export function telemetryPath(workspaceRoot) {
-  const root =
-    workspaceRoot ||
-    process.env.GROK_WORKSPACE_ROOT ||
-    process.cwd();
-  return path.join(root, ORCHESTRATOR_LOGS_DIR, "telemetry.ndjson");
-}
-
-function truncateQuery(q) {
-  const s = String(q ?? "");
-  if (s.length <= QUERY_MAX) return s;
-  return s.slice(0, QUERY_MAX);
-}
-
-export function logTelemetry(event, fields, workspaceRoot) {
-  try {
-    const rec = { ts: Date.now(), event: String(event || "") };
-    const src = fields && typeof fields === "object" ? fields : {};
-    for (const [k, v] of Object.entries(src)) {
-      if (k === "query" && v != null) rec.query = truncateQuery(v);
-      else rec[k] = v;
-    }
-    const dest = telemetryPath(workspaceRoot);
-    fs.mkdirSync(path.dirname(dest), { recursive: true });
-    fs.appendFileSync(dest, JSON.stringify(rec) + "\n");
-  } catch {
-    // fail-open
-  }
-}