@jazpiper/rules-doctor 0.1.0 → 0.2.0

package/README.md

@@ -1,6 +1,10 @@
 # @jazpiper/rules-doctor
 
-`rules-doctor` is a Node.js CLI (TypeScript) that keeps agent instruction files in sync from one source of truth: `.agentrules/rules.yaml`.
+`rules-doctor` is a Node.js CLI that keeps agent instruction files in sync from one source of truth: `.agentrules/rules.yaml`.
+
+It is designed for multi-agent workflows where each coding CLI reads a different file format.
+
+By default, commands resolve paths relative to the project root (`.git` ancestor), not the current subdirectory.
 
 ## Install
 
@@ -36,11 +40,15 @@ Creates `.agentrules/rules.yaml` if it does not exist.
 rules-doctor sync
 rules-doctor sync --target claude
 rules-doctor sync --target codex
+rules-doctor sync --target cursor,gemini,opencode,antigravity
 ```
 
 Generates/updates:
-- `CLAUDE.md` (fully managed)
-- `AGENTS.md` (only content inside markers is managed)
+- `CLAUDE.md` (`claude`, fully managed)
+- `AGENTS.md` (`codex`, `opencode`, marker-managed)
+- `.cursor/rules/rules-doctor.mdc` (`cursor`, fully managed)
+- `GEMINI.md` (`gemini`, fully managed)
+- `GEMINI.md` (`antigravity`, inferred-compatible mapping)
 
 Managed marker block in `AGENTS.md`:
 
@@ -58,10 +66,74 @@ If markers are missing, a new managed block is appended to the end of `AGENTS.md
 rules-doctor analyze
 ```
 
-Reads `CLAUDE.md` and `AGENTS.md`, then prints a concise report about:
+Reads enabled target files from `rules.yaml`, then prints a concise report about:
 - missing markers
 - missing verify commands (`lint`/`test`/`build`)
-- obvious contradictions (simple heuristics)
+- obvious contradictions (simple heuristics across generated targets)
+
+`--strict` makes `analyze` fail with non-zero exit code when findings exist.
+
+### 4) List supported adapters
+
+```bash
+rules-doctor targets list
+```
+
+Shows built-in adapters and default file paths.
+
+### 5) Directory/Path Notes
+
+- `claude`: searches `CLAUDE.md` from current directory upward; also supports `.claude/CLAUDE.md` and `.claude/rules/*.md`.
+- `codex`: looks for `AGENTS.override.md` or `AGENTS.md` from project root down to current directory.
+- `opencode`: reads project `AGENTS.md`, plus user global `~/.config/opencode/AGENTS.md`.
+- `cursor`: project rules live in `.cursor/rules/*.mdc` (legacy `.cursorrules` still exists).
+- `gemini`: uses `GEMINI.md` in workspace/ancestor directories and `~/.gemini/GEMINI.md`.
+- `antigravity`: currently mapped to `GEMINI.md` as an inferred default; verify in your environment.
+
+## Rules Schema (v2 Draft)
+
+`init` now creates a v2-compatible draft with `targets` configuration:
+
+```yaml
+version: 2
+mission: "Ship safe changes quickly while keeping agent instructions consistent."
+workflow:
+  - "Read relevant files before editing."
+  - "Make the smallest correct change."
+  - "Run verification commands before finalizing."
+commands:
+  lint: "npm run lint"
+  test: "npm run test"
+  build: "npm run build"
+done:
+  - "Commands pass or blockers are documented."
+  - "Changed behavior is reflected in docs where needed."
+approvals:
+  mode: "ask-before-destructive"
+  notes:
+    - "Ask before destructive actions or privileged operations."
+targets:
+  claude:
+    enabled: true
+    path: "CLAUDE.md"
+  codex:
+    enabled: true
+    path: "AGENTS.md"
+  cursor:
+    enabled: true
+    path: ".cursor/rules/rules-doctor.mdc"
+  gemini:
+    enabled: true
+    path: "GEMINI.md"
+  opencode:
+    enabled: true
+    path: "AGENTS.md"
+  antigravity:
+    enabled: true
+    path: "GEMINI.md"
+```
+
+You can disable or relocate any target by editing `targets.<id>.enabled/path`.
 
 ## Development
 

package/dist/adapters/antigravity.js

@@ -0,0 +1,12 @@
+const { renderManagedRulesBody } = require("./common");
+
+module.exports = {
+  id: "antigravity",
+  name: "Antigravity CLI",
+  description: "Generate GEMINI.md-compatible managed instruction file (inferred mapping).",
+  defaultPath: "GEMINI.md",
+  management: "full",
+  render(rules) {
+    return ["# GEMINI.md", "", renderManagedRulesBody(rules)].join("\n");
+  },
+};

package/dist/adapters/claude.js

@@ -0,0 +1,31 @@
+const { formatCommands, formatList } = require("./common");
+
+module.exports = {
+  id: "claude",
+  name: "Claude Code",
+  description: "Generate CLAUDE.md from rules.yaml.",
+  defaultPath: "CLAUDE.md",
+  management: "full",
+  render(rules) {
+    return [
+      "# CLAUDE.md",
+      "",
+      "## Mission",
+      rules.mission,
+      "",
+      "## Workflow",
+      formatList(rules.workflow),
+      "",
+      "## Commands",
+      formatCommands(rules.commands),
+      "",
+      "## Done",
+      formatList(rules.done),
+      "",
+      "## Approvals",
+      `- Mode: \`${rules.approvals.mode}\``,
+      ...rules.approvals.notes.map((note) => `- ${note}`),
+      "",
+    ].join("\n");
+  },
+};

package/dist/adapters/codex.js

@@ -0,0 +1,14 @@
+const { renderManagedRulesBody } = require("./common");
+
+module.exports = {
+  id: "codex",
+  name: "Codex CLI",
+  description: "Manage AGENTS.md via marker-managed section.",
+  defaultPath: "AGENTS.md",
+  management: "marker",
+  markerBegin: "<!-- RULES_DOCTOR:BEGIN -->",
+  markerEnd: "<!-- RULES_DOCTOR:END -->",
+  render(rules) {
+    return renderManagedRulesBody(rules);
+  },
+};

package/dist/adapters/common.js

@@ -0,0 +1,54 @@
+function formatList(items) {
+  if (!Array.isArray(items) || items.length === 0) {
+    return "- (none)";
+  }
+  return items.map((item) => `- ${item}`).join("\n");
+}
+
+function formatCommands(commands) {
+  if (!commands || typeof commands !== "object") {
+    return "- (none)";
+  }
+
+  const preferredOrder = ["lint", "test", "build"];
+  const names = [
+    ...preferredOrder.filter((name) => Object.prototype.hasOwnProperty.call(commands, name)),
+    ...Object.keys(commands).filter((name) => !preferredOrder.includes(name)),
+  ];
+
+  if (names.length === 0) {
+    return "- (none)";
+  }
+
+  return names.map((name) => `- ${name}: \`${commands[name]}\``).join("\n");
+}
+
+function renderManagedRulesBody(rules) {
+  return [
+    "## rules-doctor Managed Rules",
+    "Generated from `.agentrules/rules.yaml`. Edit that file, then run `rules-doctor sync`.",
+    "",
+    "### Mission",
+    rules.mission,
+    "",
+    "### Workflow",
+    formatList(rules.workflow),
+    "",
+    "### Commands",
+    formatCommands(rules.commands),
+    "",
+    "### Done",
+    formatList(rules.done),
+    "",
+    "### Approvals",
+    `- Policy: \`${rules.approvals.mode}\``,
+    ...rules.approvals.notes.map((note) => `- ${note}`),
+    "",
+  ].join("\n");
+}
+
+module.exports = {
+  formatCommands,
+  formatList,
+  renderManagedRulesBody,
+};

package/dist/adapters/cursor.js

@@ -0,0 +1,19 @@
+const { renderManagedRulesBody } = require("./common");
+
+module.exports = {
+  id: "cursor",
+  name: "Cursor",
+  description: "Manage .cursor/rules/rules-doctor.mdc as an always-applied project rule.",
+  defaultPath: ".cursor/rules/rules-doctor.mdc",
+  management: "full",
+  render(rules) {
+    return [
+      "---",
+      "description: rules-doctor managed coding rules",
+      "alwaysApply: true",
+      "---",
+      "",
+      renderManagedRulesBody(rules),
+    ].join("\n");
+  },
+};

package/dist/adapters/gemini.js

@@ -0,0 +1,12 @@
+const { renderManagedRulesBody } = require("./common");
+
+module.exports = {
+  id: "gemini",
+  name: "Gemini CLI",
+  description: "Generate GEMINI.md managed instruction file.",
+  defaultPath: "GEMINI.md",
+  management: "full",
+  render(rules) {
+    return ["# GEMINI.md", "", renderManagedRulesBody(rules)].join("\n");
+  },
+};

package/dist/adapters/index.js

@@ -0,0 +1,14 @@
+const claude = require("./claude");
+const codex = require("./codex");
+const cursor = require("./cursor");
+const gemini = require("./gemini");
+const opencode = require("./opencode");
+const antigravity = require("./antigravity");
+
+const ADAPTERS = [claude, codex, cursor, gemini, opencode, antigravity];
+const ADAPTERS_BY_ID = Object.fromEntries(ADAPTERS.map((adapter) => [adapter.id, adapter]));
+
+module.exports = {
+  ADAPTERS,
+  ADAPTERS_BY_ID,
+};

package/dist/adapters/opencode.js

@@ -0,0 +1,14 @@
+const { renderManagedRulesBody } = require("./common");
+
+module.exports = {
+  id: "opencode",
+  name: "OpenCode CLI",
+  description: "Manage AGENTS.md via marker-managed section (OpenCode rules).",
+  defaultPath: "AGENTS.md",
+  management: "marker",
+  markerBegin: "<!-- RULES_DOCTOR:BEGIN -->",
+  markerEnd: "<!-- RULES_DOCTOR:END -->",
+  render(rules) {
+    return renderManagedRulesBody(rules);
+  },
+};

package/dist/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/index.js

@@ -1,32 +1,43 @@
 #!/usr/bin/env node
+const { dirname, isAbsolute, resolve } = require("node:path");
 const { existsSync, mkdirSync, readFileSync, writeFileSync } = require("node:fs");
-const { resolve } = require("node:path");
+const { ADAPTERS, ADAPTERS_BY_ID } = require("./adapters");
 
-const RULES_FILE = resolve(".agentrules/rules.yaml");
-const CLAUDE_FILE = resolve("CLAUDE.md");
-const AGENTS_FILE = resolve("AGENTS.md");
-const MARKER_BEGIN = "<!-- RULES_DOCTOR:BEGIN -->";
-const MARKER_END = "<!-- RULES_DOCTOR:END -->";
+const RULES_RELATIVE_PATH = ".agentrules/rules.yaml";
 
 function usage() {
+  const targets = ADAPTERS.map((adapter) => adapter.id).join("|");
   return [
     "rules-doctor",
     "",
     "Usage:",
     "  rules-doctor init",
-    "  rules-doctor sync [--target all|claude|codex]",
+    `  rules-doctor sync [--target all|${targets}|<comma-separated-targets>]`,
     "  rules-doctor analyze",
+    "  rules-doctor targets list",
   ].join("\n");
 }
 
+function createLogger(options) {
+  return {
+    log:
+      options && typeof options.stdout === "function"
+        ? options.stdout
+        : (message) => console.log(message),
+    error:
+      options && typeof options.stderr === "function"
+        ? options.stderr
+        : (message) => console.error(message),
+  };
+}
+
 function readJsonFile(filePath) {
   if (!existsSync(filePath)) {
     return null;
   }
 
   try {
-    const raw = readFileSync(filePath, "utf8");
-    return JSON.parse(raw);
+    return JSON.parse(readFileSync(filePath, "utf8"));
   } catch {
     return null;
   }
@@ -49,6 +60,12 @@ function stripQuotes(value) {
 
 function parseScalar(value) {
   const cleaned = stripQuotes(value);
+  if (/^(true|false)$/i.test(cleaned)) {
+    return cleaned.toLowerCase() === "true";
+  }
+  if (cleaned === "null" || cleaned === "~") {
+    return null;
+  }
   if (/^-?\d+$/.test(cleaned)) {
     return Number(cleaned);
   }
@@ -70,6 +87,7 @@ function parseRulesText(text) {
   const lines = text.replace(/\r\n/g, "\n").split("\n");
   let section = null;
   let nested = null;
+  let currentTarget = null;
 
   for (const rawLine of lines) {
     if (!rawLine.trim() || rawLine.trim().startsWith("#")) {
@@ -81,6 +99,8 @@ function parseRulesText(text) {
 
     if (indent === 0) {
       nested = null;
+      currentTarget = null;
+
       const top = line.match(/^([a-zA-Z0-9_-]+):(.*)$/);
       if (!top) {
         continue;
@@ -88,11 +108,12 @@ function parseRulesText(text) {
 
       const key = top[1];
       const value = top[2].trim();
+
       if (!value) {
         section = key;
         if (key === "workflow" || key === "done") {
           data[key] = [];
-        } else if (key === "commands" || key === "approvals") {
+        } else if (key === "commands" || key === "approvals" || key === "targets") {
           data[key] = {};
         }
       } else {
@@ -132,6 +153,35 @@ function parseRulesText(text) {
       if (nested === "notes" && line.startsWith("- ")) {
         data.approvals.notes.push(parseScalar(line.slice(2)));
       }
+      continue;
+    }
+
+    if (section === "targets") {
+      if (indent === 2) {
+        const target = line.match(/^([a-zA-Z0-9_-]+):(.*)$/);
+        if (!target) {
+          continue;
+        }
+
+        currentTarget = target[1];
+        const maybeValue = target[2].trim();
+        if (!maybeValue) {
+          data.targets[currentTarget] = {};
+        } else {
+          data.targets[currentTarget] = { path: parseScalar(maybeValue), enabled: true };
+        }
+        continue;
+      }
+
+      if (indent >= 4 && currentTarget) {
+        const pair = line.match(/^([a-zA-Z0-9_-]+):(.*)$/);
+        if (pair) {
+          if (!data.targets[currentTarget] || typeof data.targets[currentTarget] !== "object") {
+            data.targets[currentTarget] = {};
+          }
+          data.targets[currentTarget][pair[1]] = parseScalar(pair[2].trim());
+        }
+      }
     }
   }
 
@@ -139,31 +189,15 @@ function parseRulesText(text) {
 }
 
 function quoteYaml(value) {
+  if (typeof value === "number" || typeof value === "boolean") {
+    return String(value);
+  }
+  if (value === null || typeof value === "undefined") {
+    return "null";
+  }
   return JSON.stringify(String(value));
 }
 
-function stringifyRules(rules) {
-  const lines = [
-    `version: ${Number.isFinite(rules.version) ? rules.version : 1}`,
-    `mission: ${quoteYaml(rules.mission)}`,
-    "workflow:",
-    ...rules.workflow.map((step) => `  - ${quoteYaml(step)}`),
-    "commands:",
-    ...Object.keys(rules.commands).map(
-      (name) => `  ${name}: ${quoteYaml(rules.commands[name])}`,
-    ),
-    "done:",
-    ...rules.done.map((item) => `  - ${quoteYaml(item)}`),
-    "approvals:",
-    `  mode: ${quoteYaml(rules.approvals.mode)}`,
-    "  notes:",
-    ...rules.approvals.notes.map((note) => `    - ${quoteYaml(note)}`),
-    "",
-  ];
-
-  return lines.join("\n");
-}
-
 function inferCommandFromScripts(scripts, scriptName) {
   if (scripts && typeof scripts[scriptName] === "string") {
     return `npm run ${scriptName}`;
@@ -171,12 +205,17 @@ function inferCommandFromScripts(scripts, scriptName) {
   return `echo "TODO: define ${scriptName} command"`;
 }
 
-function createDefaultRules() {
-  const pkg = readJsonFile(resolve("package.json"));
-  const scripts = pkg && typeof pkg === "object" ? pkg.scripts : undefined;
+function createDefaultRules(scripts) {
+  const targets = {};
+  for (const adapter of ADAPTERS) {
+    targets[adapter.id] = {
+      enabled: true,
+      path: adapter.defaultPath,
+    };
+  }
 
   return {
-    version: 1,
+    version: 2,
     mission: "Ship safe changes quickly while keeping agent instructions consistent.",
     workflow: [
       "Read relevant files before editing.",
@@ -196,322 +235,488 @@ function createDefaultRules() {
       mode: "ask-before-destructive",
       notes: ["Ask before destructive actions or privileged operations."],
     },
+    targets,
+  };
+}
+
+function normalizeTargetConfig(source, fallbackPath) {
+  if (typeof source === "string" && source.trim()) {
+    return { enabled: true, path: source.trim() };
+  }
+
+  if (!source || typeof source !== "object") {
+    return { enabled: true, path: fallbackPath };
+  }
+
+  return {
+    enabled: typeof source.enabled === "boolean" ? source.enabled : true,
+    path: typeof source.path === "string" && source.path.trim() ? source.path.trim() : fallbackPath,
   };
 }
 
-function normalizeRules(input) {
+function normalizeRules(input, defaults) {
   const source = input && typeof input === "object" ? input : {};
   const commands = source.commands && typeof source.commands === "object" ? source.commands : {};
   const approvals =
     source.approvals && typeof source.approvals === "object" ? source.approvals : {};
+  const sourceTargets = source.targets && typeof source.targets === "object" ? source.targets : {};
 
   const workflow = Array.isArray(source.workflow)
     ? source.workflow.filter((item) => typeof item === "string")
-    : ["Define your workflow steps."];
+    : defaults.workflow;
 
   const done = Array.isArray(source.done)
     ? source.done.filter((item) => typeof item === "string")
-    : ["Define done criteria."];
+    : defaults.done;
 
   const notes = Array.isArray(approvals.notes)
     ? approvals.notes.filter((item) => typeof item === "string")
-    : [];
+    : defaults.approvals.notes;
+
+  const targets = {};
+  for (const adapter of ADAPTERS) {
+    targets[adapter.id] = normalizeTargetConfig(sourceTargets[adapter.id], defaults.targets[adapter.id].path);
+  }
+
+  for (const customId of Object.keys(sourceTargets)) {
+    if (targets[customId]) {
+      continue;
+    }
+    targets[customId] = normalizeTargetConfig(sourceTargets[customId], `${customId.toUpperCase()}.md`);
+  }
 
   return {
-    version: typeof source.version === "number" ? source.version : 1,
+    version: typeof source.version === "number" ? source.version : defaults.version,
     mission:
-      typeof source.mission === "string" && source.mission.trim()
-        ? source.mission
-        : "Define your project mission.",
-    workflow,
+      typeof source.mission === "string" && source.mission.trim() ? source.mission : defaults.mission,
+    workflow: workflow.length > 0 ? workflow : defaults.workflow,
     commands: {
-      lint:
-        typeof commands.lint === "string"
-          ? commands.lint
-          : 'echo "TODO: define lint command"',
-      test:
-        typeof commands.test === "string"
-          ? commands.test
-          : 'echo "TODO: define test command"',
-      build:
-        typeof commands.build === "string"
-          ? commands.build
-          : 'echo "TODO: define build command"',
+      lint: typeof commands.lint === "string" ? commands.lint : defaults.commands.lint,
+      test: typeof commands.test === "string" ? commands.test : defaults.commands.test,
+      build: typeof commands.build === "string" ? commands.build : defaults.commands.build,
     },
-    done,
+    done: done.length > 0 ? done : defaults.done,
     approvals: {
-      mode:
-        typeof approvals.mode === "string" ? approvals.mode : "ask-before-destructive",
+      mode: typeof approvals.mode === "string" ? approvals.mode : defaults.approvals.mode,
       notes,
     },
+    targets,
   };
 }
 
-function readRulesOrThrow() {
-  if (!existsSync(RULES_FILE)) {
-    throw new Error(`Missing ${RULES_FILE}. Run "rules-doctor init" to create it first.`);
+function stringifyRules(rules) {
+  const knownTargetIds = ADAPTERS.map((adapter) => adapter.id);
+  const allTargetIds = [
+    ...knownTargetIds.filter((id) => Object.prototype.hasOwnProperty.call(rules.targets || {}, id)),
+    ...Object.keys(rules.targets || {})
+      .filter((id) => !knownTargetIds.includes(id))
+      .sort(),
+  ];
+
+  const lines = [
+    `version: ${quoteYaml(Number.isFinite(rules.version) ? rules.version : 2)}`,
+    `mission: ${quoteYaml(rules.mission)}`,
+    "workflow:",
+    ...rules.workflow.map((step) => `  - ${quoteYaml(step)}`),
+    "commands:",
+    ...Object.keys(rules.commands).map((name) => `  ${name}: ${quoteYaml(rules.commands[name])}`),
+    "done:",
+    ...rules.done.map((item) => `  - ${quoteYaml(item)}`),
+    "approvals:",
+    `  mode: ${quoteYaml(rules.approvals.mode)}`,
+    "  notes:",
+    ...rules.approvals.notes.map((note) => `    - ${quoteYaml(note)}`),
+    "targets:",
+  ];
+
+  for (const id of allTargetIds) {
+    const config = normalizeTargetConfig(rules.targets[id], `${id.toUpperCase()}.md`);
+    lines.push(`  ${id}:`);
+    lines.push(`    enabled: ${quoteYaml(config.enabled)}`);
+    lines.push(`    path: ${quoteYaml(config.path)}`);
   }
 
-  const raw = readFileSync(RULES_FILE, "utf8");
-  return normalizeRules(parseRulesText(raw));
+  lines.push("");
+  return lines.join("\n");
 }
 
-function formatList(items) {
-  if (!Array.isArray(items) || items.length === 0) {
-    return "- (none)";
-  }
-  return items.map((item) => `- ${item}`).join("\n");
+function hasVerifyCommand(text) {
+  return /\b(npm run|pnpm|yarn|bun)\s+(lint|test|build)\b/i.test(text);
 }
 
-function formatCommands(commands) {
-  if (!commands || typeof commands !== "object") {
-    return "- (none)";
-  }
+function hasNoApprovalLanguage(text) {
+  return /never ask (for )?approval|no approvals|without approval|do not ask for approval/i.test(
+    text,
+  );
+}
 
-  const preferredOrder = ["lint", "test", "build"];
-  const names = [
-    ...preferredOrder.filter((name) => Object.prototype.hasOwnProperty.call(commands, name)),
-    ...Object.keys(commands).filter((name) => !preferredOrder.includes(name)),
-  ];
+function hasAskApprovalLanguage(text) {
+  return /ask for approval|request approval|require approval|needs approval/i.test(text);
+}
 
-  if (names.length === 0) {
-    return "- (none)";
-  }
+function hasRequireTestsLanguage(text) {
+  return /must run tests|always run tests|run tests before done/i.test(text);
+}
 
-  return names.map((name) => `- ${name}: \`${commands[name]}\``).join("\n");
+function hasSkipTestsLanguage(text) {
+  return /skip tests|tests optional|do not run tests/i.test(text);
 }
 
-function renderClaude(rules) {
-  return [
-    "# CLAUDE.md",
-    "",
-    "## Mission",
-    rules.mission,
-    "",
-    "## Workflow",
-    formatList(rules.workflow),
-    "",
-    "## Commands",
-    formatCommands(rules.commands),
-    "",
-    "## Done",
-    formatList(rules.done),
-    "",
-    "## Approvals",
-    `- Mode: \`${rules.approvals.mode}\``,
-    ...rules.approvals.notes.map((note) => `- ${note}`),
-    "",
-  ].join("\n");
+function resolveInRoot(rootDir, filePath) {
+  if (isAbsolute(filePath)) {
+    return filePath;
+  }
+  return resolve(rootDir, filePath);
 }
 
-function renderCodexManagedSection(rules) {
-  return [
-    "## rules-doctor Managed Rules",
-    "Generated from `.agentrules/rules.yaml`. Edit that file, then run `rules-doctor sync`.",
-    "",
-    "### Mission",
-    rules.mission,
-    "",
-    "### Operational Loop",
-    "1. Read relevant context and constraints before editing.",
-    "2. Select and run the smallest command that moves the task forward.",
-    "3. Apply focused changes.",
-    "4. Run verification commands and report exact outcomes.",
-    "",
-    "### Commands",
-    formatCommands(rules.commands),
-    "",
-    "### Failure Loop",
-    "1. Capture the exact failing command and error output.",
-    "2. Form one concrete hypothesis for the failure.",
-    "3. Apply one fix and rerun the same command.",
-    "4. Repeat until green or blocked, then report blocker and next action.",
-    "",
-    "### Done",
-    formatList(rules.done),
-    "",
-    "### Approvals",
-    `- Policy: \`${rules.approvals.mode}\``,
-    ...rules.approvals.notes.map((note) => `- ${note}`),
-    "",
-  ].join("\n");
+function findProjectRoot(startDir) {
+  let current = resolve(startDir);
+  while (true) {
+    const gitPath = resolve(current, ".git");
+    const rulesPath = resolve(current, RULES_RELATIVE_PATH);
+    if (existsSync(rulesPath) || existsSync(gitPath)) {
+      return current;
+    }
+
+    const parent = dirname(current);
+    if (parent === current) {
+      return resolve(startDir);
+    }
+    current = parent;
+  }
 }
 
-function upsertManagedSection(existing, content) {
-  const start = existing.indexOf(MARKER_BEGIN);
-  const end = start >= 0 ? existing.indexOf(MARKER_END, start) : -1;
+function ensureParentDirectory(filePath) {
+  mkdirSync(dirname(filePath), { recursive: true });
+}
+
+function upsertManagedSection(existing, content, beginMarker, endMarker) {
+  const start = existing.indexOf(beginMarker);
+  const end = start >= 0 ? existing.indexOf(endMarker, start) : -1;
 
   if (start >= 0 && end > start) {
-    const before = existing.slice(0, start + MARKER_BEGIN.length);
+    const before = existing.slice(0, start + beginMarker.length);
     const after = existing.slice(end);
     return `${before}\n${content.trim()}\n${after}`.replace(/\n{3,}/g, "\n\n");
   }
 
   const base = existing.trimEnd();
   const prefix = base ? `${base}\n\n` : "";
-  return `${prefix}${MARKER_BEGIN}\n${content.trim()}\n${MARKER_END}\n`;
+  return `${prefix}${beginMarker}\n${content.trim()}\n${endMarker}\n`;
 }
 
-function initCommand() {
-  if (existsSync(RULES_FILE)) {
-    console.log(`rules.yaml already exists: ${RULES_FILE}`);
-    return;
+function loadPackageScripts(rootDir) {
+  const pkg = readJsonFile(resolve(rootDir, "package.json"));
+  if (!pkg || typeof pkg !== "object" || !pkg.scripts || typeof pkg.scripts !== "object") {
+    return {};
+  }
+  return pkg.scripts;
+}
+
+function loadRules(rootDir, options) {
+  const rulesFile = resolve(rootDir, RULES_RELATIVE_PATH);
+  const defaults = createDefaultRules(loadPackageScripts(rootDir));
+
+  if (!existsSync(rulesFile)) {
+    if (options && options.allowMissing) {
+      return {
+        rules: defaults,
+        rulesFile,
+        rulesExists: false,
+      };
+    }
+    throw new Error(`Missing ${rulesFile}. Run "rules-doctor init" to create it first.`);
   }
 
-  mkdirSync(resolve(".agentrules"), { recursive: true });
-  writeFileSync(RULES_FILE, stringifyRules(createDefaultRules()), "utf8");
-  console.log(`Created ${RULES_FILE}`);
+  const parsed = parseRulesText(readFileSync(rulesFile, "utf8"));
+  return {
+    rules: normalizeRules(parsed, defaults),
+    rulesFile,
+    rulesExists: true,
+  };
 }
 
-function syncCommand(target) {
-  const rules = readRulesOrThrow();
+function getTargetsFromSpec(spec) {
+  if (spec === "all") {
+    return ADAPTERS.map((adapter) => adapter.id);
+  }
 
-  if (target === "all" || target === "claude") {
-    writeFileSync(CLAUDE_FILE, renderClaude(rules), "utf8");
-    console.log(`Updated ${CLAUDE_FILE}`);
+  const unique = [];
+  for (const raw of spec.split(",")) {
+    const id = raw.trim();
+    if (!id) {
+      continue;
+    }
+    if (!ADAPTERS_BY_ID[id]) {
+      throw new Error(
+        `Unknown target "${id}". Use one of: all, ${ADAPTERS.map((adapter) => adapter.id).join(", ")}`,
+      );
+    }
+    if (!unique.includes(id)) {
+      unique.push(id);
+    }
   }
 
-  if (target === "all" || target === "codex") {
-    const existing = existsSync(AGENTS_FILE) ? readFileSync(AGENTS_FILE, "utf8") : "";
-    const updated = upsertManagedSection(existing, renderCodexManagedSection(rules));
-    writeFileSync(AGENTS_FILE, updated, "utf8");
-    console.log(`Updated ${AGENTS_FILE}`);
+  if (unique.length === 0) {
+    throw new Error("No targets selected.");
   }
-}
 
-function hasVerifyCommand(text) {
-  return /\b(npm run|pnpm|yarn)\s+(lint|test|build)\b/i.test(text);
+  return unique;
 }
 
-function hasNoApprovalLanguage(text) {
-  return /never ask (for )?approval|no approvals|without approval|do not ask for approval/i.test(
-    text,
-  );
-}
+function parseSyncTargets(args) {
+  if (!args || args.length === 0) {
+    return ADAPTERS.map((adapter) => adapter.id);
+  }
 
-function hasAskApprovalLanguage(text) {
-  return /ask for approval|request approval|require approval|needs approval/i.test(text);
-}
+  let targetSpec = "all";
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === "--target") {
+      const value = args[index + 1];
+      if (!value) {
+        throw new Error("Missing value for --target");
+      }
+      targetSpec = value;
+      index += 1;
+      continue;
+    }
 
-function hasRequireTestsLanguage(text) {
-  return /must run tests|always run tests|run tests before done/i.test(text);
-}
+    throw new Error(`Unknown option for sync: ${arg}`);
+  }
 
-function hasSkipTestsLanguage(text) {
-  return /skip tests|tests optional|do not run tests/i.test(text);
+  return getTargetsFromSpec(targetSpec);
 }
 
-function analyzeCommand() {
-  const claudeExists = existsSync(CLAUDE_FILE);
-  const agentsExists = existsSync(AGENTS_FILE);
-  const claude = claudeExists ? readFileSync(CLAUDE_FILE, "utf8") : "";
-  const agents = agentsExists ? readFileSync(AGENTS_FILE, "utf8") : "";
-  const issues = [];
-
-  if (!claudeExists) {
-    issues.push("CLAUDE.md missing.");
-  }
-  if (!agentsExists) {
-    issues.push("AGENTS.md missing.");
+function parseAnalyzeArgs(args) {
+  if (!args || args.length === 0) {
+    return {};
   }
 
-  if (agentsExists) {
-    const hasBegin = agents.includes(MARKER_BEGIN);
-    const hasEnd = agents.includes(MARKER_END);
-    if (!hasBegin || !hasEnd) {
-      issues.push("AGENTS.md missing rules-doctor markers.");
+  for (const arg of args) {
+    if (arg === "--strict") {
+      return { strict: true };
     }
+    throw new Error(`Unknown option for analyze: ${arg}`);
   }
 
-  if (claudeExists && !hasVerifyCommand(claude)) {
-    issues.push("CLAUDE.md appears to be missing verify commands (lint/test/build).");
-  }
+  return {};
+}
 
-  if (agentsExists && !hasVerifyCommand(agents)) {
-    issues.push("AGENTS.md appears to be missing verify commands (lint/test/build).");
-  }
+function getTargetConfig(rules, adapter) {
+  const source = rules.targets && typeof rules.targets === "object" ? rules.targets[adapter.id] : null;
+  return normalizeTargetConfig(source, adapter.defaultPath);
+}
 
-  if (
-    (hasNoApprovalLanguage(claude) && hasAskApprovalLanguage(agents)) ||
-    (hasAskApprovalLanguage(claude) && hasNoApprovalLanguage(agents))
-  ) {
-    issues.push("Potential contradiction: approval guidance differs between CLAUDE.md and AGENTS.md.");
+function initCommand(rootDir, logger) {
+  const rulesFile = resolve(rootDir, RULES_RELATIVE_PATH);
+  if (existsSync(rulesFile)) {
+    logger.log(`rules.yaml already exists: ${rulesFile}`);
+    return;
   }
 
-  if (
-    (hasRequireTestsLanguage(claude) && hasSkipTestsLanguage(agents)) ||
-    (hasSkipTestsLanguage(claude) && hasRequireTestsLanguage(agents))
-  ) {
-    issues.push("Potential contradiction: test guidance differs between CLAUDE.md and AGENTS.md.");
-  }
+  const defaults = createDefaultRules(loadPackageScripts(rootDir));
+  ensureParentDirectory(rulesFile);
+  writeFileSync(rulesFile, stringifyRules(defaults), "utf8");
+  logger.log(`Created ${rulesFile}`);
+}
 
-  console.log("rules-doctor analyze");
-  console.log(`- CLAUDE.md: ${claudeExists ? "found" : "missing"}`);
-  console.log(`- AGENTS.md: ${agentsExists ? "found" : "missing"}`);
-  console.log("- Findings:");
+function syncCommand(rootDir, logger, args) {
+  const { rules } = loadRules(rootDir);
+  const selectedTargetIds = parseSyncTargets(args);
 
-  if (issues.length === 0) {
-    console.log("- No obvious issues found.");
-    return;
+  let updated = 0;
+  for (const targetId of selectedTargetIds) {
+    const adapter = ADAPTERS_BY_ID[targetId];
+    const target = getTargetConfig(rules, adapter);
+
+    if (!target.enabled) {
+      logger.log(`Skipped ${targetId} (disabled in rules.yaml).`);
+      continue;
+    }
+
+    const targetPath = resolveInRoot(rootDir, target.path);
+    const rendered = adapter.render(rules).trim();
+    ensureParentDirectory(targetPath);
+
+    if (adapter.management === "marker") {
+      const existing = existsSync(targetPath) ? readFileSync(targetPath, "utf8") : "";
+      const updatedText = upsertManagedSection(
+        existing,
+        rendered,
+        adapter.markerBegin,
+        adapter.markerEnd,
+      );
+      writeFileSync(targetPath, updatedText, "utf8");
+    } else {
+      writeFileSync(targetPath, `${rendered}\n`, "utf8");
+    }
+
+    logger.log(`Updated ${targetPath} (${targetId})`);
+    updated += 1;
   }
 
-  for (const issue of issues) {
-    console.log(`- ${issue}`);
+  if (updated === 0) {
+    logger.log("No files updated.");
   }
 }
 
-function parseSyncTarget(args) {
-  let target = "all";
+function analyzeCommand(rootDir, logger, args) {
+  const options = parseAnalyzeArgs(args);
+  const { rules, rulesExists, rulesFile } = loadRules(rootDir, { allowMissing: true });
+  const issues = [];
+  const targetSnapshots = [];
 
-  for (let index = 0; index < args.length; index += 1) {
-    const arg = args[index];
-    if (arg === "--target") {
-      const value = args[index + 1];
-      if (value !== "all" && value !== "claude" && value !== "codex") {
-        throw new Error('Invalid --target value. Use one of: "all", "claude", "codex".');
-      }
-      target = value;
-      index += 1;
+  logger.log("rules-doctor analyze");
+  logger.log(`- rules.yaml: ${rulesExists ? "found" : "missing (using defaults)"}`);
+  logger.log(`- rules path: ${rulesFile}`);
+
+  for (const adapter of ADAPTERS) {
+    const target = getTargetConfig(rules, adapter);
+    const absolutePath = resolveInRoot(rootDir, target.path);
+    const fileExists = existsSync(absolutePath);
+    const content = fileExists ? readFileSync(absolutePath, "utf8") : "";
+
+    logger.log(
+      `- target ${adapter.id}: ${target.enabled ? "enabled" : "disabled"}, ${
+        fileExists ? "found" : "missing"
+      } (${target.path})`,
+    );
+
+    if (!target.enabled) {
       continue;
     }
 
-    throw new Error(`Unknown option for sync: ${arg}`);
+    if (!fileExists) {
+      issues.push(`${adapter.id}: expected file is missing (${target.path}).`);
+      continue;
+    }
+
+    if (adapter.management === "marker") {
+      const hasBegin = content.includes(adapter.markerBegin);
+      const hasEnd = content.includes(adapter.markerEnd);
+      if (!hasBegin || !hasEnd) {
+        issues.push(`${adapter.id}: marker block is missing.`);
+      }
+    }
+
+    if (!hasVerifyCommand(content)) {
+      issues.push(`${adapter.id}: verify commands (lint/test/build) not detected.`);
+    }
+
+    targetSnapshots.push({
+      id: adapter.id,
+      content,
+      asksApproval: hasAskApprovalLanguage(content),
+      noApproval: hasNoApprovalLanguage(content),
+      requiresTests: hasRequireTestsLanguage(content),
+      skipsTests: hasSkipTestsLanguage(content),
+    });
   }
 
-  return target;
-}
+  const askApprovalTargets = targetSnapshots.filter((item) => item.asksApproval).map((item) => item.id);
+  const noApprovalTargets = targetSnapshots.filter((item) => item.noApproval).map((item) => item.id);
+  if (askApprovalTargets.length > 0 && noApprovalTargets.length > 0) {
+    issues.push(
+      `Potential contradiction: approval guidance differs (${askApprovalTargets.join(
+        ", ",
+      )} vs ${noApprovalTargets.join(", ")}).`,
+    );
+  }
 
-function main() {
-  const [command, ...args] = process.argv.slice(2);
+  const requireTestsTargets = targetSnapshots
+    .filter((item) => item.requiresTests)
+    .map((item) => item.id);
+  const skipTestsTargets = targetSnapshots.filter((item) => item.skipsTests).map((item) => item.id);
+  if (requireTestsTargets.length > 0 && skipTestsTargets.length > 0) {
+    issues.push(
+      `Potential contradiction: test guidance differs (${requireTestsTargets.join(
+        ", ",
+      )} vs ${skipTestsTargets.join(", ")}).`,
+    );
+  }
 
-  if (!command || command === "--help" || command === "-h") {
-    console.log(usage());
-    return;
+  logger.log("- Findings:");
+  if (issues.length === 0) {
+    logger.log("- No obvious issues found.");
+    return 0;
   }
 
-  if (command === "init") {
-    initCommand();
-    return;
+  for (const issue of issues) {
+    logger.log(`- ${issue}`);
   }
 
-  if (command === "sync") {
-    syncCommand(parseSyncTarget(args));
-    return;
+  if (options.strict) {
+    throw new Error(`Analyze failed in strict mode with ${issues.length} issue(s).`);
   }
 
-  if (command === "analyze") {
-    analyzeCommand();
-    return;
+  return 0;
+}
+
+function targetsListCommand(logger) {
+  logger.log("Supported targets:");
+  for (const adapter of ADAPTERS) {
+    const mode = adapter.management === "marker" ? "marker-managed" : "full-managed";
+    logger.log(`- ${adapter.id}: ${adapter.name}`);
+    logger.log(`  default path: ${adapter.defaultPath}`);
+    logger.log(`  mode: ${mode}`);
+    logger.log(`  ${adapter.description}`);
   }
+}
+
+function runCli(argv, options) {
+  const args = Array.isArray(argv) ? argv : [];
+  const logger = createLogger(options || {});
+  const cwd = resolve(options && options.cwd ? options.cwd : process.cwd());
+  const rootDir = findProjectRoot(cwd);
 
-  throw new Error(`Unknown command: ${command}\n\n${usage()}`);
+  try {
+    const [command, ...rest] = args;
+
+    if (!command || command === "--help" || command === "-h") {
+      logger.log(usage());
+      return 0;
+    }
+
+    if (command === "init") {
+      initCommand(rootDir, logger);
+      return 0;
+    }
+
+    if (command === "sync") {
+      syncCommand(rootDir, logger, rest);
+      return 0;
+    }
+
+    if (command === "analyze") {
+      return analyzeCommand(rootDir, logger, rest);
+    }
+
+    if (command === "targets") {
+      if (rest.length === 1 && rest[0] === "list") {
+        targetsListCommand(logger);
+        return 0;
+      }
+      throw new Error('Unknown targets command. Use "rules-doctor targets list".');
+    }
+
+    throw new Error(`Unknown command: ${command}\n\n${usage()}`);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    logger.error(`Error: ${message}`);
+    return 1;
+  }
 }
 
-try {
-  main();
-} catch (error) {
-  const message = error instanceof Error ? error.message : String(error);
-  console.error(`Error: ${message}`);
-  process.exitCode = 1;
+if (require.main === module) {
+  process.exitCode = runCli(process.argv.slice(2));
 }
 
+module.exports = {
+  ADAPTERS,
+  createDefaultRules,
+  normalizeRules,
+  parseRulesText,
+  runCli,
+  stringifyRules,
+};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@jazpiper/rules-doctor",
-  "version": "0.1.0",
-  "description": "Node.js CLI to keep agent rules in sync across CLAUDE.md and AGENTS.md",
+  "version": "0.2.0",
+  "description": "Node.js CLI to sync shared coding rules across multiple agent/CLI targets",
   "license": "MIT",
   "bin": {
     "rules-doctor": "dist/index.js"
@@ -14,7 +14,7 @@
     "LICENSE"
   ],
   "scripts": {
-    "build": "node scripts/tsup.js src/index.js --clean",
+    "build": "node scripts/tsup.js src/index.js --clean --dts",
     "test": "npm run build && node --test"
   },
   "keywords": [
@@ -22,7 +22,11 @@
     "agents",
     "rules",
     "claude",
-    "codex"
+    "codex",
+    "cursor",
+    "gemini",
+    "opencode",
+    "antigravity"
   ],
   "engines": {
     "node": ">=18"