cokit-cli 1.0.8 → 1.2.0

package/templates/repo/.github/skills/cook/README.md

@@ -0,0 +1,86 @@
+# Cook Skill
+
+End-to-end feature implementation with smart intent detection.
+
+## Installation
+
+Copy the `cook/` folder to your Claude skills directory:
+```bash
+cp -r cook ~/.copilot/skills/
+```
+
+## Usage
+
+```bash
+/cook <natural language task OR plan path>
+```
+
+The skill automatically detects your intent and routes to the appropriate workflow.
+
+## Examples
+
+```bash
+# Interactive mode (default)
+/cook implement user authentication
+
+# Execute existing plan
+/cook plans/260120-auth
+
+# Fast mode (skip research)
+/cook quick fix for login bug
+/cook implement feature --fast
+
+# Auto mode (trust me bro)
+/cook implement dashboard trust me
+/cook implement feature --auto
+
+# Parallel mode (multi-agent)
+/cook implement auth, payments, notifications
+/cook implement feature --parallel
+
+# No-test mode
+/cook implement feature --no-test
+```
+
+## Modes
+
+| Mode | Research | Testing | Review | Use Case |
+|------|----------|---------|--------|----------|
+| interactive | ✓ | ✓ | User approval | Default, full control |
+| auto | ✓ | ✓ | Auto if score≥9.5 | Trusted, hands-off |
+| fast | ✗ | ✓ | Simplified | Quick fixes |
+| parallel | Optional | ✓ | User approval | Multi-feature work |
+| no-test | ✓ | ✗ | User approval | Speed priority |
+| code | ✗ | ✓ | User approval | Existing plans |
+
+## Intent Detection
+
+The skill detects mode from:
+1. **Explicit flags:** `--fast`, `--auto`, `--parallel`, `--no-test`
+2. **Plan paths:** `./plans/*`, `plan.md`, `phase-*.md`
+3. **Keywords:** "fast", "quick", "trust me", "auto", "no test"
+4. **Feature count:** 3+ features → parallel mode
+
+## Workflow
+
+```
+[Intent Detection] → [Research?] → [Plan] → [Implement] → [Test?] → [Review] → [Finalize]
+```
+
+## Files
+
+```
+cook/
+├── SKILL.md                           # Main skill definition
+├── README.md                          # This file
+└── references/
+    ├── intent-detection.md            # Detection rules
+    ├── workflow-steps.md              # Step definitions
+    ├── review-cycle.md                # Review process
+    └── subagent-patterns.md           # Subagent usage
+```
+
+## Version
+
+2.1.0 - Review gates added for human-in-the-loop mode
+2.0.0 - Smart intent detection (hybrid approach)

package/templates/repo/.github/skills/cook/SKILL.md

@@ -0,0 +1,94 @@
+---
+name: cook
+description: ALWAYS activate this skill before implementing EVERY feature, plan, or fix.
+version: 2.1.0
+---
+
+# Cook - Smart Feature Implementation
+
+End-to-end implementation with automatic workflow detection.
+
+**Principles:** YAGNI, KISS, DRY | Token efficiency | Concise reports
+
+## Usage
+
+```
+/cook <natural language task OR plan path>
+```
+
+**Optional flags:** `--fast`, `--parallel`, `--no-test`, `--auto`
+
+Example:
+```
+/cook "Add user authentication to the app" --fast
+/cook path/to/plan.md --auto
+```
+
+## Smart Intent Detection
+
+| Input Pattern | Detected Mode | Behavior |
+|---------------|---------------|----------|
+| Path to `plan.md` or `phase-*.md` | code | Execute existing plan |
+| Contains "fast", "quick" | fast | Skip research, scout→plan→code |
+| Contains "trust me", "auto" | auto | Auto-approve all steps |
+| Lists 3+ features OR "parallel" | parallel | Multi-agent execution |
+| Contains "no test", "skip test" | no-test | Skip testing step |
+| Default | interactive | Full workflow with user input |
+
+See `references/intent-detection.md` for detection logic.
+
+## Workflow Overview
+
+```
+[Intent Detection] → [Research?] → [Review] → [Plan] → [Review] → [Implement] → [Review] → [Test?] → [Review] → [Finalize]
+```
+
+**Default (non-auto):** Stops at `[Review]` gates for human approval before each major step.
+**Auto mode (`--auto`):** Skips human review gates, implements all phases continuously.
+
+| Mode | Research | Testing | Review Gates | Phase Progression |
+|------|----------|---------|--------------|-------------------|
+| interactive | ✓ | ✓ | **User approval at each step** | One at a time |
+| auto | ✓ | ✓ | Auto if score≥9.5 | All at once (no stops) |
+| fast | ✗ | ✓ | User approval at each step | One at a time |
+| parallel | Optional | ✓ | User approval at each step | Parallel groups |
+| no-test | ✓ | ✗ | User approval at each step | One at a time |
+| code | ✗ | ✓ | User approval at each step | Per plan |
+
+## Step Output Format
+
+```
+✓ Step [N]: [Brief status] - [Key metrics]
+```
+
+## Blocking Gates (Non-Auto Mode)
+
+Human review required at these checkpoints (skipped with `--auto`):
+- **Post-Research:** Review findings before planning
+- **Post-Plan:** Approve plan before implementation
+- **Post-Implementation:** Approve code before testing
+- **Post-Testing:** 100% pass + approve before finalize
+
+**Always enforced (all modes):**
+- **Testing:** 100% pass required (unless no-test mode)
+- **Code Review:** User approval OR auto-approve (score≥9.5, 0 critical)
+- **Finalize:** project-manager AND docs-manager must complete
+
+## Required Subagents
+
+| Phase | Subagent |
+|-------|----------|
+| Research | `researcher` (parallel, optional in fast) |
+| Scout | `scout` |
+| Plan | `planner` |
+| UI Work | `ui-ux-designer` |
+| Testing | `tester`, `debugger` |
+| Review | `code-reviewer` |
+| Finalize | `project-manager`, `docs-manager`, `git-manager` |
+
+## References
+
+- `references/intent-detection.md` - Detection rules and routing logic
+- `references/workflow-steps.md` - Detailed step definitions for all modes
+- `references/review-cycle.md` - Interactive and auto review processes
+- `references/subagent-patterns.md` - Subagent invocation patterns

package/templates/repo/.github/skills/cook/references/intent-detection.md

@@ -0,0 +1,101 @@
+# Intent Detection Logic
+
+Detect user intent from natural language and route to appropriate workflow.
+
+## Detection Algorithm
+
+```
+FUNCTION detectMode(input):
+  # Priority 1: Explicit flags (override all)
+  IF input contains "--fast": RETURN "fast"
+  IF input contains "--parallel": RETURN "parallel"
+  IF input contains "--auto": RETURN "auto"
+  IF input contains "--no-test": RETURN "no-test"
+
+  # Priority 2: Plan path detection
+  IF input matches path pattern (./plans/*, plan.md, phase-*.md):
+    RETURN "code"
+
+  # Priority 3: Keyword detection (case-insensitive)
+  keywords = lowercase(input)
+
+  IF keywords contains ["fast", "quick", "rapidly", "asap"]:
+    RETURN "fast"
+
+  IF keywords contains ["trust me", "auto", "yolo", "just do it"]:
+    RETURN "auto"
+
+  IF keywords contains ["no test", "skip test", "without test"]:
+    RETURN "no-test"
+
+  # Priority 4: Complexity detection
+  features = extractFeatures(input)  # comma-separated or "and"-joined items
+  IF count(features) >= 3 OR keywords contains "parallel":
+    RETURN "parallel"
+
+  # Default: interactive workflow
+  RETURN "interactive"
+```
+
+## Feature Extraction
+
+Detect multiple features from natural language:
+
+```
+"implement auth, payments, and notifications" → ["auth", "payments", "notifications"]
+"add login + signup + password reset"        → ["login", "signup", "password reset"]
+"create dashboard with charts and tables"    → single feature (dashboard)
+```
+
+**Parallel trigger:** 3+ distinct features = parallel mode
+
+## Mode Behaviors
+
+| Mode | Skip Research | Skip Test | Review Gates | Auto-Approve | Parallel Exec |
+|------|---------------|-----------|--------------|--------------|---------------|
+| interactive | ✗ | ✗ | **Yes (stops)** | ✗ | ✗ |
+| auto | ✗ | ✗ | **No (skips)** | ✓ (score≥9.5) | ✓ (all phases) |
+| fast | ✓ | ✗ | Yes (stops) | ✗ | ✗ |
+| parallel | Optional | ✗ | Yes (stops) | ✗ | ✓ |
+| no-test | ✗ | ✓ | Yes (stops) | ✗ | ✗ |
+| code | ✓ | ✗ | Yes (stops) | Per plan | Per plan |
+
+**Review Gates:** Human approval checkpoints between major steps (see `workflow-steps.md`).
+- All modes EXCEPT `auto` stop at review gates for human approval.
+- `auto` mode is the only mode that runs continuously without stopping.
+
+## Examples
+
+```
+"/cook implement user auth"
+→ Mode: interactive (default, stops at review gates)
+
+"/cook plans/260120-auth/phase-02-api.md"
+→ Mode: code (path detected, stops at review gates)
+
+"/cook quick fix for the login bug"
+→ Mode: fast ("quick" keyword, stops at review gates)
+
+"/cook implement auth, payments, notifications, shipping"
+→ Mode: parallel (4 features, stops at review gates)
+
+"/cook implement dashboard --fast"
+→ Mode: fast (explicit flag, stops at review gates)
+
+"/cook implement everything --auto"
+→ Mode: auto (NO STOPS, implements all phases continuously)
+
+"/cook implement dashboard trust me"
+→ Mode: auto ("trust me" keyword, NO STOPS)
+```
+
+**Note:** Only `--auto` flag or "trust me"/"auto"/"yolo" keywords enable continuous execution.
+
+## Conflict Resolution
+
+When multiple signals detected, priority order:
+1. Explicit flags (`--fast`, `--auto`, etc.)
+2. Path detection (plan files)
+3. Keywords in text
+4. Feature count analysis
+5. Default (interactive)

package/templates/repo/.github/skills/cook/references/review-cycle.md

@@ -0,0 +1,75 @@
+# Code Review Cycle
+
+Interactive review-fix cycle used in code workflows.
+
+## Interactive Cycle (max 3 cycles)
+
+```
+cycle = 0
+LOOP:
+  1. Run code-reviewer → score, critical_count, warnings, suggestions
+
+  2. DISPLAY FINDINGS:
+     ┌─────────────────────────────────────────┐
+     │ Code Review Results: [score]/10         │
+     ├─────────────────────────────────────────┤
+     │ Summary: [what implemented], tests      │
+     │ [X/X passed]                            │
+     ├─────────────────────────────────────────┤
+     │ Critical Issues ([N]): MUST FIX         │
+     │  - [issue] at [file:line]               │
+     │ Warnings ([N]): SHOULD FIX              │
+     │  - [issue] at [file:line]               │
+     │ Suggestions ([N]): NICE TO HAVE         │
+     │  - [suggestion]                         │
+     └─────────────────────────────────────────┘
+
+  3. AskUserQuestion (header: "Review & Approve"):
+     IF critical_count > 0:
+       - "Fix critical issues" → fix, re-run tester, cycle++, LOOP
+       - "Fix all issues" → fix all, re-run tester, cycle++, LOOP
+       - "Approve anyway" → PROCEED
+       - "Abort" → stop
+     ELSE:
+       - "Approve" → PROCEED
+       - "Fix warnings/suggestions" → fix, cycle++, LOOP
+       - "Abort" → stop
+
+  4. IF cycle >= 3 AND user selects fix:
+     → "⚠ 3 review cycles completed. Final decision required."
+     → AskUserQuestion: "Approve with noted issues" / "Abort workflow"
+```
+
+## Auto-Handling Cycle (for auto modes)
+
+```
+cycle = 0
+LOOP:
+  1. Run code-reviewer → score, critical_count, warnings
+
+  2. IF score >= 9.5 AND critical_count == 0:
+     → Auto-approve, PROCEED
+
+  3. ELSE IF critical_count > 0 AND cycle < 3:
+     → Auto-fix critical issues
+     → Re-run tester
+     → cycle++, LOOP
+
+  4. ELSE IF critical_count > 0 AND cycle >= 3:
+     → ESCALATE TO USER
+
+  5. ELSE (no critical, score < 9.5):
+     → Approve with warnings logged, PROCEED
+```
+
+## Critical Issues Definition
+- Security: XSS, SQL injection, OWASP vulnerabilities
+- Performance: bottlenecks, inefficient algorithms
+- Architecture: violations of patterns, coupling
+- Principles: YAGNI, KISS, DRY violations
+
+## Output Formats
+- Waiting: `⏸ Step 4: Code reviewed - [score]/10 - WAITING for approval`
+- After fix: `✓ Step 4: [old]/10 → Fixed [N] issues → [new]/10 - Approved`
+- Auto-approved: `✓ Step 4: Code reviewed - 9.8/10 - Auto-approved`
+- Approved: `✓ Step 4: Code reviewed - [score]/10 - User approved`

package/templates/repo/.github/skills/cook/references/subagent-patterns.md

@@ -0,0 +1,75 @@
+# Subagent Patterns
+
+Standard patterns for spawning and using subagents in cook workflows.
+
+## Task Tool Pattern
+```
+Task(subagent_type="[type]", prompt="[task description]", description="[brief]")
+```
+
+## Research Phase
+```
+Task(subagent_type="researcher", prompt="Research [topic]. Report ≤150 lines.", description="Research [topic]")
+```
+- Use multiple researchers in parallel for different topics
+- Keep reports ≤150 lines with citations
+
+## Scout Phase
+```
+Task(subagent_type="scout", prompt="Find files related to [feature] in codebase", description="Scout [feature]")
+```
+- Use `/scout:ext` (preferred) or `/scout` (fallback)
+
+## Planning Phase
+```
+Task(subagent_type="planner", prompt="Create implementation plan based on reports: [reports]. Save to [path]", description="Plan [feature]")
+```
+- Input: researcher and scout reports
+- Output: `plan.md` + `phase-XX-*.md` files
+
+## UI Implementation
+```
+Task(subagent_type="ui-ux-designer", prompt="Implement [feature] UI per ./docs/design-guidelines.md", description="UI [feature]")
+```
+- For frontend work
+- Follow design guidelines
+
+## Testing
+```
+Task(subagent_type="tester", prompt="Run test suite for plan phase [phase-name]", description="Test [phase]")
+```
+- Must achieve 100% pass rate
+
+## Debugging
+```
+Task(subagent_type="debugger", prompt="Analyze failures: [details]", description="Debug [issue]")
+```
+- Use when tests fail
+- Provides root cause analysis
+
+## Code Review
+```
+Task(subagent_type="code-reviewer", prompt="Review changes for [phase]. Check security, performance, YAGNI/KISS/DRY. Return score (X/10), critical, warnings, suggestions.", description="Review [phase]")
+```
+
+## Project Management
+```
+Task(subagent_type="project-manager", prompt="Update plan status in [path]. Mark [phase] as DONE. Update roadmap.", description="Update plan")
+```
+
+## Documentation
+```
+Task(subagent_type="docs-manager", prompt="Update docs for [phase]. Changed files: [list]", description="Update docs")
+```
+
+## Git Operations
+```
+Task(subagent_type="git-manager", prompt="Stage and commit changes with conventional commit message", description="Commit changes")
+```
+
+## Parallel Execution
+```
+Task(subagent_type="fullstack-developer", prompt="Implement [phase-file] with file ownership: [files]", description="Implement phase [N]")
+```
+- Launch multiple for parallel phases
+- Include file ownership boundaries

package/templates/repo/.github/skills/cook/references/workflow-steps.md

@@ -0,0 +1,140 @@
+# Unified Workflow Steps
+
+All modes share core steps with mode-specific variations.
+
+## Step 0: Intent Detection & Setup
+
+1. Parse input with `intent-detection.md` rules
+2. Log detected mode: `✓ Step 0: Mode [X] - [reason]`
+3. If mode=code: detect plan path, set active plan
+4. Use TaskCreate to create workflow step tasks (with dependencies if complex)
+
+**Output:** `✓ Step 0: Mode [interactive|auto|fast|parallel|no-test|code] - [detection reason]`
+
+## Step 1: Research (skip if fast/code mode)
+
+**Interactive/Auto:**
+- Spawn multiple `researcher` agents in parallel
+- Use `/scout:ext` or `scout` agent for codebase search
+- Keep reports ≤150 lines
+
+**Parallel:**
+- Optional: max 2 researchers if complex
+
+**Output:** `✓ Step 1: Research complete - [N] reports gathered`
+
+### [Review Gate 1] Post-Research (skip if auto mode)
+- Present research summary to user
+- AskUserQuestion: "Proceed to planning?" / "Request more research" / "Abort"
+- **Auto mode:** Skip this gate
+
+## Step 2: Planning
+
+**Interactive/Auto/No-test:**
+- Use `planner` agent with research context
+- Create `plan.md` + `phase-XX-*.md` files
+
+**Fast:**
+- Use `/plan:fast` with scout results only
+- Minimal planning, focus on action
+
+**Parallel:**
+- Use `/plan:parallel` for dependency graph + file ownership matrix
+
+**Code:**
+- Skip - plan already exists
+- Parse existing plan for phases
+
+**Output:** `✓ Step 2: Plan created - [N] phases`
+
+### [Review Gate 2] Post-Plan (skip if auto mode)
+- Present plan overview with phases
+- AskUserQuestion: "Approve plan and start implementation?" / "Request revisions" / "Abort"
+- **Auto mode:** Skip this gate
+
+## Step 3: Implementation
+
+**All modes:**
+- Execute phase tasks sequentially (Step 3.1, 3.2, etc.)
+- Use `ui-ux-designer` for frontend
+- Use ImageMagick/FFmpeg CLI for image assets
+- Run type checking after each file
+
+**Parallel mode:**
+- Launch multiple `fullstack-developer` agents
+- Respect file ownership boundaries
+- Wait for parallel group before next
+
+**Output:** `✓ Step 3: Implemented [N] files - [X/Y] tasks complete`
+
+### [Review Gate 3] Post-Implementation (skip if auto mode)
+- Present implementation summary (files changed, key changes)
+- AskUserQuestion: "Proceed to testing?" / "Request implementation changes" / "Abort"
+- **Auto mode:** Skip this gate
+
+## Step 4: Testing (skip if no-test mode)
+
+**All modes (except no-test):**
+- Write tests: happy path, edge cases, errors
+- Use `tester` agent
+- If failures: `debugger` → fix → repeat
+- **Forbidden:** fake mocks, commented tests, changed assertions
+
+**Output:** `✓ Step 4: Tests [X/X passed]`
+
+### [Review Gate 4] Post-Testing (skip if auto mode)
+- Present test results summary
+- AskUserQuestion: "Proceed to code review?" / "Request test fixes" / "Abort"
+- **Auto mode:** Skip this gate
+
+## Step 5: Code Review
+
+**Interactive/Parallel/Code/No-test:**
+- Use `code-reviewer` agent
+- Interactive cycle (max 3): see `review-cycle.md`
+- Requires user approval
+
+**Auto:**
+- Auto-approve if score≥9.5 AND 0 critical
+- Auto-fix critical (max 3 cycles)
+- Escalate to user after 3 failed cycles
+
+**Fast:**
+- Simplified review, no fix loop
+- User approves or aborts
+
+**Output:** `✓ Step 5: Review [score]/10 - [Approved|Auto-approved]`
+
+## Step 6: Finalize
+
+**All modes:**
+1. `project-manager` + `docs-manager` subagents in parallel
+2. Onboarding check (API keys, env vars)
+3. Auto-commit via `git-manager` subagent
+
+**Auto mode:** Continue to next phase automatically
+**Others:** Ask user before next phase
+
+**Output:** `✓ Step 6: Finalized - Status updated - Committed`
+
+## Mode-Specific Flow Summary
+
+Legend: `[R]` = Review Gate (human approval required)
+
+```
+interactive: 0 → 1 → [R] → 2 → [R] → 3 → [R] → 4 → [R] → 5(user) → 6
+auto:        0 → 1 → 2 → 3 → 4 → 5(auto) → 6 → next phase (NO stops)
+fast:        0 → skip → 2(fast) → [R] → 3 → [R] → 4 → [R] → 5(simple) → 6
+parallel:    0 → 1? → [R] → 2(parallel) → [R] → 3(multi-agent) → [R] → 4 → [R] → 5(user) → 6
+no-test:     0 → 1 → [R] → 2 → [R] → 3 → [R] → skip → 5(user) → 6
+code:        0 → skip → skip → 3 → [R] → 4 → [R] → 5(user) → 6
+```
+
+**Key difference:** `auto` mode is the ONLY mode that skips all review gates.
+
+## Critical Rules
+
+- Never skip steps without mode justification
+- Use TaskUpdate to mark tasks complete immediately
+- One task in_progress at a time (enforce via TaskList check)
+- All step outputs follow format: `✓ Step [N]: [status] - [metrics]`

package/templates/repo/.github/skills/databases/SKILL.md

@@ -0,0 +1,112 @@
+---
+name: databases
+description: Design schemas, write queries for MongoDB, PostgreSQL, SQL Server. Use for database design, SQL/NoSQL queries, aggregation pipelines, indexes, migrations, replication, performance optimization, psql CLI, EF Core.
+license: MIT
+---
+
+# Databases Skill
+
+Unified guide for working with MongoDB (document-oriented) and PostgreSQL (relational) databases. Choose the right database for your use case and master both systems.
+
+## When to Use This Skill
+
+Use when:
+- Designing database schemas and data models
+- Writing queries (SQL or MongoDB query language)
+- Building aggregation pipelines or complex joins
+- Optimizing indexes and query performance
+- Implementing database migrations
+- Setting up replication, sharding, or clustering
+- Configuring backups and disaster recovery
+- Managing database users and permissions
+- Analyzing slow queries and performance issues
+- Administering production database deployments
+
+## Reference Navigation
+
+### Database Design
+- **[db-design.md](references/db-design.md)** - Activate when user requests: Database/table design for transactional (OLTP), analytics (OLAP), create or extend schema, design fact/dimension tables, analyze/review CSV/JSON/SQL files to create tables, or need advice on data storage structure.
+
+### MongoDB References
+- **[mongodb-crud.md](references/mongodb-crud.md)** - CRUD operations, query operators, atomic updates
+- **[mongodb-aggregation.md](references/mongodb-aggregation.md)** - Aggregation pipeline, stages, operators, patterns
+- **[mongodb-indexing.md](references/mongodb-indexing.md)** - Index types, compound indexes, performance optimization
+- **[mongodb-atlas.md](references/mongodb-atlas.md)** - Atlas cloud setup, clusters, monitoring, search
+
+### PostgreSQL References
+- **[postgresql-queries.md](references/postgresql-queries.md)** - SELECT, JOINs, subqueries, CTEs, window functions
+- **[postgresql-psql-cli.md](references/postgresql-psql-cli.md)** - psql commands, meta-commands, scripting
+- **[postgresql-performance.md](references/postgresql-performance.md)** - EXPLAIN, query optimization, vacuum, indexes
+- **[postgresql-administration.md](references/postgresql-administration.md)** - User management, backups, replication, maintenance
+
+## Python Utilities
+
+Database utility scripts in `scripts/`:
+- **db_migrate.py** - Generate and apply migrations for both databases (MongoDB and PostgreSQL)
+- **db_backup.py** - Backup and restore MongoDB and PostgreSQL
+- **db_performance_check.py** - Analyze slow queries and recommend indexes
+
+```bash
+# Generate migration
+python scripts/db_migrate.py --db mongodb --generate "add_user_index"
+
+# Run backup
+python scripts/db_backup.py --db postgres --output /backups/
+
+# Check performance
+python scripts/db_performance_check.py --db mongodb --threshold 100ms
+```
+
+## Best Practices
+
+**MongoDB:**
+- Use embedded documents for 1-to-few relationships
+- Reference documents for 1-to-many or many-to-many
+- Index frequently queried fields
+- Use aggregation pipeline for complex transformations
+- Enable authentication and TLS in production
+- Use Atlas for managed hosting
+
+**PostgreSQL:**
+- Normalize schema to 3NF, denormalize for performance
+- Use foreign keys for referential integrity
+- Index foreign keys and frequently filtered columns
+- Use EXPLAIN ANALYZE to optimize queries
+- Regular VACUUM and ANALYZE maintenance
+- Connection pooling (pgBouncer) for web apps
+
+## .NET / Entity Framework Core
+
+For .NET projects, use Entity Framework Core with PostgreSQL or SQL Server:
+
+```csharp
+// DbContext configuration
+public class AppDbContext : DbContext
+{
+    public DbSet<User> Users => Set<User>();
+    public DbSet<Post> Posts => Set<Post>();
+
+    protected override void OnConfiguring(DbContextOptionsBuilder options)
+        => options.UseNpgsql("Host=localhost;Database=mydb;Username=user;Password=pass");
+        // Or: options.UseSqlServer(connectionString);
+}
+
+// Migrations
+// dotnet ef migrations add InitialCreate
+// dotnet ef database update
+
+// Query with LINQ
+var activeUsers = await _context.Users
+    .Where(u => u.IsActive)
+    .Include(u => u.Posts)
+    .ToListAsync();
+```
+
+## Resources
+
+- MongoDB: https://www.mongodb.com/docs/
+- PostgreSQL: https://www.postgresql.org/docs/
+- SQL Server: https://learn.microsoft.com/sql/
+- Entity Framework Core: https://learn.microsoft.com/ef/core/
+- MongoDB University: https://learn.mongodb.com/
+- PostgreSQL Tutorial: https://www.postgresqltutorial.com/