rulix 0.1.0

package/dist/chunk-IX4ZOAKV.js

@@ -0,0 +1,1235 @@
+// src/adapters/agents-md.ts
+import { access, writeFile } from "fs/promises";
+import { join } from "path";
+var AGENTS_MD = "AGENTS.md";
+var GENERATED_HEADER = "<!-- Generated by Rulix. Do not edit directly. -->\n\n";
+var CATEGORY_LABELS = {
+  style: "Style",
+  security: "Security",
+  testing: "Testing",
+  architecture: "Architecture",
+  workflow: "Workflow",
+  general: "General"
+};
+var CATEGORY_ORDER = [
+  "architecture",
+  "style",
+  "security",
+  "testing",
+  "workflow",
+  "general"
+];
+async function pathExists(filePath) {
+  try {
+    await access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function groupByCategory(rules) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const rule of rules) {
+    const existing = groups.get(rule.category);
+    if (existing) {
+      existing.push(rule);
+    } else {
+      groups.set(rule.category, [rule]);
+    }
+  }
+  return groups;
+}
+function buildCategorySection(category, rules) {
+  const sorted = [...rules].sort((a, b) => a.priority - b.priority);
+  const label = CATEGORY_LABELS[category];
+  const sections = sorted.map((r) => `### ${r.description}
+
+${r.content}`);
+  return `## ${label}
+
+${sections.join("\n\n")}`;
+}
+function buildAgentsMdContent(rules, includeHeader) {
+  const exportable = rules.filter(
+    (r) => r.scope === "always" || r.scope === "file-scoped"
+  );
+  if (exportable.length === 0) return "";
+  const groups = groupByCategory(exportable);
+  const sections = [];
+  for (const category of CATEGORY_ORDER) {
+    const categoryRules = groups.get(category);
+    if (categoryRules && categoryRules.length > 0) {
+      sections.push(buildCategorySection(category, categoryRules));
+    }
+  }
+  const header = includeHeader ? GENERATED_HEADER : "";
+  return `${header}# AGENTS.md
+
+${sections.join("\n\n")}
+`;
+}
+var agentsMdAdapter = {
+  name: "agents-md",
+  displayName: "AGENTS.md",
+  async detect(projectRoot) {
+    return pathExists(join(projectRoot, AGENTS_MD));
+  },
+  async import(_projectRoot) {
+    return { rules: [], warnings: [], source: AGENTS_MD };
+  },
+  async export(rules, projectRoot, options) {
+    const dryRun = options?.dryRun === true;
+    const content = buildAgentsMdContent(rules, true);
+    if (content === "") {
+      return { filesWritten: [], filesDeleted: [], warnings: [] };
+    }
+    if (!dryRun) {
+      await writeFile(join(projectRoot, AGENTS_MD), content, "utf-8");
+    }
+    return {
+      filesWritten: [AGENTS_MD],
+      filesDeleted: [],
+      warnings: []
+    };
+  },
+  getTokenBudget() {
+    return {
+      maxTokens: 32768,
+      maxInstructions: 0,
+      warningThreshold: 0.8,
+      source: "AGENTS.md convention"
+    };
+  }
+};
+
+// src/core/tokenizer.ts
+var CHARS_PER_TOKEN = 4;
+function estimateTokens(text) {
+  if (text.length === 0) return 0;
+  return Math.ceil(text.length / CHARS_PER_TOKEN);
+}
+function estimateRuleTokens(content, description) {
+  return estimateTokens(`${description}
+${content}`);
+}
+function sumTokens(tokenCounts) {
+  let total = 0;
+  for (const count of tokenCounts) {
+    total += count;
+  }
+  return total;
+}
+function computeBudgetUsage(used, max) {
+  const percentage = max === 0 ? 100 : used / max * 100;
+  return {
+    used,
+    max,
+    percentage,
+    exceeded: used > max
+  };
+}
+
+// src/adapters/claude-code.ts
+import {
+  access as access2,
+  mkdir,
+  readdir,
+  readFile,
+  rm,
+  writeFile as writeFile2
+} from "fs/promises";
+import { basename, join as join2 } from "path";
+var CLAUDE_MD = "CLAUDE.md";
+var RULES_DIR = ".claude/rules";
+var CONTEXT_PREFIX = "Context: ";
+async function pathExists2(filePath) {
+  try {
+    await access2(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function listMdFiles(dir) {
+  try {
+    const entries = await readdir(dir);
+    return entries.filter((f) => f.endsWith(".md")).sort();
+  } catch {
+    return [];
+  }
+}
+function toKebabCase(text) {
+  return text.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+}
+function stripQuotes(s) {
+  const t = s.trim();
+  if (t.startsWith('"') && t.endsWith('"') || t.startsWith("'") && t.endsWith("'")) {
+    return t.slice(1, -1);
+  }
+  return t;
+}
+function splitFrontmatter(raw) {
+  const lines = raw.replace(/\r\n/g, "\n").split("\n");
+  if (lines[0]?.trim() !== "---") return null;
+  for (let i = 1; i < lines.length; i++) {
+    if (lines[i]?.trim() === "---") {
+      return {
+        yaml: lines.slice(1, i).join("\n"),
+        content: lines.slice(i + 1).join("\n").trim()
+      };
+    }
+  }
+  return null;
+}
+function parsePaths(yaml) {
+  for (const line of yaml.split("\n")) {
+    const trimmed = line.trim();
+    const colonIdx = trimmed.indexOf(":");
+    if (colonIdx === -1) continue;
+    const key = trimmed.slice(0, colonIdx).trim();
+    const value = trimmed.slice(colonIdx + 1).trim();
+    if (key === "paths" && value !== "") {
+      if (value.startsWith("[") && value.endsWith("]")) {
+        const inner = value.slice(1, -1).trim();
+        return inner === "" ? [] : inner.split(",").map(stripQuotes);
+      }
+      return [stripQuotes(value)];
+    }
+  }
+  return void 0;
+}
+function splitByH2(raw) {
+  const parts = raw.split(/^(?=## )/m);
+  let preamble = "";
+  const sections = [];
+  for (const part of parts) {
+    if (!part.startsWith("## ")) {
+      preamble = part.trim();
+      continue;
+    }
+    const newlineIdx = part.indexOf("\n");
+    if (newlineIdx === -1) {
+      sections.push({ heading: part.slice(3).trim(), content: "" });
+    } else {
+      sections.push({
+        heading: part.slice(3, newlineIdx).trim(),
+        content: part.slice(newlineIdx + 1).trim()
+      });
+    }
+  }
+  return { preamble, sections };
+}
+function createImportedRule(id, scope, description, content, filePath, globs) {
+  return {
+    id,
+    scope,
+    description,
+    content,
+    category: "general",
+    priority: 3,
+    estimatedTokens: estimateRuleTokens(content, description),
+    ...globs ? { globs } : {},
+    source: {
+      adapter: "claude-code",
+      filePath,
+      importedAt: (/* @__PURE__ */ new Date()).toISOString()
+    }
+  };
+}
+function importClaudeMdContent(raw) {
+  const content = raw.replace(/\r\n/g, "\n").trim();
+  if (content === "") return [];
+  const { preamble, sections } = splitByH2(content);
+  if (sections.length === 0) {
+    if (!preamble) return [];
+    return [
+      createImportedRule(
+        "claude-md",
+        "always",
+        "CLAUDE.md contents",
+        preamble,
+        CLAUDE_MD
+      )
+    ];
+  }
+  const rules = [];
+  if (preamble) {
+    rules.push(
+      createImportedRule(
+        "claude-md-preamble",
+        "always",
+        "CLAUDE.md preamble",
+        preamble,
+        CLAUDE_MD
+      )
+    );
+  }
+  for (const section of sections) {
+    const isContext = section.heading.startsWith(CONTEXT_PREFIX);
+    const description = isContext ? section.heading.slice(CONTEXT_PREFIX.length) : section.heading;
+    const scope = isContext ? "agent-selected" : "always";
+    const id = toKebabCase(description);
+    if (id && section.content) {
+      rules.push(
+        createImportedRule(id, scope, description, section.content, CLAUDE_MD)
+      );
+    }
+  }
+  return rules;
+}
+async function importClaudeMd(projectRoot) {
+  const filePath = join2(projectRoot, CLAUDE_MD);
+  if (!await pathExists2(filePath)) return [];
+  const raw = await readFile(filePath, "utf-8");
+  return importClaudeMdContent(raw);
+}
+function importClaudeRuleFile(raw, filePath, id) {
+  const description = id.replace(/-/g, " ");
+  const parts = splitFrontmatter(raw);
+  if (!parts) {
+    const content = raw.replace(/\r\n/g, "\n").trim();
+    return createImportedRule(id, "always", description, content, filePath);
+  }
+  const paths = parsePaths(parts.yaml);
+  const scope = paths && paths.length > 0 ? "file-scoped" : "always";
+  const globs = scope === "file-scoped" ? paths : void 0;
+  return createImportedRule(
+    id,
+    scope,
+    description,
+    parts.content,
+    filePath,
+    globs
+  );
+}
+async function importClaudeRuleFiles(projectRoot) {
+  const dir = join2(projectRoot, RULES_DIR);
+  const files = await listMdFiles(dir);
+  const rules = [];
+  for (const file of files) {
+    const filePath = join2(RULES_DIR, file);
+    const raw = await readFile(join2(projectRoot, filePath), "utf-8");
+    rules.push(importClaudeRuleFile(raw, filePath, basename(file, ".md")));
+  }
+  return rules;
+}
+function buildClaudeMdContent(rules) {
+  const sorted = [...rules].sort((a, b) => a.priority - b.priority);
+  const sections = [];
+  for (const rule of sorted) {
+    const prefix = rule.scope === "agent-selected" ? CONTEXT_PREFIX : "";
+    sections.push(`## ${prefix}${rule.description}
+
+${rule.content}`);
+  }
+  return `${sections.join("\n\n")}
+`;
+}
+function buildClaudeRuleFile(rule) {
+  if (!rule.globs || rule.globs.length === 0) {
+    return `${rule.content}
+`;
+  }
+  const lines = ["---"];
+  if (rule.globs.length === 1) {
+    const first = rule.globs[0];
+    if (first !== void 0) lines.push(`paths: "${first}"`);
+  } else {
+    const items = rule.globs.map((g) => `"${g}"`).join(", ");
+    lines.push(`paths: [${items}]`);
+  }
+  lines.push("---");
+  lines.push("");
+  lines.push(rule.content);
+  lines.push("");
+  return lines.join("\n");
+}
+async function exportClaudeMd(rules, projectRoot, dryRun) {
+  const mdRules = rules.filter(
+    (r) => r.scope === "always" || r.scope === "agent-selected"
+  );
+  if (mdRules.length === 0) return [];
+  if (!dryRun) {
+    const content = buildClaudeMdContent(mdRules);
+    await writeFile2(join2(projectRoot, CLAUDE_MD), content, "utf-8");
+  }
+  return [CLAUDE_MD];
+}
+async function exportClaudeRules(rules, projectRoot, dryRun) {
+  const fileScoped = rules.filter((r) => r.scope === "file-scoped");
+  if (fileScoped.length === 0) return [];
+  const dir = join2(projectRoot, RULES_DIR);
+  if (!dryRun) await mkdir(dir, { recursive: true });
+  const written = [];
+  for (const rule of fileScoped) {
+    const filePath = join2(RULES_DIR, `${rule.id}.md`);
+    if (!dryRun) {
+      await writeFile2(
+        join2(projectRoot, filePath),
+        buildClaudeRuleFile(rule),
+        "utf-8"
+      );
+    }
+    written.push(filePath);
+  }
+  return written;
+}
+async function deleteStaleRuleFiles(rules, projectRoot, dryRun) {
+  const dir = join2(projectRoot, RULES_DIR);
+  const existing = await listMdFiles(dir);
+  const exportedIds = new Set(
+    rules.filter((r) => r.scope === "file-scoped").map((r) => `${r.id}.md`)
+  );
+  const deleted = [];
+  for (const file of existing) {
+    if (!exportedIds.has(file)) {
+      const filePath = join2(RULES_DIR, file);
+      if (!dryRun) await rm(join2(projectRoot, filePath));
+      deleted.push(filePath);
+    }
+  }
+  return deleted;
+}
+var claudeCodeAdapter = {
+  name: "claude-code",
+  displayName: "Claude Code",
+  async detect(projectRoot) {
+    const claudeMd = join2(projectRoot, CLAUDE_MD);
+    const claudeDir = join2(projectRoot, ".claude");
+    return await pathExists2(claudeMd) || await pathExists2(claudeDir);
+  },
+  async import(projectRoot) {
+    const mdRules = await importClaudeMd(projectRoot);
+    const ruleFiles = await importClaudeRuleFiles(projectRoot);
+    return {
+      rules: [...mdRules, ...ruleFiles],
+      warnings: [],
+      source: CLAUDE_MD
+    };
+  },
+  async export(rules, projectRoot, options) {
+    const dryRun = options?.dryRun === true;
+    const strategy = options?.strategy ?? "overwrite";
+    const mdWritten = await exportClaudeMd(rules, projectRoot, dryRun);
+    const rulesWritten = await exportClaudeRules(rules, projectRoot, dryRun);
+    const filesDeleted = strategy === "overwrite" ? await deleteStaleRuleFiles(rules, projectRoot, dryRun) : [];
+    return {
+      filesWritten: [...mdWritten, ...rulesWritten],
+      filesDeleted,
+      warnings: []
+    };
+  },
+  getTokenBudget() {
+    return {
+      maxTokens: 2e3,
+      maxInstructions: 150,
+      warningThreshold: 0.8,
+      source: "Claude Code documentation"
+    };
+  }
+};
+
+// src/adapters/cursor.ts
+import {
+  access as access3,
+  mkdir as mkdir2,
+  readdir as readdir2,
+  readFile as readFile2,
+  rm as rm2,
+  writeFile as writeFile3
+} from "fs/promises";
+import { basename as basename2, join as join3 } from "path";
+var RULES_DIR2 = ".cursor/rules";
+var LEGACY_FILE = ".cursorrules";
+var MDC_EXT = ".mdc";
+async function pathExists3(filePath) {
+  try {
+    await access3(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function listMdcFiles(dir) {
+  try {
+    const entries = await readdir2(dir);
+    return entries.filter((f) => f.endsWith(MDC_EXT)).sort();
+  } catch {
+    return [];
+  }
+}
+function stripQuotes2(s) {
+  const t = s.trim();
+  if (t.startsWith('"') && t.endsWith('"') || t.startsWith("'") && t.endsWith("'")) {
+    return t.slice(1, -1);
+  }
+  return t;
+}
+function parseInlineArray(raw) {
+  const inner = raw.slice(1, -1).trim();
+  if (inner === "") return [];
+  return inner.split(",").map(stripQuotes2);
+}
+function splitMdcFrontmatter(raw) {
+  const lines = raw.replace(/\r\n/g, "\n").split("\n");
+  if (lines[0]?.trim() !== "---") return null;
+  for (let i = 1; i < lines.length; i++) {
+    if (lines[i]?.trim() === "---") {
+      return {
+        yaml: lines.slice(1, i).join("\n"),
+        content: lines.slice(i + 1).join("\n").trim()
+      };
+    }
+  }
+  return null;
+}
+function parseMdcFields(yaml) {
+  let description;
+  let globs;
+  let alwaysApply = false;
+  for (const line of yaml.split("\n")) {
+    const trimmed = line.trim();
+    if (trimmed === "") continue;
+    const colonIdx = trimmed.indexOf(":");
+    if (colonIdx === -1) continue;
+    const key = trimmed.slice(0, colonIdx).trim();
+    const value = trimmed.slice(colonIdx + 1).trim();
+    if (key === "description" && value !== "") {
+      description = stripQuotes2(value);
+    } else if (key === "globs" && value !== "") {
+      globs = value.startsWith("[") && value.endsWith("]") ? parseInlineArray(value) : [stripQuotes2(value)];
+    } else if (key === "alwaysApply") {
+      alwaysApply = value === "true";
+    }
+  }
+  return { description, globs, alwaysApply };
+}
+function determineScope(fields) {
+  if (fields.alwaysApply) return "always";
+  if (fields.globs && fields.globs.length > 0) return "file-scoped";
+  if (fields.description) return "agent-selected";
+  return "always";
+}
+function importRuleWithoutFrontmatter(raw, filePath, id) {
+  const content = raw.replace(/\r\n/g, "\n").trim();
+  const description = id.replace(/-/g, " ");
+  return {
+    rule: {
+      id,
+      scope: "always",
+      description,
+      content,
+      category: "general",
+      priority: 3,
+      estimatedTokens: estimateRuleTokens(content, description),
+      source: {
+        adapter: "cursor",
+        filePath,
+        importedAt: (/* @__PURE__ */ new Date()).toISOString()
+      }
+    },
+    warning: {
+      filePath,
+      message: "No frontmatter found, treating as always-on rule"
+    }
+  };
+}
+function importRuleWithFrontmatter(parts, filePath, id) {
+  const fields = parseMdcFields(parts.yaml);
+  const scope = determineScope(fields);
+  const description = fields.description ?? id.replace(/-/g, " ");
+  return {
+    id,
+    scope,
+    description,
+    content: parts.content,
+    category: "general",
+    priority: 3,
+    estimatedTokens: estimateRuleTokens(parts.content, description),
+    ...scope === "file-scoped" && fields.globs ? { globs: fields.globs } : {},
+    source: {
+      adapter: "cursor",
+      filePath,
+      importedAt: (/* @__PURE__ */ new Date()).toISOString()
+    }
+  };
+}
+async function importMdcFiles(projectRoot) {
+  const rules = [];
+  const warnings = [];
+  const dir = join3(projectRoot, RULES_DIR2);
+  const files = await listMdcFiles(dir);
+  for (const file of files) {
+    const filePath = join3(RULES_DIR2, file);
+    const raw = await readFile2(join3(projectRoot, filePath), "utf-8");
+    const id = basename2(file, MDC_EXT);
+    const parts = splitMdcFrontmatter(raw);
+    if (!parts) {
+      const result = importRuleWithoutFrontmatter(raw, filePath, id);
+      rules.push(result.rule);
+      warnings.push(result.warning);
+    } else {
+      rules.push(importRuleWithFrontmatter(parts, filePath, id));
+    }
+  }
+  return { rules, warnings };
+}
+async function importLegacyFile(projectRoot) {
+  const legacyPath = join3(projectRoot, LEGACY_FILE);
+  if (!await pathExists3(legacyPath)) return { rules: [], warnings: [] };
+  const raw = await readFile2(legacyPath, "utf-8");
+  const content = raw.trim();
+  if (content === "") return { rules: [], warnings: [] };
+  return {
+    rules: [
+      {
+        id: "cursorrules-legacy",
+        scope: "always",
+        description: "Legacy .cursorrules file",
+        content,
+        category: "general",
+        priority: 3,
+        estimatedTokens: estimateRuleTokens(content, "Legacy .cursorrules"),
+        source: {
+          adapter: "cursor",
+          filePath: LEGACY_FILE,
+          importedAt: (/* @__PURE__ */ new Date()).toISOString()
+        }
+      }
+    ],
+    warnings: [
+      {
+        filePath: LEGACY_FILE,
+        message: ".cursorrules is deprecated. Migrate to .cursor/rules/*.mdc"
+      }
+    ]
+  };
+}
+function serializeMdcGlobs(globs) {
+  if (globs.length === 1) {
+    const first = globs[0];
+    if (first !== void 0) return `globs: "${first}"`;
+  }
+  const items = globs.map((g) => `"${g}"`).join(", ");
+  return `globs: [${items}]`;
+}
+function ruleToMdc(rule) {
+  const lines = ["---"];
+  lines.push(`description: "${rule.description}"`);
+  if (rule.scope === "file-scoped" && rule.globs && rule.globs.length > 0) {
+    lines.push(serializeMdcGlobs(rule.globs));
+  }
+  lines.push(`alwaysApply: ${rule.scope === "always"}`);
+  lines.push("---");
+  lines.push("");
+  lines.push(rule.content);
+  lines.push("");
+  return lines.join("\n");
+}
+async function deleteStaleFiles(projectRoot, exportedIds, dryRun) {
+  const dir = join3(projectRoot, RULES_DIR2);
+  const existing = await listMdcFiles(dir);
+  const deleted = [];
+  for (const file of existing) {
+    if (!exportedIds.has(file)) {
+      const filePath = join3(RULES_DIR2, file);
+      if (!dryRun) await rm2(join3(projectRoot, filePath));
+      deleted.push(filePath);
+    }
+  }
+  return deleted;
+}
+var cursorAdapter = {
+  name: "cursor",
+  displayName: "Cursor",
+  async detect(projectRoot) {
+    const rulesDir = join3(projectRoot, RULES_DIR2);
+    const legacyFile = join3(projectRoot, LEGACY_FILE);
+    return await pathExists3(rulesDir) || await pathExists3(legacyFile);
+  },
+  async import(projectRoot) {
+    const mdc = await importMdcFiles(projectRoot);
+    const legacy = await importLegacyFile(projectRoot);
+    return {
+      rules: [...mdc.rules, ...legacy.rules],
+      warnings: [...mdc.warnings, ...legacy.warnings],
+      source: RULES_DIR2
+    };
+  },
+  async export(rules, projectRoot, options) {
+    const dir = join3(projectRoot, RULES_DIR2);
+    const dryRun = options?.dryRun === true;
+    const strategy = options?.strategy ?? "overwrite";
+    const filesWritten = [];
+    const warnings = [];
+    if (!dryRun) await mkdir2(dir, { recursive: true });
+    for (const rule of rules) {
+      const filePath = join3(RULES_DIR2, `${rule.id}${MDC_EXT}`);
+      if (!dryRun) {
+        await writeFile3(join3(projectRoot, filePath), ruleToMdc(rule), "utf-8");
+      }
+      filesWritten.push(filePath);
+    }
+    const exportedIds = new Set(rules.map((r) => `${r.id}${MDC_EXT}`));
+    const filesDeleted = strategy === "overwrite" ? await deleteStaleFiles(projectRoot, exportedIds, dryRun) : [];
+    return { filesWritten, filesDeleted, warnings };
+  },
+  getTokenBudget() {
+    return {
+      maxTokens: 1e4,
+      maxInstructions: 500,
+      warningThreshold: 0.8,
+      source: "Cursor documentation"
+    };
+  }
+};
+
+// src/adapters/registry.ts
+var BUILTIN_ADAPTERS = [
+  cursorAdapter,
+  claudeCodeAdapter,
+  agentsMdAdapter
+];
+var adapterMap = new Map(
+  BUILTIN_ADAPTERS.map((a) => [a.name, a])
+);
+function getAdapters() {
+  return [...adapterMap.values()];
+}
+function getAdapter(name) {
+  return adapterMap.get(name);
+}
+function getAdapterNames() {
+  return [...adapterMap.keys()];
+}
+async function detectAdapters(projectRoot) {
+  const results = await Promise.all(
+    BUILTIN_ADAPTERS.map(async (adapter) => ({
+      adapter,
+      detected: await adapter.detect(projectRoot)
+    }))
+  );
+  return results.filter((r) => r.detected).map((r) => r.adapter);
+}
+
+// src/core/ir.ts
+var RulixError = class extends Error {
+  constructor(code, message, cause) {
+    super(message);
+    this.code = code;
+    this.cause = cause;
+  }
+  name = "RulixError";
+};
+
+// src/core/config.ts
+import { readFile as readFile3 } from "fs/promises";
+import { join as join4 } from "path";
+var RULIX_DIR = ".rulix";
+var CONFIG_FILENAME = "config.json";
+var RULES_DIR3 = "rules";
+var DEFAULT_OPTIONS = {
+  tokenEstimation: "heuristic",
+  agentsMdHeader: true,
+  claudeMdStrategy: "concatenate",
+  syncOnSave: false
+};
+var DEFAULT_CONFIG = {
+  targets: [],
+  presets: [],
+  overrides: {},
+  options: DEFAULT_OPTIONS
+};
+function configPath(projectRoot) {
+  return join4(projectRoot, RULIX_DIR, CONFIG_FILENAME);
+}
+function rulesPath(projectRoot) {
+  return join4(projectRoot, RULIX_DIR, RULES_DIR3);
+}
+function createDefaultConfig() {
+  return DEFAULT_CONFIG;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isStringArray(value) {
+  return Array.isArray(value) && value.every((v) => typeof v === "string");
+}
+function configError(message) {
+  return { ok: false, error: new RulixError("CONFIG_INVALID", message) };
+}
+function resolveOptions(raw) {
+  if (raw === void 0) return { ok: true, value: DEFAULT_OPTIONS };
+  if (!isRecord(raw)) return configError('"options" must be an object');
+  if (raw.tokenEstimation !== void 0 && raw.tokenEstimation !== "heuristic" && raw.tokenEstimation !== "tiktoken") {
+    return configError(
+      '"options.tokenEstimation" must be "heuristic" or "tiktoken"'
+    );
+  }
+  if (raw.claudeMdStrategy !== void 0 && raw.claudeMdStrategy !== "concatenate" && raw.claudeMdStrategy !== "reference") {
+    return configError(
+      '"options.claudeMdStrategy" must be "concatenate" or "reference"'
+    );
+  }
+  if (raw.agentsMdHeader !== void 0 && typeof raw.agentsMdHeader !== "boolean") {
+    return configError('"options.agentsMdHeader" must be a boolean');
+  }
+  if (raw.syncOnSave !== void 0 && typeof raw.syncOnSave !== "boolean") {
+    return configError('"options.syncOnSave" must be a boolean');
+  }
+  return {
+    ok: true,
+    value: {
+      tokenEstimation: raw.tokenEstimation ?? DEFAULT_OPTIONS.tokenEstimation,
+      agentsMdHeader: raw.agentsMdHeader ?? DEFAULT_OPTIONS.agentsMdHeader,
+      claudeMdStrategy: raw.claudeMdStrategy ?? DEFAULT_OPTIONS.claudeMdStrategy,
+      syncOnSave: raw.syncOnSave ?? DEFAULT_OPTIONS.syncOnSave
+    }
+  };
+}
+function resolveConfig(raw) {
+  if (!isRecord(raw)) return configError("Config must be a JSON object");
+  if (raw.targets !== void 0 && !isStringArray(raw.targets)) {
+    return configError('"targets" must be an array of strings');
+  }
+  if (raw.presets !== void 0 && !isStringArray(raw.presets)) {
+    return configError('"presets" must be an array of strings');
+  }
+  if (raw.overrides !== void 0 && !isRecord(raw.overrides)) {
+    return configError('"overrides" must be an object');
+  }
+  const options = resolveOptions(raw.options);
+  if (!options.ok) return options;
+  return {
+    ok: true,
+    value: {
+      targets: raw.targets ?? DEFAULT_CONFIG.targets,
+      presets: raw.presets ?? DEFAULT_CONFIG.presets,
+      overrides: raw.overrides ?? DEFAULT_CONFIG.overrides,
+      options: options.value
+    }
+  };
+}
+async function loadConfig(projectRoot) {
+  const filePath = configPath(projectRoot);
+  let content;
+  try {
+    content = await readFile3(filePath, "utf-8");
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+      return { ok: true, value: createDefaultConfig() };
+    }
+    throw error;
+  }
+  let raw;
+  try {
+    raw = JSON.parse(content);
+  } catch {
+    return configError(`Invalid JSON in ${filePath}`);
+  }
+  return resolveConfig(raw);
+}
+
+// src/core/parser.ts
+import { mkdir as mkdir3, readdir as readdir3, readFile as readFile4, writeFile as writeFile4 } from "fs/promises";
+import { join as join5 } from "path";
+var DEFAULT_CATEGORY = "general";
+var DEFAULT_PRIORITY = 3;
+function parseError(message, filePath) {
+  const suffix = filePath ? ` in ${filePath}` : "";
+  return {
+    ok: false,
+    error: new RulixError("PARSE_ERROR", `${message}${suffix}`)
+  };
+}
+function stripQuotes3(value) {
+  const t = value.trim();
+  if (t.startsWith('"') && t.endsWith('"') || t.startsWith("'") && t.endsWith("'")) {
+    return t.slice(1, -1);
+  }
+  return t;
+}
+function parseInlineArray2(raw) {
+  const inner = raw.slice(1, -1).trim();
+  if (inner === "") return [];
+  return inner.split(",").map(stripQuotes3);
+}
+function parseYamlValue(raw) {
+  const trimmed = raw.trim();
+  if (trimmed === "") return trimmed;
+  if (trimmed.startsWith("[") && trimmed.endsWith("]")) {
+    return parseInlineArray2(trimmed);
+  }
+  if (/^-?\d+$/.test(trimmed)) return Number(trimmed);
+  if (trimmed === "true") return true;
+  if (trimmed === "false") return false;
+  return stripQuotes3(trimmed);
+}
+function splitFrontmatter2(raw) {
+  const lines = raw.replace(/\r\n/g, "\n").split("\n");
+  if (lines[0]?.trim() !== "---") {
+    return parseError("File must start with frontmatter (---)");
+  }
+  let closingIndex = -1;
+  for (let i = 1; i < lines.length; i++) {
+    if (lines[i]?.trim() === "---") {
+      closingIndex = i;
+      break;
+    }
+  }
+  if (closingIndex === -1) {
+    return parseError("Unterminated frontmatter (missing closing ---)");
+  }
+  return {
+    ok: true,
+    value: {
+      yaml: lines.slice(1, closingIndex).join("\n"),
+      content: lines.slice(closingIndex + 1).join("\n")
+    }
+  };
+}
+function parseFrontmatterFields(yaml) {
+  const fields = {};
+  const lines = yaml.split("\n");
+  let arrayKey;
+  let arrayItems = [];
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed === "") continue;
+    if (trimmed.startsWith("- ")) {
+      if (arrayKey !== void 0) {
+        arrayItems.push(stripQuotes3(trimmed.slice(2)));
+      }
+      continue;
+    }
+    if (arrayKey !== void 0) {
+      fields[arrayKey] = arrayItems;
+      arrayKey = void 0;
+      arrayItems = [];
+    }
+    const colonIndex = trimmed.indexOf(":");
+    if (colonIndex === -1) continue;
+    const key = trimmed.slice(0, colonIndex).trim();
+    const rawValue = trimmed.slice(colonIndex + 1).trim();
+    if (rawValue === "") {
+      arrayKey = key;
+      arrayItems = [];
+    } else {
+      fields[key] = parseYamlValue(rawValue);
+    }
+  }
+  if (arrayKey !== void 0) fields[arrayKey] = arrayItems;
+  return fields;
+}
+function isValidScope(value) {
+  return value === "always" || value === "file-scoped" || value === "agent-selected";
+}
+function isValidCategory(value) {
+  return value === "style" || value === "security" || value === "testing" || value === "architecture" || value === "workflow" || value === "general";
+}
+function normalizeGlobs(value) {
+  if (value === void 0) return void 0;
+  if (typeof value === "string") return [value];
+  if (Array.isArray(value) && value.every((v) => typeof v === "string")) {
+    return value;
+  }
+  return void 0;
+}
+function parseRule(raw, filePath) {
+  const split = splitFrontmatter2(raw);
+  if (!split.ok) return parseError(split.error.message, filePath);
+  const fields = parseFrontmatterFields(split.value.yaml);
+  const content = split.value.content.trim();
+  const { id, scope, description } = fields;
+  if (typeof id !== "string" || id === "") {
+    return parseError('Missing required field "id"', filePath);
+  }
+  if (!isValidScope(scope)) {
+    return parseError('Invalid or missing "scope"', filePath);
+  }
+  if (typeof description !== "string" || description === "") {
+    return parseError('Missing required field "description"', filePath);
+  }
+  const globs = normalizeGlobs(fields.globs);
+  const extendsVal = typeof fields.extends === "string" ? fields.extends : void 0;
+  return {
+    ok: true,
+    value: {
+      id,
+      scope,
+      description,
+      content,
+      category: isValidCategory(fields.category) ? fields.category : DEFAULT_CATEGORY,
+      priority: typeof fields.priority === "number" ? fields.priority : DEFAULT_PRIORITY,
+      estimatedTokens: estimateRuleTokens(content, description),
+      ...globs !== void 0 ? { globs } : {},
+      ...extendsVal !== void 0 ? { extends: extendsVal } : {}
+    }
+  };
+}
+function serializeGlobs(globs, lines) {
+  if (globs.length === 1) {
+    const first = globs[0];
+    if (first !== void 0) lines.push(`globs: "${first}"`);
+    return;
+  }
+  lines.push("globs:");
+  for (const glob of globs) {
+    lines.push(`  - "${glob}"`);
+  }
+}
+function serializeRule(rule) {
+  const lines = ["---"];
+  lines.push(`id: ${rule.id}`);
+  lines.push(`scope: ${rule.scope}`);
+  lines.push(`description: "${rule.description}"`);
+  if (rule.globs && rule.globs.length > 0) serializeGlobs(rule.globs, lines);
+  lines.push(`category: ${rule.category}`);
+  lines.push(`priority: ${rule.priority}`);
+  if (rule.extends) lines.push(`extends: ${rule.extends}`);
+  lines.push("---");
+  lines.push("");
+  lines.push(rule.content);
+  lines.push("");
+  return lines.join("\n");
+}
+async function loadRules(projectRoot) {
+  const dir = rulesPath(projectRoot);
+  let entries;
+  try {
+    entries = await readdir3(dir);
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+      return { ok: true, value: [] };
+    }
+    throw error;
+  }
+  const mdFiles = entries.filter((f) => f.endsWith(".md")).sort();
+  const rules = [];
+  for (const file of mdFiles) {
+    const filePath = join5(dir, file);
+    const raw = await readFile4(filePath, "utf-8");
+    const result = parseRule(raw, filePath);
+    if (!result.ok) return result;
+    rules.push(result.value);
+  }
+  return { ok: true, value: rules };
+}
+async function writeRule(projectRoot, rule) {
+  const dir = rulesPath(projectRoot);
+  await mkdir3(dir, { recursive: true });
+  await writeFile4(join5(dir, `${rule.id}.md`), serializeRule(rule), "utf-8");
+}
+
+// src/core/validator.ts
+var MIN_CONTENT_LENGTH = 20;
+var MAX_CONTENT_LINES = 50;
+var VAGUE_PATTERNS = [
+  /handle .+ properly/i,
+  /do .+ correctly/i,
+  /implement .+ properly/i,
+  /make sure .+ works/i,
+  /ensure .+ is correct/i,
+  /follow best practices/i
+];
+function createIssue(code, severity, message, ruleId, suggestion) {
+  return {
+    code,
+    severity,
+    message,
+    ...ruleId !== void 0 ? { ruleId } : {},
+    ...suggestion !== void 0 ? { suggestion } : {}
+  };
+}
+function checkDuplicateIds(rules) {
+  const seen = /* @__PURE__ */ new Map();
+  const issues = [];
+  for (const rule of rules) {
+    const count = (seen.get(rule.id) ?? 0) + 1;
+    seen.set(rule.id, count);
+    if (count === 2) {
+      issues.push(
+        createIssue(
+          "V001",
+          "error",
+          `Duplicate rule ID "${rule.id}"`,
+          rule.id,
+          "Rename one of the duplicate rules"
+        )
+      );
+    }
+  }
+  return issues;
+}
+function checkRequiredFields(rule) {
+  const issues = [];
+  if (rule.id === "") {
+    issues.push(createIssue("V002", "error", "Rule has empty ID", rule.id));
+  }
+  if (rule.description === "") {
+    issues.push(
+      createIssue(
+        "V002",
+        "error",
+        `Rule "${rule.id}" has empty description`,
+        rule.id
+      )
+    );
+  }
+  return issues;
+}
+function checkFileScopedGlobs(rule) {
+  if (rule.scope !== "file-scoped") return [];
+  if (!rule.globs || rule.globs.length === 0) {
+    return [
+      createIssue(
+        "V003",
+        "error",
+        `Rule "${rule.id}" is file-scoped but has no globs`,
+        rule.id,
+        'Add globs or change scope to "always"'
+      )
+    ];
+  }
+  return [];
+}
+function checkShortContent(rule) {
+  if (rule.content.length < MIN_CONTENT_LENGTH) {
+    return [
+      createIssue(
+        "V004",
+        "warning",
+        `Rule "${rule.id}" has very short content (${rule.content.length} chars)`,
+        rule.id,
+        "Consider adding more detail"
+      )
+    ];
+  }
+  return [];
+}
+function checkVagueDescription(rule) {
+  for (const pattern of VAGUE_PATTERNS) {
+    if (pattern.test(rule.description)) {
+      return [
+        createIssue(
+          "V005",
+          "warning",
+          `Rule "${rule.id}" has a vague description`,
+          rule.id,
+          "Be more specific about what conventions to follow"
+        )
+      ];
+    }
+  }
+  return [];
+}
+function checkDefaultCategory(rule) {
+  if (rule.category === "general") {
+    return [
+      createIssue(
+        "V007",
+        "info",
+        `Rule "${rule.id}" has no specific category`,
+        rule.id,
+        "Consider assigning a category (style, security, testing, architecture, workflow)"
+      )
+    ];
+  }
+  return [];
+}
+function isValidGlobSyntax(pattern) {
+  if (pattern.trim() === "") return false;
+  let brackets = 0;
+  let braces = 0;
+  for (const ch of pattern) {
+    if (ch === "[") brackets++;
+    else if (ch === "]") brackets--;
+    else if (ch === "{") braces++;
+    else if (ch === "}") braces--;
+    if (brackets < 0 || braces < 0) return false;
+  }
+  return brackets === 0 && braces === 0;
+}
+function checkGlobSyntax(rule) {
+  if (!rule.globs) return [];
+  const issues = [];
+  for (const glob of rule.globs) {
+    if (!isValidGlobSyntax(glob)) {
+      issues.push(
+        createIssue(
+          "V009",
+          "error",
+          `Rule "${rule.id}" has invalid glob pattern: "${glob}"`,
+          rule.id
+        )
+      );
+    }
+  }
+  return issues;
+}
+function checkLongContent(rule) {
+  const lineCount = rule.content.split("\n").length;
+  if (lineCount > MAX_CONTENT_LINES) {
+    return [
+      createIssue(
+        "V010",
+        "warning",
+        `Rule "${rule.id}" has ${lineCount} lines (>${MAX_CONTENT_LINES})`,
+        rule.id,
+        "Consider splitting into smaller rules"
+      )
+    ];
+  }
+  return [];
+}
+function buildResult(issues) {
+  return {
+    passed: issues.every((i) => i.severity !== "error"),
+    errors: issues.filter((i) => i.severity === "error"),
+    warnings: issues.filter((i) => i.severity === "warning"),
+    info: issues.filter((i) => i.severity === "info")
+  };
+}
+function validateRules(rules) {
+  const issues = [];
+  issues.push(...checkDuplicateIds(rules));
+  for (const rule of rules) {
+    issues.push(...checkRequiredFields(rule));
+    issues.push(...checkFileScopedGlobs(rule));
+    issues.push(...checkShortContent(rule));
+    issues.push(...checkVagueDescription(rule));
+    issues.push(...checkDefaultCategory(rule));
+    issues.push(...checkGlobSyntax(rule));
+    issues.push(...checkLongContent(rule));
+  }
+  return buildResult(issues);
+}
+
+export {
+  agentsMdAdapter,
+  estimateTokens,
+  estimateRuleTokens,
+  sumTokens,
+  computeBudgetUsage,
+  claudeCodeAdapter,
+  cursorAdapter,
+  getAdapters,
+  getAdapter,
+  getAdapterNames,
+  detectAdapters,
+  RulixError,
+  RULIX_DIR,
+  CONFIG_FILENAME,
+  RULES_DIR3 as RULES_DIR,
+  configPath,
+  rulesPath,
+  createDefaultConfig,
+  resolveConfig,
+  loadConfig,
+  parseRule,
+  serializeRule,
+  loadRules,
+  writeRule,
+  validateRules
+};
+//# sourceMappingURL=chunk-IX4ZOAKV.js.map