oh-my-customcodex 0.1.0

package/templates/.claude/skills/claude-code-bible/scripts/fetch-docs.js

@@ -0,0 +1,244 @@
+#!/usr/bin/env node
+
+/**
+ * fetch-docs.js
+ *
+ * Fetches Claude Code official documentation from code.claude.com
+ * and saves it locally for reference.
+ *
+ * Usage:
+ *   node fetch-docs.js [--force] [--output <dir>]
+ *
+ * Options:
+ *   --force          Skip 24-hour cache check
+ *   --output <dir>   Output directory (default: ~/.claude/references/claude-code/)
+ */
+
+const https = require('https');
+const fs = require('fs');
+const path = require('path');
+const { homedir } = require('os');
+
+// Configuration
+const LLMS_TXT_URL = 'https://code.claude.com/docs/llms.txt';
+const DEFAULT_OUTPUT_DIR = path.join(homedir(), '.claude', 'references', 'claude-code');
+const FETCH_DELAY_MS = 200;
+const CACHE_HOURS = 24;
+
+// Parse CLI arguments
+function parseArgs() {
+  const args = {
+    force: false,
+    outputDir: DEFAULT_OUTPUT_DIR,
+  };
+
+  for (let i = 2; i < process.argv.length; i++) {
+    const arg = process.argv[i];
+    if (arg === '--force') {
+      args.force = true;
+    } else if (arg === '--output' && i + 1 < process.argv.length) {
+      args.outputDir = process.argv[++i];
+    }
+  }
+
+  return args;
+}
+
+// Check if cache is fresh
+function isCacheFresh(outputDir) {
+  const lastUpdatedPath = path.join(outputDir, 'last-updated.txt');
+
+  if (!fs.existsSync(lastUpdatedPath)) {
+    return false;
+  }
+
+  try {
+    const content = fs.readFileSync(lastUpdatedPath, 'utf-8').trim();
+    const lastUpdated = new Date(content);
+    const now = new Date();
+    const hoursSince = (now - lastUpdated) / (1000 * 60 * 60);
+
+    return hoursSince < CACHE_HOURS;
+  } catch (error) {
+    return false;
+  }
+}
+
+// Fetch URL with redirect support
+function fetchUrl(url) {
+  return new Promise((resolve, reject) => {
+    https.get(url, (res) => {
+      // Handle redirects
+      if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+        return fetchUrl(res.headers.location).then(resolve).catch(reject);
+      }
+
+      if (res.statusCode !== 200) {
+        return reject(new Error(`HTTP ${res.statusCode}: ${url}`));
+      }
+
+      let data = '';
+      res.on('data', (chunk) => data += chunk);
+      res.on('end', () => resolve(data));
+    }).on('error', reject);
+  });
+}
+
+// Extract documentation URLs from llms.txt
+function extractDocUrls(llmsTxtContent) {
+  const urls = [];
+
+  // Match URLs in markdown links: [title](url) and bare URLs
+  const markdownLinkRegex = /\(https?:\/\/code\.claude\.com\/docs\/[^)]+\)/g;
+  const bareLinkRegex = /^https?:\/\/code\.claude\.com\/docs\/\S+/gm;
+
+  let match;
+  while ((match = markdownLinkRegex.exec(llmsTxtContent)) !== null) {
+    // Remove surrounding parentheses
+    urls.push(match[0].slice(1, -1));
+  }
+  while ((match = bareLinkRegex.exec(llmsTxtContent)) !== null) {
+    urls.push(match[0]);
+  }
+
+  return [...new Set(urls)]; // Remove duplicates
+}
+
+// Convert URL to filename
+function urlToFilename(url) {
+  const urlObj = new URL(url);
+  let filename = urlObj.pathname.replace(/^\/docs\//, '').replace(/\/$/, '');
+
+  if (!filename) {
+    filename = 'index';
+  }
+
+  // Remove language prefix (e.g., "en/") to keep filenames clean
+  filename = filename.replace(/^en\//, '');
+
+  // Replace remaining slashes with dashes for nested paths
+  filename = filename.replace(/\//g, '-');
+
+  if (!filename.endsWith('.md')) {
+    filename += '.md';
+  }
+
+  return filename;
+}
+
+// Sleep utility
+function sleep(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+// Ensure directory exists
+function ensureDir(dirPath) {
+  if (!fs.existsSync(dirPath)) {
+    fs.mkdirSync(dirPath, { recursive: true });
+  }
+}
+
+// Main execution
+async function main() {
+  const args = parseArgs();
+  const { force, outputDir } = args;
+
+  console.log('Claude Code Documentation Fetcher');
+  console.log('==================================\n');
+
+  // Check cache freshness
+  if (!force && isCacheFresh(outputDir)) {
+    console.log('✓ Cache is fresh (less than 24 hours old)');
+    console.log('  Use --force to bypass cache check\n');
+    console.log(`Output directory: ${outputDir}`);
+    return;
+  }
+
+  // Ensure output directory exists
+  ensureDir(outputDir);
+
+  const stats = {
+    total: 0,
+    success: 0,
+    failed: 0,
+    failures: [],
+  };
+
+  try {
+    // Step 1: Fetch llms.txt
+    console.log('Fetching llms.txt...');
+    const llmsTxtContent = await fetchUrl(LLMS_TXT_URL);
+    console.log('✓ llms.txt fetched\n');
+
+    // Save llms.txt itself
+    const llmsTxtPath = path.join(outputDir, 'llms.txt');
+    fs.writeFileSync(llmsTxtPath, llmsTxtContent, 'utf-8');
+
+    // Step 2: Extract documentation URLs
+    const docUrls = extractDocUrls(llmsTxtContent);
+
+    if (docUrls.length === 0) {
+      console.log('⚠ No documentation URLs found in llms.txt');
+      return;
+    }
+
+    console.log(`Found ${docUrls.length} documentation URL(s)\n`);
+    stats.total = docUrls.length;
+
+    // Step 3: Fetch each documentation page
+    for (let i = 0; i < docUrls.length; i++) {
+      const url = docUrls[i];
+      const filename = urlToFilename(url);
+      const filepath = path.join(outputDir, filename);
+
+      try {
+        console.log(`[${i + 1}/${docUrls.length}] Fetching ${url}...`);
+        const content = await fetchUrl(url);
+        fs.writeFileSync(filepath, content, 'utf-8');
+        console.log(`  ✓ Saved to ${filename}`);
+        stats.success++;
+      } catch (error) {
+        console.log(`  ✗ Failed: ${error.message}`);
+        stats.failed++;
+        stats.failures.push({ url, error: error.message });
+      }
+
+      // Delay between requests
+      if (i < docUrls.length - 1) {
+        await sleep(FETCH_DELAY_MS);
+      }
+    }
+
+    // Step 4: Write last-updated timestamp
+    const timestamp = new Date().toISOString();
+    const lastUpdatedPath = path.join(outputDir, 'last-updated.txt');
+    fs.writeFileSync(lastUpdatedPath, timestamp, 'utf-8');
+
+    // Summary
+    console.log('\n==================================');
+    console.log('Summary:');
+    console.log(`  Total URLs:      ${stats.total}`);
+    console.log(`  Downloaded:      ${stats.success}`);
+    console.log(`  Failed:          ${stats.failed}`);
+    console.log(`  Save location:   ${outputDir}`);
+    console.log(`  Last updated:    ${timestamp}`);
+
+    if (stats.failures.length > 0) {
+      console.log('\nFailures:');
+      stats.failures.forEach(({ url, error }) => {
+        console.log(`  - ${url}`);
+        console.log(`    ${error}`);
+      });
+    }
+
+  } catch (error) {
+    console.error('\n✗ Fatal error:', error.message);
+    process.exit(1);
+  }
+}
+
+// Run
+main().catch(error => {
+  console.error('Unexpected error:', error);
+  process.exit(1);
+});

package/templates/.claude/skills/claude-native/SKILL.md

@@ -0,0 +1,215 @@
+---
+name: claude-native
+description: Monitor Claude Code releases and auto-generate GitHub issues for each new version
+scope: core
+user-invocable: true
+argument-hint: "[--backfill] [--dry-run]"
+version: 1.0.0
+---
+
+# Claude Native Skill
+
+Monitor Claude Code (the CLI tool) release history and auto-generate GitHub issues for each new version that has not yet been tracked. Replaces the deprecated customclaw Airflow-based monitoring (deprecated 2026-03-18).
+
+## Options
+
+```
+--backfill    Process ALL versions >= v2.1.86 (default behavior when flag is present)
+              Without flag: only check the latest 5 releases
+--dry-run     Show what issues would be created without actually creating them
+```
+
+## Workflow
+
+### Phase 1: Fetch CC Releases
+
+Fetch all Claude Code releases from the GitHub API:
+
+```bash
+gh api repos/anthropics/claude-code/releases \
+  --paginate \
+  --jq '.[] | {tag_name: .tag_name, published_at: .published_at, html_url: .html_url, body: .body}'
+```
+
+- Without `--backfill`: fetch only the latest 5 releases (`--limit 5` or first 5 results)
+- With `--backfill`: fetch all releases (use `--paginate`)
+- Filter: only process versions >= v2.1.86 (monitoring stopped after v2.1.85 / issue #683)
+
+### Phase 2: Check Existing Issues
+
+Search for existing tracking issues to avoid duplicates:
+
+```bash
+gh issue list \
+  --state all \
+  --search "[Claude Code v" \
+  --json number,title \
+  --limit 100
+```
+
+Build a set of already-tracked versions by extracting version strings from issue titles matching the pattern `[Claude Code v{version}]`.
+
+### Phase 3: Dedup
+
+For each fetched release version:
+- Parse the version string from `tag_name` (e.g., `v2.1.86`)
+- If a matching issue title already exists → skip (already tracked)
+- If no matching issue → add to "needs issue" list
+
+### Phase 4: Create Issues (or Dry-Run Report)
+
+#### Dry-Run Mode (`--dry-run`)
+
+Print a report of what would be created:
+
+```
+[Dry Run] Would create issues for:
+  - v2.1.86 (published: 2026-01-15)
+  - v2.1.87 (published: 2026-01-22)
+  ...
+No issues were created.
+```
+
+#### Live Mode
+
+For each version in the "needs issue" list, create a GitHub issue:
+
+```bash
+gh issue create \
+  --title "[Claude Code v{version}] New release detected" \
+  --label "automated,claude-code-release" \
+  --body "{body}"
+```
+
+Issue body format (matching the pattern established by issue #683):
+
+```markdown
+# Claude Code v{version}
+
+**Release:** v{version}
+**Published:** {published_at}
+**Link:** {html_url}
+
+## Release Summary
+
+{release_notes_body — truncated to first 2000 chars if too long}
+
+---
+
+## Action Items
+
+- [ ] Review release notes for impact on oh-my-customcodex
+- [ ] Update agent definitions if new Claude Code features affect agents
+- [ ] Test compatibility with current oh-my-customcodex version
+- [ ] Update AGENTS.md if new capabilities are relevant
+
+---
+
+_This issue was created by the `/omcodex:claude-native` skill._
+```
+
+**Notes:**
+- If `body` from the release is empty, use `_No release notes provided._`
+- Truncate release body at 2000 characters and append `... (truncated)` if needed
+- The `automated` and `claude-code-release` labels must exist in the repository; create them if missing:
+  ```bash
+  gh label create "automated" --color "#0075ca" --description "Automated issue" 2>/dev/null || true
+  gh label create "claude-code-release" --color "#e4e669" --description "Claude Code release tracking" 2>/dev/null || true
+  ```
+
+### Phase 5: Report Results
+
+After processing all versions:
+
+```
+[claude-native] Scan complete
+
+Versions checked: {N}
+New issues created: {M}
+
+Created:
+  - #1234 [Claude Code v2.1.86] New release detected
+  - #1235 [Claude Code v2.1.87] New release detected
+
+Already tracked (skipped):
+  - v2.1.85 → #683
+```
+
+If no new releases found:
+
+```
+[claude-native] No new releases found. All versions >= v2.1.86 are already tracked.
+```
+
+## Version Filtering Logic
+
+```
+MIN_VERSION = "2.1.86"
+
+For each release:
+  version = strip_v_prefix(tag_name)   # "v2.1.86" → "2.1.86"
+  parts = split(version, ".")           # ["2", "1", "86"]
+  if compare_semver(version, MIN_VERSION) >= 0:
+    include
+  else:
+    skip
+```
+
+Semver comparison: major → minor → patch (all numeric). Pre-release suffixes (e.g., `-beta`) are included and compared lexicographically after numeric parts.
+
+## Error Handling
+
+| Error | Action |
+|-------|--------|
+| `gh` not authenticated | Report: "Error: gh CLI not authenticated. Run `gh auth login` first." |
+| Rate limit hit | Report current status, list remaining versions |
+| Label creation fails | Warn and continue (issue created without label) |
+| Release body parse error | Use empty body fallback, continue |
+
+## Integration Options
+
+### Manual
+
+```
+/omcodex:claude-native
+/omcodex:claude-native --backfill
+/omcodex:claude-native --dry-run
+```
+
+### Automatic (SessionStart Hook)
+
+Can be integrated into the SessionStart hook to check for new releases at session start:
+
+```json
+{
+  "SessionStart": [
+    {
+      "command": "bash .codex/hooks/scripts/claude-native-check.sh"
+    }
+  ]
+}
+```
+
+A lightweight wrapper script can run a `--dry-run` check and notify if new releases exist.
+
+### Scheduled (CronCreate)
+
+Can be set up as a scheduled remote agent using `/schedule`:
+
+```
+/schedule "daily at 9am: /omcodex:claude-native"
+```
+
+Or via CronCreate MCP tool for programmatic scheduling.
+
+## Prerequisites
+
+- `gh` CLI installed and authenticated (`gh auth status`)
+- Repository: `baekenough/oh-my-customcodex` (default, detected from git remote)
+- Labels `automated` and `claude-code-release` (auto-created if missing)
+
+## Background
+
+- Last manually tracked release: v2.1.85 (issue #683)
+- Monitoring gap: v2.1.86 onwards (customclaw deprecated 2026-03-18)
+- This skill fills the monitoring gap and provides ongoing tracking

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

@@ -0,0 +1,206 @@
+---
+name: codex-exec
+description: Execute OpenAI Codex CLI prompts and return results
+scope: core
+argument-hint: "<prompt> [--json] [--output <path>] [--model <name>] [--timeout <ms>] [--effort <level>]"
+user-invocable: true
+---
+
+# Codex Exec Skill
+
+Execute OpenAI Codex CLI prompts in non-interactive mode and return structured results. Enables Claude + Codex hybrid workflows.
+
+## Options
+
+```
+<prompt>          Required. The prompt to send to Codex CLI
+--json            Return structured JSON Lines output
+--output <path>   Save final message to file
+--model <name>    Model override (default: Codex CLI default model)
+--timeout <ms>    Execution timeout (default: 120000, max: 600000)
+--full-auto       Enable auto-approval mode (codex -a full-auto)
+--working-dir     Working directory for Codex execution
+--effort <level>  Set reasoning effort level (minimal, low, medium, high, xhigh)
+                  Maps to Codex CLI's model_reasoning_effort config
+                  Default: uses Codex CLI's configured default
+                  Recommended: xhigh for research/analysis tasks
+```
+
+## Workflow
+
+```
+1. Pre-checks
+   - Verify `codex` binary is installed (which codex || npx codex --version)
+   - Verify authentication (OPENAI_API_KEY or logged in)
+2. Build command
+   - Base: codex exec --ephemeral "<prompt>"
+   - Apply options: --json, --model, --full-auto, -C <dir>
+   - Set --working-dir if specified
+3. Execute
+   - Run via Bash tool with timeout (default 2min, max 10min)
+   - Or use helper script: node .codex/skills/codex-exec/scripts/codex-wrapper.cjs
+4. Parse output
+   - Text mode: return raw stdout
+   - JSON mode: parse JSON Lines, extract final assistant message
+5. Report results
+   - Format output with execution metadata
+```
+
+## Safety Defaults
+
+- `--ephemeral`: No session persistence (conversations not saved)
+- Default mode: Normal approval (Codex prompts for confirmation)
+- Override with `--full-auto` only when explicitly requested
+
+## Output Format
+
+### Success (Text Mode)
+```
+[Codex Exec] Completed
+
+Model: (default)
+Duration: 23.4s
+Working Dir: /path/to/project
+
+--- Output ---
+{codex response text}
+```
+
+### Success (JSON Mode)
+```
+[Codex Exec] Completed (JSON)
+
+Model: (default)
+Duration: 23.4s
+Events: 12
+
+--- Final Message ---
+{extracted final assistant message}
+```
+
+### Failure
+```
+[Codex Exec] Failed
+
+Error: {error_message}
+Exit Code: {code}
+Suggested Fix: {suggestion}
+```
+
+## Helper Script
+
+For complex executions, use the wrapper script:
+```bash
+node .codex/skills/codex-exec/scripts/codex-wrapper.cjs --prompt "your prompt" [options]
+```
+
+The wrapper provides:
+- Environment validation (binary + auth checks)
+- Safe command construction
+- JSON Lines parsing with event extraction
+- Structured JSON output
+- Timeout handling with graceful termination
+
+## Examples
+
+```bash
+# Simple text prompt
+codex-exec "explain what this project does"
+
+# JSON output with model override
+codex-exec "list all TODO items" --json
+
+# Save output to file
+codex-exec "generate a README" --output ./README.md
+
+# Full auto mode with custom timeout
+codex-exec "fix the failing tests" --full-auto --timeout 300000
+
+# Specify working directory
+codex-exec "analyze the codebase" --working-dir /path/to/project
+```
+
+## Integration
+
+Works with the orchestrator pattern:
+- Main conversation delegates Codex 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 Codex generates code)
+
+## Availability Check
+
+codex-exec requires the Codex CLI binary to be installed and authenticated. The skill is only usable when:
+
+1. `codex` binary is found in PATH (`which codex` succeeds)
+2. Authentication is valid (OPENAI_API_KEY set or `codex` logged in)
+
+If either check fails, this skill cannot be used. Fall back to Claude agents for the task.
+
+> **Note**: This skill is invoked via `/codex-exec` command, delegated by the orchestrator, or suggested by routing skills when codex is available. The intent-detection system can trigger it for research (xhigh) and code generation (hybrid) workflows.
+
+## Agent Teams Integration
+
+When used within Agent Teams (requires explicit invocation):
+
+1. **As delegated task**: orchestrator explicitly delegates codex-exec for code generation
+2. **Hybrid workflow**: Claude team member analyzes → orchestrator invokes codex-exec → Claude reviews
+3. **Iteration**: Team messaging enables review-fix cycles between Claude and Codex outputs
+
+```
+Orchestrator delegates generation task
+  → /codex-exec invoked explicitly
+  → Output returned to orchestrator
+  → Reviewer validates quality
+  → Iterate if needed
+```
+
+## Research Workflow
+
+When the orchestrator or intent-detection detects a research/information gathering request (routing_rule in agent-triggers.yaml):
+
+1. **Check Codex availability**: Verify `codex` binary and `OPENAI_API_KEY`
+2. **If available**: Execute with xhigh reasoning effort for thorough research
+3. **If unavailable**: Fall back to Claude's WebFetch/WebSearch
+
+### Research Command Pattern
+
+```
+/codex-exec "Research and analyze: {topic}. Provide structured findings with sources." --effort xhigh --full-auto --json
+```
+
+### Effort Level Guide
+
+| Level | Use Case | Speed | Depth |
+|-------|----------|-------|-------|
+| minimal | Quick lookups | Fastest | Surface |
+| low | Simple queries | Fast | Basic |
+| medium | General tasks | Balanced | Standard |
+| high | Complex analysis | Slower | Deep |
+| xhigh | Research & investigation | Slowest | Maximum |
+
+## Code Generation Workflow
+
+When routing skills detect a code generation task and codex is available:
+
+1. **Check availability**: Verify codex CLI via `/tmp/.codex-env-status-*`
+2. **If available + new file creation**: Suggest hybrid workflow
+3. **Hybrid pattern**:
+   - codex-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
+```
+/codex-exec "Generate {description} following {framework} best practices" --effort high --full-auto
+```