@lovrozagar/grunt 0.4.0 → 0.4.2

package/cli/init.mjs

@@ -9,6 +9,7 @@ const PRODUCT_SCRIPTS = [
   "check-globals.mjs",
   "emit-agent-shell-tools.mjs",
   "emit-gemini.mjs",
+  "guarded-roots.mjs",
   "emit-mcp-policy.mjs",
   "gate-fat-tools.mjs",
   "hooks-union.mjs",
@@ -20,7 +21,6 @@ const PRODUCT_SCRIPTS = [
   "scrub-spawn-prompt.mjs",
   "scrub-text-lib.mjs",
   "sync-global-settings.mjs",
-  "telemetry.mjs",
   "browser.mjs",
   "doctor.mjs",
   "scrub-text",
@@ -28,12 +28,16 @@ const PRODUCT_SCRIPTS = [
 
 const COPY_DIRS = [".rulesync", ".grok", ".codex", ".claude", ".agents"]
 const GUARDED_MD_FILES = ["AGENTS.md", "CLAUDE.md"]
+export const GUARDED_ROOT_FILES = ["AGENTS.md", "CLAUDE.md", "GEMINI.md"]
 // .mcp.json is intentionally not copied here: scripts/emit-mcp-policy.mjs
 // (run via `rulesync:generate`, see mergeClaudeSettings ordering) owns and
 // merges it, so a plain-copy would just be clobbered/redundant.
 const OWNED_HOOK_FILES = ["scrub-spawn-prompt.mjs", "gate-fat-tools.mjs", "orchestrate-parent.js"]
-const SENTINEL_BEGIN = "<!-- grunt:begin -->"
-const SENTINEL_END = "<!-- grunt:end -->"
+export const SENTINEL_BEGIN = "<!-- grunt:begin -->"
+export const SENTINEL_END = "<!-- grunt:end -->"
+export const MAX_GUARDED_MARKDOWN_BYTES = 2 * 1024 * 1024
+const GRUNT_REGION_RE = /<!-- grunt:begin -->\r?\n?[\s\S]*?<!-- grunt:end -->\r?\n?/g
+const GRUNT_INTERIOR_RE = /<!-- grunt:begin -->\r?\n?([\s\S]*?)<!-- grunt:end -->/g
 
 function sortKeys(obj) {
   return Object.fromEntries(Object.keys(obj).sort().map((k) => [k, obj[k]]))
@@ -69,43 +73,208 @@ function destHasGruntSentinel(dest) {
 
 export function destAlreadyInited(dest) {
   return (
-    fs.existsSync(path.join(dest, "scripts", "telemetry.mjs")) ||
     fs.existsSync(path.join(dest, ".grok", "hooks", "orchestrate-parent.js")) ||
     fs.existsSync(path.join(dest, ".rulesync"))
   )
 }
 
 export function shouldAutoSkipGlobals(dest) {
-  return destHasGruntSentinel(dest) || fs.existsSync(path.join(dest, "scripts", "telemetry.mjs"))
+  return destHasGruntSentinel(dest)
+}
+
+function detectNewline(text) {
+  return String(text).includes("\r\n") ? "\r\n" : "\n"
+}
+
+function toNewline(text, nl) {
+  return String(text).replace(/\r\n/g, "\n").replace(/\n/g, nl)
+}
+
+function trimTrailingNewlines(text) {
+  return String(text).replace(/(?:\r?\n)+$/, "")
+}
+
+function normEq(a, b) {
+  return trimTrailingNewlines(String(a).replace(/\r\n/g, "\n")) ===
+    trimTrailingNewlines(String(b).replace(/\r\n/g, "\n"))
+}
+
+function cloneRe(re) {
+  return new RegExp(re.source, re.flags)
+}
+
+function inspectGuardedBuffer(buf) {
+  if (buf.length > MAX_GUARDED_MARKDOWN_BYTES) return "huge"
+  if (buf.includes(0)) return "binary"
+  return null
+}
+
+export function extractUserMarkdown(text) {
+  return String(text).replace(cloneRe(GRUNT_REGION_RE), "")
+}
+
+export function extractGruntBody(text) {
+  const parts = []
+  const re = cloneRe(GRUNT_INTERIOR_RE)
+  let m
+  while ((m = re.exec(String(text)))) {
+    parts.push(trimTrailingNewlines(m[1]))
+  }
+  if (!parts.length) return null
+  return parts.join("\n")
+}
+
+function userRemainderIsBlank(user) {
+  return String(user).replace(/\r\n/g, "\n").replace(/\n/g, "") === ""
+}
+
+export function composeGuardedMarkdown(gruntBody, userRemainder, nl = "\n") {
+  const body = toNewline(trimTrailingNewlines(gruntBody), nl)
+  const block = `${SENTINEL_BEGIN}${nl}${body}${nl}${SENTINEL_END}${nl}`
+  const user = userRemainder == null ? "" : String(userRemainder)
+  if (!user || userRemainderIsBlank(user)) return block
+  return block + toNewline(user, nl)
+}
+
+export function mergeGuardedContent(existingText, gruntBody) {
+  const existing = existingText == null ? "" : String(existingText)
+  const nl = existing.includes("\r\n") || String(gruntBody).includes("\r\n")
+    ? detectNewline(existing || gruntBody)
+    : "\n"
+  if (!existing) return composeGuardedMarkdown(gruntBody, "", nl)
+  const hadSentinel = existing.includes(SENTINEL_BEGIN) && existing.includes(SENTINEL_END)
+  const user = extractUserMarkdown(existing)
+  if (!hadSentinel && normEq(existing, gruntBody)) {
+    return composeGuardedMarkdown(gruntBody, "", nl)
+  }
+  return composeGuardedMarkdown(gruntBody, user, nl)
+}
+
+export function writeMergedGuardedFile(destPath, gruntBody) {
+  if (!fs.existsSync(destPath)) {
+    fs.writeFileSync(destPath, mergeGuardedContent("", gruntBody))
+    return
+  }
+  const buf = fs.readFileSync(destPath)
+  if (inspectGuardedBuffer(buf)) return "aborted-unsafe"
+  fs.writeFileSync(destPath, mergeGuardedContent(buf.toString("utf8"), gruntBody))
+}
+
+export function guardedMarkdownDrift(destPath, gruntBody) {
+  if (!fs.existsSync(destPath)) return true
+  const buf = fs.readFileSync(destPath)
+  if (inspectGuardedBuffer(buf)) return true
+  const text = buf.toString("utf8")
+  const interior = extractGruntBody(text)
+  if (interior == null) return !normEq(text, gruntBody)
+  return !normEq(interior, gruntBody)
 }
 
 export function mergeGuardedMarkdown(dest, pkgRoot, file, { alreadyInited = false } = {}) {
+  void alreadyInited
   const src = path.join(pkgRoot, file)
   const d = path.join(dest, file)
   if (samePath(src, d)) return
   const srcText = fs.readFileSync(src, "utf8")
+  return writeMergedGuardedFile(d, srcText)
+}
 
-  if (!fs.existsSync(d)) {
-    fs.writeFileSync(d, `${SENTINEL_BEGIN}\n${srcText}\n${SENTINEL_END}\n`)
-    return
+export function snapshotGuardedRoots(root) {
+  const snap = {}
+  for (const file of GUARDED_ROOT_FILES) {
+    const p = path.join(root, file)
+    if (!fs.existsSync(p)) continue
+    const buf = fs.readFileSync(p)
+    const unsafe = inspectGuardedBuffer(buf)
+    if (unsafe) {
+      snap[file] = { unsafe, rawBuf: buf }
+      continue
+    }
+    const raw = buf.toString("utf8")
+    snap[file] = { raw, user: extractUserMarkdown(raw) }
   }
+  return snap
+}
 
-  const destText = fs.readFileSync(d, "utf8")
-  const hasSentinel = [SENTINEL_BEGIN, SENTINEL_END].every((marker) => destText.includes(marker))
+export function remergeGuardedRoots(root, snap) {
+  for (const file of GUARDED_ROOT_FILES) {
+    const p = path.join(root, file)
+    const rec = snap[file]
+    if (rec?.unsafe) {
+      fs.writeFileSync(p, rec.rawBuf)
+      continue
+    }
+    if (!fs.existsSync(p)) {
+      if (rec?.raw != null) fs.writeFileSync(p, rec.raw)
+      continue
+    }
+    const buf = fs.readFileSync(p)
+    if (inspectGuardedBuffer(buf)) {
+      if (rec?.raw != null) fs.writeFileSync(p, rec.raw)
+      continue
+    }
+    const current = buf.toString("utf8")
+    if (rec && current === rec.raw) continue
+    const gruntBody = extractGruntBody(current) ?? current
+    const nl = detectNewline((rec && rec.raw) || current)
+    let user = rec ? rec.user : extractUserMarkdown(current)
+    if (rec && !rec.raw.includes(SENTINEL_BEGIN) && normEq(rec.raw, gruntBody)) user = ""
+    if (!rec && extractGruntBody(current) == null && normEq(current, gruntBody)) user = ""
+    fs.writeFileSync(p, composeGuardedMarkdown(gruntBody, user, nl))
+  }
+}
 
-  if (!hasSentinel) {
-    if (alreadyInited) return "skipped-side-file"
-    const gruntFile = file.replace(/\.md$/, ".grunt.md")
-    fs.writeFileSync(path.join(dest, gruntFile), srcText)
-    console.log(`${file} exists without grunt sentinel; wrote ${gruntFile} instead (original untouched)`)
+export function healGuardedRootFile(root, file, snap) {
+  if (!GUARDED_ROOT_FILES.includes(file)) return
+  const p = path.join(root, file)
+  const rec = snap[file]
+  if (!fs.existsSync(p)) return
+  if (rec?.unsafe) {
+    fs.writeFileSync(p, rec.rawBuf)
+    return
+  }
+  const buf = fs.readFileSync(p)
+  if (inspectGuardedBuffer(buf)) {
+    if (rec?.raw != null) fs.writeFileSync(p, rec.raw)
     return
   }
+  const current = buf.toString("utf8")
+  const interior = extractGruntBody(current)
+  if (interior != null) {
+    snap[file] = { raw: current, user: extractUserMarkdown(current) }
+    return
+  }
+  if (rec && current === rec.raw) return
+  const gruntBody = current
+  const nl = detectNewline((rec && rec.raw) || current)
+  let user = rec ? rec.user : extractUserMarkdown(current)
+  if (rec && !rec.raw.includes(SENTINEL_BEGIN) && normEq(rec.raw, gruntBody)) user = ""
+  if (!rec && normEq(current, gruntBody)) user = ""
+  const out = composeGuardedMarkdown(gruntBody, user, nl)
+  fs.writeFileSync(p, out)
+  snap[file] = { raw: out, user }
+}
 
-  const beginIdx = destText.indexOf(SENTINEL_BEGIN)
-  const endIdx = destText.indexOf(SENTINEL_END)
-  const before = destText.slice(0, beginIdx)
-  const after = destText.slice(endIdx + SENTINEL_END.length)
-  fs.writeFileSync(d, `${before}${SENTINEL_BEGIN}\n${srcText}\n${SENTINEL_END}${after}`)
+export function withGuardedCheckInteriors(root, fn) {
+  const snap = snapshotGuardedRoots(root)
+  try {
+    for (const file of GUARDED_ROOT_FILES) {
+      const rec = snap[file]
+      if (!rec || rec.unsafe) continue
+      const body = extractGruntBody(rec.raw)
+      if (body == null) continue
+      const nl = detectNewline(rec.raw)
+      fs.writeFileSync(path.join(root, file), `${toNewline(trimTrailingNewlines(body), nl)}${nl}`)
+    }
+    return fn()
+  } finally {
+    for (const file of GUARDED_ROOT_FILES) {
+      const rec = snap[file]
+      if (!rec) continue
+      if (rec.unsafe) fs.writeFileSync(path.join(root, file), rec.rawBuf)
+      else fs.writeFileSync(path.join(root, file), rec.raw)
+    }
+  }
 }
 
 export function mergeClaudeSettings(destRoot, pkgRoot) {
@@ -222,7 +391,6 @@ export function mergePackageJson(dest, pkgRoot) {
 export function init(dest, { pkgRoot: pkgRootOpt, execFileSync: exec = execFileSync, skipGlobals = false, applyGlobals, onPhase } = {}) {
   dest = path.resolve(dest)
   const pkgRoot = path.resolve(pkgRootOpt ?? PKG_ROOT)
-  const alreadyInited = destAlreadyInited(dest)
   const skipGlobalsApply =
     applyGlobals === true ? false : skipGlobals || shouldAutoSkipGlobals(dest)
 
@@ -255,14 +423,8 @@ export function init(dest, { pkgRoot: pkgRootOpt, execFileSync: exec = execFileS
       }
     }
 
-    let skippedSideFile = false
     for (const file of GUARDED_MD_FILES) {
-      if (mergeGuardedMarkdown(dest, pkgRoot, file, { alreadyInited }) === "skipped-side-file") {
-        skippedSideFile = true
-      }
-    }
-    if (skippedSideFile) {
-      console.log("AGENTS.md/CLAUDE.md lack markers and were left alone")
+      mergeGuardedMarkdown(dest, pkgRoot, file)
     }
 
     fs.mkdirSync(path.join(dest, "scripts"), { recursive: true })
@@ -291,9 +453,13 @@ export function init(dest, { pkgRoot: pkgRootOpt, execFileSync: exec = execFileS
     exec("npm", args, { cwd: dest, stdio: "inherit" })
   }
   runNpm("install", ["install"])
+  const guardedSnap = snapshotGuardedRoots(dest)
   runNpm("generate", ["run", "rulesync:generate"])
+  remergeGuardedRoots(dest, guardedSnap)
   if (!skipGlobalsApply) {
     runNpm("sync-globals", ["run", "sync:globals:apply"])
   }
-  runNpm("check", ["run", "rulesync:check"])
+  withGuardedCheckInteriors(dest, () => {
+    runNpm("check", ["run", "rulesync:check"])
+  })
 }