@every-env/compound-plugin 0.7.0 → 0.9.0

package/src/targets/index.ts

@@ -2,21 +2,24 @@ 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 type { KiroBundle } from "../types/kiro"
 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 { convertClaudeToKiro } from "../converters/claude-to-kiro"
 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"
+import { writeKiroBundle } from "./kiro"
 
 export type TargetHandler<TBundle = unknown> = {
   name: string
@@ -44,22 +47,28 @@ 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,
     convert: convertClaudeToGemini as TargetHandler<GeminiBundle>["convert"],
     write: writeGeminiBundle as TargetHandler<GeminiBundle>["write"],
   },
+  kiro: {
+    name: "kiro",
+    implemented: true,
+    convert: convertClaudeToKiro as TargetHandler<KiroBundle>["convert"],
+    write: writeKiroBundle as TargetHandler<KiroBundle>["write"],
+  },
 }

package/src/targets/kiro.ts

@@ -0,0 +1,122 @@
+import path from "path"
+import { backupFile, copyDir, ensureDir, pathExists, readJson, writeJson, writeText } from "../utils/files"
+import type { KiroBundle } from "../types/kiro"
+
+export async function writeKiroBundle(outputRoot: string, bundle: KiroBundle): Promise<void> {
+  const paths = resolveKiroPaths(outputRoot)
+  await ensureDir(paths.kiroDir)
+
+  // Write agents
+  if (bundle.agents.length > 0) {
+    for (const agent of bundle.agents) {
+      // Validate name doesn't escape agents directory
+      validatePathSafe(agent.name, "agent")
+
+      // Write agent JSON config
+      await writeJson(
+        path.join(paths.agentsDir, `${agent.name}.json`),
+        agent.config,
+      )
+
+      // Write agent prompt file
+      await writeText(
+        path.join(paths.agentsDir, "prompts", `${agent.name}.md`),
+        agent.promptContent + "\n",
+      )
+    }
+  }
+
+  // Write generated skills (from commands)
+  if (bundle.generatedSkills.length > 0) {
+    for (const skill of bundle.generatedSkills) {
+      validatePathSafe(skill.name, "skill")
+      await writeText(
+        path.join(paths.skillsDir, skill.name, "SKILL.md"),
+        skill.content + "\n",
+      )
+    }
+  }
+
+  // Copy skill directories (pass-through)
+  if (bundle.skillDirs.length > 0) {
+    for (const skill of bundle.skillDirs) {
+      validatePathSafe(skill.name, "skill directory")
+      const destDir = path.join(paths.skillsDir, skill.name)
+
+      // Validate destination doesn't escape skills directory
+      const resolvedDest = path.resolve(destDir)
+      if (!resolvedDest.startsWith(path.resolve(paths.skillsDir))) {
+        console.warn(`Warning: Skill name "${skill.name}" escapes .kiro/skills/. Skipping.`)
+        continue
+      }
+
+      await copyDir(skill.sourceDir, destDir)
+    }
+  }
+
+  // Write steering files
+  if (bundle.steeringFiles.length > 0) {
+    for (const file of bundle.steeringFiles) {
+      validatePathSafe(file.name, "steering file")
+      await writeText(
+        path.join(paths.steeringDir, `${file.name}.md`),
+        file.content + "\n",
+      )
+    }
+  }
+
+  // Write MCP servers to mcp.json
+  if (Object.keys(bundle.mcpServers).length > 0) {
+    const mcpPath = path.join(paths.settingsDir, "mcp.json")
+    const backupPath = await backupFile(mcpPath)
+    if (backupPath) {
+      console.log(`Backed up existing mcp.json to ${backupPath}`)
+    }
+
+    // Merge with existing mcp.json if present
+    let existingConfig: Record<string, unknown> = {}
+    if (await pathExists(mcpPath)) {
+      try {
+        existingConfig = await readJson<Record<string, unknown>>(mcpPath)
+      } catch {
+        console.warn("Warning: existing mcp.json could not be parsed and will be replaced.")
+      }
+    }
+
+    const existingServers =
+      existingConfig.mcpServers && typeof existingConfig.mcpServers === "object"
+        ? (existingConfig.mcpServers as Record<string, unknown>)
+        : {}
+    const merged = { ...existingConfig, mcpServers: { ...existingServers, ...bundle.mcpServers } }
+    await writeJson(mcpPath, merged)
+  }
+}
+
+function resolveKiroPaths(outputRoot: string) {
+  const base = path.basename(outputRoot)
+  // If already pointing at .kiro, write directly into it
+  if (base === ".kiro") {
+    return {
+      kiroDir: outputRoot,
+      agentsDir: path.join(outputRoot, "agents"),
+      skillsDir: path.join(outputRoot, "skills"),
+      steeringDir: path.join(outputRoot, "steering"),
+      settingsDir: path.join(outputRoot, "settings"),
+    }
+  }
+  // Otherwise nest under .kiro
+  const kiroDir = path.join(outputRoot, ".kiro")
+  return {
+    kiroDir,
+    agentsDir: path.join(kiroDir, "agents"),
+    skillsDir: path.join(kiroDir, "skills"),
+    steeringDir: path.join(kiroDir, "steering"),
+    settingsDir: path.join(kiroDir, "settings"),
+  }
+}
+
+function validatePathSafe(name: string, label: string): void {
+  if (name.includes("..") || name.includes("/") || name.includes("\\")) {
+    throw new Error(`${label} name contains unsafe path characters: ${name}`)
+  }
+}

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/types/kiro.ts

@@ -0,0 +1,44 @@
+export type KiroAgent = {
+  name: string
+  config: KiroAgentConfig
+  promptContent: string
+}
+
+export type KiroAgentConfig = {
+  name: string
+  description: string
+  prompt: `file://${string}`
+  tools: ["*"]
+  resources: string[]
+  includeMcpJson: true
+  welcomeMessage?: string
+}
+
+export type KiroSkill = {
+  name: string
+  content: string // Full SKILL.md with YAML frontmatter
+}
+
+export type KiroSkillDir = {
+  name: string
+  sourceDir: string
+}
+
+export type KiroSteeringFile = {
+  name: string
+  content: string
+}
+
+export type KiroMcpServer = {
+  command: string
+  args?: string[]
+  env?: Record<string, string>
+}
+
+export type KiroBundle = {
+  agents: KiroAgent[]
+  generatedSkills: KiroSkill[]
+  skillDirs: KiroSkillDir[]
+  steeringFiles: KiroSteeringFile[]
+  mcpServers: Record<string, KiroMcpServer>
+}

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