deuk-agent-rule 1.0.13 → 2.2.0

package/scripts/merge-logic.mjs

@@ -4,12 +4,24 @@ import {
   mkdirSync,
   readFileSync,
   readdirSync,
+  unlinkSync,
   writeFileSync,
 } from "fs";
 import { join } from "path";
 
 export const DEFAULT_TAG = "deuk-agent-rule";
 
+/** HTML-style markers in `.cursorrules` (separate from AGENTS.md markers). */
+export const CURSORRULES_TAG = "deuk-agent-rule-cursorrules";
+
+export function resolveCursorrulesMarkers(o = {}) {
+  return resolveMarkers({
+    tag: o.tag && String(o.tag).trim() ? String(o.tag).trim() : CURSORRULES_TAG,
+    markerBegin: o.markerBegin,
+    markerEnd: o.markerEnd,
+  });
+}
+
 export function resolveMarkers(o) {
   const hasBegin = o.markerBegin != null && o.markerBegin !== "";
   const hasEnd = o.markerEnd != null && o.markerEnd !== "";
@@ -35,7 +47,8 @@ export function findMarkerRegion(content, begin, end) {
   const j = content.indexOf(end, i + begin.length);
   if (j === -1) {
     throw new Error(
-      "Found begin marker but no matching end marker after it.\n  begin: " + begin + "\n  end: " + end,
+      `[MARKER ERROR] Found begin marker "${begin}" but no matching end marker "${end}" after it.\n` +
+      `  This usually happens if one marker was deleted or renamed manually. Please verify the target file.`
     );
   }
   const innerStart = i + begin.length;
@@ -44,60 +57,85 @@ export function findMarkerRegion(content, begin, end) {
 }
 
 export function applyAgents(opts) {
-  const {
-    targetPath,
-    bundleContent,
-    markers,
-    flavor,
-    appendIfNoMarkers,
-    dryRun,
-    backup,
-    agentsMode,
-  } = opts;
+  const { agentsMode, targetPath } = opts;
 
   if (agentsMode === "skip") {
     return {
       action: "skip",
-      reason: existsSync(targetPath)
-        ? "agents mode skip (file exists)"
-        : "agents mode skip",
+      reason: existsSync(targetPath) ? "agents mode skip (file exists)" : "agents mode skip",
     };
   }
 
   if (agentsMode === "overwrite") {
-    const prev = existsSync(targetPath) ? readFileSync(targetPath, "utf8") : "";
-    if (dryRun) {
-      return { action: "would-write", path: targetPath, mode: "overwrite" };
-    }
-    if (backup && existsSync(targetPath)) {
-      copyFileSync(targetPath, targetPath + ".bak");
-    }
-    writeFileSync(targetPath, bundleContent, "utf8");
-    return { action: "write", path: targetPath, mode: "overwrite", hadPrevious: !!prev };
+    return handleAgentOverwrite(opts);
   }
 
   const existing = existsSync(targetPath) ? readFileSync(targetPath, "utf8") : "";
-  const region = findMarkerRegion(existing, markers.begin, markers.end);
 
-  if (region) {
-    const inner = bundleContent.trimEnd() + "\n";
-    const next =
-      existing.slice(0, region.innerStart) +
-      "\n" +
-      inner +
-      existing.slice(region.innerEnd);
-    if (dryRun) {
-      return { action: "would-write", path: targetPath, mode: "inject-region" };
-    }
-    if (backup && existsSync(targetPath)) {
-      copyFileSync(targetPath, targetPath + ".bak");
+  // Workflow Safety Check: warn about different tags and error on case-mismatch
+  const markerRegex = /<!--\s*([a-zA-Z0-9_-]+):begin\s*-->/gi;
+  const currentTagMatch = opts.markers.begin.match(/<!--\s*([a-zA-Z0-9_-]+):begin\s*-->/i);
+  const currentTag = currentTagMatch ? currentTagMatch[1] : null;
+
+  const foundTags = [];
+  let m;
+  while ((m = markerRegex.exec(existing)) !== null) {
+    if (currentTag && m[1].toLowerCase() === currentTag.toLowerCase()) {
+      if (m[1] !== currentTag) {
+        throw new Error(
+          `[CRITICAL ERROR] Case mismatch for tag "${currentTag}". Found "${m[1]}" in ${targetPath}.\n` +
+          `  Please unify casing to avoid duplicate managed blocks.`
+        );
+      }
+    } else {
+      foundTags.push(m[1]);
     }
-    writeFileSync(targetPath, next, "utf8");
-    return { action: "write", path: targetPath, mode: "inject-region" };
   }
 
-  const allowAppend =
-    appendIfNoMarkers || flavor === "init";
+  if (foundTags.length > 0) {
+    console.warn(`[WARNING] Foreign markers in ${targetPath}: ${[...new Set(foundTags)].join(", ")}`);
+    console.warn(`          Current tag is "${currentTag}". This might lead to duplicate managed blocks.`);
+  }
+
+  const region = findMarkerRegion(existing, opts.markers.begin, opts.markers.end);
+
+  if (region) {
+    return handleAgentInject(opts, existing, region);
+  }
+
+  return handleAgentAppend(opts, existing);
+}
+
+function handleAgentOverwrite(opts) {
+  const { targetPath, bundleContent, dryRun, backup } = opts;
+  const prev = existsSync(targetPath) ? readFileSync(targetPath, "utf8") : "";
+  if (dryRun) {
+    return { action: "would-write", path: targetPath, mode: "overwrite" };
+  }
+  if (backup && existsSync(targetPath)) {
+    copyFileSync(targetPath, targetPath + ".bak");
+  }
+  writeFileSync(targetPath, bundleContent, "utf8");
+  return { action: "write", path: targetPath, mode: "overwrite", hadPrevious: !!prev };
+}
+
+function handleAgentInject(opts, existing, region) {
+  const { targetPath, bundleContent, dryRun, backup } = opts;
+  const inner = bundleContent.trimEnd() + "\n";
+  const next = existing.slice(0, region.innerStart) + "\n" + inner + existing.slice(region.innerEnd);
+  if (dryRun) {
+    return { action: "would-write", path: targetPath, mode: "inject-region" };
+  }
+  if (backup && existsSync(targetPath)) {
+    copyFileSync(targetPath, targetPath + ".bak");
+  }
+  writeFileSync(targetPath, next, "utf8");
+  return { action: "write", path: targetPath, mode: "inject-region" };
+}
+
+function handleAgentAppend(opts, existing) {
+  const { targetPath, bundleContent, markers, flavor, appendIfNoMarkers, dryRun, backup } = opts;
+  const allowAppend = appendIfNoMarkers || flavor === "init";
 
   if (!allowAppend) {
     const hint = [
@@ -193,3 +231,135 @@ export function readBundleAgents(bundleRoot) {
   }
   return readFileSync(p, "utf8");
 }
+
+/**
+ * Optional bundle file: Cursor root rules pointer to AGENTS.md.
+ * @returns {string|null} file contents, or null if missing
+ */
+export function readBundleCursorrules(bundleRoot) {
+  const p = join(bundleRoot, ".cursorrules");
+  if (!existsSync(p)) {
+    return null;
+  }
+  return readFileSync(p, "utf8");
+}
+
+/**
+ * Remove one tagged block (markers inclusive). Returns ok:false if begin marker not found.
+ * @returns {{ ok: true, content: string } | { ok: false, reason: string }}
+ */
+export function removeTaggedBlock(content, begin, end) {
+  const i = content.indexOf(begin);
+  if (i === -1) {
+    return { ok: false, reason: "begin not found" };
+  }
+  const j = content.indexOf(end, i + begin.length);
+  if (j === -1) {
+    return { ok: false, reason: "end not found" };
+  }
+  const afterEnd = j + end.length;
+  let next = content.slice(0, i) + content.slice(afterEnd);
+  next = next.replace(/\n{3,}/g, "\n\n").replace(/^\n+/, "").trimEnd();
+  if (next.length) {
+    next += "\n";
+  }
+  return { ok: true, content: next };
+}
+
+/**
+ * Strip `deuk-agent-rule-cursorrules` (or custom markers) region from `.cursorrules`.
+ * @param {{ cwd: string, markers: { begin: string, end: string }, dryRun?: boolean, backup?: boolean }} opts
+ */
+export function removeCursorrules(opts) {
+  const { cwd, markers, dryRun, backup } = opts;
+  const targetPath = join(cwd, ".cursorrules");
+  if (!existsSync(targetPath)) {
+    return { action: "skip", reason: "no file" };
+  }
+  const existing = readFileSync(targetPath, "utf8");
+  const result = removeTaggedBlock(existing, markers.begin, markers.end);
+  if (!result.ok) {
+    return { action: "skip", path: targetPath, reason: result.reason };
+  }
+  if (dryRun) {
+    return { action: "would-write", path: targetPath, mode: "remove-tagged" };
+  }
+  if (backup && existsSync(targetPath)) {
+    copyFileSync(targetPath, targetPath + ".bak");
+  }
+  if (result.content === "") {
+    unlinkSync(targetPath);
+    return { action: "delete", path: targetPath, mode: "remove-tagged" };
+  }
+  writeFileSync(targetPath, result.content, "utf8");
+  return { action: "write", path: targetPath, mode: "remove-tagged" };
+}
+
+/**
+ * @param {{
+ *   bundleRoot: string,
+ *   cwd: string,
+ *   markers: { begin: string, end: string },
+ *   cursorrulesMode: "skip" | "inject" | "overwrite",
+ *   dryRun?: boolean,
+ *   backup?: boolean,
+ * }} opts
+ */
+export function applyCursorrules(opts) {
+  const { bundleRoot, cwd, markers, cursorrulesMode, dryRun, backup } = opts;
+  const raw = readBundleCursorrules(bundleRoot);
+  if (!raw) {
+    return { action: "skip", reason: "bundle .cursorrules missing" };
+  }
+  const inner = raw.trimEnd();
+  const targetPath = join(cwd, ".cursorrules");
+
+  if (cursorrulesMode === "skip") {
+    return { action: "skip", reason: "cursorrules mode skip" };
+  }
+
+  const writeTaggedOnly = (bodyInner) =>
+    markers.begin + "\n\n" + bodyInner + "\n\n" + markers.end + "\n";
+
+  if (cursorrulesMode === "overwrite") {
+    const next = writeTaggedOnly(inner);
+    if (dryRun) {
+      return { action: "would-write", path: targetPath, mode: "overwrite" };
+    }
+    if (backup && existsSync(targetPath)) {
+      copyFileSync(targetPath, targetPath + ".bak");
+    }
+    writeFileSync(targetPath, next, "utf8");
+    return { action: "write", path: targetPath, mode: "overwrite" };
+  }
+
+  // inject: update tagged region, or prepend tagged block above existing content
+  const existing = existsSync(targetPath) ? readFileSync(targetPath, "utf8") : "";
+  const region = findMarkerRegion(existing, markers.begin, markers.end);
+
+  if (region) {
+    const next =
+      existing.slice(0, region.innerStart) + "\n" + inner + "\n" + existing.slice(region.innerEnd);
+    if (dryRun) {
+      return { action: "would-write", path: targetPath, mode: "inject-region" };
+    }
+    if (backup && existsSync(targetPath)) {
+      copyFileSync(targetPath, targetPath + ".bak");
+    }
+    writeFileSync(targetPath, next, "utf8");
+    return { action: "write", path: targetPath, mode: "inject-region" };
+  }
+
+  const block = writeTaggedOnly(inner) + "\n";
+  const rest = existing.replace(/^\uFEFF/, "").trimStart();
+  const next = rest.length ? block + rest : block.trimEnd() + "\n";
+
+  if (dryRun) {
+    return { action: "would-write", path: targetPath, mode: "prepend-tagged" };
+  }
+  if (backup && existsSync(targetPath)) {
+    copyFileSync(targetPath, targetPath + ".bak");
+  }
+  writeFileSync(targetPath, next, "utf8");
+  return { action: "write", path: targetPath, mode: "prepend-tagged" };
+}

package/scripts/sync-bundle.mjs

@@ -13,12 +13,14 @@ import { fileURLToPath } from "url";
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const pkgRoot = join(__dirname, "..");
 
-/** Public npm bundle: generic template only (no monorepo paths or internal handoffs). */
+/** Copy publish/ templates into bundle/ for npm packaging. */
 const publishDir = join(pkgRoot, "publish");
 const publishRulesDir = join(publishDir, "rules");
 const rulesDest = join(pkgRoot, "bundle", "rules");
 const agentsSrc = join(publishDir, "AGENTS.md");
 const agentsDest = join(pkgRoot, "bundle", "AGENTS.md");
+const cursorrulesSrc = join(publishDir, ".cursorrules");
+const cursorrulesDest = join(pkgRoot, "bundle", ".cursorrules");
 
 if (!existsSync(publishDir)) {
   throw new Error("Missing publish template dir: " + publishDir);
@@ -29,6 +31,9 @@ if (!existsSync(publishRulesDir)) {
 if (!existsSync(agentsSrc)) {
   throw new Error("Missing publish/AGENTS.md: " + agentsSrc);
 }
+if (!existsSync(cursorrulesSrc)) {
+  throw new Error("Missing publish/.cursorrules: " + cursorrulesSrc);
+}
 
 if (existsSync(rulesDest)) {
   rmSync(rulesDest, { recursive: true });
@@ -41,4 +46,5 @@ for (const name of readdirSync(publishRulesDir)) {
 
 const agentsBody = readFileSync(agentsSrc, "utf8");
 writeFileSync(agentsDest, agentsBody, "utf8");
+copyFileSync(cursorrulesSrc, cursorrulesDest);
 console.log("deuk-agent-rule: synced bundle from publish/ template.");

package/scripts/changelog-polish.mjs

@@ -1,22 +0,0 @@
-/**
- * Post-process CHANGELOG.md after commit-and-tag-version: drop internal "sync" wording
- * from user-facing bullets (OSS mirror / sync-oss / release automation noise).
- */
-import { readFileSync, writeFileSync } from "fs";
-import { dirname, join } from "path";
-import { fileURLToPath } from "url";
-
-const root = join(dirname(fileURLToPath(import.meta.url)), "..");
-const file = join(root, "CHANGELOG.md");
-let s = readFileSync(file, "utf8");
-
-s = s.replace(/,\s*and OSS sync\b/g, "");
-s = s.replace(/\s+and OSS sync\b/g, "");
-s = s.replace(
-  /- `sync-oss` copies (`package-lock\.json`) for reproducible installs\./g,
-  "- Release packaging includes $1 for reproducible installs.",
-);
-s = s.replace(/\bCLI and publish AGENTS sync\b/gi, "CLI and publish AGENTS updates");
-s = s.replace(/\bpublish AGENTS sync\b/gi, "publish AGENTS alignment");
-
-writeFileSync(file, s, "utf8");

package/scripts/sync-oss.mjs

@@ -1,128 +0,0 @@
-/**
- * Populates ../DeukAgentRulesOSS for the public GitHub repo.
- * Run: cd deuk-agent-rule && npm run sync:oss
- */
-import { cpSync, existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "fs";
-import { dirname, join } from "path";
-import { fileURLToPath } from "url";
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const pkgRoot = join(__dirname, "..");
-const repoRoot = join(pkgRoot, "..");
-const ossRoot = join(repoRoot, "DeukAgentRulesOSS");
-const ossPublic = join(pkgRoot, "oss-public");
-
-/** Set DEUK_AGENT_RULES_OSS_REPO to override, e.g. https://github.com/you/DeukAgentRulesOSS */
-const OSS_REPO =
-  process.env.DEUK_AGENT_RULES_OSS_REPO || "https://github.com/joygram/DeukAgentRules";
-
-function gitBase() {
-  let u = OSS_REPO.trim().replace(/\.git$/i, "").replace(/\/$/, "");
-  if (!u.startsWith("http")) return u;
-  return u;
-}
-
-const base = gitBase();
-const gitUrl = base.startsWith("http") ? "git+" + base + ".git" : base;
-
-/** Public mirror: no prebump/postchangelog (internal sync / polish hooks). */
-function stripOssVersionrcScripts(ossVersionrcPath) {
-  let t = readFileSync(ossVersionrcPath, "utf8").replace(/\r\n/g, "\n");
-  t = t.replace(/\n  scripts:\s*\{\n[\s\S]*?\n  \},\s*\n/, "\n");
-  writeFileSync(ossVersionrcPath, t, "utf8");
-}
-
-mkdirSync(join(ossRoot, "scripts"), { recursive: true });
-mkdirSync(join(ossRoot, "publish"), { recursive: true });
-
-cpSync(join(pkgRoot, "publish"), join(ossRoot, "publish"), { recursive: true, force: true });
-if (existsSync(join(pkgRoot, ".github"))) {
-  cpSync(join(pkgRoot, ".github"), join(ossRoot, ".github"), { recursive: true, force: true });
-}
-cpSync(join(pkgRoot, "scripts", "cli.mjs"), join(ossRoot, "scripts", "cli.mjs"), { force: true });
-cpSync(join(pkgRoot, "scripts", "merge-logic.mjs"), join(ossRoot, "scripts", "merge-logic.mjs"), {
-  force: true,
-});
-cpSync(join(pkgRoot, "scripts", "sync-bundle.mjs"), join(ossRoot, "scripts", "sync-bundle.mjs"), {
-  force: true,
-});
-
-if (!existsSync(ossPublic)) {
-  throw new Error("Missing oss-public/: " + ossPublic);
-}
-cpSync(join(pkgRoot, "README.md"), join(ossRoot, "README.md"), { force: true });
-cpSync(join(pkgRoot, "README.ko.md"), join(ossRoot, "README.ko.md"), { force: true });
-if (existsSync(join(pkgRoot, "CHANGELOG.md"))) {
-  cpSync(join(pkgRoot, "CHANGELOG.md"), join(ossRoot, "CHANGELOG.md"), { force: true });
-}
-if (existsSync(join(pkgRoot, "package-lock.json"))) {
-  cpSync(join(pkgRoot, "package-lock.json"), join(ossRoot, "package-lock.json"), { force: true });
-}
-if (existsSync(join(pkgRoot, "LICENSE"))) {
-  cpSync(join(pkgRoot, "LICENSE"), join(ossRoot, "LICENSE"), { force: true });
-}
-if (existsSync(join(pkgRoot, ".npmrc"))) {
-  cpSync(join(pkgRoot, ".npmrc"), join(ossRoot, ".npmrc"), { force: true });
-}
-if (existsSync(join(pkgRoot, ".versionrc.cjs"))) {
-  cpSync(join(pkgRoot, ".versionrc.cjs"), join(ossRoot, ".versionrc.cjs"), { force: true });
-  stripOssVersionrcScripts(join(ossRoot, ".versionrc.cjs"));
-}
-const changelogTemplates = join(pkgRoot, "changelog-templates");
-if (existsSync(changelogTemplates)) {
-  cpSync(changelogTemplates, join(ossRoot, "changelog-templates"), { recursive: true, force: true });
-}
-cpSync(join(ossPublic, "RELEASING.md"), join(ossRoot, "RELEASING.md"), { force: true });
-cpSync(join(ossPublic, "RELEASING.ko.md"), join(ossRoot, "RELEASING.ko.md"), { force: true });
-cpSync(join(ossPublic, "GITHUB_DESCRIPTION.md"), join(ossRoot, "GITHUB_DESCRIPTION.md"), {
-  force: true,
-});
-
-const srcPkg = JSON.parse(readFileSync(join(pkgRoot, "package.json"), "utf8"));
-const outPkg = {
-  ...srcPkg,
-  license: srcPkg.license || "Apache-2.0",
-  repository: {
-    type: "git",
-    url: gitUrl,
-  },
-  bugs: {
-    url: base.startsWith("http") ? base + "/issues" : base,
-  },
-  homepage: base.startsWith("http") ? base + "#readme" : base,
-  files: [
-    "LICENSE",
-    "bundle/**/*",
-    "scripts/**/*.mjs",
-    "README.md",
-    "README.ko.md",
-    "CHANGELOG.md",
-  ],
-};
-delete outPkg.private;
-if (outPkg.scripts && outPkg.scripts["merge:dry"]) {
-  const { "merge:dry": _md, ...r2 } = outPkg.scripts;
-  outPkg.scripts = r2;
-}
-if (outPkg.scripts && outPkg.scripts["sync:oss"]) {
-  const { "sync:oss": _drop, ...rest } = outPkg.scripts;
-  outPkg.scripts = rest;
-}
-/** Mirror is not a publish/version source: no bump scripts or release devDependencies. */
-for (const k of ["bump", "bump:patch", "bump:minor", "bump:major"]) {
-  if (outPkg.scripts && outPkg.scripts[k]) {
-    const { [k]: _drop, ...rest } = outPkg.scripts;
-    outPkg.scripts = rest;
-  }
-}
-delete outPkg.devDependencies;
-
-writeFileSync(join(ossRoot, "package.json"), JSON.stringify(outPkg, null, 2) + "\n", "utf8");
-
-const ossPolish = join(ossRoot, "scripts", "changelog-polish.mjs");
-if (existsSync(ossPolish)) {
-  unlinkSync(ossPolish);
-}
-
-console.log("deuk-agent-rule: synced OSS tree at " + ossRoot);
-console.log("  Override repo URL: DEUK_AGENT_RULES_OSS_REPO=https://github.com/org/DeukAgentRulesOSS");