oh-my-customcode 0.1.3 → 0.2.0

package/templates/agents/sw-engineer/language/rust-expert/refs/rust/index.yaml

@@ -1,26 +0,0 @@
-# Rust Guide
-
-metadata:
-  name: rust
-  description: Rust language reference documentation
-
-source:
-  type: external
-  origin: rust-lang.org
-  urls:
-    - https://doc.rust-lang.org/book/
-    - https://rust-lang.github.io/api-guidelines/
-    - https://doc.rust-lang.org/nightly/style-guide/
-  last_fetched: "2026-01-22"
-
-documents:
-  - name: ownership
-    path: ./ownership.md
-    description: Ownership, borrowing, and lifetimes
-
-  - name: error-handling
-    path: ./error-handling.md
-    description: Error handling patterns in Rust
-
-used_by:
-  - rust-expert

package/templates/agents/sw-engineer/language/rust-expert/refs/rust/ownership.md

@@ -1,180 +0,0 @@
-# Rust Ownership
-
-> Reference for ownership, borrowing, and lifetimes
-
-## Ownership Rules
-
-1. Each value has exactly one owner
-2. When the owner goes out of scope, the value is dropped
-3. Values can be moved or borrowed
-
-## Move Semantics
-
-```rust
-// Move ownership
-let s1 = String::from("hello");
-let s2 = s1; // s1 is moved to s2
-// s1 is no longer valid
-
-// Clone to copy
-let s1 = String::from("hello");
-let s2 = s1.clone(); // s1 is still valid
-
-// Copy types (stack-only data)
-let x = 5;
-let y = x; // x is still valid (i32 implements Copy)
-```
-
-## Borrowing
-
-### Immutable References
-
-```rust
-fn main() {
-    let s1 = String::from("hello");
-    let len = calculate_length(&s1); // borrow s1
-    println!("The length of '{}' is {}.", s1, len);
-}
-
-fn calculate_length(s: &String) -> usize {
-    s.len()
-}
-```
-
-### Mutable References
-
-```rust
-fn main() {
-    let mut s = String::from("hello");
-    change(&mut s);
-}
-
-fn change(some_string: &mut String) {
-    some_string.push_str(", world");
-}
-```
-
-### Borrowing Rules
-
-```rust
-// Rule 1: At any time, either ONE mutable reference
-// OR any number of immutable references
-let mut s = String::from("hello");
-
-let r1 = &s; // OK
-let r2 = &s; // OK
-// let r3 = &mut s; // ERROR: cannot borrow as mutable
-
-let r3 = &mut s; // OK after r1 and r2 are done
-```
-
-## Lifetimes
-
-### Basic Syntax
-
-```rust
-// Lifetime annotation
-fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
-    if x.len() > y.len() {
-        x
-    } else {
-        y
-    }
-}
-```
-
-### Struct Lifetimes
-
-```rust
-struct ImportantExcerpt<'a> {
-    part: &'a str,
-}
-
-impl<'a> ImportantExcerpt<'a> {
-    fn level(&self) -> i32 {
-        3
-    }
-
-    fn announce_and_return_part(&self, announcement: &str) -> &str {
-        println!("Attention please: {}", announcement);
-        self.part
-    }
-}
-```
-
-### Lifetime Elision
-
-```rust
-// These are equivalent:
-fn first_word(s: &str) -> &str { ... }
-fn first_word<'a>(s: &'a str) -> &'a str { ... }
-
-// Elision rules:
-// 1. Each reference parameter gets its own lifetime
-// 2. If exactly one input lifetime, it's assigned to all outputs
-// 3. If &self or &mut self, its lifetime is assigned to outputs
-```
-
-### Static Lifetime
-
-```rust
-// 'static: lives for entire program duration
-let s: &'static str = "I have a static lifetime.";
-
-// All string literals have 'static lifetime
-```
-
-## Common Patterns
-
-### Returning References
-
-```rust
-// Cannot return reference to local variable
-fn dangle() -> &String { // ERROR
-    let s = String::from("hello");
-    &s // s goes out of scope!
-}
-
-// Return owned value instead
-fn no_dangle() -> String {
-    let s = String::from("hello");
-    s
-}
-```
-
-### Struct with References
-
-```rust
-// Struct holding reference must have lifetime
-struct Config<'a> {
-    query: &'a str,
-    filename: &'a str,
-}
-
-// Implementation with lifetime
-impl<'a> Config<'a> {
-    fn new(args: &'a [String]) -> Config<'a> {
-        Config {
-            query: &args[1],
-            filename: &args[2],
-        }
-    }
-}
-```
-
-### Multiple Lifetimes
-
-```rust
-fn longest_with_announcement<'a, 'b>(
-    x: &'a str,
-    y: &'a str,
-    ann: &'b str,
-) -> &'a str {
-    println!("Announcement: {}", ann);
-    if x.len() > y.len() {
-        x
-    } else {
-        y
-    }
-}
-```

package/templates/agents/sw-engineer/language/rust-expert/refs/rust-best-practices/index.yaml

@@ -1,26 +0,0 @@
-# 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/agents/sw-engineer/language/typescript-expert/AGENT.md

@@ -1,47 +0,0 @@
-# TypeScript Expert Agent
-
-> **Type**: SW Engineer
-> **Source**: Internal
-
-## Purpose
-
-Expert TypeScript developer specialized in writing type-safe, maintainable, and scalable TypeScript code following industry best practices.
-
-## Capabilities
-
-1. Write type-safe TypeScript code with proper type annotations
-2. Design robust type systems using advanced TypeScript features
-3. Leverage generics, conditional types, and mapped types
-4. Implement proper error handling patterns
-5. Optimize for both development experience and runtime performance
-6. Apply Node.js and browser-specific patterns
-
-## When to Use
-
-- Writing new TypeScript applications or libraries
-- Reviewing existing TypeScript code for type safety
-- Designing APIs with strong type contracts
-- Migrating JavaScript to TypeScript
-- Implementing Node.js backend services
-
-## Skills
-
-| Skill | Purpose |
-|-------|---------|
-| typescript-best-practices | Core TypeScript development guidelines |
-
-## Guides
-
-| Guide | Purpose |
-|-------|---------|
-| typescript | Reference documentation from official TypeScript docs |
-
-## Workflow
-
-```
-1. Understand requirements
-2. Apply typescript-best-practices skill
-3. Reference typescript guide for specific patterns
-4. Write/review code with type safety
-5. Ensure proper type inference and explicit annotations
-```

package/templates/agents/sw-engineer/language/typescript-expert/index.yaml

@@ -1,27 +0,0 @@
-# TypeScript Expert Agent
-
-metadata:
-  name: typescript-expert
-  type: sw-engineer/language
-  description: Expert TypeScript developer with focus on type safety
-
-source:
-  type: internal
-
-capabilities:
-  - Write type-safe TypeScript code
-  - Design robust type systems
-  - Leverage generics and advanced types
-  - Implement error handling patterns
-  - Optimize for DX and performance
-  - Node.js and browser patterns
-
-skills:
-  - name: typescript-best-practices
-    path: ../../../../skills/development/typescript-best-practices/
-    required: true
-
-guides:
-  - name: typescript
-    path: ../../../../guides/typescript/
-    required: true

package/templates/agents/sw-engineer/language/typescript-expert/refs/typescript/advanced-types.md

@@ -1,225 +0,0 @@
-# TypeScript Advanced Types
-
-> Reference for advanced TypeScript type patterns
-
-## Utility Types
-
-```typescript
-// Partial - make all properties optional
-type PartialUser = Partial<User>;
-
-// Required - make all properties required
-type RequiredUser = Required<User>;
-
-// Readonly - make all properties readonly
-type ReadonlyUser = Readonly<User>;
-
-// Pick - select specific properties
-type UserName = Pick<User, 'name' | 'email'>;
-
-// Omit - exclude specific properties
-type UserWithoutId = Omit<User, 'id'>;
-
-// Record - create object type with key-value pairs
-type UserMap = Record<string, User>;
-
-// Exclude - exclude types from union
-type NonNullStatus = Exclude<Status | null, null>;
-
-// Extract - extract types from union
-type StringStatus = Extract<Status, string>;
-
-// NonNullable - remove null and undefined
-type DefinedValue = NonNullable<string | null | undefined>;
-
-// ReturnType - get function return type
-type Result = ReturnType<typeof fetchUser>;
-
-// Parameters - get function parameter types
-type Params = Parameters<typeof fetchUser>;
-```
-
-## Mapped Types
-
-```typescript
-// Make all properties optional
-type Optional<T> = {
-  [P in keyof T]?: T[P];
-};
-
-// Make all properties readonly
-type Immutable<T> = {
-  readonly [P in keyof T]: T[P];
-};
-
-// Make all properties nullable
-type Nullable<T> = {
-  [P in keyof T]: T[P] | null;
-};
-
-// Remap keys
-type Getters<T> = {
-  [P in keyof T as `get${Capitalize<string & P>}`]: () => T[P];
-};
-
-// Filter properties by type
-type OnlyStrings<T> = {
-  [P in keyof T as T[P] extends string ? P : never]: T[P];
-};
-```
-
-## Conditional Types
-
-```typescript
-// Basic conditional
-type IsString<T> = T extends string ? true : false;
-
-// With infer
-type UnwrapPromise<T> = T extends Promise<infer U> ? U : T;
-
-// Array element type
-type ElementType<T> = T extends (infer E)[] ? E : never;
-
-// Function return type
-type GetReturnType<T> = T extends (...args: any[]) => infer R ? R : never;
-
-// Distributive conditional
-type ToArray<T> = T extends any ? T[] : never;
-// ToArray<string | number> = string[] | number[]
-```
-
-## Template Literal Types
-
-```typescript
-// Simple template
-type Greeting = `Hello, ${string}!`;
-
-// With union
-type EventHandler = `on${Capitalize<'click' | 'hover' | 'focus'>}`;
-// 'onClick' | 'onHover' | 'onFocus'
-
-// Extract from string
-type ExtractRouteParams<T extends string> =
-  T extends `${string}:${infer Param}/${infer Rest}`
-    ? Param | ExtractRouteParams<Rest>
-    : T extends `${string}:${infer Param}`
-    ? Param
-    : never;
-
-// ExtractRouteParams<'/users/:id/posts/:postId'>
-// = 'id' | 'postId'
-```
-
-## Discriminated Unions
-
-```typescript
-interface Circle {
-  kind: 'circle';
-  radius: number;
-}
-
-interface Square {
-  kind: 'square';
-  side: number;
-}
-
-interface Rectangle {
-  kind: 'rectangle';
-  width: number;
-  height: number;
-}
-
-type Shape = Circle | Square | Rectangle;
-
-function getArea(shape: Shape): number {
-  switch (shape.kind) {
-    case 'circle':
-      return Math.PI * shape.radius ** 2;
-    case 'square':
-      return shape.side ** 2;
-    case 'rectangle':
-      return shape.width * shape.height;
-  }
-}
-```
-
-## Index Signatures
-
-```typescript
-// String index
-interface Dictionary {
-  [key: string]: string;
-}
-
-// Number index
-interface NumberMap {
-  [index: number]: string;
-}
-
-// With specific properties
-interface User {
-  id: string;
-  name: string;
-  [key: string]: string; // additional properties
-}
-
-// Template literal index
-type Handlers = {
-  [K in `on${Capitalize<string>}`]: (event: Event) => void;
-};
-```
-
-## Type Narrowing
-
-```typescript
-// Control flow analysis
-function process(value: string | number | null) {
-  if (value === null) {
-    return; // value is null
-  }
-
-  if (typeof value === 'string') {
-    console.log(value.toUpperCase()); // value is string
-  } else {
-    console.log(value.toFixed(2)); // value is number
-  }
-}
-
-// Assertion functions
-function assertIsString(value: unknown): asserts value is string {
-  if (typeof value !== 'string') {
-    throw new Error('Not a string');
-  }
-}
-
-// Type predicates
-function isNonNull<T>(value: T): value is NonNullable<T> {
-  return value !== null && value !== undefined;
-}
-
-const filtered = items.filter(isNonNull);
-```
-
-## Brand Types
-
-```typescript
-// Create distinct types for same underlying type
-type UserId = string & { readonly brand: unique symbol };
-type PostId = string & { readonly brand: unique symbol };
-
-function createUserId(id: string): UserId {
-  return id as UserId;
-}
-
-function createPostId(id: string): PostId {
-  return id as PostId;
-}
-
-function getUser(id: UserId): User { ... }
-
-const userId = createUserId('123');
-const postId = createPostId('456');
-
-getUser(userId); // OK
-getUser(postId); // Error: PostId not assignable to UserId
-```

package/templates/agents/sw-engineer/language/typescript-expert/refs/typescript/index.yaml

@@ -1,26 +0,0 @@
-# TypeScript Guide
-
-metadata:
-  name: typescript
-  description: TypeScript language reference documentation
-
-source:
-  type: external
-  origin: typescriptlang.org
-  urls:
-    - https://www.typescriptlang.org/docs/handbook/
-    - https://google.github.io/styleguide/tsguide.html
-    - https://basarat.gitbook.io/typescript/
-  last_fetched: "2026-01-22"
-
-documents:
-  - name: type-system
-    path: ./type-system.md
-    description: TypeScript type system fundamentals
-
-  - name: advanced-types
-    path: ./advanced-types.md
-    description: Advanced TypeScript type patterns
-
-used_by:
-  - typescript-expert