automatasaurus 0.1.0

package/template/skills/github-workflow/SKILL.md

@@ -0,0 +1,161 @@
+---
+name: github-workflow
+description: Manages GitHub workflow including issues, PRs, labels, and reviews. Use when working with GitHub issues, creating PRs, or coordinating reviews.
+---
+
+# GitHub Workflow Skill
+
+Guidance for managing the development workflow through GitHub.
+
+## Issue State Labels
+
+| Label | Description | When to Apply |
+|-------|-------------|---------------|
+| `ready` | No blocking dependencies | Issue can be picked up |
+| `in-progress` | Currently being implemented | Developer starts work |
+| `blocked` | Waiting on dependencies | Has unresolved blockers |
+| `needs-review` | PR open, awaiting reviews | PR created |
+
+```bash
+gh issue edit {n} --add-label "in-progress" --remove-label "ready"
+gh issue edit {n} --add-label "needs-review" --remove-label "in-progress"
+```
+
+## Dependency Tracking
+
+In issue body:
+```markdown
+## Dependencies
+Depends on #12 (User authentication)
+Depends on #15 (Database schema)
+```
+
+Parse dependencies:
+```bash
+gh issue view {n} --json body --jq '.body' | grep -oE "Depends on #[0-9]+" | grep -oE "[0-9]+"
+gh issue view {dep} --json state --jq '.state'
+```
+
+## Agent Identification
+
+**All GitHub interactions must include an agent identifier header.**
+
+Format: `**[Agent Name]**` at the start of every issue body, PR description, and comment.
+
+## Standardized Review Comments
+
+Since all agents share the same GitHub user, reviews use standardized comments:
+
+**Approval:**
+```
+✅ APPROVED - [Role]
+[Summary]
+```
+
+**Changes Requested:**
+```
+❌ CHANGES REQUESTED - [Role]
+[Issues to address]
+```
+
+## Required Reviews Per PR
+
+| Review | When Required |
+|--------|---------------|
+| Architect | Always |
+| Designer | If UI changes |
+| Tester | Always |
+
+## Review Templates
+
+### Architect
+```bash
+gh pr comment {n} --body "**[Architect]**
+
+✅ APPROVED - Architect
+
+Clean architecture. LGTM."
+```
+
+### Designer
+```bash
+gh pr comment {n} --body "**[Designer]**
+
+✅ APPROVED - Designer
+
+UI looks good. Accessibility met."
+
+# Or if not applicable:
+gh pr comment {n} --body "**[Designer]** N/A - No UI changes."
+```
+
+### Tester
+```bash
+gh pr comment {n} --body "**[Tester]**
+
+✅ APPROVED - Tester
+
+**Tests:** All passing
+**Manual:** Completed
+
+Ready for merge."
+```
+
+### Product Owner (Merge)
+```bash
+gh pr comment {n} --body "**[Product Owner]**
+
+All required reviews complete:
+- ✅ Architect
+- ✅ Tester
+
+Proceeding with merge."
+
+gh pr merge {n} --squash --delete-branch
+```
+
+## PR Approval Verification
+
+Before merge:
+1. `✅ APPROVED - Architect` present
+2. `✅ APPROVED - Tester` present
+3. `✅ APPROVED - Designer` present (if UI)
+4. No outstanding `❌ CHANGES REQUESTED`
+5. CI/tests passing
+
+```bash
+gh pr view {n} --comments  # Check for approval comments
+```
+
+## Labels
+
+### Priority
+| Label | Description |
+|-------|-------------|
+| `priority:high` | Work first |
+| `priority:medium` | Normal |
+| `priority:low` | Work last |
+
+### Type
+| Label | Description |
+|-------|-------------|
+| `feature` | New functionality |
+| `bug` | Bug fix |
+| `enhancement` | Improvement |
+
+## Common Commands
+
+```bash
+# Issues
+gh issue list --state open --label "ready"
+gh issue view {n}
+gh issue edit {n} --add-label "in-progress"
+
+# PRs
+gh pr create --title "..." --body "..."
+gh pr view {n} --comments
+gh pr merge {n} --squash --delete-branch
+
+# Milestones
+gh issue edit {n} --milestone "v1.0"
+```

package/template/skills/infrastructure-standards/SKILL.md

@@ -0,0 +1,189 @@
+---
+name: infrastructure-standards
+description: Infrastructure, cloud, and DevOps standards. Use when setting up new projects, configuring cloud resources, or working with IaC.
+---
+
+# Infrastructure Standards
+
+## New Project Preferences
+
+When starting new projects, prefer:
+
+- **Terraform** for Infrastructure as Code
+- **GCP** (Google Cloud Platform) by default, unless otherwise specified
+- **Serverless** architectures that are free when idle (Cloud Run, Cloud Functions)
+- **Docker Compose** for local development
+
+## Terraform
+
+### Project Structure
+```
+infrastructure/
+├── main.tf           # Main configuration
+├── variables.tf      # Input variables
+├── outputs.tf        # Output values
+├── providers.tf      # Provider configuration
+├── terraform.tfvars  # Variable values (gitignored for secrets)
+└── modules/          # Reusable modules
+    └── api/
+        ├── main.tf
+        ├── variables.tf
+        └── outputs.tf
+```
+
+### Best Practices
+- Use remote state (GCS bucket for GCP)
+- Lock state files to prevent concurrent modifications
+- Use workspaces or separate state files for environments
+- Tag all resources consistently
+- Use modules for reusable infrastructure
+
+### GCP Provider Setup
+```hcl
+terraform {
+  required_version = ">= 1.0"
+
+  required_providers {
+    google = {
+      source  = "hashicorp/google"
+      version = "~> 5.0"
+    }
+  }
+
+  backend "gcs" {
+    bucket = "project-terraform-state"
+    prefix = "terraform/state"
+  }
+}
+
+provider "google" {
+  project = var.project_id
+  region  = var.region
+}
+```
+
+## GCP Services
+
+### Preferred Services (Free When Idle)
+
+| Use Case | Service | Notes |
+|----------|---------|-------|
+| APIs/Backend | Cloud Run | Scale to zero, pay per request |
+| Background Jobs | Cloud Functions | Event-driven, scale to zero |
+| Scheduled Tasks | Cloud Scheduler + Cloud Functions | Cron-like scheduling |
+| Database | Cloud SQL (small) or Firestore | Firestore has free tier |
+| Storage | Cloud Storage | Pay per use |
+| Auth | Firebase Auth | Free tier generous |
+
+### Cloud Run Example
+```hcl
+resource "google_cloud_run_service" "api" {
+  name     = "api"
+  location = var.region
+
+  template {
+    spec {
+      containers {
+        image = "gcr.io/${var.project_id}/api:latest"
+
+        resources {
+          limits = {
+            memory = "512Mi"
+            cpu    = "1"
+          }
+        }
+      }
+    }
+
+    metadata {
+      annotations = {
+        "autoscaling.knative.dev/minScale" = "0"  # Scale to zero
+        "autoscaling.knative.dev/maxScale" = "10"
+      }
+    }
+  }
+}
+```
+
+## Docker Compose (Local Dev)
+
+### Standard Structure
+```yaml
+# docker-compose.yml
+version: "3.8"
+
+services:
+  api:
+    build: ./api
+    ports:
+      - "8000:8000"
+    volumes:
+      - ./api:/app
+    environment:
+      - DATABASE_URL=postgresql://postgres:postgres@db:5432/app
+    depends_on:
+      - db
+
+  web:
+    build: ./web
+    ports:
+      - "3000:3000"
+    volumes:
+      - ./web:/app
+      - /app/node_modules
+    environment:
+      - VITE_API_URL=http://localhost:8000
+
+  db:
+    image: postgres:15
+    ports:
+      - "5432:5432"
+    environment:
+      - POSTGRES_PASSWORD=postgres
+      - POSTGRES_DB=app
+    volumes:
+      - postgres_data:/var/lib/postgresql/data
+
+volumes:
+  postgres_data:
+```
+
+### Best Practices
+- Use named volumes for persistent data
+- Mount source code for hot reload in development
+- Use `.env` files for environment variables (gitignored)
+- Include health checks for dependent services
+- Use `depends_on` with health conditions when needed
+
+## Environment Management
+
+### Secret Handling
+- Never commit secrets to git
+- Use `.env` files locally (gitignored)
+- Use GCP Secret Manager for production
+- Reference secrets in Terraform:
+
+```hcl
+data "google_secret_manager_secret_version" "api_key" {
+  secret = "api-key"
+}
+
+resource "google_cloud_run_service" "api" {
+  # ...
+  template {
+    spec {
+      containers {
+        env {
+          name = "API_KEY"
+          value_from {
+            secret_key_ref {
+              name = google_secret_manager_secret.api_key.secret_id
+              key  = "latest"
+            }
+          }
+        }
+      }
+    }
+  }
+}
+```

package/template/skills/javascript-standards/SKILL.md

@@ -0,0 +1,355 @@
+---
+name: javascript-standards
+description: JavaScript and TypeScript coding standards, conventions, and best practices. Use when writing, reviewing, or testing JS/TS code.
+---
+
+# JavaScript/TypeScript Coding Standards
+
+## New Project Preferences
+
+When starting new frontend projects, prefer:
+
+- **React 18** with TypeScript
+- **Vite** for development server
+- **Parcel** for production bundling
+- **shadcn/ui** for components
+- **Tailwind CSS 3** for styling
+
+## General Preferences
+
+- **TypeScript over JavaScript** for new code
+- **ESM over CommonJS** (`import`/`export` not `require`)
+- **Prettier** for formatting, **ESLint** for linting
+- **Strict TypeScript** (`"strict": true` in tsconfig)
+
+## Style Guide
+
+### Formatting (Prettier defaults)
+- Line length: 80-100 characters
+- Single quotes for strings
+- Semicolons: consistent (prefer with)
+- Trailing commas: ES5 or all
+- 2 space indentation
+
+### Naming Conventions
+```typescript
+// Files: kebab-case or PascalCase for components
+user-service.ts
+UserProfile.tsx
+
+// Variables and functions: camelCase
+const activeUsers = [];
+function getUserById(userId: string): User {}
+
+// Classes and types: PascalCase
+class UserService {}
+interface UserProfile {}
+type UserId = string;
+
+// Constants: SCREAMING_SNAKE_CASE or camelCase
+const MAX_RETRY_ATTEMPTS = 3;
+const defaultTimeout = 30000; // also acceptable
+
+// React components: PascalCase
+function UserCard({ user }: UserCardProps) {}
+const ProfileHeader: React.FC<Props> = () => {};
+
+// Boolean variables: is/has/should prefix
+const isActive = true;
+const hasPermission = false;
+const shouldRefetch = true;
+```
+
+## TypeScript
+
+### Type Definitions
+```typescript
+// Prefer interfaces for objects that can be extended
+interface User {
+  id: string;
+  email: string;
+  name: string;
+  createdAt: Date;
+}
+
+// Use type for unions, intersections, mapped types
+type UserId = string | number;
+type UserWithPosts = User & { posts: Post[] };
+type Readonly<T> = { readonly [K in keyof T]: T[K] };
+
+// Avoid `any` - use `unknown` for truly unknown types
+function parseJSON(json: string): unknown {
+  return JSON.parse(json);
+}
+
+// Use generics for reusable types
+function first<T>(arr: T[]): T | undefined {
+  return arr[0];
+}
+```
+
+### Strict Null Checking
+```typescript
+// Always handle null/undefined explicitly
+function getUser(id: string): User | null {
+  const user = users.get(id);
+  return user ?? null;
+}
+
+// Use optional chaining and nullish coalescing
+const userName = user?.profile?.name ?? 'Anonymous';
+
+// Non-null assertion only when you're certain
+const element = document.getElementById('app')!;
+```
+
+### Enums and Constants
+```typescript
+// Prefer const objects over enums for better tree-shaking
+const UserRole = {
+  Admin: 'admin',
+  User: 'user',
+  Guest: 'guest',
+} as const;
+
+type UserRole = typeof UserRole[keyof typeof UserRole];
+
+// If using enums, prefer string enums
+enum Status {
+  Pending = 'pending',
+  Active = 'active',
+  Inactive = 'inactive',
+}
+```
+
+## Functions
+
+```typescript
+// Use arrow functions for callbacks and short functions
+const doubled = numbers.map((n) => n * 2);
+
+// Use function declarations for top-level/hoisted functions
+function processUser(user: User): ProcessedUser {
+  // ...
+}
+
+// Default parameters over optional with fallback
+function greet(name: string, greeting = 'Hello'): string {
+  return `${greeting}, ${name}!`;
+}
+
+// Destructure parameters for objects
+function createUser({ email, name, role = 'user' }: CreateUserParams): User {
+  // ...
+}
+
+// Use rest parameters over arguments
+function sum(...numbers: number[]): number {
+  return numbers.reduce((a, b) => a + b, 0);
+}
+```
+
+## Async Code
+
+```typescript
+// Prefer async/await over .then() chains
+async function fetchUserData(userId: string): Promise<UserData> {
+  const user = await fetchUser(userId);
+  const posts = await fetchPosts(userId);
+  return { user, posts };
+}
+
+// Use Promise.all for concurrent operations
+async function fetchAllData(userId: string): Promise<AllData> {
+  const [user, posts, settings] = await Promise.all([
+    fetchUser(userId),
+    fetchPosts(userId),
+    fetchSettings(userId),
+  ]);
+  return { user, posts, settings };
+}
+
+// Handle errors appropriately
+async function safeOperation(): Promise<Result | null> {
+  try {
+    return await riskyOperation();
+  } catch (error) {
+    if (error instanceof NetworkError) {
+      console.error('Network error:', error.message);
+      return null;
+    }
+    throw error; // Re-throw unexpected errors
+  }
+}
+```
+
+## React Patterns
+
+```typescript
+// Functional components with TypeScript
+interface UserCardProps {
+  user: User;
+  onEdit?: (user: User) => void;
+  className?: string;
+}
+
+function UserCard({ user, onEdit, className }: UserCardProps) {
+  return (
+    <div className={className}>
+      <h2>{user.name}</h2>
+      {onEdit && <button onClick={() => onEdit(user)}>Edit</button>}
+    </div>
+  );
+}
+
+// Custom hooks
+function useUser(userId: string) {
+  const [user, setUser] = useState<User | null>(null);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState<Error | null>(null);
+
+  useEffect(() => {
+    let cancelled = false;
+
+    async function load() {
+      try {
+        const data = await fetchUser(userId);
+        if (!cancelled) setUser(data);
+      } catch (e) {
+        if (!cancelled) setError(e as Error);
+      } finally {
+        if (!cancelled) setLoading(false);
+      }
+    }
+
+    load();
+    return () => { cancelled = true; };
+  }, [userId]);
+
+  return { user, loading, error };
+}
+
+// Memoization
+const ExpensiveComponent = memo(function ExpensiveComponent({ data }: Props) {
+  const processed = useMemo(() => expensiveProcess(data), [data]);
+  const handleClick = useCallback(() => onClick(data.id), [data.id, onClick]);
+
+  return <div onClick={handleClick}>{processed}</div>;
+});
+```
+
+## Error Handling
+
+```typescript
+// Custom error classes
+class AppError extends Error {
+  constructor(
+    message: string,
+    public code: string,
+    public statusCode: number = 500,
+  ) {
+    super(message);
+    this.name = 'AppError';
+  }
+}
+
+class NotFoundError extends AppError {
+  constructor(resource: string, id: string) {
+    super(`${resource} with id ${id} not found`, 'NOT_FOUND', 404);
+    this.name = 'NotFoundError';
+  }
+}
+
+// Type guards for error handling
+function isAppError(error: unknown): error is AppError {
+  return error instanceof AppError;
+}
+
+function handleError(error: unknown): Response {
+  if (isAppError(error)) {
+    return { status: error.statusCode, message: error.message };
+  }
+  console.error('Unexpected error:', error);
+  return { status: 500, message: 'Internal server error' };
+}
+```
+
+## Testing
+
+```typescript
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+// or: import { jest } from '@jest/globals';
+
+describe('UserService', () => {
+  let service: UserService;
+  let mockDb: MockDatabase;
+
+  beforeEach(() => {
+    mockDb = createMockDatabase();
+    service = new UserService(mockDb);
+  });
+
+  it('should fetch user by id', async () => {
+    mockDb.users.get.mockResolvedValue({ id: '1', name: 'Test' });
+
+    const user = await service.getUser('1');
+
+    expect(user).toEqual({ id: '1', name: 'Test' });
+    expect(mockDb.users.get).toHaveBeenCalledWith('1');
+  });
+
+  it('should throw NotFoundError for missing user', async () => {
+    mockDb.users.get.mockResolvedValue(null);
+
+    await expect(service.getUser('999')).rejects.toThrow(NotFoundError);
+  });
+});
+
+// React Testing Library
+import { render, screen, fireEvent } from '@testing-library/react';
+
+describe('UserCard', () => {
+  it('should display user name', () => {
+    render(<UserCard user={{ id: '1', name: 'John' }} />);
+
+    expect(screen.getByText('John')).toBeInTheDocument();
+  });
+
+  it('should call onEdit when button clicked', () => {
+    const onEdit = vi.fn();
+    render(<UserCard user={{ id: '1', name: 'John' }} onEdit={onEdit} />);
+
+    fireEvent.click(screen.getByRole('button', { name: /edit/i }));
+
+    expect(onEdit).toHaveBeenCalledWith({ id: '1', name: 'John' });
+  });
+});
+```
+
+## Project Commands
+
+Check `.claude/commands.md` for project-specific commands. Common JS/TS commands:
+
+```bash
+# Dependencies
+npm install
+npm ci  # Clean install for CI
+
+# Development
+npm run dev
+npm run build
+
+# Linting & Formatting
+npm run lint
+npm run lint -- --fix
+npm run format
+
+# Testing
+npm test
+npm run test:watch
+npm run test:coverage
+
+# Type checking
+npm run typecheck
+npx tsc --noEmit
+```