oh-my-customcode 0.158.0 → 0.159.0

package/templates/.claude/skills/codex-exec/scripts/codex-wrapper.cjs

@@ -1,430 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * codex-wrapper.js
- *
- * Node.js wrapper for OpenAI Codex CLI (non-interactive execution).
- * Executes codex in ephemeral mode with structured JSON output.
- *
- * Usage:
- *   node codex-wrapper.js --prompt "your prompt" [options]
- *
- * Options:
- *   --prompt <text>       Required: prompt to execute
- *   --json                Enable JSON Lines output from codex
- *   --output <path>       Save final message to file
- *   --model <name>        Specify model (default: o3)
- *   --timeout <ms>        Execution timeout in milliseconds (default: 120000, max: 600000)
- *   --full-auto           Use full-auto approval mode (default: -a never)
- *   --working-dir <dir>   Set working directory for execution
- *
- * Output (JSON to stdout):
- *   Success: { "success": true, "output": "...", "duration_ms": 1234, ... }
- *   Failure: { "success": false, "error": "...", "stderr": "...", ... }
- *
- * Exit codes:
- *   0 = success
- *   1 = execution error
- *   2 = validation error (missing binary/auth)
- */
-
-const { spawn, execFileSync } = require('child_process');
-const fs = require('fs');
-const path = require('path');
-const os = require('os');
-
-// Configuration
-const DEFAULT_TIMEOUT_MS = 120000; // 2 minutes
-const MAX_TIMEOUT_MS = 600000; // 10 minutes
-const KILL_GRACE_PERIOD_MS = 5000; // 5 seconds for graceful shutdown
-
-/**
- * Parse command line arguments
- * @returns {Object} Parsed arguments
- */
-function parseArgs() {
-  const args = {
-    prompt: null,
-    json: false,
-    output: null,
-    model: null,
-    timeout: DEFAULT_TIMEOUT_MS,
-    fullAuto: false,
-    workingDir: null,
-    effort: null,
-  };
-
-  for (let i = 2; i < process.argv.length; i++) {
-    const arg = process.argv[i];
-
-    switch (arg) {
-      case '--prompt':
-        if (i + 1 < process.argv.length) {
-          args.prompt = process.argv[++i];
-        }
-        break;
-      case '--json':
-        args.json = true;
-        break;
-      case '--output':
-        if (i + 1 < process.argv.length) {
-          args.output = process.argv[++i];
-        }
-        break;
-      case '--model':
-        if (i + 1 < process.argv.length) {
-          args.model = process.argv[++i];
-        }
-        break;
-      case '--timeout':
-        if (i + 1 < process.argv.length) {
-          const timeoutValue = parseInt(process.argv[++i], 10);
-          if (!isNaN(timeoutValue)) {
-            args.timeout = Math.min(timeoutValue, MAX_TIMEOUT_MS);
-          }
-        }
-        break;
-      case '--full-auto':
-        args.fullAuto = true;
-        break;
-      case '--working-dir':
-        if (i + 1 < process.argv.length) {
-          args.workingDir = process.argv[++i];
-        }
-        break;
-      case '--effort':
-      case '--reasoning-effort':
-        if (i + 1 < process.argv.length) {
-          args.effort = process.argv[++i];
-        }
-        break;
-    }
-  }
-
-  return args;
-}
-
-/**
- * Validate environment for codex execution
- * @returns {Object} Validation result { valid: boolean, errors: string[] }
- */
-function validateEnvironment() {
-  const errors = [];
-
-  // Check for codex binary
-  try {
-    execFileSync('which', ['codex'], { stdio: 'pipe' });
-  } catch (error) {
-    // Try common installation paths
-    const commonPaths = [
-      '/usr/local/bin/codex',
-      path.join(os.homedir(), '.local', 'bin', 'codex'),
-      path.join(os.homedir(), 'bin', 'codex'),
-    ];
-
-    const codexExists = commonPaths.some(p => fs.existsSync(p));
-    if (!codexExists) {
-      errors.push('codex binary not found in PATH or common locations');
-    }
-  }
-
-  // Note: OPENAI_API_KEY is optional if codex has its own stored auth (via `codex auth`)
-  if (!process.env.OPENAI_API_KEY) {
-    console.error('[codex-wrapper] Note: OPENAI_API_KEY not set, relying on codex built-in auth');
-  }
-
-  return {
-    valid: errors.length === 0,
-    errors,
-  };
-}
-
-/**
- * Build codex command array
- * @param {Object} options - Command options
- * @returns {Object} Command structure { binary: string, args: string[] }
- */
-function buildCommand(options) {
-  const args = ['exec', '--ephemeral'];
-
-  // Approval mode (default: normal, --full-auto: automatic execution)
-  if (options.fullAuto) {
-    args.push('--full-auto');
-  }
-
-  // JSON output
-  if (options.json) {
-    args.push('--json');
-  }
-
-  // Model selection
-  if (options.model) {
-    args.push('--model', options.model);
-  }
-
-  // Working directory
-  if (options.workingDir) {
-    args.push('-C', options.workingDir);
-  }
-
-  // Reasoning effort (maps to -c model_reasoning_effort="value")
-  if (options.effort) {
-    const validEfforts = ['minimal', 'low', 'medium', 'high', 'xhigh'];
-    if (validEfforts.includes(options.effort)) {
-      args.push('-c', `model_reasoning_effort="${options.effort}"`);
-    } else {
-      process.stderr.write(`Warning: Invalid effort level "${options.effort}". Valid: ${validEfforts.join(', ')}\n`);
-    }
-  }
-
-  // Add prompt as last argument
-  args.push(options.prompt);
-
-  return {
-    binary: 'codex',
-    args,
-  };
-}
-
-/**
- * Execute codex command
- * @param {string} binary - Binary to execute
- * @param {string[]} args - Command arguments
- * @param {number} timeout - Timeout in milliseconds
- * @param {string|null} workingDir - Working directory
- * @returns {Promise<Object>} Execution result
- */
-function executeCodex(binary, args, timeout, workingDir = null) {
-  return new Promise((resolve) => {
-    const startTime = Date.now();
-    let stdout = '';
-    let stderr = '';
-    let timedOut = false;
-
-    const spawnOptions = {
-      cwd: workingDir || process.cwd(),
-      env: process.env,
-    };
-
-    const child = spawn(binary, args, spawnOptions);
-
-    // Collect output
-    child.stdout.on('data', (data) => {
-      stdout += data.toString();
-    });
-
-    child.stderr.on('data', (data) => {
-      stderr += data.toString();
-    });
-
-    // Set timeout
-    const timeoutHandle = setTimeout(() => {
-      timedOut = true;
-      console.error('[codex-wrapper] Timeout reached, terminating process...', { file: 'stderr' });
-
-      // Graceful termination attempt
-      child.kill('SIGTERM');
-
-      // Force kill after grace period
-      setTimeout(() => {
-        if (!child.killed) {
-          console.error('[codex-wrapper] Force killing process...', { file: 'stderr' });
-          child.kill('SIGKILL');
-        }
-      }, KILL_GRACE_PERIOD_MS);
-    }, timeout);
-
-    // Handle process exit
-    child.on('close', (exitCode) => {
-      clearTimeout(timeoutHandle);
-      const durationMs = Date.now() - startTime;
-
-      resolve({
-        exitCode: exitCode !== null ? exitCode : 1,
-        stdout,
-        stderr,
-        timedOut,
-        durationMs,
-      });
-    });
-
-    // Handle spawn errors
-    child.on('error', (error) => {
-      clearTimeout(timeoutHandle);
-      const durationMs = Date.now() - startTime;
-
-      resolve({
-        exitCode: 1,
-        stdout,
-        stderr: stderr + '\nSpawn error: ' + error.message,
-        timedOut: false,
-        durationMs,
-      });
-    });
-  });
-}
-
-/**
- * Parse JSON Lines output from codex
- * @param {string} output - Raw output string
- * @returns {Object} Parsed result { events: object[], finalMessage: string|null, parseErrors: string[] }
- */
-function parseJsonLines(output) {
-  const lines = output.split('\n').filter(line => line.trim().length > 0);
-  const events = [];
-  const parseErrors = [];
-  let finalMessage = null;
-
-  for (const line of lines) {
-    try {
-      const event = JSON.parse(line);
-      events.push(event);
-
-      // Codex CLI v0.99.0 format: item.completed events with agent_message type
-      if (event.type === 'item.completed' && event.item) {
-        if (event.item.type === 'agent_message' && event.item.text) {
-          finalMessage = event.item.text;
-        }
-      }
-      // Look for assistant message in various event structures (fallback for future API changes)
-      else if (event.type === 'assistant_message' && event.content) {
-        finalMessage = event.content;
-      } else if (event.message && event.message.role === 'assistant') {
-        finalMessage = event.message.content || event.message.text;
-      } else if (event.role === 'assistant' && event.content) {
-        finalMessage = event.content;
-      }
-    } catch (error) {
-      parseErrors.push(`Failed to parse line: ${error.message}`);
-    }
-  }
-
-  return {
-    events,
-    finalMessage,
-    parseErrors,
-  };
-}
-
-/**
- * Main execution function
- */
-async function main() {
-  const args = parseArgs();
-
-  // Validate required arguments
-  if (!args.prompt) {
-    const result = {
-      success: false,
-      error: 'Missing required argument: --prompt',
-      exit_code: 2,
-    };
-    console.log(JSON.stringify(result, null, 2));
-    process.exit(2);
-  }
-
-  // Validate environment
-  const validation = validateEnvironment();
-  if (!validation.valid) {
-    const result = {
-      success: false,
-      error: 'Environment validation failed',
-      validation_errors: validation.errors,
-      exit_code: 2,
-    };
-    console.log(JSON.stringify(result, null, 2));
-    process.exit(2);
-  }
-
-  console.error(`[codex-wrapper] Executing codex with timeout: ${args.timeout}ms`);
-  if (args.workingDir) {
-    console.error(`[codex-wrapper] Working directory: ${args.workingDir}`);
-  }
-
-  // Build command
-  const command = buildCommand(args);
-  console.error(`[codex-wrapper] Command: ${command.binary} ${command.args.join(' ')}`);
-
-  // Execute
-  const execResult = await executeCodex(
-    command.binary,
-    command.args,
-    args.timeout,
-    args.workingDir
-  );
-
-  // Process result
-  let output = null;
-  let eventsCount = 0;
-
-  if (args.json && execResult.stdout) {
-    const parsed = parseJsonLines(execResult.stdout);
-    eventsCount = parsed.events.length;
-    output = parsed.finalMessage;
-
-    if (parsed.parseErrors.length > 0) {
-      console.error('[codex-wrapper] JSON parse errors:', parsed.parseErrors.join('; '));
-    }
-  } else {
-    output = execResult.stdout.trim();
-  }
-
-  // Determine success
-  const success = execResult.exitCode === 0 && !execResult.timedOut;
-
-  // Build result object
-  const result = {
-    success,
-    duration_ms: execResult.durationMs,
-    exit_code: execResult.exitCode,
-  };
-
-  if (success) {
-    result.output = output || execResult.stdout;
-    result.model = args.model || 'o3';
-    if (args.json) {
-      result.events_count = eventsCount;
-    }
-  } else {
-    if (execResult.timedOut) {
-      result.error = `Execution timed out after ${args.timeout}ms`;
-    } else {
-      result.error = 'Execution failed';
-    }
-    if (execResult.stderr) {
-      result.stderr = execResult.stderr.trim();
-    }
-  }
-
-  // Write output file if requested
-  if (args.output && output) {
-    try {
-      const outputDir = path.dirname(args.output);
-      if (!fs.existsSync(outputDir)) {
-        fs.mkdirSync(outputDir, { recursive: true });
-      }
-      fs.writeFileSync(args.output, output, 'utf-8');
-      console.error(`[codex-wrapper] Output written to: ${args.output}`);
-    } catch (error) {
-      console.error(`[codex-wrapper] Failed to write output file: ${error.message}`);
-      result.output_file_error = error.message;
-    }
-  }
-
-  // Output JSON result to stdout
-  console.log(JSON.stringify(result, null, 2));
-
-  process.exit(result.exit_code);
-}
-
-// Run
-main().catch(error => {
-  const result = {
-    success: false,
-    error: 'Unexpected error: ' + error.message,
-    stack: error.stack,
-    exit_code: 1,
-  };
-  console.log(JSON.stringify(result, null, 2));
-  process.exit(1);
-});

package/templates/.claude/skills/gemini-exec/SKILL.md

@@ -1,215 +0,0 @@
----
-name: gemini-exec
-description: Execute Gemini CLI prompts and return results
-scope: core
-argument-hint: "<prompt> [--json] [--stream-json] [--output <path>] [--model <name>] [--timeout <ms>] [--sandbox] [--plan]"
-user-invocable: true
----
-
-# Gemini Exec Skill
-
-Execute Google Gemini CLI prompts in non-interactive mode and return structured results. Enables Claude + Gemini hybrid workflows.
-
-## Options
-
-```
-<prompt>          Required. The prompt to send to Gemini CLI
---json            Return structured JSON output (-o json)
---stream-json     Return streaming JSON events (-o stream-json)
---output <path>   Save response to file
---model <name>    Model override (default: Gemini CLI default)
---timeout <ms>    Execution timeout (default: 120000, max: 600000)
---yolo            Enable auto-approval mode (gemini -y)
---sandbox         Run in sandbox mode (gemini -s)
---plan            Use plan approval mode (--approval-mode plan)
---working-dir     Working directory for Gemini execution
-```
-
-## Workflow
-
-```
-1. Pre-checks
-   - Verify `gemini` binary is installed (which gemini)
-   - Verify authentication (GOOGLE_API_KEY, GEMINI_API_KEY, or gcloud auth)
-2. Build command
-   - Base: gemini -p "<prompt>"
-   - Apply options: -o json, -m <model>, -y, -s, --approval-mode plan
-3. Execute
-   - Run via Bash tool with timeout (default 2min, max 10min)
-   - Or use helper script: node .claude/skills/gemini-exec/scripts/gemini-wrapper.cjs
-4. Parse output
-   - Text mode: return raw stdout
-   - JSON mode: parse single JSON object, extract response field
-   - Stream-JSON mode: parse event stream, extract final assistant message
-5. Report results
-   - Format output with execution metadata
-```
-
-## Safety Defaults
-
-- `-p` flag: Non-interactive prompt mode (no session persistence)
-- Default mode: Normal approval (Gemini prompts for confirmation)
-- Override with `--yolo` only when explicitly requested
-- Sandbox mode (`-s`) available for isolated execution
-
-## Output Format
-
-### Success (Text Mode)
-```
-[Gemini Exec] Completed
-
-Model: (default)
-Duration: 23.4s
-Working Dir: /path/to/project
-
---- Output ---
-{gemini response text}
-```
-
-### Success (JSON Mode)
-```
-[Gemini Exec] Completed (JSON)
-
-Model: (default)
-Duration: 23.4s
-
---- Response ---
-{extracted response from JSON}
-
---- Stats ---
-{token usage and other stats}
-```
-
-### Success (Stream-JSON Mode)
-```
-[Gemini Exec] Completed (Stream-JSON)
-
-Model: (default)
-Duration: 23.4s
-Events: 12
-
---- Final Message ---
-{extracted final assistant message}
-```
-
-### Failure
-```
-[Gemini Exec] Failed
-
-Error: {error_message}
-Exit Code: {code}
-Suggested Fix: {suggestion}
-```
-
-## Helper Script
-
-For complex executions, use the wrapper script:
-```bash
-node .claude/skills/gemini-exec/scripts/gemini-wrapper.cjs --prompt "your prompt" [options]
-```
-
-The wrapper provides:
-- Environment validation (binary + auth checks)
-- Safe command construction
-- JSON and stream-JSON parsing with response extraction
-- Structured JSON output
-- Timeout handling with graceful termination
-
-## Examples
-
-```bash
-# Simple text prompt
-gemini-exec "explain what this project does"
-
-# JSON output with model override
-gemini-exec "list all TODO items" --json --model gemini-2.5-pro
-
-# Stream-JSON for detailed event tracking
-gemini-exec "analyze the codebase" --stream-json
-
-# Save output to file
-gemini-exec "generate a README" --output ./README.md
-
-# Sandbox mode with auto-approval
-gemini-exec "fix the failing tests" --yolo --sandbox
-
-# Plan mode for careful execution
-gemini-exec "refactor the auth module" --plan
-
-# Specify working directory
-gemini-exec "analyze the codebase" --working-dir /path/to/project
-```
-
-## Integration
-
-Works with the orchestrator pattern:
-- Main conversation delegates Gemini execution via this skill
-- Results are returned to the main conversation for further processing
-- Can be chained with other skills (e.g., dev-review after Gemini generates code)
-
-## Availability Check
-
-gemini-exec requires the Gemini CLI binary to be installed and authenticated. The skill is only usable when:
-
-1. `gemini` binary is found in PATH (`which gemini` succeeds)
-2. Authentication is valid (GOOGLE_API_KEY, GEMINI_API_KEY set, or gcloud auth active)
-
-If either check fails, this skill cannot be used. Fall back to Claude agents for the task.
-
-> **Note**: This skill is invoked via `/gemini-exec` command, delegated by the orchestrator, or suggested by routing skills when gemini is available. The intent-detection system can trigger it for research and code generation hybrid workflows.
-
-## Agent Teams Integration
-
-When used within Agent Teams (requires explicit invocation):
-
-1. **As delegated task**: orchestrator explicitly delegates gemini-exec for code generation
-2. **Hybrid workflow**: Claude team member analyzes → orchestrator invokes gemini-exec → Claude reviews
-3. **Iteration**: Team messaging enables review-fix cycles between Claude and Gemini outputs
-
-```
-Orchestrator delegates generation task
-  → /gemini-exec invoked explicitly
-  → Output returned to orchestrator
-  → Reviewer validates quality
-  → Iterate if needed
-```
-
-## Research Workflow
-
-When the orchestrator or intent-detection detects a research request:
-
-1. **Check Gemini availability**: Verify `gemini` binary and auth
-2. **If available**: Execute prompt for research
-3. **If unavailable**: Fall back to Claude's WebFetch/WebSearch
-
-### Research Command Pattern
-```
-/gemini-exec "Research and analyze: {topic}. Provide structured findings with sources." --json
-```
-
-## Code Generation Workflow
-
-When routing skills detect a code generation task and gemini is available:
-
-1. **Check availability**: Verify gemini CLI via `/tmp/.claude-env-status-*`
-2. **If available + new file creation**: Suggest hybrid workflow
-3. **Hybrid pattern**:
-   - gemini-exec generates initial code (fast, broad generation)
-   - Claude expert reviews for quality, patterns, best practices
-   - Iterate if needed
-
-### Suitable Tasks
-- New file scaffolding
-- Boilerplate generation
-- Test stub creation
-- Documentation generation
-
-### Unsuitable Tasks
-- Modifying existing code (Claude expert better at understanding context)
-- Architecture decisions (requires reasoning, not generation)
-- Bug fixes (requires deep code understanding)
-
-### Code Generation Command Pattern
-```
-/gemini-exec "Generate {description} following {framework} best practices" --yolo
-```