ai-dot 0.1.0-alpha.1

package/dist/index.js

@@ -0,0 +1,3234 @@
+// src/commands/add.ts
+import { existsSync } from "fs";
+import { mkdir, readFile, writeFile } from "fs/promises";
+import { join } from "path";
+import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
+
+// src/tui.ts
+import {
+  confirm,
+  intro,
+  isCancel,
+  multiselect,
+  outro,
+  select,
+  spinner,
+  text
+} from "@clack/prompts";
+function isTTY() {
+  return Boolean(process.stdin.isTTY && process.stdout.isTTY);
+}
+function cancelGuard(value) {
+  if (isCancel(value)) {
+    outro("Cancelled.");
+    process.exit(0);
+  }
+  return value;
+}
+
+// src/commands/check.ts
+import { homedir as homedir2 } from "os";
+import { join as join4 } from "path";
+
+// src/config/loader.ts
+import { readdir as readdir2, readFile as readFile4 } from "fs/promises";
+import { homedir } from "os";
+import { join as join3 } from "path";
+import { parse as parseYaml2 } from "yaml";
+
+// src/config/markdown-loader.ts
+import { readFile as readFile2 } from "fs/promises";
+function parseMarkdownWithFrontmatter(raw) {
+  const trimmed = raw.trimStart();
+  if (!trimmed.startsWith("---")) {
+    return { frontmatter: {}, body: raw.trim() };
+  }
+  const endIndex = trimmed.indexOf("---", 3);
+  if (endIndex === -1) {
+    return { frontmatter: {}, body: raw.trim() };
+  }
+  const frontmatterBlock = trimmed.slice(3, endIndex).trim();
+  const body = trimmed.slice(endIndex + 3).trim();
+  const frontmatter = {};
+  for (const line of frontmatterBlock.split("\n")) {
+    const colonIdx = line.indexOf(":");
+    if (colonIdx === -1) continue;
+    const key = line.slice(0, colonIdx).trim();
+    const rawValue = line.slice(colonIdx + 1).trim();
+    frontmatter[key] = parseFrontmatterValue(rawValue);
+  }
+  return { frontmatter, body };
+}
+function parseFrontmatterValue(raw) {
+  if (raw === "true") return true;
+  if (raw === "false") return false;
+  if (raw === "") return "";
+  if (/^-?\d+(\.\d+)?$/.test(raw)) return Number(raw);
+  if (raw.startsWith("[") && raw.endsWith("]")) {
+    const inner = raw.slice(1, -1).trim();
+    if (!inner) return [];
+    return inner.split(",").map((s) => {
+      const v = s.trim();
+      if (v.startsWith('"') && v.endsWith('"') || v.startsWith("'") && v.endsWith("'")) {
+        return v.slice(1, -1);
+      }
+      return v;
+    });
+  }
+  if (raw.startsWith('"') && raw.endsWith('"') || raw.startsWith("'") && raw.endsWith("'")) {
+    return raw.slice(1, -1);
+  }
+  return raw;
+}
+async function loadMarkdownFile(filePath) {
+  const content = await readFile2(filePath, "utf-8");
+  return parseMarkdownWithFrontmatter(content);
+}
+
+// src/config/schema.ts
+function emptyConfig() {
+  return {
+    directives: [],
+    skills: [],
+    agents: [],
+    toolServers: [],
+    hooks: [],
+    permissions: [],
+    settings: [],
+    ignorePatterns: []
+  };
+}
+function mergeConfigs(base, override) {
+  const mergedSettings = [...base.settings];
+  for (const setting of override.settings) {
+    const idx = mergedSettings.findIndex((s) => s.key === setting.key);
+    if (idx >= 0) {
+      mergedSettings[idx] = setting;
+    } else {
+      mergedSettings.push(setting);
+    }
+  }
+  const mergedServers = [...base.toolServers];
+  for (const server of override.toolServers) {
+    const idx = mergedServers.findIndex((s) => s.name === server.name);
+    if (idx >= 0) {
+      mergedServers[idx] = server;
+    } else {
+      mergedServers.push(server);
+    }
+  }
+  return {
+    directives: [...base.directives, ...override.directives],
+    skills: [...base.skills, ...override.skills],
+    agents: [...base.agents, ...override.agents],
+    toolServers: mergedServers,
+    hooks: [...base.hooks, ...override.hooks],
+    permissions: [...base.permissions, ...override.permissions],
+    settings: mergedSettings,
+    ignorePatterns: [...base.ignorePatterns, ...override.ignorePatterns]
+  };
+}
+function validateConfig(config) {
+  const errors = [];
+  for (const d of config.directives) {
+    if (!d.content.trim()) {
+      errors.push({ file: "directives", message: "Directive has empty content" });
+    }
+  }
+  for (const s of config.skills) {
+    if (!s.name.trim()) {
+      errors.push({ file: "skills", message: "Skill has empty name" });
+    }
+    if (!s.content.trim()) {
+      errors.push({ file: `skills/${s.name}`, message: "Skill has empty content" });
+    }
+  }
+  for (const a of config.agents) {
+    if (!a.name.trim()) {
+      errors.push({ file: "agents", message: "Agent has empty name" });
+    }
+    if (!a.instructions.trim()) {
+      errors.push({ file: `agents/${a.name}`, message: "Agent has empty instructions" });
+    }
+  }
+  for (const ts of config.toolServers) {
+    if (!ts.name.trim()) {
+      errors.push({ file: "config.yaml", message: "ToolServer has empty name" });
+    }
+    if (ts.transport === "stdio" && !ts.command) {
+      errors.push({
+        file: "config.yaml",
+        message: `ToolServer "${ts.name}" uses stdio transport but has no command`
+      });
+    }
+    if ((ts.transport === "http" || ts.transport === "sse") && !ts.url) {
+      errors.push({
+        file: "config.yaml",
+        message: `ToolServer "${ts.name}" uses ${ts.transport} transport but has no url`
+      });
+    }
+  }
+  for (const p of config.permissions) {
+    if (!p.tool.trim()) {
+      errors.push({ file: "config.yaml", message: "Permission has empty tool" });
+    }
+  }
+  return { valid: errors.length === 0, errors };
+}
+
+// src/config/skill-loader.ts
+import { readdir, readFile as readFile3, stat } from "fs/promises";
+import { join as join2 } from "path";
+async function loadSkills(skillsDir) {
+  const entries = await readdir(skillsDir).catch(() => []);
+  const skills = [];
+  for (const entry of entries) {
+    const skillDir = join2(skillsDir, entry);
+    const skillStat = await stat(skillDir).catch(() => null);
+    if (!skillStat?.isDirectory()) continue;
+    const skillFile = join2(skillDir, "SKILL.md");
+    const content = await readFile3(skillFile, "utf-8").catch(() => null);
+    if (content === null) continue;
+    skills.push({
+      name: entry,
+      description: extractDescription(content),
+      content,
+      disableAutoInvocation: false
+    });
+  }
+  return skills;
+}
+function extractDescription(content) {
+  const lines = content.split("\n");
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    return trimmed.length > 100 ? `${trimmed.slice(0, 97)}...` : trimmed;
+  }
+  return "";
+}
+
+// src/config/loader.ts
+async function loadProjectConfig(aiDir, scope = "project") {
+  const config = emptyConfig();
+  const errors = [];
+  const configPath = join3(aiDir, "config.yaml");
+  await loadConfigYaml(configPath, config, errors, scope);
+  const directivesDir = join3(aiDir, "directives");
+  await loadDirectives(directivesDir, config, errors, scope);
+  const skillsDir = join3(aiDir, "skills");
+  try {
+    config.skills = await loadSkills(skillsDir);
+  } catch {
+  }
+  const agentsDir = join3(aiDir, "agents");
+  await loadAgents(agentsDir, config, errors);
+  return { config, errors };
+}
+async function loadMergedConfig(projectDir) {
+  const userAiDir = join3(homedir(), ".ai");
+  const projectAiDir = join3(projectDir, ".ai");
+  const userResult = await loadProjectConfig(userAiDir, "user");
+  const projectResult = await loadProjectConfig(projectAiDir, "project");
+  const errors = [...userResult.errors, ...projectResult.errors];
+  const config = mergeConfigs(userResult.config, projectResult.config);
+  return { config, errors };
+}
+async function loadConfigYaml(filePath, config, errors, scope = "project") {
+  let raw;
+  try {
+    raw = await readFile4(filePath, "utf-8");
+  } catch {
+    return;
+  }
+  let parsed;
+  try {
+    parsed = parseYaml2(raw) ?? {};
+  } catch (e) {
+    errors.push({
+      file: filePath,
+      message: `Invalid YAML: ${e instanceof Error ? e.message : String(e)}`
+    });
+    return;
+  }
+  if (typeof parsed !== "object" || parsed === null) {
+    errors.push({ file: filePath, message: "config.yaml must be a YAML mapping" });
+    return;
+  }
+  if (parsed.mcpServers && typeof parsed.mcpServers === "object") {
+    for (const [name, raw2] of Object.entries(parsed.mcpServers)) {
+      const server = parseToolServer(name, raw2, filePath, errors, scope);
+      if (server) config.toolServers.push(server);
+    }
+  }
+  if (Array.isArray(parsed.permissions)) {
+    for (const raw2 of parsed.permissions) {
+      const perm = parsePermission(raw2, filePath, errors, scope);
+      if (perm) config.permissions.push(perm);
+    }
+  }
+  if (parsed.settings && typeof parsed.settings === "object") {
+    for (const [key, value] of Object.entries(parsed.settings)) {
+      config.settings.push({ key, value, scope });
+    }
+  }
+  if (Array.isArray(parsed.hooks)) {
+    for (const raw2 of parsed.hooks) {
+      const hook = parseHook(raw2, filePath, errors, scope);
+      if (hook) config.hooks.push(hook);
+    }
+  }
+  if (Array.isArray(parsed.ignore)) {
+    for (const raw2 of parsed.ignore) {
+      if (typeof raw2 === "string") {
+        config.ignorePatterns.push({ pattern: raw2, scope });
+      }
+    }
+  }
+}
+function parseToolServer(name, raw, file, errors, scope = "project") {
+  if (typeof raw !== "object" || raw === null) {
+    errors.push({ file, message: `mcpServers.${name} must be an object` });
+    return null;
+  }
+  const obj = raw;
+  const transport = typeof obj.transport === "string" ? obj.transport : "stdio";
+  return {
+    name,
+    transport,
+    command: typeof obj.command === "string" ? obj.command : void 0,
+    url: typeof obj.url === "string" ? obj.url : void 0,
+    args: Array.isArray(obj.args) ? obj.args.map(String) : void 0,
+    env: typeof obj.env === "object" && obj.env !== null ? Object.fromEntries(
+      Object.entries(obj.env).map(([k, v]) => [k, String(v)])
+    ) : void 0,
+    enabledTools: Array.isArray(obj.enabledTools) ? obj.enabledTools.map(String) : void 0,
+    disabledTools: Array.isArray(obj.disabledTools) ? obj.disabledTools.map(String) : void 0,
+    scope
+  };
+}
+function parsePermission(raw, file, errors, scope = "project") {
+  if (typeof raw !== "object" || raw === null) {
+    errors.push({ file, message: "Permission entry must be an object" });
+    return null;
+  }
+  const obj = raw;
+  if (typeof obj.tool !== "string" || typeof obj.decision !== "string") {
+    errors.push({ file, message: "Permission requires 'tool' and 'decision' fields" });
+    return null;
+  }
+  return {
+    tool: obj.tool,
+    pattern: typeof obj.pattern === "string" ? obj.pattern : void 0,
+    decision: obj.decision,
+    scope
+  };
+}
+function parseHook(raw, file, errors, scope = "project") {
+  if (typeof raw !== "object" || raw === null) {
+    errors.push({ file, message: "Hook entry must be an object" });
+    return null;
+  }
+  const obj = raw;
+  if (typeof obj.event !== "string" || typeof obj.handler !== "string") {
+    errors.push({ file, message: "Hook requires 'event' and 'handler' fields" });
+    return null;
+  }
+  return {
+    event: obj.event,
+    matcher: typeof obj.matcher === "string" ? obj.matcher : void 0,
+    handler: obj.handler,
+    scope
+  };
+}
+async function loadDirectives(directivesDir, config, errors, scope = "project") {
+  let files;
+  try {
+    files = await readdir2(directivesDir);
+  } catch {
+    return;
+  }
+  for (const file of files.filter((f) => f.endsWith(".md"))) {
+    const filePath = join3(directivesDir, file);
+    try {
+      const { frontmatter, body } = await loadMarkdownFile(filePath);
+      const directive = {
+        content: body,
+        scope: typeof frontmatter.scope === "string" ? frontmatter.scope : scope,
+        alwaysApply: frontmatter.alwaysApply !== false,
+        appliesTo: Array.isArray(frontmatter.appliesTo) ? frontmatter.appliesTo.map(String) : typeof frontmatter.appliesTo === "string" ? [frontmatter.appliesTo] : void 0,
+        description: typeof frontmatter.description === "string" ? frontmatter.description : file.replace(/\.md$/, "")
+      };
+      config.directives.push(directive);
+    } catch (e) {
+      errors.push({
+        file: filePath,
+        message: `Failed to parse: ${e instanceof Error ? e.message : String(e)}`
+      });
+    }
+  }
+}
+async function loadAgents(agentsDir, config, errors) {
+  let files;
+  try {
+    files = await readdir2(agentsDir);
+  } catch {
+    return;
+  }
+  for (const file of files.filter((f) => f.endsWith(".md"))) {
+    const filePath = join3(agentsDir, file);
+    try {
+      const { frontmatter, body } = await loadMarkdownFile(filePath);
+      const agent = {
+        name: file.replace(/\.md$/, ""),
+        description: typeof frontmatter.description === "string" ? frontmatter.description : "",
+        instructions: body,
+        model: typeof frontmatter.model === "string" ? frontmatter.model : void 0,
+        readonly: frontmatter.readonly === true ? true : void 0,
+        tools: Array.isArray(frontmatter.tools) ? frontmatter.tools.map(String) : void 0
+      };
+      config.agents.push(agent);
+    } catch (e) {
+      errors.push({
+        file: filePath,
+        message: `Failed to parse: ${e instanceof Error ? e.message : String(e)}`
+      });
+    }
+  }
+}
+
+// src/emitters/types.ts
+var TargetTool = {
+  Claude: "claude",
+  Cursor: "cursor",
+  Codex: "codex",
+  OpenCode: "opencode",
+  Copilot: "copilot",
+  Antigravity: "antigravity"
+};
+var ALL_TARGETS = [
+  TargetTool.Claude,
+  TargetTool.Cursor,
+  TargetTool.Codex,
+  TargetTool.OpenCode,
+  TargetTool.Copilot,
+  TargetTool.Antigravity
+];
+
+// src/commands/check.ts
+async function runCheck(projectDir, scope = "project") {
+  const isUserScope = scope === "user";
+  const label = isUserScope ? "~/.ai/" : ".ai/";
+  console.log(`Checking ${label} configuration...
+`);
+  const { config, errors: loadErrors } = isUserScope ? await loadProjectConfig(join4(homedir2(), ".ai"), "user") : await loadMergedConfig(projectDir);
+  if (loadErrors.length > 0) {
+    console.error("\x1B[31mLoad errors:\x1B[0m");
+    for (const err of loadErrors) {
+      console.error(`  ${err.file}${err.line ? `:${err.line}` : ""}: ${err.message}`);
+    }
+    process.exitCode = 1;
+    return;
+  }
+  const { valid, errors: valErrors } = validateConfig(config);
+  if (!valid) {
+    console.error("\x1B[31mValidation errors:\x1B[0m");
+    for (const err of valErrors) {
+      console.error(`  ${err.file}: ${err.message}`);
+    }
+    process.exitCode = 1;
+    return;
+  }
+  console.log("\x1B[32m\u2713\x1B[0m Config is valid\n");
+  printSummary(config);
+  console.log("\n\x1B[1mTarget compatibility:\x1B[0m\n");
+  for (const target of ALL_TARGETS) {
+    checkTarget(config, target);
+  }
+}
+function printSummary(config) {
+  const counts = [
+    ["Directives", config.directives.length],
+    ["Skills", config.skills.length],
+    ["Agents", config.agents.length],
+    ["MCP Servers", config.toolServers.length],
+    ["Permissions", config.permissions.length],
+    ["Settings", config.settings.length],
+    ["Hooks", config.hooks.length],
+    ["Ignore patterns", config.ignorePatterns.length]
+  ];
+  console.log("\x1B[1mConfig summary:\x1B[0m");
+  for (const [label, count] of counts) {
+    if (count > 0) {
+      console.log(`  ${label}: ${count}`);
+    }
+  }
+}
+function checkTarget(config, target) {
+  const warnings = [];
+  if (target === "codex") {
+    if (config.hooks.length > 0) {
+      warnings.push("Hooks are not supported \u2014 will be skipped");
+    }
+    if (config.permissions.length > 0) {
+      warnings.push("Per-tool permissions are lossy \u2014 mapped to approval_policy");
+    }
+    if (config.directives.some((d) => d.appliesTo?.length)) {
+      warnings.push("File-scoped directives are not enforced \u2014 included as notes only");
+    }
+    if (config.agents.some((a) => a.tools?.length)) {
+      warnings.push("Per-agent tool restrictions are not supported");
+    }
+  }
+  if (target === "cursor") {
+    if (config.hooks.length > 0) {
+      warnings.push("Hook support is limited \u2014 hooks not directly emitted");
+    }
+  }
+  const icon = warnings.length > 0 ? "\x1B[33m\u26A0\x1B[0m" : "\x1B[32m\u2713\x1B[0m";
+  console.log(`  ${icon} ${target}`);
+  for (const w of warnings) {
+    console.log(`    - ${w}`);
+  }
+}
+
+// src/import/runner.ts
+import { join as join9 } from "path";
+
+// src/import/parsers/claude.ts
+import { readFile as readFile5 } from "fs/promises";
+import { join as join5 } from "path";
+async function parseClaude(projectDir, files) {
+  const config = emptyConfig();
+  for (const file of files) {
+    switch (file.kind) {
+      case "directives":
+        if (file.relativePath === "CLAUDE.md") {
+          await parseClaudeMd(file.path, config);
+        } else {
+          await parseClaudeRule(file.path, config);
+        }
+        break;
+      case "mcp":
+        await parseMcpJson(file.path, config);
+        break;
+      case "settings":
+        await parseClaudeSettings(file.path, config);
+        break;
+      case "agents":
+        await parseClaudeAgent(file.path, config);
+        break;
+      case "skills": {
+        const skillsDir = join5(projectDir, ".claude", "skills");
+        try {
+          config.skills = await loadSkills(skillsDir);
+        } catch {
+        }
+        break;
+      }
+    }
+  }
+  return config;
+}
+async function parseClaudeMd(filePath, config) {
+  const raw = await readFile5(filePath, "utf-8").catch(() => null);
+  if (!raw) return;
+  const sections = raw.split("\n\n---\n\n");
+  for (const section of sections) {
+    const content = section.trim();
+    if (!content) continue;
+    config.directives.push({
+      content,
+      scope: "project",
+      alwaysApply: true,
+      description: extractHeading(content)
+    });
+  }
+}
+async function parseClaudeRule(filePath, config) {
+  const raw = await readFile5(filePath, "utf-8").catch(() => null);
+  if (!raw) return;
+  let content = raw.trim();
+  let appliesTo;
+  const match = content.match(/^<!--\s*applies to:\s*(.+?)\s*-->\s*\n*/);
+  if (match) {
+    appliesTo = match[1].split(",").map((s) => s.trim());
+    content = content.slice(match[0].length).trim();
+  }
+  config.directives.push({
+    content,
+    scope: "project",
+    alwaysApply: !appliesTo,
+    appliesTo,
+    description: extractHeading(content)
+  });
+}
+async function parseMcpJson(filePath, config) {
+  const raw = await readFile5(filePath, "utf-8").catch(() => null);
+  if (!raw) return;
+  try {
+    const parsed = JSON.parse(raw);
+    const servers = parsed.mcpServers ?? parsed;
+    if (typeof servers !== "object" || servers === null) return;
+    for (const [name, entry] of Object.entries(servers)) {
+      const obj = entry;
+      config.toolServers.push({
+        name,
+        transport: typeof obj.type === "string" ? obj.type : "stdio",
+        command: typeof obj.command === "string" ? obj.command : void 0,
+        url: typeof obj.url === "string" ? obj.url : void 0,
+        args: Array.isArray(obj.args) ? obj.args.map(String) : void 0,
+        env: typeof obj.env === "object" && obj.env !== null ? Object.fromEntries(
+          Object.entries(obj.env).map(([k, v]) => [k, String(v)])
+        ) : void 0,
+        scope: "project"
+      });
+    }
+  } catch {
+  }
+}
+async function parseClaudeSettings(filePath, config) {
+  const raw = await readFile5(filePath, "utf-8").catch(() => null);
+  if (!raw) return;
+  try {
+    const parsed = JSON.parse(raw);
+    if (parsed.permissions) {
+      const perms = parsed.permissions;
+      for (const rule of perms.allow ?? []) {
+        const p = parsePermissionRule(rule, "allow");
+        if (p) {
+          config.permissions.push(p);
+        }
+      }
+      for (const rule of perms.deny ?? []) {
+        const p = parsePermissionRule(rule, "deny");
+        if (p) {
+          if (p.tool === "Read" || p.tool === "Edit") {
+            const pattern = p.pattern;
+            if (pattern) {
+              const existing = config.ignorePatterns.find((ip) => ip.pattern === pattern);
+              if (!existing) {
+                config.ignorePatterns.push({ pattern, scope: "project" });
+              }
+            }
+          } else {
+            config.permissions.push(p);
+          }
+        }
+      }
+    }
+    if (parsed.hooks && typeof parsed.hooks === "object") {
+      for (const [event, entries] of Object.entries(parsed.hooks)) {
+        if (!Array.isArray(entries)) continue;
+        for (const entry of entries) {
+          const obj = entry;
+          if (typeof obj.command !== "string") continue;
+          config.hooks.push({
+            event,
+            handler: obj.command,
+            matcher: typeof obj.matcher === "string" ? obj.matcher : void 0,
+            scope: "project"
+          });
+        }
+      }
+    }
+    const knownKeys = /* @__PURE__ */ new Set(["permissions", "hooks"]);
+    for (const [key, value] of Object.entries(parsed)) {
+      if (!knownKeys.has(key)) {
+        config.settings.push({ key, value, scope: "project" });
+      }
+    }
+  } catch {
+  }
+}
+function parsePermissionRule(rule, decision) {
+  const match = rule.match(/^(\w+)\((.+)\)$/);
+  if (match) {
+    return { tool: match[1], pattern: match[2], decision, scope: "project" };
+  }
+  return { tool: rule, decision, scope: "project" };
+}
+async function parseClaudeAgent(filePath, config) {
+  const raw = await readFile5(filePath, "utf-8").catch(() => null);
+  if (!raw) return;
+  const name = filePath.split("/").pop()?.replace(/\.md$/, "") ?? "agent";
+  config.agents.push({
+    name,
+    description: "",
+    instructions: raw.trim()
+  });
+}
+function extractHeading(content) {
+  const match = content.match(/^#\s+(.+)$/m);
+  if (match) return match[1].trim();
+  const firstLine = content.split("\n")[0]?.trim() ?? "";
+  return firstLine.length > 50 ? `${firstLine.slice(0, 47)}...` : firstLine;
+}
+
+// src/import/parsers/codex.ts
+import { readFile as readFile6 } from "fs/promises";
+import { parse as parseToml } from "smol-toml";
+async function parseCodex(_projectDir, files) {
+  const config = emptyConfig();
+  for (const file of files) {
+    switch (file.kind) {
+      case "settings":
+        await parseCodexToml(file.path, config);
+        break;
+      case "directives":
+        await parseAgentsMd(file.path, config);
+        break;
+    }
+  }
+  return config;
+}
+async function parseCodexToml(filePath, config) {
+  const raw = await readFile6(filePath, "utf-8").catch(() => null);
+  if (!raw) return;
+  try {
+    const parsed = parseToml(raw);
+    if (parsed.mcp_servers && typeof parsed.mcp_servers === "object") {
+      for (const [name, entry] of Object.entries(parsed.mcp_servers)) {
+        const obj = entry;
+        config.toolServers.push({
+          name,
+          transport: typeof obj.type === "string" ? obj.type : "stdio",
+          command: typeof obj.command === "string" ? obj.command : void 0,
+          url: typeof obj.url === "string" ? obj.url : void 0,
+          args: Array.isArray(obj.args) ? obj.args.map(String) : void 0,
+          env: typeof obj.env === "object" && obj.env !== null ? Object.fromEntries(
+            Object.entries(obj.env).map(([k, v]) => [
+              k,
+              String(v)
+            ])
+          ) : void 0,
+          scope: "project"
+        });
+      }
+    }
+    if (typeof parsed.approval_policy === "string") {
+      if (parsed.approval_policy === "unless-allowed") {
+        config.permissions.push({
+          tool: "Bash",
+          decision: "allow",
+          scope: "project"
+        });
+      }
+    }
+    if (Array.isArray(parsed.protected_paths)) {
+      for (const p of parsed.protected_paths) {
+        if (typeof p === "string") {
+          config.ignorePatterns.push({ pattern: p, scope: "project" });
+        }
+      }
+    }
+    const knownKeys = /* @__PURE__ */ new Set(["mcp_servers", "approval_policy", "protected_paths"]);
+    for (const [key, value] of Object.entries(parsed)) {
+      if (!knownKeys.has(key)) {
+        config.settings.push({ key, value, scope: "project" });
+      }
+    }
+  } catch {
+  }
+}
+async function parseAgentsMd(filePath, config) {
+  const raw = await readFile6(filePath, "utf-8").catch(() => null);
+  if (!raw) return;
+  const lines = raw.split("\n");
+  let currentName = null;
+  let currentType = "directive";
+  let currentLines = [];
+  const flush = () => {
+    const content = currentLines.join("\n").trim();
+    if (!content) return;
+    if (currentType === "agent" && currentName) {
+      config.agents.push({
+        name: currentName,
+        description: "",
+        instructions: content
+      });
+    } else if (currentType === "directive") {
+      config.directives.push({
+        content,
+        scope: "project",
+        alwaysApply: true,
+        description: currentName ?? "directive"
+      });
+    }
+  };
+  for (const line of lines) {
+    const agentMatch = line.match(/^##\s+Agent:\s+(.+)$/);
+    const sectionMatch = !agentMatch ? line.match(/^##\s+(.+)$/) : null;
+    if (agentMatch) {
+      flush();
+      currentName = agentMatch[1].trim();
+      currentType = "agent";
+      currentLines = [];
+    } else if (sectionMatch) {
+      flush();
+      currentName = sectionMatch[1].trim();
+      currentType = "directive";
+      currentLines = [];
+    } else if (currentName !== null || currentType === "directive") {
+      if (line.match(/^#\s/) && currentLines.length === 0 && currentName === null) continue;
+      currentLines.push(line);
+    }
+  }
+  flush();
+}
+
+// src/import/parsers/cursor.ts
+import { readFile as readFile7 } from "fs/promises";
+async function parseCursor(_projectDir, files) {
+  const config = emptyConfig();
+  for (const file of files) {
+    switch (file.kind) {
+      case "directives":
+        await parseCursorRule(file.path, config);
+        break;
+      case "mcp":
+        await parseCursorMcp(file.path, config);
+        break;
+      case "agents":
+        await parseCursorAgent(file.path, config);
+        break;
+    }
+  }
+  return config;
+}
+async function parseCursorRule(filePath, config) {
+  const raw = await readFile7(filePath, "utf-8").catch(() => null);
+  if (!raw) return;
+  const { frontmatter, body } = parseMarkdownWithFrontmatter(raw);
+  let appliesTo;
+  if (typeof frontmatter.globs === "string") {
+    appliesTo = frontmatter.globs.split(",").map((s) => s.trim());
+  } else if (Array.isArray(frontmatter.globs)) {
+    appliesTo = frontmatter.globs.map(String);
+  }
+  config.directives.push({
+    content: body,
+    scope: "project",
+    alwaysApply: frontmatter.alwaysApply !== false,
+    appliesTo,
+    description: typeof frontmatter.description === "string" ? frontmatter.description : filePath.split("/").pop()?.replace(/\.mdc?$/, "") ?? "rule"
+  });
+}
+async function parseCursorMcp(filePath, config) {
+  const raw = await readFile7(filePath, "utf-8").catch(() => null);
+  if (!raw) return;
+  try {
+    const parsed = JSON.parse(raw);
+    const servers = parsed.mcpServers ?? parsed;
+    if (typeof servers !== "object" || servers === null) return;
+    for (const [name, entry] of Object.entries(servers)) {
+      const obj = entry;
+      config.toolServers.push({
+        name,
+        transport: typeof obj.type === "string" ? obj.type : "stdio",
+        command: typeof obj.command === "string" ? obj.command : void 0,
+        url: typeof obj.url === "string" ? obj.url : void 0,
+        args: Array.isArray(obj.args) ? obj.args.map(String) : void 0,
+        env: typeof obj.env === "object" && obj.env !== null ? Object.fromEntries(
+          Object.entries(obj.env).map(([k, v]) => [k, String(v)])
+        ) : void 0,
+        scope: "project"
+      });
+    }
+  } catch {
+  }
+}
+async function parseCursorAgent(filePath, config) {
+  const raw = await readFile7(filePath, "utf-8").catch(() => null);
+  if (!raw) return;
+  const { frontmatter, body } = parseMarkdownWithFrontmatter(raw);
+  const name = filePath.split("/").pop()?.replace(/\.md$/, "") ?? "agent";
+  config.agents.push({
+    name,
+    description: typeof frontmatter.description === "string" ? frontmatter.description : "",
+    instructions: body,
+    model: typeof frontmatter.model === "string" ? frontmatter.model : void 0,
+    readonly: frontmatter.readonly === true ? true : void 0,
+    tools: Array.isArray(frontmatter.tools) ? frontmatter.tools.map(String) : void 0
+  });
+}
+
+// src/import/parsers/opencode.ts
+import { readFile as readFile8 } from "fs/promises";
+import { join as join6 } from "path";
+async function parseOpenCode(projectDir, files) {
+  const config = emptyConfig();
+  for (const file of files) {
+    switch (file.kind) {
+      case "settings":
+        await parseOpenCodeJson(file.path, config);
+        break;
+      case "agents":
+        await parseOpenCodeAgent(file.path, config);
+        break;
+      case "skills": {
+        const skillsDir = join6(projectDir, ".opencode", "skills");
+        try {
+          config.skills = await loadSkills(skillsDir);
+        } catch {
+        }
+        break;
+      }
+    }
+  }
+  return config;
+}
+var SETTINGS_KEYS = /* @__PURE__ */ new Set(["model", "theme", "provider", "maxTokens"]);
+async function parseOpenCodeJson(filePath, config) {
+  const raw = await readFile8(filePath, "utf-8").catch(() => null);
+  if (!raw) return;
+  try {
+    const parsed = JSON.parse(raw);
+    if (parsed.mcp && typeof parsed.mcp === "object") {
+      for (const [name, entry] of Object.entries(parsed.mcp)) {
+        const obj = entry;
+        const rawType = typeof obj.type === "string" ? obj.type : "stdio";
+        const transport = rawType === "remote" ? "http" : rawType;
+        config.toolServers.push({
+          name,
+          transport,
+          command: typeof obj.command === "string" ? obj.command : void 0,
+          url: typeof obj.url === "string" ? obj.url : void 0,
+          args: Array.isArray(obj.args) ? obj.args.map(String) : void 0,
+          env: typeof obj.env === "object" && obj.env !== null ? Object.fromEntries(
+            Object.entries(obj.env).map(([k, v]) => [
+              k,
+              String(v)
+            ])
+          ) : void 0,
+          scope: "project"
+        });
+      }
+    }
+    if (parsed.permission && typeof parsed.permission === "object") {
+      for (const [tool, value] of Object.entries(parsed.permission)) {
+        if (typeof value === "string") {
+          config.permissions.push({
+            tool,
+            decision: value,
+            scope: "project"
+          });
+        } else if (typeof value === "object" && value !== null) {
+          for (const [pattern, decision] of Object.entries(value)) {
+            config.permissions.push({
+              tool,
+              pattern,
+              decision,
+              scope: "project"
+            });
+          }
+        }
+      }
+    }
+    if (Array.isArray(parsed.instructions)) {
+      for (const instrPath of parsed.instructions) {
+        if (typeof instrPath !== "string") continue;
+        const absPath = join6(filePath, "..", instrPath);
+        const content = await readFile8(absPath, "utf-8").catch(() => null);
+        if (!content) continue;
+        let body = content.trim();
+        let appliesTo;
+        const match = body.match(/^<!--\s*applies to:\s*(.+?)\s*-->\s*\n*/);
+        if (match) {
+          appliesTo = match[1].split(",").map((s) => s.trim());
+          body = body.slice(match[0].length).trim();
+        }
+        config.directives.push({
+          content: body,
+          scope: "project",
+          alwaysApply: !appliesTo,
+          appliesTo,
+          description: extractHeading2(body)
+        });
+      }
+    }
+    if (parsed.watcher?.ignore && Array.isArray(parsed.watcher.ignore)) {
+      for (const pattern of parsed.watcher.ignore) {
+        if (typeof pattern === "string") {
+          config.ignorePatterns.push({ pattern, scope: "project" });
+        }
+      }
+    }
+    for (const [key, value] of Object.entries(parsed)) {
+      if (SETTINGS_KEYS.has(key)) {
+        config.settings.push({ key, value, scope: "project" });
+      }
+    }
+  } catch {
+  }
+}
+async function parseOpenCodeAgent(filePath, config) {
+  const raw = await readFile8(filePath, "utf-8").catch(() => null);
+  if (!raw) return;
+  const { frontmatter, body } = parseMarkdownWithFrontmatter(raw);
+  const name = filePath.split("/").pop()?.replace(/\.md$/, "") ?? "agent";
+  config.agents.push({
+    name,
+    description: typeof frontmatter.description === "string" ? frontmatter.description : "",
+    instructions: body,
+    model: typeof frontmatter.model === "string" ? frontmatter.model : void 0,
+    mode: typeof frontmatter.mode === "string" ? frontmatter.mode : void 0,
+    temperature: typeof frontmatter.temperature === "number" ? frontmatter.temperature : void 0,
+    topP: typeof frontmatter.top_p === "number" ? frontmatter.top_p : void 0,
+    steps: typeof frontmatter.steps === "number" ? frontmatter.steps : void 0,
+    color: typeof frontmatter.color === "string" ? frontmatter.color : void 0,
+    hidden: frontmatter.hidden === true ? true : void 0,
+    disabled: frontmatter.disable === true ? true : void 0
+  });
+}
+function extractHeading2(content) {
+  const match = content.match(/^#\s+(.+)$/m);
+  if (match) return match[1].trim();
+  const firstLine = content.split("\n")[0]?.trim() ?? "";
+  return firstLine.length > 50 ? `${firstLine.slice(0, 47)}...` : firstLine;
+}
+
+// src/import/scanner.ts
+import { readdir as readdir3, stat as stat2 } from "fs/promises";
+import { join as join7, relative } from "path";
+async function exists(p) {
+  try {
+    await stat2(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function listMdFiles(dir) {
+  try {
+    const entries = await readdir3(dir);
+    return entries.filter((f) => f.endsWith(".md"));
+  } catch {
+    return [];
+  }
+}
+async function listMdcFiles(dir) {
+  try {
+    const entries = await readdir3(dir);
+    return entries.filter((f) => f.endsWith(".mdc"));
+  } catch {
+    return [];
+  }
+}
+async function listSkillDirs(dir) {
+  try {
+    const entries = await readdir3(dir);
+    const dirs = [];
+    for (const entry of entries) {
+      const p = join7(dir, entry);
+      const s = await stat2(p).catch(() => null);
+      if (s?.isDirectory()) {
+        const skillFile = join7(p, "SKILL.md");
+        if (await exists(skillFile)) dirs.push(entry);
+      }
+    }
+    return dirs;
+  } catch {
+    return [];
+  }
+}
+async function scanForConfigs(projectDir) {
+  const detected = [];
+  const add = (absPath, source, kind, label) => {
+    detected.push({
+      path: absPath,
+      relativePath: relative(projectDir, absPath),
+      source,
+      kind,
+      label
+    });
+  };
+  const claudeMd = join7(projectDir, "CLAUDE.md");
+  if (await exists(claudeMd)) add(claudeMd, "claude", "directives", "CLAUDE.md (directives)");
+  const mcpJson = join7(projectDir, ".mcp.json");
+  if (await exists(mcpJson)) add(mcpJson, "claude", "mcp", ".mcp.json (MCP servers)");
+  const claudeSettings = join7(projectDir, ".claude", "settings.json");
+  if (await exists(claudeSettings))
+    add(claudeSettings, "claude", "settings", ".claude/settings.json (permissions + settings)");
+  const claudeRulesDir = join7(projectDir, ".claude", "rules");
+  for (const f of await listMdFiles(claudeRulesDir)) {
+    const p = join7(claudeRulesDir, f);
+    add(p, "claude", "directives", `.claude/rules/${f} (directive)`);
+  }
+  const claudeAgentsDir = join7(projectDir, ".claude", "agents");
+  for (const f of await listMdFiles(claudeAgentsDir)) {
+    const p = join7(claudeAgentsDir, f);
+    add(p, "claude", "agents", `.claude/agents/${f} (agent)`);
+  }
+  const claudeSkillsDir = join7(projectDir, ".claude", "skills");
+  for (const s of await listSkillDirs(claudeSkillsDir)) {
+    const p = join7(claudeSkillsDir, s, "SKILL.md");
+    add(p, "claude", "skills", `.claude/skills/${s}/SKILL.md (skill)`);
+  }
+  const cursorRulesDir = join7(projectDir, ".cursor", "rules");
+  for (const f of await listMdcFiles(cursorRulesDir)) {
+    const p = join7(cursorRulesDir, f);
+    add(p, "cursor", "directives", `.cursor/rules/${f} (directive)`);
+  }
+  const cursorMcp = join7(projectDir, ".cursor", "mcp.json");
+  if (await exists(cursorMcp)) add(cursorMcp, "cursor", "mcp", ".cursor/mcp.json (MCP servers)");
+  const cursorAgentsDir = join7(projectDir, ".cursor", "agents");
+  for (const f of await listMdFiles(cursorAgentsDir)) {
+    const p = join7(cursorAgentsDir, f);
+    add(p, "cursor", "agents", `.cursor/agents/${f} (agent)`);
+  }
+  const codexToml = join7(projectDir, ".codex", "config.toml");
+  if (await exists(codexToml)) add(codexToml, "codex", "settings", ".codex/config.toml (settings)");
+  const agentsMd = join7(projectDir, "AGENTS.md");
+  if (await exists(agentsMd)) add(agentsMd, "codex", "directives", "AGENTS.md (directives)");
+  const opencodeJson = join7(projectDir, "opencode.json");
+  if (await exists(opencodeJson))
+    add(opencodeJson, "opencode", "settings", "opencode.json (config)");
+  const opencodeAgentsDir = join7(projectDir, ".opencode", "agents");
+  for (const f of await listMdFiles(opencodeAgentsDir)) {
+    const p = join7(opencodeAgentsDir, f);
+    add(p, "opencode", "agents", `.opencode/agents/${f} (agent)`);
+  }
+  const opencodeSkillsDir = join7(projectDir, ".opencode", "skills");
+  for (const s of await listSkillDirs(opencodeSkillsDir)) {
+    const p = join7(opencodeSkillsDir, s, "SKILL.md");
+    add(p, "opencode", "skills", `.opencode/skills/${s}/SKILL.md (skill)`);
+  }
+  return detected;
+}
+
+// src/import/writer.ts
+import { mkdir as mkdir2, writeFile as writeFile2 } from "fs/promises";
+import { join as join8 } from "path";
+import { stringify as stringifyYaml2 } from "yaml";
+function slugify(str) {
+  return str.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+}
+async function writeProjectConfig(aiDir, config) {
+  const written = [];
+  await mkdir2(aiDir, { recursive: true });
+  await mkdir2(join8(aiDir, "directives"), { recursive: true });
+  await mkdir2(join8(aiDir, "skills"), { recursive: true });
+  await mkdir2(join8(aiDir, "agents"), { recursive: true });
+  const yamlObj = {};
+  if (config.toolServers.length > 0) {
+    const servers = {};
+    for (const s of config.toolServers) {
+      const entry = { transport: s.transport };
+      if (s.command) entry.command = s.command;
+      if (s.url) entry.url = s.url;
+      if (s.args?.length) entry.args = s.args;
+      if (s.env && Object.keys(s.env).length > 0) entry.env = s.env;
+      if (s.enabledTools?.length) entry.enabledTools = s.enabledTools;
+      if (s.disabledTools?.length) entry.disabledTools = s.disabledTools;
+      servers[s.name] = entry;
+    }
+    yamlObj.mcpServers = servers;
+  } else {
+    yamlObj.mcpServers = {};
+  }
+  if (config.permissions.length > 0) {
+    yamlObj.permissions = config.permissions.map((p) => {
+      const entry = { tool: p.tool, decision: p.decision };
+      if (p.pattern) entry.pattern = p.pattern;
+      return entry;
+    });
+  } else {
+    yamlObj.permissions = [];
+  }
+  if (config.settings.length > 0) {
+    const settingsObj = {};
+    for (const s of config.settings) {
+      settingsObj[s.key] = s.value;
+    }
+    yamlObj.settings = settingsObj;
+  } else {
+    yamlObj.settings = {};
+  }
+  if (config.hooks.length > 0) {
+    yamlObj.hooks = config.hooks.map((h) => {
+      const entry = { event: h.event, handler: h.handler };
+      if (h.matcher) entry.matcher = h.matcher;
+      return entry;
+    });
+  } else {
+    yamlObj.hooks = [];
+  }
+  if (config.ignorePatterns.length > 0) {
+    yamlObj.ignore = config.ignorePatterns.map((p) => p.pattern);
+  } else {
+    yamlObj.ignore = [];
+  }
+  const configPath = join8(aiDir, "config.yaml");
+  await writeFile2(configPath, stringifyYaml2(yamlObj), "utf-8");
+  written.push(configPath);
+  for (const d of config.directives) {
+    const name = slugify(d.description || "rule");
+    const fm = [];
+    fm.push(`scope: ${d.scope}`);
+    fm.push(`alwaysApply: ${d.alwaysApply}`);
+    if (d.appliesTo?.length) {
+      fm.push(`appliesTo: [${d.appliesTo.join(", ")}]`);
+    }
+    if (d.description) {
+      fm.push(`description: ${d.description}`);
+    }
+    const header = `---
+${fm.join("\n")}
+---`;
+    const filePath = join8(aiDir, "directives", `${name}.md`);
+    await writeFile2(filePath, `${header}
+
+${d.content}
+`, "utf-8");
+    written.push(filePath);
+  }
+  for (const a of config.agents) {
+    const fm = [];
+    if (a.description) fm.push(`description: ${a.description}`);
+    if (a.model) fm.push(`model: ${a.model}`);
+    if (a.readonly) fm.push("readonly: true");
+    if (a.tools?.length) fm.push(`tools: [${a.tools.join(", ")}]`);
+    const header = fm.length > 0 ? `---
+${fm.join("\n")}
+---
+
+` : "";
+    const filePath = join8(aiDir, "agents", `${a.name}.md`);
+    await writeFile2(filePath, `${header}${a.instructions}
+`, "utf-8");
+    written.push(filePath);
+  }
+  for (const s of config.skills) {
+    const skillDir = join8(aiDir, "skills", s.name);
+    await mkdir2(skillDir, { recursive: true });
+    const filePath = join8(skillDir, "SKILL.md");
+    await writeFile2(filePath, s.content, "utf-8");
+    written.push(filePath);
+  }
+  return written;
+}
+
+// src/import/runner.ts
+async function runImport(projectDir, options) {
+  const detected = await scanForConfigs(projectDir);
+  const filtered = options.sourceFilter ? detected.filter((f) => f.source === options.sourceFilter) : detected;
+  if (filtered.length === 0) {
+    return { detected, imported: [], config: emptyConfig(), filesWritten: [] };
+  }
+  const selected = options.selectFiles ? await options.selectFiles(filtered) : filtered;
+  if (selected.length === 0) {
+    return { detected, imported: [], config: emptyConfig(), filesWritten: [] };
+  }
+  const bySource = groupBySource(selected);
+  let importedConfig = emptyConfig();
+  if (bySource.claude.length > 0) {
+    const partial = await parseClaude(projectDir, bySource.claude);
+    importedConfig = mergeConfigs(importedConfig, toFull(partial));
+  }
+  if (bySource.cursor.length > 0) {
+    const partial = await parseCursor(projectDir, bySource.cursor);
+    importedConfig = mergeConfigs(importedConfig, toFull(partial));
+  }
+  if (bySource.codex.length > 0) {
+    const partial = await parseCodex(projectDir, bySource.codex);
+    importedConfig = mergeConfigs(importedConfig, toFull(partial));
+  }
+  if (bySource.opencode.length > 0) {
+    const partial = await parseOpenCode(projectDir, bySource.opencode);
+    importedConfig = mergeConfigs(importedConfig, toFull(partial));
+  }
+  importedConfig.toolServers = deduplicateByName(importedConfig.toolServers);
+  const aiDir = join9(projectDir, ".ai");
+  try {
+    const existing = await loadProjectConfig(aiDir, "project");
+    if (hasContent(existing.config)) {
+      importedConfig = mergeConfigs(importedConfig, existing.config);
+    }
+  } catch {
+  }
+  const filesWritten = await writeProjectConfig(aiDir, importedConfig);
+  return {
+    detected,
+    imported: selected,
+    config: importedConfig,
+    filesWritten
+  };
+}
+function groupBySource(files) {
+  const result = {
+    claude: [],
+    cursor: [],
+    codex: [],
+    opencode: []
+  };
+  for (const f of files) {
+    result[f.source].push(f);
+  }
+  return result;
+}
+function toFull(partial) {
+  return { ...emptyConfig(), ...partial };
+}
+function deduplicateByName(items) {
+  const seen = /* @__PURE__ */ new Set();
+  return items.filter((item) => {
+    if (seen.has(item.name)) return false;
+    seen.add(item.name);
+    return true;
+  });
+}
+function hasContent(config) {
+  return config.directives.length > 0 || config.skills.length > 0 || config.agents.length > 0 || config.toolServers.length > 0 || config.hooks.length > 0 || config.permissions.length > 0 || config.settings.length > 0 || config.ignorePatterns.length > 0;
+}
+
+// src/commands/import.ts
+async function runImportCommand(projectDir, options) {
+  if (isTTY()) {
+    await interactiveImport(projectDir, options);
+  } else {
+    await nonInteractiveImport(projectDir, options);
+  }
+}
+async function interactiveImport(projectDir, options) {
+  intro("ai-dot import \u2014 detect and import existing configs");
+  const detected = await scanForConfigs(projectDir);
+  const filtered = options?.source ? detected.filter((f) => f.source === options.source) : detected;
+  if (filtered.length === 0) {
+    outro("No existing config files found.");
+    return;
+  }
+  const result = await runImport(projectDir, {
+    interactive: true,
+    sourceFilter: options?.source,
+    selectFiles: async (files) => {
+      const selected = cancelGuard(
+        await multiselect({
+          message: "Select files to import:",
+          options: files.map((f) => ({
+            value: f.relativePath,
+            label: f.label,
+            hint: f.source
+          })),
+          required: true
+        })
+      );
+      return files.filter((f) => selected.includes(f.relativePath));
+    }
+  });
+  if (result.imported.length === 0) {
+    outro("Nothing imported.");
+    return;
+  }
+  console.log(`
+  \x1B[32m\u2713\x1B[0m Imported ${result.imported.length} file(s):`);
+  for (const f of result.imported) {
+    console.log(`    ${f.label}`);
+  }
+  console.log(`
+  Wrote ${result.filesWritten.length} file(s) to .ai/`);
+  outro("Run ai-dot sync to generate tool configs from imported settings.");
+}
+async function nonInteractiveImport(projectDir, options) {
+  const result = await runImport(projectDir, {
+    interactive: false,
+    sourceFilter: options?.source
+  });
+  if (result.detected.length === 0) {
+    console.log("No existing config files found.");
+    return;
+  }
+  if (result.imported.length === 0) {
+    console.log("No files to import.");
+    return;
+  }
+  console.log(`\x1B[32m\u2713\x1B[0m Imported ${result.imported.length} file(s):`);
+  for (const f of result.imported) {
+    console.log(`  ${f.label}`);
+  }
+  console.log(`
+Wrote ${result.filesWritten.length} file(s) to .ai/`);
+  console.log("\nNext: run \x1B[1mai-dot sync\x1B[0m to generate tool configs.");
+}
+
+// src/commands/init.ts
+import { existsSync as existsSync2 } from "fs";
+import { join as join12 } from "path";
+
+// src/templates/blank.ts
+function blankTemplate() {
+  return emptyConfig();
+}
+
+// src/templates/minimal.ts
+function minimalTemplate() {
+  return {
+    directives: [
+      {
+        content: "# Project Conventions\n\n- Follow existing code style and patterns\n- Write clear, descriptive commit messages\n- Keep functions focused and small\n- Add comments only where the logic isn't self-evident",
+        scope: "project",
+        alwaysApply: true,
+        description: "conventions"
+      }
+    ],
+    skills: [],
+    agents: [],
+    toolServers: [],
+    hooks: [],
+    permissions: [],
+    settings: [],
+    ignorePatterns: [
+      { pattern: "node_modules/**", scope: "project" },
+      { pattern: "dist/**", scope: "project" },
+      { pattern: ".env", scope: "project" },
+      { pattern: ".env.*", scope: "project" }
+    ]
+  };
+}
+
+// src/templates/monorepo.ts
+function monorepoTemplate() {
+  return {
+    directives: [
+      {
+        content: "# Monorepo Conventions\n\n- Each package lives in its own directory under `packages/` or `apps/`\n- Changes to shared packages require careful review of downstream consumers\n- Prefer workspace-level dependencies; hoist shared deps to the root\n- Each package must have its own README, tests, and build script\n- Cross-package imports must go through published package names, not relative paths",
+        scope: "project",
+        alwaysApply: true,
+        description: "monorepo-conventions"
+      },
+      {
+        content: "# Code Review Guidelines\n\n- All changes need at least one approval before merging\n- Review for correctness, readability, and maintainability\n- Check that changes don't break other packages in the workspace\n- Verify that new dependencies are justified and properly scoped",
+        scope: "project",
+        alwaysApply: true,
+        description: "code-review"
+      }
+    ],
+    skills: [],
+    agents: [
+      {
+        name: "reviewer",
+        description: "Reviews code changes for quality and cross-package impact",
+        instructions: "You are a code reviewer for a monorepo. When reviewing changes:\n\n1. Check if the change affects shared packages and identify downstream consumers\n2. Verify that cross-package dependencies are properly declared\n3. Ensure tests cover the change adequately\n4. Flag any breaking changes to package APIs\n5. Check for consistent coding patterns across the monorepo",
+        readonly: true
+      }
+    ],
+    toolServers: [],
+    hooks: [],
+    permissions: [
+      { tool: "Bash", pattern: "npm *", decision: "allow", scope: "project" },
+      { tool: "Bash", pattern: "pnpm *", decision: "allow", scope: "project" },
+      { tool: "Bash", pattern: "yarn *", decision: "allow", scope: "project" },
+      { tool: "Bash", pattern: "turbo *", decision: "allow", scope: "project" }
+    ],
+    settings: [],
+    ignorePatterns: [
+      { pattern: "node_modules/**", scope: "project" },
+      { pattern: "dist/**", scope: "project" },
+      { pattern: "build/**", scope: "project" },
+      { pattern: ".env", scope: "project" },
+      { pattern: ".env.*", scope: "project" },
+      { pattern: ".turbo/**", scope: "project" }
+    ]
+  };
+}
+
+// src/templates/python.ts
+function pythonTemplate() {
+  return {
+    directives: [
+      {
+        content: "# Python Conventions\n\n- Use type hints for all function signatures\n- Follow PEP 8 style guidelines\n- Use `ruff` or `black` for formatting\n- Prefer f-strings over `.format()` or `%` formatting\n- Use `pathlib.Path` instead of `os.path` for file operations\n- Use dataclasses or Pydantic models for structured data",
+        scope: "project",
+        alwaysApply: true,
+        description: "python-conventions"
+      },
+      {
+        content: "# Docstring Conventions\n\n- Write docstrings for all public modules, classes, and functions\n- Use Google-style docstrings\n- Include Args, Returns, and Raises sections as applicable\n- Keep the first line as a concise summary",
+        scope: "project",
+        alwaysApply: true,
+        description: "docstrings"
+      },
+      {
+        content: "# Testing Rules\n\n- Write tests using pytest\n- Use descriptive test names: `test_<what>_<condition>_<expected>`\n- Use fixtures for shared setup\n- Mock external services, not internal logic\n- Aim for high coverage on business logic",
+        scope: "project",
+        alwaysApply: true,
+        description: "testing"
+      }
+    ],
+    skills: [],
+    agents: [],
+    toolServers: [],
+    hooks: [],
+    permissions: [
+      { tool: "Bash", pattern: "python *", decision: "allow", scope: "project" },
+      { tool: "Bash", pattern: "pip *", decision: "allow", scope: "project" },
+      { tool: "Bash", pattern: "pytest *", decision: "allow", scope: "project" }
+    ],
+    settings: [],
+    ignorePatterns: [
+      { pattern: "__pycache__/**", scope: "project" },
+      { pattern: ".venv/**", scope: "project" },
+      { pattern: "*.pyc", scope: "project" },
+      { pattern: ".env", scope: "project" },
+      { pattern: "dist/**", scope: "project" },
+      { pattern: "*.egg-info/**", scope: "project" }
+    ]
+  };
+}
+
+// src/templates/web.ts
+function webTemplate() {
+  return {
+    directives: [
+      {
+        content: "# TypeScript Conventions\n\n- Use strict TypeScript \u2014 avoid `any`, prefer explicit types\n- Prefer `const` over `let`; never use `var`\n- Use ES modules (`import`/`export`), not CommonJS\n- Prefer async/await over raw promises\n- Use template literals over string concatenation\n- Destructure objects and arrays where it improves readability",
+        scope: "project",
+        alwaysApply: true,
+        description: "typescript-conventions"
+      },
+      {
+        content: "# Testing Rules\n\n- Write tests for all new functionality\n- Use descriptive test names that explain the expected behavior\n- Prefer unit tests; use integration tests for cross-boundary flows\n- Mock external dependencies, not internal modules\n- Each test should test one thing",
+        scope: "project",
+        alwaysApply: true,
+        description: "testing"
+      },
+      {
+        content: "# Security Guidelines\n\n- Never hardcode secrets, tokens, or credentials\n- Validate and sanitize all user input\n- Use parameterized queries for database operations\n- Escape output to prevent XSS\n- Follow the principle of least privilege for permissions and access",
+        scope: "project",
+        alwaysApply: true,
+        description: "security"
+      }
+    ],
+    skills: [],
+    agents: [],
+    toolServers: [
+      {
+        name: "filesystem",
+        transport: "stdio",
+        command: "npx",
+        args: ["-y", "@modelcontextprotocol/server-filesystem", "."],
+        scope: "project"
+      }
+    ],
+    hooks: [],
+    permissions: [
+      { tool: "Bash", pattern: "npm *", decision: "allow", scope: "project" },
+      { tool: "Bash", pattern: "npx *", decision: "allow", scope: "project" }
+    ],
+    settings: [],
+    ignorePatterns: [
+      { pattern: "node_modules/**", scope: "project" },
+      { pattern: "dist/**", scope: "project" },
+      { pattern: "build/**", scope: "project" },
+      { pattern: ".env", scope: "project" },
+      { pattern: ".env.*", scope: "project" },
+      { pattern: "*.min.js", scope: "project" }
+    ]
+  };
+}
+
+// src/templates/index.ts
+var TEMPLATES = [
+  {
+    name: "minimal",
+    label: "Minimal",
+    description: "Conventions + common ignore patterns",
+    factory: minimalTemplate
+  },
+  {
+    name: "web",
+    label: "Web / TypeScript",
+    description: "TypeScript conventions, testing, security, MCP server",
+    factory: webTemplate
+  },
+  {
+    name: "python",
+    label: "Python",
+    description: "Formatting, typing, docstrings, pytest conventions",
+    factory: pythonTemplate
+  },
+  {
+    name: "monorepo",
+    label: "Monorepo",
+    description: "Workspace-aware conventions, reviewer agent",
+    factory: monorepoTemplate
+  },
+  {
+    name: "blank",
+    label: "Blank",
+    description: "Empty config skeleton",
+    factory: blankTemplate
+  }
+];
+function getTemplate(name) {
+  const template = TEMPLATES.find((t) => t.name === name);
+  if (!template) {
+    throw new Error(`Unknown template: ${name}`);
+  }
+  return template.factory();
+}
+var TEMPLATE_NAMES = TEMPLATES.map((t) => t.name);
+
+// src/commands/sync.ts
+import { mkdir as mkdir3, writeFile as writeFile4 } from "fs/promises";
+import { homedir as homedir3 } from "os";
+import { dirname, join as join11 } from "path";
+
+// src/emitters/agents.ts
+var agentsEmitter = {
+  emit(config, target) {
+    switch (target) {
+      case "claude":
+        return emitClaudeAgents(config.agents);
+      case "cursor":
+        return emitCursorAgents(config.agents);
+      case "codex":
+        return emitCodexAgents(config.agents);
+      case "opencode":
+        return emitOpenCodeAgents(config.agents);
+      case "copilot":
+        return emitCopilotAgents(config.agents);
+      case "antigravity":
+        return emitAntigravityAgents(config.agents);
+    }
+  }
+};
+function emitClaudeAgents(agents) {
+  const files = [];
+  for (const agent of agents) {
+    files.push({
+      path: `.claude/agents/${agent.name}.md`,
+      content: `${agent.instructions}
+`
+    });
+  }
+  return { files, warnings: [] };
+}
+function emitCursorAgents(agents) {
+  const files = [];
+  for (const agent of agents) {
+    const frontmatter = [];
+    if (agent.description) frontmatter.push(`description: ${agent.description}`);
+    if (agent.model) frontmatter.push(`model: ${agent.model}`);
+    if (agent.readonly) frontmatter.push(`readonly: true`);
+    if (agent.tools?.length) frontmatter.push(`tools: [${agent.tools.join(", ")}]`);
+    const header = frontmatter.length > 0 ? `---
+${frontmatter.join("\n")}
+---
+
+` : "";
+    files.push({
+      path: `.cursor/agents/${agent.name}.md`,
+      content: `${header}${agent.instructions}
+`
+    });
+  }
+  return { files, warnings: [] };
+}
+function emitCodexAgents(agents) {
+  const files = [];
+  const warnings = [];
+  if (agents.length === 0) return { files, warnings };
+  const sections = agents.map((a) => {
+    const meta = [];
+    if (a.model) meta.push(`Model: ${a.model}`);
+    if (a.readonly) meta.push("Read-only access");
+    if (a.tools?.length) meta.push(`Tools: ${a.tools.join(", ")}`);
+    const metaBlock = meta.length > 0 ? `
+
+> ${meta.join(" | ")}` : "";
+    return `## Agent: ${a.name}
+
+${a.description ? `${a.description}
+
+` : ""}${a.instructions}${metaBlock}`;
+  });
+  files.push({
+    path: "AGENTS.md",
+    content: `# Agents
+
+${sections.join("\n\n---\n\n")}
+`
+  });
+  if (agents.some((a) => a.tools?.length)) {
+    warnings.push(
+      "Codex does not support per-agent tool restrictions \u2014 tools listed as notes only."
+    );
+  }
+  return { files, warnings };
+}
+var COPILOT_TOOL_MAP = {
+  Read: "read",
+  Write: "edit",
+  Edit: "edit",
+  Bash: "execute",
+  Shell: "execute",
+  Search: "search",
+  WebSearch: "web",
+  WebFetch: "web"
+};
+function emitCopilotAgents(agents) {
+  const files = [];
+  const warnings = [];
+  for (const agent of agents) {
+    const frontmatter = [];
+    frontmatter.push(`description: ${agent.description || agent.name}`);
+    if (agent.readonly) {
+      frontmatter.push(`tools: [read, search]`);
+    } else if (agent.tools?.length) {
+      const mapped = [
+        ...new Set(
+          agent.tools.map((t) => {
+            const alias = COPILOT_TOOL_MAP[t];
+            if (!alias) {
+              warnings.push(
+                `Unknown tool "${t}" for Copilot agent "${agent.name}" \u2014 passed through as-is.`
+              );
+              return t.toLowerCase();
+            }
+            return alias;
+          })
+        )
+      ];
+      frontmatter.push(`tools: [${mapped.join(", ")}]`);
+    }
+    if (agent.model) {
+      warnings.push(
+        `Copilot agents do not support model override in file config \u2014 model "${agent.model}" on agent "${agent.name}" is ignored.`
+      );
+    }
+    const header = `---
+${frontmatter.join("\n")}
+---
+
+`;
+    files.push({
+      path: `.github/agents/${agent.name}.agent.md`,
+      content: `${header}${agent.instructions}
+`
+    });
+  }
+  return { files, warnings };
+}
+function emitOpenCodeAgents(agents) {
+  const files = [];
+  for (const agent of agents) {
+    const frontmatter = [];
+    if (agent.description) frontmatter.push(`description: ${agent.description}`);
+    if (agent.mode) frontmatter.push(`mode: ${agent.mode}`);
+    if (agent.model) frontmatter.push(`model: ${agent.model}`);
+    if (agent.temperature !== void 0) frontmatter.push(`temperature: ${agent.temperature}`);
+    if (agent.topP !== void 0) frontmatter.push(`top_p: ${agent.topP}`);
+    if (agent.steps !== void 0) frontmatter.push(`steps: ${agent.steps}`);
+    if (agent.color) frontmatter.push(`color: ${agent.color}`);
+    if (agent.hidden) frontmatter.push(`hidden: true`);
+    if (agent.disabled) frontmatter.push(`disable: true`);
+    if (agent.readonly) {
+      frontmatter.push(`tools:`);
+      frontmatter.push(`  write: false`);
+      frontmatter.push(`  bash: false`);
+    }
+    const header = frontmatter.length > 0 ? `---
+${frontmatter.join("\n")}
+---
+
+` : "";
+    files.push({
+      path: `.opencode/agents/${agent.name}.md`,
+      content: `${header}${agent.instructions}
+`
+    });
+  }
+  return { files, warnings: [] };
+}
+function emitAntigravityAgents(agents) {
+  const warnings = [];
+  if (agents.length > 0) {
+    warnings.push(
+      "Antigravity does not support file-based agent configuration \u2014 agents are skipped."
+    );
+  }
+  return { files: [], warnings };
+}
+
+// src/emitters/directives.ts
+var directivesEmitter = {
+  emit(config, target) {
+    switch (target) {
+      case "claude":
+        return emitClaude(config.directives);
+      case "cursor":
+        return emitCursor(config.directives);
+      case "codex":
+        return emitCodex(config.directives);
+      case "opencode":
+        return emitOpenCode(config.directives);
+      case "copilot":
+        return emitCopilot(config.directives);
+      case "antigravity":
+        return emitAntigravity(config.directives);
+    }
+  }
+};
+function emitClaude(directives) {
+  const files = [];
+  const warnings = [];
+  const alwaysApply = directives.filter((d) => d.alwaysApply && !d.appliesTo?.length);
+  const scoped = directives.filter((d) => !d.alwaysApply || d.appliesTo?.length);
+  if (alwaysApply.length > 0) {
+    const sections = alwaysApply.map((d) => d.content);
+    files.push({
+      path: "CLAUDE.md",
+      content: `${sections.join("\n\n---\n\n")}
+`
+    });
+  }
+  for (const directive of scoped) {
+    const name = slugify2(directive.description || "rule");
+    let content = directive.content;
+    if (directive.appliesTo?.length) {
+      const globs = directive.appliesTo.join(", ");
+      content = `<!-- applies to: ${globs} -->
+
+${content}`;
+    }
+    files.push({
+      path: `.claude/rules/${name}.md`,
+      content: `${content}
+`
+    });
+  }
+  return { files, warnings };
+}
+function emitCursor(directives) {
+  const files = [];
+  const warnings = [];
+  for (const directive of directives) {
+    const name = slugify2(directive.description || "rule");
+    const frontmatter = [];
+    if (directive.description) {
+      frontmatter.push(`description: ${directive.description}`);
+    }
+    if (directive.appliesTo?.length) {
+      frontmatter.push(`globs: ${directive.appliesTo.join(", ")}`);
+    }
+    frontmatter.push(`alwaysApply: ${directive.alwaysApply}`);
+    const header = `---
+${frontmatter.join("\n")}
+---`;
+    files.push({
+      path: `.cursor/rules/${name}.mdc`,
+      content: `${header}
+
+${directive.content}
+`
+    });
+  }
+  return { files, warnings };
+}
+function emitCodex(directives) {
+  const files = [];
+  const warnings = [];
+  if (directives.length === 0) return { files, warnings };
+  const sections = directives.map((d) => {
+    const header = d.description ? `## ${d.description}` : "## Directive";
+    const scopeNote = d.appliesTo?.length ? `
+
+> Applies to: ${d.appliesTo.join(", ")}` : "";
+    return `${header}${scopeNote}
+
+${d.content}`;
+  });
+  files.push({
+    path: "AGENTS.md",
+    content: `# Project Instructions
+
+${sections.join("\n\n---\n\n")}
+`
+  });
+  if (directives.some((d) => d.appliesTo?.length)) {
+    warnings.push(
+      "Codex AGENTS.md does not support file-scoped directives \u2014 appliesTo patterns are included as notes but not enforced."
+    );
+  }
+  return { files, warnings };
+}
+function emitOpenCode(directives) {
+  const files = [];
+  const warnings = [];
+  if (directives.length === 0) return { files, warnings };
+  const paths = [];
+  for (const directive of directives) {
+    const name = slugify2(directive.description || "rule");
+    let content = directive.content;
+    if (directive.appliesTo?.length) {
+      content = `<!-- applies to: ${directive.appliesTo.join(", ")} -->
+
+${content}`;
+    }
+    const relPath = `.opencode/instructions/${name}.md`;
+    files.push({ path: relPath, content: `${content}
+` });
+    paths.push(relPath);
+  }
+  files.push({
+    path: "opencode.json",
+    content: `${JSON.stringify({ instructions: paths }, null, 2)}
+`
+  });
+  if (directives.some((d) => d.appliesTo?.length)) {
+    warnings.push(
+      "OpenCode does not support file-scoped directives \u2014 appliesTo patterns are included as comments but not enforced."
+    );
+  }
+  return { files, warnings };
+}
+function emitCopilot(directives) {
+  const files = [];
+  const warnings = [];
+  const repoWide = directives.filter((d) => d.alwaysApply && !d.appliesTo?.length);
+  const scoped = directives.filter((d) => !d.alwaysApply || (d.appliesTo?.length ?? 0) > 0);
+  if (repoWide.length > 0) {
+    const sections = repoWide.map((d) => d.content);
+    files.push({
+      path: ".github/copilot-instructions.md",
+      content: `${sections.join("\n\n---\n\n")}
+`
+    });
+  }
+  for (const directive of scoped) {
+    const name = slugify2(directive.description || "rule");
+    let content = directive.content;
+    if (directive.appliesTo?.length) {
+      const applyTo = directive.appliesTo.join(",");
+      content = `---
+applyTo: "${applyTo}"
+---
+
+${content}`;
+    }
+    files.push({
+      path: `.github/instructions/${name}.instructions.md`,
+      content: `${content}
+`
+    });
+  }
+  return { files, warnings };
+}
+function emitAntigravity(directives) {
+  const files = [];
+  const warnings = [];
+  for (const directive of directives) {
+    const name = slugify2(directive.description || "rule");
+    const frontmatter = [];
+    if (directive.description) {
+      frontmatter.push(`description: ${directive.description}`);
+    }
+    if (directive.alwaysApply && directive.appliesTo?.length) {
+      frontmatter.push(`globs:`);
+      for (const glob of directive.appliesTo) {
+        frontmatter.push(`  - "${glob}"`);
+      }
+    } else if (directive.alwaysApply) {
+      frontmatter.push(`alwaysApply: true`);
+    } else if (!directive.appliesTo?.length) {
+      frontmatter.push(`alwaysApply: false`);
+    } else {
+      frontmatter.push(`globs:`);
+      for (const glob of directive.appliesTo) {
+        frontmatter.push(`  - "${glob}"`);
+      }
+    }
+    const header = `---
+${frontmatter.join("\n")}
+---`;
+    files.push({
+      path: `.agent/rules/${name}.md`,
+      content: `${header}
+
+${directive.content}
+`
+    });
+  }
+  return { files, warnings };
+}
+function slugify2(str) {
+  return str.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+}
+
+// src/emitters/hooks.ts
+var hooksEmitter = {
+  emit(config, target) {
+    switch (target) {
+      case "claude":
+        return emitClaude2(config.hooks, config.ignorePatterns);
+      case "cursor":
+        return emitCursor2(config.hooks, config.ignorePatterns);
+      case "codex":
+        return emitCodex2(config.hooks, config.ignorePatterns);
+      case "opencode":
+        return emitOpenCode2(config.hooks, config.ignorePatterns);
+      case "copilot":
+        return emitCopilot2(config.hooks, config.ignorePatterns);
+      case "antigravity":
+        return emitAntigravity2(config.hooks, config.ignorePatterns);
+    }
+  }
+};
+function emitClaude2(hooks, ignorePatterns) {
+  const files = [];
+  const warnings = [];
+  if (hooks.length === 0 && ignorePatterns.length === 0) return { files, warnings };
+  const settings = {};
+  if (hooks.length > 0) {
+    const hooksObj = {};
+    for (const hook of hooks) {
+      if (!hooksObj[hook.event]) hooksObj[hook.event] = [];
+      const entry = { command: hook.handler };
+      if (hook.matcher) entry.matcher = hook.matcher;
+      hooksObj[hook.event].push(entry);
+    }
+    settings.hooks = hooksObj;
+  }
+  if (ignorePatterns.length > 0) {
+    const deny = ignorePatterns.flatMap((p) => [`Read(${p.pattern})`, `Edit(${p.pattern})`]);
+    settings.permissions = { deny };
+  }
+  files.push({
+    path: ".claude/settings.json",
+    content: `${JSON.stringify(settings, null, 2)}
+`
+  });
+  return { files, warnings };
+}
+function emitCursor2(hooks, ignorePatterns) {
+  const files = [];
+  const warnings = [];
+  if (ignorePatterns.length > 0) {
+    const lines = [
+      "# Generated by ai-dot",
+      "# File exclusion rules for Cursor AI",
+      "",
+      ...ignorePatterns.map((p) => p.pattern),
+      ""
+    ];
+    files.push({
+      path: ".cursorignore",
+      content: lines.join("\n")
+    });
+  }
+  if (hooks.length > 0) {
+    warnings.push(
+      "Cursor hook support is limited \u2014 hooks are not directly emitted to Cursor config."
+    );
+  }
+  return { files, warnings };
+}
+function emitCodex2(hooks, ignorePatterns) {
+  const files = [];
+  const warnings = [];
+  if (ignorePatterns.length > 0) {
+    const paths = ignorePatterns.map((p) => `"${p.pattern}"`).join(", ");
+    files.push({
+      path: ".codex/config.toml",
+      content: `protected_paths = [${paths}]
+`
+    });
+  }
+  if (hooks.length > 0) {
+    warnings.push("Codex does not support hooks \u2014 hook configuration is skipped.");
+  }
+  return { files, warnings };
+}
+function emitOpenCode2(hooks, ignorePatterns) {
+  const files = [];
+  const warnings = [];
+  if (ignorePatterns.length > 0) {
+    const ignore = ignorePatterns.map((p) => p.pattern);
+    files.push({
+      path: "opencode.json",
+      content: `${JSON.stringify({ watcher: { ignore } }, null, 2)}
+`
+    });
+  }
+  if (hooks.length > 0) {
+    warnings.push("OpenCode does not support lifecycle hooks \u2014 hook configuration is skipped.");
+  }
+  return { files, warnings };
+}
+var COPILOT_HOOK_EVENTS = /* @__PURE__ */ new Set([
+  "preToolUse",
+  "postToolUse",
+  "sessionStart",
+  "sessionEnd",
+  "userPromptSubmitted",
+  "agentStop",
+  "subagentStop",
+  "errorOccurred"
+]);
+function emitCopilot2(hooks, ignorePatterns) {
+  const files = [];
+  const warnings = [];
+  if (hooks.length > 0) {
+    const hooksObj = {};
+    for (const hook of hooks) {
+      if (!COPILOT_HOOK_EVENTS.has(hook.event)) {
+        warnings.push(`Hook event "${hook.event}" is not supported by Copilot \u2014 skipped.`);
+        continue;
+      }
+      if (!hooksObj[hook.event]) hooksObj[hook.event] = [];
+      const entry = { command: hook.handler };
+      if (hook.matcher) entry.matcher = hook.matcher;
+      hooksObj[hook.event].push(entry);
+    }
+    if (Object.keys(hooksObj).length > 0) {
+      files.push({
+        path: ".github/hooks/ai-dot.hooks.json",
+        content: `${JSON.stringify({ hooks: hooksObj }, null, 2)}
+`
+      });
+    }
+  }
+  if (ignorePatterns.length > 0) {
+    warnings.push(
+      "Copilot does not support file-based ignore patterns \u2014 ignore configuration is skipped."
+    );
+  }
+  return { files, warnings };
+}
+function emitAntigravity2(hooks, ignorePatterns) {
+  const warnings = [];
+  if (hooks.length > 0) {
+    warnings.push("Antigravity does not support hooks \u2014 hook configuration is skipped.");
+  }
+  if (ignorePatterns.length > 0) {
+    warnings.push(
+      "Antigravity does not support file-based ignore patterns \u2014 ignore configuration is skipped."
+    );
+  }
+  return { files: [], warnings };
+}
+
+// src/emitters/mcp.ts
+var mcpEmitter = {
+  emit(config, target) {
+    switch (target) {
+      case "claude":
+        return emitClaudeMcp(config.toolServers);
+      case "cursor":
+        return emitCursorMcp(config.toolServers);
+      case "codex":
+        return emitCodexMcp(config.toolServers);
+      case "opencode":
+        return emitOpenCodeMcp(config.toolServers);
+      case "copilot":
+        return emitCopilotMcp(config.toolServers);
+      case "antigravity":
+        return emitAntigravityMcp(config.toolServers);
+    }
+  }
+};
+function emitClaudeMcp(servers) {
+  const files = [];
+  const warnings = [];
+  if (servers.length === 0) return { files, warnings };
+  const mcpServers = {};
+  for (const server of servers) {
+    mcpServers[server.name] = buildMcpEntry(server);
+  }
+  files.push({
+    path: ".mcp.json",
+    content: `${JSON.stringify({ mcpServers }, null, 2)}
+`
+  });
+  return { files, warnings };
+}
+function emitCursorMcp(servers) {
+  const files = [];
+  const warnings = [];
+  if (servers.length === 0) return { files, warnings };
+  const mcpServers = {};
+  for (const server of servers) {
+    mcpServers[server.name] = buildMcpEntry(server);
+  }
+  files.push({
+    path: ".cursor/mcp.json",
+    content: `${JSON.stringify({ mcpServers }, null, 2)}
+`
+  });
+  return { files, warnings };
+}
+function emitCodexMcp(servers) {
+  const files = [];
+  const warnings = [];
+  if (servers.length === 0) return { files, warnings };
+  const sections = [];
+  for (const server of servers) {
+    sections.push(buildTomlSection(server));
+  }
+  files.push({
+    path: ".codex/config.toml",
+    content: `${sections.join("\n\n")}
+`
+  });
+  if (servers.some((s) => s.enabledTools?.length || s.disabledTools?.length)) {
+    warnings.push(
+      "Codex config.toml does not support enabledTools/disabledTools filtering for MCP servers."
+    );
+  }
+  return { files, warnings };
+}
+function emitCopilotMcp(servers) {
+  const files = [];
+  const warnings = [];
+  if (servers.length === 0) return { files, warnings };
+  const mcpServers = {};
+  for (const server of servers) {
+    const entry = buildMcpEntry(server);
+    if (!entry.type) {
+      entry.type = "stdio";
+    }
+    mcpServers[server.name] = entry;
+  }
+  files.push({
+    path: ".vscode/mcp.json",
+    content: `${JSON.stringify({ mcpServers }, null, 2)}
+`
+  });
+  warnings.push(
+    "Copilot coding agent MCP must be configured in GitHub repo settings separately \u2014 .vscode/mcp.json is for VS Code Copilot Chat only."
+  );
+  return { files, warnings };
+}
+function buildMcpEntry(server) {
+  const entry = {};
+  if (server.transport === "stdio") {
+    entry.command = server.command;
+    if (server.args?.length) entry.args = server.args;
+  } else {
+    entry.type = server.transport;
+    entry.url = server.url;
+  }
+  if (server.env && Object.keys(server.env).length > 0) {
+    entry.env = server.env;
+  }
+  return entry;
+}
+function buildTomlSection(server) {
+  const lines = [`[mcp_servers.${server.name}]`];
+  if (server.transport === "stdio") {
+    lines.push(`type = "stdio"`);
+    if (server.command) lines.push(`command = ${tomlString(server.command)}`);
+    if (server.args?.length) {
+      lines.push(`args = [${server.args.map(tomlString).join(", ")}]`);
+    }
+  } else {
+    lines.push(`type = ${tomlString(server.transport)}`);
+    if (server.url) lines.push(`url = ${tomlString(server.url)}`);
+  }
+  if (server.env && Object.keys(server.env).length > 0) {
+    lines.push("");
+    lines.push(`[mcp_servers.${server.name}.env]`);
+    for (const [key, value] of Object.entries(server.env)) {
+      lines.push(`${key} = ${tomlString(value)}`);
+    }
+  }
+  return lines.join("\n");
+}
+function emitOpenCodeMcp(servers) {
+  const files = [];
+  const warnings = [];
+  if (servers.length === 0) return { files, warnings };
+  const mcp = {};
+  for (const server of servers) {
+    const entry = {};
+    if (server.transport === "stdio") {
+      entry.type = "stdio";
+      entry.command = server.command;
+      if (server.args?.length) entry.args = server.args;
+    } else {
+      entry.type = "remote";
+      entry.url = server.url;
+    }
+    if (server.env && Object.keys(server.env).length > 0) {
+      entry.env = server.env;
+    }
+    mcp[server.name] = entry;
+  }
+  files.push({
+    path: "opencode.json",
+    content: `${JSON.stringify({ mcp }, null, 2)}
+`
+  });
+  if (servers.some((s) => s.enabledTools?.length || s.disabledTools?.length)) {
+    warnings.push(
+      "OpenCode does not support enabledTools/disabledTools filtering for MCP servers."
+    );
+  }
+  return { files, warnings };
+}
+function emitAntigravityMcp(servers) {
+  const files = [];
+  const warnings = [];
+  if (servers.length === 0) return { files, warnings };
+  const mcpServers = {};
+  for (const server of servers) {
+    mcpServers[server.name] = buildMcpEntry(server);
+  }
+  files.push({
+    path: "mcp_config.json",
+    content: `${JSON.stringify({ mcpServers }, null, 2)}
+`
+  });
+  if (servers.some((s) => s.enabledTools?.length || s.disabledTools?.length)) {
+    warnings.push(
+      "Antigravity does not support enabledTools/disabledTools filtering for MCP servers."
+    );
+  }
+  return { files, warnings };
+}
+function tomlString(s) {
+  return `"${s.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+}
+
+// src/emitters/permissions.ts
+var permissionsEmitter = {
+  emit(config, target) {
+    switch (target) {
+      case "claude":
+        return emitClaude3(config.permissions, config.settings);
+      case "cursor":
+        return emitCursor3(config.permissions, config.settings);
+      case "codex":
+        return emitCodex3(config.permissions, config.settings);
+      case "opencode":
+        return emitOpenCode3(config.permissions, config.settings);
+      case "copilot":
+        return emitCopilot3(config.permissions, config.settings);
+      case "antigravity":
+        return emitAntigravity3(config.permissions, config.settings);
+    }
+  }
+};
+function emitClaude3(permissions, settings) {
+  const files = [];
+  const warnings = [];
+  if (permissions.length === 0 && settings.length === 0) return { files, warnings };
+  const settingsObj = {};
+  if (permissions.length > 0) {
+    const allow = [];
+    const deny = [];
+    for (const perm of permissions) {
+      const rule = perm.pattern ? `${perm.tool}(${perm.pattern})` : perm.tool;
+      if (perm.decision === "allow") allow.push(rule);
+      else if (perm.decision === "deny") deny.push(rule);
+    }
+    const permsObj = {};
+    if (allow.length > 0) permsObj.allow = allow;
+    if (deny.length > 0) permsObj.deny = deny;
+    settingsObj.permissions = permsObj;
+    if (permissions.some((p) => p.decision === "ask")) {
+      warnings.push(
+        'Claude Code does not support "ask" permission decision \u2014 these rules are omitted.'
+      );
+    }
+  }
+  for (const setting of settings) {
+    settingsObj[setting.key] = setting.value;
+  }
+  files.push({
+    path: ".claude/settings.json",
+    content: `${JSON.stringify(settingsObj, null, 2)}
+`
+  });
+  return { files, warnings };
+}
+function emitCursor3(permissions, settings) {
+  const files = [];
+  const warnings = [];
+  if (permissions.length === 0 && settings.length === 0) return { files, warnings };
+  const cliConfig = {};
+  if (permissions.length > 0) {
+    const allow = [];
+    const deny = [];
+    for (const perm of permissions) {
+      const rule = perm.pattern ? `${perm.tool}(${perm.pattern})` : perm.tool;
+      if (perm.decision === "allow") allow.push(rule);
+      else if (perm.decision === "deny") deny.push(rule);
+    }
+    const permsObj = {};
+    if (allow.length > 0) permsObj.allow = allow;
+    if (deny.length > 0) permsObj.deny = deny;
+    cliConfig.permissions = permsObj;
+  }
+  for (const setting of settings) {
+    cliConfig[setting.key] = setting.value;
+  }
+  files.push({
+    path: ".cursor/cli.json",
+    content: `${JSON.stringify(cliConfig, null, 2)}
+`
+  });
+  return { files, warnings };
+}
+function emitCodex3(permissions, settings) {
+  const files = [];
+  const warnings = [];
+  if (permissions.length === 0 && settings.length === 0) return { files, warnings };
+  const lines = [];
+  if (permissions.length > 0) {
+    const hasAllow = permissions.some((p) => p.decision === "allow");
+    const hasDeny = permissions.some((p) => p.decision === "deny");
+    if (hasAllow && !hasDeny) {
+      lines.push(`approval_policy = "unless-allowed"`);
+    } else if (hasDeny) {
+      lines.push(`approval_policy = "unless-allowed"`);
+    } else {
+      lines.push(`approval_policy = "on-failure"`);
+    }
+    warnings.push(
+      "Codex permissions are lossy \u2014 per-tool/pattern permissions are mapped to a single approval_policy."
+    );
+  }
+  for (const setting of settings) {
+    const value = typeof setting.value === "string" ? `"${setting.value}"` : String(setting.value);
+    lines.push(`${setting.key} = ${value}`);
+  }
+  files.push({
+    path: ".codex/config.toml",
+    content: `${lines.join("\n")}
+`
+  });
+  return { files, warnings };
+}
+function emitOpenCode3(permissions, settings) {
+  const files = [];
+  const warnings = [];
+  if (permissions.length === 0 && settings.length === 0) return { files, warnings };
+  const config = {};
+  if (permissions.length > 0) {
+    const permission = {};
+    for (const perm of permissions) {
+      if (perm.pattern) {
+        const toolKey = perm.tool.toLowerCase();
+        if (!permission[toolKey] || typeof permission[toolKey] !== "object") {
+          permission[toolKey] = {};
+        }
+        permission[toolKey][perm.pattern] = perm.decision;
+      } else {
+        permission[perm.tool.toLowerCase()] = perm.decision;
+      }
+    }
+    config.permission = permission;
+  }
+  for (const setting of settings) {
+    config[setting.key] = setting.value;
+  }
+  files.push({
+    path: "opencode.json",
+    content: `${JSON.stringify(config, null, 2)}
+`
+  });
+  return { files, warnings };
+}
+function emitCopilot3(permissions, settings) {
+  const warnings = [];
+  if (permissions.length > 0) {
+    warnings.push(
+      "Copilot does not support file-based permission configuration \u2014 permissions are skipped."
+    );
+  }
+  if (settings.length > 0) {
+    warnings.push(
+      "Copilot does not support file-based settings configuration \u2014 settings are skipped."
+    );
+  }
+  return { files: [], warnings };
+}
+function emitAntigravity3(permissions, settings) {
+  const warnings = [];
+  if (permissions.length > 0) {
+    warnings.push(
+      "Antigravity does not support file-based permission configuration \u2014 permissions are skipped."
+    );
+  }
+  if (settings.length > 0) {
+    warnings.push(
+      "Antigravity does not support file-based settings configuration \u2014 settings are skipped."
+    );
+  }
+  return { files: [], warnings };
+}
+
+// src/emitters/skills.ts
+var SKILLS_DIRS = {
+  claude: ".claude/skills",
+  cursor: ".cursor/skills",
+  codex: ".codex/skills",
+  opencode: ".opencode/skills",
+  copilot: ".github/skills",
+  antigravity: ".agent/skills"
+};
+var skillsEmitter = {
+  emit(config, target) {
+    const files = [];
+    const warnings = [];
+    const baseDir = SKILLS_DIRS[target];
+    for (const skill of config.skills) {
+      files.push({
+        path: `${baseDir}/${skill.name}/SKILL.md`,
+        content: skill.content
+      });
+    }
+    return { files, warnings };
+  }
+};
+
+// src/state.ts
+import { createHash } from "crypto";
+import { readFile as readFile9, writeFile as writeFile3 } from "fs/promises";
+import { join as join10 } from "path";
+var STATE_FILE = ".ai/.state.json";
+function contentHash(content) {
+  return createHash("sha256").update(content).digest("hex").slice(0, 16);
+}
+async function loadState(projectDir) {
+  try {
+    const raw = await readFile9(join10(projectDir, STATE_FILE), "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+async function saveState(projectDir, files) {
+  const state = {
+    lastSync: (/* @__PURE__ */ new Date()).toISOString(),
+    files: {}
+  };
+  for (const file of files) {
+    state.files[file.path] = contentHash(file.content);
+  }
+  await writeFile3(join10(projectDir, STATE_FILE), `${JSON.stringify(state, null, 2)}
+`, "utf-8");
+}
+async function diffFiles(projectDir, generated, state) {
+  const entries = [];
+  const seenPaths = /* @__PURE__ */ new Set();
+  for (const file of generated) {
+    seenPaths.add(file.path);
+    const generatedHash = contentHash(file.content);
+    let diskContent = null;
+    try {
+      diskContent = await readFile9(join10(projectDir, file.path), "utf-8");
+    } catch {
+    }
+    if (diskContent === null) {
+      entries.push({ path: file.path, status: "new" });
+      continue;
+    }
+    const diskHash = contentHash(diskContent);
+    const lastKnownHash = state?.files[file.path];
+    if (diskHash === generatedHash) {
+      entries.push({ path: file.path, status: "up-to-date" });
+    } else if (!lastKnownHash) {
+      entries.push({ path: file.path, status: "conflict" });
+    } else if (diskHash === lastKnownHash) {
+      entries.push({ path: file.path, status: "modified" });
+    } else {
+      entries.push({ path: file.path, status: "conflict" });
+    }
+  }
+  if (state) {
+    for (const path of Object.keys(state.files)) {
+      if (!seenPaths.has(path)) {
+        entries.push({ path, status: "orphaned" });
+      }
+    }
+  }
+  return entries;
+}
+
+// src/commands/sync.ts
+var USER_OUTPUT_DIRS = {
+  claude: join11(homedir3(), ".claude"),
+  cursor: join11(homedir3(), ".cursor"),
+  codex: join11(homedir3(), ".codex"),
+  opencode: join11(homedir3(), ".config", "opencode"),
+  copilot: join11(homedir3(), ".copilot"),
+  antigravity: join11(homedir3(), ".agent")
+};
+var EMITTERS = [
+  skillsEmitter,
+  directivesEmitter,
+  mcpEmitter,
+  agentsEmitter,
+  permissionsEmitter,
+  hooksEmitter
+];
+async function runSync(projectDir, options) {
+  const isUserScope = options.scope === "user";
+  const label = isUserScope ? "~/.ai/" : ".ai/";
+  console.log(`Loading config from ${label} ...`);
+  const { config, errors: loadErrors } = isUserScope ? await loadProjectConfig(join11(homedir3(), ".ai"), "user") : await loadMergedConfig(projectDir);
+  if (loadErrors.length > 0) {
+    console.error("\x1B[31mConfig errors:\x1B[0m");
+    for (const err of loadErrors) {
+      console.error(`  ${err.file}${err.line ? `:${err.line}` : ""}: ${err.message}`);
+    }
+    process.exitCode = 1;
+    return;
+  }
+  const { errors: valErrors } = validateConfig(config);
+  if (valErrors.length > 0) {
+    console.error("\x1B[31mValidation errors:\x1B[0m");
+    for (const err of valErrors) {
+      console.error(`  ${err.file}: ${err.message}`);
+    }
+    process.exitCode = 1;
+    return;
+  }
+  const targets = options.targets.length > 0 ? options.targets : [...ALL_TARGETS];
+  const perTarget = /* @__PURE__ */ new Map();
+  for (const target of targets) {
+    const targetFiles = [];
+    const targetWarnings = [];
+    for (const emitter of EMITTERS) {
+      const result = emitter.emit(config, target);
+      targetFiles.push(...result.files);
+      targetWarnings.push(...result.warnings);
+    }
+    perTarget.set(target, { files: targetFiles, warnings: targetWarnings });
+  }
+  const allFiles = [...perTarget.values()].flatMap((r) => r.files);
+  const allWarnings = [...perTarget.values()].flatMap((r) => r.warnings);
+  const mergedFiles = mergeFiles(allFiles);
+  if (allWarnings.length > 0) {
+    console.log("\x1B[33mWarnings:\x1B[0m");
+    for (const w of allWarnings) {
+      console.log(`  \u26A0 ${w}`);
+    }
+    console.log("");
+  }
+  if (!isUserScope && !options.force && !options.dryRun) {
+    const state = await loadState(projectDir);
+    const statuses = await diffFiles(projectDir, mergedFiles, state);
+    const conflicts = statuses.filter((s) => s.status === "conflict");
+    if (conflicts.length > 0) {
+      console.error("\x1B[31mConflicts detected (files manually edited since last sync):\x1B[0m");
+      for (const c of conflicts) {
+        console.error(`  ! ${c.path}`);
+      }
+      console.error("\nUse \x1B[1m--force\x1B[0m to overwrite, or manually resolve.");
+      process.exitCode = 1;
+      return;
+    }
+  }
+  if (options.dryRun) {
+    console.log("\x1B[36mDry run \u2014 files that would be written:\x1B[0m");
+    for (const file of mergedFiles) {
+      const outputPath = resolveOutputPath(file.path, isUserScope, projectDir, targets);
+      console.log(`  ${outputPath}`);
+    }
+  } else {
+    let filesToWrite = mergedFiles;
+    if (!options.yes && isTTY() && !isUserScope) {
+      const state = await loadState(projectDir);
+      const statuses = await diffFiles(projectDir, mergedFiles, state);
+      const changeCount = statuses.filter(
+        (s) => s.status !== "up-to-date" && s.status !== "orphaned"
+      ).length;
+      if (changeCount === 0) {
+        console.log("\x1B[32m\u2713\x1B[0m Everything is up-to-date.");
+        return;
+      }
+      printStatusTable(statuses, projectDir, isUserScope, targets);
+      const proceed = cancelGuard(
+        await confirm({
+          message: `Apply ${changeCount} change${changeCount === 1 ? "" : "s"}?`,
+          initialValue: true
+        })
+      );
+      if (!proceed) {
+        console.log("Sync cancelled.");
+        return;
+      }
+      const changePaths = new Set(
+        statuses.filter((s) => s.status !== "up-to-date").map((s) => s.path)
+      );
+      filesToWrite = mergedFiles.filter((f) => changePaths.has(f.path));
+    }
+    for (const file of filesToWrite) {
+      const fullPath = resolveOutputPath(file.path, isUserScope, projectDir, targets);
+      await mkdir3(dirname(fullPath), { recursive: true });
+      await writeFile4(fullPath, file.content, "utf-8");
+    }
+    if (!isUserScope) {
+      await saveState(projectDir, mergedFiles);
+    }
+    printSyncSummary(config, targets, perTarget, filesToWrite.length);
+  }
+}
+var TARGET_LABELS = {
+  claude: "Claude Code",
+  cursor: "Cursor",
+  codex: "Codex",
+  opencode: "OpenCode",
+  copilot: "GitHub Copilot",
+  antigravity: "Antigravity"
+};
+function countEntities(config) {
+  const counts = [];
+  if (config.directives.length > 0)
+    counts.push({ label: "directive", count: config.directives.length });
+  if (config.skills.length > 0) counts.push({ label: "skill", count: config.skills.length });
+  if (config.agents.length > 0) counts.push({ label: "agent", count: config.agents.length });
+  if (config.toolServers.length > 0)
+    counts.push({ label: "MCP server", count: config.toolServers.length });
+  if (config.permissions.length > 0)
+    counts.push({ label: "permission", count: config.permissions.length });
+  if (config.hooks.length > 0) counts.push({ label: "hook", count: config.hooks.length });
+  return counts;
+}
+function pluralize(count, singular) {
+  return `${count} ${singular}${count === 1 ? "" : "s"}`;
+}
+function printSyncSummary(config, targets, perTarget, filesWritten) {
+  const entities = countEntities(config);
+  console.log(
+    `\x1B[32m\u2713\x1B[0m Synced to ${targets.length} target${targets.length === 1 ? "" : "s"}`
+  );
+  console.log("");
+  const maxLabelLen = Math.max(...targets.map((t) => TARGET_LABELS[t].length));
+  for (const target of targets) {
+    const label = TARGET_LABELS[target].padEnd(maxLabelLen);
+    const result = perTarget.get(target);
+    const warnings = result?.warnings ?? [];
+    const targetEntities = entities.filter((e) => {
+      const unsupported = warnings.some(
+        (w) => w.toLowerCase().includes(e.label.toLowerCase()) && w.toLowerCase().includes("not support")
+      );
+      return !unsupported;
+    }).map((e) => pluralize(e.count, e.label));
+    const summary = targetEntities.length > 0 ? targetEntities.join(", ") : "no entities";
+    const warningNotes = warnings.filter((w) => w.toLowerCase().includes("not support")).map((w) => `\x1B[33m\u26A0 ${w}\x1B[0m`);
+    if (warningNotes.length > 0) {
+      console.log(`  ${label}  \u2014 ${summary}`);
+      for (const note of warningNotes) {
+        console.log(`  ${"".padEnd(maxLabelLen)}    ${note}`);
+      }
+    } else {
+      console.log(`  ${label}  \u2014 ${summary}`);
+    }
+  }
+  console.log("");
+  console.log(`  ${filesWritten} file${filesWritten === 1 ? "" : "s"} written.`);
+}
+function resolveOutputPath(relativePath, isUserScope, projectDir, _targets) {
+  if (!isUserScope) {
+    return join11(projectDir, relativePath);
+  }
+  for (const [tool, userDir] of Object.entries(USER_OUTPUT_DIRS)) {
+    const prefix = `.${tool}/`;
+    if (relativePath.startsWith(prefix)) {
+      return join11(userDir, relativePath.slice(prefix.length));
+    }
+  }
+  const copilotPrefixes = [".github/", ".vscode/"];
+  for (const prefix of copilotPrefixes) {
+    if (relativePath.startsWith(prefix)) {
+      return join11(USER_OUTPUT_DIRS.copilot, relativePath);
+    }
+  }
+  if (relativePath.startsWith(".agent/")) {
+    return join11(USER_OUTPUT_DIRS.antigravity, relativePath.slice(".agent/".length));
+  }
+  return join11(homedir3(), relativePath);
+}
+function mergeFiles(files) {
+  const byPath = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    const existing = byPath.get(file.path) ?? [];
+    existing.push(file);
+    byPath.set(file.path, existing);
+  }
+  const merged = [];
+  for (const [path, group] of byPath) {
+    if (group.length === 1) {
+      merged.push(group[0]);
+      continue;
+    }
+    if (path.endsWith(".json")) {
+      let result = {};
+      for (const file of group) {
+        const parsed = JSON.parse(file.content);
+        result = deepMerge(result, parsed);
+      }
+      merged.push({ path, content: `${JSON.stringify(result, null, 2)}
+` });
+    } else if (path.endsWith(".toml")) {
+      const combined = group.map((f) => f.content.trim()).join("\n\n");
+      merged.push({ path, content: `${combined}
+` });
+    } else if (path.endsWith(".md")) {
+      const combined = group.map((f) => f.content.trim()).join("\n\n---\n\n");
+      merged.push({ path, content: `${combined}
+` });
+    } else {
+      merged.push(group[group.length - 1]);
+    }
+  }
+  return merged;
+}
+var STATUS_COLORS = {
+  new: "\x1B[32m",
+  modified: "\x1B[33m",
+  "up-to-date": "\x1B[2m",
+  conflict: "\x1B[31m",
+  orphaned: "\x1B[2m"
+};
+function printStatusTable(statuses, projectDir, isUserScope, targets) {
+  console.log("");
+  for (const entry of statuses) {
+    const color = STATUS_COLORS[entry.status] ?? "";
+    const reset = "\x1B[0m";
+    const outputPath = resolveOutputPath(entry.path, isUserScope, projectDir, targets);
+    const suffix = entry.status === "up-to-date" ? " (skip)" : "";
+    console.log(`  ${color}${outputPath.padEnd(40)}${entry.status}${suffix}${reset}`);
+  }
+  console.log("");
+}
+function deepMerge(target, source) {
+  const result = { ...target };
+  for (const [key, value] of Object.entries(source)) {
+    if (typeof value === "object" && value !== null && !Array.isArray(value) && typeof result[key] === "object" && result[key] !== null && !Array.isArray(result[key])) {
+      result[key] = deepMerge(
+        result[key],
+        value
+      );
+    } else if (Array.isArray(value) && Array.isArray(result[key])) {
+      result[key] = [...result[key], ...value];
+    } else {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+
+// src/commands/init.ts
+async function runInit(projectDir, options) {
+  if (isTTY() && !options?.template) {
+    await interactiveInit(projectDir, options);
+  } else {
+    await nonInteractiveInit(projectDir, options);
+  }
+}
+async function interactiveInit(projectDir, options) {
+  intro("ai-dot \u2014 universal AI tool config");
+  const aiDir = join12(projectDir, ".ai");
+  if (existsSync2(aiDir)) {
+    const proceed = cancelGuard(
+      await confirm({ message: ".ai/ directory already exists. Reinitialize?" })
+    );
+    if (!proceed) {
+      outro("Keeping existing .ai/ directory.");
+      return;
+    }
+  }
+  const targets = cancelGuard(
+    await multiselect({
+      message: "Which AI tools do you use?",
+      options: [
+        { value: "claude", label: "Claude Code" },
+        { value: "cursor", label: "Cursor" },
+        { value: "codex", label: "Codex" }
+      ],
+      required: true
+    })
+  );
+  const templateName = cancelGuard(
+    await select({
+      message: "Start from a template?",
+      options: TEMPLATES.map((t) => ({
+        value: t.name,
+        label: t.label,
+        hint: t.description
+      }))
+    })
+  );
+  const config = getTemplate(templateName);
+  const written = await writeProjectConfig(aiDir, config);
+  console.log(`
+  \x1B[32m\u2713\x1B[0m Created .ai/ from "${templateName}" template`);
+  for (const f of written) {
+    const rel = f.replace(`${projectDir}/`, "");
+    console.log(`    ${rel}`);
+  }
+  if (!options?.skipImport) {
+    const detected = await scanForConfigs(projectDir);
+    if (detected.length > 0) {
+      const doImport = cancelGuard(
+        await confirm({
+          message: `Found ${detected.length} existing config file(s). Import them?`
+        })
+      );
+      if (doImport) {
+        const result = await runImport(projectDir, {
+          interactive: false
+        });
+        if (result.imported.length > 0) {
+          console.log(`
+  \x1B[32m\u2713\x1B[0m Imported ${result.imported.length} file(s)`);
+          for (const f of result.imported) {
+            console.log(`    ${f.label}`);
+          }
+        }
+      }
+    }
+  }
+  const doSync = cancelGuard(await confirm({ message: "Run ai-dot sync now?" }));
+  if (doSync) {
+    console.log("");
+    await runSync(projectDir, { targets, dryRun: false, scope: "project", force: false });
+  }
+  outro("Done! Edit .ai/ to customize, then run ai-dot sync.");
+}
+async function nonInteractiveInit(projectDir, options) {
+  const aiDir = join12(projectDir, ".ai");
+  const templateName = options?.template ?? "blank";
+  const config = getTemplate(templateName);
+  const written = await writeProjectConfig(aiDir, config);
+  console.log(`\x1B[32m\u2713\x1B[0m Initialized .ai/ from "${templateName}" template`);
+  for (const f of written) {
+    const rel = f.replace(`${projectDir}/`, "");
+    console.log(`  ${rel}`);
+  }
+  if (!options?.skipImport) {
+    const detected = await scanForConfigs(projectDir);
+    if (detected.length > 0) {
+      const result = await runImport(projectDir, {
+        interactive: false
+      });
+      if (result.imported.length > 0) {
+        console.log(`\x1B[32m\u2713\x1B[0m Imported ${result.imported.length} existing config file(s)`);
+      }
+    }
+  }
+  if (options?.autoSync) {
+    const targets = options.targets ?? [];
+    await runSync(projectDir, { targets, dryRun: false, scope: "project", force: false });
+  }
+  if (!options?.autoSync) {
+    console.log("\nNext: run \x1B[1mai-dot sync\x1B[0m to generate tool configs.");
+  }
+}
+
+// src/commands/status.ts
+var EMITTERS2 = [
+  skillsEmitter,
+  directivesEmitter,
+  mcpEmitter,
+  agentsEmitter,
+  permissionsEmitter,
+  hooksEmitter
+];
+var STATUS_ICONS = {
+  new: "\x1B[32m+\x1B[0m",
+  "up-to-date": "\x1B[90m=\x1B[0m",
+  modified: "\x1B[33m~\x1B[0m",
+  conflict: "\x1B[31m!\x1B[0m",
+  orphaned: "\x1B[31m-\x1B[0m"
+};
+var STATUS_LABELS = {
+  new: "new",
+  "up-to-date": "up-to-date",
+  modified: "modified",
+  conflict: "conflict (manually edited)",
+  orphaned: "orphaned (no longer generated)"
+};
+async function runStatus(projectDir) {
+  const { config, errors: loadErrors } = await loadMergedConfig(projectDir);
+  if (loadErrors.length > 0) {
+    console.error("\x1B[31mConfig errors:\x1B[0m");
+    for (const err of loadErrors) {
+      console.error(`  ${err.file}${err.line ? `:${err.line}` : ""}: ${err.message}`);
+    }
+    process.exitCode = 1;
+    return;
+  }
+  const { errors: valErrors } = validateConfig(config);
+  if (valErrors.length > 0) {
+    console.error("\x1B[31mValidation errors:\x1B[0m");
+    for (const err of valErrors) {
+      console.error(`  ${err.file}: ${err.message}`);
+    }
+    process.exitCode = 1;
+    return;
+  }
+  const allFiles = [];
+  for (const target of ALL_TARGETS) {
+    for (const emitter of EMITTERS2) {
+      const result = emitter.emit(config, target);
+      allFiles.push(...result.files);
+    }
+  }
+  const mergedFiles = mergeFilesByPath(allFiles);
+  const state = await loadState(projectDir);
+  if (!state) {
+    console.log("No previous sync state found. Run \x1B[1mai-dot sync\x1B[0m first.\n");
+  }
+  const entries = await diffFiles(projectDir, mergedFiles, state);
+  const counts = {
+    new: 0,
+    "up-to-date": 0,
+    modified: 0,
+    conflict: 0,
+    orphaned: 0
+  };
+  console.log("\x1B[1mFile status:\x1B[0m\n");
+  for (const entry of entries.sort((a, b) => a.path.localeCompare(b.path))) {
+    counts[entry.status]++;
+    console.log(
+      `  ${STATUS_ICONS[entry.status]} ${entry.path}  \x1B[90m${STATUS_LABELS[entry.status]}\x1B[0m`
+    );
+  }
+  console.log("");
+  const parts = [];
+  if (counts.new > 0) parts.push(`\x1B[32m${counts.new} new\x1B[0m`);
+  if (counts.modified > 0) parts.push(`\x1B[33m${counts.modified} modified\x1B[0m`);
+  if (counts["up-to-date"] > 0) parts.push(`\x1B[90m${counts["up-to-date"]} up-to-date\x1B[0m`);
+  if (counts.conflict > 0) parts.push(`\x1B[31m${counts.conflict} conflicts\x1B[0m`);
+  if (counts.orphaned > 0) parts.push(`\x1B[31m${counts.orphaned} orphaned\x1B[0m`);
+  console.log(`  ${parts.join(", ")}`);
+  if (counts.conflict > 0) {
+    console.log("\n  Use \x1B[1mai-dot sync --force\x1B[0m to overwrite conflicting files.");
+  }
+}
+function mergeFilesByPath(files) {
+  const byPath = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    const existing = byPath.get(file.path);
+    if (!existing) {
+      byPath.set(file.path, file);
+    } else if (file.path.endsWith(".json")) {
+      const merged = deepMergeJson(existing.content, file.content);
+      byPath.set(file.path, { path: file.path, content: merged });
+    } else if (file.path.endsWith(".toml")) {
+      byPath.set(file.path, {
+        path: file.path,
+        content: `${existing.content.trim()}
+
+${file.content.trim()}
+`
+      });
+    } else if (file.path.endsWith(".md")) {
+      byPath.set(file.path, {
+        path: file.path,
+        content: `${existing.content.trim()}
+
+---
+
+${file.content.trim()}
+`
+      });
+    } else {
+      byPath.set(file.path, file);
+    }
+  }
+  return [...byPath.values()];
+}
+function deepMergeJson(a, b) {
+  const objA = JSON.parse(a);
+  const objB = JSON.parse(b);
+  const merged = merge(objA, objB);
+  return `${JSON.stringify(merged, null, 2)}
+`;
+}
+function merge(target, source) {
+  const result = { ...target };
+  for (const [key, value] of Object.entries(source)) {
+    if (typeof value === "object" && value !== null && !Array.isArray(value) && typeof result[key] === "object" && result[key] !== null && !Array.isArray(result[key])) {
+      result[key] = merge(result[key], value);
+    } else if (Array.isArray(value) && Array.isArray(result[key])) {
+      result[key] = [...result[key], ...value];
+    } else {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+
+// src/domain/factories.ts
+function createDirective(overrides) {
+  return {
+    alwaysApply: true,
+    ...overrides
+  };
+}
+function createSkill(overrides) {
+  return {
+    description: "",
+    disableAutoInvocation: false,
+    ...overrides
+  };
+}
+function createAgent(overrides) {
+  return {
+    description: "",
+    ...overrides
+  };
+}
+function createToolServer(overrides) {
+  return { ...overrides };
+}
+function createHook(overrides) {
+  return { ...overrides };
+}
+function createPermission(overrides) {
+  return { ...overrides };
+}
+function createSetting(overrides) {
+  return { ...overrides };
+}
+function createIgnorePattern(overrides) {
+  return { ...overrides };
+}
+
+// src/domain/hook.ts
+var HookEvent = {
+  PreToolUse: "preToolUse",
+  PostToolUse: "postToolUse",
+  PreFileEdit: "preFileEdit",
+  PostFileEdit: "postFileEdit",
+  SessionStart: "sessionStart",
+  SessionEnd: "sessionEnd",
+  UserPromptSubmitted: "userPromptSubmitted",
+  AgentStop: "agentStop",
+  SubagentStop: "subagentStop",
+  ErrorOccurred: "errorOccurred"
+};
+
+// src/domain/permission.ts
+var Decision = {
+  Allow: "allow",
+  Deny: "deny",
+  Ask: "ask"
+};
+
+// src/domain/scope.ts
+var Scope = {
+  Enterprise: "enterprise",
+  Project: "project",
+  User: "user",
+  Local: "local"
+};
+var SCOPE_PRECEDENCE = [
+  Scope.Enterprise,
+  Scope.Project,
+  Scope.User,
+  Scope.Local
+];
+function scopeOutranks(a, b) {
+  return SCOPE_PRECEDENCE.indexOf(a) < SCOPE_PRECEDENCE.indexOf(b);
+}
+
+// src/domain/tool-server.ts
+var Transport = {
+  Stdio: "stdio",
+  Http: "http",
+  Sse: "sse"
+};
+
+// src/domain/type-guards.ts
+function isObj(v) {
+  return typeof v === "object" && v !== null;
+}
+function hasString(o, k) {
+  return typeof o[k] === "string";
+}
+function hasScope(o) {
+  return typeof o.scope === "string" && SCOPE_PRECEDENCE.includes(o.scope);
+}
+function isDirective(v) {
+  return isObj(v) && hasString(v, "content") && hasScope(v) && typeof v.alwaysApply === "boolean";
+}
+function isSkill(v) {
+  return isObj(v) && hasString(v, "name") && hasString(v, "content") && typeof v.disableAutoInvocation === "boolean";
+}
+function isAgent(v) {
+  return isObj(v) && hasString(v, "name") && hasString(v, "instructions");
+}
+function isToolServer(v) {
+  return isObj(v) && hasString(v, "name") && hasString(v, "transport") && hasScope(v);
+}
+function isHook(v) {
+  return isObj(v) && hasString(v, "event") && hasString(v, "handler") && hasScope(v);
+}
+function isPermission(v) {
+  return isObj(v) && hasString(v, "tool") && hasString(v, "decision") && hasScope(v);
+}
+function isSetting(v) {
+  return isObj(v) && hasString(v, "key") && "value" in v && hasScope(v);
+}
+function isIgnorePattern(v) {
+  return isObj(v) && hasString(v, "pattern") && hasScope(v);
+}
+export {
+  ALL_TARGETS,
+  Decision,
+  HookEvent,
+  SCOPE_PRECEDENCE,
+  Scope,
+  TEMPLATES,
+  TEMPLATE_NAMES,
+  TargetTool,
+  Transport,
+  agentsEmitter,
+  contentHash,
+  createAgent,
+  createDirective,
+  createHook,
+  createIgnorePattern,
+  createPermission,
+  createSetting,
+  createSkill,
+  createToolServer,
+  diffFiles,
+  directivesEmitter,
+  emptyConfig,
+  getTemplate,
+  hooksEmitter,
+  isAgent,
+  isDirective,
+  isHook,
+  isIgnorePattern,
+  isPermission,
+  isSetting,
+  isSkill,
+  isToolServer,
+  loadMarkdownFile,
+  loadMergedConfig,
+  loadProjectConfig,
+  loadSkills,
+  loadState,
+  mcpEmitter,
+  mergeConfigs,
+  parseClaude,
+  parseCodex,
+  parseCursor,
+  parseMarkdownWithFrontmatter,
+  parseOpenCode,
+  permissionsEmitter,
+  runCheck,
+  runImport,
+  runImportCommand,
+  runInit,
+  runStatus,
+  runSync,
+  saveState,
+  scanForConfigs,
+  scopeOutranks,
+  skillsEmitter,
+  validateConfig,
+  writeProjectConfig
+};
+//# sourceMappingURL=index.js.map