@orchid-labs/pluxx 0.1.0 → 0.1.1

package/src/cli/test.ts

@@ -3,6 +3,7 @@ import { resolve } from 'path'
 import { loadConfig } from '../config/load'
 import { build } from '../generators'
 import { lintProject, type LintResult } from './lint'
+import { runEvalSuite, type EvalReport } from './eval'
 import type { TargetPlatform } from '../schema'
 
 export interface TestRunOptions {
@@ -25,6 +26,7 @@ export interface TestRunResult {
     error?: string
   }
   lint?: LintResult
+  eval?: EvalReport
   build?: {
     ok: boolean
     outDir: string
@@ -56,7 +58,7 @@ export async function runTestSuite(options: TestRunOptions = {}): Promise<TestRu
   try {
     const config = await loadConfig(rootDir)
     const targets = options.targets ?? config.targets
-    const lint = await lintProject(rootDir)
+    const lint = await lintProject(rootDir, { targets })
 
     if (lint.errors > 0) {
       return {
@@ -71,6 +73,7 @@ export async function runTestSuite(options: TestRunOptions = {}): Promise<TestRu
     }
 
     await build(config, rootDir, { targets })
+    const evalReport = await runEvalSuite({ rootDir })
 
     const checks = targets.map((platform) => {
       const requiredPath = SMOKE_PATHS[platform]
@@ -79,13 +82,14 @@ export async function runTestSuite(options: TestRunOptions = {}): Promise<TestRu
     })
 
     return {
-      ok: checks.every((check) => check.ok),
+      ok: checks.every((check) => check.ok) && evalReport.errors === 0,
       config: {
         ok: true,
         name: config.name,
         version: config.version,
       },
       lint,
+      eval: evalReport,
       build: {
         ok: true,
         outDir: config.outDir,
@@ -119,6 +123,10 @@ export function printTestResult(result: TestRunResult): void {
     console.log(`Lint: ${result.lint.errors} error(s), ${result.lint.warnings} warning(s)`)
   }
 
+  if (result.eval) {
+    console.log(`Eval: ${result.eval.errors} error(s), ${result.eval.warnings} warning(s), ${result.eval.infos} info message(s)`)
+  }
+
   if (result.build) {
     console.log(`Build: ${result.build.targets.join(', ')} -> ${result.build.outDir}`)
   }

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

@@ -1,6 +1,8 @@
 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'
@@ -26,4 +28,145 @@ export class ClaudeCodeGenerator extends Generator {
     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/codex/index.ts

@@ -1,6 +1,7 @@
 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'
@@ -44,6 +45,7 @@ export class CodexGenerator extends Generator {
         },
       }),
       this.generateAgentsMd(),
+      this.generatePermissionsCompanion(),
     ])
 
     this.copySkills()
@@ -92,6 +94,12 @@ export class CodexGenerator extends Generator {
       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
       }
@@ -109,6 +117,21 @@ export class CodexGenerator extends Generator {
 
     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')

package/src/index.ts

@@ -7,7 +7,18 @@ export {
   type Permissions,
 } from './schema'
 export { definePlugin } from './config/define'
-export { PLATFORM_LIMITS, PLATFORM_VALIDATION_RULES, getPlatformRules, type PlatformLimits, type PlatformRules, type PlatformRuleSource } from './validation/platform-rules'
+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,