@hasna/instructions 0.6.0 → 0.7.0

package/dist/chunks/index-1cnyjnd7.js

@@ -0,0 +1,623 @@
+// @bun
+import {
+  applyConfigsWithReport,
+  compactPathForConfigHome,
+  expandPath,
+  getConfigHome,
+  normalizeTargetPath
+} from "./index-z3ma4aqk.js";
+import {
+  applyTransform,
+  detectMachineContext,
+  isRetiredOrUnsupportedConfigAgent,
+  isSecretVarName,
+  redactContent,
+  redactFormatForTarget,
+  resolveConfigStore,
+  retiredOrUnsupportedAgentReason,
+  templateizeMachineContent
+} from "./index-7m4j8a33.js";
+
+// src/lib/sync.ts
+import { existsSync as existsSync2, readdirSync as readdirSync2, readFileSync as readFileSync2 } from "fs";
+import { basename, extname, join as join2 } from "path";
+
+// src/lib/sync-dir.ts
+import { existsSync, readdirSync, readFileSync, statSync } from "fs";
+import { join, relative } from "path";
+var SKIP = [".db", ".db-shm", ".db-wal", ".log", ".lock", ".DS_Store", "node_modules", ".git"];
+function shouldSkip(p) {
+  return SKIP.some((s) => p.includes(s));
+}
+async function syncFromDir(dir, opts = {}) {
+  const store = opts.store ?? resolveConfigStore();
+  const absDir = expandPath(dir);
+  if (!existsSync(absDir))
+    return { added: 0, updated: 0, unchanged: 0, skipped: [`Not found: ${absDir}`] };
+  const files = opts.recursive !== false ? walkDir(absDir) : readdirSync(absDir).map((f) => join(absDir, f)).filter((f) => statSync(f).isFile());
+  const result = { added: 0, updated: 0, unchanged: 0, skipped: [] };
+  const allConfigs = await store.listConfigs();
+  for (const file of files) {
+    if (shouldSkip(file)) {
+      result.skipped.push(file);
+      continue;
+    }
+    try {
+      const content = readFileSync(file, "utf-8");
+      if (content.length > 500000) {
+        result.skipped.push(file + " (too large)");
+        continue;
+      }
+      const targetPath = compactPathForConfigHome(file);
+      const redacted = redactContent(content, redactFormatForTarget(targetPath, detectFormat(file)));
+      const existing = allConfigs.find((c) => c.target_path === targetPath);
+      if (!existing) {
+        if (!opts.dryRun)
+          await store.createConfig({ name: relative(absDir, file), category: detectCategory(file), agent: detectAgent(file), target_path: targetPath, format: detectFormat(file), content: redacted.content });
+        result.added++;
+      } else if (existing.content !== redacted.content) {
+        if (!opts.dryRun)
+          await store.updateConfig(existing.id, { content: redacted.content });
+        result.updated++;
+      } else {
+        result.unchanged++;
+      }
+    } catch {
+      result.skipped.push(file);
+    }
+  }
+  return result;
+}
+async function syncToDir(dir, opts = {}) {
+  const store = opts.store ?? resolveConfigStore();
+  const absDir = expandPath(dir);
+  const normalized = dir.startsWith("~/") ? dir : compactPathForConfigHome(absDir);
+  const configs = (await store.listConfigs()).filter((c) => c.target_path && (c.target_path.startsWith(normalized) || c.target_path.startsWith(absDir)));
+  const result = { added: 0, updated: 0, unchanged: 0, skipped: [] };
+  for (const config of configs) {
+    if (config.kind === "reference")
+      continue;
+    try {
+      const report = await applyConfigsWithReport([config], { dryRun: opts.dryRun, store });
+      result.skipped.push(...report.skipped.map((entry) => `${entry.path} (${entry.owner})`));
+      if (report.failures.length > 0)
+        throw new Error(report.failures[0].message);
+      for (const applied of report.results) {
+        applied.changed ? result.updated++ : result.unchanged++;
+      }
+    } catch {
+      result.skipped.push(config.target_path || config.id);
+    }
+  }
+  return result;
+}
+function walkDir(dir, files = []) {
+  for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    const full = join(dir, entry.name);
+    if (shouldSkip(full))
+      continue;
+    if (entry.isDirectory())
+      walkDir(full, files);
+    else if (entry.isFile())
+      files.push(full);
+  }
+  return files;
+}
+
+// src/lib/sync.ts
+var CLAUDE_PROMPT_OUTPUTS = [
+  { agent: "codex", target_path: "~/.codex/AGENTS.md", transform: "codex-flat" },
+  { agent: "codewith", target_path: "~/.codewith/CODEWITH.md", transform: "codex-flat" },
+  { agent: "opencode", target_path: "~/.config/opencode/AGENTS.md", transform: "opencode-flat" },
+  { agent: "aicopilot", target_path: "~/.config/aicopilot/AICOPILOT.md", transform: "codex-flat" },
+  { agent: "antigravity", target_path: "~/.gemini/GEMINI.md", transform: "codex-flat" },
+  { agent: "cursor", target_path: "~/.cursor/rules/claude.mdc", transform: "cursor-mdc" },
+  { agent: "qwen", target_path: "~/.qwen/QWEN.md", transform: "codex-flat" }
+];
+function claudeRuleOutputs(fileName) {
+  const stem = basename(fileName, extname(fileName));
+  return [
+    { agent: "cursor", target_path: `~/.cursor/rules/${stem}.mdc`, transform: "cursor-mdc" }
+  ];
+}
+function normalizeOutputs(outputs) {
+  return outputs ?? [];
+}
+function outputsEqual(a, b) {
+  return JSON.stringify(normalizeOutputs(a)) === JSON.stringify(normalizeOutputs(b));
+}
+var UNGUARDED_LOCAL_ENV_HELPER = '. "$HOME/.local/bin/env"';
+var GUARDED_LOCAL_ENV_HELPER = '[ -r "$HOME/.local/bin/env" ] && . "$HOME/.local/bin/env"';
+function normalizeKnownConfigSource(known, content) {
+  if (known.name !== "bash-profile")
+    return content;
+  return content.split(`
+`).map((line) => line === UNGUARDED_LOCAL_ENV_HELPER ? GUARDED_LOCAL_ENV_HELPER : line).join(`
+`);
+}
+function outputOwnerIdsByTarget(configs) {
+  const owners = new Map;
+  for (const config of configs) {
+    for (const output of config.outputs) {
+      const targetPath = normalizeTargetPath(output.target_path);
+      const existing = owners.get(targetPath) ?? new Set;
+      existing.add(config.id);
+      owners.set(targetPath, existing);
+    }
+  }
+  return owners;
+}
+function isGeneratedOutputTarget(config, owners) {
+  if (!config.target_path)
+    return false;
+  const ownerIds = owners.get(normalizeTargetPath(config.target_path));
+  return !!ownerIds && !ownerIds.has(config.id);
+}
+function hasClaudePromptSource() {
+  return existsSync2(expandPath("~/.claude/CLAUDE.md"));
+}
+function hasClaudeRuleSourceForCursorTarget(targetPath) {
+  const absoluteTargetPath = expandPath(targetPath);
+  const absolutePrefix = expandPath("~/.cursor/rules");
+  if (!absoluteTargetPath.startsWith(`${absolutePrefix}/`) || !absoluteTargetPath.endsWith(".mdc"))
+    return false;
+  const stem = basename(absoluteTargetPath, ".mdc");
+  return existsSync2(expandPath(`~/.claude/rules/${stem}.md`)) || existsSync2(expandPath(`~/.claude/rules/${stem}.mdc`));
+}
+function isKnownGeneratedTargetPath(targetPath) {
+  const normalizedTargetPath = normalizeTargetPath(targetPath);
+  const promptTargets = new Set(CLAUDE_PROMPT_OUTPUTS.map((output) => normalizeTargetPath(output.target_path)));
+  if (promptTargets.has(normalizedTargetPath))
+    return hasClaudePromptSource();
+  return hasClaudeRuleSourceForCursorTarget(targetPath);
+}
+var KNOWN_CONFIGS = [
+  { path: "~/.claude/CLAUDE.md", name: "claude-claude-md", category: "rules", agent: "claude", format: "markdown", outputs: CLAUDE_PROMPT_OUTPUTS },
+  { path: "~/.claude/settings.json", name: "claude-settings", category: "agent", agent: "claude", format: "json" },
+  { path: "~/.claude/settings.local.json", name: "claude-settings-local", category: "agent", agent: "claude", format: "json" },
+  { path: "~/.claude/keybindings.json", name: "claude-keybindings", category: "agent", agent: "claude", format: "json", optional: true },
+  { path: "~/.claude/rules", name: "claude-rules", category: "rules", agent: "claude", rulesDir: "~/.claude/rules", rulesExtensions: [".md", ".mdc"] },
+  { path: "~/.codex/config.toml", name: "codex-config", category: "agent", agent: "codex", format: "toml" },
+  { path: "~/.codex/AGENTS.md", name: "codex-agents-md", category: "rules", agent: "codex", format: "markdown" },
+  { path: "~/.config/opencode/AGENTS.md", name: "opencode-agents-md", category: "rules", agent: "opencode", format: "markdown", optional: true },
+  { path: "~/.config/opencode/opencode.json", name: "opencode-config", category: "mcp", agent: "opencode", format: "json", optional: true, description: "OpenCode config (includes Skills MCP server entries)" },
+  { path: "~/.cursor/rules", name: "cursor-rules", category: "rules", agent: "cursor", rulesDir: "~/.cursor/rules", rulesExtensions: [".md", ".mdc"] },
+  { path: "~/.cursor/mcp.json", name: "cursor-mcp", category: "mcp", agent: "cursor", format: "json", optional: true, description: "Cursor MCP config (includes Skills MCP server entries)" },
+  { path: "~/.codewith/CODEWITH.md", name: "codewith-codewith-md", category: "rules", agent: "codewith", format: "markdown", optional: true },
+  { path: "~/.codewith/config.toml", name: "codewith-config", category: "mcp", agent: "codewith", format: "toml", optional: true, description: "codewith config (Codex fork, includes Skills MCP server entries)" },
+  { path: "~/.config/aicopilot/AICOPILOT.md", name: "aicopilot-aicopilot-md", category: "rules", agent: "aicopilot", format: "markdown", optional: true },
+  { path: "~/.config/aicopilot/aicopilot.json", name: "aicopilot-config", category: "mcp", agent: "aicopilot", format: "json", optional: true, description: "AI Copilot config (includes instructions and MCP server entries)" },
+  { path: "~/.gemini/GEMINI.md", name: "antigravity-global-rules", category: "rules", agent: "antigravity", format: "markdown", optional: true, description: "Google Antigravity global rules file" },
+  { path: "~/.gemini/config/mcp_config.json", name: "antigravity-global-mcp", category: "mcp", agent: "antigravity", format: "json", optional: true, description: "Google Antigravity global MCP server entries" },
+  { path: "~/.qwen/QWEN.md", name: "qwen-qwen-md", category: "rules", agent: "qwen", format: "markdown", optional: true, description: "Qwen Code global instructional context" },
+  { path: "~/.qwen/settings.json", name: "qwen-settings", category: "agent", agent: "qwen", format: "json", optional: true, description: "Qwen Code settings.json, including native hooks" },
+  { path: "~/.claude.json", name: "claude-json", category: "mcp", agent: "claude", format: "json", description: "Claude Code global config (includes MCP server entries)" },
+  { path: "~/.zshrc", name: "zshrc", category: "shell", agent: "zsh" },
+  { path: "~/.zprofile", name: "zprofile", category: "shell", agent: "zsh", optional: true },
+  { path: "~/.bashrc", name: "bashrc", category: "shell", agent: "zsh", optional: true },
+  { path: "~/.bash_profile", name: "bash-profile", category: "shell", agent: "zsh", optional: true },
+  { path: "~/.gitconfig", name: "gitconfig", category: "git", agent: "git", format: "ini" },
+  { path: "~/.gitignore_global", name: "gitignore-global", category: "git", agent: "git", optional: true },
+  { path: "~/.npmrc", name: "npmrc", category: "tools", agent: "npm", format: "ini" },
+  { path: "~/.bunfig.toml", name: "bunfig", category: "tools", agent: "global", format: "toml", optional: true }
+];
+var PROJECT_CONFIG_FILES = [
+  { file: "CLAUDE.md", category: "rules", agent: "claude", format: "markdown" },
+  { file: ".claude/settings.json", category: "agent", agent: "claude", format: "json" },
+  { file: ".claude/settings.local.json", category: "agent", agent: "claude", format: "json" },
+  { file: ".mcp.json", category: "mcp", agent: "claude", format: "json" },
+  { file: "AGENTS.md", category: "rules", agent: "codex", format: "markdown" },
+  { file: ".codex/AGENTS.md", category: "rules", agent: "codex", format: "markdown" },
+  { file: ".opencode/AGENTS.md", category: "rules", agent: "opencode", format: "markdown" },
+  { file: "CODEWITH.md", category: "rules", agent: "codewith", format: "markdown" },
+  { file: ".codewith/CODEWITH.md", category: "rules", agent: "codewith", format: "markdown" },
+  { file: ".aicopilot/AICOPILOT.md", category: "rules", agent: "aicopilot", format: "markdown" },
+  { file: "AICOPILOT.md", category: "rules", agent: "aicopilot", format: "markdown" },
+  { file: ".cursor/mcp.json", category: "mcp", agent: "cursor", format: "json" },
+  { file: ".github/copilot-instructions.md", category: "rules", agent: "copilot", format: "markdown" },
+  { file: "QWEN.md", category: "rules", agent: "qwen", format: "markdown" },
+  { file: ".agents/mcp_config.json", category: "mcp", agent: "antigravity", format: "json" },
+  { file: ".qwen/settings.json", category: "agent", agent: "qwen", format: "json" }
+];
+async function syncProject(opts) {
+  const store = opts.store ?? resolveConfigStore();
+  const absDir = expandPath(opts.projectDir);
+  const projectName = absDir.split("/").pop() || "project";
+  const result = { added: 0, updated: 0, unchanged: 0, skipped: [] };
+  const allConfigs = await store.listConfigs();
+  const machine = detectMachineContext();
+  for (const pf of PROJECT_CONFIG_FILES) {
+    const abs = join2(absDir, pf.file);
+    if (!existsSync2(abs))
+      continue;
+    try {
+      const rawContent = readFileSync2(abs, "utf-8");
+      if (rawContent.length > 500000) {
+        result.skipped.push(pf.file);
+        continue;
+      }
+      const redacted = redactContent(rawContent, pf.format);
+      const machineAware = templateizeMachineContent(redacted.content, machine);
+      const content = machineAware.content;
+      const isTemplate = redacted.isTemplate || machineAware.changed;
+      const name = `${projectName}/${pf.file}`;
+      const targetPath = abs.startsWith(getConfigHome()) ? abs.replace(getConfigHome(), "~") : abs;
+      const slug = name.toLowerCase().replace(/[^a-z0-9]+/g, "-");
+      const existing = allConfigs.find((c) => c.target_path === targetPath || c.slug === slug);
+      if (!existing) {
+        if (!opts.dryRun)
+          await store.createConfig({ name, category: pf.category, agent: pf.agent, format: pf.format, content, target_path: targetPath, is_template: isTemplate });
+        result.added++;
+      } else if (existing.content !== content) {
+        if (!opts.dryRun)
+          await store.updateConfig(existing.id, { content, is_template: isTemplate });
+        result.updated++;
+      } else {
+        result.unchanged++;
+      }
+    } catch {
+      result.skipped.push(pf.file);
+    }
+  }
+  for (const ruleDir of [
+    { dir: join2(absDir, ".claude", "rules"), agent: "claude", namePrefix: "rules" },
+    { dir: join2(absDir, ".agents", "rules"), agent: "antigravity", namePrefix: "antigravity-rules" },
+    { dir: join2(absDir, ".cursor", "rules"), agent: "cursor", namePrefix: "cursor-rules" },
+    { dir: join2(absDir, ".github", "instructions"), agent: "copilot", namePrefix: "copilot-instructions" },
+    { dir: join2(absDir, ".devin", "rules"), agent: "devin", namePrefix: "devin-rules" },
+    { dir: join2(absDir, ".windsurf", "rules"), agent: "windsurf-legacy", namePrefix: "windsurf-rules" },
+    { dir: join2(absDir, ".clinerules"), agent: "cline", namePrefix: "cline-rules" }
+  ]) {
+    if (!existsSync2(ruleDir.dir))
+      continue;
+    const mdFiles = readdirSync2(ruleDir.dir).filter((f) => f.endsWith(".md") || f.endsWith(".mdc"));
+    for (const f of mdFiles) {
+      const abs = join2(ruleDir.dir, f);
+      const raw = readFileSync2(abs, "utf-8");
+      const redacted = redactContent(raw, "markdown");
+      const machineAware = templateizeMachineContent(redacted.content, machine);
+      const content = machineAware.content;
+      const isTemplate = redacted.isTemplate || machineAware.changed;
+      const name = `${projectName}/${ruleDir.namePrefix}/${f}`;
+      const targetPath = abs.startsWith(getConfigHome()) ? abs.replace(getConfigHome(), "~") : abs;
+      const slug = name.toLowerCase().replace(/[^a-z0-9]+/g, "-");
+      const existing = allConfigs.find((c) => c.target_path === targetPath || c.slug === slug);
+      if (!existing) {
+        if (!opts.dryRun)
+          await store.createConfig({ name, category: "rules", agent: ruleDir.agent, format: "markdown", content, target_path: targetPath, is_template: isTemplate });
+        result.added++;
+      } else if (existing.content !== content) {
+        if (!opts.dryRun)
+          await store.updateConfig(existing.id, { content, is_template: isTemplate });
+        result.updated++;
+      } else {
+        result.unchanged++;
+      }
+    }
+  }
+  return result;
+}
+async function syncKnown(opts = {}) {
+  const store = opts.store ?? resolveConfigStore();
+  const result = { added: 0, updated: 0, unchanged: 0, skipped: [] };
+  const home = getConfigHome();
+  const machine = detectMachineContext();
+  let targets = KNOWN_CONFIGS;
+  if (opts.agent)
+    targets = targets.filter((k) => k.agent === opts.agent);
+  if (opts.category)
+    targets = targets.filter((k) => k.category === opts.category);
+  const allConfigs = await store.listConfigs();
+  const existingOutputOwners = outputOwnerIdsByTarget(allConfigs);
+  for (const known of targets) {
+    if (known.rulesDir) {
+      const absDir = expandPath(known.rulesDir);
+      if (!existsSync2(absDir)) {
+        result.skipped.push(known.rulesDir);
+        continue;
+      }
+      const extensions = known.rulesExtensions ?? [".md", ".mdc"];
+      const ruleFiles = readdirSync2(absDir).filter((f) => extensions.some((ext) => f.endsWith(ext)));
+      for (const f of ruleFiles) {
+        const abs2 = join2(absDir, f);
+        const targetPath = abs2.replace(home, "~");
+        if (existingOutputOwners.has(normalizeTargetPath(targetPath)) || isKnownGeneratedTargetPath(targetPath)) {
+          result.skipped.push(`${targetPath} (generated output)`);
+          continue;
+        }
+        const raw = readFileSync2(abs2, "utf-8");
+        const redacted = redactContent(raw, "markdown");
+        const machineAware = templateizeMachineContent(redacted.content, machine);
+        const content = machineAware.content;
+        const isTemplate = redacted.isTemplate || machineAware.changed;
+        const name = `${known.name}-${f}`;
+        const slug = name.toLowerCase().replace(/[^a-z0-9]+/g, "-");
+        const existing = allConfigs.find((c) => c.target_path === targetPath || c.slug === slug);
+        const outputs = known.agent === "claude" ? claudeRuleOutputs(f) : known.outputs;
+        if (!existing) {
+          if (!opts.dryRun)
+            await store.createConfig({ name, category: known.category, agent: known.agent, format: "markdown", content, target_path: targetPath, is_template: isTemplate, outputs });
+          result.added++;
+        } else if (existing.content !== content) {
+          if (!opts.dryRun)
+            await store.updateConfig(existing.id, { content, is_template: isTemplate, outputs });
+          result.updated++;
+        } else if (!outputsEqual(existing.outputs, outputs)) {
+          if (!opts.dryRun)
+            await store.updateConfig(existing.id, { outputs });
+          result.updated++;
+        } else {
+          result.unchanged++;
+        }
+      }
+      continue;
+    }
+    const abs = expandPath(known.path);
+    if (!existsSync2(abs)) {
+      result.skipped.push(known.path);
+      continue;
+    }
+    try {
+      const rawContent = normalizeKnownConfigSource(known, readFileSync2(abs, "utf-8"));
+      if (rawContent.length > 500000) {
+        result.skipped.push(known.path + " (too large)");
+        continue;
+      }
+      const fmt = known.format ?? detectFormat(abs);
+      const redacted = redactContent(rawContent, redactFormatForTarget(abs, fmt));
+      const machineAware = templateizeMachineContent(redacted.content, machine);
+      const content = machineAware.content;
+      const isTemplate = redacted.isTemplate || machineAware.changed;
+      const targetPath = abs.replace(home, "~");
+      if (existingOutputOwners.has(normalizeTargetPath(targetPath)) || isKnownGeneratedTargetPath(targetPath)) {
+        result.skipped.push(`${targetPath} (generated output)`);
+        continue;
+      }
+      const existing = allConfigs.find((c) => c.target_path === targetPath || c.slug === known.name);
+      if (!existing) {
+        if (!opts.dryRun) {
+          await store.createConfig({
+            name: known.name,
+            category: known.category,
+            agent: known.agent,
+            format: fmt,
+            content,
+            target_path: known.kind === "reference" ? null : targetPath,
+            kind: known.kind ?? "file",
+            description: known.description,
+            is_template: isTemplate,
+            outputs: known.outputs
+          });
+        }
+        result.added++;
+      } else if (existing.content !== content) {
+        if (!opts.dryRun)
+          await store.updateConfig(existing.id, { content, is_template: isTemplate, outputs: known.outputs });
+        result.updated++;
+      } else if (!outputsEqual(existing.outputs, known.outputs)) {
+        if (!opts.dryRun)
+          await store.updateConfig(existing.id, { outputs: known.outputs });
+        result.updated++;
+      } else {
+        result.unchanged++;
+      }
+    } catch {
+      result.skipped.push(known.path);
+    }
+  }
+  return result;
+}
+async function syncToDisk(opts = {}) {
+  const store = opts.store ?? resolveConfigStore();
+  const result = { added: 0, updated: 0, unchanged: 0, skipped: [] };
+  const allFileConfigs = await store.listConfigs({ kind: "file", ...opts.category ? { category: opts.category } : {} });
+  const outputOwners = outputOwnerIdsByTarget(allFileConfigs);
+  let configs = allFileConfigs.filter((config) => {
+    return !isGeneratedOutputTarget(config, outputOwners);
+  }).filter((config) => {
+    if (!opts.agent)
+      return true;
+    return config.agent === opts.agent || config.outputs.some((output) => output.agent === opts.agent);
+  });
+  for (const config of configs) {
+    if (!config.target_path && config.outputs.length === 0)
+      continue;
+    if (isRetiredOrUnsupportedConfigAgent(config.agent)) {
+      result.skipped.push(`${config.slug} (${retiredOrUnsupportedAgentReason(config.agent)})`);
+      continue;
+    }
+    try {
+      const report = await applyConfigsWithReport([config], {
+        dryRun: opts.dryRun,
+        store,
+        outputAgent: opts.agent
+      });
+      result.skipped.push(...report.skipped.map((entry) => `${entry.path} (${entry.owner})`));
+      if (report.failures.length > 0)
+        throw new Error(report.failures[0].message);
+      for (const applied of report.results) {
+        applied.changed ? result.updated++ : result.unchanged++;
+      }
+    } catch {
+      result.skipped.push(config.target_path ?? config.id);
+    }
+  }
+  return result;
+}
+var CERTAIN_PLACEHOLDER_RE = /\{\{[A-Za-z_][A-Za-z0-9_]*\}\}/g;
+var ASSIGNED_PLACEHOLDER_RE = /[=:]\s*(["']?)(\$\{([A-Za-z_][A-Za-z0-9_]*)\}|\$([A-Z][A-Z0-9_]*)|%([A-Za-z_][A-Za-z0-9_]*)%)\1\s*,?\s*$/;
+function redactionPlaceholders(storedLine) {
+  const found = [...storedLine.match(CERTAIN_PLACEHOLDER_RE) ?? []];
+  const assigned = storedLine.match(ASSIGNED_PLACEHOLDER_RE);
+  if (assigned) {
+    const name = assigned[3] ?? assigned[4] ?? assigned[5];
+    if (name && isSecretVarName(name))
+      found.push(assigned[2]);
+  }
+  return found;
+}
+function storedPlaceholderIsLiteralOnDisk(storedLine, diskLine) {
+  return redactionPlaceholders(storedLine).some((p) => !diskLine.includes(p));
+}
+function buildDiff(expectedContent, targetPath, storedFormat, showSecrets) {
+  const path = expandPath(targetPath);
+  if (!existsSync2(path))
+    return `(file not found on disk: ${path})`;
+  const diskContent = readFileSync2(path, "utf-8");
+  if (diskContent === expectedContent)
+    return "(no diff \u2014 identical)";
+  const format = redactFormatForTarget(targetPath, storedFormat);
+  const stored = expectedContent.split(`
+`);
+  const disk = diskContent.split(`
+`);
+  const { content: redactedDiskContent, redacted } = showSecrets ? { content: diskContent, redacted: [] } : redactContent(diskContent, format);
+  const redactedDisk = redactedDiskContent.split(`
+`);
+  const reasonByLine = new Map;
+  for (const r of redacted)
+    if (!reasonByLine.has(r.line))
+      reasonByLine.set(r.line, r.reason);
+  const lines = [`--- stored (DB)`, `+++ disk (${path})`];
+  const maxLen = Math.max(stored.length, disk.length);
+  for (let i = 0;i < maxLen; i++) {
+    const lineNo = i + 1;
+    const s = stored[i];
+    const dk = disk[i];
+    if (s === dk) {
+      if (s !== undefined)
+        lines.push(` ${s}`);
+      continue;
+    }
+    if (showSecrets || dk === undefined) {
+      if (s !== undefined)
+        lines.push(`-${s}`);
+      if (dk !== undefined)
+        lines.push(`+${dk}`);
+      continue;
+    }
+    const structural = s !== undefined && storedPlaceholderIsLiteralOnDisk(s, dk);
+    const patterned = reasonByLine.has(lineNo);
+    if (!structural && !patterned) {
+      if (s !== undefined)
+        lines.push(`-${s}`);
+      lines.push(`+${dk}`);
+      continue;
+    }
+    if (structural) {
+      const placeholder = redactionPlaceholders(s).find((p) => !dk.includes(p)) ?? "a placeholder";
+      lines.push(`~line ${lineNo} differs: stored \`${s}\`, disk holds a literal value for ${placeholder} \u2014 redacted (use --show-secrets on a TTY to reveal)`);
+      continue;
+    }
+    const safe = redactedDisk[i] ?? "";
+    const reason = reasonByLine.get(lineNo);
+    if (s !== undefined && safe === s) {
+      lines.push(`~line ${lineNo} differs: stored \`${s}\`, disk holds a literal value (${reason}) \u2014 redacted (use --show-secrets on a TTY to reveal)`);
+    } else {
+      if (s !== undefined)
+        lines.push(`-${s}`);
+      lines.push(`+${safe}`);
+      lines.push(`~line ${lineNo}: disk value redacted (${reason}) \u2014 use --show-secrets on a TTY to reveal`);
+    }
+  }
+  return lines.join(`
+`);
+}
+async function diffConfig(config, opts = {}) {
+  if (!config.target_path && config.outputs.length === 0)
+    return "(reference \u2014 no target path)";
+  const diffs = [];
+  const store = opts.store ?? resolveConfigStore();
+  const contextConfigs = config.outputs.length > 0 || config.target_path ? await store.listConfigs() : [config];
+  if (isGeneratedOutputTarget(config, outputOwnerIdsByTarget(contextConfigs))) {
+    return "(generated output \u2014 managed by fan-out)";
+  }
+  const showSecrets = opts.showSecrets ?? false;
+  if (config.target_path) {
+    const diff = buildDiff(config.content, config.target_path, config.format, showSecrets);
+    if (!diff.includes("no diff"))
+      diffs.push(diff);
+  }
+  if (config.outputs.length > 0) {
+    for (const output of config.outputs) {
+      const expected = applyTransform(config, output, { configs: contextConfigs });
+      const diff = buildDiff(expected, output.target_path, detectFormat(output.target_path), showSecrets);
+      if (!diff.includes("no diff"))
+        diffs.push(diff);
+    }
+  }
+  return diffs.length > 0 ? diffs.join(`
+
+`) : "(no diff \u2014 identical)";
+}
+function detectCategory(filePath) {
+  const p = filePath.toLowerCase().replace(getConfigHome(), "~");
+  if (p.includes("/.claude/rules/") || p.includes("/.cursor/rules/") || p.includes("/.agents/rules/") || p.endsWith("claude.md") || p.endsWith("agents.md") || p.endsWith("codewith.md") || p.endsWith("aicopilot.md") || p.endsWith("/.gemini/gemini.md") || p.endsWith(".mdc"))
+    return "rules";
+  if (p.includes(".mcp.json") || p.includes("mcp"))
+    return "mcp";
+  if (p.includes("/.claude/") || p.includes("/.codex/") || p.includes("/.antigravity/") || p.includes("/.agents/") || p.includes("/.cursor/") || p.includes("/.config/opencode/") || p.includes("/.codewith/") || p.includes("/.config/aicopilot/") || p.includes("/.qwen/"))
+    return "agent";
+  if (p.includes(".zshrc") || p.includes(".zprofile") || p.includes(".bashrc") || p.includes(".bash_profile"))
+    return "shell";
+  if (p.includes(".gitconfig") || p.includes(".gitignore"))
+    return "git";
+  if (p.includes(".npmrc") || p.includes("tsconfig") || p.includes("bunfig"))
+    return "tools";
+  if (p.includes(".secrets"))
+    return "secrets_schema";
+  return "tools";
+}
+function detectAgent(filePath) {
+  const p = filePath.toLowerCase().replace(getConfigHome(), "~");
+  if (p.includes("/.github/instructions/") || p.endsWith("/.github/copilot-instructions.md"))
+    return "copilot";
+  if (p.includes("/.devin/rules/"))
+    return "devin";
+  if (p.includes("/.windsurf/rules/"))
+    return "windsurf-legacy";
+  if (p.includes("/.clinerules/"))
+    return "cline";
+  if (p.endsWith("/.gemini/gemini.md") || p.endsWith("/.gemini/config/mcp_config.json"))
+    return "antigravity";
+  if (p.includes("/.agents/rules/") || p.endsWith("/.agents/mcp_config.json"))
+    return "antigravity";
+  if (p.includes("/.claude/") || p.endsWith("claude.md"))
+    return "claude";
+  if (p.includes("/.config/opencode/"))
+    return "opencode";
+  if (p.includes("/.cursor/") || p.endsWith(".mdc"))
+    return "cursor";
+  if (p.includes("/.codewith/") || p.endsWith("codewith.md"))
+    return "codewith";
+  if (p.includes("/.config/aicopilot/"))
+    return "aicopilot";
+  if (p.includes("/.qwen/"))
+    return "qwen";
+  if (p.includes("/.antigravity/"))
+    return "antigravity";
+  if (p.includes("/.codex/") || p.endsWith("agents.md"))
+    return "codex";
+  if (p.includes(".zshrc") || p.includes(".zprofile") || p.includes(".bashrc"))
+    return "zsh";
+  if (p.includes(".gitconfig") || p.includes(".gitignore"))
+    return "git";
+  if (p.includes(".npmrc"))
+    return "npm";
+  return "global";
+}
+function detectFormat(filePath) {
+  const ext = extname(filePath).toLowerCase();
+  if (ext === ".json")
+    return "json";
+  if (ext === ".toml")
+    return "toml";
+  if (ext === ".yaml" || ext === ".yml")
+    return "yaml";
+  if (ext === ".md" || ext === ".mdc" || ext === ".markdown")
+    return "markdown";
+  if (ext === ".ini" || ext === ".cfg")
+    return "ini";
+  return "text";
+}
+export { syncFromDir, syncToDir, CLAUDE_PROMPT_OUTPUTS, KNOWN_CONFIGS, PROJECT_CONFIG_FILES, syncProject, syncKnown, syncToDisk, diffConfig, detectCategory, detectAgent, detectFormat };