@every-env/compound-plugin 0.1.0 → 0.2.0

package/src/targets/opencode.ts

@@ -1,10 +1,15 @@
 import path from "path"
-import { copyDir, ensureDir, writeJson, writeText } from "../utils/files"
+import { backupFile, copyDir, ensureDir, writeJson, writeText } from "../utils/files"
 import type { OpenCodeBundle } from "../types/opencode"
 
 export async function writeOpenCodeBundle(outputRoot: string, bundle: OpenCodeBundle): Promise<void> {
   const paths = resolveOpenCodePaths(outputRoot)
   await ensureDir(paths.root)
+
+  const backupPath = await backupFile(paths.configPath)
+  if (backupPath) {
+    console.log(`Backed up existing config to ${backupPath}`)
+  }
   await writeJson(paths.configPath, bundle.config)
 
   const agentsDir = paths.agentsDir
@@ -28,7 +33,10 @@ export async function writeOpenCodeBundle(outputRoot: string, bundle: OpenCodeBu
 }
 
 function resolveOpenCodePaths(outputRoot: string) {
-  if (path.basename(outputRoot) === ".opencode") {
+  const base = path.basename(outputRoot)
+  // Global install: ~/.config/opencode (basename is "opencode")
+  // Project install: .opencode (basename is ".opencode")
+  if (base === "opencode" || base === ".opencode") {
     return {
       root: outputRoot,
       configPath: path.join(outputRoot, "opencode.json"),
@@ -38,6 +46,7 @@ function resolveOpenCodePaths(outputRoot: string) {
     }
   }
 
+  // Custom output directory - nest under .opencode subdirectory
   return {
     root: outputRoot,
     configPath: path.join(outputRoot, "opencode.json"),

package/src/types/claude.ts

@@ -79,7 +79,7 @@ export type ClaudeHookAgent = {
 export type ClaudeHookEntry = ClaudeHookCommand | ClaudeHookPrompt | ClaudeHookAgent
 
 export type ClaudeHookMatcher = {
-  matcher: string
+  matcher?: string
   hooks: ClaudeHookEntry[]
 }
 

package/src/utils/files.ts

@@ -1,6 +1,19 @@
 import { promises as fs } from "fs"
 import path from "path"
 
+export async function backupFile(filePath: string): Promise<string | null> {
+  if (!(await pathExists(filePath))) return null
+
+  try {
+    const timestamp = new Date().toISOString().replace(/[:.]/g, "-")
+    const backupPath = `${filePath}.bak.${timestamp}`
+    await fs.copyFile(filePath, backupPath)
+    return backupPath
+  } catch {
+    return null
+  }
+}
+
 export async function pathExists(filePath: string): Promise<boolean> {
   try {
     await fs.access(filePath)

package/src/utils/symlink.ts

@@ -0,0 +1,43 @@
+import fs from "fs/promises"
+
+/**
+ * Create a symlink, safely replacing any existing symlink at target.
+ * Only removes existing symlinks - refuses to delete real directories.
+ */
+export async function forceSymlink(source: string, target: string): Promise<void> {
+  try {
+    const stat = await fs.lstat(target)
+    if (stat.isSymbolicLink()) {
+      // Safe to remove existing symlink
+      await fs.unlink(target)
+    } else if (stat.isDirectory()) {
+      // Refuse to delete real directories
+      throw new Error(
+        `Cannot create symlink at ${target}: a real directory exists there. ` +
+        `Remove it manually if you want to replace it with a symlink.`
+      )
+    } else {
+      // Regular file - remove it
+      await fs.unlink(target)
+    }
+  } catch (err) {
+    // ENOENT means target doesn't exist, which is fine
+    if ((err as NodeJS.ErrnoException).code !== "ENOENT") {
+      throw err
+    }
+  }
+  await fs.symlink(source, target)
+}
+
+/**
+ * Validate a skill name to prevent path traversal attacks.
+ * Returns true if safe, false if potentially malicious.
+ */
+export function isValidSkillName(name: string): boolean {
+  if (!name || name.length === 0) return false
+  if (name.includes("/") || name.includes("\\")) return false
+  if (name.includes("..")) return false
+  if (name.includes("\0")) return false
+  if (name === "." || name === "..") return false
+  return true
+}

package/tests/cli.test.ts

@@ -63,7 +63,7 @@ describe("CLI", () => {
     expect(await exists(path.join(tempRoot, ".opencode", "plugins", "converted-hooks.ts"))).toBe(true)
   })
 
-  test("install defaults output to ~/.opencode", async () => {
+  test("install defaults output to ~/.config/opencode", async () => {
     const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), "cli-local-default-"))
     const fixtureRoot = path.join(import.meta.dir, "fixtures", "sample-plugin")
 
@@ -95,8 +95,9 @@ describe("CLI", () => {
     }
 
     expect(stdout).toContain("Installed compound-engineering")
-    expect(await exists(path.join(tempRoot, ".opencode", "opencode.json"))).toBe(true)
-    expect(await exists(path.join(tempRoot, ".opencode", "agents", "repo-research-analyst.md"))).toBe(true)
+    // OpenCode global config lives at ~/.config/opencode per XDG spec
+    expect(await exists(path.join(tempRoot, ".config", "opencode", "opencode.json"))).toBe(true)
+    expect(await exists(path.join(tempRoot, ".config", "opencode", "agents", "repo-research-analyst.md"))).toBe(true)
   })
 
   test("list returns plugins in a temp workspace", async () => {
@@ -174,8 +175,9 @@ describe("CLI", () => {
     }
 
     expect(stdout).toContain("Installed compound-engineering")
-    expect(await exists(path.join(tempRoot, ".opencode", "opencode.json"))).toBe(true)
-    expect(await exists(path.join(tempRoot, ".opencode", "agents", "repo-research-analyst.md"))).toBe(true)
+    // OpenCode global config lives at ~/.config/opencode per XDG spec
+    expect(await exists(path.join(tempRoot, ".config", "opencode", "opencode.json"))).toBe(true)
+    expect(await exists(path.join(tempRoot, ".config", "opencode", "agents", "repo-research-analyst.md"))).toBe(true)
   })
 
   test("convert writes OpenCode output", async () => {

package/tests/codex-converter.test.ts

@@ -89,6 +89,89 @@ describe("convertClaudeToCodex", () => {
     expect(bundle.mcpServers?.local?.args).toEqual(["hello"])
   })
 
+  test("transforms Task agent calls to skill references", () => {
+    const plugin: ClaudePlugin = {
+      ...fixturePlugin,
+      commands: [
+        {
+          name: "plan",
+          description: "Planning with agents",
+          body: `Run these agents in parallel:
+
+- Task repo-research-analyst(feature_description)
+- Task learnings-researcher(feature_description)
+
+Then consolidate findings.
+
+Task best-practices-researcher(topic)`,
+          sourcePath: "/tmp/plugin/commands/plan.md",
+        },
+      ],
+      agents: [],
+      skills: [],
+    }
+
+    const bundle = convertClaudeToCodex(plugin, {
+      agentMode: "subagent",
+      inferTemperature: false,
+      permissions: "none",
+    })
+
+    const commandSkill = bundle.generatedSkills.find((s) => s.name === "plan")
+    expect(commandSkill).toBeDefined()
+    const parsed = parseFrontmatter(commandSkill!.content)
+
+    // Task calls should be transformed to skill references
+    expect(parsed.body).toContain("Use the $repo-research-analyst skill to: feature_description")
+    expect(parsed.body).toContain("Use the $learnings-researcher skill to: feature_description")
+    expect(parsed.body).toContain("Use the $best-practices-researcher skill to: topic")
+
+    // Original Task syntax should not remain
+    expect(parsed.body).not.toContain("Task repo-research-analyst")
+    expect(parsed.body).not.toContain("Task learnings-researcher")
+  })
+
+  test("transforms slash commands to prompts syntax", () => {
+    const plugin: ClaudePlugin = {
+      ...fixturePlugin,
+      commands: [
+        {
+          name: "plan",
+          description: "Planning with commands",
+          body: `After planning, you can:
+
+1. Run /deepen-plan to enhance
+2. Run /plan_review for feedback
+3. Start /workflows:work to implement
+
+Don't confuse with file paths like /tmp/output.md or /dev/null.`,
+          sourcePath: "/tmp/plugin/commands/plan.md",
+        },
+      ],
+      agents: [],
+      skills: [],
+    }
+
+    const bundle = convertClaudeToCodex(plugin, {
+      agentMode: "subagent",
+      inferTemperature: false,
+      permissions: "none",
+    })
+
+    const commandSkill = bundle.generatedSkills.find((s) => s.name === "plan")
+    expect(commandSkill).toBeDefined()
+    const parsed = parseFrontmatter(commandSkill!.content)
+
+    // Slash commands should be transformed to /prompts: syntax
+    expect(parsed.body).toContain("/prompts:deepen-plan")
+    expect(parsed.body).toContain("/prompts:plan_review")
+    expect(parsed.body).toContain("/prompts:workflows-work")
+
+    // File paths should NOT be transformed
+    expect(parsed.body).toContain("/tmp/output.md")
+    expect(parsed.body).toContain("/dev/null")
+  })
+
   test("truncates generated skill descriptions to Codex limits and single line", () => {
     const longDescription = `Line one\nLine two ${"a".repeat(2000)}`
     const plugin: ClaudePlugin = {

package/tests/codex-writer.test.ts

@@ -73,4 +73,36 @@ describe("writeCodexBundle", () => {
     expect(await exists(path.join(codexRoot, "prompts", "command-one.md"))).toBe(true)
     expect(await exists(path.join(codexRoot, "skills", "skill-one", "SKILL.md"))).toBe(true)
   })
+
+  test("backs up existing config.toml before overwriting", async () => {
+    const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), "codex-backup-"))
+    const codexRoot = path.join(tempRoot, ".codex")
+    const configPath = path.join(codexRoot, "config.toml")
+
+    // Create existing config
+    await fs.mkdir(codexRoot, { recursive: true })
+    const originalContent = "# My original config\n[custom]\nkey = \"value\"\n"
+    await fs.writeFile(configPath, originalContent)
+
+    const bundle: CodexBundle = {
+      prompts: [],
+      skillDirs: [],
+      generatedSkills: [],
+      mcpServers: { test: { command: "echo" } },
+    }
+
+    await writeCodexBundle(codexRoot, bundle)
+
+    // New config should be written
+    const newConfig = await fs.readFile(configPath, "utf8")
+    expect(newConfig).toContain("[mcp_servers.test]")
+
+    // Backup should exist with original content
+    const files = await fs.readdir(codexRoot)
+    const backupFileName = files.find((f) => f.startsWith("config.toml.bak."))
+    expect(backupFileName).toBeDefined()
+
+    const backupContent = await fs.readFile(path.join(codexRoot, backupFileName!), "utf8")
+    expect(backupContent).toBe(originalContent)
+  })
 })

package/tests/opencode-writer.test.ts

@@ -59,4 +59,61 @@ describe("writeOpenCodeBundle", () => {
     expect(await exists(path.join(outputRoot, "skills", "skill-one", "SKILL.md"))).toBe(true)
     expect(await exists(path.join(outputRoot, ".opencode"))).toBe(false)
   })
+
+  test("writes directly into ~/.config/opencode style output root", async () => {
+    // Simulates the global install path: ~/.config/opencode
+    const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), "config-opencode-"))
+    const outputRoot = path.join(tempRoot, ".config", "opencode")
+    const bundle: OpenCodeBundle = {
+      config: { $schema: "https://opencode.ai/config.json" },
+      agents: [{ name: "agent-one", content: "Agent content" }],
+      plugins: [],
+      skillDirs: [
+        {
+          name: "skill-one",
+          sourceDir: path.join(import.meta.dir, "fixtures", "sample-plugin", "skills", "skill-one"),
+        },
+      ],
+    }
+
+    await writeOpenCodeBundle(outputRoot, bundle)
+
+    // Should write directly, not nested under .opencode
+    expect(await exists(path.join(outputRoot, "opencode.json"))).toBe(true)
+    expect(await exists(path.join(outputRoot, "agents", "agent-one.md"))).toBe(true)
+    expect(await exists(path.join(outputRoot, "skills", "skill-one", "SKILL.md"))).toBe(true)
+    expect(await exists(path.join(outputRoot, ".opencode"))).toBe(false)
+  })
+
+  test("backs up existing opencode.json before overwriting", async () => {
+    const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), "opencode-backup-"))
+    const outputRoot = path.join(tempRoot, ".opencode")
+    const configPath = path.join(outputRoot, "opencode.json")
+
+    // Create existing config
+    await fs.mkdir(outputRoot, { recursive: true })
+    const originalConfig = { $schema: "https://opencode.ai/config.json", custom: "value" }
+    await fs.writeFile(configPath, JSON.stringify(originalConfig, null, 2))
+
+    const bundle: OpenCodeBundle = {
+      config: { $schema: "https://opencode.ai/config.json", new: "config" },
+      agents: [],
+      plugins: [],
+      skillDirs: [],
+    }
+
+    await writeOpenCodeBundle(outputRoot, bundle)
+
+    // New config should be written
+    const newConfig = JSON.parse(await fs.readFile(configPath, "utf8"))
+    expect(newConfig.new).toBe("config")
+
+    // Backup should exist with original content
+    const files = await fs.readdir(outputRoot)
+    const backupFileName = files.find((f) => f.startsWith("opencode.json.bak."))
+    expect(backupFileName).toBeDefined()
+
+    const backupContent = JSON.parse(await fs.readFile(path.join(outputRoot, backupFileName!), "utf8"))
+    expect(backupContent.custom).toBe("value")
+  })
 })

package/plugins/compound-engineering/commands/plan_review.md

@@ -1,7 +0,0 @@
----
-name: plan_review
-description: Have multiple specialized agents review a plan in parallel
-argument-hint: "[plan file path or plan content]"
----
-
-Have @agent-dhh-rails-reviewer @agent-kieran-rails-reviewer @agent-code-simplicity-reviewer review this plan in parallel.

package/plugins/compound-engineering/commands/resolve_pr_parallel.md

@@ -1,49 +0,0 @@
----
-name: resolve_pr_parallel
-description: Resolve all PR comments using parallel processing
-argument-hint: "[optional: PR number or current PR]"
----
-
-Resolve all PR comments using parallel processing.
-
-Claude Code automatically detects and understands your git context:
-
-- Current branch detection
-- Associated PR context
-- All PR comments and review threads
-- Can work with any PR by specifying the PR number, or ask it.
-
-## Workflow
-
-### 1. Analyze
-
-Get all unresolved comments for PR
-
-```bash
-gh pr status
-bin/get-pr-comments PR_NUMBER
-```
-
-### 2. Plan
-
-Create a TodoWrite list of all unresolved items grouped by type.
-
-### 3. Implement (PARALLEL)
-
-Spawn a pr-comment-resolver agent for each unresolved item in parallel.
-
-So if there are 3 comments, it will spawn 3 pr-comment-resolver agents in parallel. liek this
-
-1. Task pr-comment-resolver(comment1)
-2. Task pr-comment-resolver(comment2)
-3. Task pr-comment-resolver(comment3)
-
-Always run all in parallel subagents/Tasks for each Todo item.
-
-### 4. Commit & Resolve
-
-- Commit changes
-- Run bin/resolve-pr-thread THREAD_ID_1
-- Push to remote
-
-Last, check bin/get-pr-comments PR_NUMBER again to see if all comments are resolved. They should be, if not, repeat the process from 1.