@lovrozagar/grunt 0.1.0

package/scripts/persist-plan.mjs

@@ -0,0 +1,309 @@
+#!/usr/bin/env node
+/** Allocate/slugify/validate/write a local plan under .tmp/plans/. */
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+export const PLAN_DIR = ".tmp/plans";
+/** 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$/;
+export const SERIAL_LINE_RE = /^serial: [1-9][0-9]*$/;
+export const STATUS_RE = /^(ready|in-progress|done|blocked)$/;
+export const DATE_RE = /^\d{4}-\d{2}-\d{2}$/;
+export const DATETIME_RE = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z$/;
+export const CREATED_RE = /^\d{4}-\d{2}-\d{2}(T\d{2}:\d{2}:\d{2}Z)?$/;
+export const FILENAME_STAMP_RE = /-\d{8}T\d{6}Z$/;
+export const REQUIRED_H2 = [
+  "Goal",
+  "Context",
+  "Constraints",
+  "Watch-outs",
+  "Steps",
+  "Verify",
+];
+const BOX_RE = /^( {0,2})(\d+(?:\.\d+){0,2}) \[([ xX])\] (.+)$/;
+const LEAF_ID_RE = /^\d+\.\d+(?:\.\d+)?$/;
+
+export function slugify(name) {
+  let s = String(name || "")
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/-+/g, "-")
+    .replace(/^-+|-+$/g, "");
+  if (s.length > 50) {
+    s = s.slice(0, 50).replace(/-+$/g, "");
+  }
+  if (!s) s = "unnamed";
+  if (s.endsWith(".lock")) {
+    s = s.slice(0, -5).replace(/-+$/g, "") || "unnamed";
+  }
+  return s;
+}
+
+export function utcDateTime(d = new Date()) {
+  return d.toISOString().replace(/\.\d{3}Z$/, "Z");
+}
+
+export function utcDate(d = new Date()) {
+  return utcDateTime(d).slice(0, 10);
+}
+
+export function compactCreatedStamp(created) {
+  return String(created).replace(/[-:]/g, "");
+}
+
+export function slugFromFilename(filename) {
+  return String(filename)
+    .replace(/\.md$/, "")
+    .replace(/^[0-9]+-/, "")
+    .replace(FILENAME_STAMP_RE, "");
+}
+
+export function extractPlanName(content) {
+  const m = String(content).match(/^\s*PLAN_NAME:\s*(.+?)\s*$/m);
+  return m ? m[1].trim() : "";
+}
+
+export function stripPlanName(content) {
+  return String(content).replace(/^\s*PLAN_NAME:\s*.+\s*\n/, "");
+}
+
+export function extractH1(content) {
+  const m = String(content).match(/^#\s+(.+?)\s*$/m);
+  return m ? m[1].trim() : "";
+}
+
+export function nextSerial(plansDir) {
+  let next = 1;
+  if (!fs.existsSync(plansDir)) return next;
+  for (const b of fs.readdirSync(plansDir)) {
+    if (!b.endsWith(".md")) continue;
+    const m = b.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 ensureGitignore(workspaceRoot) {
+  const p = path.join(workspaceRoot, ".gitignore");
+  let cur = "";
+  try {
+    cur = fs.readFileSync(p, "utf8");
+  } catch {
+    fs.writeFileSync(p, ".tmp/\n");
+    return;
+  }
+  if (/(?:^|\n)\.tmp\/(?:\n|$)/.test(cur)) return;
+  const next = cur.endsWith("\n") || !cur ? cur : cur + "\n";
+  fs.writeFileSync(p, next + ".tmp/\n");
+}
+
+function stripFrontmatter(text) {
+  const s = String(text).replace(/^\uFEFF/, "");
+  if (!s.startsWith("---\n")) return s;
+  const end = s.indexOf("\n---\n", 4);
+  if (end === -1) return s;
+  return s.slice(end + 5);
+}
+
+export function injectFrontmatter({ serial, slug, source, body, created }) {
+  const src = String(source || "").slice(0, 120);
+  let rest = stripFrontmatter(body).replace(/^\s+/, "");
+  if (!rest.startsWith("# ")) {
+    rest = `# ${slug}\n\n` + rest;
+  } else {
+    rest = rest.replace(/^# .+/, `# ${slug}`);
+  }
+  return `---
+serial: ${serial}
+name: ${slug}
+status: ready
+created: ${created || utcDateTime()}
+source: ${JSON.stringify(src)}
+---
+
+${rest}`;
+}
+
+function sectionBodies(text) {
+  const h2 = [...text.matchAll(/^## (.+)$/gm)].map((m) => ({
+    title: m[1].trim(),
+    index: m.index,
+  }));
+  const bodies = {};
+  for (let i = 0; i < h2.length; i++) {
+    const start = h2[i].index + h2[i].title.length + 4;
+    const end = i + 1 < h2.length ? h2[i + 1].index : text.length;
+    bodies[h2[i].title] = text.slice(start, end);
+  }
+  return { order: h2.map((h) => h.title), bodies };
+}
+
+function parseFrontmatter(text) {
+  if (!text.startsWith("---\n")) return { error: "missing frontmatter" };
+  const end = text.indexOf("\n---\n", 4);
+  if (end === -1) return { error: "unterminated frontmatter" };
+  const raw = text.slice(4, end);
+  const map = {};
+  for (const line of raw.split("\n")) {
+    const m = line.match(/^([a-z]+):(?:\s+(.*))?$/);
+    if (!m) continue;
+    let v = m[2] ?? "";
+    if (v.startsWith('"') && v.endsWith('"')) {
+      try {
+        v = JSON.parse(v);
+      } catch {
+        v = v.slice(1, -1);
+      }
+    }
+    map[m[1]] = v;
+  }
+  return { map, body: text.slice(end + 5) };
+}
+
+export function validatePlan(filename, text) {
+  const errors = [];
+  if (!FILENAME_RE.test(filename)) errors.push("filename");
+  const fm = parseFrontmatter(text);
+  if (fm.error) {
+    errors.push(fm.error);
+    return errors;
+  }
+  const { map, body } = fm;
+  const serialLine = text.split("\n").find((l) => l.startsWith("serial:"));
+  if (!serialLine || !SERIAL_LINE_RE.test(serialLine)) errors.push("serial line");
+  for (const k of ["serial", "name", "status", "created", "source"]) {
+    if (map[k] == null || map[k] === "") errors.push(`missing ${k}`);
+  }
+  if (map.status && !STATUS_RE.test(map.status)) errors.push("status");
+  if (map.created && !CREATED_RE.test(map.created)) errors.push("created");
+  if (typeof map.source === "string" && map.source.length > 120) {
+    errors.push("source length");
+  }
+  const slugFromName = map.name;
+  if (slugFromName && slugFromFilename(filename) !== slugFromName) {
+    errors.push("name/filename slug");
+  }
+  if (!body.trim().startsWith(`# ${slugFromName}`)) errors.push("h1 slug");
+  const { order, bodies } = sectionBodies(body);
+  const firstSix = order.slice(0, REQUIRED_H2.length);
+  if (REQUIRED_H2.some((h, i) => firstSix[i] !== h)) errors.push("heading order");
+  const extra = order.filter((h) => !REQUIRED_H2.includes(h));
+  if (extra.length) errors.push("extra h2");
+  const goal = (bodies.Goal || "").trim();
+  const sentences = goal.split(/(?<=[.!?])(?:\s+|$)/).filter((s) => s.trim());
+  if (!goal || sentences.length < 1 || sentences.length > 3) errors.push("goal");
+  for (const h of ["Context", "Constraints", "Watch-outs"]) {
+    const b = (bodies[h] || "").trim();
+    if (!b) errors.push(`${h} empty`);
+    else if (!/^(?:[-*] |\(none\))/m.test(b)) errors.push(`${h} bullets`);
+  }
+  const boxes = [];
+  for (const line of text.split("\n")) {
+    const m = line.match(BOX_RE);
+    if (!m) continue;
+    if (m[3] !== " ") errors.push("fresh [x]");
+    boxes.push({ id: m[2], text: m[4] });
+  }
+  const leaves = boxes.filter((b) => LEAF_ID_RE.test(b.id));
+  if (leaves.length < 1) errors.push("no N.M leaf");
+  const phases = boxes.filter((b) => /^\d+$/.test(b.id));
+  for (const p of phases) {
+    if (!boxes.some((b) => b.id.startsWith(p.id + "."))) errors.push(`phase ${p.id} leaf`);
+  }
+  if (phases.length) {
+    const last = phases[phases.length - 1];
+    if (!/^Verify\b/i.test(last.text) && last.id !== String(phases.length)) {
+      errors.push("verify last phase");
+    }
+  }
+  return [...new Set(errors)];
+}
+
+export function persistPlan({
+  workspaceRoot,
+  content,
+  source,
+  created,
+} = {}) {
+  const ws = workspaceRoot || process.cwd();
+  const raw = String(content || "");
+  const planName = extractPlanName(raw) || extractH1(stripFrontmatter(stripPlanName(raw)));
+  const slug = slugify(planName);
+  const src =
+    source ||
+    (raw.match(/^\s*source:\s*(.+)$/m) ? undefined : planName);
+  const body = stripPlanName(raw);
+  const plansDir = path.join(ws, PLAN_DIR);
+  fs.mkdirSync(plansDir, { recursive: true });
+  const createdAt =
+    created && DATETIME_RE.test(created) ? created : utcDateTime();
+  const stamp = compactCreatedStamp(createdAt);
+  let serial = nextSerial(plansDir);
+  let filename = `${serial}-${slug}-${stamp}.md`;
+  let dest = path.join(plansDir, filename);
+  let tries = 0;
+  while (fs.existsSync(dest) && tries < 5) {
+    serial += 1;
+    filename = `${serial}-${slug}-${stamp}.md`;
+    dest = path.join(plansDir, filename);
+    tries += 1;
+  }
+  if (fs.existsSync(dest)) {
+    return { ok: false, error: "serial collision" };
+  }
+  const goalMatch = stripFrontmatter(body).match(/## Goal\n([\s\S]*?)\n## /);
+  const sourceText = String(
+    source ||
+      planName ||
+      (goalMatch ? goalMatch[1].trim().replace(/\s+/g, " ") : slug),
+  ).slice(0, 120);
+  const full = injectFrontmatter({
+    serial,
+    slug,
+    source: sourceText,
+    body,
+    created: createdAt,
+  });
+  const errors = validatePlan(filename, full);
+  if (errors.length) {
+    return { ok: false, error: errors.join("; "), errors };
+  }
+  ensureGitignore(ws);
+  fs.writeFileSync(dest, full);
+  return { ok: true, path: dest, serial, slug, content: full, 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 = persistPlan({ workspaceRoot, content });
+    if (!result.ok) {
+      process.stderr.write((result.error || "invalid plan") + "\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/purge-global-mcps.mjs

@@ -0,0 +1,291 @@
+#!/usr/bin/env node
+/** Purge stubborn global MCP sources under $HOME (dry-run default). Never project MCP. */
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { parse as parseToml, stringify as stringifyToml } from "smol-toml";
+
+const PLUGIN_IDS = ["cloudflare", "stripe"];
+const DISABLE_MCP = ["cloudflare-docs", "MCP_DOCKER", "stripe"];
+const CURSOR_SERVER = "MCP_DOCKER";
+const STRIPE_PLUGIN = "stripe";
+
+function isPlainObject(v) {
+  return v != null && typeof v === "object" && !Array.isArray(v) && !(v instanceof Date);
+}
+
+/** HOME, else USERPROFILE (Windows / env sim), else os.homedir(). */
+export function resolveHome(env = process.env) {
+  return env.HOME || env.USERPROFILE || os.homedir();
+}
+
+export function parseArgv(argv) {
+  const args = Array.isArray(argv) ? argv : [];
+  let apply = false;
+  for (const a of args) {
+    if (a === "--apply") {
+      apply = true;
+      continue;
+    }
+    return { ok: false, error: `unknown flag: ${a}` };
+  }
+  return { ok: true, apply };
+}
+
+export function grokConfigPath(home) {
+  return path.join(path.resolve(home), ".grok", "config.toml");
+}
+
+export function cursorMcpPath(home) {
+  return path.join(path.resolve(home), ".cursor", "mcp.json");
+}
+
+export function claudePluginsPath(home) {
+  return path.join(path.resolve(home), ".claude", "plugins", "installed_plugins.json");
+}
+
+function isStripePluginKey(k) {
+  return String(k).split("@")[0] === STRIPE_PLUGIN;
+}
+
+function strList(v, label) {
+  if (v == null) return [];
+  if (!Array.isArray(v)) throw new Error(`unreadable dest: ${label}`);
+  return v.map((x) => String(x));
+}
+
+function dedupe(list) {
+  const out = [];
+  const seen = new Set();
+  for (const x of list) {
+    if (seen.has(x)) continue;
+    seen.add(x);
+    out.push(x);
+  }
+  return out;
+}
+
+function writeText(abs, body) {
+  const text = body.endsWith("\n") ? body : body + "\n";
+  fs.mkdirSync(path.dirname(abs), { recursive: true });
+  fs.writeFileSync(abs, text);
+}
+
+function reportLine(row) {
+  return `${row.action} ${row.path} ${row.detail}`;
+}
+
+function planGrok(home) {
+  const abs = grokConfigPath(home);
+  let raw;
+  try {
+    raw = fs.readFileSync(abs, "utf8");
+  } catch (err) {
+    if (err && err.code === "ENOENT") {
+      return { abs, skip: true, detail: "noop (missing)", obj: null };
+    }
+    throw new Error(`unreadable dest: ${abs}`);
+  }
+  let obj;
+  try {
+    const v = parseToml(raw);
+    if (!isPlainObject(v)) throw new Error("not a table");
+    obj = v;
+  } catch {
+    throw new Error(`unreadable dest: ${abs}`);
+  }
+
+  const next = { ...obj };
+  const details = [];
+  let changed = false;
+
+  const hadPlugins = isPlainObject(obj.plugins);
+  if (obj.plugins != null && !hadPlugins) {
+    throw new Error(`unreadable dest: ${abs}`);
+  }
+  const plugins = hadPlugins ? { ...obj.plugins } : {};
+  const enabled = strList(plugins.enabled, abs);
+  const disabled = strList(plugins.disabled, abs);
+  const nextEnabled = enabled.filter((n) => !PLUGIN_IDS.includes(n));
+  const nextDisabled = dedupe([...disabled, ...PLUGIN_IDS]);
+  const enabledChanged = nextEnabled.join("\0") !== enabled.join("\0");
+  const disabledChanged = nextDisabled.join("\0") !== disabled.join("\0");
+  if (enabledChanged) {
+    const removed = enabled.filter((n) => PLUGIN_IDS.includes(n));
+    details.push(`remove ${removed.join(", ")} from [plugins].enabled`);
+    changed = true;
+  }
+  if (disabledChanged) {
+    const added = PLUGIN_IDS.filter((id) => !disabled.includes(id));
+    details.push(`add ${added.join(", ")} to [plugins].disabled`);
+    changed = true;
+  }
+  if (enabledChanged || disabledChanged) {
+    if ("enabled" in plugins || enabledChanged) plugins.enabled = nextEnabled;
+    plugins.disabled = nextDisabled;
+    next.plugins = plugins;
+  }
+
+  const mcpKey = "disabled_mcp_servers";
+  if (next[mcpKey] == null || Array.isArray(next[mcpKey])) {
+    const cur = strList(next[mcpKey], abs);
+    const mcpNext = dedupe([...cur, ...DISABLE_MCP]);
+    if (mcpNext.join("\0") !== cur.join("\0")) {
+      const added = mcpNext.filter((x) => !cur.includes(x));
+      next[mcpKey] = mcpNext;
+      details.push(`add ${added.join(", ")} to ${mcpKey}`);
+      changed = true;
+    }
+  }
+
+  return {
+    abs,
+    skip: !changed,
+    detail: changed ? details.join("; ") : "noop (already clean)",
+    obj: next,
+    changed,
+  };
+}
+
+function planClaudePlugins(home) {
+  const abs = claudePluginsPath(home);
+  let raw;
+  try {
+    raw = fs.readFileSync(abs, "utf8");
+  } catch (err) {
+    if (err && err.code === "ENOENT") {
+      return { abs, skip: true, detail: "noop (missing)", json: null };
+    }
+    throw new Error(`unreadable dest: ${abs}`);
+  }
+  let obj;
+  try {
+    obj = JSON.parse(raw);
+  } catch {
+    throw new Error(`unreadable dest: ${abs}`);
+  }
+  if (!isPlainObject(obj)) throw new Error(`unreadable dest: ${abs}`);
+  const plugins = obj.plugins;
+  if (plugins == null) {
+    return { abs, skip: true, detail: "noop (already clean)", json: null };
+  }
+  if (!isPlainObject(plugins)) throw new Error(`unreadable dest: ${abs}`);
+  const keys = Object.keys(plugins).filter(isStripePluginKey);
+  if (!keys.length) {
+    return { abs, skip: true, detail: "noop (already clean)", json: null };
+  }
+  const nextPlugins = { ...plugins };
+  for (const k of keys) delete nextPlugins[k];
+  return {
+    abs,
+    skip: false,
+    detail: `remove ${keys.join(", ")} from plugins`,
+    json: { ...obj, plugins: nextPlugins },
+    changed: true,
+  };
+}
+
+function planCursor(home) {
+  const abs = cursorMcpPath(home);
+  let raw;
+  try {
+    raw = fs.readFileSync(abs, "utf8");
+  } catch (err) {
+    if (err && err.code === "ENOENT") {
+      return { abs, skip: true, detail: "noop (missing)", json: null };
+    }
+    throw new Error(`unreadable dest: ${abs}`);
+  }
+  let obj;
+  try {
+    obj = JSON.parse(raw);
+  } catch {
+    throw new Error(`unreadable dest: ${abs}`);
+  }
+  if (!isPlainObject(obj)) throw new Error(`unreadable dest: ${abs}`);
+  const servers = obj.mcpServers;
+  if (servers == null) {
+    return { abs, skip: true, detail: "noop (already clean)", json: null };
+  }
+  if (!isPlainObject(servers)) throw new Error(`unreadable dest: ${abs}`);
+  if (!Object.prototype.hasOwnProperty.call(servers, CURSOR_SERVER)) {
+    return { abs, skip: true, detail: "noop (already clean)", json: null };
+  }
+  const nextServers = { ...servers };
+  delete nextServers[CURSOR_SERVER];
+  const json = { ...obj, mcpServers: nextServers };
+  return {
+    abs,
+    skip: false,
+    detail: `remove ${CURSOR_SERVER} from mcpServers`,
+    json,
+    changed: true,
+  };
+}
+
+export function purgeGlobalMcps({ home, apply = false } = {}) {
+  const report = [];
+  const action = apply ? "apply" : "dry-run";
+  try {
+    if (!home) throw new Error("HOME required");
+    const grok = planGrok(home);
+    const cursor = planCursor(home);
+    const claude = planClaudePlugins(home);
+    if (apply) {
+      if (!grok.skip && grok.obj) {
+        writeText(grok.abs, stringifyToml(grok.obj));
+      }
+      if (!cursor.skip && cursor.json) {
+        writeText(cursor.abs, JSON.stringify(cursor.json, null, 2));
+      }
+      if (!claude.skip && claude.json) {
+        writeText(claude.abs, JSON.stringify(claude.json, null, 2));
+      }
+    }
+    for (const row of [
+      { action, path: grok.abs, detail: grok.detail },
+      { action, path: cursor.abs, detail: cursor.detail },
+      { action, path: claude.abs, detail: claude.detail },
+    ]) {
+      report.push({ ...row, line: reportLine(row) });
+    }
+    return { ok: true, report };
+  } catch (err) {
+    const error = String(err && err.message ? err.message : err);
+    return { ok: false, report, error };
+  }
+}
+
+function main() {
+  try {
+    const parsed = parseArgv(process.argv.slice(2));
+    if (!parsed.ok) {
+      process.stderr.write((parsed.error || "invalid argv") + "\n");
+      return 1;
+    }
+    const home = resolveHome();
+    if (!home) {
+      process.stderr.write("HOME required\n");
+      return 1;
+    }
+    const result = purgeGlobalMcps({ home, apply: parsed.apply });
+    for (const row of result.report || []) {
+      process.stdout.write((row.line || reportLine(row)) + "\n");
+    }
+    if (!result.ok) {
+      process.stderr.write((result.error || "purge failed") + "\n");
+      return 1;
+    }
+    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());
+}