@lovrozagar/grunt 0.5.2 → 0.6.1

package/cli/init.mjs

@@ -6,24 +6,51 @@ import {
   WORKSPACE_SKILLS_REL,
   findSkillContentConflicts,
   formatSkillConflictWarn,
+  listSkillDirNames,
 } from "../scripts/skill-conflicts.mjs"
+import {
+  SENTINEL_BEGIN,
+  extractGruntBody,
+  writeMergedGuardedFile,
+  snapshotGuardedRoots,
+  remergeGuardedRoots,
+  withGuardedCheckInteriors,
+} from "../scripts/guarded-md.mjs"
+
+export {
+  GUARDED_ROOT_FILES,
+  SENTINEL_BEGIN,
+  SENTINEL_END,
+  MAX_GUARDED_MARKDOWN_BYTES,
+  extractUserMarkdown,
+  extractGruntBody,
+  composeGuardedMarkdown,
+  mergeGuardedContent,
+  writeMergedGuardedFile,
+  guardedMarkdownDrift,
+  snapshotGuardedRoots,
+  remergeGuardedRoots,
+  healGuardedRootFile,
+  withGuardedCheckInteriors,
+} from "../scripts/guarded-md.mjs"
 
 const PKG_ROOT = path.join(path.dirname(fileURLToPath(import.meta.url)), "..")
 
-const PRODUCT_SCRIPTS = [
+export const PRODUCT_SCRIPTS = [
   "check-globals.mjs",
   "emit-agent-shell-tools.mjs",
   "emit-gemini.mjs",
   "emit-maps.mjs",
+  "guarded-md.mjs",
   "guarded-roots.mjs",
   "emit-mcp-policy.mjs",
   "gate-fat-tools.mjs",
   "hooks-union.mjs",
   "pipeline.mjs",
   "grunt-job.mjs",
-  "grunt-config.mjs",
   "parse-need.mjs",
   "persist-handoff.mjs",
+  "persist-implementation.mjs",
   "persist-tmp.mjs",
   "persist-plan.mjs",
   "purge-global-mcps.mjs",
@@ -31,14 +58,64 @@ const PRODUCT_SCRIPTS = [
   "scrub-text-lib.mjs",
   "sync-global-settings.mjs",
   "browser.mjs",
+  "speak.mjs",
+  "listen.mjs",
+  "google-workspace.mjs",
+  "interactive.mjs",
+  "prompt.mjs",
+  "setup.mjs",
   "doctor.mjs",
   "skill-conflicts.mjs",
   "scrub-text",
 ]
 
 const COPY_DIRS = [".rulesync", ".grok", ".codex", ".claude", ".agents"]
+export const RETIRED_SKILLS = ["parent", "solo", "cascade"]
+export const RETIRED_AGENTS = ["implementer", "thinker"]
+/** Cumulative. Dest `scripts/<name>` deleted on init/upgrade even if no longer shipped. */
+export const RETIRED_SCRIPTS = ["telemetry.mjs", "grunt-config.mjs"]
+/** Repo-relative paths grunt used to ship. Deleted on init/upgrade. Consumer extras elsewhere kept. */
+export const RETIRED_PATHS = [
+  ".grok/parent.md",
+  ".grok/skills/shared",
+  ".rulesync/grunt.config.jsonc",
+  ".rulesync/grunt.config.local.jsonc",
+  ".rulesync/grunt.config.local.jsonc.example",
+]
+export const RESERVED_SKILLS = [
+  "ask",
+  "auto",
+  "browser",
+  "clasp",
+  "commit",
+  "commit-and-push",
+  "commit-push",
+  "commit-push-deploy",
+  "commit-push-release",
+  "explain",
+  "google-workspace",
+  "handoff",
+  "implement-plan",
+  "listen",
+  "pickup",
+  "speak",
+  "tmp",
+  "write-plan",
+]
+const SKILL_MIRROR_DIRS = [
+  [".rulesync", "skills"],
+  [".grok", "skills"],
+  [".claude", "skills"],
+  [".agents", "skills"],
+]
+const AGENT_MIRROR_DIRS = [
+  [".rulesync", "subagents"],
+  [".claude", "agents"],
+  [".grok", "agents"],
+  [".agents", "agents"],
+  [".codex", "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 consumer `grunt:rulesync:generate`, see mergeClaudeSettings ordering) owns and
 // merges it, so a plain-copy would just be clobbered/redundant.
@@ -54,16 +131,6 @@ export const LAUNCH_SCRIPTS = {
   grok: "grok --yolo",
 }
 const OWNED_HOOK_FILES = ["scrub-spawn-prompt.mjs", "gate-fat-tools.mjs", "orchestrate-parent.js"]
-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 =
-  /(?:^|(?<=\n)|(?<=\r\n))[ \t]*<!-- grunt:begin -->[ \t]*\r?\n?[\s\S]*?(?:^|(?<=\n)|(?<=\r\n))[ \t]*<!-- grunt:end -->[ \t]*\r?\n?/g
-const GRUNT_INTERIOR_RE =
-  /(?:^|(?<=\n)|(?<=\r\n))[ \t]*<!-- grunt:begin -->[ \t]*\r?\n?([\s\S]*?)(?:^|(?<=\n)|(?<=\r\n))[ \t]*<!-- grunt:end -->/g
-const ORPHAN_END_RE = /(?:^|\r?\n)[ \t]*<!-- grunt:end -->[ \t]*(?=\r?\n|$)|<!-- grunt:end -->/g
-const BEGIN_LINE_RE = /^[ \t]*<!-- grunt:begin -->[ \t]*$/
-const END_LINE_RE = /^[ \t]*<!-- grunt:end -->[ \t]*$/
 
 function sortKeys(obj) {
   return Object.fromEntries(Object.keys(obj).sort().map((k) => [k, obj[k]]))
@@ -77,17 +144,58 @@ export function samePath(a, b) {
   }
 }
 
+const GITIGNORE_ENTRIES = [{ re: /^\.tmp\/?$/, line: ".tmp/" }]
+
+function rmQuiet(abs) {
+  fs.rmSync(abs, { recursive: true, force: true })
+}
+
+export function pruneRetired(dest, { pkgRoot } = {}) {
+  const root = path.resolve(dest)
+  for (const segs of SKILL_MIRROR_DIRS) {
+    for (const name of RETIRED_SKILLS) {
+      rmQuiet(path.join(root, ...segs, name))
+    }
+  }
+  if (pkgRoot) {
+    const packaged = new Set(
+      listSkillDirNames(path.join(path.resolve(pkgRoot), WORKSPACE_SKILLS_REL)),
+    )
+    for (const segs of SKILL_MIRROR_DIRS) {
+      for (const name of RESERVED_SKILLS) {
+        if (packaged.has(name)) continue
+        rmQuiet(path.join(root, ...segs, name))
+      }
+    }
+  }
+  for (const segs of AGENT_MIRROR_DIRS) {
+    for (const name of RETIRED_AGENTS) {
+      rmQuiet(path.join(root, ...segs, `${name}.md`))
+      rmQuiet(path.join(root, ...segs, `${name}.toml`))
+    }
+  }
+  for (const name of RETIRED_AGENTS) {
+    rmQuiet(path.join(root, ".gemini", "agents", name))
+    rmQuiet(path.join(root, ".grok", "roles", `${name}.toml`))
+  }
+  for (const name of RETIRED_SCRIPTS) {
+    rmQuiet(path.join(root, "scripts", name))
+  }
+  for (const rel of RETIRED_PATHS) {
+    rmQuiet(path.join(root, ...rel.split("/")))
+  }
+}
+
 export function mergeGitignore(dest) {
   const gi = path.join(dest, ".gitignore")
-  if (!fs.existsSync(gi)) {
-    fs.writeFileSync(gi, ".tmp/\n")
-    return
-  }
-  const text = fs.readFileSync(gi, "utf8")
-  const has = text.split(/\r?\n/).some((line) => /^\.tmp\/?$/.test(line))
-  if (has) return
-  const prefix = text.endsWith("\n") || text.length === 0 ? "" : "\n"
-  fs.appendFileSync(gi, `${prefix}.tmp/\n`)
+  const text = fs.existsSync(gi) ? fs.readFileSync(gi, "utf8") : ""
+  const present = text.split(/\r?\n/)
+  const missing = GITIGNORE_ENTRIES.filter(
+    ({ re }) => !present.some((line) => re.test(line)),
+  ).map(({ line }) => line)
+  if (missing.length === 0) return
+  const prefix = text.length === 0 || text.endsWith("\n") ? "" : "\n"
+  fs.writeFileSync(gi, `${text}${prefix}${missing.join("\n")}\n`)
 }
 
 function destHasGruntSentinel(dest) {
@@ -108,120 +216,6 @@ export function shouldAutoSkipGlobals(dest) {
   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) {
-  let user = String(text).replace(cloneRe(GRUNT_REGION_RE), "")
-  const i = user.indexOf(SENTINEL_BEGIN)
-  if (i >= 0) user = user.slice(0, i)
-  user = user.replace(cloneRe(ORPHAN_END_RE), "")
-  return userRemainderIsBlank(user) ? "" : user
-}
-
-function unwrapStackedMarkers(text) {
-  const lines = String(text).split(/\r?\n/)
-  let start = 0
-  let end = lines.length
-  while (start < end && BEGIN_LINE_RE.test(lines[start])) start++
-  while (end > start && lines[end - 1] === "") end--
-  while (end > start && END_LINE_RE.test(lines[end - 1])) {
-    end--
-    while (end > start && lines[end - 1] === "") end--
-  }
-  return lines.slice(start, end).join("\n")
-}
-
-export function extractGruntBody(text) {
-  const src = String(text)
-  const parts = []
-  const re = cloneRe(GRUNT_INTERIOR_RE)
-  let m
-  while ((m = re.exec(src))) {
-    parts.push(trimTrailingNewlines(unwrapStackedMarkers(m[1])))
-  }
-  if (parts.length) return parts.join("\n")
-  const i = src.indexOf(SENTINEL_BEGIN)
-  if (i >= 0) {
-    return trimTrailingNewlines(
-      unwrapStackedMarkers(src.slice(i + SENTINEL_BEGIN.length).replace(/^[ \t]*\r?\n/, "")),
-    )
-  }
-  if (!src.includes(SENTINEL_END)) return null
-  return trimTrailingNewlines(unwrapStackedMarkers(src))
-}
-
-function userRemainderIsBlank(user) {
-  return String(user).replace(/\r\n/g, "\n").replace(/\n/g, "") === ""
-}
-
-export function composeGuardedMarkdown(gruntBody, userRemainder, nl = "\n") {
-  const raw = extractGruntBody(gruntBody) ?? gruntBody
-  const body = toNewline(trimTrailingNewlines(raw), nl)
-  const block = `${SENTINEL_BEGIN}${nl}${body}${nl}${SENTINEL_END}${nl}`
-  const user = extractUserMarkdown(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)
@@ -231,104 +225,6 @@ export function mergeGuardedMarkdown(dest, pkgRoot, file, { alreadyInited = fals
   return writeMergedGuardedFile(d, extractGruntBody(srcText) ?? srcText)
 }
 
-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
-}
-
-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))
-  }
-}
-
-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 }
-}
-
-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) {
   const srcPath = path.join(pkgRoot, ".claude", "settings.json")
   const destPath = path.join(destRoot, ".claude", "settings.json")
@@ -485,6 +381,8 @@ export function mergePackageJson(dest, pkgRoot) {
   destPkg.devDependencies = { ...(destPkg.devDependencies || {}) }
   destPkg.devDependencies["smol-toml"] = srcPkg.devDependencies["smol-toml"]
   destPkg.devDependencies["rulesync"] = srcPkg.devDependencies["rulesync"]
+  const clack = srcPkg.dependencies?.["@clack/prompts"]
+  if (clack) destPkg.devDependencies["@clack/prompts"] = clack
   destPkg.scripts = sortKeys(destPkg.scripts)
   destPkg.devDependencies = sortKeys(destPkg.devDependencies)
   fs.writeFileSync(destPath, `${JSON.stringify(destPkg, null, 2)}\n`)
@@ -536,6 +434,8 @@ export function init(dest, { pkgRoot: pkgRootOpt, execFileSync: exec = execFileS
       }
     }
 
+    pruneRetired(dest, { pkgRoot })
+
     for (const file of GUARDED_MD_FILES) {
       mergeGuardedMarkdown(dest, pkgRoot, file)
     }