@lnai/core 0.1.1 → 0.3.0

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 
 declare const UNIFIED_DIR = ".ai";
-declare const TOOL_IDS: readonly ["claudeCode", "opencode"];
+declare const TOOL_IDS: readonly ["claudeCode", "opencode", "cursor", "copilot"];
 type ToolId = (typeof TOOL_IDS)[number];
 declare const CONFIG_FILES: {
     readonly config: "config.json";
@@ -65,6 +65,8 @@ declare const toolConfigSchema: z.ZodObject<{
 declare const toolIdSchema: z.ZodEnum<{
     claudeCode: "claudeCode";
     opencode: "opencode";
+    cursor: "cursor";
+    copilot: "copilot";
 }>;
 /** Settings configuration (Claude format as source of truth) */
 declare const settingsSchema: z.ZodObject<{
@@ -84,10 +86,6 @@ declare const settingsSchema: z.ZodObject<{
         url: z.ZodOptional<z.ZodString>;
         headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
     }, z.core.$strip>>>;
-    overrides: z.ZodOptional<z.ZodObject<{
-        claudeCode: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-        opencode: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    }, z.core.$strip>>;
 }, z.core.$strip>;
 /** Main config.json structure. Uses partial object to allow partial tool configs. */
 declare const configSchema: z.ZodObject<{
@@ -100,6 +98,14 @@ declare const configSchema: z.ZodObject<{
             enabled: z.ZodBoolean;
             versionControl: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
         }, z.core.$strip>>;
+        cursor: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodBoolean;
+            versionControl: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        }, z.core.$strip>>;
+        copilot: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodBoolean;
+            versionControl: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        }, z.core.$strip>>;
     }, z.core.$strip>>;
 }, z.core.$strip>;
 /** Skill frontmatter (name and description required) */
@@ -134,19 +140,11 @@ interface MarkdownFrontmatter {
 /** All parsed configuration from the .ai directory */
 interface UnifiedState {
     config: {
-        tools?: Partial<Record<ToolId, {
-            enabled: boolean;
-            versionControl?: boolean;
-        }>>;
+        tools?: Partial<Record<ToolId, ToolConfig>>;
     };
     settings: {
-        permissions?: {
-            allow?: string[];
-            ask?: string[];
-            deny?: string[];
-        };
-        mcpServers?: Record<string, unknown>;
-        overrides?: Partial<Record<ToolId, Record<string, unknown>>>;
+        permissions?: Permissions;
+        mcpServers?: Record<string, McpServer>;
     } | null;
     agents: string | null;
     rules: MarkdownFile<RuleFrontmatter>[];

package/dist/index.js

@@ -2,12 +2,11 @@ import { z } from 'zod';
 import * as fs3 from 'fs/promises';
 import * as path from 'path';
 import matter from 'gray-matter';
-import deepmerge from 'deepmerge';
 import * as crypto from 'crypto';
 
 // src/constants.ts
 var UNIFIED_DIR = ".ai";
-var TOOL_IDS = ["claudeCode", "opencode"];
+var TOOL_IDS = ["claudeCode", "opencode", "cursor", "copilot"];
 var CONFIG_FILES = {
   config: "config.json",
   settings: "settings.json",
@@ -20,11 +19,15 @@ var CONFIG_DIRS = {
 };
 var TOOL_OUTPUT_DIRS = {
   claudeCode: ".claude",
-  opencode: ".opencode"
+  opencode: ".opencode",
+  cursor: ".cursor",
+  copilot: ".github"
 };
 var OVERRIDE_DIRS = {
   claudeCode: ".claude",
-  opencode: ".opencode"
+  opencode: ".opencode",
+  cursor: ".cursor",
+  copilot: ".copilot"
 };
 
 // src/errors.ts
@@ -50,10 +53,10 @@ var ParseError = class extends LnaiError {
 var ValidationError = class extends LnaiError {
   path;
   value;
-  constructor(message, path7, value) {
+  constructor(message, path5, value) {
     super(message, "VALIDATION_ERROR");
     this.name = "ValidationError";
-    this.path = path7;
+    this.path = path5;
     this.value = value;
   }
 };
@@ -104,19 +107,17 @@ var toolConfigSchema = z.object({
   enabled: z.boolean(),
   versionControl: z.boolean().optional().default(false)
 });
-var toolIdSchema = z.enum(["claudeCode", "opencode"]);
+var toolIdSchema = z.enum(["claudeCode", "opencode", "cursor", "copilot"]);
 var settingsSchema = z.object({
   permissions: permissionsSchema.optional(),
-  mcpServers: z.record(z.string(), mcpServerSchema).optional(),
-  overrides: z.object({
-    claudeCode: z.record(z.string(), z.unknown()).optional(),
-    opencode: z.record(z.string(), z.unknown()).optional()
-  }).optional()
+  mcpServers: z.record(z.string(), mcpServerSchema).optional()
 });
 var configSchema = z.object({
   tools: z.object({
     claudeCode: toolConfigSchema,
-    opencode: toolConfigSchema
+    opencode: toolConfigSchema,
+    cursor: toolConfigSchema,
+    copilot: toolConfigSchema
   }).partial().optional()
 });
 var skillFrontmatterSchema = z.object({
@@ -399,18 +400,24 @@ async function scanDir(baseDir, currentDir, files) {
     }
   }
 }
-function deepMergeConfigs(base, override) {
-  return deepmerge(base, override, {
-    arrayMerge: (target, source) => [.../* @__PURE__ */ new Set([...target, ...source])]
-  });
-}
-async function fileExists2(filePath) {
-  try {
-    await fs3.access(filePath);
-    return true;
-  } catch {
-    return false;
+async function applyFileOverrides(files, rootDir, toolId) {
+  const outputDir = TOOL_OUTPUT_DIRS[toolId];
+  const overrideFiles = await scanOverrideDirectory(rootDir, toolId);
+  const overridePaths = /* @__PURE__ */ new Set();
+  const overrideOutputFiles = [];
+  for (const overrideFile of overrideFiles) {
+    const outputPath = `${outputDir}/${overrideFile.relativePath}`;
+    overridePaths.add(outputPath);
+    const symlinkDir = path.dirname(outputPath);
+    const sourcePath = `${UNIFIED_DIR}/${OVERRIDE_DIRS[toolId]}/${overrideFile.relativePath}`;
+    overrideOutputFiles.push({
+      path: outputPath,
+      type: "symlink",
+      target: path.relative(symlinkDir, sourcePath)
+    });
   }
+  const filteredFiles = files.filter((file) => !overridePaths.has(file.path));
+  return [...filteredFiles, ...overrideOutputFiles];
 }
 
 // src/plugins/claude-code/index.ts
@@ -447,65 +454,446 @@ var claudeCodePlugin = {
         target: `../../${UNIFIED_DIR}/skills/${skill.path}`
       });
     }
-    const baseSettings = {};
+    const settings = {};
     if (state.settings?.permissions) {
-      baseSettings["permissions"] = state.settings.permissions;
+      settings["permissions"] = state.settings.permissions;
     }
     if (state.settings?.mcpServers) {
-      baseSettings["mcpServers"] = state.settings.mcpServers;
+      settings["mcpServers"] = state.settings.mcpServers;
     }
-    let finalSettings = baseSettings;
-    if (state.settings?.overrides?.claudeCode) {
-      finalSettings = deepMergeConfigs(
-        baseSettings,
-        state.settings.overrides.claudeCode
-      );
-    }
-    if (Object.keys(finalSettings).length > 0) {
+    if (Object.keys(settings).length > 0) {
       files.push({
         path: `${outputDir}/settings.json`,
         type: "json",
-        content: finalSettings
+        content: settings
       });
     }
-    const overrideFiles = await scanOverrideDirectory(rootDir, "claudeCode");
-    for (const overrideFile of overrideFiles) {
-      const targetPath = path.join(
-        rootDir,
-        outputDir,
-        overrideFile.relativePath
-      );
-      if (await fileExists2(targetPath)) {
+    return applyFileOverrides(files, rootDir, "claudeCode");
+  },
+  validate(state) {
+    const warnings = [];
+    if (!state.agents) {
+      warnings.push({
+        path: ["AGENTS.md"],
+        message: "No AGENTS.md found - .claude/CLAUDE.md will not be created"
+      });
+    }
+    return { valid: true, errors: [], warnings, skipped: [] };
+  }
+};
+
+// src/utils/transforms.ts
+var ENV_VAR_PATTERN = /\$\{([^}:]+)(:-[^}]*)?\}/g;
+function transformEnvVar(value, format) {
+  if (format === "opencode") {
+    return value.replace(ENV_VAR_PATTERN, "{env:$1}");
+  }
+  return value.replace(ENV_VAR_PATTERN, "${env:$1}");
+}
+function transformEnvVars(env, format) {
+  const result = {};
+  for (const [key, value] of Object.entries(env)) {
+    result[key] = transformEnvVar(value, format);
+  }
+  return result;
+}
+function parsePermissionRule(rule) {
+  const match = rule.match(/^(\w+)\(([^)]+)\)$/);
+  if (!match) {
+    return null;
+  }
+  const tool = match[1];
+  const pattern = match[2];
+  if (!tool || !pattern) {
+    return null;
+  }
+  return { tool, pattern };
+}
+function deriveDescription(filename, content) {
+  const headingMatch = content.match(/^#\s+(.+)$/m);
+  if (headingMatch && headingMatch[1]) {
+    return headingMatch[1];
+  }
+  const baseName = filename.replace(/\.md$/, "");
+  return baseName.replace(/-/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
+}
+
+// src/plugins/copilot/transforms.ts
+function transformRuleToCopilot(rule) {
+  const description = deriveDescription(rule.path, rule.content);
+  const paths = rule.frontmatter.paths || [];
+  const frontmatter = {
+    description
+  };
+  if (paths.length > 0) {
+    frontmatter.applyTo = paths.join(",");
+  }
+  return {
+    frontmatter,
+    content: rule.content
+  };
+}
+function serializeCopilotInstruction(frontmatter, content) {
+  const lines = ["---"];
+  if (frontmatter.applyTo) {
+    lines.push(`applyTo: ${JSON.stringify(frontmatter.applyTo)}`);
+  }
+  lines.push(`description: ${JSON.stringify(frontmatter.description)}`);
+  lines.push("---");
+  lines.push("");
+  lines.push(content);
+  return lines.join("\n");
+}
+function transformMcpToCopilot(servers) {
+  if (!servers || Object.keys(servers).length === 0) {
+    return void 0;
+  }
+  const result = {};
+  for (const [name, server] of Object.entries(servers)) {
+    if (server.type === "http" || server.type === "sse") {
+      if (!server.url) {
         continue;
       }
+      const copilotServer = {
+        url: server.url
+      };
+      if (server.headers && Object.keys(server.headers).length > 0) {
+        copilotServer.requestInit = {
+          headers: transformEnvVars(server.headers, "copilot")
+        };
+      }
+      result[name] = copilotServer;
+    } else if (server.command) {
+      const copilotServer = {
+        type: "stdio",
+        command: server.command
+      };
+      if (server.args && server.args.length > 0) {
+        copilotServer.args = server.args;
+      }
+      if (server.env && Object.keys(server.env).length > 0) {
+        copilotServer.env = transformEnvVars(server.env, "copilot");
+      }
+      result[name] = copilotServer;
+    }
+  }
+  if (Object.keys(result).length === 0) {
+    return void 0;
+  }
+  return {
+    inputs: [],
+    servers: result
+  };
+}
+
+// src/plugins/copilot/index.ts
+var copilotPlugin = {
+  id: "copilot",
+  name: "GitHub Copilot",
+  async detect(_rootDir) {
+    return false;
+  },
+  async import(_rootDir) {
+    return null;
+  },
+  async export(state, rootDir) {
+    const files = [];
+    if (state.agents) {
       files.push({
-        path: `${outputDir}/${overrideFile.relativePath}`,
+        path: ".github/copilot-instructions.md",
         type: "symlink",
-        target: `../${UNIFIED_DIR}/${OVERRIDE_DIRS.claudeCode}/${overrideFile.relativePath}`
+        target: `../${UNIFIED_DIR}/AGENTS.md`
       });
     }
-    return files;
+    for (const rule of state.rules) {
+      const transformed = transformRuleToCopilot(rule);
+      const ruleContent = serializeCopilotInstruction(
+        transformed.frontmatter,
+        transformed.content
+      );
+      const outputFilename = rule.path.replace(/\.md$/, ".instructions.md");
+      files.push({
+        path: `.github/instructions/${outputFilename}`,
+        type: "text",
+        content: ruleContent
+      });
+    }
+    for (const skill of state.skills) {
+      files.push({
+        path: `.github/skills/${skill.path}`,
+        type: "symlink",
+        target: `../../${UNIFIED_DIR}/skills/${skill.path}`
+      });
+    }
+    const mcpConfig = transformMcpToCopilot(state.settings?.mcpServers);
+    if (mcpConfig) {
+      files.push({
+        path: ".vscode/mcp.json",
+        type: "json",
+        content: { inputs: mcpConfig.inputs, servers: mcpConfig.servers }
+      });
+    }
+    return applyFileOverrides(files, rootDir, "copilot");
   },
   validate(state) {
     const warnings = [];
     if (!state.agents) {
       warnings.push({
         path: ["AGENTS.md"],
-        message: "No AGENTS.md found - .claude/CLAUDE.md will not be created"
+        message: "No AGENTS.md found - .github/copilot-instructions.md will not be created"
+      });
+    }
+    const permissions = state.settings?.permissions;
+    const hasPermissions = permissions && (permissions.allow && permissions.allow.length > 0 || permissions.ask && permissions.ask.length > 0 || permissions.deny && permissions.deny.length > 0);
+    if (hasPermissions) {
+      warnings.push({
+        path: ["settings", "permissions"],
+        message: "GitHub Copilot does not support permissions - they will be ignored"
       });
     }
+    const mcpServers = state.settings?.mcpServers;
+    if (mcpServers) {
+      for (const [name, server] of Object.entries(mcpServers)) {
+        const isRemote = server.type === "http" || server.type === "sse";
+        const hasCommand = !!server.command;
+        if (isRemote && !server.url) {
+          warnings.push({
+            path: ["settings", "mcpServers", name],
+            message: `MCP server "${name}" is type "${server.type}" but has no url - it will be skipped`
+          });
+        } else if (!isRemote && !hasCommand) {
+          warnings.push({
+            path: ["settings", "mcpServers", name],
+            message: `MCP server "${name}" has no command or type - it will be skipped`
+          });
+        }
+      }
+    }
     return { valid: true, errors: [], warnings, skipped: [] };
   }
 };
 
+// src/plugins/cursor/transforms.ts
+function transformRuleToCursor(rule) {
+  const description = deriveDescription(rule.path, rule.content);
+  const globs = rule.frontmatter.paths || [];
+  const alwaysApply = globs.length === 0;
+  return {
+    frontmatter: {
+      description,
+      globs,
+      alwaysApply
+    },
+    content: rule.content
+  };
+}
+function serializeCursorRule(frontmatter, content) {
+  const lines = [
+    "---",
+    `description: ${JSON.stringify(frontmatter.description)}`
+  ];
+  lines.push("globs:");
+  for (const glob of frontmatter.globs) {
+    lines.push(`  - ${JSON.stringify(glob)}`);
+  }
+  lines.push(`alwaysApply: ${frontmatter.alwaysApply}`);
+  lines.push("---");
+  lines.push("");
+  lines.push(content);
+  return lines.join("\n");
+}
+function transformMcpToCursor(servers) {
+  if (!servers || Object.keys(servers).length === 0) {
+    return void 0;
+  }
+  const result = {};
+  for (const [name, server] of Object.entries(servers)) {
+    if (server.type === "http" || server.type === "sse") {
+      const cursorServer = {
+        url: server.url
+      };
+      if (server.headers) {
+        cursorServer.headers = transformEnvVars(server.headers, "cursor");
+      }
+      result[name] = cursorServer;
+    } else if (server.command) {
+      const cursorServer = {
+        command: server.command
+      };
+      if (server.args && server.args.length > 0) {
+        cursorServer.args = server.args;
+      }
+      if (server.env) {
+        cursorServer.env = transformEnvVars(server.env, "cursor");
+      }
+      result[name] = cursorServer;
+    }
+  }
+  return Object.keys(result).length > 0 ? result : void 0;
+}
+function transformPermissionsToCursor(permissions) {
+  if (!permissions) {
+    return { permissions: void 0, hasAskPermissions: false };
+  }
+  const allow = [];
+  const deny = [];
+  let hasAskPermissions = false;
+  if (permissions.allow) {
+    for (const rule of permissions.allow) {
+      const transformed = transformPermissionRule(rule);
+      if (transformed) {
+        allow.push(transformed);
+      }
+    }
+  }
+  if (permissions.ask && permissions.ask.length > 0) {
+    hasAskPermissions = true;
+    for (const rule of permissions.ask) {
+      const transformed = transformPermissionRule(rule);
+      if (transformed) {
+        allow.push(transformed);
+      }
+    }
+  }
+  if (permissions.deny) {
+    for (const rule of permissions.deny) {
+      const transformed = transformPermissionRule(rule);
+      if (transformed) {
+        deny.push(transformed);
+      }
+    }
+  }
+  if (allow.length === 0 && deny.length === 0) {
+    return { permissions: void 0, hasAskPermissions };
+  }
+  return {
+    permissions: {
+      allow,
+      deny
+    },
+    hasAskPermissions
+  };
+}
+function transformPermissionRule(rule) {
+  const match = rule.match(/^(\w+)\(([^)]+)\)$/);
+  if (!match) {
+    return null;
+  }
+  const tool = match[1];
+  let pattern = match[2];
+  const cursorTool = tool.toLowerCase() === "bash" ? "Shell" : tool;
+  if (pattern.endsWith(":*")) {
+    pattern = pattern.slice(0, -2);
+  }
+  return `${cursorTool}(${pattern})`;
+}
+
+// src/plugins/cursor/index.ts
+var cursorPlugin = {
+  id: "cursor",
+  name: "Cursor",
+  async detect(_rootDir) {
+    return false;
+  },
+  async import(_rootDir) {
+    return null;
+  },
+  async export(state, rootDir) {
+    const files = [];
+    const outputDir = TOOL_OUTPUT_DIRS.cursor;
+    if (state.agents) {
+      files.push({
+        path: "AGENTS.md",
+        type: "symlink",
+        target: `${UNIFIED_DIR}/AGENTS.md`
+      });
+    }
+    for (const rule of state.rules) {
+      const transformed = transformRuleToCursor(rule);
+      const ruleContent = serializeCursorRule(
+        transformed.frontmatter,
+        transformed.content
+      );
+      const outputFilename = rule.path.replace(/\.md$/, ".mdc");
+      files.push({
+        path: `${outputDir}/rules/${outputFilename}`,
+        type: "text",
+        content: ruleContent
+      });
+    }
+    for (const skill of state.skills) {
+      files.push({
+        path: `${outputDir}/skills/${skill.path}`,
+        type: "symlink",
+        target: `../../${UNIFIED_DIR}/skills/${skill.path}`
+      });
+    }
+    const mcpServers = transformMcpToCursor(state.settings?.mcpServers);
+    if (mcpServers) {
+      files.push({
+        path: `${outputDir}/mcp.json`,
+        type: "json",
+        content: { mcpServers }
+      });
+    }
+    const cliContent = buildCliContent(state.settings?.permissions);
+    if (cliContent) {
+      files.push({
+        path: `${outputDir}/cli.json`,
+        type: "json",
+        content: cliContent
+      });
+    }
+    return applyFileOverrides(files, rootDir, "cursor");
+  },
+  validate(state) {
+    const warnings = [];
+    if (!state.agents) {
+      warnings.push({
+        path: ["AGENTS.md"],
+        message: "No AGENTS.md found - root AGENTS.md will not be created"
+      });
+    }
+    const permissionsResult = transformPermissionsToCursor(
+      state.settings?.permissions
+    );
+    if (permissionsResult.hasAskPermissions) {
+      warnings.push({
+        path: ["settings", "permissions", "ask"],
+        message: 'Cursor does not support "ask" permission level - these rules will be treated as "allow"'
+      });
+    }
+    const mcpServers = state.settings?.mcpServers;
+    if (mcpServers) {
+      for (const [name, server] of Object.entries(mcpServers)) {
+        const isRemote = server.type === "http" || server.type === "sse";
+        const hasCommand = !!server.command;
+        if (!isRemote && !hasCommand) {
+          warnings.push({
+            path: ["settings", "mcpServers", name],
+            message: `MCP server "${name}" has no command or type - it will be skipped`
+          });
+        }
+      }
+    }
+    return { valid: true, errors: [], warnings, skipped: [] };
+  }
+};
+function buildCliContent(permissions) {
+  const permissionsResult = transformPermissionsToCursor(permissions);
+  if (!permissionsResult.permissions) {
+    return void 0;
+  }
+  return { permissions: permissionsResult.permissions };
+}
+
 // src/plugins/opencode/transforms.ts
 function transformMcpToOpenCode(servers) {
   if (!servers || Object.keys(servers).length === 0) {
     return void 0;
   }
   const result = {};
-  for (const [name, serverRaw] of Object.entries(servers)) {
-    const server = serverRaw;
+  for (const [name, server] of Object.entries(servers)) {
     if (server.type === "http" || server.type === "sse") {
       const openCodeServer = {
         type: "remote",
@@ -522,7 +910,7 @@ function transformMcpToOpenCode(servers) {
         command
       };
       if (server.env) {
-        openCodeServer.environment = transformEnvVars(server.env);
+        openCodeServer.environment = transformEnvVars(server.env, "opencode");
       }
       result[name] = openCodeServer;
     }
@@ -539,7 +927,7 @@ function transformPermissionsToOpenCode(permissions) {
       return;
     }
     for (const rule of rules) {
-      const parsed = parsePermissionRule(rule);
+      const parsed = parsePermissionRuleForOpenCode(rule);
       if (!parsed) {
         continue;
       }
@@ -555,28 +943,13 @@ function transformPermissionsToOpenCode(permissions) {
   processRules(permissions.deny, "deny");
   return Object.keys(result).length > 0 ? result : void 0;
 }
-function transformEnvVar(value) {
-  return value.replace(/\$\{([^}:]+)(:-[^}]*)?\}/g, "{env:$1}");
-}
-function transformEnvVars(env) {
-  const result = {};
-  for (const [key, value] of Object.entries(env)) {
-    result[key] = transformEnvVar(value);
-  }
-  return result;
-}
-function parsePermissionRule(rule) {
-  const match = rule.match(/^(\w+)\(([^)]+)\)$/);
-  if (!match) {
-    return null;
-  }
-  const tool = match[1];
-  const pattern = match[2];
-  if (!tool || !pattern) {
+function parsePermissionRuleForOpenCode(rule) {
+  const parsed = parsePermissionRule(rule);
+  if (!parsed) {
     return null;
   }
-  const normalizedTool = tool.toLowerCase();
-  let normalizedPattern = pattern;
+  const normalizedTool = parsed.tool.toLowerCase();
+  let normalizedPattern = parsed.pattern;
   if (normalizedPattern.includes(":*")) {
     normalizedPattern = normalizedPattern.replace(/:(\*)/g, " $1");
   }
@@ -620,51 +993,28 @@ var opencodePlugin = {
         target: `../../${UNIFIED_DIR}/skills/${skill.path}`
       });
     }
-    const baseConfig = {
+    const config = {
       $schema: "https://opencode.ai/config.json"
     };
     if (state.rules.length > 0) {
-      baseConfig["instructions"] = [`${outputDir}/rules/*.md`];
+      config["instructions"] = [`${outputDir}/rules/*.md`];
     }
     const mcp = transformMcpToOpenCode(state.settings?.mcpServers);
     if (mcp) {
-      baseConfig["mcp"] = mcp;
+      config["mcp"] = mcp;
     }
     const permission = transformPermissionsToOpenCode(
       state.settings?.permissions
     );
     if (permission) {
-      baseConfig["permission"] = permission;
-    }
-    let finalConfig = baseConfig;
-    if (state.settings?.overrides?.opencode) {
-      finalConfig = deepMergeConfigs(
-        baseConfig,
-        state.settings.overrides.opencode
-      );
+      config["permission"] = permission;
     }
     files.push({
       path: "opencode.json",
       type: "json",
-      content: finalConfig
+      content: config
     });
-    const overrideFiles = await scanOverrideDirectory(rootDir, "opencode");
-    for (const overrideFile of overrideFiles) {
-      const targetPath = path.join(
-        rootDir,
-        outputDir,
-        overrideFile.relativePath
-      );
-      if (await fileExists2(targetPath)) {
-        continue;
-      }
-      files.push({
-        path: `${outputDir}/${overrideFile.relativePath}`,
-        type: "symlink",
-        target: `../${UNIFIED_DIR}/${OVERRIDE_DIRS.opencode}/${overrideFile.relativePath}`
-      });
-    }
-    return files;
+    return applyFileOverrides(files, rootDir, "opencode");
   },
   validate(state) {
     const warnings = [];
@@ -701,6 +1051,8 @@ var pluginRegistry = new PluginRegistry();
 
 // src/plugins/index.ts
 pluginRegistry.register(claudeCodePlugin);
+pluginRegistry.register(copilotPlugin);
+pluginRegistry.register(cursorPlugin);
 pluginRegistry.register(opencodePlugin);
 function computeHash(content) {
   return crypto.createHash("sha256").update(content, "utf-8").digest("hex");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lnai/core",
-  "version": "0.1.1",
+  "version": "0.3.0",
   "description": "Core library for LNAI - unified AI config management",
   "type": "module",
   "license": "MIT",
@@ -19,7 +19,10 @@
     "config",
     "configuration",
     "claude",
+    "cursor",
     "opencode",
+    "copilot",
+    "github-copilot",
     "cli",
     "ai-tools"
   ],
@@ -33,7 +36,6 @@
     "dist"
   ],
   "dependencies": {
-    "deepmerge": "^4.3.1",
     "gray-matter": "^4.0.3",
     "zod": "^4.3.6"
   },