@orchid-labs/pluxx 0.1.1 → 0.1.3

package/src/generators/index.ts

@@ -1,71 +0,0 @@
-import { rmSync, mkdirSync } from 'fs'
-import { resolve, relative } from 'path'
-import type { PluginConfig, TargetPlatform } from '../schema'
-import { Generator } from './base'
-import { ClaudeCodeGenerator } from './claude-code'
-import { CursorGenerator } from './cursor'
-import { CodexGenerator } from './codex'
-import { OpenCodeGenerator } from './opencode'
-import { GitHubCopilotGenerator } from './github-copilot'
-import { OpenHandsGenerator } from './openhands'
-import { WarpGenerator } from './warp'
-import { GeminiCliGenerator } from './gemini-cli'
-import { RooCodeGenerator } from './roo-code'
-import { ClineGenerator } from './cline'
-import { AmpGenerator } from './amp'
-
-const GENERATORS: Record<TargetPlatform, new (config: PluginConfig, rootDir: string) => Generator> = {
-  'claude-code': ClaudeCodeGenerator,
-  cursor: CursorGenerator,
-  codex: CodexGenerator,
-  opencode: OpenCodeGenerator,
-  'github-copilot': GitHubCopilotGenerator,
-  openhands: OpenHandsGenerator,
-  warp: WarpGenerator,
-  'gemini-cli': GeminiCliGenerator,
-  'roo-code': RooCodeGenerator,
-  cline: ClineGenerator,
-  amp: AmpGenerator,
-}
-
-export interface BuildOptions {
-  /** Override targets from config */
-  targets?: TargetPlatform[]
-  /** Clean output directory before building */
-  clean?: boolean
-}
-
-export async function build(
-  config: PluginConfig,
-  rootDir: string,
-  options: BuildOptions = {},
-): Promise<void> {
-  const targets = options.targets ?? config.targets
-  const outDir = resolve(rootDir, config.outDir)
-
-  // CRITICAL: Guard against path traversal — outDir must stay within rootDir
-  const rel = relative(rootDir, outDir)
-  if (rel.startsWith('..') || resolve(outDir) === resolve(rootDir)) {
-    throw new Error(
-      `outDir "${config.outDir}" resolves outside the project root. Refusing to delete.`
-    )
-  }
-
-  if (options.clean !== false) {
-    rmSync(outDir, { recursive: true, force: true })
-  }
-  mkdirSync(outDir, { recursive: true })
-
-  const generators = targets.map(target => {
-    const GeneratorClass = GENERATORS[target]
-    if (!GeneratorClass) {
-      throw new Error(`Unknown target platform: ${target}`)
-    }
-    return new GeneratorClass(config, rootDir)
-  })
-
-  // Build all targets in parallel
-  await Promise.all(generators.map(g => g.generate()))
-}
-
-export { Generator }

package/src/generators/opencode/index.ts

@@ -1,526 +0,0 @@
-import { existsSync, readdirSync, readFileSync, statSync } from 'fs'
-import { extname, relative, resolve } from 'path'
-import { Generator } from '../base'
-import type { HookEntry, TargetPlatform } from '../../schema'
-import { buildOpenCodePermissionMap } from '../../permissions'
-
-type GeneratedHook = {
-  command: string
-  timeout?: number
-  matcher?: HookEntry['matcher']
-  failClosed?: boolean
-}
-
-interface OpenCodeMcpDefinition {
-  transport: 'http' | 'sse' | 'stdio'
-  url?: string
-  command?: string
-  args?: string[]
-  env?: Record<string, string>
-  auth?: {
-    type: 'bearer' | 'header' | 'none'
-    envVar?: string
-    headerName?: string
-    headerTemplate?: string
-  }
-}
-
-interface OpenCodeHookPlan {
-  event: Record<string, GeneratedHook[]>
-  toolBefore: {
-    all: GeneratedHook[]
-    read: GeneratedHook[]
-    mcp: GeneratedHook[]
-  }
-  toolAfter: {
-    all: GeneratedHook[]
-    edit: GeneratedHook[]
-    mcp: GeneratedHook[]
-  }
-  shellEnv: GeneratedHook[]
-  chatMessage: GeneratedHook[]
-}
-
-export class OpenCodeGenerator extends Generator {
-  readonly platform: TargetPlatform = 'opencode'
-
-  async generate(): Promise<void> {
-    await Promise.all([
-      this.generatePackageJson(),
-      this.generatePluginWrapper(),
-    ])
-
-    this.copySkills()
-    this.copyCommands()
-    this.copyScripts()
-    this.copyAssets()
-  }
-
-  private async generatePackageJson(): Promise<void> {
-    const npmName = this.config.platforms?.opencode?.npmPackage
-      ?? `opencode-${this.config.name}`
-
-    const pkg = {
-      name: npmName,
-      version: this.config.version,
-      description: `${this.config.description} (OpenCode plugin)`,
-      main: 'index.ts',
-      type: 'module',
-      keywords: [
-        'opencode-plugin',
-        ...(this.config.keywords ?? []),
-      ],
-      author: this.config.author.name,
-      license: this.config.license,
-      peerDependencies: {
-        '@opencode-ai/plugin': '*',
-      },
-    }
-
-    await this.writeJson('package.json', pkg)
-  }
-
-  private async generatePluginWrapper(): Promise<void> {
-    const pluginName = toPascalCase(this.config.name) + 'Plugin'
-    const envVars = this.getRequiredEnvVars()
-    const mcpDefinitions = this.getOpenCodeMcpDefinitions()
-    const commandDefinitions = this.getOpenCodeCommandDefinitions()
-    const hookPlan = this.getOpenCodeHookPlan()
-    const instructions = this.getInstructionsContent()
-    const permissionMap = buildOpenCodePermissionMap(this.config.permissions)
-
-    const lines: string[] = [
-      `import type { Config, Plugin } from "@opencode-ai/plugin"`,
-      `import { existsSync, readFileSync } from "fs"`,
-      `import { resolve } from "path"`,
-      '',
-      `type GeneratedHook = {`,
-      `  command: string`,
-      `  timeout?: number`,
-      `  matcher?: string`,
-      `  failClosed?: boolean`,
-      `}`,
-      '',
-      `const REQUIRED_ENV_VARS = ${JSON.stringify(envVars, null, 2)}`,
-      '',
-      `const MCP_DEFINITIONS = ${JSON.stringify(mcpDefinitions, null, 2)}`,
-      '',
-      `const TUI_COMMANDS = ${JSON.stringify(commandDefinitions, null, 2)}`,
-      '',
-      `const EVENT_HOOKS: Record<string, GeneratedHook[]> = ${JSON.stringify(hookPlan.event, null, 2)}`,
-      '',
-      `const TOOL_BEFORE_HOOKS = ${JSON.stringify(hookPlan.toolBefore, null, 2)}`,
-      '',
-      `const TOOL_AFTER_HOOKS = ${JSON.stringify(hookPlan.toolAfter, null, 2)}`,
-      '',
-      `const SHELL_ENV_HOOKS = ${JSON.stringify(hookPlan.shellEnv, null, 2)}`,
-      '',
-      `const CHAT_MESSAGE_HOOKS = ${JSON.stringify(hookPlan.chatMessage, null, 2)}`,
-      '',
-      `const INSTRUCTIONS = ${JSON.stringify(instructions)}`,
-      '',
-      `const PERMISSIONS = ${JSON.stringify(permissionMap, null, 2)}`,
-      '',
-      `const isMcpTool = (tool: string): boolean =>`,
-      `  tool === "mcp" || tool.startsWith("mcp.") || tool.startsWith("mcp_")`,
-      '',
-      `const loadUserConfig = (directory: string): { values?: Record<string, string | number | boolean>; env?: Record<string, string> } => {`,
-      `  const filepath = resolve(directory, ".pluxx-user.json")`,
-      `  if (!existsSync(filepath)) return {}`,
-      `  try {`,
-      `    return JSON.parse(readFileSync(filepath, "utf-8"))`,
-      `  } catch {`,
-      `    return {}`,
-      `  }`,
-      `}`,
-      '',
-      `const resolveRuntimeValue = (name: string, userEnv: Record<string, string>): string | undefined =>`,
-      `  userEnv[name] ?? process.env[name]`,
-      '',
-      `const materializeEnv = (input: Record<string, string> | undefined, userEnv: Record<string, string>): Record<string, string> | undefined => {`,
-      `  if (!input) return undefined`,
-      `  const output: Record<string, string> = {}`,
-      `  for (const [key, value] of Object.entries(input)) {`,
-      `    output[key] = value.replace(/\\$\\{([A-Za-z_][A-Za-z0-9_]*)\\}/g, (_match, name) => resolveRuntimeValue(name, userEnv) ?? \`\\\${\${name}}\`)`,
-      `  }`,
-      `  return output`,
-      `}`,
-      '',
-      `const buildMcpConfig = (directory: string): NonNullable<Config["mcp"]> => {`,
-      `  const config: NonNullable<Config["mcp"]> = {}`,
-      `  const userEnv = loadUserConfig(directory).env ?? {}`,
-      '',
-      `  for (const [name, definition] of Object.entries(MCP_DEFINITIONS)) {`,
-      `    if (definition.transport === "stdio" && definition.command) {`,
-      `      config[name] = {`,
-      `        type: "local",`,
-      `        command: [definition.command, ...(definition.args ?? [])],`,
-      `        ...(definition.env ? { environment: materializeEnv(definition.env, userEnv) } : {}),`,
-      `      }`,
-      `      continue`,
-      `    }`,
-      '',
-      `    if (!definition.url) continue`,
-      '',
-      `    const remote: {`,
-      `      type: "remote"`,
-      `      url: string`,
-      `      headers?: Record<string, string>`,
-      `    } = {`,
-      `      type: "remote",`,
-      `      url: definition.url,`,
-      `    }`,
-      '',
-      `    if (definition.auth?.type === "bearer" && definition.auth.envVar) {`,
-      `      const token = resolveRuntimeValue(definition.auth.envVar, userEnv)`,
-      `      if (token) remote.headers = { Authorization: \`Bearer \${token}\` }`,
-      `    }`,
-      '',
-      `    if (definition.auth?.type === "header" && definition.auth.envVar && definition.auth.headerName && definition.auth.headerTemplate) {`,
-      `      const value = resolveRuntimeValue(definition.auth.envVar, userEnv)`,
-      `      if (value) {`,
-      `        remote.headers = {`,
-      `          ...(remote.headers ?? {}),`,
-      `          [definition.auth.headerName]: definition.auth.headerTemplate.replace("\${value}", value),`,
-      `        }`,
-      `      }`,
-      `    }`,
-      '',
-      `    config[name] = remote`,
-      `  }`,
-      '',
-      `  return config`,
-      `}`,
-      '',
-      `const applyInstructions = (system: string[]): void => {`,
-      `  if (!INSTRUCTIONS) return`,
-      `  if (!system.includes(INSTRUCTIONS)) {`,
-      `    system.unshift(INSTRUCTIONS)`,
-      `  }`,
-      `}`,
-      '',
-      `/**`,
-      ` * ${this.config.description}`,
-      ` * Generated by pluxx — do not edit manually.`,
-      ` */`,
-      `export const ${pluginName}: Plugin = async ({ project, client, $, directory }) => {`,
-      `  const runHook = async (hook: GeneratedHook, context: Record<string, string>): Promise<void> => {`,
-      `    try {`,
-      `      const command = hook.command.replaceAll("\${PLUGIN_ROOT}", directory)`,
-      `      const execution = $\`bash -lc \${command}\``,
-      `      if (hook.timeout) {`,
-      `        await Promise.race([`,
-      `          execution,`,
-      `          new Promise((_, reject) => {`,
-      `            setTimeout(() => reject(new Error(\`Hook timed out after \${hook.timeout}ms: \${command}\`)), hook.timeout)`,
-      `          }),`,
-      `        ])`,
-      `      } else {`,
-      `        await execution`,
-      `      }`,
-      `    } catch (error) {`,
-      `      await client.app.log({`,
-      `        body: {`,
-      `          service: "${this.config.name}",`,
-      `          level: "error",`,
-      `          message: "OpenCode hook execution failed",`,
-      `          extra: {`,
-      `            ...context,`,
-      `            hook: hook.command,`,
-      `            error: error instanceof Error ? error.message : String(error),`,
-      `          },`,
-      `        },`,
-      `      })`,
-      `      if (hook.failClosed) throw error`,
-      `    }`,
-      `  }`,
-      '',
-      `  const runHooks = async (hooks: GeneratedHook[], context: Record<string, string>): Promise<void> => {`,
-      `    for (const hook of hooks) {`,
-      `      await runHook(hook, context)`,
-      `    }`,
-      `  }`,
-      '',
-      `  return {`,
-      `    config: async (config) => {`,
-      `      if (Object.keys(MCP_DEFINITIONS).length > 0) {`,
-      `        config.mcp = {`,
-      `          ...(config.mcp ?? {}),`,
-      `          ...buildMcpConfig(directory),`,
-      `        }`,
-      `      }`,
-      '',
-      `      if (Object.keys(TUI_COMMANDS).length > 0) {`,
-      `        config.command = {`,
-      `          ...(config.command ?? {}),`,
-      `          ...TUI_COMMANDS,`,
-      `        }`,
-      `      }`,
-      '',
-      `      if (Object.keys(PERMISSIONS).length > 0) {`,
-      `        config.permission = {`,
-      `          ...(config.permission ?? {}),`,
-      `          ...PERMISSIONS,`,
-      `        }`,
-      `      }`,
-      `    },`,
-      '',
-      `    "tool.execute.before": async (input, output) => {`,
-      `      await runHooks(TOOL_BEFORE_HOOKS.all, { hookType: "tool.execute.before", tool: input.tool })`,
-      `      if (input.tool === "read") {`,
-      `        await runHooks(TOOL_BEFORE_HOOKS.read, { hookType: "tool.execute.before", tool: input.tool })`,
-      `      }`,
-      `      if (isMcpTool(input.tool)) {`,
-      `        await runHooks(TOOL_BEFORE_HOOKS.mcp, { hookType: "tool.execute.before", tool: input.tool })`,
-      `      }`,
-      `    },`,
-      '',
-      `    "tool.execute.after": async (input, output) => {`,
-      `      await runHooks(TOOL_AFTER_HOOKS.all, { hookType: "tool.execute.after", tool: input.tool })`,
-      `      if (input.tool === "edit" || input.tool === "write") {`,
-      `        await runHooks(TOOL_AFTER_HOOKS.edit, { hookType: "tool.execute.after", tool: input.tool })`,
-      `      }`,
-      `      if (isMcpTool(input.tool)) {`,
-      `        await runHooks(TOOL_AFTER_HOOKS.mcp, { hookType: "tool.execute.after", tool: input.tool })`,
-      `      }`,
-      `    },`,
-      '',
-      `    "shell.env": async (input, output) => {`,
-      `      await runHooks(SHELL_ENV_HOOKS, { hookType: "shell.env", cwd: input.cwd })`,
-      `    },`,
-      '',
-      `    "chat.message": async (input, output) => {`,
-      `      await runHooks(CHAT_MESSAGE_HOOKS, { hookType: "chat.message", sessionID: input.sessionID })`,
-      `    },`,
-      '',
-      `    "experimental.chat.system.transform": async (input, output) => {`,
-      `      applyInstructions(output.system)`,
-      `    },`,
-      '',
-      `    "experimental.session.compacting": async (input, output) => {`,
-      `      if (INSTRUCTIONS && !output.context.includes(INSTRUCTIONS)) {`,
-      `        output.context.push(INSTRUCTIONS)`,
-      `      }`,
-      `    },`,
-      '',
-      `    event: async ({ event }) => {`,
-      `      if (event.type === "session.created") {`,
-    ]
-
-    for (const envVar of envVars) {
-      lines.push(`        if (!process.env.${envVar}) {`)
-      lines.push(`          await client.app.log({`)
-      lines.push(`            body: {`)
-      lines.push(`              service: "${this.config.name}",`)
-      lines.push(`              level: "warn",`)
-      lines.push(`              message: "${envVar} is not set. ${this.config.brand?.displayName ?? this.config.name} plugin may not work correctly.",`)
-      lines.push(`            },`)
-      lines.push(`          })`)
-      lines.push(`        }`)
-    }
-    lines.push(`      }`)
-    lines.push(`      const hooks = EVENT_HOOKS[event.type] ?? []`)
-    lines.push(`      await runHooks(hooks, { hookType: "event", event: event.type })`)
-    lines.push(`    },`)
-
-    lines.push(`  }`)
-    lines.push(`}`)
-    lines.push('')
-
-    await this.writeFile('index.ts', lines.join('\n'))
-  }
-
-  private getRequiredEnvVars(): string[] {
-    const vars = new Set<string>()
-    if (this.config.mcp) {
-      for (const server of Object.values(this.config.mcp)) {
-        if (server.auth && 'envVar' in server.auth && server.auth.envVar) {
-          vars.add(server.auth.envVar)
-        }
-      }
-    }
-    return [...vars]
-  }
-
-  private getOpenCodeMcpDefinitions(): Record<string, OpenCodeMcpDefinition> {
-    if (!this.config.mcp) return {}
-
-    const output: Record<string, OpenCodeMcpDefinition> = {}
-    for (const [name, server] of Object.entries(this.config.mcp)) {
-      const auth = server.auth?.type === 'platform'
-        ? undefined
-        : server.auth
-
-      output[name] = {
-        transport: server.transport,
-        ...(server.url ? { url: server.url } : {}),
-        ...(server.command ? { command: server.command } : {}),
-        ...(server.args ? { args: server.args } : {}),
-        ...(server.env ? { env: server.env } : {}),
-        ...(auth ? { auth } : {}),
-      }
-    }
-    return output
-  }
-
-  private getOpenCodeCommandDefinitions(): Record<string, { template: string; description?: string }> {
-    if (!this.config.commands) return {}
-
-    const commandsDir = this.resolveConfigPath(this.config.commands, 'commands')
-    if (!existsSync(commandsDir)) return {}
-
-    const files = this.walkFiles(commandsDir).filter(file => extname(file) === '.md')
-    const output: Record<string, { template: string; description?: string }> = {}
-
-    for (const file of files) {
-      const raw = readFileSync(file, 'utf-8')
-      const { description, body } = parseMarkdownCommand(raw)
-      const relativePath = relative(commandsDir, file)
-        .replace(/\\/g, '/')
-        .replace(/\.md$/i, '')
-      const name = relativePath.replace(/\//g, '-').toLowerCase()
-
-      output[name] = {
-        template: body.trim(),
-        ...(description ? { description } : {}),
-      }
-    }
-
-    return output
-  }
-
-  private getInstructionsContent(): string | null {
-    if (!this.config.instructions) return null
-    const instructionsPath = this.resolveConfigPath(this.config.instructions, 'instructions')
-    if (!existsSync(instructionsPath)) return null
-    return readFileSync(instructionsPath, 'utf-8').trim()
-  }
-
-  private getOpenCodeHookPlan(): OpenCodeHookPlan {
-    const plan: OpenCodeHookPlan = {
-      event: {},
-      toolBefore: { all: [], read: [], mcp: [] },
-      toolAfter: { all: [], edit: [], mcp: [] },
-      shellEnv: [],
-      chatMessage: [],
-    }
-
-    if (!this.config.hooks) return plan
-
-    for (const [event, entries] of Object.entries(this.config.hooks)) {
-      if (!entries || entries.length === 0) continue
-
-      const hooks = entries
-        .filter(entry => entry.type !== 'prompt' && entry.command)
-        .map(entry => ({
-          command: entry.command!,
-          ...(entry.timeout ? { timeout: entry.timeout } : {}),
-          ...(entry.matcher ? { matcher: entry.matcher } : {}),
-          ...(entry.failClosed !== undefined ? { failClosed: entry.failClosed } : {}),
-        }))
-
-      if (hooks.length === 0) continue
-
-      switch (event) {
-        case 'preToolUse':
-          plan.toolBefore.all.push(...hooks)
-          break
-        case 'beforeReadFile':
-          plan.toolBefore.read.push(...hooks)
-          break
-        case 'beforeMCPExecution':
-          plan.toolBefore.mcp.push(...hooks)
-          break
-        case 'postToolUse':
-          plan.toolAfter.all.push(...hooks)
-          break
-        case 'afterFileEdit':
-          plan.toolAfter.edit.push(...hooks)
-          break
-        case 'afterMCPExecution':
-          plan.toolAfter.mcp.push(...hooks)
-          break
-        case 'beforeShellExecution':
-          plan.shellEnv.push(...hooks)
-          break
-        case 'beforeSubmitPrompt':
-          plan.chatMessage.push(...hooks)
-          break
-        default: {
-          const opencodeEvent = mapHookEventName(event)
-          if (!plan.event[opencodeEvent]) {
-            plan.event[opencodeEvent] = []
-          }
-          plan.event[opencodeEvent].push(...hooks)
-        }
-      }
-    }
-
-    return plan
-  }
-
-  private walkFiles(dir: string): string[] {
-    const entries = readdirSync(dir)
-    const files: string[] = []
-
-    for (const entry of entries) {
-      const fullPath = resolve(dir, entry)
-      const stat = statSync(fullPath)
-      if (stat.isDirectory()) {
-        files.push(...this.walkFiles(fullPath))
-      } else if (stat.isFile()) {
-        files.push(fullPath)
-      }
-    }
-
-    return files
-  }
-}
-
-function parseMarkdownCommand(content: string): { description?: string; body: string } {
-  const trimmed = content.trim()
-  if (!trimmed.startsWith('---')) {
-    return { body: content }
-  }
-
-  const endFrontmatter = trimmed.indexOf('\n---', 3)
-  if (endFrontmatter === -1) {
-    return { body: content }
-  }
-
-  const frontmatter = trimmed.slice(3, endFrontmatter).trim()
-  const body = trimmed.slice(endFrontmatter + 4)
-  const descriptionLine = frontmatter
-    .split('\n')
-    .find(line => line.trim().startsWith('description:'))
-  const description = descriptionLine
-    ? descriptionLine.split(':').slice(1).join(':').trim().replace(/^["']|["']$/g, '')
-    : undefined
-
-  return { description, body }
-}
-
-function mapHookEventName(event: string): string {
-  const map: Record<string, string> = {
-    sessionStart: 'session.created',
-    sessionEnd: 'session.idle',
-    stop: 'session.idle',
-    beforeShellExecution: 'shell.env',
-    afterShellExecution: 'command.executed',
-    preToolUse: 'tool.execute.before',
-    postToolUse: 'tool.execute.after',
-    beforeMCPExecution: 'tool.execute.before',
-    afterMCPExecution: 'tool.execute.after',
-    afterFileEdit: 'file.edited',
-    beforeReadFile: 'tool.execute.before',
-    beforeSubmitPrompt: 'chat.message',
-  }
-  return map[event] ?? event
-}
-
-function toPascalCase(str: string): string {
-  return str
-    .split('-')
-    .map(part => part.charAt(0).toUpperCase() + part.slice(1))
-    .join('')
-}

package/src/generators/openhands/index.ts

@@ -1,32 +0,0 @@
-import { Generator } from '../base'
-import { generateClaudeFamilyOutputs } from '../shared/claude-family'
-import type { TargetPlatform } from '../../schema'
-
-/**
- * OpenHands uses .plugin/plugin.json (Claude Code-compatible format).
- * Discovery dirs: .openhands/skills/, .claude/skills/, .agents/skills/
- */
-export class OpenHandsGenerator extends Generator {
-  readonly platform: TargetPlatform = 'openhands'
-
-  async generate(): Promise<void> {
-    await generateClaudeFamilyOutputs({
-      config: this.config,
-      rootDir: this.rootDir,
-      platform: this.platform,
-      options: {
-        manifestPath: '.plugin/plugin.json',
-        instructionsFile: 'AGENTS.md',
-        pluginRootVar: 'PLUGIN_ROOT',
-      },
-      writeJson: (relativePath, data) => this.writeJson(relativePath, data),
-      writeFile: (relativePath, content) => this.writeFile(relativePath, content),
-    })
-
-    this.copySkills()
-    this.copyCommands()
-    this.copyAgents()
-    this.copyScripts()
-    this.copyAssets()
-  }
-}

package/src/generators/roo-code/index.ts

@@ -1,35 +0,0 @@
-import { existsSync } from 'fs'
-import { Generator } from '../base'
-import type { TargetPlatform } from '../../schema'
-
-/**
- * Roo Code uses .roo/mcp.json for MCP config, .roorules for instructions,
- * and .roo/skills/ for skills. No plugin manifest.
- */
-export class RooCodeGenerator extends Generator {
-  readonly platform: TargetPlatform = 'roo-code'
-
-  async generate(): Promise<void> {
-    await Promise.all([
-      this.generateMcpConfig('.roo/mcp.json'),
-      this.generateRules(),
-    ])
-
-    this.copyRooSkills()
-    this.copyScripts()
-  }
-
-  private async generateRules(): Promise<void> {
-    if (!this.config.instructions) return
-    const srcPath = this.resolveConfigPath(this.config.instructions, 'instructions')
-    if (!existsSync(srcPath)) return
-
-    const content = await Bun.file(srcPath).text()
-    await this.writeFile('.roorules', content)
-  }
-
-  /** Copy skills into .roo/skills/ instead of the default skills/ */
-  private copyRooSkills(): void {
-    this.copyDir(this.config.skills, '.roo/skills/', 'skills')
-  }
-}