@lnai/core 0.2.0 → 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", "cursor"];
+declare const TOOL_IDS: readonly ["claudeCode", "opencode", "cursor", "copilot"];
 type ToolId = (typeof TOOL_IDS)[number];
 declare const CONFIG_FILES: {
     readonly config: "config.json";
@@ -66,6 +66,7 @@ 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<{
@@ -85,11 +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>>;
-        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 +102,10 @@ 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>>;
     }, z.core.$strip>>;
 }, z.core.$strip>;
 /** Skill frontmatter (name and description required) */
@@ -145,7 +145,6 @@ interface UnifiedState {
     settings: {
         permissions?: Permissions;
         mcpServers?: Record<string, McpServer>;
-        overrides?: Partial<Record<ToolId, Record<string, unknown>>>;
     } | 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", "cursor"];
+var TOOL_IDS = ["claudeCode", "opencode", "cursor", "copilot"];
 var CONFIG_FILES = {
   config: "config.json",
   settings: "settings.json",
@@ -21,12 +20,14 @@ var CONFIG_DIRS = {
 var TOOL_OUTPUT_DIRS = {
   claudeCode: ".claude",
   opencode: ".opencode",
-  cursor: ".cursor"
+  cursor: ".cursor",
+  copilot: ".github"
 };
 var OVERRIDE_DIRS = {
   claudeCode: ".claude",
   opencode: ".opencode",
-  cursor: ".cursor"
+  cursor: ".cursor",
+  copilot: ".copilot"
 };
 
 // src/errors.ts
@@ -106,21 +107,17 @@ 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"]);
 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
   }).partial().optional()
 });
 var skillFrontmatterSchema = z.object({
@@ -403,38 +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 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 +454,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 +482,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 +687,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 +713,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 +724,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 +829,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 +879,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 +910,7 @@ function transformMcpToOpenCode(servers) {
         command
       };
       if (server.env) {
-        openCodeServer.environment = transformEnvVars(server.env);
+        openCodeServer.environment = transformEnvVars(server.env, "opencode");
       }
       result[name] = openCodeServer;
     }
@@ -798,7 +927,7 @@ function transformPermissionsToOpenCode(permissions) {
       return;
     }
     for (const rule of rules) {
-      const parsed = parsePermissionRule(rule);
+      const parsed = parsePermissionRuleForOpenCode(rule);
       if (!parsed) {
         continue;
       }
@@ -814,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) {
+function parsePermissionRuleForOpenCode(rule) {
+  const parsed = parsePermissionRule(rule);
+  if (!parsed) {
     return null;
   }
-  const tool = match[1];
-  const pattern = match[2];
-  if (!tool || !pattern) {
-    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 +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 getOverrideOutputFiles(rootDir, "opencode");
-    files.push(...overrideFiles);
-    return files;
+    return applyFileOverrides(files, rootDir, "opencode");
   },
   validate(state) {
     const warnings = [];
@@ -946,6 +1051,7 @@ var pluginRegistry = new PluginRegistry();
 
 // src/plugins/index.ts
 pluginRegistry.register(claudeCodePlugin);
+pluginRegistry.register(copilotPlugin);
 pluginRegistry.register(cursorPlugin);
 pluginRegistry.register(opencodePlugin);
 function computeHash(content) {

package/package.json

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