mdrules 0.0.0-stage → 0.1.1

package/dist/cli.js

@@ -0,0 +1,926 @@
+#!/usr/bin/env node
+
+// src/core/config.ts
+import fs from "fs";
+import os from "os";
+import path from "path";
+import { fileURLToPath } from "url";
+var LANGS = ["en", "es", "fr", "pt", "de", "it"];
+var LANG_NAMES = { en: "English", es: "Espa\xF1ol", fr: "Fran\xE7ais", pt: "Portugu\xEAs", de: "Deutsch", it: "Italiano" };
+var DEFAULT_SOURCE = "en";
+var isLang = (v) => LANGS.includes(v);
+var MAIN_DOCS = ["CLAUDE.md", "AGENTS.md"];
+var PKG_ROOT = (() => {
+  let dir = path.dirname(fileURLToPath(import.meta.url));
+  while (!fs.existsSync(path.join(dir, "package.json"))) dir = path.dirname(dir);
+  return dir;
+})();
+var TEMPLATES_DIR = path.join(PKG_ROOT, "templates");
+var WEB_DIR = path.join(PKG_ROOT, "dist", "web");
+var GLOBAL_DIR = process.env.MDRULES_HOME ?? path.join(os.homedir(), ".mdrules");
+var stateDir = (root2) => path.join(root2, ".mdrules");
+var configFile = (root2) => path.join(stateDir(root2), "config.json");
+function readConfig(root2) {
+  try {
+    const raw = JSON.parse(fs.readFileSync(configFile(root2), "utf8"));
+    const langs = Array.isArray(raw.langs) ? raw.langs : raw.lang ? [raw.lang] : [];
+    return { mainDoc: raw.mainDoc ?? null, langs: langs.filter(isLang), initializedAt: raw.initializedAt };
+  } catch {
+    return null;
+  }
+}
+function writeConfig(root2, config) {
+  fs.mkdirSync(stateDir(root2), { recursive: true });
+  fs.writeFileSync(configFile(root2), JSON.stringify(config, null, 2) + "\n");
+}
+function safeResolve(root2, rel) {
+  const abs = path.resolve(root2, rel);
+  if (abs !== root2 && !abs.startsWith(root2 + path.sep)) throw new Error(`Path outside project: ${rel}`);
+  return abs;
+}
+var toPosix = (p2) => p2.split(path.sep).join("/");
+var DEFAULT_SETTINGS = { font: "inter", size: 15, lineHeight: 1.65, padding: 28, width: "full", wrap: true };
+var settingsFile = () => path.join(GLOBAL_DIR, "settings.json");
+function readSettings() {
+  try {
+    return { ...DEFAULT_SETTINGS, ...JSON.parse(fs.readFileSync(settingsFile(), "utf8")) };
+  } catch {
+    return { ...DEFAULT_SETTINGS };
+  }
+}
+function writeSettings(patch) {
+  const next = { ...readSettings(), ...patch };
+  fs.mkdirSync(GLOBAL_DIR, { recursive: true });
+  fs.writeFileSync(settingsFile(), JSON.stringify(next, null, 2) + "\n");
+  return next;
+}
+
+// src/core/i18n.ts
+import crypto from "crypto";
+import fs4 from "fs";
+import path4 from "path";
+
+// src/core/langdetect.ts
+var STOPWORDS = {
+  en: ["the", "and", "is", "are", "of", "to", "in", "for", "with", "this", "that", "it", "on", "be", "as", "by", "not", "or", "from", "when", "each", "use", "should", "will", "can", "all", "has", "have", "which", "only"],
+  es: ["el", "la", "los", "las", "de", "del", "que", "y", "en", "un", "una", "para", "con", "por", "es", "son", "se", "como", "al", "lo", "m\xE1s", "pero", "su", "sus", "este", "esta", "cuando", "cada", "debe", "tambi\xE9n"],
+  fr: ["le", "la", "les", "de", "des", "du", "et", "est", "un", "une", "pour", "dans", "avec", "que", "qui", "en", "sur", "par", "pas", "au", "aux", "ce", "cette", "sont", "ou", "chaque", "doit", "quand", "aussi", "\xEAtre"],
+  pt: ["o", "os", "as", "de", "do", "da", "dos", "das", "que", "e", "em", "um", "uma", "para", "com", "por", "n\xE3o", "\xE9", "s\xE3o", "se", "como", "ao", "mais", "mas", "seu", "sua", "cada", "deve", "quando", "tamb\xE9m"],
+  de: ["der", "die", "das", "und", "ist", "sind", "ein", "eine", "zu", "den", "dem", "mit", "f\xFCr", "von", "auf", "nicht", "auch", "es", "im", "bei", "wird", "werden", "oder", "wenn", "jede", "jeder", "soll", "muss", "kann", "nur"],
+  it: ["il", "lo", "la", "gli", "le", "di", "del", "della", "che", "e", "\xE8", "un", "una", "per", "con", "non", "sono", "si", "come", "al", "alla", "pi\xF9", "ma", "suo", "questo", "questa", "quando", "ogni", "deve", "anche"]
+};
+var SETS = Object.fromEntries(Object.entries(STOPWORDS).map(([l, w]) => [l, new Set(w)]));
+function prose(md) {
+  return md.replace(/^---\r?\n[\s\S]*?\r?\n---/, " ").replace(/```[\s\S]*?```/g, " ").replace(/<!--[\s\S]*?-->/g, " ").replace(/`[^`]*`/g, " ").replace(/\]\([^)]*\)/g, " ").replace(/https?:\/\/\S+/g, " ").replace(/[|#>*_\-[\]()]/g, " ");
+}
+function detectLang(md) {
+  const words = prose(md).toLowerCase().match(/[\p{L}]+/gu) ?? [];
+  if (words.length < 25) return null;
+  const scores = Object.keys(SETS).map((lang) => ({ lang, hits: words.reduce((n, w) => n + (SETS[lang].has(w) ? 1 : 0), 0) }));
+  scores.sort((a, b) => b.hits - a.hits);
+  const [best, second] = scores;
+  if (best.hits < 6 || best.hits < second.hits * 1.5) return null;
+  return best.lang;
+}
+
+// src/core/rules.ts
+import fs2 from "fs";
+import path2 from "path";
+import YAML from "yaml";
+var rulesDir = () => path2.join(GLOBAL_DIR, "rules");
+var START = "<!-- mdrules:rules:start -->";
+var END = "<!-- mdrules:rules:end -->";
+var slugify = (s) => s.toLowerCase().normalize("NFD").replace(/[̀-ͯ]/g, "").replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+function seedRules() {
+  if (fs2.existsSync(rulesDir())) return;
+  fs2.mkdirSync(rulesDir(), { recursive: true });
+  const src = path2.join(TEMPLATES_DIR, "rules");
+  for (const f of fs2.readdirSync(src)) fs2.copyFileSync(path2.join(src, f), path2.join(rulesDir(), f));
+}
+function parseRule(id, text) {
+  const m = text.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
+  const meta = m ? YAML.parse(m[1]) ?? {} : {};
+  return { id, title: meta.title ?? id, body: (m ? m[2] : text).trim() };
+}
+function listRules() {
+  seedRules();
+  return fs2.readdirSync(rulesDir()).filter((f) => f.endsWith(".md")).map((f) => parseRule(f.slice(0, -3), fs2.readFileSync(path2.join(rulesDir(), f), "utf8"))).sort((a, b) => a.title.localeCompare(b.title));
+}
+function saveRule(rule) {
+  seedRules();
+  const id = rule.id || slugify(rule.title) || `rule-${Date.now()}`;
+  const text = `---
+${YAML.stringify({ title: rule.title }).trim()}
+---
+${rule.body.trim()}
+`;
+  fs2.writeFileSync(path2.join(rulesDir(), `${id}.md`), text);
+  return { id, title: rule.title, body: rule.body.trim() };
+}
+function deleteRule(id) {
+  fs2.rmSync(path2.join(rulesDir(), `${path2.basename(id)}.md`), { force: true });
+}
+function appliedRuleIds(docText) {
+  const section = extractSection(docText);
+  if (!section) return [];
+  return [...section.matchAll(/<!-- rule:([\w-]+) -->/g)].map((m) => m[1]);
+}
+function extractSection(text) {
+  const s = text.indexOf(START);
+  const e = text.indexOf(END);
+  return s >= 0 && e > s ? text.slice(s, e + END.length) : null;
+}
+function writtenRules(docText) {
+  const section = extractSection(docText) ?? "";
+  const out = {};
+  for (const m of section.matchAll(/<!-- rule:([\w-]+) -->\n([\s\S]*?)(?=\n+<!-- (?:rule:|mdrules:rules:end))/g)) out[m[1]] = { id: m[1], title: m[1], body: m[2].trim() };
+  return out;
+}
+function sourceLangOf(docText) {
+  const m = /<!-- mdrules:source-lang:(\w+) -->/.exec(extractSection(docText) ?? "");
+  return m && isLang(m[1]) ? m[1] : DEFAULT_SOURCE;
+}
+function projectSourceLang(root2, mainDoc) {
+  const doc = mainDoc ?? MAIN_DOCS.find((d) => fs2.existsSync(path2.join(root2, d)));
+  if (!doc) return DEFAULT_SOURCE;
+  try {
+    return sourceLangOf(fs2.readFileSync(path2.join(root2, doc), "utf8"));
+  } catch {
+    return DEFAULT_SOURCE;
+  }
+}
+function renderSection(rules, sourceLang) {
+  const body = rules.map((r) => `<!-- rule:${r.id} -->
+${r.body}`).join("\n\n");
+  return [
+    START,
+    "## Working rules",
+    "",
+    "This project uses mdrules: follow `.claude/skills/mdrules/SKILL.md` when editing any `.md` file.",
+    "",
+    `<!-- mdrules:source-lang:${sourceLang} -->`,
+    `- Source language of every \`.md\` file: **${LANG_NAMES[sourceLang]}** (\`${sourceLang}\`).`,
+    ...body ? ["", body] : [],
+    END
+  ].join("\n");
+}
+function applyRules(docText, rules, sourceLang = sourceLangOf(docText)) {
+  const section = renderSection(rules, sourceLang);
+  const existing = extractSection(docText);
+  if (existing) return docText.replace(existing, section);
+  return docText.replace(/\s*$/, "") + "\n\n" + section + "\n";
+}
+function applyRulesToFile(file, ids, sourceLang) {
+  const text = fs2.existsSync(file) ? fs2.readFileSync(file, "utf8") : "";
+  const all = listRules();
+  const written = writtenRules(text);
+  const rules = (ids ?? appliedRuleIds(text)).map((id) => all.find((r) => r.id === id) ?? written[id]).filter((r) => !!r);
+  fs2.writeFileSync(file, applyRules(text, rules, sourceLang ?? sourceLangOf(text)));
+}
+
+// src/core/scan.ts
+import fs3 from "fs";
+import path3 from "path";
+import ignore from "ignore";
+var ALWAYS_SKIP = /* @__PURE__ */ new Set(["node_modules", ".git", ".mdrules", "dist", "build", ".next", ".turbo", "coverage", ".venv"]);
+var IGNORE_FILE = ".mdrulesignore";
+function loadIgnore(root2, file) {
+  const ig = ignore();
+  try {
+    ig.add(fs3.readFileSync(path3.join(root2, file), "utf8"));
+  } catch {
+  }
+  return ig;
+}
+function readIgnoreList(root2) {
+  try {
+    return fs3.readFileSync(path3.join(root2, IGNORE_FILE), "utf8").split("\n").map((l) => l.trim()).filter((l) => l && !l.startsWith("#"));
+  } catch {
+    return [];
+  }
+}
+function setIgnored(root2, rel, kind, ignored) {
+  const entry = kind === "dir" ? `${rel}/` : rel;
+  const lines = readIgnoreList(root2).filter((l) => l !== entry && l !== rel);
+  if (ignored) lines.push(entry);
+  fs3.writeFileSync(path3.join(root2, IGNORE_FILE), lines.length ? lines.join("\n") + "\n" : "");
+}
+function watchSkips(root2) {
+  const gitIgnore = loadIgnore(root2, ".gitignore");
+  return (rel, isDir) => {
+    if (!rel || rel.startsWith("..")) return false;
+    if (rel.split("/").some((s) => ALWAYS_SKIP.has(s))) return true;
+    if (isDir !== false && gitIgnore.ignores(rel + "/")) return true;
+    return isDir !== true && gitIgnore.ignores(rel);
+  };
+}
+function scanTree(root2) {
+  const gitIgnore = loadIgnore(root2, ".gitignore");
+  const mdIgnore = loadIgnore(root2, IGNORE_FILE);
+  function walk(dirAbs, parentIgnored) {
+    let entries;
+    try {
+      entries = fs3.readdirSync(dirAbs, { withFileTypes: true });
+    } catch {
+      return [];
+    }
+    const nodes = [];
+    for (const e of entries) {
+      if (ALWAYS_SKIP.has(e.name)) continue;
+      const abs = path3.join(dirAbs, e.name);
+      const rel = toPosix(path3.relative(root2, abs));
+      if (e.isDirectory()) {
+        if (gitIgnore.ignores(rel + "/")) continue;
+        const ignored = parentIgnored || mdIgnore.ignores(rel + "/");
+        const children = walk(abs, ignored);
+        if (!children.length) continue;
+        const project = MAIN_DOCS.some((d) => children.some((c) => c.kind === "file" && c.name === d));
+        nodes.push({ name: e.name, path: rel, kind: "dir", project: project || void 0, ignored: ignored || void 0, children });
+      } else if (e.isFile() && e.name.toLowerCase().endsWith(".md")) {
+        if (gitIgnore.ignores(rel)) continue;
+        const ignored = parentIgnored || mdIgnore.ignores(rel);
+        nodes.push({ name: e.name, path: rel, kind: "file", ignored: ignored || void 0 });
+      }
+    }
+    return nodes.sort(compareNodes);
+  }
+  return walk(root2, false);
+}
+function compareNodes(a, b) {
+  const rank = (n) => n.kind === "file" && MAIN_DOCS.includes(n.name) ? 0 : n.kind === "dir" ? 1 : 2;
+  return rank(a) - rank(b) || a.name.localeCompare(b.name);
+}
+function flattenFiles(nodes, includeIgnored = false) {
+  const out = [];
+  for (const n of nodes) {
+    if (n.ignored && !includeIgnored) continue;
+    if (n.kind === "file") out.push(n);
+    else out.push(...flattenFiles(n.children ?? [], includeIgnored));
+  }
+  return out;
+}
+function findSubprojects(nodes) {
+  const out = [];
+  for (const n of nodes) {
+    if (n.kind !== "dir") continue;
+    if (n.project) out.push(n.path);
+    out.push(...findSubprojects(n.children ?? []));
+  }
+  return out;
+}
+
+// src/core/i18n.ts
+var stateFile = (root2) => path4.join(stateDir(root2), "state.json");
+var translationPath = (root2, lang, rel) => path4.join(stateDir(root2), "i18n", lang, rel);
+var hash = (text) => crypto.createHash("sha1").update(text).digest("hex").slice(0, 12);
+var readText = (abs) => {
+  try {
+    return fs4.readFileSync(abs, "utf8");
+  } catch {
+    return null;
+  }
+};
+function readState(root2) {
+  try {
+    const raw = JSON.parse(fs4.readFileSync(stateFile(root2), "utf8"));
+    if (!raw.translations) return { translations: raw, keepLanguage: {} };
+    return { translations: raw.translations ?? {}, keepLanguage: raw.keepLanguage ?? {} };
+  } catch {
+    return { translations: {}, keepLanguage: {} };
+  }
+}
+function writeState(root2, state) {
+  fs4.mkdirSync(stateDir(root2), { recursive: true });
+  fs4.writeFileSync(stateFile(root2), JSON.stringify(state, null, 2) + "\n");
+}
+function fileStatus(root2, lang, rel) {
+  const source = readText(path4.join(root2, rel));
+  const translation = readText(translationPath(root2, lang, rel));
+  if (translation === null || source === null) return "missing";
+  const recorded = readState(root2).translations[lang]?.[rel];
+  if (!recorded) return "outdated";
+  const sourceChanged = hash(source) !== recorded.source;
+  const translationChanged = hash(translation) !== recorded.translation;
+  if (sourceChanged && translationChanged) return "conflict";
+  if (sourceChanged) return "outdated";
+  if (translationChanged) return "pending-sync";
+  return "synced";
+}
+function allStatuses(root2, lang) {
+  return flattenFiles(scanTree(root2)).map((f) => ({
+    path: f.path,
+    lang,
+    status: fileStatus(root2, lang, f.path),
+    translation: path4.relative(root2, translationPath(root2, lang, f.path))
+  }));
+}
+function foreignFiles(root2, sourceLang) {
+  const { keepLanguage: keepLanguage2 } = readState(root2);
+  const out = [];
+  for (const f of flattenFiles(scanTree(root2))) {
+    const text = readText(path4.join(root2, f.path));
+    const detected = text ? detectLang(text) : null;
+    if (detected && detected !== sourceLang && keepLanguage2[f.path] !== detected) out.push({ path: f.path, detected });
+  }
+  return out;
+}
+function syncReport(root2) {
+  const config = readConfig(root2);
+  const sourceLang = projectSourceLang(root2, config?.mainDoc);
+  const langs = (config?.langs ?? []).filter((l) => l !== sourceLang);
+  return {
+    sourceLang,
+    langs,
+    foreign: foreignFiles(root2, sourceLang),
+    files: langs.flatMap((l) => allStatuses(root2, l))
+  };
+}
+function markSynced(root2, lang, rel) {
+  const source = readText(path4.join(root2, rel));
+  const translation = readText(translationPath(root2, lang, rel));
+  if (source === null) throw new Error(`Source not found: ${rel}`);
+  if (translation === null) throw new Error(`Translation not found: ${path4.relative(root2, translationPath(root2, lang, rel))}`);
+  const state = readState(root2);
+  state.translations[lang] ??= {};
+  state.translations[lang][rel] = { source: hash(source), translation: hash(translation) };
+  writeState(root2, state);
+}
+function keepLanguage(root2, rel) {
+  const text = readText(path4.join(root2, rel));
+  const detected = text ? detectLang(text) : null;
+  if (!detected) throw new Error(`Could not detect the language of ${rel}`);
+  const state = readState(root2);
+  state.keepLanguage[rel] = detected;
+  writeState(root2, state);
+  return detected;
+}
+
+// src/server/index.ts
+import fs6 from "fs";
+import http from "http";
+import path6 from "path";
+import { watch } from "chokidar";
+import open from "open";
+import pc from "picocolors";
+import { WebSocketServer } from "ws";
+
+// src/core/dashboard.ts
+import fs5 from "fs";
+import path5 from "path";
+import YAML2 from "yaml";
+function parseFrontmatter(text) {
+  const m = text.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+  if (!m) return {};
+  try {
+    return YAML2.parse(m[1]) ?? {};
+  } catch {
+    return {};
+  }
+}
+function summarize(root2) {
+  return flattenFiles(scanTree(root2)).map((f) => {
+    const text = fs5.readFileSync(path5.join(root2, f.path), "utf8");
+    const meta = parseFrontmatter(text);
+    const total = text.match(/^\s*[-*+] \[[ xX]\]/gm)?.length ?? 0;
+    const done = text.match(/^\s*[-*+] \[[xX]\]/gm)?.length ?? 0;
+    const heading = text.match(/^#\s+(.+)$/m)?.[1];
+    return {
+      path: f.path,
+      title: meta.title ?? heading ?? f.name.replace(/\.md$/i, ""),
+      type: meta.type ?? null,
+      status: meta.status ?? null,
+      phase: typeof meta.phase === "number" ? meta.phase : null,
+      updated: meta.updated ? String(meta.updated instanceof Date ? meta.updated.toISOString().slice(0, 10) : meta.updated) : null,
+      tasks: { done, total }
+    };
+  });
+}
+
+// src/core/git.ts
+import { execFileSync } from "child_process";
+function git(root2, args2) {
+  try {
+    return execFileSync("git", ["-c", "core.quotepath=off", ...args2], { cwd: root2, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], maxBuffer: 32 * 1024 * 1024 });
+  } catch (err) {
+    return typeof err?.stdout === "string" && err.stdout ? err.stdout : null;
+  }
+}
+var isGitRepo = (root2) => git(root2, ["rev-parse", "--is-inside-work-tree"])?.trim() === "true";
+function gitStatuses(root2) {
+  const prefix = git(root2, ["rev-parse", "--show-prefix"])?.trim() ?? "";
+  const out = git(root2, ["status", "--porcelain=v1", "-z", "--untracked-files=all", "--", "."]);
+  const result = {};
+  if (!out) return result;
+  const parts = out.split("\0");
+  for (let i = 0; i < parts.length; i++) {
+    const entry = parts[i];
+    if (entry.length < 4) continue;
+    const code = entry.slice(0, 2);
+    let file = entry.slice(3);
+    if (code[0] === "R" || code[0] === "C") i++;
+    if (!file.toLowerCase().endsWith(".md")) continue;
+    if (prefix && file.startsWith(prefix)) file = file.slice(prefix.length);
+    if (file.startsWith(".mdrules/")) continue;
+    result[file] = code === "??" ? "U" : code.includes("D") ? "D" : code.includes("A") ? "A" : "M";
+  }
+  return result;
+}
+function gitDiff(root2, rel) {
+  const status = gitStatuses(root2)[rel];
+  if (status === "U") return git(root2, ["diff", "--no-index", "--", "/dev/null", rel]) ?? "";
+  const hasHead = git(root2, ["rev-parse", "--verify", "HEAD"]) !== null;
+  return git(root2, hasHead ? ["diff", "HEAD", "--", rel] : ["diff", "--cached", "--", rel]) ?? "";
+}
+
+// src/server/index.ts
+var IMAGE_MIME = {
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".avif": "image/avif",
+  ".svg": "image/svg+xml",
+  ".bmp": "image/bmp",
+  ".ico": "image/x-icon"
+};
+var MIME = {
+  ".html": "text/html; charset=utf-8",
+  ".js": "text/javascript",
+  ".css": "text/css",
+  ".svg": "image/svg+xml",
+  ".json": "application/json",
+  ".woff2": "font/woff2"
+};
+var HttpError = class extends Error {
+  constructor(status, message) {
+    super(message);
+    this.status = status;
+  }
+  status;
+};
+async function readBody(req) {
+  let data = "";
+  for await (const chunk of req) data += chunk;
+  if (!data) return {};
+  if (!req.headers["content-type"]?.startsWith("application/json")) throw new HttpError(415, "Expected application/json");
+  return JSON.parse(data);
+}
+var LOCAL_HOSTS = /* @__PURE__ */ new Set(["localhost", "127.0.0.1", "[::1]"]);
+function isLocalRequest(req) {
+  const host = req.headers.host ?? "";
+  try {
+    if (!LOCAL_HOSTS.has(new URL(`http://${host}`).hostname)) return false;
+    return !req.headers.origin || new URL(req.headers.origin).host === host;
+  } catch {
+    return false;
+  }
+}
+async function startServer({ root: root2, port, open: openBrowser }) {
+  const config = () => readConfig(root2) ?? { mainDoc: null, langs: [] };
+  const sourceLang = () => projectSourceLang(root2, readConfig(root2)?.mainDoc);
+  const viewLang = (value) => isLang(value) && value !== sourceLang() && config().langs.includes(value) ? value : null;
+  const mdPath = (rel) => {
+    if (typeof rel !== "string" || !rel.toLowerCase().endsWith(".md")) throw new HttpError(400, "Expected a .md path");
+    safeResolve(root2, rel);
+    return rel;
+  };
+  const deletable = (rel) => {
+    if (typeof rel !== "string" || !rel.trim()) throw new HttpError(400, "Expected a path");
+    const abs = safeResolve(root2, rel);
+    if (abs === root2) throw new HttpError(400, "Refusing to delete the project root");
+    if (!fs6.existsSync(abs)) throw new HttpError(404, "Not found");
+    return abs;
+  };
+  const routes = {
+    "GET /api/info": () => {
+      const c = config();
+      return { name: path6.basename(root2), mainDoc: c.mainDoc ?? null, sourceLang: sourceLang(), langs: c.langs.filter((l) => l !== sourceLang()), git: isGitRepo(root2) };
+    },
+    "PUT /api/config": (_, body) => {
+      const c = config();
+      if (Array.isArray(body.langs)) c.langs = body.langs.filter(isLang);
+      if (isLang(body.sourceLang) && body.sourceLang !== sourceLang()) {
+        if (!c.mainDoc) throw new HttpError(400, "No main document configured; run `mdrules init`");
+        applyRulesToFile(path6.join(root2, c.mainDoc), void 0, body.sourceLang);
+      }
+      writeConfig(root2, c);
+      return { ...c, langs: c.langs.filter((l) => l !== sourceLang()) };
+    },
+    "GET /api/settings": () => readSettings(),
+    "PUT /api/settings": (_, body) => writeSettings(body),
+    "GET /api/tree": (url2) => {
+      const l = viewLang(url2.searchParams.get("lang"));
+      const sync2 = l ? Object.fromEntries(allStatuses(root2, l).map((e) => [e.path, e.status])) : {};
+      const foreign = Object.fromEntries(foreignFiles(root2, sourceLang()).map((f) => [f.path, f.detected]));
+      return { tree: scanTree(root2), git: gitStatuses(root2), sync: sync2, foreign };
+    },
+    "POST /api/keep-language": (_, body) => ({ lang: keepLanguage(root2, mdPath(body.path)) }),
+    "GET /api/file": (url2) => {
+      const rel = mdPath(url2.searchParams.get("path"));
+      const l = viewLang(url2.searchParams.get("lang"));
+      const source = fs6.readFileSync(safeResolve(root2, rel), "utf8");
+      if (l) {
+        const tPath = translationPath(root2, l, rel);
+        if (fs6.existsSync(tPath)) return { path: rel, content: fs6.readFileSync(tPath, "utf8"), target: "translation", status: fileStatus(root2, l, rel) };
+        return { path: rel, content: source, target: "source", status: "missing" };
+      }
+      return { path: rel, content: source, target: "source", status: null };
+    },
+    "PUT /api/file": (_, body) => {
+      const rel = mdPath(body.path);
+      const l = viewLang(body.lang);
+      const file = body.target === "translation" && l ? translationPath(root2, l, rel) : safeResolve(root2, rel);
+      fs6.mkdirSync(path6.dirname(file), { recursive: true });
+      fs6.writeFileSync(file, String(body.content ?? ""));
+      return { ok: true, status: l ? fileStatus(root2, l, rel) : null };
+    },
+    "POST /api/file": (_, body) => {
+      const rel = mdPath(body.path);
+      const file = safeResolve(root2, rel);
+      if (fs6.existsSync(file)) throw new HttpError(409, "File already exists");
+      fs6.mkdirSync(path6.dirname(file), { recursive: true });
+      const title = path6.basename(rel, ".md").replace(/^\d+[-_]/, "").replace(/[-_]/g, " ");
+      fs6.writeFileSync(file, `# ${title.charAt(0).toUpperCase() + title.slice(1)}
+
+`);
+      return { ok: true, path: rel };
+    },
+    "GET /api/delete-preview": (url2) => {
+      const abs = deletable(url2.searchParams.get("path"));
+      if (!fs6.statSync(abs).isDirectory()) return { kind: "file", files: 1, md: 1 };
+      const files = fs6.readdirSync(abs, { recursive: true, withFileTypes: true }).filter((e) => e.isFile());
+      return { kind: "dir", files: files.length, md: files.filter((e) => e.name.toLowerCase().endsWith(".md")).length };
+    },
+    "DELETE /api/path": (url2) => {
+      const rel = toPosix(path6.relative(root2, deletable(url2.searchParams.get("path"))));
+      fs6.rmSync(safeResolve(root2, rel), { recursive: true });
+      for (const l of config().langs) fs6.rmSync(translationPath(root2, l, rel), { recursive: true, force: true });
+      return { ok: true };
+    },
+    "POST /api/ignore": (_, body) => {
+      safeResolve(root2, body.path);
+      setIgnored(root2, body.path, body.kind === "dir" ? "dir" : "file", !!body.ignored);
+      return { ok: true };
+    },
+    "GET /api/diff": (url2) => ({ diff: gitDiff(root2, mdPath(url2.searchParams.get("path"))) }),
+    "GET /api/dashboard": () => ({ docs: summarize(root2) }),
+    "GET /api/rules": () => {
+      const mainDoc = readConfig(root2)?.mainDoc;
+      const text = mainDoc && fs6.existsSync(path6.join(root2, mainDoc)) ? fs6.readFileSync(path6.join(root2, mainDoc), "utf8") : "";
+      return { rules: listRules(), applied: appliedRuleIds(text), mainDoc: mainDoc ?? null };
+    },
+    "PUT /api/rules": (_, body) => saveRule(body),
+    "DELETE /api/rules": (url2) => {
+      deleteRule(url2.searchParams.get("id") ?? "");
+      return { ok: true };
+    },
+    "POST /api/rules/apply": (_, body) => {
+      const mainDoc = readConfig(root2)?.mainDoc;
+      if (!mainDoc) throw new HttpError(400, "No main document configured; run `mdrules init`");
+      applyRulesToFile(path6.join(root2, mainDoc), body.ids ?? []);
+      return { ok: true };
+    }
+  };
+  const server = http.createServer(async (req, res) => {
+    if (!isLocalRequest(req)) {
+      res.writeHead(403).end("Forbidden");
+      return;
+    }
+    const url2 = new URL(req.url ?? "/", "http://localhost");
+    const route = routes[`${req.method} ${url2.pathname}`];
+    if (route) {
+      try {
+        const result = await route(url2, req.method === "GET" || req.method === "DELETE" ? {} : await readBody(req));
+        res.writeHead(200, { "content-type": "application/json" }).end(JSON.stringify(result));
+      } catch (err) {
+        const status = err instanceof HttpError ? err.status : err.code === "ENOENT" ? 404 : 500;
+        res.writeHead(status, { "content-type": "application/json" }).end(JSON.stringify({ error: err.message }));
+      }
+      return;
+    }
+    if (req.method === "GET" && url2.pathname === "/api/asset") return serveAsset(url2.searchParams.get("path") ?? "", res);
+    serveStatic(url2.pathname, res);
+  });
+  function serveAsset(rel, res) {
+    let file;
+    try {
+      file = safeResolve(root2, rel);
+    } catch {
+      res.writeHead(404).end();
+      return;
+    }
+    const type = IMAGE_MIME[path6.extname(file).toLowerCase()];
+    if (!type || !fs6.existsSync(file) || !fs6.statSync(file).isFile()) {
+      res.writeHead(404).end();
+      return;
+    }
+    res.writeHead(200, { "content-type": type, "cache-control": "no-cache" });
+    fs6.createReadStream(file).pipe(res);
+  }
+  const actualPort = await listen(server, port);
+  const wss = new WebSocketServer({ server, path: "/ws", verifyClient: ({ req }) => isLocalRequest(req) });
+  const broadcast = (msg) => {
+    const data = JSON.stringify(msg);
+    for (const client of wss.clients) client.send(data);
+  };
+  const skips = watchSkips(root2);
+  watch(root2, {
+    ignoreInitial: true,
+    // Unreadable folders (e.g. caches owned by another user) are skipped instead of failing.
+    ignorePermissionErrors: true,
+    ignored: (p2, stats) => {
+      const rel = toPosix(path6.relative(root2, p2));
+      if (rel === ".mdrules") return false;
+      if (rel.startsWith(".mdrules/")) return !rel.startsWith(".mdrules/i18n") && rel !== ".mdrules/state.json" && rel !== ".mdrules/config.json";
+      return skips(rel, stats ? stats.isDirectory() : void 0);
+    }
+  }).on("error", (err) => console.warn(pc.yellow(`  file watcher: ${err.message}`))).on("all", (event, file) => {
+    const abs = path6.resolve(file);
+    if (!abs.endsWith(".md") && !abs.endsWith(".json") && !abs.endsWith(".mdrulesignore") && event !== "addDir" && event !== "unlinkDir") return;
+    let rel = toPosix(path6.relative(root2, abs));
+    const i18n = toPosix(path6.relative(root2, path6.join(stateDir(root2), "i18n")));
+    if (rel.startsWith(i18n + "/")) rel = rel.split("/").slice(3).join("/");
+    broadcast({ type: "fs", event, path: rel });
+  });
+  const url = `http://localhost:${actualPort}`;
+  console.log(`
+  ${pc.bold("mdrules")} ${pc.dim("\u2192")} ${pc.cyan(url)}  ${pc.dim(root2)}
+`);
+  if (!fs6.existsSync(WEB_DIR)) console.log(pc.yellow("  Web UI not built: run `pnpm build`, or `pnpm dev` and open http://localhost:4320\n"));
+  else if (openBrowser) open(url).catch(() => {
+  });
+}
+function listen(server, port) {
+  return new Promise((resolve, reject) => {
+    server.once("error", (err) => {
+      if (err.code === "EADDRINUSE") resolve(listen(server, port + 1));
+      else reject(err);
+    });
+    server.listen(port, "127.0.0.1", () => resolve(port));
+  });
+}
+function serveStatic(pathname, res) {
+  let file = path6.join(WEB_DIR, path6.normalize(pathname).replace(/^(\.\.[/\\])+/, ""));
+  if (!file.startsWith(WEB_DIR) || !fs6.existsSync(file) || fs6.statSync(file).isDirectory()) file = path6.join(WEB_DIR, "index.html");
+  if (!fs6.existsSync(file)) {
+    res.writeHead(404).end("Web UI not built. Run `pnpm build`.");
+    return;
+  }
+  res.writeHead(200, { "content-type": MIME[path6.extname(file)] ?? "application/octet-stream" });
+  fs6.createReadStream(file).pipe(res);
+}
+
+// src/cli/init.ts
+import fs8 from "fs";
+import path8 from "path";
+import * as p from "@clack/prompts";
+import pc2 from "picocolors";
+
+// src/core/scaffold.ts
+import fs7 from "fs";
+import path7 from "path";
+var today = () => (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+function fill(text, vars) {
+  return text.replace(/\{\{(\w+)\}\}/g, (_, k) => vars[k] ?? "");
+}
+function copyTree(src, dest, vars, created, root2) {
+  for (const e of fs7.readdirSync(src, { withFileTypes: true })) {
+    const from = path7.join(src, e.name);
+    const to = path7.join(dest, e.name);
+    if (e.isDirectory()) {
+      fs7.mkdirSync(to, { recursive: true });
+      copyTree(from, to, vars, created, root2);
+    } else if (!fs7.existsSync(to)) {
+      fs7.writeFileSync(to, fill(fs7.readFileSync(from, "utf8"), vars));
+      created.push(toPosix(path7.relative(root2, to)));
+    }
+  }
+}
+function scaffoldDocs(root2) {
+  const created = [];
+  fs7.mkdirSync(path7.join(root2, "docs"), { recursive: true });
+  copyTree(path7.join(TEMPLATES_DIR, "docs"), path7.join(root2, "docs"), { date: today() }, created, root2);
+  return created;
+}
+function createMainDoc(root2, name) {
+  const file = path7.join(root2, name);
+  if (fs7.existsSync(file)) return;
+  const text = fs7.readFileSync(path7.join(TEMPLATES_DIR, "main.md"), "utf8");
+  fs7.writeFileSync(file, fill(text, { name: path7.basename(root2), date: today() }));
+}
+function installSkill(root2) {
+  const dir = path7.join(root2, ".claude", "skills", "mdrules");
+  fs7.mkdirSync(dir, { recursive: true });
+  fs7.copyFileSync(path7.join(TEMPLATES_DIR, "skill", "SKILL.md"), path7.join(dir, "SKILL.md"));
+}
+function ensureGitignore(root2) {
+  const file = path7.join(root2, ".gitignore");
+  const text = fs7.existsSync(file) ? fs7.readFileSync(file, "utf8") : "";
+  if (text.split("\n").some((l) => [".mdrules", ".mdrules/", "/.mdrules", "/.mdrules/"].includes(l.trim()))) return;
+  fs7.writeFileSync(file, text + (text && !text.endsWith("\n") ? "\n" : "") + ".mdrules/\n");
+}
+function hideInVsCode(root2) {
+  const file = path7.join(root2, ".vscode", "settings.json");
+  let settings = {};
+  if (fs7.existsSync(file)) {
+    try {
+      settings = JSON.parse(fs7.readFileSync(file, "utf8"));
+    } catch {
+      return false;
+    }
+  }
+  settings["files.exclude"] = { ...settings["files.exclude"] ?? {}, "**/.mdrules": true };
+  fs7.mkdirSync(path7.dirname(file), { recursive: true });
+  fs7.writeFileSync(file, JSON.stringify(settings, null, 2) + "\n");
+  return true;
+}
+
+// src/cli/init.ts
+function check(value) {
+  if (p.isCancel(value)) {
+    p.cancel("Cancelled.");
+    process.exit(0);
+  }
+  return value;
+}
+async function chooseMainDoc(root2) {
+  const existing = MAIN_DOCS.filter((d) => fs8.existsSync(path8.join(root2, d)));
+  if (existing.length === 2) {
+    return check(
+      await p.select({
+        message: "Both CLAUDE.md and AGENTS.md exist. Which one is the main document?",
+        options: existing.map((d) => ({ value: d, label: d }))
+      })
+    );
+  }
+  if (existing.length === 1) {
+    const choice2 = check(
+      await p.select({
+        message: `Found ${pc2.cyan(existing[0])}. Use it as the main document?`,
+        options: [
+          { value: existing[0], label: `Yes, use ${existing[0]}` },
+          ...MAIN_DOCS.filter((d) => d !== existing[0]).map((d) => ({ value: d, label: `No, create ${d}` }))
+        ]
+      })
+    );
+    createMainDoc(root2, choice2);
+    return choice2;
+  }
+  const choice = check(
+    await p.select({
+      message: "No CLAUDE.md or AGENTS.md found. Which one should I create?",
+      options: MAIN_DOCS.map((d) => ({ value: d, label: d, hint: d === "CLAUDE.md" ? "Claude Code" : "other agents" }))
+    })
+  );
+  createMainDoc(root2, choice);
+  p.log.success(`Created ${choice}`);
+  return choice;
+}
+async function runInit(root2) {
+  p.intro(pc2.bgCyan(pc2.black(" mdrules ")));
+  const previous = readConfig(root2);
+  const mainDoc = await chooseMainDoc(root2);
+  const mainFile = path8.join(root2, mainDoc);
+  if (!fs8.existsSync(path8.join(root2, "docs"))) {
+    const create = check(await p.confirm({ message: "Create the base /docs structure?", initialValue: true }));
+    if (create) p.log.success(`Created ${scaffoldDocs(root2).join(", ")}`);
+  }
+  const mainText = fs8.readFileSync(mainFile, "utf8");
+  const sourceLang = check(
+    await p.select({
+      message: "Source language of the .md files (what the AI reads and writes)",
+      options: LANGS.map((l) => ({ value: l, label: LANG_NAMES[l], hint: l === "en" ? "default" : void 0 })),
+      initialValue: sourceLangOf(mainText)
+    })
+  );
+  const langs = check(
+    await p.multiselect({
+      message: "Translation languages (view and edit docs in them; the source files never change language)",
+      options: LANGS.filter((l) => l !== sourceLang).map((l) => ({ value: l, label: LANG_NAMES[l] })),
+      initialValues: (previous?.langs ?? []).filter((l) => l !== sourceLang),
+      required: false
+    })
+  );
+  const rules = listRules();
+  const applied = appliedRuleIds(mainText);
+  const selected = check(
+    await p.multiselect({
+      message: "Which working rules apply to this project?",
+      options: rules.map((r) => ({ value: r.id, label: r.title, hint: r.body.split("\n")[0].replace(/^- /, "") })),
+      initialValues: applied,
+      required: false
+    })
+  );
+  applyRulesToFile(mainFile, selected, sourceLang);
+  const subprojects = findSubprojects(scanTree(root2));
+  if (subprojects.length && selected.length) {
+    const targets = check(
+      await p.multiselect({
+        message: "Monorepo detected. Apply the same rules to these projects too?",
+        options: subprojects.map((s) => ({ value: s, label: s })),
+        required: false
+      })
+    );
+    for (const dir of targets) {
+      const doc = MAIN_DOCS.find((d) => fs8.existsSync(path8.join(root2, dir, d)));
+      applyRulesToFile(path8.join(root2, dir, doc), selected, sourceLang);
+    }
+  }
+  ensureGitignore(root2);
+  if (!previous) {
+    const hide = check(await p.confirm({ message: "Hide the .mdrules/ folder in VS Code?", initialValue: true }));
+    if (hide && !hideInVsCode(root2)) p.log.warn('.vscode/settings.json has comments; add "**/.mdrules": true to files.exclude by hand.');
+  }
+  installSkill(root2);
+  const config = { mainDoc, langs, initializedAt: previous?.initializedAt ?? (/* @__PURE__ */ new Date()).toISOString() };
+  writeConfig(root2, config);
+  p.outro(`Ready. Skill installed in ${pc2.cyan(".claude/skills/mdrules")}`);
+  return config;
+}
+
+// src/cli/index.ts
+var HELP = `mdrules \u2014 visual editor for your project's Markdown
+
+Usage
+  mdrules                 init if needed, then open the editor
+  mdrules init            (re)run the setup: main doc, docs/, rules, language
+  mdrules serve           open the editor without running init
+  mdrules sync --status [--json]                    translations + files not in the source language
+  mdrules sync --mark [--lang xx] <path...>|--all   record translations as in sync
+  mdrules sync --keep <path...>                     keep files in their current language
+
+Options
+  --port <n>   server port (default 4319)
+  --no-open    do not open the browser
+`;
+var args = process.argv.slice(2);
+var flag = (name) => args.includes(name);
+var option = (name) => {
+  const i = args.indexOf(name);
+  return i >= 0 ? args[i + 1] : void 0;
+};
+var command = args[0] && !args[0].startsWith("-") ? args[0] : "start";
+var root = process.env.MDRULES_ROOT ?? process.cwd();
+async function main() {
+  if (flag("--help") || flag("-h")) return console.log(HELP);
+  if (command === "sync") return sync();
+  if (command === "init") {
+    await runInit(root);
+    return;
+  }
+  if (command === "start" && !readConfig(root)) {
+    if (process.stdin.isTTY) await runInit(root);
+  }
+  if (command === "start" || command === "serve") {
+    await startServer({ root, port: Number(option("--port") ?? 4319), open: !flag("--no-open") });
+    return;
+  }
+  console.log(HELP);
+  process.exitCode = 1;
+}
+function sync() {
+  const report = syncReport(root);
+  const paths = (after) => args.slice(args.indexOf(after) + 1).filter((a, i, all) => !a.startsWith("--") && all[i - 1] !== "--lang");
+  if (flag("--keep")) {
+    for (const p2 of paths("--keep")) {
+      try {
+        console.log(`kept    ${p2} (${keepLanguage(root, p2)})`);
+      } catch (err) {
+        console.error(`skipped ${p2}: ${err.message}`);
+      }
+    }
+    return;
+  }
+  if (flag("--mark")) {
+    const only = option("--lang");
+    const langs = only && isLang(only) ? [only] : report.langs;
+    const files = flag("--all") ? [...new Set(report.files.map((f) => f.path))] : paths("--mark");
+    for (const p2 of files) {
+      for (const l of langs) {
+        try {
+          markSynced(root, l, p2);
+          console.log(`synced  ${l} ${p2}`);
+        } catch (err) {
+          if (!flag("--all")) console.error(`skipped ${l} ${p2}: ${err.message}`);
+        }
+      }
+    }
+    return;
+  }
+  if (flag("--json")) return console.log(JSON.stringify(report, null, 2));
+  console.log(`Source language: ${report.sourceLang}   Translations: ${report.langs.join(", ") || "none"}`);
+  if (report.foreign.length) {
+    console.log(`
+Not in ${report.sourceLang}:`);
+    for (const f of report.foreign) console.log(`  ${f.detected}  ${f.path}`);
+  }
+  const pending = report.files.filter((f) => f.status !== "synced");
+  if (pending.length) console.log("");
+  for (const e of pending) console.log(`${e.lang}  ${e.status.padEnd(13)} ${e.path}`);
+  if (!pending.length && !report.foreign.length) console.log("Everything in sync.");
+}
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});