@every-env/compound-plugin 0.5.2 → 0.8.0

package/tests/pi-writer.test.ts

@@ -0,0 +1,99 @@
+import { describe, expect, test } from "bun:test"
+import { promises as fs } from "fs"
+import path from "path"
+import os from "os"
+import { writePiBundle } from "../src/targets/pi"
+import type { PiBundle } from "../src/types/pi"
+
+async function exists(filePath: string): Promise<boolean> {
+  try {
+    await fs.access(filePath)
+    return true
+  } catch {
+    return false
+  }
+}
+
+describe("writePiBundle", () => {
+  test("writes prompts, skills, extensions, mcporter config, and AGENTS.md block", async () => {
+    const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), "pi-writer-"))
+    const outputRoot = path.join(tempRoot, ".pi")
+
+    const bundle: PiBundle = {
+      prompts: [{ name: "workflows-plan", content: "Prompt content" }],
+      skillDirs: [
+        {
+          name: "skill-one",
+          sourceDir: path.join(import.meta.dir, "fixtures", "sample-plugin", "skills", "skill-one"),
+        },
+      ],
+      generatedSkills: [{ name: "repo-research-analyst", content: "---\nname: repo-research-analyst\n---\n\nBody" }],
+      extensions: [{ name: "compound-engineering-compat.ts", content: "export default function () {}" }],
+      mcporterConfig: {
+        mcpServers: {
+          context7: { baseUrl: "https://mcp.context7.com/mcp" },
+        },
+      },
+    }
+
+    await writePiBundle(outputRoot, bundle)
+
+    expect(await exists(path.join(outputRoot, "prompts", "workflows-plan.md"))).toBe(true)
+    expect(await exists(path.join(outputRoot, "skills", "skill-one", "SKILL.md"))).toBe(true)
+    expect(await exists(path.join(outputRoot, "skills", "repo-research-analyst", "SKILL.md"))).toBe(true)
+    expect(await exists(path.join(outputRoot, "extensions", "compound-engineering-compat.ts"))).toBe(true)
+    expect(await exists(path.join(outputRoot, "compound-engineering", "mcporter.json"))).toBe(true)
+
+    const agentsPath = path.join(outputRoot, "AGENTS.md")
+    const agentsContent = await fs.readFile(agentsPath, "utf8")
+    expect(agentsContent).toContain("BEGIN COMPOUND PI TOOL MAP")
+    expect(agentsContent).toContain("MCPorter")
+  })
+
+  test("writes to ~/.pi/agent style roots without nesting under .pi", async () => {
+    const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), "pi-agent-root-"))
+    const outputRoot = path.join(tempRoot, "agent")
+
+    const bundle: PiBundle = {
+      prompts: [{ name: "workflows-work", content: "Prompt content" }],
+      skillDirs: [],
+      generatedSkills: [],
+      extensions: [],
+    }
+
+    await writePiBundle(outputRoot, bundle)
+
+    expect(await exists(path.join(outputRoot, "prompts", "workflows-work.md"))).toBe(true)
+    expect(await exists(path.join(outputRoot, ".pi"))).toBe(false)
+  })
+
+  test("backs up existing mcporter config before overwriting", async () => {
+    const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), "pi-backup-"))
+    const outputRoot = path.join(tempRoot, ".pi")
+    const configPath = path.join(outputRoot, "compound-engineering", "mcporter.json")
+
+    await fs.mkdir(path.dirname(configPath), { recursive: true })
+    await fs.writeFile(configPath, JSON.stringify({ previous: true }, null, 2))
+
+    const bundle: PiBundle = {
+      prompts: [],
+      skillDirs: [],
+      generatedSkills: [],
+      extensions: [],
+      mcporterConfig: {
+        mcpServers: {
+          linear: { baseUrl: "https://mcp.linear.app/mcp" },
+        },
+      },
+    }
+
+    await writePiBundle(outputRoot, bundle)
+
+    const files = await fs.readdir(path.dirname(configPath))
+    const backupFileName = files.find((file) => file.startsWith("mcporter.json.bak."))
+    expect(backupFileName).toBeDefined()
+
+    const currentConfig = JSON.parse(await fs.readFile(configPath, "utf8")) as { mcpServers: Record<string, unknown> }
+    expect(currentConfig.mcpServers.linear).toBeDefined()
+  })
+})

package/tests/sync-copilot.test.ts

@@ -0,0 +1,148 @@
+import { describe, expect, test } from "bun:test"
+import { promises as fs } from "fs"
+import path from "path"
+import os from "os"
+import { syncToCopilot } from "../src/sync/copilot"
+import type { ClaudeHomeConfig } from "../src/parsers/claude-home"
+
+describe("syncToCopilot", () => {
+  test("symlinks skills to .github/skills/", async () => {
+    const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), "sync-copilot-"))
+    const fixtureSkillDir = path.join(import.meta.dir, "fixtures", "sample-plugin", "skills", "skill-one")
+
+    const config: ClaudeHomeConfig = {
+      skills: [
+        {
+          name: "skill-one",
+          sourceDir: fixtureSkillDir,
+          skillPath: path.join(fixtureSkillDir, "SKILL.md"),
+        },
+      ],
+      mcpServers: {},
+    }
+
+    await syncToCopilot(config, tempRoot)
+
+    const linkedSkillPath = path.join(tempRoot, "skills", "skill-one")
+    const linkedStat = await fs.lstat(linkedSkillPath)
+    expect(linkedStat.isSymbolicLink()).toBe(true)
+  })
+
+  test("skips skills with invalid names", async () => {
+    const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), "sync-copilot-invalid-"))
+
+    const config: ClaudeHomeConfig = {
+      skills: [
+        {
+          name: "../escape-attempt",
+          sourceDir: "/tmp/bad-skill",
+          skillPath: "/tmp/bad-skill/SKILL.md",
+        },
+      ],
+      mcpServers: {},
+    }
+
+    await syncToCopilot(config, tempRoot)
+
+    const skillsDir = path.join(tempRoot, "skills")
+    const entries = await fs.readdir(skillsDir).catch(() => [])
+    expect(entries).toHaveLength(0)
+  })
+
+  test("merges MCP config with existing file", async () => {
+    const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), "sync-copilot-merge-"))
+    const mcpPath = path.join(tempRoot, "copilot-mcp-config.json")
+
+    await fs.writeFile(
+      mcpPath,
+      JSON.stringify({
+        mcpServers: {
+          existing: { type: "local", command: "node", args: ["server.js"], tools: ["*"] },
+        },
+      }, null, 2),
+    )
+
+    const config: ClaudeHomeConfig = {
+      skills: [],
+      mcpServers: {
+        context7: { url: "https://mcp.context7.com/mcp" },
+      },
+    }
+
+    await syncToCopilot(config, tempRoot)
+
+    const merged = JSON.parse(await fs.readFile(mcpPath, "utf8")) as {
+      mcpServers: Record<string, { command?: string; url?: string; type: string }>
+    }
+
+    expect(merged.mcpServers.existing?.command).toBe("node")
+    expect(merged.mcpServers.context7?.url).toBe("https://mcp.context7.com/mcp")
+  })
+
+  test("transforms MCP env var names to COPILOT_MCP_ prefix", async () => {
+    const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), "sync-copilot-env-"))
+
+    const config: ClaudeHomeConfig = {
+      skills: [],
+      mcpServers: {
+        server: {
+          command: "echo",
+          args: ["hello"],
+          env: { API_KEY: "secret", COPILOT_MCP_TOKEN: "already-prefixed" },
+        },
+      },
+    }
+
+    await syncToCopilot(config, tempRoot)
+
+    const mcpPath = path.join(tempRoot, "copilot-mcp-config.json")
+    const mcpConfig = JSON.parse(await fs.readFile(mcpPath, "utf8")) as {
+      mcpServers: Record<string, { env?: Record<string, string> }>
+    }
+
+    expect(mcpConfig.mcpServers.server?.env).toEqual({
+      COPILOT_MCP_API_KEY: "secret",
+      COPILOT_MCP_TOKEN: "already-prefixed",
+    })
+  })
+
+  test("writes MCP config with restricted permissions", async () => {
+    const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), "sync-copilot-perms-"))
+
+    const config: ClaudeHomeConfig = {
+      skills: [],
+      mcpServers: {
+        server: { command: "echo", args: ["hello"] },
+      },
+    }
+
+    await syncToCopilot(config, tempRoot)
+
+    const mcpPath = path.join(tempRoot, "copilot-mcp-config.json")
+    const stat = await fs.stat(mcpPath)
+    // Check owner read+write permission (0o600 = 33216 in decimal, masked to file perms)
+    const perms = stat.mode & 0o777
+    expect(perms).toBe(0o600)
+  })
+
+  test("does not write MCP config when no MCP servers", async () => {
+    const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), "sync-copilot-nomcp-"))
+    const fixtureSkillDir = path.join(import.meta.dir, "fixtures", "sample-plugin", "skills", "skill-one")
+
+    const config: ClaudeHomeConfig = {
+      skills: [
+        {
+          name: "skill-one",
+          sourceDir: fixtureSkillDir,
+          skillPath: path.join(fixtureSkillDir, "SKILL.md"),
+        },
+      ],
+      mcpServers: {},
+    }
+
+    await syncToCopilot(config, tempRoot)
+
+    const mcpExists = await fs.access(path.join(tempRoot, "copilot-mcp-config.json")).then(() => true).catch(() => false)
+    expect(mcpExists).toBe(false)
+  })
+})

package/tests/sync-droid.test.ts

@@ -0,0 +1,57 @@
+import { describe, expect, test } from "bun:test"
+import { promises as fs } from "fs"
+import path from "path"
+import os from "os"
+import { syncToDroid } from "../src/sync/droid"
+import type { ClaudeHomeConfig } from "../src/parsers/claude-home"
+
+describe("syncToDroid", () => {
+  test("symlinks skills to factory skills dir", async () => {
+    const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), "sync-droid-"))
+    const fixtureSkillDir = path.join(import.meta.dir, "fixtures", "sample-plugin", "skills", "skill-one")
+
+    const config: ClaudeHomeConfig = {
+      skills: [
+        {
+          name: "skill-one",
+          sourceDir: fixtureSkillDir,
+          skillPath: path.join(fixtureSkillDir, "SKILL.md"),
+        },
+      ],
+      mcpServers: {
+        context7: { url: "https://mcp.context7.com/mcp" },
+      },
+    }
+
+    await syncToDroid(config, tempRoot)
+
+    const linkedSkillPath = path.join(tempRoot, "skills", "skill-one")
+    const linkedStat = await fs.lstat(linkedSkillPath)
+    expect(linkedStat.isSymbolicLink()).toBe(true)
+
+    // Droid does not write MCP config
+    const mcpExists = await fs.access(path.join(tempRoot, "mcp.json")).then(() => true).catch(() => false)
+    expect(mcpExists).toBe(false)
+  })
+
+  test("skips skills with invalid names", async () => {
+    const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), "sync-droid-invalid-"))
+    const fixtureSkillDir = path.join(import.meta.dir, "fixtures", "sample-plugin", "skills", "skill-one")
+
+    const config: ClaudeHomeConfig = {
+      skills: [
+        {
+          name: "../escape",
+          sourceDir: fixtureSkillDir,
+          skillPath: path.join(fixtureSkillDir, "SKILL.md"),
+        },
+      ],
+      mcpServers: {},
+    }
+
+    await syncToDroid(config, tempRoot)
+
+    const entries = await fs.readdir(path.join(tempRoot, "skills"))
+    expect(entries).toHaveLength(0)
+  })
+})

package/tests/sync-pi.test.ts

@@ -0,0 +1,68 @@
+import { describe, expect, test } from "bun:test"
+import { promises as fs } from "fs"
+import path from "path"
+import os from "os"
+import { syncToPi } from "../src/sync/pi"
+import type { ClaudeHomeConfig } from "../src/parsers/claude-home"
+
+describe("syncToPi", () => {
+  test("symlinks skills and writes MCPorter config", async () => {
+    const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), "sync-pi-"))
+    const fixtureSkillDir = path.join(import.meta.dir, "fixtures", "sample-plugin", "skills", "skill-one")
+
+    const config: ClaudeHomeConfig = {
+      skills: [
+        {
+          name: "skill-one",
+          sourceDir: fixtureSkillDir,
+          skillPath: path.join(fixtureSkillDir, "SKILL.md"),
+        },
+      ],
+      mcpServers: {
+        context7: { url: "https://mcp.context7.com/mcp" },
+        local: { command: "echo", args: ["hello"] },
+      },
+    }
+
+    await syncToPi(config, tempRoot)
+
+    const linkedSkillPath = path.join(tempRoot, "skills", "skill-one")
+    const linkedStat = await fs.lstat(linkedSkillPath)
+    expect(linkedStat.isSymbolicLink()).toBe(true)
+
+    const mcporterPath = path.join(tempRoot, "compound-engineering", "mcporter.json")
+    const mcporterConfig = JSON.parse(await fs.readFile(mcporterPath, "utf8")) as {
+      mcpServers: Record<string, { baseUrl?: string; command?: string }>
+    }
+
+    expect(mcporterConfig.mcpServers.context7?.baseUrl).toBe("https://mcp.context7.com/mcp")
+    expect(mcporterConfig.mcpServers.local?.command).toBe("echo")
+  })
+
+  test("merges existing MCPorter config", async () => {
+    const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), "sync-pi-merge-"))
+    const mcporterPath = path.join(tempRoot, "compound-engineering", "mcporter.json")
+    await fs.mkdir(path.dirname(mcporterPath), { recursive: true })
+
+    await fs.writeFile(
+      mcporterPath,
+      JSON.stringify({ mcpServers: { existing: { baseUrl: "https://example.com/mcp" } } }, null, 2),
+    )
+
+    const config: ClaudeHomeConfig = {
+      skills: [],
+      mcpServers: {
+        context7: { url: "https://mcp.context7.com/mcp" },
+      },
+    }
+
+    await syncToPi(config, tempRoot)
+
+    const merged = JSON.parse(await fs.readFile(mcporterPath, "utf8")) as {
+      mcpServers: Record<string, { baseUrl?: string }>
+    }
+
+    expect(merged.mcpServers.existing?.baseUrl).toBe("https://example.com/mcp")
+    expect(merged.mcpServers.context7?.baseUrl).toBe("https://mcp.context7.com/mcp")
+  })
+})

package/src/targets/cursor.ts

@@ -1,48 +0,0 @@
-import path from "path"
-import { backupFile, copyDir, ensureDir, writeJson, writeText } from "../utils/files"
-import type { CursorBundle } from "../types/cursor"
-
-export async function writeCursorBundle(outputRoot: string, bundle: CursorBundle): Promise<void> {
-  const paths = resolveCursorPaths(outputRoot)
-  await ensureDir(paths.cursorDir)
-
-  if (bundle.rules.length > 0) {
-    const rulesDir = path.join(paths.cursorDir, "rules")
-    for (const rule of bundle.rules) {
-      await writeText(path.join(rulesDir, `${rule.name}.mdc`), rule.content + "\n")
-    }
-  }
-
-  if (bundle.commands.length > 0) {
-    const commandsDir = path.join(paths.cursorDir, "commands")
-    for (const command of bundle.commands) {
-      await writeText(path.join(commandsDir, `${command.name}.md`), command.content + "\n")
-    }
-  }
-
-  if (bundle.skillDirs.length > 0) {
-    const skillsDir = path.join(paths.cursorDir, "skills")
-    for (const skill of bundle.skillDirs) {
-      await copyDir(skill.sourceDir, path.join(skillsDir, skill.name))
-    }
-  }
-
-  if (bundle.mcpServers && Object.keys(bundle.mcpServers).length > 0) {
-    const mcpPath = path.join(paths.cursorDir, "mcp.json")
-    const backupPath = await backupFile(mcpPath)
-    if (backupPath) {
-      console.log(`Backed up existing mcp.json to ${backupPath}`)
-    }
-    await writeJson(mcpPath, { mcpServers: bundle.mcpServers })
-  }
-}
-
-function resolveCursorPaths(outputRoot: string) {
-  const base = path.basename(outputRoot)
-  // If already pointing at .cursor, write directly into it
-  if (base === ".cursor") {
-    return { cursorDir: outputRoot }
-  }
-  // Otherwise nest under .cursor
-  return { cursorDir: path.join(outputRoot, ".cursor") }
-}

package/src/types/cursor.ts

@@ -1,29 +0,0 @@
-export type CursorRule = {
-  name: string
-  content: string
-}
-
-export type CursorCommand = {
-  name: string
-  content: string
-}
-
-export type CursorSkillDir = {
-  name: string
-  sourceDir: string
-}
-
-export type CursorMcpServer = {
-  command?: string
-  args?: string[]
-  env?: Record<string, string>
-  url?: string
-  headers?: Record<string, string>
-}
-
-export type CursorBundle = {
-  rules: CursorRule[]
-  commands: CursorCommand[]
-  skillDirs: CursorSkillDir[]
-  mcpServers?: Record<string, CursorMcpServer>
-}