oh-my-customcode 0.1.2 → 0.1.4

package/templates/agents/sw-engineer/language/rust-expert/refs/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/agents/sw-engineer/language/typescript-expert/refs/typescript/advanced-types.md

@@ -0,0 +1,225 @@
+# 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

@@ -0,0 +1,26 @@
+# 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

package/templates/agents/sw-engineer/language/typescript-expert/refs/typescript/type-system.md

@@ -0,0 +1,219 @@
+# TypeScript Type System
+
+> Reference for TypeScript type fundamentals
+
+## Basic Types
+
+```typescript
+// Primitives
+const name: string = 'TypeScript';
+const version: number = 5.0;
+const isActive: boolean = true;
+
+// Arrays
+const numbers: number[] = [1, 2, 3];
+const items: Array<string> = ['a', 'b', 'c'];
+
+// Tuples
+const pair: [string, number] = ['key', 42];
+
+// Enums
+enum Status {
+  Pending = 'pending',
+  Active = 'active',
+  Completed = 'completed',
+}
+
+// Any and Unknown
+const flexible: any = 'anything';
+const safe: unknown = 'must narrow';
+
+// Void and Never
+function log(message: string): void {
+  console.log(message);
+}
+
+function fail(message: string): never {
+  throw new Error(message);
+}
+```
+
+## Interfaces
+
+```typescript
+interface User {
+  readonly id: string;
+  name: string;
+  email: string;
+  age?: number; // optional
+}
+
+// Extending interfaces
+interface Admin extends User {
+  permissions: string[];
+}
+
+// Implementing interfaces
+class UserImpl implements User {
+  readonly id: string;
+  name: string;
+  email: string;
+
+  constructor(id: string, name: string, email: string) {
+    this.id = id;
+    this.name = name;
+    this.email = email;
+  }
+}
+```
+
+## Type Aliases
+
+```typescript
+// Union types
+type Status = 'pending' | 'active' | 'completed';
+
+// Intersection types
+type Employee = User & { department: string };
+
+// Function types
+type Handler = (event: Event) => void;
+
+// Object types
+type Point = {
+  x: number;
+  y: number;
+};
+```
+
+## Generics
+
+```typescript
+// Generic function
+function identity<T>(arg: T): T {
+  return arg;
+}
+
+// Generic interface
+interface Container<T> {
+  value: T;
+  getValue(): T;
+}
+
+// Generic class
+class Box<T> {
+  private content: T;
+
+  constructor(content: T) {
+    this.content = content;
+  }
+
+  getContent(): T {
+    return this.content;
+  }
+}
+
+// Generic constraints
+function getLength<T extends { length: number }>(item: T): number {
+  return item.length;
+}
+
+// Default type parameters
+function createArray<T = string>(length: number, value: T): T[] {
+  return Array(length).fill(value);
+}
+```
+
+## Type Guards
+
+```typescript
+// typeof guard
+function processValue(value: string | number) {
+  if (typeof value === 'string') {
+    console.log(value.toUpperCase());
+  } else {
+    console.log(value.toFixed(2));
+  }
+}
+
+// instanceof guard
+function handleError(error: unknown) {
+  if (error instanceof Error) {
+    console.log(error.message);
+  }
+}
+
+// Custom type guard
+function isUser(obj: unknown): obj is User {
+  return (
+    typeof obj === 'object' &&
+    obj !== null &&
+    'id' in obj &&
+    'name' in obj
+  );
+}
+
+// in operator
+function processShape(shape: Circle | Square) {
+  if ('radius' in shape) {
+    console.log('Circle with radius:', shape.radius);
+  } else {
+    console.log('Square with side:', shape.side);
+  }
+}
+```
+
+## Literal Types
+
+```typescript
+// String literals
+type Direction = 'north' | 'south' | 'east' | 'west';
+
+// Numeric literals
+type DiceRoll = 1 | 2 | 3 | 4 | 5 | 6;
+
+// Boolean literal
+type Success = true;
+
+// Template literal types
+type EventName = `on${Capitalize<string>}`;
+type OnClick = `on${'Click' | 'Hover'}`;
+```
+
+## Type Assertions
+
+```typescript
+// as syntax (preferred)
+const input = document.getElementById('input') as HTMLInputElement;
+
+// Angle bracket syntax
+const input2 = <HTMLInputElement>document.getElementById('input');
+
+// Non-null assertion
+const element = document.getElementById('root')!;
+
+// const assertion
+const config = {
+  endpoint: '/api',
+  timeout: 5000,
+} as const;
+```
+
+## Nullability
+
+```typescript
+// Optional property
+interface User {
+  name: string;
+  email?: string;
+}
+
+// Optional chaining
+const email = user?.email?.toLowerCase();
+
+// Nullish coalescing
+const displayName = user.nickname ?? user.name;
+
+// Non-null assertion
+const element = document.getElementById('root')!;
+```