@orchid-labs/pluxx 0.1.1 → 0.1.4

package/src/generators/shared/claude-family.ts

@@ -1,215 +0,0 @@
-import { existsSync } from 'fs'
-import { resolve } from 'path'
-import { warnDroppedHookFields } from '../hooks-warning'
-import type { PluginConfig, TargetPlatform } from '../../schema'
-import { mapHookEventToPascalCase } from '../../hook-events'
-import { buildGeneratedPermissionHookScript } from '../../permissions'
-
-export interface ClaudeFamilyOptions {
-  manifestPath: string
-  instructionsFile: string
-  pluginRootVar: string
-  titleSuffix?: string
-  mapEventName?: (event: string) => string
-  includeStandardHooksManifest?: boolean
-}
-
-export async function generateClaudeFamilyOutputs(args: {
-  config: PluginConfig
-  rootDir: string
-  platform: TargetPlatform
-  options: ClaudeFamilyOptions
-  writeJson: (relativePath: string, data: unknown) => Promise<void>
-  writeFile: (relativePath: string, content: string) => Promise<void>
-}): Promise<void> {
-  const {
-    config,
-    rootDir,
-    platform,
-    options,
-    writeJson,
-    writeFile,
-  } = args
-
-  await Promise.all([
-    writeManifest(config, options, writeJson),
-    writeMcpConfig(config, platform, writeJson),
-    writeHooks(config, platform, options, writeJson, writeFile),
-    writeInstructions(config, rootDir, options, writeFile),
-  ])
-}
-
-async function writeManifest(
-  config: PluginConfig,
-  options: ClaudeFamilyOptions,
-  writeJson: (relativePath: string, data: unknown) => Promise<void>,
-): Promise<void> {
-  const manifest: Record<string, unknown> = {
-    name: config.name,
-    version: config.version,
-    description: config.description,
-    author: config.author,
-    license: config.license,
-  }
-
-  if (config.repository) {
-    manifest.repository = config.repository
-  }
-  if (config.keywords) {
-    manifest.keywords = config.keywords
-  }
-  if (config.commands) {
-    manifest.commands = './commands/'
-  }
-  if (config.agents) {
-    manifest.agents = './agents/'
-  }
-  manifest.skills = './skills/'
-  if ((config.hooks || config.permissions) && options.includeStandardHooksManifest !== false) {
-    manifest.hooks = './hooks/hooks.json'
-  }
-  if (config.mcp) {
-    manifest.mcpServers = './.mcp.json'
-  }
-
-  await writeJson(options.manifestPath, manifest)
-}
-
-async function writeMcpConfig(
-  config: PluginConfig,
-  platform: TargetPlatform,
-  writeJson: (relativePath: string, data: unknown) => Promise<void>,
-): Promise<void> {
-  if (!config.mcp) return
-
-  const mcpServers: Record<string, unknown> = {}
-  const usesPlatformManagedAuth = platform === 'claude-code'
-    && config.platforms?.['claude-code']?.mcpAuth === 'platform'
-
-  for (const [name, server] of Object.entries(config.mcp)) {
-    if (server.transport === 'stdio' && server.command) {
-      mcpServers[name] = {
-        command: server.command,
-        args: server.args ?? [],
-        env: server.env ?? {},
-      }
-    } else {
-      const entry: Record<string, unknown> = {
-        type: server.transport === 'sse' ? 'sse' : 'http',
-        url: server.url,
-      }
-
-      if (usesPlatformManagedAuth || server.auth?.type === 'platform') {
-        mcpServers[name] = entry
-        continue
-      }
-
-      if (server.auth?.type === 'bearer' && server.auth.envVar) {
-        entry.headers = {
-          Authorization: `Bearer \${${server.auth.envVar}}`,
-        }
-      } else if (server.auth?.type === 'header' && server.auth.envVar) {
-        entry.headers = {
-          [server.auth.headerName]: server.auth.headerTemplate.replace(
-            '${value}',
-            `\${${server.auth.envVar}}`,
-          ),
-        }
-      }
-
-      mcpServers[name] = entry
-    }
-  }
-
-  await writeJson('.mcp.json', { mcpServers })
-}
-
-async function writeHooks(
-  config: PluginConfig,
-  platform: TargetPlatform,
-  options: ClaudeFamilyOptions,
-  writeJson: (relativePath: string, data: unknown) => Promise<void>,
-  writeFile: (relativePath: string, content: string) => Promise<void>,
-): Promise<void> {
-  const hooks: Record<string, unknown[]> = {}
-  const mapEventName = options.mapEventName ?? defaultMapEventName
-  const usesPlatformManagedAuth = platform === 'claude-code'
-    && config.platforms?.['claude-code']?.mcpAuth === 'platform'
-  const permissionScript = buildGeneratedPermissionHookScript(config.permissions)
-
-  if (permissionScript) {
-    await writeFile('hooks/pluxx-permissions.mjs', permissionScript)
-    hooks.PreToolUse = [{
-      hooks: [{
-        type: 'command',
-        command: `node \${${options.pluginRootVar}}/hooks/pluxx-permissions.mjs claude-pretool`,
-      }],
-    }]
-  }
-
-  if (!config.hooks) {
-    if (Object.keys(hooks).length > 0) {
-      await writeJson('hooks/hooks.json', { hooks })
-    }
-    return
-  }
-
-  for (const [event, entries] of Object.entries(config.hooks)) {
-    if (!entries) continue
-
-    warnDroppedHookFields(platform, event, entries)
-    const mappedEvent = mapEventName(event)
-    const commandEntries = entries.filter((entry) => {
-      if (entry.type === 'prompt' || !entry.command) return false
-      if (
-        usesPlatformManagedAuth
-        && entry.command.includes('check-env.sh')
-      ) {
-        return false
-      }
-      return true
-    })
-    if (commandEntries.length === 0) continue
-
-    hooks[mappedEvent] = [
-      ...(hooks[mappedEvent] ?? []),
-      ...commandEntries.map(entry => ({
-      ...(entry.matcher !== undefined ? { matcher: entry.matcher } : {}),
-      hooks: [{
-        type: 'command',
-        command: entry.command!.replace('${PLUGIN_ROOT}', `\${${options.pluginRootVar}}`),
-      }],
-      })),
-    ]
-  }
-
-  await writeJson('hooks/hooks.json', { hooks })
-}
-
-async function writeInstructions(
-  config: PluginConfig,
-  rootDir: string,
-  options: ClaudeFamilyOptions,
-  writeFile: (relativePath: string, content: string) => Promise<void>,
-): Promise<void> {
-  if (!config.instructions) return
-
-  const srcPath = resolve(rootDir, config.instructions)
-  if (!existsSync(srcPath)) return
-
-  const content = await Bun.file(srcPath).text()
-  const titleSuffix = options.titleSuffix ?? 'Plugin'
-  const instructions = [
-    `# ${config.brand?.displayName ?? config.name} ${titleSuffix}`,
-    '',
-    config.brand?.shortDescription ?? config.description,
-    '',
-    content,
-  ].join('\n')
-
-  await writeFile(options.instructionsFile, instructions)
-}
-
-function defaultMapEventName(event: string): string {
-  return mapHookEventToPascalCase(event)
-}

package/src/generators/warp/index.ts

@@ -1,32 +0,0 @@
-import { existsSync } from 'fs'
-import { Generator } from '../base'
-import type { TargetPlatform } from '../../schema'
-
-/**
- * Warp reads skills from .agents/skills/ and .warp/skills/.
- * Uses AGENTS.md for instructions. MCP via config.
- * No formal plugin manifest — generates skills + AGENTS.md + MCP config.
- */
-export class WarpGenerator extends Generator {
-  readonly platform: TargetPlatform = 'warp'
-
-  async generate(): Promise<void> {
-    await Promise.all([
-      this.generateAgentsMd(),
-      this.generateMcpConfig('mcp.json'),
-    ])
-
-    this.copySkills()
-    this.copyScripts()
-  }
-
-  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/hook-events.ts

@@ -1,33 +0,0 @@
-export const CURSOR_SUPPORTED_HOOK_EVENTS = [
-  'sessionStart',
-  'sessionEnd',
-  'preToolUse',
-  'postToolUse',
-  'postToolUseFailure',
-  'subagentStart',
-  'subagentStop',
-  'beforeShellExecution',
-  'afterShellExecution',
-  'beforeMCPExecution',
-  'afterMCPExecution',
-  'beforeReadFile',
-  'afterFileEdit',
-  'beforeSubmitPrompt',
-  'preCompact',
-  'stop',
-  'afterAgentResponse',
-  'afterAgentThought',
-  'beforeTabFileRead',
-  'afterTabFileEdit',
-] as const
-
-export const CURSOR_LOOP_LIMIT_HOOK_EVENTS = ['stop', 'subagentStop'] as const
-
-const PASCAL_CASE_HOOK_ALIASES: Record<string, string> = {
-  beforeSubmitPrompt: 'UserPromptSubmit',
-}
-
-export function mapHookEventToPascalCase(event: string): string {
-  return PASCAL_CASE_HOOK_ALIASES[event]
-    ?? event.charAt(0).toUpperCase() + event.slice(1)
-}

package/src/index.ts

@@ -1,34 +0,0 @@
-export {
-  PluginConfigSchema,
-  type PluginConfig,
-  type TargetPlatform,
-  type UserConfigEntry,
-  type PermissionRule,
-  type Permissions,
-} from './schema'
-export { definePlugin } from './config/define'
-export {
-  PLATFORM_LIMITS,
-  PLATFORM_LIMIT_POLICIES,
-  PLATFORM_VALIDATION_RULES,
-  getPlatformRules,
-  type PlatformLimitKind,
-  type PlatformLimitPolicy,
-  type PlatformLimitPolicies,
-  type PlatformLimits,
-  type PlatformRules,
-  type PlatformRuleSource,
-} from './validation/platform-rules'
-export { getPlatformCompatibilityMatrix, renderCompatibilityMatrixMarkdown, type PlatformCompatibilityRow } from './compatibility/matrix'
-export {
-  buildGeneratedPermissionHookScript,
-  buildOpenCodePermissionMap,
-  collectPermissionRules,
-  parsePermissionRule,
-  permissionRulesNeedToolLevelDowngrade,
-  type OpenCodePermissionMap,
-  type ParsedPermissionRule,
-  type PermissionAction,
-  type PermissionRuleKind,
-} from './permissions'
-export { formatPublishPlan, planPublish, runPublish, type PublishAssetPlan, type PublishCheck, type PublishPlan, type PublishPlanOptions, type PublishRunResult } from './cli/publish'