oh-my-customcode 0.1.0

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

@@ -0,0 +1,266 @@
+# Rust Best Practices Skill
+
+> **Category**: Development
+> **Source**: Internal (based on Rust API Guidelines and The Book)
+
+## 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

package/templates/skills/development/rust-best-practices/index.yaml

@@ -0,0 +1,26 @@
+# Rust Best Practices Skill
+
+metadata:
+  name: rust-best-practices
+  category: development
+  description: Idiomatic Rust patterns from official guidelines
+
+source:
+  type: internal
+  reference:
+    - https://doc.rust-lang.org/book/
+    - https://rust-lang.github.io/api-guidelines/
+    - https://doc.rust-lang.org/nightly/style-guide/
+
+provides:
+  - Rust naming conventions
+  - Ownership and borrowing patterns
+  - Error handling patterns
+  - Trait and generic design
+  - Memory management guidelines
+  - Concurrency patterns
+  - API design guidelines
+  - Documentation standards
+
+used_by:
+  - rust-expert

package/templates/skills/development/typescript-best-practices/SKILL.md

@@ -0,0 +1,320 @@
+# TypeScript Best Practices Skill
+
+> **Category**: Development
+> **Source**: Internal (based on Google TypeScript Style Guide and TypeScript Handbook)
+
+## Purpose
+
+Apply type-safe TypeScript patterns and best practices from industry standards.
+
+## Core Principles
+
+```
+Type safety over convenience
+Explicit over implicit
+Prefer strict mode
+Use inference wisely
+```
+
+## Rules
+
+### 1. Type System
+
+```yaml
+type_inference:
+  rely_on: trivially inferred types (primitives, literals)
+  annotate: complex expressions, return types, public APIs
+
+any_vs_unknown:
+  prefer: unknown (requires type narrowing)
+  avoid: any (disables type checking)
+  if_any_needed: add suppressing comment
+
+nullable:
+  prefer: "field?: Type"
+  avoid: "field: Type | undefined"
+  compare_enums: explicitly, not boolean coercion
+
+patterns: |
+  // Good: unknown with narrowing
+  function process(data: unknown): void {
+    if (typeof data === 'string') {
+      console.log(data.toUpperCase());
+    }
+  }
+
+  // Avoid: any
+  function process(data: any): void {
+    console.log(data.toUpperCase()); // No type checking!
+  }
+```
+
+### 2. Interfaces vs Types
+
+```yaml
+prefer_interfaces:
+  - Object type definitions
+  - Public API contracts
+  - Extendable types
+
+use_types_for:
+  - Union types
+  - Intersection types
+  - Mapped types
+  - Utility types
+
+patterns: |
+  // Interface for objects
+  interface User {
+    id: string;
+    name: string;
+    email: string;
+  }
+
+  // Type for unions/utilities
+  type Status = 'pending' | 'active' | 'completed';
+  type ReadonlyUser = Readonly<User>;
+```
+
+### 3. Arrays and Generics
+
+```yaml
+array_syntax:
+  simple_types: "T[]"
+  complex_types: "Array<T>"
+
+generics:
+  naming: single uppercase (T, K, V) or descriptive (TItem, TResult)
+  constraints: use extends for type bounds
+  defaults: provide when appropriate
+
+patterns: |
+  // Array syntax
+  const numbers: number[] = [1, 2, 3];
+  const items: Array<{ id: string; value: number }> = [];
+
+  // Generic constraints
+  function getProperty<T, K extends keyof T>(obj: T, key: K): T[K] {
+    return obj[key];
+  }
+```
+
+### 4. Variables and Constants
+
+```yaml
+declarations:
+  prefer: const
+  when_needed: let
+  never: var
+
+one_per_statement: true
+
+patterns: |
+  // Good
+  const name = 'TypeScript';
+  const version = 5.0;
+
+  // Avoid
+  var name = 'TypeScript', version = 5.0;
+```
+
+### 5. Functions
+
+```yaml
+function_declarations:
+  named_functions: function declaration
+  callbacks: arrow functions
+  methods: shorthand syntax
+
+parameters:
+  prefer_rest: "...args: T[]"
+  avoid: arguments object
+
+this_handling:
+  prefer: arrow functions or explicit parameter
+  avoid: rebinding with bind/call/apply
+
+patterns: |
+  // Function declaration
+  function processData(data: Data): Result {
+    return transform(data);
+  }
+
+  // Arrow function for callbacks
+  items.map((item) => item.value);
+
+  // Rest parameters
+  function concat(...strings: string[]): string {
+    return strings.join('');
+  }
+```
+
+### 6. Classes
+
+```yaml
+visibility:
+  prefer: explicit modifiers (public, private, protected)
+  avoid: private fields (#)
+
+initialization:
+  prefer: at declaration site
+  use: parameter properties in constructors
+
+readonly:
+  apply_to: non-reassigned properties
+
+patterns: |
+  class User {
+    readonly id: string;
+    private email: string;
+
+    constructor(
+      public name: string,
+      email: string,
+    ) {
+      this.id = generateId();
+      this.email = email;
+    }
+  }
+```
+
+### 7. Naming Conventions
+
+```yaml
+UpperCamelCase:
+  - Classes
+  - Interfaces
+  - Type aliases
+  - Enums
+  - Type parameters
+
+lowerCamelCase:
+  - Variables
+  - Parameters
+  - Functions
+  - Methods
+  - Properties
+
+CONSTANT_CASE:
+  - Global constants
+  - Enum values
+  - Static readonly fields
+
+rules:
+  - No leading/trailing underscores
+  - No abbreviations (except universal: URL, ID, DNS)
+  - Acronyms as whole words: loadHttpUrl, not loadHTTPURL
+  - Single-letter names only in 10-line scopes
+```
+
+### 8. Control Flow
+
+```yaml
+braces:
+  always: use braces for all control statements
+
+equality:
+  always: "=== and !=="
+  never: "== and !="
+
+loops:
+  arrays: for...of
+  objects: for...in with hasOwnProperty check
+
+patterns: |
+  // Always braced
+  if (condition) {
+    doSomething();
+  }
+
+  // for...of for arrays
+  for (const item of items) {
+    process(item);
+  }
+
+  // for...in with check
+  for (const key in obj) {
+    if (Object.prototype.hasOwnProperty.call(obj, key)) {
+      process(obj[key]);
+    }
+  }
+```
+
+### 9. Error Handling
+
+```yaml
+throwing:
+  only: Error instances
+  with_message: descriptive error messages
+
+catching:
+  type: unknown
+  validate: before use
+
+empty_catch:
+  require: rationale comment
+
+patterns: |
+  // Throw Error instances
+  throw new Error('Invalid input');
+
+  // Catch with unknown
+  try {
+    riskyOperation();
+  } catch (error: unknown) {
+    if (error instanceof Error) {
+      console.error(error.message);
+    }
+    throw error;
+  }
+```
+
+### 10. Imports and Exports
+
+```yaml
+imports:
+  prefer: named imports
+  use_namespace: for large APIs
+  prefer_relative: within project
+
+exports:
+  prefer: named exports
+  avoid: default exports
+
+patterns: |
+  // Named imports
+  import { User, UserService } from './user';
+
+  // Namespace import for large APIs
+  import * as fs from 'fs';
+
+  // Named exports
+  export interface User { }
+  export function createUser() { }
+```
+
+### 11. Disallowed Features
+
+```yaml
+never_use:
+  - eval() or dynamic code evaluation
+  - with statements
+  - const enum (use plain enum)
+  - debugger statements in production
+  - Modifying built-in prototypes
+  - Wrapper objects (new String(), new Boolean())
+  - Automatic semicolon insertion reliance
+```
+
+## Application
+
+When writing or reviewing TypeScript code:
+
+1. **Always** enable strict mode
+2. **Always** use explicit return types for public APIs
+3. **Prefer** unknown over any
+4. **Prefer** interfaces for object types
+5. **Use** const by default
+6. **Use** triple equals exclusively
+7. **Handle** errors with typed catch blocks
+8. **Avoid** default exports

package/templates/skills/development/typescript-best-practices/index.yaml

@@ -0,0 +1,28 @@
+# TypeScript Best Practices Skill
+
+metadata:
+  name: typescript-best-practices
+  category: development
+  description: Type-safe TypeScript patterns from industry standards
+
+source:
+  type: internal
+  reference:
+    - https://www.typescriptlang.org/docs/handbook/
+    - https://google.github.io/styleguide/tsguide.html
+    - https://basarat.gitbook.io/typescript/
+
+provides:
+  - TypeScript type system patterns
+  - Interface and type design
+  - Generic usage guidelines
+  - Variable and constant rules
+  - Function design patterns
+  - Class structure guidelines
+  - Naming conventions
+  - Control flow patterns
+  - Error handling patterns
+  - Import/export organization
+
+used_by:
+  - typescript-expert

package/templates/skills/development/vercel-deploy/SKILL.md

@@ -0,0 +1,73 @@
+# Vercel Deploy
+
+> **Source**: vercel-labs/agent-skills
+> **Capability**: Instant deployment to Vercel
+
+## When to Use
+
+- Deploy application to Vercel
+- Create preview deployments
+- Generate shareable URLs
+
+## Features
+
+### Framework Detection
+```
+Auto-detects 40+ frameworks from package.json:
+- Next.js
+- React
+- Vue
+- Nuxt
+- Svelte
+- Astro
+- and more...
+```
+
+### Auto Exclusions
+```
+Automatically excludes:
+- node_modules/
+- .git/
+- .env files
+```
+
+### Output
+```
+On successful deployment:
+1. Preview URL (view deployment)
+2. Claim URL (transfer ownership)
+```
+
+## Execution Flow
+
+```
+1. Detect project framework
+2. Prepare deployment bundle
+3. Upload to Vercel
+4. Return URLs
+```
+
+## Output Format
+
+```
+[Deploy Success]
+Preview: https://project-xxx.vercel.app
+Claim: https://vercel.com/claim/xxx
+```
+
+## Scripts
+
+See `scripts/deploy.sh` for deployment automation.
+
+## Requirements
+
+- Valid project structure
+- package.json present
+- Vercel CLI or API token (for authenticated deploys)
+
+## Limitations
+
+- Claimable deploys are anonymous
+- Preview URLs are temporary
+- Full features require Vercel account
+```