@martinffx/atelier 1.0.2 → 1.2.0

package/skills/code-git-worktrees/SKILL.md

@@ -1,218 +0,0 @@
----
-name: code-git-worktrees
-description: Use when starting feature work that needs isolation from current workspace - creates isolated git worktrees with smart directory selection and safety verification. Triggers on worktree, git worktree, isolated workspace, or creating a new branch for feature work.
-user-invocable: true
----
-
-# Using Git Worktrees
-
-## Overview
-
-Git worktrees create isolated workspaces sharing the same repository, allowing work on multiple branches simultaneously without switching.
-
-**Core principle:** Systematic directory selection + safety verification = reliable isolation.
-
-**Announce at start:** "I'm using the using-git-worktrees skill to set up an isolated workspace."
-
-## Directory Selection Process
-
-Follow this priority order:
-
-### 1. Check Existing Directories
-
-```bash
-# Check in priority order
-ls -d .worktrees 2>/dev/null     # Preferred (hidden)
-ls -d worktrees 2>/dev/null      # Alternative
-```
-
-**If found:** Use that directory. If both exist, `.worktrees` wins.
-
-### 2. Check AGENTS.md
-
-```bash
-grep -i "worktree.*director" AGENTS.md 2>/dev/null
-```
-
-**If preference specified:** Use it without asking.
-
-### 3. Ask User
-
-If no directory exists and no AGENTS.md preference:
-
-```
-No worktree directory found. Where should I create worktrees?
-
-1. .worktrees/ (project-local, hidden)
-2. ~/.config/superpowers/worktrees/<project-name>/ (global location)
-
-Which would you prefer?
-```
-
-## Safety Verification
-
-### For Project-Local Directories (.worktrees or worktrees)
-
-**MUST verify directory is ignored before creating worktree:**
-
-```bash
-# Check if directory is ignored (respects local, global, and system gitignore)
-git check-ignore -q .worktrees 2>/dev/null || git check-ignore -q worktrees 2>/dev/null
-```
-
-**If NOT ignored:**
-
-Per Jesse's rule "Fix broken things immediately":
-1. Add appropriate line to .gitignore
-2. Commit the change
-3. Proceed with worktree creation
-
-**Why critical:** Prevents accidentally committing worktree contents to repository.
-
-### For Global Directory (~/.config/superpowers/worktrees)
-
-No .gitignore verification needed - outside project entirely.
-
-## Creation Steps
-
-### 1. Detect Project Name
-
-```bash
-project=$(basename "$(git rev-parse --show-toplevel)")
-```
-
-### 2. Create Worktree
-
-```bash
-# Determine full path
-case $LOCATION in
-  .worktrees|worktrees)
-    path="$LOCATION/$BRANCH_NAME"
-    ;;
-  ~/.config/superpowers/worktrees/*)
-    path="~/.config/superpowers/worktrees/$project/$BRANCH_NAME"
-    ;;
-esac
-
-# Create worktree with new branch
-git worktree add "$path" -b "$BRANCH_NAME"
-cd "$path"
-```
-
-### 3. Run Project Setup
-
-Auto-detect and run appropriate setup:
-
-```bash
-# Node.js
-if [ -f package.json ]; then npm install; fi
-
-# Rust
-if [ -f Cargo.toml ]; then cargo build; fi
-
-# Python
-if [ -f requirements.txt ]; then pip install -r requirements.txt; fi
-if [ -f pyproject.toml ]; then poetry install; fi
-
-# Go
-if [ -f go.mod ]; then go mod download; fi
-```
-
-### 4. Verify Clean Baseline
-
-Run tests to ensure worktree starts clean:
-
-```bash
-# Examples - use project-appropriate command
-npm test
-cargo test
-pytest
-go test ./...
-```
-
-**If tests fail:** Report failures, ask whether to proceed or investigate.
-
-**If tests pass:** Report ready.
-
-### 5. Report Location
-
-```
-Worktree ready at <full-path>
-Tests passing (<N> tests, 0 failures)
-Ready to implement <feature-name>
-```
-
-## Quick Reference
-
-| Situation | Action |
-|-----------|--------|
-| `.worktrees/` exists | Use it (verify ignored) |
-| `worktrees/` exists | Use it (verify ignored) |
-| Both exist | Use `.worktrees/` |
-| Neither exists | Check AGENTS.md → Ask user |
-| Directory not ignored | Add to .gitignore + commit |
-| Tests fail during baseline | Report failures + ask |
-| No package.json/Cargo.toml | Skip dependency install |
-
-## Common Mistakes
-
-### Skipping ignore verification
-
-- **Problem:** Worktree contents get tracked, pollute git status
-- **Fix:** Always use `git check-ignore` before creating project-local worktree
-
-### Assuming directory location
-
-- **Problem:** Creates inconsistency, violates project conventions
-- **Fix:** Follow priority: existing > AGENTS.md > ask
-
-### Proceeding with failing tests
-
-- **Problem:** Can't distinguish new bugs from pre-existing issues
-- **Fix:** Report failures, get explicit permission to proceed
-
-### Hardcoding setup commands
-
-- **Problem:** Breaks on projects using different tools
-- **Fix:** Auto-detect from project files (package.json, etc.)
-
-## Example Workflow
-
-```
-You: I'm using the using-git-worktrees skill to set up an isolated workspace.
-
-[Check .worktrees/ - exists]
-[Verify ignored - git check-ignore confirms .worktrees/ is ignored]
-[Create worktree: git worktree add .worktrees/auth -b feature/auth]
-[Run npm install]
-[Run npm test - 47 passing]
-
-Worktree ready at /Users/jesse/myproject/.worktrees/auth
-Tests passing (47 tests, 0 failures)
-Ready to implement auth feature
-```
-
-## Red Flags
-
-**Never:**
-- Create worktree without verifying it's ignored (project-local)
-- Skip baseline test verification
-- Proceed with failing tests without asking
-- Assume directory location when ambiguous
-- Skip AGENTS.md check
-
-**Always:**
-- Follow directory priority: existing > AGENTS.md > ask
-- Verify directory is ignored for project-local
-- Auto-detect and run project setup
-- Verify clean test baseline
-
-## Integration
-
-**Called by:**
-- Any skill needing isolated workspace for feature work
-- When user explicitly requests worktree setup
-- Before long-running implementation tasks that could pollute current workspace
-
-**Pairs with:**
-- `stacked-commit` - Use worktrees when managing stacked commits across multiple branches

package/skills/code-perf/SKILL.md

@@ -1,163 +0,0 @@
----
-name: code-perf
-description: >
-  Performance profiling and optimization. Use when code is slow, has memory issues, or needs
-  optimization. Triggers on "slow", "performance", "optimize", "memory leak", "profiling",
-  "bottleneck", or any performance-related concern.
-user-invocable: true
----
-
-# Code Perf
-
-Performance profiling and optimization workflow.
-
-## The Golden Rule
-
-**Never optimize without profiling.**
-
-You don't know where the bottleneck is until you measure. Making changes without
-profiling wastes time and often makes things worse.
-
----
-
-## Workflow
-
-### 1. Profile
-
-Measure the current performance.
-
-**Questions:**
-- What's slow? (endpoint, operation, page load)
-- How slow? (latency, throughput)
-- Under what conditions? (load, data size)
-
-**Tools:**
-- Browser DevTools (Performance tab)
-- Node clinic.js
-- Python cProfile
-- Go pprof
-
-### 2. Identify
-
-Find the hot paths.
-
-**Look for:**
-- Functions called many times
-- Large memory allocations
-- Blocking I/O
-- Unnecessary computations
-
-### 3. Optimize
-
-Apply the right optimization pattern.
-
-### 4. Verify
-
-Re-profile to confirm improvement.
-
----
-
-## Common Bottlenecks
-
-See references/common-bottlenecks.md for detailed patterns:
-
-| Pattern | Symptom | Solution |
-|---------|---------|----------|
-| N+1 | Multiple DB queries | Eager load, batch |
-| Memory leak | Growing RSS | Clear caches, weak refs |
-| Blocking I/O | Thread blocked | Async, worker pool |
-| Unnecessary work | CPU high | Skip redundant calc |
-| Large data | Slow serialization | Pagination, streams |
-
----
-
-## Optimization Patterns
-
-See references/optimization-patterns.md for:
-
-### Caching
-
-```javascript
-// Before: every call hits DB
-const user = await db.users.find(id);
-
-// After: cache
-const cacheKey = `user:${id}`;
-let user = await redis.get(cacheKey);
-if (!user) {
-  user = await db.users.find(id);
-  await redis.set(cacheKey, user, 'EX', 300);
-}
-```
-
-### Lazy Loading
-
-```javascript
-// Before: load everything
-const allUsers = await db.users.findMany();
-
-// After: paginate
-const users = await db.users.findMany({
-  take: 20,
-  skip: page * 20
-});
-```
-
-### Connection Pooling
-
-```javascript
-// Before: new connection each time
-const client = new Client();
-await client.connect();
-
-// After: pool
-const pool = new Pool({ max: 20 });
-// Use pool.query() throughout
-```
-
----
-
-## Profiling Tools
-
-See references/profiling-tools.md for:
-
-### Node.js
-
-```bash
-# CPU profiling
-node --prof app.js
-
-# Memory
-node --inspect app.js  # Chrome DevTools
-
-# clinic.js
-npx clinic doctor -- node app.js
-```
-
-### Python
-
-```bash
-# cProfile
-python -m cProfile -o profile.prof app.py
-
-# view with: python -m cProfile -s cumulative app.py
-```
-
-### Go
-
-```bash
-# pprof
-go test -cpuprofile=cpu.prof
-go tool pprof cpu.prof
-
-# Web interface
-go tool pprof -http=:8080 cpu.prof
-```
-
----
-
-## Skill Loading
-
-- If optimization involves queries → load python-sqlalchemy or typescript-drizzle-orm
-- If memory issues → load for heap snapshots
-- If database → load appropriate database skill

package/skills/code-perf/references/common-bottlenecks.md

@@ -1,124 +0,0 @@
-# Common Performance Bottlenecks
-
-## N+1 Query Problem
-
-### Symptom
-Many database queries when one should suffice.
-
-### Diagnosis
-```sql
--- Enable query logging
--- See N+1 queries in logs
-```
-
-### Solution
-
-**Before:**
-```python
-for user in users:
-    print(user.profile.name)  # Each = query
-```
-
-**After:**
-```python
-# Eager load
-users = db.query(users).options(joinedload(User.profile)).all()
-
-# Or batch
-profiles = ProfileService.get_many([u.id for u in users])
-```
-
----
-
-## Memory Leaks
-
-### Symptom
-RSS grows over time, never回收es.
-
-### Diagnosis
-- Chrome DevTools Memory tab
-- heap snapshots before/after
-
-### Common Causes
-
-1. **Unclosed connections**
-2. **Growing caches** (no eviction)
-3. **Event listeners** (not removed)
-4. **Closures holding references**
-5. **Global variables**
-
-### Solution
-```javascript
-// Clear cache
-cache.clear();
-
-// Remove listener
-element.removeEventListener('click', handler);
-
-// Use weak refs
-const ref = new WeakRef(obj);
-```
-
----
-
-## Blocking I/O
-
-### Symptom
-Thread/process blocked, can't handle other requests.
-
-### Solution
-
-```javascript
-// Before: blocking
-const data = fs.readFileSync('file.txt');
-
-// After: async
-const data = await fs.promises.readFile('file.txt');
-```
-
----
-
-## Unnecessary Work
-
-### Symptom
-CPU high, doing redundant computation.
-
-### Examples
-
-1. **Validation twice** - in frontend and backend
-2. **Same calculation multiple times**
-3. **Processing data not needed**
-
-### Solution
-```javascript
-// Cache expensive computations
-const memoize = fn => {
-  const cache = new Map();
-  return (...args) => {
-    const key = JSON.stringify(args);
-    return cache.get(key) ?? fn(...args);
-  };
-};
-```
-
----
-
-## Large Data Serialization
-
-### Symptom
-Slow JSON serialization of large objects.
-
-### Solution
-
-```javascript
-// Pagination
-const page = req.query.page || 1;
-const limit = 20;
-const users = await db.users.findMany({
-  take: limit,
-  skip: (page - 1) * limit
-});
-
-// Streams for large files
-stream.pipe(JSON.stringify());
-```

package/skills/code-perf/references/optimization-patterns.md

@@ -1,167 +0,0 @@
-# Optimization Patterns
-
-## Caching
-
-### When
-- Same data requested multiple times
-- Expensive computation
-- External API calls
-
-### Patterns
-
-**In-memory:**
-```javascript
-const cache = new Map();
-
-async function getUser(id) {
-  if (cache.has(id)) return cache.get(id);
-  const user = await db.find(id);
-  cache.set(id, user);
-  return user;
-}
-```
-
-**With TTL:**
-```javascript
-function withTTL(cache, ttl) {
-  return {
-    get(key) {
-      const item = cache.get(key);
-      if (item && Date.now() - item.timestamp < ttl) {
-        return item.value;
-      }
-      return null;
-    },
-    set(key, value) {
-      cache.set(key, { value, timestamp: Date.now() });
-    }
-  };
-}
-```
-
-**Distributed (Redis):**
-```javascript
-async function getCached(key, fetcher, ttl = 300) {
-  const cached = await redis.get(key);
-  if (cached) return JSON.parse(cached);
-  
-  const value = await fetcher();
-  await redis.set(key, JSON.stringify(value), 'EX', ttl);
-  return value;
-}
-```
-
----
-
-## Lazy Loading
-
-### When
-- Large data sets
-- Heavy imports
-- Optional features
-
-### Patterns
-
-**Pagination:**
-```javascript
-async function getUsers(page = 1, limit = 20) {
-  return db.users.findMany({
-    take: limit,
-    skip: (page - 1) * limit,
-    orderBy: { createdAt: 'desc' }
-  });
-}
-```
-
-**Code splitting:**
-```javascript
-// Before: import everything
-import * as heavy from './heavy';
-
-// After: dynamic import
-const heavy = await import('./heavy');
-```
-
-**Virtual scrolling:**
-```javascript
-// Only render visible items
-<VirtualList items={users} height={400} itemHeight={40} />
-```
-
----
-
-## Connection Pooling
-
-### When
-- Database connections
-- HTTP clients
-- WebSocket connections
-
-### Patterns
-
-```javascript
-import { Pool } from 'pg';
-
-const pool = new Pool({
-  max: 20,
-  idleTimeoutMillis: 30000,
-  connectionTimeoutMillis: 2000,
-});
-
-// Use throughout
-const result = await pool.query('SELECT * FROM users');
-```
-
----
-
-## Batch Operations
-
-### When
-- Multiple inserts/updates
-- Multiple API calls
-
-### Patterns
-
-**Bulk insert:**
-```javascript
-// Before: N queries
-for (const item of items) {
-  await db.insert(item);
-}
-
-// After: 1 query
-await db.insertMany(items);
-```
-
-**Batch API calls:**
-```javascript
-// Use Promise.all with limit
-async function batch(items, fn, limit = 10) {
-  const results = [];
-  for (let i = 0; i < items.length; i += limit) {
-    const batch = items.slice(i, i + limit);
-    results.push(...await Promise.all(batch.map(fn)));
-  }
-  return results;
-}
-```
-
----
-
-## Memoization
-
-```javascript
-function memoize(fn) {
-  const cache = new Map();
-  return (...args) => {
-    const key = JSON.stringify(args);
-    if (cache.has(key)) return cache.get(key);
-    const result = fn(...args);
-    cache.set(key, result);
-    return result;
-  };
-}
-
-// Usage
-const fib = memoize(n => n <= 1 ? n : fib(n-1) + fib(n-2));
-```