@lovrozagar/grunt 0.4.2 → 0.5.2

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/pipeline.mjs

@@ -0,0 +1,67 @@
+#!/usr/bin/env node
+/** Inner generate/check/watch chain. Called by guarded-roots; not a public npm script. */
+import { execSync } from "node:child_process";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+export const COMMANDS = {
+  generate: [
+    "rulesync generate -t claudecode,codexcli,antigravity-cli,grokcli -f rules,subagents,skills",
+    "rulesync generate -t claudecode,codexcli,antigravity-cli -f hooks",
+    "node scripts/emit-mcp-policy.mjs",
+    "node scripts/emit-gemini.mjs",
+    "node scripts/emit-agent-shell-tools.mjs",
+    "node scripts/emit-maps.mjs",
+    "node scripts/hooks-union.mjs",
+  ],
+  check: [
+    "rulesync generate -t claudecode,codexcli,antigravity-cli,grokcli -f rules,skills --check",
+    "rulesync generate -t codexcli,antigravity-cli,grokcli -f subagents --check",
+    "rulesync generate -t claudecode,codexcli,antigravity-cli -f hooks --check",
+    "node scripts/emit-mcp-policy.mjs --check",
+    "node scripts/emit-gemini.mjs --check",
+    "node scripts/emit-agent-shell-tools.mjs --check",
+    "node scripts/emit-maps.mjs --check",
+    "node scripts/check-globals.mjs",
+    "node scripts/hooks-union.mjs --check",
+  ],
+  watch: [
+    "node scripts/emit-mcp-policy.mjs",
+    "node scripts/emit-gemini.mjs",
+    "node scripts/emit-agent-shell-tools.mjs",
+    "rulesync generate -t claudecode,codexcli,antigravity-cli,grokcli -f rules,subagents,skills --watch",
+  ],
+};
+
+export function envWithLocalBin(cwd, env = process.env) {
+  const binDir = path.join(cwd, "node_modules", ".bin");
+  const merged = { ...env };
+  const key = Object.keys(merged).find((k) => k.toLowerCase() === "path") || "PATH";
+  merged[key] = `${binDir}${path.delimiter}${merged[key] || ""}`;
+  return merged;
+}
+
+export function runPipeline(mode, { cwd = process.cwd(), exec = execSync } = {}) {
+  const cmds = COMMANDS[mode];
+  if (!cmds) {
+    throw new Error("usage: pipeline.mjs generate|check|watch");
+  }
+  const env = envWithLocalBin(cwd);
+  for (const cmd of cmds) {
+    exec(cmd, { cwd, stdio: "inherit", shell: true, env });
+  }
+}
+
+function main() {
+  try {
+    runPipeline(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/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`
   );
 }
 

package/scripts/skill-conflicts.mjs

@@ -0,0 +1,71 @@
+#!/usr/bin/env node
+/** Workspace vs packaged grunt skill content conflicts (warn-only). */
+import fs from "node:fs";
+import path from "node:path";
+
+export const WORKSPACE_SKILLS_REL = ".rulesync/skills";
+export const PACKAGED_SKILLS_REL = path.join(
+  "node_modules",
+  "@lovrozagar",
+  "grunt",
+  ".rulesync",
+  "skills",
+);
+
+export function listSkillDirNames(skillsRoot) {
+  let entries;
+  try {
+    entries = fs.readdirSync(skillsRoot, { withFileTypes: true });
+  } catch (err) {
+    if (err && err.code === "ENOENT") return [];
+    throw err;
+  }
+  const out = [];
+  for (const ent of entries) {
+    if (!ent.isDirectory() || ent.name.startsWith(".")) continue;
+    const skillMd = path.join(skillsRoot, ent.name, "SKILL.md");
+    try {
+      if (!fs.statSync(skillMd).isFile()) continue;
+    } catch {
+      continue;
+    }
+    out.push(ent.name);
+  }
+  out.sort((a, b) => a.localeCompare(b));
+  return out;
+}
+
+function readSkillMd(skillsRoot, name) {
+  const abs = path.join(skillsRoot, name, "SKILL.md");
+  try {
+    return fs.readFileSync(abs);
+  } catch {
+    return null;
+  }
+}
+
+/** Names in both trees whose SKILL.md bytes differ. */
+export function findSkillContentConflicts({ workspaceSkillsDir, packagedSkillsDir } = {}) {
+  if (!workspaceSkillsDir || !packagedSkillsDir) return [];
+  const packaged = listSkillDirNames(packagedSkillsDir);
+  if (!packaged.length) return [];
+  const conflicts = [];
+  for (const name of packaged) {
+    const ws = readSkillMd(workspaceSkillsDir, name);
+    if (ws == null) continue;
+    const pkg = readSkillMd(packagedSkillsDir, name);
+    if (pkg == null) continue;
+    if (Buffer.compare(ws, pkg) !== 0) {
+      conflicts.push({
+        name,
+        workspacePath: path.join(workspaceSkillsDir, name, "SKILL.md"),
+        packagedPath: path.join(packagedSkillsDir, name, "SKILL.md"),
+      });
+    }
+  }
+  return conflicts;
+}
+
+export function formatSkillConflictWarn(name) {
+  return `skill \`${name}\` differs from packaged grunt; re-init overwrites`;
+}