oh-my-customcode 0.12.1 → 0.12.2

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

@@ -1,272 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * fetch-docs.js
- *
- * Fetches Codex documentation from official OpenAI sources and saves
- * local snapshots for verification workflows.
- *
- * Usage:
- *   node fetch-docs.js [--force] [--output <dir>]
- *
- * Options:
- *   --force          Skip 24-hour cache check
- *   --output <dir>   Output directory (default: ~/.codex/references/codex-docs/)
- */
-
-import fs from 'node:fs';
-import https from 'node:https';
-import path from 'node:path';
-import { homedir } from 'node:os';
-
-const DEFAULT_OUTPUT_DIR = path.join(homedir(), '.codex', 'references', 'codex-docs');
-const LAST_UPDATED_FILE = 'last-updated.txt';
-const SOURCE_POLICY_FILE = 'source-policy.json';
-const FETCH_REPORT_FILE = 'fetch-report.json';
-const CACHE_HOURS = 24;
-const FETCH_DELAY_MS = 200;
-const MAX_REDIRECTS = 5;
-const REQUEST_TIMEOUT_MS = 15000;
-
-// Primary + fallback URLs are explicit to keep behavior predictable in CI.
-const SOURCE_POLICY = [
-  {
-    id: 'codex-overview',
-    description: 'Codex landing and product overview',
-    urls: ['https://developers.openai.com/codex/', 'https://developers.openai.com/codex'],
-  },
-  {
-    id: 'codex-cli',
-    description: 'Codex CLI guide',
-    urls: ['https://developers.openai.com/codex/cli'],
-  },
-  {
-    id: 'codex-ide',
-    description: 'Codex IDE guide',
-    urls: ['https://developers.openai.com/codex/ide'],
-  },
-  {
-    id: 'codex-cloud',
-    description: 'Codex cloud guide',
-    urls: ['https://developers.openai.com/codex/cloud'],
-  },
-  {
-    id: 'codex-cloud-internet',
-    description: 'Codex cloud internet access policy',
-    urls: [
-      'https://developers.openai.com/codex/cloud/internet-access',
-      'https://developers.openai.com/codex/cloud/agent-internet',
-    ],
-  },
-  {
-    id: 'codex-changelog',
-    description: 'Codex changelog',
-    urls: ['https://developers.openai.com/codex/changelog'],
-  },
-];
-
-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;
-      continue;
-    }
-    if (arg === '--output' && i + 1 < process.argv.length) {
-      args.outputDir = process.argv[++i];
-    }
-  }
-
-  return args;
-}
-
-function ensureDir(dirPath) {
-  if (!fs.existsSync(dirPath)) {
-    fs.mkdirSync(dirPath, { recursive: true });
-  }
-}
-
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-function isCacheFresh(outputDir) {
-  const lastUpdatedPath = path.join(outputDir, LAST_UPDATED_FILE);
-  if (!fs.existsSync(lastUpdatedPath)) {
-    return false;
-  }
-
-  try {
-    const content = fs.readFileSync(lastUpdatedPath, 'utf-8').trim();
-    const lastUpdated = new Date(content);
-    if (Number.isNaN(lastUpdated.getTime())) {
-      return false;
-    }
-
-    const hoursSince = (Date.now() - lastUpdated.getTime()) / (1000 * 60 * 60);
-    return hoursSince < CACHE_HOURS;
-  } catch {
-    return false;
-  }
-}
-
-function fetchUrl(url, redirectCount = 0) {
-  return new Promise((resolve, reject) => {
-    const request = https.get(url, (res) => {
-      const statusCode = res.statusCode || 0;
-
-      if (statusCode >= 300 && statusCode < 400 && res.headers.location) {
-        if (redirectCount >= MAX_REDIRECTS) {
-          reject(new Error(`Too many redirects: ${url}`));
-          return;
-        }
-
-        const redirectUrl = new URL(res.headers.location, url).toString();
-        fetchUrl(redirectUrl, redirectCount + 1).then(resolve).catch(reject);
-        return;
-      }
-
-      if (statusCode !== 200) {
-        reject(new Error(`HTTP ${statusCode}: ${url}`));
-        return;
-      }
-
-      let data = '';
-      res.setEncoding('utf8');
-      res.on('data', (chunk) => {
-        data += chunk;
-      });
-      res.on('end', () => {
-        resolve(data);
-      });
-    });
-
-    request.setTimeout(REQUEST_TIMEOUT_MS, () => {
-      request.destroy(new Error(`Request timeout after ${REQUEST_TIMEOUT_MS}ms: ${url}`));
-    });
-
-    request.on('error', reject);
-  });
-}
-
-async function fetchWithFallback(source) {
-  const errors = [];
-
-  for (const candidateUrl of source.urls) {
-    try {
-      const content = await fetchUrl(candidateUrl);
-      return { success: true, content, url: candidateUrl, errors };
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      errors.push({ url: candidateUrl, error: message });
-    }
-  }
-
-  return { success: false, content: null, url: null, errors };
-}
-
-function writeJsonFile(filePath, data) {
-  fs.writeFileSync(filePath, `${JSON.stringify(data, null, 2)}\n`, 'utf-8');
-}
-
-async function main() {
-  const { force, outputDir } = parseArgs();
-
-  console.log('Codex Documentation Fetcher');
-  console.log('==================================\n');
-
-  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;
-  }
-
-  ensureDir(outputDir);
-
-  const fetchedAt = new Date().toISOString();
-  const report = {
-    fetchedAt,
-    sourcePolicyVersion: 1,
-    totalSources: SOURCE_POLICY.length,
-    successCount: 0,
-    failureCount: 0,
-    sources: [],
-  };
-
-  console.log(`Source policy: ${SOURCE_POLICY.length} canonical source(s)\n`);
-
-  for (let i = 0; i < SOURCE_POLICY.length; i++) {
-    const source = SOURCE_POLICY[i];
-    console.log(`[${i + 1}/${SOURCE_POLICY.length}] ${source.id}`);
-
-    const result = await fetchWithFallback(source);
-
-    if (result.success) {
-      const fileName = `${source.id}.html`;
-      fs.writeFileSync(path.join(outputDir, fileName), result.content, 'utf-8');
-      report.successCount += 1;
-      report.sources.push({
-        id: source.id,
-        description: source.description,
-        status: 'ok',
-        selectedUrl: result.url,
-        outputFile: fileName,
-        attemptedUrls: source.urls,
-      });
-      console.log(`  ✓ fetched ${result.url}`);
-      console.log(`  ✓ saved ${fileName}`);
-    } else {
-      report.failureCount += 1;
-      report.sources.push({
-        id: source.id,
-        description: source.description,
-        status: 'failed',
-        selectedUrl: null,
-        outputFile: null,
-        attemptedUrls: source.urls,
-        errors: result.errors,
-      });
-      console.log('  ✗ failed all candidate URLs');
-      for (const item of result.errors) {
-        console.log(`    - ${item.url}: ${item.error}`);
-      }
-    }
-
-    if (i < SOURCE_POLICY.length - 1) {
-      await sleep(FETCH_DELAY_MS);
-    }
-  }
-
-  writeJsonFile(path.join(outputDir, SOURCE_POLICY_FILE), {
-    generatedAt: fetchedAt,
-    policy: SOURCE_POLICY,
-  });
-  writeJsonFile(path.join(outputDir, FETCH_REPORT_FILE), report);
-
-  if (report.successCount === 0) {
-    console.error('\n✗ Fatal error: unable to fetch any Codex documentation sources.');
-    process.exit(1);
-  }
-
-  fs.writeFileSync(path.join(outputDir, LAST_UPDATED_FILE), `${fetchedAt}\n`, 'utf-8');
-
-  console.log('\n==================================');
-  console.log('Summary:');
-  console.log(`  Total sources:   ${report.totalSources}`);
-  console.log(`  Downloaded:      ${report.successCount}`);
-  console.log(`  Failed:          ${report.failureCount}`);
-  console.log(`  Save location:   ${outputDir}`);
-  console.log(`  Last updated:    ${fetchedAt}`);
-}
-
-main().catch((error) => {
-  const message = error instanceof Error ? error.message : String(error);
-  console.error('\n✗ Unexpected error:', message);
-  process.exit(1);
-});

package/templates/.codex/skills/create-agent/SKILL.md

@@ -1,91 +0,0 @@
----
-name: create-agent
-description: Create a new agent with complete structure
-argument-hint: "<name> --type <type>"
-disable-model-invocation: true
----
-
-# Create Agent Skill
-
-Create a new agent with complete directory structure, files, and registration.
-
-## Parameters
-
-| Name | Type | Required | Description |
-|------|------|----------|-------------|
-| name | string | yes | Agent name (kebab-case) |
-
-## Options
-
-```
---type, -t       Agent type (required)
-                 Values: sw-engineer, sw-engineer/backend, infra-engineer, manager
---source, -s     External source URL (for external agents)
---desc, -d       Description
---skills         Comma-separated skills to include
-```
-
-## Workflow
-
-```
-1. Validate input
-   ├── Name is unique
-   ├── Name is kebab-case
-   └── Type is valid
-
-2. Create agent file
-   └── .codex/agents/{name}.md
-
-4. Validate
-   └── Run mgr-supplier:audit
-```
-
-## Templates
-
-### Agent File Template
-
-```markdown
-# {Name} Agent
-
-> **Type**: {Type}
-> **Source**: Internal
-
-## Purpose
-
-{Description}
-
-## Capabilities
-
-1.
-2.
-
-## Skills
-
-| Skill | Purpose |
-|-------|---------|
-
-## Guides
-
-| Guide | Purpose |
-|-------|---------|
-```
-
-## Output Format
-
-```
-[mgr-creator:agent lang-golang-expert --type sw-engineer]
-
-Creating agent: lang-golang-expert
-
-[1/4] Validating...
-  ✓ Name available
-  ✓ Type valid: sw-engineer
-
-[2/4] Creating agent file...
-  ✓ .codex/agents/lang-golang-expert.md
-
-[3/4] Validating...
-  ✓ mgr-supplier:audit passed
-
-Agent created successfully: .codex/agents/lang-golang-expert.md
-```

package/templates/.codex/skills/dbt-best-practices/SKILL.md

@@ -1,54 +0,0 @@
----
-name: dbt-best-practices
-description: dbt best practices for SQL modeling, testing, and analytics engineering workflows
-user-invocable: false
----
-
-# dbt Best Practices
-
-## Project Structure
-
-### Layer Organization (CRITICAL)
-- **Staging**: 1:1 with source tables (`stg_{source}__{entity}`)
-- **Intermediate**: Business logic composition (`int_{entity}_{verb}`)
-- **Marts**: Final consumption models (`fct_{entity}`, `dim_{entity}`)
-
-### Materialization Strategy
-- Staging: `view` (lightweight, always fresh)
-- Intermediate: `ephemeral` or `view`
-- Marts: `table` or `incremental`
-
-## Modeling Patterns
-
-### Naming Conventions
-- Staging: `stg_source__table`
-- Intermediate: `int_entity_verb`
-- Facts: `fct_entity`
-- Dimensions: `dim_entity`
-
-### Incremental Models
-- Use `is_incremental()` macro
-- Define `unique_key` for merge strategy
-- Choose strategy: append, merge, delete+insert
-
-## Testing
-
-### Schema Tests
-- `unique`, `not_null` for primary keys
-- `relationships` for foreign keys
-- `accepted_values` for enums
-- Custom data tests
-
-### Source Freshness
-- Configure `loaded_at_field`
-- Set freshness thresholds
-
-## Documentation
-
-- Add descriptions to models
-- Document column definitions
-- Use `doc` blocks for reusable text
-- Generate and host dbt docs
-
-## References
-- [dbt Best Practices](https://docs.getdbt.com/guides/best-practices)

package/templates/.codex/skills/de-lead-routing/SKILL.md

@@ -1,243 +0,0 @@
----
-name: de-lead-routing
-description: Routes data engineering tasks to the correct DE expert agent. Use when user requests data pipeline design, DAG authoring, SQL modeling, stream processing, or warehouse optimization.
-user-invocable: false
----
-
-# DE Lead Routing Skill
-
-## Purpose
-
-Routes data engineering tasks to appropriate DE expert agents. This skill contains the coordination logic for orchestrating data engineering agents across orchestration, modeling, processing, streaming, and warehouse specializations.
-
-## Engineers Under Management
-
-| Type | Agents | Purpose |
-|------|--------|---------|
-| de/orchestration | de-airflow-expert | DAG authoring, scheduling, testing |
-| de/modeling | de-dbt-expert | SQL modeling, testing, documentation |
-| de/processing | de-spark-expert | Distributed data processing |
-| de/streaming | de-kafka-expert | Event streaming, topic design |
-| de/warehouse | de-snowflake-expert | Cloud DWH, query optimization |
-| de/architecture | de-pipeline-expert | Pipeline design, cross-tool patterns |
-
-## Tool/Framework Detection
-
-### Keyword Mapping
-
-| Keyword | Agent |
-|---------|-------|
-| "airflow", "dag", "scheduling", "orchestration" | de-airflow-expert |
-| "dbt", "modeling", "sql model", "analytics engineering" | de-dbt-expert |
-| "spark", "pyspark", "distributed processing", "distributed" | de-spark-expert |
-| "kafka", "streaming", "event", "consumer", "producer" | de-kafka-expert |
-| "snowflake", "warehouse", "clustering key" | de-snowflake-expert |
-| "pipeline", "ETL", "ELT", "data quality", "lineage" | de-pipeline-expert |
-| "iceberg", "table format" | de-snowflake-expert or de-pipeline-expert |
-
-### File Pattern Mapping
-
-| Pattern | Agent |
-|---------|-------|
-| `dags/*.py`, `airflow.cfg`, `airflow_settings.yaml` | de-airflow-expert |
-| `models/**/*.sql`, `dbt_project.yml`, `schema.yml` | de-dbt-expert |
-| Spark job files, `spark-submit` configs | de-spark-expert |
-| Kafka configs, `*.properties` (Kafka), `streams/*.java` | de-kafka-expert |
-| Snowflake SQL, warehouse DDL | de-snowflake-expert |
-
-## Command Routing
-
-```
-DE Request → Detection → Expert Agent
-
-Airflow DAG → de-airflow-expert
-dbt model   → de-dbt-expert
-Spark job   → de-spark-expert
-Kafka topic → de-kafka-expert
-Snowflake   → de-snowflake-expert
-Pipeline    → de-pipeline-expert
-Multi-tool  → Multiple experts (parallel)
-```
-
-## Routing Rules
-
-### 1. Pipeline Development Workflow
-
-```
-1. Receive pipeline task request
-2. Identify tools and components:
-   - DAG orchestration → de-airflow-expert
-   - SQL transformations → de-dbt-expert
-   - Distributed processing → de-spark-expert
-   - Event streaming → de-kafka-expert
-   - Warehouse operations → de-snowflake-expert
-   - Architecture decisions → de-pipeline-expert
-3. Select appropriate experts
-4. Distribute tasks (parallel if 2+ tools)
-5. Aggregate results
-6. Present unified report
-```
-
-Example:
-```
-User: "Design a pipeline that runs dbt models from Airflow and loads into Snowflake"
-
-Detection:
-  - Airflow DAG → de-airflow-expert
-  - dbt model → de-dbt-expert
-  - Snowflake loading → de-snowflake-expert
-  - Pipeline architecture → de-pipeline-expert
-
-Route (parallel where independent):
-  Task(de-pipeline-expert → overall architecture design)
-  Task(de-airflow-expert → DAG structure)
-  Task(de-dbt-expert → model design)
-  Task(de-snowflake-expert → warehouse setup)
-
-Aggregate:
-  Pipeline architecture defined
-  Airflow DAG: 5 tasks designed
-  dbt: 12 models structured
-  Snowflake: warehouse + schema configured
-```
-
-### 2. Data Quality Workflow
-
-```
-1. Analyze data quality requirements
-2. Route to appropriate experts:
-   - dbt tests → de-dbt-expert
-   - Pipeline validation → de-pipeline-expert
-   - Source freshness → de-airflow-expert
-3. Coordinate cross-tool quality strategy
-```
-
-### 3. Multi-Tool Projects
-
-For projects spanning multiple DE tools:
-
-```
-1. Detect all DE tools in project
-2. Identify primary tool (most files/configs)
-3. Route to appropriate experts:
-   - If task spans multiple tools → parallel experts
-   - If task is tool-specific → single expert
-4. Coordinate cross-tool consistency
-```
-
-## Sub-agent Model Selection
-
-### Model Mapping by Task Type
-
-| Task Type | Recommended Model | Reason |
-|-----------|-------------------|--------|
-| Pipeline architecture | `reasoning` | Deep reasoning required |
-| DAG/model review | `balanced` | Balanced quality judgment |
-| Implementation | `balanced` | Standard code generation |
-| Quick validation | `fast` | Fast response |
-
-### Model Mapping by Agent
-
-| Agent | Default Model | Alternative |
-|-------|---------------|-------------|
-| de-pipeline-expert | `balanced` | `reasoning` for architecture |
-| de-airflow-expert | `balanced` | `fast` for DAG validation |
-| de-dbt-expert | `balanced` | `fast` for test checks |
-| de-spark-expert | `balanced` | `reasoning` for optimization |
-| de-kafka-expert | `balanced` | `reasoning` for topology design |
-| de-snowflake-expert | `balanced` | `reasoning` for warehouse design |
-
-### Task Call Examples
-
-```
-# Complex pipeline architecture
-Task(
-  subagent_type: "general-purpose",
-  prompt: "Design end-to-end pipeline architecture following de-pipeline-expert guidelines",
-  model: "reasoning"
-)
-
-# Standard DAG review
-Task(
-  subagent_type: "general-purpose",
-  prompt: "Review Airflow DAGs in dags/ following de-airflow-expert guidelines",
-  model: "balanced"
-)
-
-# Quick dbt test validation
-Task(
-  subagent_type: "Explore",
-  prompt: "Find all dbt models missing schema tests",
-  model: "fast"
-)
-```
-
-## Parallel Execution
-
-Following R009:
-- Maximum 4 parallel instances
-- Independent tool/module operations
-- Coordinate cross-tool consistency
-
-Example:
-```
-User: "Review all DE configs"
-
-Detection:
-  - dags/ → de-airflow-expert
-  - models/ → de-dbt-expert
-  - kafka/ → de-kafka-expert
-
-Route (parallel):
-  Task(de-airflow-expert role → review dags/, model: "balanced")
-  Task(de-dbt-expert role → review models/, model: "balanced")
-  Task(de-kafka-expert role → review kafka/, model: "balanced")
-```
-
-## Display Format
-
-```
-[Analyzing] Detected: Airflow, dbt, Snowflake
-
-[Delegating] de-airflow-expert:balanced → DAG design
-[Delegating] de-dbt-expert:balanced → Model structure
-[Delegating] de-snowflake-expert:balanced → Warehouse config
-
-[Progress] ███████████░ 2/3 experts completed
-
-[Summary]
-  Airflow: DAG with 5 tasks designed
-  dbt: 12 models across 3 layers
-  Snowflake: Warehouse + schema configured
-
-Pipeline design completed.
-```
-
-## Integration with Other Routing Skills
-
-- **dev-lead-routing**: Hands off to DE lead when data engineering keywords detected
-- **secretary-routing**: DE agents accessible through secretary for management tasks
-- **qa-lead-routing**: Coordinates with QA for data quality testing
-
-## Agent Teams Awareness
-
-Before routing via Task tool, check if Agent Teams is available (`CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1` or TeamCreate/SendMessage tools present).
-
-**Self-check:** Does this task need 3+ agents, shared state, or inter-agent communication? If yes, prefer Agent Teams over Task tool. See R018 for the full decision matrix.
-
-| Scenario | Preferred |
-|----------|-----------|
-| Single-tool DE task | Task Tool |
-| Multi-tool pipeline design (3+ tools) | Agent Teams |
-| Cross-tool data quality analysis | Agent Teams |
-| Quick DAG/model validation | Task Tool |
-
-## Usage
-
-This skill is NOT user-invocable. It should be automatically triggered when the main conversation detects data engineering intent.
-
-Detection criteria:
-- User requests pipeline design or data engineering
-- User mentions DE tool names (Airflow, dbt, Spark, Kafka, Snowflake)
-- User provides DE-related file paths (dags/, models/, etc.)
-- User requests data quality or lineage work