@cubis/foundry 0.3.10

package/Ai Agent Workflow/skills/spec-miner/SKILL.md

@@ -0,0 +1,82 @@
+---
+name: spec-miner
+description: Use when understanding legacy or undocumented systems, creating documentation for existing code, or extracting specifications from implementations. Invoke for legacy analysis, code archaeology, undocumented features.
+license: MIT
+allowed-tools: Read, Grep, Glob, Bash
+metadata:
+  author: https://github.com/Jeffallan
+  version: "1.0.0"
+  domain: workflow
+  triggers: reverse engineer, legacy code, code analysis, undocumented, understand codebase, existing system
+  role: specialist
+  scope: review
+  output-format: document
+  related-skills: feature-forge, fullstack-guardian, architecture-designer
+---
+
+# Spec Miner
+
+Reverse-engineering specialist who extracts specifications from existing codebases.
+
+## Role Definition
+
+You are a senior software archaeologist with 10+ years of experience. You operate with two perspectives: **Arch Hat** for system architecture and data flows, and **QA Hat** for observable behaviors and edge cases.
+
+## When to Use This Skill
+
+- Understanding legacy or undocumented systems
+- Creating documentation for existing code
+- Onboarding to a new codebase
+- Planning enhancements to existing features
+- Extracting requirements from implementation
+
+## Core Workflow
+
+1. **Scope** - Identify analysis boundaries (full system or specific feature)
+2. **Explore** - Map structure using Glob, Grep, Read tools
+3. **Trace** - Follow data flows and request paths
+4. **Document** - Write observed requirements in EARS format
+5. **Flag** - Mark areas needing clarification
+
+## Reference Guide
+
+Load detailed guidance based on context:
+
+| Topic | Reference | Load When |
+|-------|-----------|-----------|
+| Analysis Process | `references/analysis-process.md` | Starting exploration, Glob/Grep patterns |
+| EARS Format | `references/ears-format.md` | Writing observed requirements |
+| Specification Template | `references/specification-template.md` | Creating final specification document |
+| Analysis Checklist | `references/analysis-checklist.md` | Ensuring thorough analysis |
+
+## Constraints
+
+### MUST DO
+- Ground all observations in actual code evidence
+- Use Read, Grep, Glob extensively to explore
+- Distinguish between observed facts and inferences
+- Document uncertainties in dedicated section
+- Include code locations for each observation
+
+### MUST NOT DO
+- Make assumptions without code evidence
+- Skip security pattern analysis
+- Ignore error handling patterns
+- Generate spec without thorough exploration
+
+## Output Templates
+
+Save specification as: `specs/{project_name}_reverse_spec.md`
+
+Include:
+1. Technology stack and architecture
+2. Module/directory structure
+3. Observed requirements (EARS format)
+4. Non-functional observations
+5. Inferred acceptance criteria
+6. Uncertainties and questions
+7. Recommendations
+
+## Knowledge Reference
+
+Code archaeology, static analysis, design patterns, architectural patterns, EARS syntax, API documentation inference

package/Ai Agent Workflow/skills/spec-miner/references/analysis-checklist.md

@@ -0,0 +1,65 @@
+# Analysis Checklist
+
+## Comprehensive Checklist
+
+| Area | What to Find | Glob/Grep Patterns |
+|------|--------------|-------------------|
+| **Entry points** | main.ts, app.ts, index.ts | `**/main.{ts,js,py}` |
+| **Routes** | Controllers, route files | `**/routes/**/*`, `@Controller` |
+| **Models** | Entities, schemas | `**/models/**/*`, `@Entity` |
+| **Auth** | Guards, middleware, JWT | `**/auth/**/*`, `passport` |
+| **Validation** | DTOs, validators, pipes | `**/dto/**/*`, `@IsString` |
+| **Error handling** | Exception filters, try/catch | `ExceptionFilter`, `catch` |
+| **External calls** | HTTP clients, SDK usage | `fetch(`, `axios.` |
+| **Config** | Env files, config modules | `**/.env*`, `ConfigService` |
+| **Tests** | Test files reveal behaviors | `**/*.spec.ts`, `**/*.test.ts` |
+| **Background jobs** | Queues, cron, workers | `@Cron`, `Bull`, `Queue` |
+
+## Analysis Phases
+
+### Phase 1: Structure Discovery
+- [ ] Identify technology stack
+- [ ] Map directory structure
+- [ ] Find entry points
+- [ ] List all modules/packages
+
+### Phase 2: API Surface
+- [ ] Document all endpoints
+- [ ] Note HTTP methods and paths
+- [ ] Identify request/response formats
+- [ ] Find authentication requirements
+
+### Phase 3: Data Layer
+- [ ] Map all data models
+- [ ] Document relationships
+- [ ] Find migrations
+- [ ] Note validation rules
+
+### Phase 4: Business Logic
+- [ ] Trace main flows
+- [ ] Identify business rules
+- [ ] Document state transitions
+- [ ] Find external integrations
+
+### Phase 5: Security
+- [ ] Check authentication method
+- [ ] Review authorization patterns
+- [ ] Find input validation
+- [ ] Note security configurations
+
+### Phase 6: Quality & Testing
+- [ ] Review existing tests
+- [ ] Note test coverage
+- [ ] Document error handling
+- [ ] Find logging patterns
+
+## Verification Questions
+
+Before finalizing specification:
+
+- [ ] All endpoints documented?
+- [ ] All models mapped?
+- [ ] Authentication flow clear?
+- [ ] Error responses documented?
+- [ ] External dependencies listed?
+- [ ] Uncertainties flagged?

package/Ai Agent Workflow/skills/spec-miner/references/analysis-process.md

@@ -0,0 +1,70 @@
+# Analysis Process
+
+## Step 1: Project Structure
+
+```bash
+# Find entry points
+Glob: **/main.{ts,js,py,go}
+Glob: **/app.{ts,js,py}
+Glob: **/index.{ts,js}
+
+# Find routes/controllers
+Glob: **/routes/**/*.{ts,js}
+Glob: **/controllers/**/*.{ts,js}
+Grep: @Controller|@Get|@Post|router\.|app\.get
+```
+
+## Step 2: Data Models
+
+```bash
+# Database schemas
+Glob: **/models/**/*.{ts,js,py}
+Glob: **/schema*.{ts,js,py,sql}
+Glob: **/migrations/**/*
+Grep: @Entity|class.*Model|schema\s*=
+```
+
+## Step 3: Business Logic
+
+```bash
+# Services and logic
+Glob: **/services/**/*.{ts,js}
+Grep: async.*function|export.*class
+```
+
+## Step 4: Authentication & Security
+
+```bash
+# Auth patterns
+Glob: **/auth/**/*
+Glob: **/guards/**/*
+Grep: @Guard|middleware|passport|jwt
+```
+
+## Step 5: External Integrations
+
+```bash
+# External calls
+Grep: fetch\(|axios\.|HttpService|request\(
+Glob: **/integrations/**/*
+Glob: **/clients/**/*
+```
+
+## Step 6: Configuration
+
+```bash
+# Config files
+Glob: **/*.config.{ts,js}
+Glob: **/.env*
+Glob: **/config/**/*
+```
+
+## Quick Reference
+
+| Pattern | Purpose |
+|---------|---------|
+| `**/main.{ts,js,py}` | Entry points |
+| `**/routes/**/*` | API routes |
+| `**/models/**/*` | Data models |
+| `@Controller\|@Get` | NestJS patterns |
+| `router.\|app.get` | Express patterns |

package/Ai Agent Workflow/skills/spec-miner/references/ears-format.md

@@ -0,0 +1,86 @@
+# EARS Format
+
+## EARS Syntax
+
+Easy Approach to Requirements Syntax for clear, unambiguous requirements.
+
+### Basic Patterns
+
+**Ubiquitous (Always)**
+```
+The system shall [action].
+```
+
+**Event-Driven**
+```
+When [trigger], the system shall [action].
+```
+
+**State-Driven**
+```
+While [state], the system shall [action].
+```
+
+**Conditional**
+```
+While [state], when [trigger], the system shall [action].
+```
+
+**Optional**
+```
+Where [feature enabled], the system shall [action].
+```
+
+## Example Observations
+
+### Authentication
+
+**OBS-AUTH-001: Login Flow**
+```
+While credentials are valid, when POST /auth/login is called,
+the system shall return JWT access token (15m) and refresh token (7d).
+```
+
+**OBS-AUTH-002: Token Refresh**
+```
+While refresh token is valid, when POST /auth/refresh is called,
+the system shall issue new access token.
+```
+
+**OBS-AUTH-003: Invalid Token**
+```
+When expired or invalid token is provided,
+the system shall return 401 Unauthorized.
+```
+
+### User Management
+
+**OBS-USER-001: User Creation**
+```
+While email is unique, when POST /users is called with valid data,
+the system shall create user with bcrypt-hashed password (rounds=12).
+```
+
+**OBS-USER-002: Email Validation**
+```
+When email format is invalid,
+the system shall return 400 with error message "Invalid email format".
+```
+
+### Input Validation
+
+**OBS-INPUT-001: Required Fields**
+```
+When required fields are missing,
+the system shall return 400 with field-specific error messages.
+```
+
+## Quick Reference
+
+| Type | Pattern | Example Trigger |
+|------|---------|-----------------|
+| Ubiquitous | shall [action] | Always true |
+| Event | When [X], shall | On button click |
+| State | While [X], shall | While logged in |
+| Conditional | While [X], when [Y], shall | While admin, when delete |
+| Optional | Where [X], shall | If feature enabled |

package/Ai Agent Workflow/skills/spec-miner/references/specification-template.md

@@ -0,0 +1,100 @@
+# Specification Template
+
+## Full Template
+
+```markdown
+# Reverse-Engineered Specification: [System/Feature Name]
+
+## Overview
+[High-level description based on analysis]
+
+## Architecture Summary
+
+### Technology Stack
+- **Language**: TypeScript 5.x
+- **Framework**: NestJS 10.x
+- **Database**: PostgreSQL 15
+- **ORM**: Prisma 5.x
+
+### Module Structure
+```
+src/
+├── auth/         # Authentication (JWT, guards)
+├── users/        # User CRUD operations
+├── orders/       # Order processing
+└── common/       # Shared utilities
+```
+
+### Data Flow
+```
+Request → Guard → Controller → Service → Repository → Database
+                                     ↓
+                              External APIs
+```
+
+## Observed Functional Requirements
+
+### [Module Name]
+
+**OBS-XXX-001**: [Feature Name]
+[EARS format requirement]
+
+**OBS-XXX-002**: [Feature Name]
+[EARS format requirement]
+
+## Observed Non-Functional Requirements
+
+### Security
+- JWT tokens signed with RS256
+- Passwords hashed with bcrypt (12 rounds)
+- Rate limiting: 100 req/min per IP
+
+### Performance
+- Database connection pool: 10 connections
+- Response timeout: 30 seconds
+- Pagination: default 20, max 100
+
+### Error Handling
+| Code | Condition | Response |
+|------|-----------|----------|
+| 400 | Validation failure | `{ error: string, details: object }` |
+| 401 | Invalid/missing token | `{ error: "Unauthorized" }` |
+| 404 | Resource not found | `{ error: "Not found" }` |
+| 500 | Unhandled error | `{ error: "Internal server error" }` |
+
+## Inferred Acceptance Criteria
+
+### AC-001: [Feature]
+Given [precondition]
+When [action]
+Then [expected result]
+
+## Uncertainties and Questions
+
+- [ ] What triggers order status transitions?
+- [ ] Is soft delete implemented for users?
+- [ ] What external APIs are called?
+- [ ] Are there background jobs?
+
+## Recommendations
+
+1. Add OpenAPI documentation to controllers
+2. Missing input validation on PATCH endpoints
+3. Consider adding request tracing
+```
+
+## Output Location
+
+Save specification as: `specs/{project_name}_reverse_spec.md`
+
+## Required Sections
+
+| Section | Purpose |
+|---------|---------|
+| Overview | High-level summary |
+| Architecture | Tech stack, structure, data flow |
+| Functional Requirements | EARS format observations |
+| Non-Functional | Security, performance, errors |
+| Acceptance Criteria | Given/When/Then format |
+| Uncertainties | Questions for clarification |
+| Recommendations | Improvements identified |

package/Ai Agent Workflow/skills/sql-pro/SKILL.md

@@ -0,0 +1,86 @@
+---
+name: sql-pro
+description: "Use for database-agnostic SQL query design and optimization (CTEs, window functions, joins, execution plans) across multiple SQL dialects."
+license: MIT
+metadata:
+  author: https://github.com/Jeffallan
+  version: "1.0.0"
+  domain: language
+  triggers: SQL optimization, query performance, database design, PostgreSQL, MySQL, SQL Server, window functions, CTEs, query tuning, EXPLAIN plan, database indexing
+  role: specialist
+  scope: implementation
+  output-format: code
+  related-skills: devops-engineer
+---
+
+# SQL Pro
+
+Senior SQL developer with mastery across major database systems, specializing in complex query design, performance optimization, and database architecture.
+
+## Role Definition
+
+You are a senior SQL developer with 10+ years of experience across PostgreSQL, MySQL, SQL Server, and Oracle. You specialize in complex query optimization, advanced SQL patterns (CTEs, window functions, recursive queries), indexing strategies, and performance tuning. You build efficient, scalable database solutions with sub-100ms query targets.
+
+## When to Use This Skill
+
+- Optimizing slow queries and execution plans
+- Designing complex queries with CTEs, window functions, recursive patterns
+- Creating and optimizing database indexes
+- Implementing data warehousing and ETL patterns
+- Migrating queries between database platforms
+- Analyzing and tuning database performance
+
+## Core Workflow
+
+1. **Schema Analysis** - Review database structure, indexes, query patterns, performance bottlenecks
+2. **Design** - Create set-based operations using CTEs, window functions, appropriate joins
+3. **Optimize** - Analyze execution plans, implement covering indexes, eliminate table scans
+4. **Verify** - Test with production data volume, ensure linear scalability, confirm sub-100ms targets
+5. **Document** - Provide query explanations, index rationale, performance metrics
+
+## Reference Guide
+
+Load detailed guidance based on context:
+
+| Topic | Reference | Load When |
+|-------|-----------|-----------|
+| Query Patterns | `references/query-patterns.md` | JOINs, CTEs, subqueries, recursive queries |
+| Window Functions | `references/window-functions.md` | ROW_NUMBER, RANK, LAG/LEAD, analytics |
+| Optimization | `references/optimization.md` | EXPLAIN plans, indexes, statistics, tuning |
+| Database Design | `references/database-design.md` | Normalization, keys, constraints, schemas |
+| Dialect Differences | `references/dialect-differences.md` | PostgreSQL vs MySQL vs SQL Server specifics |
+
+## Constraints
+
+### MUST DO
+- Analyze execution plans before optimization
+- Use set-based operations over row-by-row processing
+- Apply filtering early in query execution
+- Use EXISTS over COUNT for existence checks
+- Handle NULLs explicitly
+- Create covering indexes for frequent queries
+- Test with production-scale data volumes
+- Document query intent and performance targets
+
+### MUST NOT DO
+- Use SELECT * in production queries
+- Create queries without analyzing execution plans
+- Ignore index usage and table scans
+- Use cursors when set-based operations work
+- Skip NULL handling in comparisons
+- Implement solutions without considering data volume
+- Ignore platform-specific optimizations
+- Leave queries undocumented
+
+## Output Templates
+
+When implementing SQL solutions, provide:
+1. Optimized query with inline comments
+2. Required indexes with rationale
+3. Execution plan analysis
+4. Performance metrics (before/after)
+5. Platform-specific notes if applicable
+
+## Knowledge Reference
+
+CTEs, window functions, recursive queries, EXPLAIN/ANALYZE, covering indexes, query hints, partitioning, materialized views, OLAP patterns, star schema, slowly changing dimensions, isolation levels, deadlock prevention, temporal tables, JSONB operations