@every-env/compound-plugin 0.7.0 → 0.8.0

package/src/sync/{cursor.ts → copilot.ts}

@@ -4,19 +4,21 @@ import type { ClaudeHomeConfig } from "../parsers/claude-home"
 import type { ClaudeMcpServer } from "../types/claude"
 import { forceSymlink, isValidSkillName } from "../utils/symlink"
 
-type CursorMcpServer = {
+type CopilotMcpServer = {
+  type: string
   command?: string
   args?: string[]
   url?: string
+  tools: string[]
   env?: Record<string, string>
   headers?: Record<string, string>
 }
 
-type CursorMcpConfig = {
-  mcpServers: Record<string, CursorMcpServer>
+type CopilotMcpConfig = {
+  mcpServers: Record<string, CopilotMcpServer>
 }
 
-export async function syncToCursor(
+export async function syncToCopilot(
   config: ClaudeHomeConfig,
   outputRoot: string,
 ): Promise<void> {
@@ -33,10 +35,10 @@ export async function syncToCursor(
   }
 
   if (Object.keys(config.mcpServers).length > 0) {
-    const mcpPath = path.join(outputRoot, "mcp.json")
+    const mcpPath = path.join(outputRoot, "copilot-mcp-config.json")
     const existing = await readJsonSafe(mcpPath)
-    const converted = convertMcpForCursor(config.mcpServers)
-    const merged: CursorMcpConfig = {
+    const converted = convertMcpForCopilot(config.mcpServers)
+    const merged: CopilotMcpConfig = {
       mcpServers: {
         ...(existing.mcpServers ?? {}),
         ...converted,
@@ -46,10 +48,10 @@ export async function syncToCursor(
   }
 }
 
-async function readJsonSafe(filePath: string): Promise<Partial<CursorMcpConfig>> {
+async function readJsonSafe(filePath: string): Promise<Partial<CopilotMcpConfig>> {
   try {
     const content = await fs.readFile(filePath, "utf-8")
-    return JSON.parse(content) as Partial<CursorMcpConfig>
+    return JSON.parse(content) as Partial<CopilotMcpConfig>
   } catch (err) {
     if ((err as NodeJS.ErrnoException).code === "ENOENT") {
       return {}
@@ -58,21 +60,41 @@ async function readJsonSafe(filePath: string): Promise<Partial<CursorMcpConfig>>
   }
 }
 
-function convertMcpForCursor(
+function convertMcpForCopilot(
   servers: Record<string, ClaudeMcpServer>,
-): Record<string, CursorMcpServer> {
-  const result: Record<string, CursorMcpServer> = {}
+): Record<string, CopilotMcpServer> {
+  const result: Record<string, CopilotMcpServer> = {}
   for (const [name, server] of Object.entries(servers)) {
-    const entry: CursorMcpServer = {}
+    const entry: CopilotMcpServer = {
+      type: server.command ? "local" : "sse",
+      tools: ["*"],
+    }
+
     if (server.command) {
       entry.command = server.command
       if (server.args && server.args.length > 0) entry.args = server.args
-      if (server.env && Object.keys(server.env).length > 0) entry.env = server.env
     } else if (server.url) {
       entry.url = server.url
       if (server.headers && Object.keys(server.headers).length > 0) entry.headers = server.headers
     }
+
+    if (server.env && Object.keys(server.env).length > 0) {
+      entry.env = prefixEnvVars(server.env)
+    }
+
     result[name] = entry
   }
   return result
 }
+
+function prefixEnvVars(env: Record<string, string>): Record<string, string> {
+  const result: Record<string, string> = {}
+  for (const [key, value] of Object.entries(env)) {
+    if (key.startsWith("COPILOT_MCP_")) {
+      result[key] = value
+    } else {
+      result[`COPILOT_MCP_${key}`] = value
+    }
+  }
+  return result
+}

package/src/targets/copilot.ts

@@ -0,0 +1,48 @@
+import path from "path"
+import { backupFile, copyDir, ensureDir, writeJson, writeText } from "../utils/files"
+import type { CopilotBundle } from "../types/copilot"
+
+export async function writeCopilotBundle(outputRoot: string, bundle: CopilotBundle): Promise<void> {
+  const paths = resolveCopilotPaths(outputRoot)
+  await ensureDir(paths.githubDir)
+
+  if (bundle.agents.length > 0) {
+    const agentsDir = path.join(paths.githubDir, "agents")
+    for (const agent of bundle.agents) {
+      await writeText(path.join(agentsDir, `${agent.name}.agent.md`), agent.content + "\n")
+    }
+  }
+
+  if (bundle.generatedSkills.length > 0) {
+    const skillsDir = path.join(paths.githubDir, "skills")
+    for (const skill of bundle.generatedSkills) {
+      await writeText(path.join(skillsDir, skill.name, "SKILL.md"), skill.content + "\n")
+    }
+  }
+
+  if (bundle.skillDirs.length > 0) {
+    const skillsDir = path.join(paths.githubDir, "skills")
+    for (const skill of bundle.skillDirs) {
+      await copyDir(skill.sourceDir, path.join(skillsDir, skill.name))
+    }
+  }
+
+  if (bundle.mcpConfig && Object.keys(bundle.mcpConfig).length > 0) {
+    const mcpPath = path.join(paths.githubDir, "copilot-mcp-config.json")
+    const backupPath = await backupFile(mcpPath)
+    if (backupPath) {
+      console.log(`Backed up existing copilot-mcp-config.json to ${backupPath}`)
+    }
+    await writeJson(mcpPath, { mcpServers: bundle.mcpConfig })
+  }
+}
+
+function resolveCopilotPaths(outputRoot: string) {
+  const base = path.basename(outputRoot)
+  // If already pointing at .github, write directly into it
+  if (base === ".github") {
+    return { githubDir: outputRoot }
+  }
+  // Otherwise nest under .github
+  return { githubDir: path.join(outputRoot, ".github") }
+}

package/src/targets/index.ts

@@ -2,20 +2,20 @@ import type { ClaudePlugin } from "../types/claude"
 import type { OpenCodeBundle } from "../types/opencode"
 import type { CodexBundle } from "../types/codex"
 import type { DroidBundle } from "../types/droid"
-import type { CursorBundle } from "../types/cursor"
 import type { PiBundle } from "../types/pi"
+import type { CopilotBundle } from "../types/copilot"
 import type { GeminiBundle } from "../types/gemini"
 import { convertClaudeToOpenCode, type ClaudeToOpenCodeOptions } from "../converters/claude-to-opencode"
 import { convertClaudeToCodex } from "../converters/claude-to-codex"
 import { convertClaudeToDroid } from "../converters/claude-to-droid"
-import { convertClaudeToCursor } from "../converters/claude-to-cursor"
 import { convertClaudeToPi } from "../converters/claude-to-pi"
+import { convertClaudeToCopilot } from "../converters/claude-to-copilot"
 import { convertClaudeToGemini } from "../converters/claude-to-gemini"
 import { writeOpenCodeBundle } from "./opencode"
 import { writeCodexBundle } from "./codex"
 import { writeDroidBundle } from "./droid"
-import { writeCursorBundle } from "./cursor"
 import { writePiBundle } from "./pi"
+import { writeCopilotBundle } from "./copilot"
 import { writeGeminiBundle } from "./gemini"
 
 export type TargetHandler<TBundle = unknown> = {
@@ -44,18 +44,18 @@ export const targets: Record<string, TargetHandler> = {
     convert: convertClaudeToDroid as TargetHandler<DroidBundle>["convert"],
     write: writeDroidBundle as TargetHandler<DroidBundle>["write"],
   },
-  cursor: {
-    name: "cursor",
-    implemented: true,
-    convert: convertClaudeToCursor as TargetHandler<CursorBundle>["convert"],
-    write: writeCursorBundle as TargetHandler<CursorBundle>["write"],
-  },
   pi: {
     name: "pi",
     implemented: true,
     convert: convertClaudeToPi as TargetHandler<PiBundle>["convert"],
     write: writePiBundle as TargetHandler<PiBundle>["write"],
   },
+  copilot: {
+    name: "copilot",
+    implemented: true,
+    convert: convertClaudeToCopilot as TargetHandler<CopilotBundle>["convert"],
+    write: writeCopilotBundle as TargetHandler<CopilotBundle>["write"],
+  },
   gemini: {
     name: "gemini",
     implemented: true,

package/src/types/copilot.ts

@@ -0,0 +1,31 @@
+export type CopilotAgent = {
+  name: string
+  content: string
+}
+
+export type CopilotGeneratedSkill = {
+  name: string
+  content: string
+}
+
+export type CopilotSkillDir = {
+  name: string
+  sourceDir: string
+}
+
+export type CopilotMcpServer = {
+  type: string
+  command?: string
+  args?: string[]
+  url?: string
+  tools: string[]
+  env?: Record<string, string>
+  headers?: Record<string, string>
+}
+
+export type CopilotBundle = {
+  agents: CopilotAgent[]
+  generatedSkills: CopilotGeneratedSkill[]
+  skillDirs: CopilotSkillDir[]
+  mcpConfig?: Record<string, CopilotMcpServer>
+}

package/src/utils/frontmatter.ts

@@ -58,7 +58,7 @@ function formatYamlValue(value: unknown): string {
   if (raw.includes("\n")) {
     return `|\n${raw.split("\n").map((line) => `  ${line}`).join("\n")}`
   }
-  if (raw.includes(":") || raw.startsWith("[") || raw.startsWith("{")) {
+  if (raw.includes(":") || raw.startsWith("[") || raw.startsWith("{") || raw === "*") {
     return JSON.stringify(raw)
   }
   return raw