oh-my-customcode 0.7.0 → 0.9.0

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

@@ -0,0 +1,101 @@
+---
+name: react-best-practices
+description: React/Next.js performance optimization with 40+ rules in 8 categories
+user-invocable: false
+---
+
+## When to Use
+
+- Writing React/Next.js components
+- Data fetching implementation
+- Performance review
+- Bundle size optimization
+
+## Categories by Priority
+
+### Critical Priority
+
+#### Waterfall Elimination
+```
+- Avoid sequential data fetching
+- Use parallel data fetching
+- Implement proper loading states
+- Prefetch critical data
+```
+
+#### Bundle Optimization
+```
+- Minimize client-side JavaScript
+- Use dynamic imports
+- Tree-shake unused code
+- Analyze bundle with tools
+```
+
+### High Priority
+
+#### Server-Side Performance
+```
+- Use Server Components by default
+- Minimize 'use client' directives
+- Implement streaming where possible
+- Cache server responses
+```
+
+### Medium-High Priority
+
+#### Client-Side Fetching
+```
+- Use SWR or React Query
+- Implement optimistic updates
+- Handle loading/error states
+- Cache API responses
+```
+
+### Medium Priority
+
+#### Rendering
+```
+- Avoid unnecessary re-renders
+- Use React.memo strategically
+- Implement useMemo/useCallback properly
+- Virtualize long lists
+```
+
+#### Caching
+```
+- Implement proper cache headers
+- Use ISR for dynamic content
+- Cache database queries
+- CDN caching strategies
+```
+
+#### Code Splitting
+```
+- Split by route
+- Lazy load below-fold content
+- Dynamic import heavy libraries
+- Preload critical chunks
+```
+
+### Low-Medium Priority
+
+#### Image Optimization
+```
+- Use next/image
+- Implement proper sizing
+- Use modern formats (WebP, AVIF)
+- Lazy load off-screen images
+```
+
+## Execution Flow
+
+```
+1. Identify optimization area
+2. Check relevant category rules
+3. Apply recommendations
+4. Verify improvements
+```
+
+## Scripts
+
+See `scripts/` directory for automation helpers.

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

@@ -0,0 +1,83 @@
+---
+name: redis-best-practices
+description: Redis best practices for caching, data structures, and in-memory data architecture
+user-invocable: false
+---
+
+# Redis Best Practices
+
+## Caching Patterns
+
+### Cache-Aside (CRITICAL)
+- Read: check cache → miss → read DB → set cache
+- Write: update DB → invalidate cache
+- Best for read-heavy workloads
+
+### Write-Through
+- Write: update cache AND DB simultaneously
+- Ensures consistency
+- Higher write latency
+
+### Write-Behind
+- Write: update cache → async DB update
+- Lowest latency
+- Risk of data loss
+
+## Data Structures
+
+### String
+- Simple key-value: `SET key value`
+- Counters: `INCR`, `DECR`, `INCRBY`
+- Bit operations: `SETBIT`, `BITCOUNT`
+
+### Hash
+- Object storage: `HSET user:1 name "Alice"`
+- Partial updates: `HINCRBY user:1 visits 1`
+- Memory efficient for small hashes
+
+### List
+- Queues: `LPUSH`, `RPOP` (FIFO)
+- Stacks: `LPUSH`, `LPOP` (LIFO)
+- Capped collections: `LTRIM`
+
+### Set
+- Unique collections: `SADD`, `SMEMBERS`
+- Intersections: `SINTER`
+- Random sampling: `SRANDMEMBER`
+
+### Sorted Set
+- Leaderboards: `ZADD`, `ZRANGEBYSCORE`
+- Rate limiting: `ZADD timestamp`
+- Priority queues
+
+### Stream
+- Event log: `XADD`, `XREAD`
+- Consumer groups: `XGROUP`, `XACK`
+- Pub/Sub with persistence
+
+## Performance
+
+### Memory Optimization
+- Set maxmemory policy: `allkeys-lru`, `volatile-lru`
+- Monitor memory: `INFO memory`
+- Use appropriate data structures (Hash vs String)
+
+### Pipelining
+- Batch multiple commands
+- Reduces round-trip latency
+- Use for bulk operations
+
+## High Availability
+
+### Redis Cluster
+- Horizontal scaling
+- Automatic sharding (16384 slots)
+- Multi-master replication
+
+### Redis Sentinel
+- Automatic failover
+- Monitoring and notifications
+- Configuration provider
+
+## References
+- [Redis Best Practices](https://redis.io/docs/manual/patterns/)

package/templates/.codex/skills/result-aggregation/SKILL.md

@@ -0,0 +1,164 @@
+---
+name: result-aggregation
+description: Aggregate parallel agent results into concise output
+user-invocable: false
+---
+
+## Purpose
+
+Aggregate and format results from multiple parallel agent executions into concise, scannable output.
+
+## When to Use
+
+- After parallel agent execution completes
+- When ecomode is active
+- For batch operation summaries
+- When reporting multi-agent task results
+
+## Aggregation Formats
+
+### Standard Batch Format
+
+```
+[Batch Complete] {completed}/{total}
+├── {agent}: {icon} {summary}
+├── {agent}: {icon} {summary}
+└── {agent}: {icon} {summary}
+```
+
+### Detailed Batch Format
+
+```
+[Batch Complete] {completed}/{total}
+
+[1] {agent-name}
+    Status: {success|failed|partial}
+    Target: {file/path}
+    Result: {summary}
+
+[2] {agent-name}
+    Status: {success|failed|partial}
+    Target: {file/path}
+    Result: {summary}
+```
+
+### Error Summary Format
+
+```
+[Batch Complete] {completed}/{total} ({failures} failed)
+
+Failures:
+├── {agent}: {error summary}
+└── {agent}: {error summary}
+
+Successes:
+├── {agent}: ✓ {summary}
+└── {agent}: ✓ {summary}
+```
+
+## Status Icons
+
+| Icon | Status | Use When |
+|------|--------|----------|
+| ✓ | Success | Task completed successfully |
+| ✗ | Failed | Task failed with error |
+| ⚠ | Warning | Completed with warnings |
+| ⏳ | Pending | Still in progress |
+| ⊘ | Skipped | Task was skipped |
+
+## Aggregation Rules
+
+### 1. Ordering
+
+```yaml
+order:
+  - Failed results first (need attention)
+  - Warnings second
+  - Successes last
+  - Within category: alphabetical by agent
+```
+
+### 2. Summary Length
+
+```yaml
+ecomode_on:
+  max_length: 50 characters
+  truncate_with: "..."
+
+ecomode_off:
+  max_length: 200 characters
+  allow_multiline: true
+```
+
+### 3. Grouping
+
+```yaml
+group_by:
+  - status (success/failed/warning)
+  - agent_type (when mixed types)
+  - target_path (when same agent, different targets)
+```
+
+## Integration
+
+### With Secretary
+
+```
+Secretary receives:
+  - List of agent results
+  - Ecomode status
+  - User display preferences
+
+Secretary outputs:
+  - Aggregated summary using this skill
+  - Individual details if requested
+```
+
+### With Ecomode
+
+```
+When ecomode active:
+  - Use compact format
+  - One line per agent
+  - Icons for status
+  - Truncate long summaries
+```
+
+## Examples
+
+### Code Review Batch
+
+```
+[Batch Complete] 4/4
+
+├── lang-golang-expert: ✓ src/main.go - 2 issues (1 naming, 1 error handling)
+├── lang-python-expert: ✓ scripts/*.py - Clean
+├── lang-rust-expert: ⚠ lib/core.rs - 1 unsafe block flagged
+└── lang-typescript-expert: ✓ web/app.tsx - 3 suggestions
+```
+
+### Agent Creation Batch
+
+```
+[Batch Complete] 3/4 (1 failed)
+
+✗ lang-kotlin-expert: Skill not found: kotlin-best-practices
+✓ lang-golang-expert: Agent created at .codex/agents/lang-golang-expert.md
+✓ lang-python-expert: Agent created at .codex/agents/lang-python-expert.md
+✓ lang-rust-expert: Agent created at .codex/agents/lang-rust-expert.md
+```
+
+### Audit Batch
+
+```
+[Batch Complete] 5/5
+
+Agents Audited:
+├── mgr-creator: ✓ All refs valid
+├── mgr-updater: ✓ All refs valid
+├── mgr-supplier: ⚠ 1 deprecated ref
+├── lang-golang-expert: ✓ All refs valid
+└── lang-python-expert: ✓ All refs valid
+
+Summary: 5 agents checked, 1 warning
+```

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

@@ -0,0 +1,267 @@
+---
+name: rust-best-practices
+description: Idiomatic Rust patterns from official guidelines
+user-invocable: false
+---
+
+## Purpose
+
+Apply idiomatic Rust patterns and best practices from official documentation.
+
+## Core Principles
+
+```
+Safety without garbage collection
+Zero-cost abstractions
+Fearless concurrency
+Ownership as a feature
+```
+
+## Rules
+
+### 1. Naming Conventions
+
+```yaml
+crates:
+  style: snake_case or kebab-case
+  example: my_crate, my-crate
+
+modules:
+  style: snake_case
+  example: my_module
+
+types:
+  style: UpperCamelCase
+  example: MyStruct, MyEnum
+
+traits:
+  style: UpperCamelCase
+  example: Iterator, Display
+
+functions_methods:
+  style: snake_case
+  example: my_function, get_value
+
+constants:
+  style: SCREAMING_SNAKE_CASE
+  example: MAX_SIZE
+
+type_parameters:
+  style: single uppercase or CamelCase
+  example: T, E, Item
+
+lifetimes:
+  style: short lowercase
+  example: 'a, 'b, 'static
+
+macros:
+  style: snake_case!
+  example: vec!, println!
+```
+
+### 2. Ownership and Borrowing
+
+```yaml
+principles:
+  - Each value has exactly one owner
+  - References cannot outlive the data they reference
+  - Either one mutable reference OR many immutable references
+
+prefer:
+  - "&T over T" when not needing ownership
+  - "&mut T over T" when modifying without consuming
+  - "T over Box<T>" when size is known at compile time
+
+avoid:
+  - Clone when borrowing suffices
+  - RefCell unless interior mutability is needed
+  - Unsafe unless absolutely necessary
+```
+
+### 3. Error Handling
+
+```yaml
+result_type:
+  - Return Result<T, E> for recoverable errors
+  - Use ? operator for propagation
+  - Define custom error types for libraries
+
+option_type:
+  - Use Option<T> for nullable values
+  - Prefer map/and_then over match when appropriate
+  - Use unwrap_or, unwrap_or_else, unwrap_or_default
+
+panic:
+  - Only for unrecoverable errors
+  - Use in tests with assert!, assert_eq!
+  - Avoid in library code
+
+patterns: |
+  // Propagation with ?
+  fn read_file() -> Result<String, io::Error> {
+      let mut file = File::open("file.txt")?;
+      let mut contents = String::new();
+      file.read_to_string(&mut contents)?;
+      Ok(contents)
+  }
+
+  // Custom error type
+  #[derive(Debug)]
+  enum MyError {
+      Io(io::Error),
+      Parse(ParseIntError),
+  }
+```
+
+### 4. Traits and Generics
+
+```yaml
+trait_design:
+  - Keep traits focused and small
+  - Use associated types for output types
+  - Implement standard traits: Debug, Clone, Default, PartialEq
+
+standard_traits:
+  - Debug: for debugging output
+  - Clone: explicit duplication
+  - Default: default value construction
+  - PartialEq, Eq: equality comparison
+  - PartialOrd, Ord: ordering
+  - Hash: for HashMap keys
+  - Display: user-facing output
+  - From/Into: type conversion
+
+generics:
+  - Use trait bounds to specify requirements
+  - Prefer impl Trait in argument position
+  - Use where clauses for complex bounds
+```
+
+### 5. Memory Management
+
+```yaml
+stack_vs_heap:
+  - Stack: fixed-size, Copy types
+  - Heap: dynamic-size, Box, Vec, String
+
+smart_pointers:
+  - Box<T>: heap allocation with single owner
+  - Rc<T>: reference counting (single-threaded)
+  - Arc<T>: atomic reference counting (multi-threaded)
+  - RefCell<T>: interior mutability
+
+avoid_leaks:
+  - Drop trait for cleanup
+  - RAII pattern for resources
+  - Weak references to break cycles
+```
+
+### 6. Concurrency
+
+```yaml
+send_sync:
+  - Send: safe to transfer between threads
+  - Sync: safe to share references between threads
+
+primitives:
+  - Mutex<T>: mutual exclusion
+  - RwLock<T>: multiple readers or one writer
+  - Arc<T>: thread-safe reference counting
+  - mpsc: channels for message passing
+
+patterns: |
+  // Shared state with Arc and Mutex
+  let counter = Arc::new(Mutex::new(0));
+  let counter_clone = Arc::clone(&counter);
+
+  thread::spawn(move || {
+      let mut num = counter_clone.lock().unwrap();
+      *num += 1;
+  });
+
+  // Message passing
+  let (tx, rx) = mpsc::channel();
+  thread::spawn(move || {
+      tx.send(value).unwrap();
+  });
+  let received = rx.recv().unwrap();
+```
+
+### 7. API Design
+
+```yaml
+guidelines:
+  - Accept borrowed data when possible
+  - Return owned data when the caller needs it
+  - Use Into/AsRef for flexible parameters
+  - Implement standard conversion traits
+
+constructors:
+  - new() for primary constructor
+  - with_* for alternative constructors
+  - Builder pattern for many parameters
+
+methods:
+  - is_* for boolean queries
+  - as_* for cheap conversions (borrows)
+  - to_* for expensive conversions (copies)
+  - into_* for ownership transfers
+```
+
+### 8. Documentation
+
+```yaml
+rules:
+  - Document all public items
+  - Include examples in doc comments
+  - Use # Examples section
+  - Document panics, errors, safety
+
+format: |
+  /// Brief description.
+  ///
+  /// More detailed explanation if needed.
+  ///
+  /// # Examples
+  ///
+  /// ```
+  /// let result = my_function(42);
+  /// assert_eq!(result, 84);
+  /// ```
+  ///
+  /// # Panics
+  ///
+  /// Panics if the input is zero.
+  pub fn my_function(x: i32) -> i32 {
+      x * 2
+  }
+```
+
+### 9. Project Structure
+
+```yaml
+layout:
+  - src/lib.rs or src/main.rs: crate root
+  - src/bin/: additional binaries
+  - tests/: integration tests
+  - benches/: benchmarks
+  - examples/: example programs
+
+modules:
+  - One module per file
+  - mod.rs or filename.rs for module
+  - pub use for re-exports
+```
+
+## Application
+
+When writing or reviewing Rust code:
+
+1. **Always** handle ownership correctly
+2. **Always** handle errors with Result/Option
+3. **Prefer** borrowing over cloning
+4. **Prefer** zero-cost abstractions
+5. **Implement** standard traits (Debug, Clone, etc.)
+6. **Document** public APIs with examples
+7. **Avoid** unsafe unless necessary
+8. **Use** clippy for linting