@lnai/core 0.2.0 → 0.4.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", "cursor"];
+declare const TOOL_IDS: readonly ["claudeCode", "opencode", "cursor", "copilot", "windsurf"];
 type ToolId = (typeof TOOL_IDS)[number];
 declare const CONFIG_FILES: {
     readonly config: "config.json";
@@ -66,6 +66,8 @@ declare const toolIdSchema: z.ZodEnum<{
     claudeCode: "claudeCode";
     opencode: "opencode";
     cursor: "cursor";
+    copilot: "copilot";
+    windsurf: "windsurf";
 }>;
 /** Settings configuration (Claude format as source of truth) */
 declare const settingsSchema: z.ZodObject<{
@@ -85,11 +87,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>>;
-        cursor: 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<{
@@ -106,6 +103,14 @@ declare const configSchema: 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>>;
+        windsurf: 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) */
@@ -145,7 +150,6 @@ interface UnifiedState {
     settings: {
         permissions?: Permissions;
         mcpServers?: Record<string, McpServer>;
-        overrides?: Partial<Record<ToolId, Record<string, unknown>>>;
     } | null;
     agents: string | null;
     rules: MarkdownFile<RuleFrontmatter>[];
@@ -302,12 +306,13 @@ interface InitOptions {
     tools?: ToolId[];
     minimal?: boolean;
     force?: boolean;
+    versionControl?: Record<ToolId, boolean>;
 }
 interface InitResult {
     created: string[];
 }
 declare function initUnifiedConfig(options: InitOptions): Promise<InitResult>;
 declare function hasUnifiedConfig(rootDir: string): Promise<boolean>;
-declare function generateDefaultConfig(tools?: ToolId[]): Config;
+declare function generateDefaultConfig(tools?: ToolId[], versionControl?: Record<ToolId, boolean>): Config;
 
 export { CONFIG_DIRS, CONFIG_FILES, type ChangeResult, type Config, FileNotFoundError, type InitOptions, type InitResult, LnaiError, type MarkdownFile, type MarkdownFrontmatter, type McpServer, type OutputFile, ParseError, type PermissionLevel, type Permissions, type Plugin, PluginError, type RuleFrontmatter, type Settings, type SkillFrontmatter, type SkippedFeatureDetail, type SyncOptions, type SyncResult, TOOL_IDS, TOOL_OUTPUT_DIRS, type ToolConfig, type ToolId, UNIFIED_DIR, type UnifiedState, ValidationError, type ValidationErrorDetail, type ValidationResult, type ValidationWarningDetail, WriteError, type WriterOptions, claudeCodePlugin, computeHash, configSchema, generateDefaultConfig, hasUnifiedConfig, initUnifiedConfig, mcpServerSchema, opencodePlugin, parseFrontmatter, parseUnifiedConfig, permissionsSchema, pluginRegistry, ruleFrontmatterSchema, runSyncPipeline, settingsSchema, skillFrontmatterSchema, toolConfigSchema, toolIdSchema, updateGitignore, validateConfig, validateSettings, validateUnifiedState, writeFiles };

package/dist/index.js

@@ -2,12 +2,17 @@ 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", "cursor"];
+var TOOL_IDS = [
+  "claudeCode",
+  "opencode",
+  "cursor",
+  "copilot",
+  "windsurf"
+];
 var CONFIG_FILES = {
   config: "config.json",
   settings: "settings.json",
@@ -21,12 +26,16 @@ var CONFIG_DIRS = {
 var TOOL_OUTPUT_DIRS = {
   claudeCode: ".claude",
   opencode: ".opencode",
-  cursor: ".cursor"
+  cursor: ".cursor",
+  copilot: ".github",
+  windsurf: ".windsurf"
 };
 var OVERRIDE_DIRS = {
   claudeCode: ".claude",
   opencode: ".opencode",
-  cursor: ".cursor"
+  cursor: ".cursor",
+  copilot: ".copilot",
+  windsurf: ".windsurf"
 };
 
 // src/errors.ts
@@ -106,21 +115,24 @@ var toolConfigSchema = z.object({
   enabled: z.boolean(),
   versionControl: z.boolean().optional().default(false)
 });
-var toolIdSchema = z.enum(["claudeCode", "opencode", "cursor"]);
+var toolIdSchema = z.enum([
+  "claudeCode",
+  "opencode",
+  "cursor",
+  "copilot",
+  "windsurf"
+]);
 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(),
-    cursor: 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,
-    cursor: toolConfigSchema
+    cursor: toolConfigSchema,
+    copilot: toolConfigSchema,
+    windsurf: toolConfigSchema
   }).partial().optional()
 });
 var skillFrontmatterSchema = z.object({
@@ -403,38 +415,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 getOverrideOutputFiles(rootDir, toolId) {
+async function applyFileOverrides(files, rootDir, toolId) {
   const outputDir = TOOL_OUTPUT_DIRS[toolId];
   const overrideFiles = await scanOverrideDirectory(rootDir, toolId);
-  const result = [];
+  const overridePaths = /* @__PURE__ */ new Set();
+  const overrideOutputFiles = [];
   for (const overrideFile of overrideFiles) {
-    const targetPath = path.join(rootDir, outputDir, overrideFile.relativePath);
-    if (await fileExists2(targetPath)) {
-      continue;
-    }
-    const symlinkPath = `${outputDir}/${overrideFile.relativePath}`;
-    const symlinkDir = path.dirname(symlinkPath);
+    const outputPath = `${outputDir}/${overrideFile.relativePath}`;
+    overridePaths.add(outputPath);
+    const symlinkDir = path.dirname(outputPath);
     const sourcePath = `${UNIFIED_DIR}/${OVERRIDE_DIRS[toolId]}/${overrideFile.relativePath}`;
-    result.push({
-      path: symlinkPath,
+    overrideOutputFiles.push({
+      path: outputPath,
       type: "symlink",
       target: path.relative(symlinkDir, sourcePath)
     });
   }
-  return result;
+  const filteredFiles = files.filter((file) => !overridePaths.has(file.path));
+  return [...filteredFiles, ...overrideOutputFiles];
 }
 
 // src/plugins/claude-code/index.ts
@@ -471,30 +469,21 @@ 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;
-    }
-    let finalSettings = baseSettings;
-    if (state.settings?.overrides?.claudeCode) {
-      finalSettings = deepMergeConfigs(
-        baseSettings,
-        state.settings.overrides.claudeCode
-      );
+      settings["mcpServers"] = state.settings.mcpServers;
     }
-    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 getOverrideOutputFiles(rootDir, "claudeCode");
-    files.push(...overrideFiles);
-    return files;
+    return applyFileOverrides(files, rootDir, "claudeCode");
   },
   validate(state) {
     const warnings = [];
@@ -508,6 +497,197 @@ var claudeCodePlugin = {
   }
 };
 
+// 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: ".github/copilot-instructions.md",
+        type: "symlink",
+        target: `../${UNIFIED_DIR}/AGENTS.md`
+      });
+    }
+    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 - .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);
@@ -522,14 +702,6 @@ function transformRuleToCursor(rule) {
     content: rule.content
   };
 }
-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());
-}
 function serializeCursorRule(frontmatter, content) {
   const lines = [
     "---",
@@ -556,7 +728,7 @@ function transformMcpToCursor(servers) {
         url: server.url
       };
       if (server.headers) {
-        cursorServer.headers = transformEnvVarsToCursor(server.headers);
+        cursorServer.headers = transformEnvVars(server.headers, "cursor");
       }
       result[name] = cursorServer;
     } else if (server.command) {
@@ -567,23 +739,13 @@ function transformMcpToCursor(servers) {
         cursorServer.args = server.args;
       }
       if (server.env) {
-        cursorServer.env = transformEnvVarsToCursor(server.env);
+        cursorServer.env = transformEnvVars(server.env, "cursor");
       }
       result[name] = cursorServer;
     }
   }
   return Object.keys(result).length > 0 ? result : void 0;
 }
-function transformEnvVarToCursor(value) {
-  return value.replace(/\$\{([^}:]+)(:-[^}]*)?\}/g, "${env:$1}");
-}
-function transformEnvVarsToCursor(env) {
-  const result = {};
-  for (const [key, value] of Object.entries(env)) {
-    result[key] = transformEnvVarToCursor(value);
-  }
-  return result;
-}
 function transformPermissionsToCursor(permissions) {
   if (!permissions) {
     return { permissions: void 0, hasAskPermissions: false };
@@ -682,47 +844,22 @@ var cursorPlugin = {
       });
     }
     const mcpServers = transformMcpToCursor(state.settings?.mcpServers);
-    const cursorOverrides = state.settings?.overrides?.cursor;
-    const hasMcpOverrides = cursorOverrides?.["mcpServers"] !== void 0;
-    if (mcpServers || hasMcpOverrides) {
-      let mcpContent = mcpServers ? { mcpServers } : {};
-      if (cursorOverrides?.["mcpServers"]) {
-        mcpContent = deepMergeConfigs(mcpContent, {
-          mcpServers: cursorOverrides["mcpServers"]
-        });
-      }
+    if (mcpServers) {
       files.push({
         path: `${outputDir}/mcp.json`,
         type: "json",
-        content: mcpContent
+        content: { mcpServers }
       });
     }
-    const permissionsResult = transformPermissionsToCursor(
-      state.settings?.permissions
-    );
-    const hasCliOverrides = cursorOverrides !== void 0 && Object.keys(cursorOverrides).some((key) => key !== "mcpServers");
-    if (permissionsResult.permissions || hasCliOverrides) {
-      let cliContent = permissionsResult.permissions ? { permissions: permissionsResult.permissions } : {};
-      if (cursorOverrides) {
-        const cliOverrides = {};
-        for (const [key, value] of Object.entries(cursorOverrides)) {
-          if (key !== "mcpServers") {
-            cliOverrides[key] = value;
-          }
-        }
-        if (Object.keys(cliOverrides).length > 0) {
-          cliContent = deepMergeConfigs(cliContent, cliOverrides);
-        }
-      }
+    const cliContent = buildCliContent(state.settings?.permissions);
+    if (cliContent) {
       files.push({
         path: `${outputDir}/cli.json`,
         type: "json",
         content: cliContent
       });
     }
-    const overrideFiles = await getOverrideOutputFiles(rootDir, "cursor");
-    files.push(...overrideFiles);
-    return files;
+    return applyFileOverrides(files, rootDir, "cursor");
   },
   validate(state) {
     const warnings = [];
@@ -757,6 +894,13 @@ var cursorPlugin = {
     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) {
@@ -781,7 +925,7 @@ function transformMcpToOpenCode(servers) {
         command
       };
       if (server.env) {
-        openCodeServer.environment = transformEnvVars(server.env);
+        openCodeServer.environment = transformEnvVars(server.env, "opencode");
       }
       result[name] = openCodeServer;
     }
@@ -798,7 +942,7 @@ function transformPermissionsToOpenCode(permissions) {
       return;
     }
     for (const rule of rules) {
-      const parsed = parsePermissionRule(rule);
+      const parsed = parsePermissionRuleForOpenCode(rule);
       if (!parsed) {
         continue;
       }
@@ -814,28 +958,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");
   }
@@ -879,37 +1008,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 getOverrideOutputFiles(rootDir, "opencode");
-    files.push(...overrideFiles);
-    return files;
+    return applyFileOverrides(files, rootDir, "opencode");
   },
   validate(state) {
     const warnings = [];
@@ -944,10 +1064,116 @@ var PluginRegistry = class {
 };
 var pluginRegistry = new PluginRegistry();
 
+// src/plugins/windsurf/transforms.ts
+function transformRuleToWindsurf(rule) {
+  const frontmatter = {
+    trigger: "manual"
+  };
+  return {
+    frontmatter,
+    content: rule.content
+  };
+}
+function serializeWindsurfRule(frontmatter, content) {
+  const lines = ["---"];
+  lines.push(`trigger: ${frontmatter.trigger}`);
+  if (frontmatter.globs && frontmatter.globs.length > 0) {
+    lines.push("globs:");
+    for (const glob of frontmatter.globs) {
+      lines.push(`  - ${glob}`);
+    }
+  }
+  if (frontmatter.description) {
+    const escaped = frontmatter.description.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+    lines.push(`description: "${escaped}"`);
+  }
+  lines.push("---");
+  lines.push("");
+  lines.push(content);
+  return lines.join("\n");
+}
+
+// src/plugins/windsurf/index.ts
+var windsurfPlugin = {
+  id: "windsurf",
+  name: "Windsurf",
+  async detect(_rootDir) {
+    return false;
+  },
+  async import(_rootDir) {
+    return null;
+  },
+  async export(state, rootDir) {
+    const files = [];
+    const outputDir = TOOL_OUTPUT_DIRS.windsurf;
+    if (state.agents) {
+      files.push({
+        path: "AGENTS.md",
+        type: "symlink",
+        target: `${UNIFIED_DIR}/AGENTS.md`
+      });
+    }
+    for (const rule of state.rules) {
+      const transformed = transformRuleToWindsurf(rule);
+      const ruleContent = serializeWindsurfRule(
+        transformed.frontmatter,
+        transformed.content
+      );
+      files.push({
+        path: `${outputDir}/rules/${rule.path}`,
+        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}`
+      });
+    }
+    return applyFileOverrides(files, rootDir, "windsurf");
+  },
+  validate(state) {
+    const warnings = [];
+    const skipped = [];
+    if (!state.agents) {
+      warnings.push({
+        path: ["AGENTS.md"],
+        message: "No AGENTS.md found - root AGENTS.md will not be created"
+      });
+    }
+    if (state.rules.length > 0) {
+      warnings.push({
+        path: [".windsurf/rules"],
+        message: "Rules are exported with 'trigger: manual' and require explicit @mention to invoke"
+      });
+    }
+    if (state.settings?.mcpServers && Object.keys(state.settings.mcpServers).length > 0) {
+      skipped.push({
+        feature: "mcpServers",
+        reason: "Windsurf uses global MCP config at ~/.codeium/windsurf/mcp_config.json - project-level MCP servers are not exported"
+      });
+    }
+    if (state.settings?.permissions) {
+      const hasPermissions = (state.settings.permissions.allow?.length ?? 0) > 0 || (state.settings.permissions.ask?.length ?? 0) > 0 || (state.settings.permissions.deny?.length ?? 0) > 0;
+      if (hasPermissions) {
+        skipped.push({
+          feature: "permissions",
+          reason: "Windsurf does not support declarative permissions"
+        });
+      }
+    }
+    return { valid: true, errors: [], warnings, skipped };
+  }
+};
+
 // src/plugins/index.ts
 pluginRegistry.register(claudeCodePlugin);
+pluginRegistry.register(copilotPlugin);
 pluginRegistry.register(cursorPlugin);
 pluginRegistry.register(opencodePlugin);
+pluginRegistry.register(windsurfPlugin);
 function computeHash(content) {
   return crypto.createHash("sha256").update(content, "utf-8").digest("hex");
 }
@@ -1060,9 +1286,8 @@ async function updateGitignore(rootDir, paths) {
   const markerRegex = new RegExp(`${marker}[\\s\\S]*?${endMarker}\\n?`, "g");
   content = content.replace(markerRegex, "");
   content = content.trimEnd();
-  const newSection = ["", marker, ...paths.map((p) => p), endMarker, ""].join(
-    "\n"
-  );
+  const uniquePaths = [...new Set(paths)];
+  const newSection = ["", marker, ...uniquePaths, endMarker, ""].join("\n");
   content = content + newSection;
   await fs3.writeFile(gitignorePath, content, "utf-8");
 }
@@ -1138,10 +1363,16 @@ async function runSyncPipeline(options) {
   return results;
 }
 async function initUnifiedConfig(options) {
-  const { rootDir, tools, minimal = false, force = false } = options;
+  const {
+    rootDir,
+    tools,
+    minimal = false,
+    force = false,
+    versionControl
+  } = options;
   const aiDir = path.join(rootDir, UNIFIED_DIR);
   const created = [];
-  const config = generateDefaultConfig(tools);
+  const config = generateDefaultConfig(tools, versionControl);
   const exists = await hasUnifiedConfig(rootDir);
   if (exists && !force) {
     throw new ValidationError(
@@ -1183,7 +1414,7 @@ async function hasUnifiedConfig(rootDir) {
     return false;
   }
 }
-function generateDefaultConfig(tools) {
+function generateDefaultConfig(tools, versionControl) {
   if (tools) {
     const validation = validateToolIds(tools);
     if (!validation.valid) {
@@ -1200,7 +1431,7 @@ function generateDefaultConfig(tools) {
   for (const toolId of TOOL_IDS) {
     toolsConfig[toolId] = {
       enabled: enabledTools.includes(toolId),
-      versionControl: false
+      versionControl: versionControl?.[toolId] ?? false
     };
   }
   return { tools: toolsConfig };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lnai/core",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "description": "Core library for LNAI - unified AI config management",
   "type": "module",
   "license": "MIT",
@@ -21,6 +21,9 @@
     "claude",
     "cursor",
     "opencode",
+    "copilot",
+    "github-copilot",
+    "windsurf",
     "cli",
     "ai-tools"
   ],
@@ -34,7 +37,6 @@
     "dist"
   ],
   "dependencies": {
-    "deepmerge": "^4.3.1",
     "gray-matter": "^4.0.3",
     "zod": "^4.3.6"
   },