conflux-ai 0.1.0

package/dist/cli/index.js

@@ -0,0 +1,1667 @@
+#!/usr/bin/env node
+
+// src/cli/index.ts
+import { Command } from "commander";
+import { readFileSync as readFileSync3 } from "fs";
+import { fileURLToPath } from "url";
+import { dirname as dirname2, join as join7 } from "path";
+
+// src/providers/registry.ts
+var ProviderRegistry = class {
+  providers = /* @__PURE__ */ new Map();
+  /** Register a provider (built-in or external) */
+  register(provider) {
+    if (this.providers.has(provider.id)) {
+      throw new Error(
+        `Provider "${provider.id}" is already registered. Remove it first before re-registering.`
+      );
+    }
+    this.providers.set(provider.id, provider);
+  }
+  /** Unregister a provider */
+  unregister(id) {
+    return this.providers.delete(id);
+  }
+  /** Get a provider by ID */
+  get(id) {
+    return this.providers.get(id);
+  }
+  /** List all registered providers */
+  list() {
+    return Array.from(this.providers.values());
+  }
+  /** Detect which providers apply to the given project */
+  detect(projectPath2) {
+    return this.list().filter((p) => p.detect(projectPath2));
+  }
+  /** Get providers that support a specific capability */
+  withCapability(capability) {
+    return this.list().filter((p) => p.capabilities.includes(capability));
+  }
+  /** Get count of registered providers */
+  get size() {
+    return this.providers.size;
+  }
+};
+var registry = new ProviderRegistry();
+
+// src/core/types.ts
+var ProviderCapability = /* @__PURE__ */ ((ProviderCapability2) => {
+  ProviderCapability2["INSTRUCTIONS"] = "instructions";
+  ProviderCapability2["HOOKS"] = "hooks";
+  ProviderCapability2["MCP"] = "mcp";
+  ProviderCapability2["PERMISSIONS"] = "permissions";
+  ProviderCapability2["SKILLS"] = "skills";
+  return ProviderCapability2;
+})(ProviderCapability || {});
+
+// src/providers/base.ts
+var AIProvider = class {
+  // ─── Utility ────────────────────────────────────────────────
+  /** Check if this provider supports a specific capability */
+  hasCapability(cap) {
+    return this.capabilities.includes(cap);
+  }
+};
+
+// src/utils/hash.ts
+import { createHash } from "crypto";
+function hashContent(content) {
+  return createHash("sha256").update(content).digest("hex").slice(0, 16);
+}
+
+// src/utils/fs.ts
+import {
+  readFileSync,
+  writeFileSync,
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  statSync,
+  symlinkSync,
+  unlinkSync,
+  rmSync
+} from "fs";
+import { dirname, join, relative } from "path";
+function readFileIfExists(path) {
+  if (existsSync(path)) {
+    return readFileSync(path, "utf-8");
+  }
+  return null;
+}
+function writeFile(path, content) {
+  const dir = dirname(path);
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  writeFileSync(path, content, "utf-8");
+}
+function pathExists(path) {
+  return existsSync(path);
+}
+function projectPath(projectRoot, ...segments) {
+  return join(projectRoot, ...segments);
+}
+
+// src/generators/instructions.ts
+function generatePrimaryInstructions(config) {
+  const lines = [
+    "# AGENTS.md",
+    "",
+    "> Auto-generated by [Conflux](https://github.com/conflux-ai/conflux).",
+    "> Edit `.ai/config.yaml` instead \u2014 changes to this file will be overwritten on next `conflux sync`.",
+    "",
+    "---",
+    ""
+  ];
+  const alwaysRules = config.rules?.filter((r) => r.alwaysApply !== false) ?? [];
+  if (alwaysRules.length > 0) {
+    for (const rule of alwaysRules) {
+      lines.push(`<!-- BEGIN: ${rule.path} -->`);
+      lines.push(`<!-- Source: ${rule.path} -->`);
+      lines.push(`@${rule.path}`);
+      lines.push(`<!-- END: ${rule.path} -->`);
+      lines.push("");
+    }
+  }
+  if (config.references && config.references.length > 0) {
+    lines.push("## References");
+    lines.push("");
+    for (const ref of config.references) {
+      lines.push(`- [${ref.description ?? ref.path}](${ref.path})`);
+    }
+    lines.push("");
+  }
+  const content = lines.join("\n");
+  const hash = hashContent(content);
+  return {
+    path: config.primary,
+    content,
+    format: "markdown",
+    mode: "write",
+    hash
+  };
+}
+function generateToolInstructions(config, toolPrimaryFile) {
+  const content = `<!-- Generated by Conflux \u2014 edit .ai/config.yaml instead -->
+@${config.primary}
+`;
+  return {
+    path: toolPrimaryFile,
+    content,
+    format: "markdown",
+    mode: "write",
+    hash: hashContent(content)
+  };
+}
+
+// src/generators/mcp.ts
+function generateMcpClaudeCode(config) {
+  const servers = {};
+  for (const [name, server] of Object.entries(config.servers)) {
+    const entry = { command: server.command };
+    if (server.args && server.args.length > 0) {
+      entry.args = server.args;
+    }
+    if (server.env && Object.keys(server.env).length > 0) {
+      entry.env = server.env;
+    }
+    servers[name] = entry;
+  }
+  const mcpConfig = { mcpServers: servers };
+  const content = JSON.stringify(mcpConfig, null, 2) + "\n";
+  return {
+    path: ".claude/settings.json",
+    content,
+    format: "json",
+    mode: "merge",
+    hash: hashContent(content)
+  };
+}
+function generateMcpCodex(config) {
+  const lines = [
+    "# MCP Servers \u2014 Auto-generated by Conflux",
+    "# Edit .ai/config.yaml instead.",
+    ""
+  ];
+  if (config.env) {
+    for (const [key, value] of Object.entries(config.env)) {
+      lines.push(`[mcp_env]`);
+      lines.push(`${key} = "${value}"`);
+      lines.push("");
+      break;
+    }
+  }
+  for (const [name, server] of Object.entries(config.servers)) {
+    lines.push("[[mcp_servers]]");
+    lines.push(`name = "${name}"`);
+    lines.push(`command = "${server.command}"`);
+    if (server.args && server.args.length > 0) {
+      const argsStr = server.args.map((a) => `"${a}"`).join(", ");
+      lines.push(`args = [${argsStr}]`);
+    }
+    if (server.env && Object.keys(server.env).length > 0) {
+      for (const [key, value] of Object.entries(server.env)) {
+        lines.push(`[mcp_servers.env]`);
+        lines.push(`${key} = "${value}"`);
+      }
+    }
+    lines.push("");
+  }
+  const content = lines.join("\n");
+  return {
+    path: ".codex/config.toml",
+    content,
+    format: "toml",
+    mode: "merge",
+    hash: hashContent(content)
+  };
+}
+function generateMcpCursor(config) {
+  const servers = {};
+  for (const [name, server] of Object.entries(config.servers)) {
+    const entry = { command: server.command };
+    if (server.args && server.args.length > 0) {
+      entry.args = server.args;
+    }
+    if (server.env && Object.keys(server.env).length > 0) {
+      entry.env = server.env;
+    }
+    servers[name] = entry;
+  }
+  const mcpConfig = { mcpServers: servers };
+  const content = JSON.stringify(mcpConfig, null, 2) + "\n";
+  return {
+    path: ".cursor/mcp.json",
+    content,
+    format: "json",
+    mode: "write",
+    hash: hashContent(content)
+  };
+}
+
+// src/providers/claude-code/index.ts
+var ClaudeCodeProvider = class extends AIProvider {
+  id = "claude-code";
+  name = "Claude Code";
+  version = "1.0.0";
+  capabilities = [
+    "instructions" /* INSTRUCTIONS */,
+    "hooks" /* HOOKS */,
+    "mcp" /* MCP */,
+    "permissions" /* PERMISSIONS */,
+    "skills" /* SKILLS */
+  ];
+  detect(projectPath2) {
+    return pathExists(projectPath(projectPath2, ".claude")) || pathExists(projectPath(projectPath2, "CLAUDE.md"));
+  }
+  discoverExisting(projectPath2) {
+    const result = {
+      instructions: [],
+      hooks: null,
+      mcp: null,
+      permissions: null,
+      skills: []
+    };
+    const claudeMd = projectPath(projectPath2, "CLAUDE.md");
+    if (pathExists(claudeMd)) {
+      result.instructions.push(claudeMd);
+    }
+    const settingsPath = projectPath(projectPath2, ".claude", "settings.json");
+    if (pathExists(settingsPath)) {
+      try {
+        const raw = JSON.parse(readFileIfExists(settingsPath) ?? "{}");
+        if (raw.hooks) result.hooks = raw.hooks;
+        if (raw.mcpServers) result.mcp = raw.mcpServers;
+        if (raw.permissions) result.permissions = raw.permissions;
+      } catch {
+      }
+    }
+    const skillsDir = projectPath(projectPath2, ".claude", "skills");
+    if (pathExists(skillsDir)) {
+      result.skills.push(skillsDir);
+    }
+    return result;
+  }
+  async sync(projectPath2, config, options) {
+    const result = {
+      provider: this.id,
+      filesWritten: [],
+      filesRemoved: [],
+      errors: [],
+      warnings: []
+    };
+    const dryRun = options?.dryRun ?? false;
+    try {
+      if (config.instructions) {
+        const override = config.providers?.overrides?.["claude-code"];
+        const instructionsConfig = {
+          ...config.instructions,
+          ...override?.instructions
+        };
+        const files = this.generateInstructions(instructionsConfig);
+        for (const file of files) {
+          result.filesWritten.push(file);
+          if (!dryRun) {
+            writeFile(projectPath(projectPath2, file.path), file.content);
+          }
+        }
+      }
+      if (config.hooks) {
+        const files = this.generateHooks(config.hooks);
+        for (const file of files) {
+          result.filesWritten.push(file);
+        }
+      }
+      if (config.mcp) {
+        const files = this.generateMcp(config.mcp);
+        for (const file of files) {
+          result.filesWritten.push(file);
+        }
+      }
+      if (config.permissions) {
+        const files = this.generatePermissions(config.permissions);
+        for (const file of files) {
+          result.filesWritten.push(file);
+        }
+      }
+      this.writeSettingsJson(projectPath2, config, dryRun, result);
+    } catch (err) {
+      result.errors.push(`Sync failed: ${err.message}`);
+    }
+    return result;
+  }
+  async clean(projectPath2) {
+    const removed = [];
+    const files = [
+      "CLAUDE.md",
+      ".claude/settings.json"
+    ];
+    for (const f of files) {
+      const fullPath = projectPath(projectPath2, f);
+      if (pathExists(fullPath)) {
+        removed.push(f);
+      }
+    }
+    return removed;
+  }
+  async checkDrift(projectPath2, _config, state) {
+    const providerState = state.providers[this.id];
+    const report = {
+      provider: this.id,
+      inSync: true,
+      lastSyncTime: providerState?.lastSync ? new Date(providerState.lastSync) : null,
+      modifiedFiles: [],
+      missingFiles: [],
+      extraFiles: []
+    };
+    if (!providerState?.synced) {
+      report.inSync = false;
+      return report;
+    }
+    for (const [filePath, fileState] of Object.entries(providerState.files)) {
+      const fullPath = projectPath(projectPath2, filePath);
+      const content = readFileIfExists(fullPath);
+      if (content === null) {
+        report.missingFiles.push(filePath);
+        report.inSync = false;
+      } else {
+        const actualHash = hashContent(content);
+        if (actualHash !== fileState.hash) {
+          report.modifiedFiles.push({
+            path: filePath,
+            expectedHash: fileState.hash,
+            actualHash
+          });
+          report.inSync = false;
+        }
+      }
+    }
+    return report;
+  }
+  // ─── Dimension Generators ──────────────────────────────────────
+  generateInstructions(config) {
+    const files = [];
+    files.push(generateToolInstructions(config, "CLAUDE.md"));
+    return files;
+  }
+  generateHooks(config) {
+    const hooksJson = {};
+    for (const [event, entries] of Object.entries(config)) {
+      hooksJson[event] = entries.map((entry) => ({
+        matcher: entry.matcher ?? "",
+        hooks: [
+          {
+            type: "command",
+            command: entry.command,
+            timeout: entry.timeout ?? 30
+          }
+        ]
+      }));
+    }
+    const content = JSON.stringify({ hooks: hooksJson }, null, 2) + "\n";
+    return [
+      {
+        path: ".claude/settings.json",
+        content,
+        format: "json",
+        mode: "merge",
+        hash: hashContent(content)
+      }
+    ];
+  }
+  generateMcp(config) {
+    return [generateMcpClaudeCode(config)];
+  }
+  generatePermissions(config) {
+    const permConfig = {
+      permissions: {
+        default: config.default
+      }
+    };
+    if (config.allow) {
+      permConfig.permissions.allow = config.allow;
+    }
+    if (config.deny) {
+      permConfig.permissions.deny = config.deny;
+    }
+    const content = JSON.stringify(permConfig, null, 2) + "\n";
+    return [
+      {
+        path: ".claude/settings.json",
+        content,
+        format: "json",
+        mode: "merge",
+        hash: hashContent(content)
+      }
+    ];
+  }
+  generateSkills(config, _projectPath) {
+    const files = [];
+    if (config.local) {
+      for (const skill of config.local) {
+        files.push({
+          path: `.claude/skills/${skill.name}`,
+          content: `../.agents/skills/${skill.name}`,
+          format: "text",
+          mode: "symlink",
+          hash: ""
+        });
+      }
+    }
+    return files;
+  }
+  // ─── Helpers ───────────────────────────────────────────────────
+  writeSettingsJson(projectPath2, config, dryRun, result) {
+    const settingsPath = projectPath(projectPath2, ".claude", "settings.json");
+    let existing = {};
+    if (pathExists(settingsPath)) {
+      try {
+        existing = JSON.parse(readFileIfExists(settingsPath) ?? "{}");
+      } catch {
+      }
+    }
+    if (config.hooks) {
+      const hooksSection = {};
+      for (const [event, entries] of Object.entries(config.hooks)) {
+        hooksSection[event] = entries.map((entry) => ({
+          matcher: entry.matcher ?? "",
+          hooks: [
+            {
+              type: "command",
+              command: entry.command,
+              timeout: entry.timeout ?? 30
+            }
+          ]
+        }));
+      }
+      existing.hooks = hooksSection;
+    }
+    if (config.mcp) {
+      const servers = {};
+      for (const [name, server] of Object.entries(config.mcp.servers)) {
+        const entry = { command: server.command };
+        if (server.args?.length) entry.args = server.args;
+        if (server.env && Object.keys(server.env).length > 0) entry.env = server.env;
+        servers[name] = entry;
+      }
+      existing.mcpServers = servers;
+    }
+    if (config.permissions) {
+      const perm = {
+        default: config.permissions.default
+      };
+      if (config.permissions.allow) perm.allow = config.permissions.allow;
+      if (config.permissions.deny) perm.deny = config.permissions.deny;
+      existing.permissions = perm;
+    }
+    const content = JSON.stringify(existing, null, 2) + "\n";
+    const file = {
+      path: ".claude/settings.json",
+      content,
+      format: "json",
+      mode: "write",
+      hash: hashContent(content)
+    };
+    result.filesWritten.push(file);
+    if (!dryRun) {
+      writeFile(settingsPath, content);
+    }
+  }
+};
+
+// src/providers/codex/index.ts
+var CodexProvider = class extends AIProvider {
+  id = "codex";
+  name = "Codex CLI";
+  version = "1.0.0";
+  capabilities = [
+    "instructions" /* INSTRUCTIONS */,
+    "hooks" /* HOOKS */,
+    "mcp" /* MCP */,
+    "permissions" /* PERMISSIONS */,
+    "skills" /* SKILLS */
+  ];
+  detect(projectPath2) {
+    return pathExists(projectPath(projectPath2, ".codex")) || pathExists(projectPath(projectPath2, "AGENTS.md"));
+  }
+  discoverExisting(projectPath2) {
+    const result = {
+      instructions: [],
+      hooks: null,
+      mcp: null,
+      permissions: null,
+      skills: []
+    };
+    const agentsMd = projectPath(projectPath2, "AGENTS.md");
+    if (pathExists(agentsMd)) {
+      result.instructions.push(agentsMd);
+    }
+    const hooksPath = projectPath(projectPath2, ".codex", "hooks.json");
+    if (pathExists(hooksPath)) {
+      try {
+        result.hooks = JSON.parse(readFileIfExists(hooksPath) ?? "{}");
+      } catch {
+      }
+    }
+    const configPath = projectPath(projectPath2, ".codex", "config.toml");
+    if (pathExists(configPath)) {
+      const raw = readFileIfExists(configPath);
+      if (raw?.includes("[[mcp_servers]]")) {
+        result.mcp = { _fromToml: true };
+      }
+    }
+    return result;
+  }
+  async sync(projectPath2, config, options) {
+    const result = {
+      provider: this.id,
+      filesWritten: [],
+      filesRemoved: [],
+      errors: [],
+      warnings: []
+    };
+    const dryRun = options?.dryRun ?? false;
+    try {
+      if (config.instructions) {
+        const files = this.generateInstructions(config.instructions);
+        for (const file of files) {
+          result.filesWritten.push(file);
+          if (!dryRun) {
+            writeFile(projectPath(projectPath2, file.path), file.content);
+          }
+        }
+      }
+      if (config.hooks) {
+        const files = this.generateHooks(config.hooks);
+        for (const file of files) {
+          result.filesWritten.push(file);
+          if (!dryRun) {
+            writeFile(projectPath(projectPath2, file.path), file.content);
+          }
+        }
+      }
+      if (config.mcp) {
+        const mcpFile = generateMcpCodex(config.mcp);
+        result.filesWritten.push(mcpFile);
+        if (!dryRun) {
+          writeFile(projectPath(projectPath2, mcpFile.path), mcpFile.content);
+        }
+      }
+    } catch (err) {
+      result.errors.push(`Sync failed: ${err.message}`);
+    }
+    return result;
+  }
+  async clean(projectPath2) {
+    const removed = [];
+    const files = [
+      "AGENTS.md",
+      ".codex/hooks.json",
+      ".codex/config.toml"
+    ];
+    for (const f of files) {
+      if (pathExists(projectPath(projectPath2, f))) {
+        removed.push(f);
+      }
+    }
+    return removed;
+  }
+  async checkDrift(projectPath2, _config, state) {
+    const providerState = state.providers[this.id];
+    const report = {
+      provider: this.id,
+      inSync: true,
+      lastSyncTime: providerState?.lastSync ? new Date(providerState.lastSync) : null,
+      modifiedFiles: [],
+      missingFiles: [],
+      extraFiles: []
+    };
+    if (!providerState?.synced) {
+      report.inSync = false;
+      return report;
+    }
+    for (const [filePath, fileState] of Object.entries(providerState.files)) {
+      const fullPath = projectPath(projectPath2, filePath);
+      const content = readFileIfExists(fullPath);
+      if (content === null) {
+        report.missingFiles.push(filePath);
+        report.inSync = false;
+      } else if (hashContent(content) !== fileState.hash) {
+        report.modifiedFiles.push({
+          path: filePath,
+          expectedHash: fileState.hash,
+          actualHash: hashContent(content)
+        });
+        report.inSync = false;
+      }
+    }
+    return report;
+  }
+  // ─── Dimension Generators ──────────────────────────────────────
+  generateInstructions(config) {
+    return [generatePrimaryInstructions(config)];
+  }
+  generateHooks(config) {
+    const hooksData = { hooks: {} };
+    for (const [event, entries] of Object.entries(config)) {
+      hooksData.hooks[event] = entries.map((entry) => ({
+        matcher: entry.matcher ?? "",
+        hooks: [
+          {
+            type: "command",
+            command: entry.command,
+            timeout: entry.timeout ?? 30
+          }
+        ]
+      }));
+    }
+    const content = JSON.stringify(hooksData, null, 2) + "\n";
+    return [
+      {
+        path: ".codex/hooks.json",
+        content,
+        format: "json",
+        mode: "write",
+        hash: hashContent(content)
+      }
+    ];
+  }
+  generateMcp(config) {
+    return [generateMcpCodex(config)];
+  }
+  generatePermissions(config) {
+    const lines = [
+      "# Permissions \u2014 Auto-generated by Conflux",
+      "[permissions]",
+      `default = "${config.default}"`
+    ];
+    if (config.allow) {
+      lines.push("allow = [");
+      for (const rule of config.allow) {
+        lines.push(`  "${rule}",`);
+      }
+      lines.push("]");
+    }
+    if (config.deny) {
+      lines.push("deny = [");
+      for (const rule of config.deny) {
+        lines.push(`  "${rule}",`);
+      }
+      lines.push("]");
+    }
+    const content = lines.join("\n") + "\n";
+    return [
+      {
+        path: ".codex/config.toml",
+        content,
+        format: "toml",
+        mode: "merge",
+        hash: hashContent(content)
+      }
+    ];
+  }
+  generateSkills(config, _projectPath) {
+    return (config.local ?? []).map((skill) => ({
+      path: `.codex/skills/${skill.name}`,
+      content: `../.agents/skills/${skill.name}`,
+      format: "text",
+      mode: "symlink",
+      hash: ""
+    }));
+  }
+};
+
+// src/providers/cursor/index.ts
+var CursorProvider = class extends AIProvider {
+  id = "cursor";
+  name = "Cursor";
+  version = "1.0.0";
+  capabilities = [
+    "instructions" /* INSTRUCTIONS */,
+    "mcp" /* MCP */,
+    "skills" /* SKILLS */
+    // Cursor does NOT support hooks or permissions natively
+  ];
+  detect(projectPath2) {
+    return pathExists(projectPath(projectPath2, ".cursor")) || pathExists(projectPath(projectPath2, ".cursorrules"));
+  }
+  discoverExisting(projectPath2) {
+    const result = {
+      instructions: [],
+      hooks: null,
+      mcp: null,
+      permissions: null,
+      skills: []
+    };
+    const legacyRules = projectPath(projectPath2, ".cursorrules");
+    if (pathExists(legacyRules)) {
+      result.instructions.push(legacyRules);
+    }
+    const rulesDir = projectPath(projectPath2, ".cursor", "rules");
+    if (pathExists(rulesDir)) {
+      result.instructions.push(rulesDir);
+    }
+    const mcpPath = projectPath(projectPath2, ".cursor", "mcp.json");
+    if (pathExists(mcpPath)) {
+      try {
+        result.mcp = JSON.parse(readFileIfExists(mcpPath) ?? "{}");
+      } catch {
+      }
+    }
+    return result;
+  }
+  async sync(projectPath2, config, options) {
+    const result = {
+      provider: this.id,
+      filesWritten: [],
+      filesRemoved: [],
+      errors: [],
+      warnings: []
+    };
+    const dryRun = options?.dryRun ?? false;
+    try {
+      if (config.instructions) {
+        const override = config.providers?.overrides?.cursor;
+        const instructionsConfig = {
+          ...config.instructions,
+          ...override?.instructions
+        };
+        const files = this.generateInstructions(instructionsConfig);
+        for (const file of files) {
+          result.filesWritten.push(file);
+          if (!dryRun) {
+            writeFile(projectPath(projectPath2, file.path), file.content);
+          }
+        }
+      }
+      if (config.mcp) {
+        const files = this.generateMcp(config.mcp);
+        for (const file of files) {
+          result.filesWritten.push(file);
+          if (!dryRun) {
+            writeFile(projectPath(projectPath2, file.path), file.content);
+          }
+        }
+      }
+      if (config.hooks) {
+        result.warnings.push("Cursor does not natively support lifecycle hooks \u2014 hooks skipped");
+      }
+      if (config.permissions) {
+        result.warnings.push("Cursor has limited permission support (settings UI only) \u2014 permissions skipped");
+      }
+    } catch (err) {
+      result.errors.push(`Sync failed: ${err.message}`);
+    }
+    return result;
+  }
+  async clean(projectPath2) {
+    const removed = [];
+    const files = [
+      ".cursor/mcp.json"
+    ];
+    for (const f of files) {
+      if (pathExists(projectPath(projectPath2, f))) {
+        removed.push(f);
+      }
+    }
+    return removed;
+  }
+  async checkDrift(projectPath2, _config, state) {
+    const providerState = state.providers[this.id];
+    const report = {
+      provider: this.id,
+      inSync: true,
+      lastSyncTime: providerState?.lastSync ? new Date(providerState.lastSync) : null,
+      modifiedFiles: [],
+      missingFiles: [],
+      extraFiles: []
+    };
+    if (!providerState?.synced) {
+      report.inSync = false;
+      return report;
+    }
+    for (const [filePath, fileState] of Object.entries(providerState.files)) {
+      const fullPath = projectPath(projectPath2, filePath);
+      const content = readFileIfExists(fullPath);
+      if (content === null) {
+        report.missingFiles.push(filePath);
+        report.inSync = false;
+      } else if (hashContent(content) !== fileState.hash) {
+        report.modifiedFiles.push({
+          path: filePath,
+          expectedHash: fileState.hash,
+          actualHash: hashContent(content)
+        });
+        report.inSync = false;
+      }
+    }
+    return report;
+  }
+  // ─── Dimension Generators ──────────────────────────────────────
+  generateInstructions(config) {
+    const files = [];
+    files.push(generatePrimaryInstructions(config));
+    if (config.rules) {
+      for (const rule of config.rules) {
+        const mdcContent = [
+          "---",
+          `description: "${rule.description ?? rule.path}"`,
+          ...rule.globs ? [`globs: [${rule.globs.join(", ")}]`] : [],
+          `alwaysApply: ${rule.alwaysApply ?? true}`,
+          "---",
+          "",
+          `@${rule.path}`
+        ].join("\n");
+        const fileName = rule.path.replace(/^rules\//, "").replace(/\.md$/, ".mdc");
+        files.push({
+          path: `.cursor/rules/${fileName}`,
+          content: mdcContent,
+          format: "markdown",
+          mode: "write",
+          hash: hashContent(mdcContent)
+        });
+      }
+    }
+    return files;
+  }
+  generateHooks(_config) {
+    return [];
+  }
+  generateMcp(config) {
+    return [generateMcpCursor(config)];
+  }
+  generatePermissions(_config) {
+    return [];
+  }
+  generateSkills(config, _projectPath) {
+    return (config.local ?? []).map((skill) => ({
+      path: `.cursor/skills/${skill.name}`,
+      content: `../.agents/skills/${skill.name}`,
+      format: "text",
+      mode: "symlink",
+      hash: ""
+    }));
+  }
+};
+
+// src/providers/index.ts
+function registerAllProviders() {
+  const providers = [
+    new ClaudeCodeProvider(),
+    new CodexProvider(),
+    new CursorProvider()
+  ];
+  for (const provider of providers) {
+    if (!registry.get(provider.id)) {
+      registry.register(provider);
+    }
+  }
+}
+
+// src/cli/commands/init.ts
+import { join as join3 } from "path";
+
+// src/detectors/index.ts
+import { existsSync as existsSync2 } from "fs";
+import { join as join2 } from "path";
+
+// src/detectors/patterns.ts
+var DETECTOR_PATTERNS = [
+  {
+    providerId: "claude-code",
+    markers: [".claude", "CLAUDE.md", ".claude/settings.json"],
+    configPatterns: [
+      ".claude/**/*.json",
+      ".claude/**/*.md",
+      "CLAUDE.md"
+    ]
+  },
+  {
+    providerId: "codex",
+    markers: [".codex", "AGENTS.md", ".codex/config.toml"],
+    configPatterns: [
+      ".codex/**/*.toml",
+      ".codex/**/*.json",
+      ".codex/**/*.md",
+      "AGENTS.md"
+    ]
+  },
+  {
+    providerId: "cursor",
+    markers: [".cursor", ".cursorrules", ".cursor/rules"],
+    configPatterns: [
+      ".cursor/**/*.mdc",
+      ".cursor/**/*.json",
+      ".cursorrules"
+    ]
+  },
+  {
+    providerId: "windsurf",
+    markers: [".windsurf", ".windsurfrules", ".windsurf/rules"],
+    configPatterns: [
+      ".windsurf/**/*",
+      ".windsurfrules"
+    ]
+  },
+  {
+    providerId: "copilot",
+    markers: [
+      ".github/copilot-instructions.md",
+      ".github/instructions"
+    ],
+    configPatterns: [
+      ".github/copilot-instructions.md",
+      ".github/instructions/**/*.md"
+    ]
+  },
+  {
+    providerId: "gemini-cli",
+    markers: [".gemini", "GEMINI.md"],
+    configPatterns: [
+      ".gemini/**/*.json",
+      ".gemini/**/*.toml",
+      "GEMINI.md"
+    ]
+  },
+  {
+    providerId: "aider",
+    markers: [".aider.conf.yml", ".aider", "CONVENTIONS.md"],
+    configPatterns: [
+      ".aider.conf.yml",
+      ".aider/**/*.json",
+      "CONVENTIONS.md"
+    ]
+  }
+];
+
+// src/detectors/index.ts
+function detectTools(projectPath2) {
+  return DETECTOR_PATTERNS.filter(
+    (pattern) => pattern.markers.some((marker) => existsSync2(join2(projectPath2, marker)))
+  );
+}
+function detectToolIds(projectPath2) {
+  return detectTools(projectPath2).map((p) => p.providerId);
+}
+
+// src/utils/logger.ts
+import chalk from "chalk";
+var currentLevel = 1 /* INFO */;
+var logger = {
+  debug(msg) {
+    if (currentLevel <= 0 /* DEBUG */) {
+      console.error(chalk.gray(`  [debug] ${msg}`));
+    }
+  },
+  info(msg) {
+    if (currentLevel <= 1 /* INFO */) {
+      console.log(chalk.blue("\u2139"), msg);
+    }
+  },
+  success(msg) {
+    if (currentLevel <= 1 /* INFO */) {
+      console.log(chalk.green("\u2713"), msg);
+    }
+  },
+  warn(msg) {
+    if (currentLevel <= 2 /* WARN */) {
+      console.warn(chalk.yellow("\u26A0"), msg);
+    }
+  },
+  error(msg) {
+    if (currentLevel <= 3 /* ERROR */) {
+      console.error(chalk.red("\u2717"), msg);
+    }
+  },
+  heading(msg) {
+    if (currentLevel <= 1 /* INFO */) {
+      console.log();
+      console.log(chalk.bold.cyan("\u25CF"), chalk.bold(msg));
+    }
+  },
+  table(rows) {
+    if (currentLevel > 1 /* INFO */) return;
+    if (rows.length === 0) return;
+    const keys = Object.keys(rows[0]);
+    const colWidths = keys.map(
+      (key) => Math.max(key.length, ...rows.map((r) => (r[key] ?? "").length))
+    );
+    const header = keys.map((k, i) => chalk.bold(k.padEnd(colWidths[i]))).join("  ");
+    console.log("  " + header);
+    const sep = colWidths.map((w) => "\u2500".repeat(w)).join("  ");
+    console.log("  " + chalk.gray(sep));
+    for (const row of rows) {
+      const line = keys.map((k, i) => (row[k] ?? "").padEnd(colWidths[i])).join("  ");
+      console.log("  " + line);
+    }
+  }
+};
+
+// src/cli/commands/init.ts
+function registerInitCommand(program2) {
+  program2.command("init").description(
+    "Initialize .ai/config.yaml \u2014 scan existing configs and import them"
+  ).option("--template <name>", "Template: minimal, full, monorepo").option("--force", "Overwrite existing .ai/config.yaml").action(async (options, command) => {
+    const globalOpts = command.parent?.opts() ?? {};
+    const projectPath2 = globalOpts.project ?? process.cwd();
+    const dryRun = globalOpts.dryRun ?? false;
+    const force = options.force ?? false;
+    const configDir = join3(projectPath2, ".ai");
+    const configPath = join3(configDir, "config.yaml");
+    if (pathExists(configPath) && !force) {
+      logger.error(".ai/config.yaml already exists.");
+      logger.info("Use --force to overwrite, or edit it directly.");
+      process.exit(1);
+    }
+    logger.heading("Conflux Init");
+    logger.info(`Project: ${projectPath2}`);
+    const detectedPatterns = detectTools(projectPath2);
+    const detectedIds = detectedPatterns.map((p) => p.providerId);
+    if (detectedIds.length > 0) {
+      logger.success(`Detected ${detectedIds.length} AI tool(s): ${detectedIds.join(", ")}`);
+    } else {
+      logger.info("No AI tools detected. A minimal config will be generated.");
+    }
+    const discovered = {};
+    for (const id of detectedIds) {
+      const provider = registry.get(id);
+      if (provider) {
+        try {
+          discovered[id] = provider.discoverExisting(projectPath2);
+        } catch {
+        }
+      }
+    }
+    const config = buildConfigFromDiscovered(detectedIds, discovered, options.template);
+    if (dryRun) {
+      logger.info("[DRY RUN] Would create .ai/config.yaml:");
+      console.log("---");
+      console.log(toYamlString(config));
+      console.log("---");
+    } else {
+      writeFile(configPath, toYamlString(config));
+      logger.success("Created .ai/config.yaml");
+    }
+    console.log();
+    logger.heading("Next steps:");
+    logger.info("1. Review .ai/config.yaml and adjust as needed");
+    logger.info("2. Run 'conflux sync' to generate tool-specific configs");
+    logger.info("3. Run 'conflux status' to check sync health");
+  });
+}
+function buildConfigFromDiscovered(detectedIds, discovered, _template) {
+  const config = {
+    version: 1
+  };
+  const allInstructions = /* @__PURE__ */ new Set();
+  for (const [, d] of Object.entries(discovered)) {
+    for (const path of d.instructions) {
+      allInstructions.add(path);
+    }
+  }
+  if (allInstructions.size > 0) {
+    config.instructions = {
+      primary: "AGENTS.md",
+      references: Array.from(allInstructions).map((path) => ({
+        path,
+        description: `Existing instruction file (auto-discovered)`
+      }))
+    };
+  } else {
+    config.instructions = {
+      primary: "AGENTS.md"
+    };
+  }
+  const allMcpServers = {};
+  for (const [providerId, d] of Object.entries(discovered)) {
+    if (d.mcp && typeof d.mcp === "object") {
+      const servers = d.mcp.mcpServers ?? d.mcp;
+      if (typeof servers === "object") {
+        for (const [name, server] of Object.entries(servers)) {
+          if (typeof server === "object" && server !== null && !allMcpServers[name]) {
+            const s = server;
+            allMcpServers[name] = {
+              command: String(s.command ?? ""),
+              ...s.args ? { args: s.args } : {},
+              ...s.env ? { env: s.env } : {}
+            };
+          }
+        }
+      }
+    }
+  }
+  if (Object.keys(allMcpServers).length > 0) {
+    config.mcp = { servers: allMcpServers };
+  }
+  config.providers = {
+    enabled: detectedIds
+  };
+  config.meta = {
+    created: (/* @__PURE__ */ new Date()).toISOString().split("T")[0],
+    description: "Auto-generated by conflux init"
+  };
+  return config;
+}
+function toYamlString(config) {
+  const lines = [
+    "# .ai/config.yaml \u2014 Unified AI Coding Tool Configuration",
+    "# Generated by Conflux (https://github.com/conflux-ai/conflux)",
+    "# Edit this file as the single source of truth for all AI tool configs.",
+    "",
+    `version: ${config.version}`,
+    ""
+  ];
+  if (config.instructions) {
+    lines.push("# \u2500\u2500\u2500 Project Instructions \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+    lines.push("instructions:");
+    lines.push(`  primary: ${config.instructions.primary}`);
+    if (config.instructions.references?.length) {
+      lines.push("  references:");
+      for (const ref of config.instructions.references) {
+        lines.push(`    - path: ${ref.path}`);
+        if (ref.description) {
+          lines.push(`      description: "${ref.description}"`);
+        }
+      }
+    }
+    lines.push("");
+  }
+  if (config.mcp && Object.keys(config.mcp.servers).length > 0) {
+    lines.push("# \u2500\u2500\u2500 MCP Servers \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+    lines.push("mcp:");
+    lines.push("  servers:");
+    for (const [name, server] of Object.entries(config.mcp.servers)) {
+      lines.push(`    ${name}:`);
+      lines.push(`      command: ${server.command}`);
+      if (server.args?.length) {
+        lines.push(`      args: [${server.args.map((a) => `"${a}"`).join(", ")}]`);
+      }
+    }
+    lines.push("");
+  }
+  if (config.providers?.enabled?.length) {
+    lines.push("# \u2500\u2500\u2500 Providers \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+    lines.push("providers:");
+    lines.push("  enabled:");
+    for (const id of config.providers.enabled) {
+      lines.push(`    - ${id}`);
+    }
+    lines.push("");
+  }
+  if (config.meta) {
+    lines.push("# \u2500\u2500\u2500 Metadata \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+    lines.push("meta:");
+    if (config.meta.description) {
+      lines.push(`  description: "${config.meta.description}"`);
+    }
+    lines.push(`  created: "${config.meta.created ?? "unknown"}"`);
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+
+// src/cli/commands/sync.ts
+import { join as join5 } from "path";
+
+// src/core/config.ts
+import { readFileSync as readFileSync2, existsSync as existsSync3 } from "fs";
+import { join as join4 } from "path";
+import yaml from "js-yaml";
+
+// src/core/schema.ts
+import { z } from "zod";
+var InstructionRuleSchema = z.object({
+  path: z.string().describe("Path to the rule file (markdown)"),
+  description: z.string().optional().describe("What this rule covers"),
+  globs: z.array(z.string()).optional().describe("File globs this rule applies to"),
+  alwaysApply: z.boolean().optional().default(true).describe("Always apply regardless of glob")
+});
+var InstructionReferenceSchema = z.object({
+  path: z.string().describe("Path to the reference document"),
+  description: z.string().optional().describe("What this document covers")
+});
+var InstructionsConfigSchema = z.object({
+  primary: z.string().default("AGENTS.md").describe("Primary instruction file name"),
+  references: z.array(InstructionReferenceSchema).optional().describe("Reference documents to include"),
+  rules: z.array(InstructionRuleSchema).optional().describe("Granular rule files")
+});
+var HookEntrySchema = z.object({
+  command: z.string().describe("Command to execute"),
+  timeout: z.number().int().positive().optional().describe("Timeout in seconds"),
+  description: z.string().optional().describe("What this hook does"),
+  matcher: z.string().optional().describe("Regex matcher (e.g., tool name pattern)")
+});
+var HooksConfigSchema = z.record(
+  z.string(),
+  z.array(HookEntrySchema)
+).describe("Lifecycle event hooks keyed by event name");
+var McpServerSchema = z.object({
+  command: z.string().describe("Command to run the MCP server"),
+  args: z.array(z.string()).optional().describe("Command arguments"),
+  env: z.record(z.string(), z.string()).optional().describe("Environment variables")
+});
+var McpConfigSchema = z.object({
+  env: z.record(z.string(), z.string()).optional().describe("Global env vars for all MCP servers"),
+  servers: z.record(z.string(), McpServerSchema).describe("MCP server configurations")
+});
+var PermissionsConfigSchema = z.object({
+  default: z.enum(["prompt", "allow", "deny"]).default("prompt").describe("Default permission mode"),
+  allow: z.array(z.string()).optional().describe("Globally allowed operations"),
+  deny: z.array(z.string()).optional().describe("Globally denied operations")
+});
+var LocalSkillSchema = z.object({
+  name: z.string().describe("Skill name (invoked by this name)"),
+  path: z.string().describe("Path to SKILL.md file"),
+  description: z.string().optional().describe("What this skill does"),
+  tags: z.array(z.string()).optional().describe("Tags for categorization")
+});
+var ExternalSkillSchema = z.object({
+  name: z.string().describe("Skill name"),
+  source: z.string().describe("Source repo or package (e.g., 'org/repo')"),
+  sourceType: z.enum(["github", "npm", "url"]).describe("Type of source"),
+  skillPath: z.string().describe("Path to the skill within the source"),
+  description: z.string().optional()
+});
+var SkillsConfigSchema = z.object({
+  local: z.array(LocalSkillSchema).optional().describe("Locally defined skills"),
+  external: z.array(ExternalSkillSchema).optional().describe("Skills from external sources")
+});
+var ProviderOverrideSchema = z.object({
+  instructions: InstructionsConfigSchema.partial().optional(),
+  hooks: HooksConfigSchema.optional(),
+  mcp: McpConfigSchema.partial().optional(),
+  permissions: PermissionsConfigSchema.partial().optional(),
+  skills: SkillsConfigSchema.partial().optional()
+});
+var ProvidersConfigSchema = z.object({
+  enabled: z.array(z.string()).optional().describe("Providers to enable (omitted = auto-detect)"),
+  overrides: z.record(z.string(), ProviderOverrideSchema).optional().describe("Per-provider overrides")
+});
+var ConfluxMetaSchema = z.object({
+  created: z.string().optional().describe("Creation date"),
+  schema: z.string().optional().describe("Schema URL for validation"),
+  description: z.string().optional().describe("Project description")
+});
+var UnifiedConfigSchema = z.object({
+  version: z.literal(1).describe("Config schema version (must be 1)"),
+  instructions: InstructionsConfigSchema.optional().describe("Project instructions for AI agents"),
+  hooks: HooksConfigSchema.optional().describe("Lifecycle event hooks"),
+  mcp: McpConfigSchema.optional().describe("MCP server configurations"),
+  permissions: PermissionsConfigSchema.optional().describe("Permission rules"),
+  skills: SkillsConfigSchema.optional().describe("Reusable skill/command definitions"),
+  providers: ProvidersConfigSchema.optional().describe("Provider enablement and overrides"),
+  meta: ConfluxMetaSchema.optional().describe("Metadata")
+});
+
+// src/core/config.ts
+import { ZodError } from "zod";
+function loadConfig(projectPath2) {
+  const configPath = join4(projectPath2, ".ai", "config.yaml");
+  if (!existsSync3(configPath)) {
+    throw new ConfigNotFoundError(
+      `No .ai/config.yaml found in ${projectPath2}. Run "conflux init" to create one.`
+    );
+  }
+  let raw;
+  try {
+    const content = readFileSync2(configPath, "utf-8");
+    raw = yaml.load(content);
+  } catch (err) {
+    if (err instanceof ConfigNotFoundError) throw err;
+    throw new ConfigParseError(
+      `Failed to parse ${configPath}: ${err.message}`
+    );
+  }
+  return validateConfig(raw, configPath);
+}
+function validateConfig(raw, source) {
+  try {
+    return UnifiedConfigSchema.parse(raw);
+  } catch (err) {
+    if (err instanceof ZodError) {
+      const issues = err.issues.map((i) => `  - ${i.path.join(".") || "(root)"}: ${i.message}`).join("\n");
+      const label = source ? ` in ${source}` : "";
+      throw new ConfigValidationError(`Schema validation failed${label}:
+${issues}`);
+    }
+    throw err;
+  }
+}
+function configExists(projectPath2) {
+  return existsSync3(join4(projectPath2, ".ai", "config.yaml"));
+}
+var ConfigNotFoundError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ConfigNotFoundError";
+  }
+};
+var ConfigParseError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ConfigParseError";
+  }
+};
+var ConfigValidationError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ConfigValidationError";
+  }
+};
+
+// src/cli/commands/sync.ts
+var STATE_PATH = ".ai/.conflux-state.json";
+function registerSyncCommand(program2) {
+  program2.command("sync").description("Sync .ai/config.yaml to all detected AI tools").option("--providers <list>", "Comma-separated list of providers to target").option("--no-detect", "Skip auto-detection, use --providers explicitly").option("--check", "Check if configs are in sync (for CI); exit 1 if stale").action(async (options, command) => {
+    const globalOpts = command.parent?.opts() ?? {};
+    const projectPath2 = globalOpts.project ?? process.cwd();
+    const dryRun = globalOpts.dryRun ?? false;
+    const verbose = globalOpts.verbose ?? false;
+    if (verbose) {
+      logger.info(`Project: ${projectPath2}`);
+      logger.info(`Dry run: ${dryRun}`);
+    }
+    if (options.check) {
+      const ok = await checkSync(projectPath2);
+      if (!ok) {
+        logger.error("Configuration is out of sync. Run 'conflux sync' to fix.");
+        process.exit(1);
+      }
+      logger.success("All AI tool configs are in sync.");
+      process.exit(0);
+    }
+    try {
+      const config = loadConfig(projectPath2);
+      if (verbose) {
+        logger.info("Config loaded and validated successfully");
+      }
+      const enableList = options.providers ? options.providers.split(",").map((s) => s.trim()) : void 0;
+      let providerIds;
+      if (enableList) {
+        providerIds = enableList;
+      } else if (options.detect !== false) {
+        providerIds = detectToolIds(projectPath2);
+      } else {
+        providerIds = registry.list().map((p) => p.id);
+      }
+      if (config.providers?.enabled) {
+        providerIds = providerIds.filter(
+          (id) => config.providers.enabled.includes(id)
+        );
+      }
+      if (providerIds.length === 0) {
+        logger.warn("No AI tools detected in this project.");
+        logger.info(
+          "Run 'conflux providers --detect' to see what's available, or use --providers to specify tools explicitly."
+        );
+        return;
+      }
+      logger.heading(`Syncing to ${providerIds.length} tool(s)`);
+      const syncOpts = {
+        dryRun,
+        verbose,
+        force: false
+      };
+      const results = [];
+      const stateData = {
+        version: 1,
+        lastSync: (/* @__PURE__ */ new Date()).toISOString(),
+        configHash: hashContent(JSON.stringify(config)),
+        providers: {}
+      };
+      for (const providerId of providerIds) {
+        const provider = registry.get(providerId);
+        if (!provider) {
+          logger.warn(`Unknown provider: ${providerId} \u2014 skipping`);
+          continue;
+        }
+        logger.info(`Syncing ${provider.name}...`);
+        try {
+          const result = await provider.sync(projectPath2, config, syncOpts);
+          stateData.providers[providerId] = {
+            synced: result.errors.length === 0,
+            lastSync: (/* @__PURE__ */ new Date()).toISOString(),
+            files: {}
+          };
+          for (const file of result.filesWritten) {
+            stateData.providers[providerId].files[file.path] = {
+              hash: file.hash ?? hashContent(file.content),
+              generatedFrom: file.path,
+              type: file.mode === "symlink" ? "symlink" : "file"
+            };
+          }
+          results.push(result);
+          for (const file of result.filesWritten) {
+            const prefix = dryRun ? "  [DRY RUN]" : "  \u2192";
+            logger.success(`${prefix} ${file.path}`);
+          }
+          for (const warning of result.warnings) {
+            logger.warn(warning);
+          }
+          for (const error of result.errors) {
+            logger.error(error);
+          }
+        } catch (err) {
+          logger.error(`${provider.name}: ${err.message}`);
+        }
+      }
+      if (!dryRun) {
+        const statePath = join5(projectPath2, STATE_PATH);
+        writeFile(statePath, JSON.stringify(stateData, null, 2) + "\n");
+        logger.success(`State written to ${STATE_PATH}`);
+      }
+      const totalFiles = results.reduce((sum, r) => sum + r.filesWritten.length, 0);
+      const totalErrors = results.reduce((sum, r) => sum + r.errors.length, 0);
+      const totalWarnings = results.reduce((sum, r) => sum + r.warnings.length, 0);
+      console.log();
+      if (dryRun) {
+        logger.heading(
+          `[DRY RUN] Would write ${totalFiles} file(s) across ${results.length} tool(s)`
+        );
+      } else {
+        logger.heading(
+          `Synced ${totalFiles} file(s) across ${results.length} tool(s)`
+        );
+      }
+      if (totalWarnings > 0) {
+        logger.warn(`${totalWarnings} warning(s)`);
+      }
+      if (totalErrors > 0) {
+        logger.error(`${totalErrors} error(s)`);
+      }
+    } catch (err) {
+      logger.error(`Failed to load config: ${err.message}`);
+      logger.info("Run 'conflux init' to create a .ai/config.yaml file.");
+      process.exit(1);
+    }
+  });
+}
+async function checkSync(projectPath2) {
+  if (!configExists(projectPath2)) {
+    logger.error("No .ai/config.yaml found. Run 'conflux init' first.");
+    return false;
+  }
+  const statePath = join5(projectPath2, STATE_PATH);
+  if (!pathExists(statePath)) {
+    logger.error("No .ai/.conflux-state.json found. Run 'conflux sync' first.");
+    return false;
+  }
+  let state;
+  try {
+    state = JSON.parse(readFileIfExists(statePath) ?? "{}");
+  } catch {
+    logger.error("Corrupted state file. Run 'conflux sync' to regenerate.");
+    return false;
+  }
+  const config = loadConfig(projectPath2);
+  const currentConfigHash = hashContent(JSON.stringify(config));
+  if (currentConfigHash !== state.configHash) {
+    logger.error("\u274C .ai/config.yaml was modified since last sync.");
+    logger.info("   Run 'conflux sync' to update tool configs.");
+    return false;
+  }
+  let allOk = true;
+  for (const [providerId, providerState] of Object.entries(state.providers)) {
+    if (!providerState?.synced) continue;
+    for (const [filePath, fileState] of Object.entries(providerState.files)) {
+      const fullPath = join5(projectPath2, filePath);
+      const content = readFileIfExists(fullPath);
+      if (content === null) {
+        logger.error(`\u274C Missing: ${filePath} (${providerId})`);
+        allOk = false;
+        continue;
+      }
+      const actualHash = hashContent(content);
+      if (actualHash !== fileState.hash) {
+        logger.error(`\u274C Drifted: ${filePath} (${providerId}) \u2014 manually edited`);
+        allOk = false;
+      }
+    }
+  }
+  const detectedIds = detectToolIds(projectPath2);
+  const enabledIds = config.providers?.enabled ?? detectedIds;
+  const syncedIds = Object.keys(state.providers);
+  for (const id of enabledIds) {
+    if (detectedIds.includes(id) && !syncedIds.includes(id)) {
+      logger.warn(`\u26A0 New tool detected: ${id} \u2014 run 'conflux sync' to generate configs`);
+    }
+  }
+  return allOk;
+}
+
+// src/cli/commands/providers.ts
+var CAPABILITY_ICONS = {
+  instructions: "\u{1F4CB}",
+  hooks: "\u{1FA9D}",
+  mcp: "\u{1F50C}",
+  permissions: "\u{1F512}",
+  skills: "\u26A1"
+};
+function registerProvidersCommand(program2) {
+  program2.command("providers").description("List supported AI coding tools and their capabilities").option("--details", "Show detailed capability breakdown").option("--detect", "Show which tools are detected in the current project").action(async (options, command) => {
+    const globalOpts = command.parent?.opts() ?? {};
+    const projectPath2 = globalOpts.project ?? process.cwd();
+    const providers = registry.list();
+    if (providers.length === 0) {
+      logger.warn("No providers registered. This is a bug \u2014 please report it.");
+      return;
+    }
+    logger.heading(`AI Coding Tools (${providers.length} supported)`);
+    const detectedPatterns = options.detect ? detectTools(projectPath2) : [];
+    const detectedIds = new Set(detectedPatterns.map((p) => p.providerId));
+    if (options.details) {
+      const rows = providers.map((p) => {
+        const capStr = p.capabilities.map((c) => CAPABILITY_ICONS[c] ?? "\u2753").join(" ");
+        return {
+          Provider: p.id,
+          Name: p.name,
+          Capabilities: capStr,
+          Detected: detectedIds.has(p.id) ? "\u2713" : "-"
+        };
+      });
+      logger.table(rows);
+    } else {
+      for (const p of providers) {
+        const detected = detectedIds.has(p.id) ? " (detected)" : "";
+        console.log(`  ${p.id.padEnd(20)} ${p.name}${detected}`);
+      }
+    }
+    if (options.details) {
+      console.log();
+      console.log("  Capability legend:");
+      for (const cap of Object.values(ProviderCapability)) {
+        console.log(`    ${CAPABILITY_ICONS[cap] ?? "\u2753"} ${cap}`);
+      }
+    }
+  });
+}
+
+// src/cli/commands/setup-git-hook.ts
+import { join as join6 } from "path";
+var HOOK_SCRIPT = `#!/bin/sh
+# ============================================================================
+# Conflux pre-commit hook
+# Ensures AI tool configs are in sync before every commit.
+# Installed by: conflux setup-git-hook
+# ============================================================================
+
+echo "\u{1F50D} Conflux: checking AI config sync..."
+
+if command -v conflux &> /dev/null; then
+  conflux sync --check
+  if [ $? -ne 0 ]; then
+    echo ""
+    echo "\u274C AI tool configs are out of sync with .ai/config.yaml."
+    echo "   Run 'conflux sync' to fix, then commit again."
+    echo "   Or use 'git commit --no-verify' to skip this check."
+    exit 1
+  fi
+  echo "\u2705 AI configs in sync."
+else
+  echo "\u26A0\uFE0F  conflux not found in PATH \u2014 skipping sync check."
+  echo "   Install: npm install -g conflux-ai"
+fi
+`;
+function registerSetupGitHookCommand(program2) {
+  program2.command("setup-git-hook").description("Install a pre-commit hook that auto-checks config sync").option("--force", "Overwrite existing pre-commit hook").action(async (options, command) => {
+    const globalOpts = command.parent?.opts() ?? {};
+    const projectPath2 = globalOpts.project ?? process.cwd();
+    const gitDir = join6(projectPath2, ".git");
+    if (!pathExists(gitDir)) {
+      logger.error("Not a git repository. Run 'git init' first.");
+      process.exit(1);
+    }
+    const hookPath = join6(gitDir, "hooks", "pre-commit");
+    const existing = readFileIfExists(hookPath);
+    if (existing && !options.force) {
+      if (existing.includes("Conflux pre-commit hook")) {
+        logger.info("Conflux pre-commit hook already installed.");
+        logger.info("Use --force to reinstall.");
+        return;
+      }
+      logger.warn("A pre-commit hook already exists.");
+      logger.info(hookPath);
+      logger.info("");
+      logger.info("Options:");
+      logger.info("  1. Use --force to replace it (your existing hook will be lost)");
+      logger.info("  2. Manually add this line to your existing hook:");
+      console.log("");
+      console.log("     conflux sync --check");
+      console.log("");
+      return;
+    }
+    writeFile(hookPath, HOOK_SCRIPT);
+    try {
+      const { chmodSync } = await import("fs");
+      chmodSync(hookPath, 493);
+    } catch {
+    }
+    logger.success("Installed pre-commit hook:");
+    logger.info(`  ${hookPath}`);
+    console.log("");
+    logger.info("Now, before every 'git commit', Conflux will:");
+    logger.info("  1. Check if .ai/config.yaml changed since last sync");
+    logger.info("  2. Check if any generated files were manually edited");
+    logger.info("  3. Block the commit if configs are out of sync");
+    console.log("");
+    logger.info("To skip the check: git commit --no-verify");
+  });
+}
+
+// src/cli/index.ts
+registerAllProviders();
+var __filename2 = fileURLToPath(import.meta.url);
+var __dirname2 = dirname2(__filename2);
+var pkgPath = join7(__dirname2, "..", "..", "package.json");
+var pkg = JSON.parse(readFileSync3(pkgPath, "utf-8"));
+var program = new Command();
+program.name("conflux").description(
+  "Unified configuration manager for AI coding tools.\nDefine once in .ai/config.yaml \u2014 sync to Claude Code, Codex, Cursor, and more."
+).version(pkg.version, "-V, --version", "Show version number").option("-v, --verbose", "Verbose output").option("-d, --dry-run", "Preview changes without writing files").option("-p, --project <path>", "Project root directory", process.cwd()).option("--json", "Output in JSON format (for programmatic use)").option("-y, --yes", "Skip confirmation prompts");
+registerInitCommand(program);
+registerSyncCommand(program);
+registerProvidersCommand(program);
+registerSetupGitHookCommand(program);
+program.parse(process.argv);
+//# sourceMappingURL=index.js.map