@orchid-labs/pluxx 0.1.0

package/src/generators/cursor/index.ts

@@ -0,0 +1,158 @@
+import { existsSync } from 'fs'
+import { Generator } from '../base'
+import type { TargetPlatform } from '../../schema'
+import { buildGeneratedPermissionHookScript } from '../../permissions'
+
+export class CursorGenerator extends Generator {
+  readonly platform: TargetPlatform = 'cursor'
+
+  async generate(): Promise<void> {
+    await Promise.all([
+      this.generateManifest(),
+      this.generateMcpConfig('mcp.json'),
+      this.generateHooks(),
+      this.generateRules(),
+      this.generateAgentsMd(),
+    ])
+
+    this.copySkills()
+    this.copyCommands()
+    this.copyAgents()
+    this.copyScripts()
+    this.copyAssets()
+  }
+
+  private async generateManifest(): Promise<void> {
+    const manifest: Record<string, unknown> = {
+      name: this.config.name,
+      description: this.config.description,
+      version: this.config.version,
+      author: this.config.author,
+    }
+
+    if (this.config.repository) manifest.repository = this.config.repository
+    if (this.config.license) manifest.license = this.config.license
+    if (this.config.keywords) manifest.keywords = this.config.keywords
+    if (this.config.brand?.websiteURL) manifest.homepage = this.config.brand.websiteURL
+    if (this.config.brand?.icon) manifest.logo = this.config.brand.icon
+
+    manifest.skills = './skills/'
+    if (this.config.commands) manifest.commands = './commands/'
+    if (this.config.agents) manifest.agents = './agents/'
+    if (this.config.platforms?.cursor?.rules?.length) manifest.rules = './rules/'
+    if (this.config.hooks || this.config.permissions) manifest.hooks = './hooks/hooks.json'
+    if (this.config.mcp) manifest.mcpServers = './mcp.json'
+
+    await this.writeJson('.cursor-plugin/plugin.json', manifest)
+  }
+
+  private async generateHooks(): Promise<void> {
+    const permissionScript = buildGeneratedPermissionHookScript(this.config.permissions)
+    if (!this.config.hooks && !permissionScript) return
+    const usesPlatformManagedAuth = this.config.platforms?.cursor?.mcpAuth === 'platform'
+
+    // Cursor hooks format matches the canonical format closely
+    const hooks: Record<string, unknown[]> = {}
+
+    if (permissionScript) {
+      await this.writeFile('hooks/pluxx-permissions.mjs', permissionScript)
+      hooks.preToolUse = [{
+        command: 'node ./hooks/pluxx-permissions.mjs cursor-pretool',
+      }]
+      hooks.beforeShellExecution = [{
+        command: 'node ./hooks/pluxx-permissions.mjs cursor-shell',
+      }]
+      hooks.beforeReadFile = [{
+        command: 'node ./hooks/pluxx-permissions.mjs cursor-read',
+      }]
+      hooks.beforeMCPExecution = [{
+        command: 'node ./hooks/pluxx-permissions.mjs cursor-mcp',
+      }]
+    }
+
+    if (!this.config.hooks) {
+      await this.writeJson('hooks/hooks.json', { version: 1, hooks })
+      return
+    }
+
+    for (const [event, entries] of Object.entries(this.config.hooks)) {
+      if (!entries) continue
+      const filteredEntries = entries.filter((entry) => {
+        if (
+          usesPlatformManagedAuth
+          && entry.type !== 'prompt'
+          && entry.command?.includes('check-env.sh')
+        ) {
+          return false
+        }
+        return true
+      })
+
+      if (filteredEntries.length === 0) continue
+
+      hooks[event] = [
+        ...(hooks[event] ?? []),
+        ...filteredEntries.map(entry => {
+        const hookDef: Record<string, unknown> = {}
+        if (entry.type === 'prompt') {
+          hookDef.type = 'prompt'
+          hookDef.prompt = entry.prompt
+          if (entry.model) hookDef.model = entry.model
+        } else if (entry.command) {
+          hookDef.command = entry.command.replace('${PLUGIN_ROOT}', '.')
+        }
+        if (entry.timeout) hookDef.timeout = entry.timeout
+        if (entry.matcher) hookDef.matcher = entry.matcher
+        if (entry.failClosed) hookDef.failClosed = entry.failClosed
+        if (entry.loop_limit !== undefined) hookDef.loop_limit = entry.loop_limit
+        return hookDef
+      }),
+      ]
+    }
+
+    await this.writeJson('hooks/hooks.json', { version: 1, hooks })
+  }
+
+  private async generateRules(): Promise<void> {
+    const overrides = this.config.platforms?.cursor
+    if (!overrides?.rules?.length) return
+
+    for (const rule of overrides.rules) {
+      const frontmatter = [
+        '---',
+        `description: "${rule.description}"`,
+      ]
+      if (rule.globs) {
+        if (Array.isArray(rule.globs)) {
+          frontmatter.push(`globs: ${JSON.stringify(rule.globs)}`)
+        } else {
+          frontmatter.push(`globs: "${rule.globs}"`)
+        }
+      }
+      if (rule.alwaysApply !== undefined) {
+        frontmatter.push(`alwaysApply: ${rule.alwaysApply}`)
+      }
+      frontmatter.push('---')
+
+      const content = rule.content ?? ''
+      const filename = rule.description
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-|-$/g, '')
+
+      await this.writeFile(
+        `rules/${filename}.mdc`,
+        frontmatter.join('\n') + '\n\n' + content
+      )
+    }
+  }
+
+  private async generateAgentsMd(): 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('AGENTS.md', content)
+  }
+}

package/src/generators/gemini-cli/index.ts

@@ -0,0 +1,83 @@
+import { existsSync } from 'fs'
+import { Generator } from '../base'
+import { warnDroppedHookFields } from '../hooks-warning'
+import type { TargetPlatform } from '../../schema'
+
+/**
+ * Gemini CLI uses gemini-extension.json for the plugin manifest,
+ * GEMINI.md for instructions, and mcpServers in the same format as Claude Code.
+ */
+export class GeminiCliGenerator extends Generator {
+  readonly platform: TargetPlatform = 'gemini-cli'
+
+  async generate(): Promise<void> {
+    await Promise.all([
+      this.generateManifest(),
+      this.generateInstructions(),
+    ])
+
+    this.copySkills()
+    this.copyScripts()
+    this.copyAssets()
+  }
+
+  private async generateManifest(): Promise<void> {
+    const manifest: Record<string, unknown> = {
+      name: this.config.name,
+      version: this.config.version,
+      description: this.config.description,
+      author: this.config.author,
+    }
+
+    // MCP servers block
+    const mcpServers = this.buildMcpServers({
+      transformRemoteEntry: ({ server, entry }) => ({
+        type: server.transport === 'sse' ? 'sse' : 'http',
+        ...entry,
+      }),
+    })
+    if (mcpServers) {
+      manifest.mcpServers = mcpServers
+    }
+
+    // Skills paths
+    manifest.skills = ['./skills/']
+
+    // Hooks block
+    if (this.config.hooks) {
+      const hooks: Record<string, unknown[]> = {}
+
+      for (const [event, entries] of Object.entries(this.config.hooks)) {
+        if (!entries) continue
+        warnDroppedHookFields(this.platform, event, entries)
+        const commandEntries = entries.filter(entry => entry.type !== 'prompt' && entry.command)
+        if (commandEntries.length === 0) continue
+        hooks[event] = commandEntries.map(entry => ({
+          command: entry.command!.replace('${PLUGIN_ROOT}', '.'),
+        }))
+      }
+
+      manifest.hooks = hooks
+    }
+
+    await this.writeJson('gemini-extension.json', manifest)
+  }
+
+  private async generateInstructions(): 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()
+
+    const geminiMd = [
+      `# ${this.config.brand?.displayName ?? this.config.name}`,
+      '',
+      this.config.brand?.shortDescription ?? this.config.description,
+      '',
+      content,
+    ].join('\n')
+
+    await this.writeFile('GEMINI.md', geminiMd)
+  }
+}

package/src/generators/github-copilot/index.ts

@@ -0,0 +1,32 @@
+import { Generator } from '../base'
+import { generateClaudeFamilyOutputs } from '../shared/claude-family'
+import type { TargetPlatform } from '../../schema'
+
+/**
+ * GitHub Copilot CLI uses the same plugin manifest format as Claude Code.
+ * Discovery dirs: .github/skills/, .claude/skills/, .agents/skills/
+ */
+export class GitHubCopilotGenerator extends Generator {
+  readonly platform: TargetPlatform = 'github-copilot'
+
+  async generate(): Promise<void> {
+    await generateClaudeFamilyOutputs({
+      config: this.config,
+      rootDir: this.rootDir,
+      platform: this.platform,
+      options: {
+        manifestPath: '.claude-plugin/plugin.json',
+        instructionsFile: 'CLAUDE.md',
+        pluginRootVar: 'CLAUDE_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/hooks-warning.ts

@@ -0,0 +1,51 @@
+import type { HookEntry, TargetPlatform } from '../schema'
+
+const MATCHER_PASSTHROUGH_PLATFORMS = new Set<TargetPlatform>([
+  'claude-code',
+  'cursor',
+  'github-copilot',
+  'openhands',
+])
+
+const FAIL_CLOSED_PASSTHROUGH_PLATFORMS = new Set<TargetPlatform>([
+  'cursor',
+])
+
+const LOOP_LIMIT_PASSTHROUGH_PLATFORMS = new Set<TargetPlatform>([
+  'cursor',
+])
+
+export function warnDroppedHookFields(
+  platform: TargetPlatform,
+  event: string,
+  entries: HookEntry[],
+): void {
+  const hasPromptHooks = entries.some(entry => entry.type === 'prompt')
+  const hasMatcher = entries.some(entry => entry.matcher !== undefined)
+  const hasFailClosed = entries.some(entry => entry.failClosed !== undefined)
+  const hasLoopLimit = entries.some(entry => entry.loop_limit !== undefined)
+
+  if (hasPromptHooks) {
+    console.warn(
+      `[pluxx] ${platform} generator dropped unsupported prompt-based hook for event "${event}".`
+    )
+  }
+
+  if (hasMatcher && !MATCHER_PASSTHROUGH_PLATFORMS.has(platform)) {
+    console.warn(
+      `[pluxx] ${platform} generator dropped unsupported hook field "matcher" for event "${event}".`
+    )
+  }
+
+  if (hasFailClosed && !FAIL_CLOSED_PASSTHROUGH_PLATFORMS.has(platform)) {
+    console.warn(
+      `[pluxx] ${platform} generator dropped unsupported hook field "failClosed" for event "${event}".`
+    )
+  }
+
+  if (hasLoopLimit && !LOOP_LIMIT_PASSTHROUGH_PLATFORMS.has(platform)) {
+    console.warn(
+      `[pluxx] ${platform} generator dropped unsupported hook field "loop_limit" for event "${event}".`
+    )
+  }
+}

package/src/generators/index.ts

@@ -0,0 +1,71 @@
+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 }