@orchid-labs/pluxx 0.1.1 → 0.1.4

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

@@ -1,172 +0,0 @@
-import { Generator } from '../base'
-import { generateClaudeFamilyOutputs } from '../shared/claude-family'
-import type { TargetPlatform } from '../../schema'
-import { existsSync, readFileSync, readdirSync, writeFileSync } from 'fs'
-import { basename, join } from 'path'
-
-export class ClaudeCodeGenerator extends Generator {
-  readonly platform: TargetPlatform = 'claude-code'
-
-  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',
-        includeStandardHooksManifest: false,
-      },
-      writeJson: (relativePath, data) => this.writeJson(relativePath, data),
-      writeFile: (relativePath, content) => this.writeFile(relativePath, content),
-    })
-
-    this.copySkills()
-    this.copyCommands()
-    this.copyAgents()
-    this.copyScripts()
-    this.copyAssets()
-  }
-
-  protected copySkills(): void {
-    super.copySkills()
-
-    const collidingSkills = this.collectCollidingSkills()
-    for (const skill of collidingSkills) {
-      const outputPath = join(this.outDir, 'skills', skill.dirName, 'SKILL.md')
-      if (!existsSync(outputPath)) continue
-
-      const current = readFileSync(outputPath, 'utf-8')
-      const hiddenName = buildHiddenSkillName(skill.effectiveName)
-      const rewritten = rewriteClaudeCollidingSkill(current, hiddenName)
-      if (rewritten !== current) {
-        writeFileSync(outputPath, rewritten, 'utf-8')
-      }
-    }
-  }
-
-  private collectCollidingSkills(): Array<{ dirName: string; effectiveName: string }> {
-    if (!this.config.commands) return []
-
-    const commandsSrc = this.resolveConfigPath(this.config.commands, 'commands')
-    const skillsSrc = this.resolveConfigPath(this.config.skills, 'skills')
-    if (!existsSync(commandsSrc) || !existsSync(skillsSrc)) return []
-
-    const commandNames = collectTopLevelCommandNames(commandsSrc)
-    const collidingSkills: Array<{ dirName: string; effectiveName: string }> = []
-
-    for (const entry of readdirSync(skillsSrc, { withFileTypes: true })) {
-      if (!entry.isDirectory()) continue
-      const skillFile = join(skillsSrc, entry.name, 'SKILL.md')
-      if (!existsSync(skillFile)) continue
-
-      const content = readFileSync(skillFile, 'utf-8')
-      const effectiveName = getEffectiveSkillName(content, entry.name)
-      if (commandNames.has(effectiveName)) {
-        collidingSkills.push({ dirName: entry.name, effectiveName })
-      }
-    }
-
-    return collidingSkills
-  }
-}
-
-function collectTopLevelCommandNames(commandsRoot: string): Set<string> {
-  const commandNames = new Set<string>()
-  for (const entry of readdirSync(commandsRoot, { withFileTypes: true })) {
-    if (entry.isFile() && entry.name.toLowerCase().endsWith('.md')) {
-      commandNames.add(basename(entry.name, '.md'))
-    }
-  }
-  return commandNames
-}
-
-function getEffectiveSkillName(content: string, fallback: string): string {
-  const frontmatter = extractFrontmatterLines(content)
-  if (!frontmatter) return fallback
-
-  for (const line of frontmatter) {
-    const match = /^name:\s*(.+)\s*$/i.exec(line.trim())
-    if (match?.[1]) {
-      return stripYamlScalar(match[1]) || fallback
-    }
-  }
-
-  return fallback
-}
-
-function buildHiddenSkillName(name: string): string {
-  const maxBaseLength = 64 - '-skill'.length
-  const trimmed = name.length > maxBaseLength ? name.slice(0, maxBaseLength) : name
-  return `${trimmed}-skill`
-}
-
-function rewriteClaudeCollidingSkill(content: string, hiddenName: string): string {
-  const frontmatter = extractFrontmatterLines(content)
-  if (!frontmatter) {
-    return [
-      '---',
-      `name: ${hiddenName}`,
-      'user-invocable: false',
-      '---',
-      '',
-      content.trimStart(),
-    ].join('\n')
-  }
-
-  const rewritten = [...frontmatter]
-  let sawName = false
-  let sawUserInvocable = false
-
-  for (let index = 0; index < rewritten.length; index += 1) {
-    const trimmed = rewritten[index].trim()
-    if (/^name:\s*/i.test(trimmed)) {
-      rewritten[index] = `name: ${hiddenName}`
-      sawName = true
-      continue
-    }
-    if (/^user-invocable:\s*/i.test(trimmed)) {
-      rewritten[index] = 'user-invocable: false'
-      sawUserInvocable = true
-    }
-  }
-
-  if (!sawName) rewritten.push(`name: ${hiddenName}`)
-  if (!sawUserInvocable) rewritten.push('user-invocable: false')
-
-  const lines = content.split('\n')
-  const endIndex = findFrontmatterEndIndex(lines)
-  const body = endIndex === -1 ? content : lines.slice(endIndex + 1).join('\n')
-  return ['---', ...rewritten, '---', body ? `\n${body.replace(/^\n/, '')}` : ''].join('\n')
-}
-
-function extractFrontmatterLines(content: string): string[] | null {
-  const lines = content.split('\n')
-  const endIndex = findFrontmatterEndIndex(lines)
-  if (endIndex === -1) return null
-  return lines.slice(1, endIndex)
-}
-
-function findFrontmatterEndIndex(lines: string[]): number {
-  if (lines[0]?.trim() !== '---') return -1
-
-  for (let index = 1; index < lines.length; index += 1) {
-    if (lines[index].trim() === '---') {
-      return index
-    }
-  }
-
-  return -1
-}
-
-function stripYamlScalar(value: string): string {
-  const trimmed = value.trim()
-  if (
-    (trimmed.startsWith('"') && trimmed.endsWith('"'))
-    || (trimmed.startsWith("'") && trimmed.endsWith("'"))
-  ) {
-    return trimmed.slice(1, -1).trim()
-  }
-  return trimmed
-}

package/src/generators/cline/index.ts

@@ -1,35 +0,0 @@
-import { existsSync } from 'fs'
-import { Generator } from '../base'
-import type { TargetPlatform } from '../../schema'
-
-/**
- * Cline uses .clinerules for instructions, .cline/mcp.json for MCP config,
- * and .cline/skills/ for skills. No plugin manifest.
- */
-export class ClineGenerator extends Generator {
-  readonly platform: TargetPlatform = 'cline'
-
-  async generate(): Promise<void> {
-    await Promise.all([
-      this.generateMcpConfig('.cline/mcp.json'),
-      this.generateRules(),
-    ])
-
-    this.copyClineSkills()
-    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('.clinerules', content)
-  }
-
-  /** Copy skills into .cline/skills/ instead of the default skills/ */
-  private copyClineSkills(): void {
-    this.copyDir(this.config.skills, '.cline/skills/', 'skills')
-  }
-}

package/src/generators/codex/index.ts

@@ -1,143 +0,0 @@
-import { existsSync } from 'fs'
-import { Generator } from '../base'
-import type { TargetPlatform } from '../../schema'
-import { collectPermissionRules } from '../../permissions'
-
-export class CodexGenerator extends Generator {
-  readonly platform: TargetPlatform = 'codex'
-
-  async generate(): Promise<void> {
-    await Promise.all([
-      this.generateManifest(),
-      this.generateMcpConfig('.mcp.json', {
-        includeDefaultAuthHeaders: false,
-        transformRemoteEntry: ({ name, server }) => {
-          const entry: Record<string, unknown> = {
-            url: server.url,
-          }
-
-          if (server.auth?.type === 'bearer' && server.auth.envVar) {
-            entry.bearer_token_env_var = server.auth.envVar
-          } else if (server.auth?.type === 'header' && server.auth.envVar) {
-            const isBearerAuthorizationHeader =
-              server.auth.headerName === 'Authorization'
-              && server.auth.headerTemplate === 'Bearer ${value}'
-
-            if (isBearerAuthorizationHeader) {
-              entry.bearer_token_env_var = server.auth.envVar
-            } else if (server.auth.headerTemplate === '${value}') {
-              entry.env_http_headers = {
-                [server.auth.headerName]: server.auth.envVar,
-              }
-            } else if (!server.auth.headerTemplate.includes('${value}')) {
-              entry.http_headers = {
-                [server.auth.headerName]: server.auth.headerTemplate,
-              }
-            } else {
-              console.warn(
-                `[pluxx] codex generator: MCP server "${name}" uses auth.type "header" with a templated header Codex cannot express exactly. `
-                + 'Supported Codex auth outputs are bearer_token_env_var, env_http_headers, and http_headers; this header was omitted.'
-              )
-            }
-          }
-
-          return entry
-        },
-      }),
-      this.generateAgentsMd(),
-      this.generatePermissionsCompanion(),
-    ])
-
-    this.copySkills()
-    this.copyAgents()
-    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,
-    }
-
-    if (this.config.repository) manifest.homepage = this.config.repository
-    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
-
-    manifest.skills = './skills/'
-    if (this.config.mcp) manifest.mcpServers = './.mcp.json'
-
-    // Codex supports rich interface metadata
-    if (this.config.brand) {
-      const iface: Record<string, unknown> = {
-        displayName: this.config.brand.displayName,
-        shortDescription: this.config.brand.shortDescription ?? this.config.description,
-        category: this.config.brand.category,
-      }
-
-      if (this.config.brand.longDescription) {
-        iface.longDescription = this.config.brand.longDescription
-      }
-      if (this.config.brand.color) {
-        iface.brandColor = this.config.brand.color
-      }
-      if (this.config.brand.icon) {
-        iface.composerIcon = this.config.brand.icon
-        iface.logo = this.config.brand.icon
-      }
-      if (this.config.brand.defaultPrompts) {
-        iface.defaultPrompt = this.config.brand.defaultPrompts
-      }
-      if (this.config.brand.websiteURL) {
-        iface.websiteURL = this.config.brand.websiteURL
-      }
-      if (this.config.brand.privacyPolicyURL) {
-        iface.privacyPolicyURL = this.config.brand.privacyPolicyURL
-      }
-      if (this.config.brand.termsOfServiceURL) {
-        iface.termsOfServiceURL = this.config.brand.termsOfServiceURL
-      }
-      if (this.config.brand.screenshots) {
-        iface.screenshots = this.config.brand.screenshots
-      }
-
-      // Merge Codex-specific interface overrides
-      const codexOverrides = this.config.platforms?.codex?.interface
-      if (codexOverrides) {
-        Object.assign(iface, codexOverrides)
-      }
-
-      iface.developerName = this.config.author.name
-
-      manifest.interface = iface
-    }
-
-    await this.writeJson('.codex-plugin/plugin.json', manifest)
-  }
-
-  private async generatePermissionsCompanion(): Promise<void> {
-    if (!this.config.permissions) return
-
-    const rules = collectPermissionRules(this.config.permissions)
-    if (rules.length === 0) return
-
-    await this.writeJson('.codex/permissions.generated.json', {
-      model: 'pluxx.permissions.v1',
-      enforcedByPluginBundle: false,
-      note: 'Codex permissions are configured externally. Use this file as a generated mirror of canonical rules for Codex user/admin policy or hook configuration.',
-      rules,
-    })
-  }
-
-  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/cursor/index.ts

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

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

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

@@ -1,51 +0,0 @@
-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}".`
-    )
-  }
-}