cast-code 1.0.0

package/dist/modules/skills/definitions/general/file-operations.md

@@ -0,0 +1,60 @@
+---
+name: file-operations
+description: Read, write, and edit files in the filesystem
+tools:
+  - read_file
+  - write_file
+  - edit_file
+  - glob
+  - ls
+---
+
+# File Operations — Domain Knowledge
+
+This skill teaches you how to work with files effectively. Study this to learn patterns, avoid mistakes, and make better decisions.
+
+## Core Principle: Read → Understand → Edit → Verify
+
+Every file operation follows this cycle. NEVER skip steps.
+
+## Tool Mastery
+
+### read_file
+- **When**: Before ANY edit, to answer questions, to verify changes
+- **Pattern**: Read the whole file first, then specific sections with offset/limit for large files
+- **Anti-pattern**: Reading 5 lines of a 500-line file and guessing the rest
+
+### write_file
+- **When**: Creating NEW files only. Never for existing files.
+- **Anti-pattern**: Using write_file on existing files (overwrites everything — use edit_file)
+
+### edit_file
+- **When**: Modifying existing files with precise string replacement
+- **Critical**: The `old_string` must be UNIQUE in the file. Include 2-3 surrounding lines for uniqueness.
+- **Anti-pattern**: Providing just `const x = 1` when there are 5 similar lines
+- **Tip**: Use `replace_all=true` ONLY when renaming across the entire file
+
+### glob
+- **When**: Finding files by name pattern. Always the FIRST step in discovery.
+- **Key patterns**: `**/*.ts`, `src/**/*.service.ts`, `*.{js,ts,jsx,tsx}`
+
+### ls
+- **When**: Quick directory overview, understanding project structure
+
+## Decision Framework
+
+| Situation | Tool | Why |
+|-----------|------|-----|
+| What's in this file? | read_file | Direct content access |
+| Find all test files | glob `**/*.test.ts` | Pattern matching |
+| Fix this line | read_file → edit_file | Must read first |
+| Create a new util | write_file | New file creation |
+| Find where X is defined | glob → grep → read_file | Progressive narrowing |
+
+## Common Mistakes
+
+1. **Editing without reading** — You WILL get the old_string wrong
+2. **Assuming file structure** — Always verify with ls or glob first
+3. **Overwriting with write_file** — Use edit_file for existing files
+4. **Non-unique old_string** — Add more context lines to make it unique
+5. **Not verifying after edit** — Always re-read to confirm changes

package/dist/modules/skills/definitions/general/git-operations.md

@@ -0,0 +1,59 @@
+---
+name: git-operations
+description: Git version control operations
+tools:
+  - shell
+---
+
+# Git Operations — Domain Knowledge
+
+This skill teaches you how to work with Git safely and effectively. Study this to learn safe workflows, commit conventions, and recovery techniques.
+
+## Core Principle: Check → Stage → Commit → Verify
+
+Always know the state before changing it.
+
+## Safe Workflow
+
+```
+1. git status                    # What's the current state?
+2. git diff                      # What exactly changed?
+3. git add <specific files>      # Stage only what's needed
+4. git diff --staged             # Verify what's being committed
+5. git commit -m "clear message" # Commit with intent
+6. git status                    # Verify clean state
+```
+
+## Commit Message Convention
+
+Types: feat, fix, refactor, docs, test, chore, style, perf
+Rule: First line < 50 chars, imperative mood ("Add feature" not "Added feature")
+
+## DANGER ZONE — Commands That Need User Confirmation
+
+| Command | Risk |
+|---------|------|
+| `git push --force` | Overwrites remote history |
+| `git reset --hard` | Destroys local changes |
+| `git clean -f` | Deletes untracked files |
+| `git branch -D` | Force-deletes a branch |
+| `git checkout .` | Discards all unstaged changes |
+
+## Safe Commands (No Confirmation Needed)
+
+- `git status`, `git log`, `git diff`, `git branch`
+- `git add <specific_file>` (not `git add -A`)
+- `git commit -m "message"` (with proper message)
+- `git stash` / `git stash pop`
+- `git fetch`
+
+## Recovery Techniques
+
+| Problem | Solution |
+|---------|----------|
+| Wrong commit message | `git commit --amend` (if not pushed) |
+| Committed wrong file | `git reset HEAD~1` (soft) → re-stage |
+| Need to undo last commit | `git reset --soft HEAD~1` |
+| Accidentally deleted file | `git checkout -- <file>` |
+| Find when bug introduced | `git bisect start` |
+| See who changed a line | `git blame <file>` |

package/dist/modules/skills/definitions/general/planning.md

@@ -0,0 +1,86 @@
+---
+name: planning
+description: Task planning and decomposition
+tools:
+  - read_file
+  - glob
+  - enter_plan_mode
+  - exit_plan_mode
+  - task_create
+  - task_update
+---
+
+# Planning — Domain Knowledge
+
+This skill teaches you how to plan complex work before executing it. Study this to learn when to plan, how to decompose tasks, and how to create actionable plans.
+
+## Core Principle: Think Before You Act
+
+The time you spend planning saves 5x the time you'd waste fixing mistakes.
+
+## When to Plan (Decision Framework)
+
+| Situation | Plan needed? | Why |
+|-----------|-------------|-----|
+| Fix a typo | No | Single, obvious change |
+| Add a function to existing file | No | Clear scope |
+| Add a new feature (3+ files) | **YES** | Multiple touchpoints |
+| Refactor a module | **YES** | Ripple effects |
+| Change an API contract | **YES** | Breaking changes possible |
+| Debug a complex bug | Maybe | Investigate first, plan the fix |
+| User says "implement X" where X is vague | **YES** | Need to clarify scope |
+
+## Planning Process
+
+### Phase 1: Discovery (BEFORE plan_mode)
+1. `glob` to understand project structure
+2. `read_file` key files (entry points, configs, relevant modules)
+3. `grep` to find related code and patterns
+4. Identify ALL files that will be touched
+
+### Phase 2: Plan (IN plan_mode)
+1. `enter_plan_mode` — signals you're planning, not executing
+2. List every file to create/modify with specific changes
+3. Order by dependency (don't modify callers before callees)
+4. Identify risks and edge cases
+5. Define verification steps
+6. `exit_plan_mode` — present plan for user approval
+
+### Phase 3: Execute (AFTER approval)
+1. Create tasks with `task_create` for each step
+2. Execute sequentially, marking tasks complete
+3. Verify after each step
+4. Run tests at the end
+
+## Plan Template
+
+```markdown
+## Goal
+[What we're achieving]
+
+## Changes
+1. **file1.ts** — [what changes and why]
+2. **file2.ts** — [what changes and why]
+
+## Order of Operations
+1. First: [foundation changes]
+2. Then: [dependent changes]
+3. Finally: [verification]
+
+## Risks
+- [What could go wrong and mitigation]
+```
+
+## Task Decomposition Rules
+
+### Good tasks are:
+- **Specific**: "Add validateEmail function to utils/validation.ts"
+- **Independent**: Can be verified in isolation when possible
+- **Small**: 1-2 file changes per task
+- **Ordered**: Dependencies are explicit
+
+### Anti-patterns:
+- "Implement everything" (too vague)
+- "Fix the code" (what code? what fix?)
+- Tasks that can't be verified
+- Skipping the planning step for complex work

package/dist/modules/skills/definitions/general/search.md

@@ -0,0 +1,59 @@
+---
+name: search
+description: Search for patterns and content in the codebase
+tools:
+  - grep
+  - glob
+---
+
+# Search — Domain Knowledge
+
+This skill teaches you how to find anything in a codebase efficiently. Study this to learn search strategies and progressive narrowing techniques.
+
+## Core Principle: Broad → Narrow → Precise
+
+Never start with a narrow search. Cast a wide net first, then refine.
+
+## Search Strategy Matrix
+
+| I need to find... | First try | Fallback |
+|-------------------|-----------|----------|
+| A file by name | `glob **/*filename*` | `glob **/*.ext` |
+| A function definition | `grep "function name\|const name"` | Per-file type search |
+| Where X is used | `grep "X"` files_with_matches | `grep "import.*X"` |
+| A config value | `glob **/*.{json,yaml,toml,env}` | `grep "KEY_NAME"` |
+| Dead code | `grep "export.*FuncName"` then `grep "FuncName"` (compare counts) | |
+
+## Regex Patterns Every Developer Needs
+
+### Finding Definitions
+- `class\s+ClassName` — Class definition
+- `function\s+funcName` — Function declaration
+- `const\s+funcName\s*=` — Arrow function
+- `interface\s+InterfaceName` — TypeScript interface
+- `export\s+(default\s+)?` — Exports
+
+### Finding Usage
+- `import.*{.*Name.*}.*from` — Named imports
+- `new\s+ClassName` — Instantiation
+- `Name\(` — Function calls
+
+### Finding Problems
+- `TODO|FIXME|HACK|XXX` — Developer notes
+- `console\.(log|error|warn)` — Debug output
+- `\.catch\(\s*\)` — Empty catch blocks
+
+## Progressive Narrowing Technique
+
+1. **Discover**: `glob "**/*.ts"` → understand the file landscape
+2. **Locate**: `grep "pattern"` with `output_mode=files_with_matches` → find candidate files
+3. **Context**: `grep "pattern"` with `context_lines=5` on specific files → see surrounding code
+4. **Read**: `read_file` the most promising candidates → full understanding
+
+## Common Mistakes
+
+1. **Too specific too early** — Search for parts of the string, not the exact thing
+2. **Wrong file types** — Search `.ts` AND `.tsx` and `.js`
+3. **Case sensitivity** — Always consider case-insensitive first
+4. **Giving up after one miss** — Try synonyms, partial matches, different patterns
+5. **Not using context_lines** — A match without context is often useless

package/dist/modules/skills/definitions/specialized/api-design.md

@@ -0,0 +1,85 @@
+---
+name: api-design
+description: REST and GraphQL API design patterns
+tools:
+  - read_file
+  - write_file
+  - edit_file
+---
+
+# API Design — Domain Knowledge
+
+This skill teaches you how to design clean, consistent APIs. Study this to learn REST conventions, error handling patterns, and API best practices.
+
+## REST Conventions
+
+### HTTP Methods
+| Method | Purpose | Idempotent | Body |
+|--------|---------|------------|------|
+| GET | Read | Yes | No |
+| POST | Create | No | Yes |
+| PUT | Replace | Yes | Yes |
+| PATCH | Partial update | Yes | Yes |
+| DELETE | Remove | Yes | No |
+
+### URL Structure
+- `/users` — Collection (GET all, POST create)
+- `/users/:id` — Single resource (GET, PUT, PATCH, DELETE)
+- `/users/:id/posts` — Nested resource
+- Never: `/getUser`, `/createUser` (verbs in URLs)
+
+### Status Codes (Know These)
+| Code | Meaning | When |
+|------|---------|------|
+| 200 | OK | Successful GET, PUT, PATCH |
+| 201 | Created | Successful POST |
+| 204 | No Content | Successful DELETE |
+| 400 | Bad Request | Validation failure |
+| 401 | Unauthorized | Missing/invalid auth |
+| 403 | Forbidden | Valid auth, no permission |
+| 404 | Not Found | Resource doesn't exist |
+| 409 | Conflict | Duplicate, version mismatch |
+| 422 | Unprocessable | Valid syntax, invalid semantics |
+| 500 | Server Error | Unexpected failure |
+
+## Response Envelope Pattern
+
+```json
+{
+  "data": { ... },
+  "meta": { "page": 1, "totalPages": 10, "total": 100 },
+  "errors": []
+}
+```
+
+## Error Response Pattern
+
+```json
+{
+  "error": {
+    "code": "VALIDATION_FAILED",
+    "message": "Human-readable description",
+    "details": [
+      { "field": "email", "message": "Invalid format" }
+    ]
+  }
+}
+```
+
+## API Design Checklist
+
+1. **Consistent naming** — plural nouns, kebab-case
+2. **Pagination** — offset/limit or cursor-based for lists
+3. **Filtering** — query params: `?status=active&sort=-created`
+4. **Versioning** — URL path `/api/v1/` (simplest)
+5. **Auth** — Bearer token in Authorization header
+6. **Rate limiting** — Return 429 with Retry-After header
+7. **CORS** — Configure allowed origins explicitly
+
+## Common Mistakes
+
+1. **Verbs in URLs** — Use HTTP methods instead
+2. **Inconsistent response format** — Always same envelope
+3. **200 for errors** — Use proper status codes
+4. **No pagination** — Always paginate collections
+5. **Leaking internals** — Don't expose DB IDs or stack traces

package/dist/modules/skills/definitions/specialized/database-operations.md

@@ -0,0 +1,78 @@
+---
+name: database-operations
+description: Database design and query optimization
+tools:
+  - read_file
+  - write_file
+  - edit_file
+  - shell
+---
+
+# Database Operations — Domain Knowledge
+
+This skill teaches you database design, query optimization, and safe migration practices. Study this to make good data modeling decisions.
+
+## Schema Design Principles
+
+### Normalization Rules
+- **1NF**: Atomic values, no repeating groups
+- **2NF**: No partial dependencies on composite keys
+- **3NF**: No transitive dependencies
+
+### When to Denormalize
+| Situation | Denormalize? | Technique |
+|-----------|-------------|-----------|
+| Read-heavy, write-rare | Yes | Materialized view / computed column |
+| Reporting/analytics | Yes | Star schema / denormalized table |
+| Real-time dashboard | Yes | Pre-aggregated cache |
+| OLTP with consistency needs | No | Keep normalized |
+
+## Query Optimization
+
+### Indexing Decision Framework
+| Query pattern | Index type |
+|---------------|------------|
+| `WHERE col = value` | B-tree index on col |
+| `WHERE col1 = X AND col2 = Y` | Composite index (col1, col2) |
+| `WHERE col LIKE 'prefix%'` | B-tree (prefix only) |
+| `ORDER BY col` | Index on col |
+| `WHERE col IN (...)` | B-tree index on col |
+| Full-text search | GIN / Full-text index |
+
+### Performance Diagnosis
+1. `EXPLAIN ANALYZE` the slow query
+2. Look for: Seq Scan (missing index), Nested Loop (N+1), Sort (missing index)
+3. Add index → re-explain → verify improvement
+
+### Common Performance Issues
+| Problem | Symptom | Fix |
+|---------|---------|-----|
+| N+1 queries | Many identical queries | Eager loading / JOIN |
+| Missing index | Seq Scan on large table | Add appropriate index |
+| Over-fetching | SELECT * on wide table | Select specific columns |
+| Lock contention | Timeout errors | Shorter transactions |
+
+## Migration Safety
+
+### Safe Operations (can run anytime)
+- Add nullable column
+- Add index CONCURRENTLY
+- Create new table
+- Add constraint with NOT VALID
+
+### Dangerous Operations (need careful planning)
+| Operation | Risk | Safe approach |
+|-----------|------|---------------|
+| Drop column | Data loss | Deploy code first, drop later |
+| Rename column | Breaks queries | Add new, migrate, drop old |
+| Change type | Data corruption | Add new column, backfill, swap |
+| Add NOT NULL | Fails on existing nulls | Backfill first, then constrain |
+
+## ORM vs Raw SQL
+
+| Use ORM when... | Use Raw SQL when... |
+|-----------------|---------------------|
+| Standard CRUD | Complex aggregations |
+| Migrations | Performance-critical queries |
+| Type safety needed | Database-specific features |
+| Rapid prototyping | Bulk operations |

package/dist/modules/skills/definitions/specialized/frontend-bootstrap.md

@@ -0,0 +1,71 @@
+---
+name: frontend-bootstrap
+description: Bootstrap full frontend projects from Figma and product requirements
+tools:
+  - read_file
+  - write_file
+  - edit_file
+  - glob
+  - grep
+  - ls
+  - shell
+---
+
+# Frontend Bootstrap from Figma
+
+Use this skill when the goal is to turn a prototype into a complete frontend foundation quickly.
+
+## Outcome Targets
+
+- Deliver a runnable frontend scaffold with routing, layout, and core pages.
+- Generate reusable UI primitives before page-specific components.
+- Apply consistent styling through design tokens and theme variables.
+- Keep architecture ready for backend integration.
+
+## Figma-to-Code Workflow
+
+1. Map screens and flows:
+- Identify all top-level screens in the prototype.
+- Capture navigation structure and page hierarchy.
+- Note critical interaction states (loading, empty, error, success).
+
+2. Extract design system:
+- Color palette, typography scale, spacing scale, border radius, shadow set.
+- Component variants for button, input, select, table, modal, card, badge, tabs.
+- Breakpoints and responsive behavior.
+
+3. Plan project structure:
+- `src/app` or `src/pages` for routes/screens.
+- `src/components/ui` for primitives.
+- `src/components/features` for domain components.
+- `src/styles` for tokens/theme/global styles.
+- `src/lib` for utilities and configuration.
+
+4. Generate in layers:
+- First: tokens/theme + base layout + routes.
+- Second: UI primitives and variants.
+- Third: screen composition using primitives.
+- Fourth: stubs for API services and typed contracts.
+
+5. Validate consistency:
+- Verify token usage over hardcoded values.
+- Verify responsive layout across mobile/tablet/desktop.
+- Verify accessibility basics: semantic roles, labels, focus, contrast.
+
+## Heuristics for Common Elements
+
+- Table-heavy screens:
+  - Create reusable `DataTable` with column config, pagination, loading and empty states.
+- Form-heavy screens:
+  - Create form field wrappers with validation message and helper text support.
+- Modal-heavy flows:
+  - Standardize modal shell, close behavior, keyboard handling, and action footer.
+- Dashboard screens:
+  - Prioritize layout grid and card primitives before chart wiring.
+
+## Integration Readiness
+
+- Keep API and data fetching behind dedicated service/hooks layers.
+- Use mock data adapters initially to unblock UI.
+- Preserve clear boundaries so backend integration only replaces adapters and endpoints.
+

package/dist/modules/skills/definitions/specialized/react-patterns.md

@@ -0,0 +1,77 @@
+---
+name: react-patterns
+description: React component patterns and best practices
+tools:
+  - read_file
+  - write_file
+  - edit_file
+---
+
+# React Patterns — Domain Knowledge
+
+This skill teaches you React best practices, component architecture, and performance patterns. Study this to write idiomatic React code.
+
+## Component Architecture Decision Tree
+
+| Need | Pattern | Why |
+|------|---------|-----|
+| Simple display | Functional component | No state needed |
+| Local state | useState/useReducer | Component-level reactivity |
+| Shared state | Context + useContext | Cross-component without prop drilling |
+| Server data | React Query / SWR | Cache, refetch, loading states |
+| Side effects | useEffect with cleanup | Subscriptions, timers, API calls |
+| Reusable logic | Custom hooks | Extract and share behavior |
+
+## Component Patterns
+
+### Functional Components (always prefer)
+```tsx
+interface Props {
+  title: string;
+  onClick?: () => void;
+}
+
+export function MyComponent({ title, onClick }: Props) {
+  return <button onClick={onClick}>{title}</button>;
+}
+```
+
+### Custom Hooks (extract reusable logic)
+```tsx
+function useCounter(initial = 0) {
+  const [count, setCount] = useState(initial);
+  const increment = useCallback(() => setCount(c => c + 1), []);
+  return { count, increment };
+}
+```
+
+### Composition over Inheritance
+- Use `children` prop for flexible layouts
+- Use render props for shared behavior
+- Use compound components for related UI (Tabs/Tab, Select/Option)
+
+## Performance Rules
+
+| Problem | Solution | When |
+|---------|----------|------|
+| Expensive calc re-runs | `useMemo(() => calc, [deps])` | calc takes >1ms |
+| Callback causes re-render | `useCallback(fn, [deps])` | Passed to memoized child |
+| Component re-renders unnecessarily | `React.memo(Component)` | Props rarely change |
+| Large bundle | `React.lazy(() => import(...))` | Route-level splitting |
+| Long list | Virtualization (react-window) | 100+ items |
+
+## Anti-Patterns to Avoid
+
+1. **State for derived data** — Compute from existing state instead of storing separately
+2. **useEffect for transforms** — Transform during render, not in effects
+3. **Index as key** — Use stable IDs from data, not array index
+4. **Nested ternaries in JSX** — Extract to variables or early returns
+5. **Prop drilling 3+ levels** — Use Context or composition
+
+## Accessibility Checklist
+
+- Semantic HTML (`button` not `div onClick`)
+- ARIA labels for icon-only buttons
+- Keyboard navigation (Tab, Enter, Escape)
+- Focus management after modals/dialogs
+- Color contrast (4.5:1 minimum)

package/dist/modules/skills/definitions/specialized/testing-strategies.md

@@ -0,0 +1,79 @@
+---
+name: testing-strategies
+description: Testing patterns and strategies
+tools:
+  - read_file
+  - write_file
+  - edit_file
+  - shell
+---
+
+# Testing Strategies — Domain Knowledge
+
+This skill teaches you how to write effective tests. Study this to learn what to test, how to structure tests, and when to use different testing approaches.
+
+## Testing Pyramid
+
+| Level | Speed | Count | Coverage |
+|-------|-------|-------|----------|
+| Unit | Fast (ms) | Many | Functions, classes, utils |
+| Integration | Medium (s) | Moderate | API routes, DB queries, services |
+| E2E | Slow (s-min) | Few | Critical user flows only |
+
+## The AAA Pattern (ALWAYS follow this)
+
+```typescript
+test('should [behavior] when [condition]', () => {
+  // Arrange — set up the test
+  const calculator = new Calculator();
+
+  // Act — perform the action
+  const result = calculator.add(2, 3);
+
+  // Assert — verify the result
+  expect(result).toBe(5);
+});
+```
+
+## What to Test (Decision Framework)
+
+| Code type | Test approach | Priority |
+|-----------|---------------|----------|
+| Pure functions | Unit test with edge cases | HIGH |
+| API endpoints | Integration test with real DB | HIGH |
+| UI components | Render + interaction tests | MEDIUM |
+| Config/setup | Smoke test (does it load?) | LOW |
+| External APIs | Mock + contract test | MEDIUM |
+| Error paths | Unit test thrown errors | HIGH |
+
+## Test Naming Convention
+
+- `should [expected behavior] when [condition]`
+- `[method] returns [result] for [input]`
+- `throws [error] when [invalid input]`
+
+## Mocking Rules
+
+| Mock when... | Don't mock when... |
+|-------------|-------------------|
+| External API calls | Core business logic |
+| Database in unit tests | Database in integration tests |
+| Time (Date.now, timers) | Simple utility functions |
+| Random values | Data transformations |
+| File system in CI | File system in integration |
+
+## Running Tests
+
+- `npm test` or `npx jest` — run all tests
+- `npm test -- --watch` — watch mode
+- `npm test -- --coverage` — coverage report
+- `npm test -- path/to/file` — run specific file
+- `npx jest --testPathPattern="pattern"` — filter by pattern
+
+## Common Mistakes
+
+1. **Testing implementation, not behavior** — Test WHAT it does, not HOW
+2. **Shared mutable state between tests** — Reset in beforeEach
+3. **Not testing error cases** — Happy path + error paths
+4. **Brittle snapshot tests** — Only snapshot stable, small components
+5. **Skipping async cleanup** — Always await and clean up promises/timers

package/dist/modules/skills/index.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+_export_star(require("./skills.module"), exports);
+_export_star(require("./services/skill-loader.service"), exports);
+_export_star(require("./services/skill-registry.service"), exports);
+_export_star(require("./types"), exports);
+function _export_star(from, to) {
+    Object.keys(from).forEach(function(k) {
+        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
+            Object.defineProperty(to, k, {
+                enumerable: true,
+                get: function() {
+                    return from[k];
+                }
+            });
+        }
+    });
+    return from;
+}
+
+//# sourceMappingURL=index.js.map

package/dist/modules/skills/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/modules/skills/index.ts"],"sourcesContent":["export * from './skills.module';\nexport * from './services/skill-loader.service';\nexport * from './services/skill-registry.service';\nexport * from './types';\n"],"names":[],"mappings":";;;;qBAAc;qBACA;qBACA;qBACA"}