@neyugn/agent-kits 0.1.0

package/kits/coder/skills/clean-code/scripts/lint_runner.py

@@ -0,0 +1,186 @@
+#!/usr/bin/env python3
+"""
+Lint Runner - Unified linting and type checking
+=================================================
+
+Auto-detects project type and runs appropriate linters.
+
+Usage:
+    python .agent/skills/clean-code/scripts/lint_runner.py <project_path>
+    python .agent/skills/clean-code/scripts/lint_runner.py . --fix
+
+Supports:
+    - Node.js: npm run lint, eslint, prettier, tsc --noEmit
+    - Python: ruff check, black --check, mypy
+"""
+
+import subprocess
+import sys
+import json
+import platform
+from pathlib import Path
+from datetime import datetime
+
+# Fix console encoding
+try:
+    sys.stdout.reconfigure(encoding='utf-8', errors='replace')
+except:
+    pass
+
+
+def detect_project_type(project_path: Path) -> dict:
+    """Detect project type and available linters."""
+    result = {"type": "unknown", "linters": []}
+    
+    # Node.js project
+    package_json = project_path / "package.json"
+    if package_json.exists():
+        result["type"] = "node"
+        try:
+            pkg = json.loads(package_json.read_text(encoding='utf-8'))
+            scripts = pkg.get("scripts", {})
+            deps = {**pkg.get("dependencies", {}), **pkg.get("devDependencies", {})}
+            
+            # Check for lint script
+            if "lint" in scripts:
+                result["linters"].append({"name": "npm lint", "cmd": ["npm", "run", "lint"]})
+            elif "eslint" in deps:
+                result["linters"].append({"name": "eslint", "cmd": ["npx", "eslint", "."]})
+            
+            # Check for TypeScript
+            if "typescript" in deps or (project_path / "tsconfig.json").exists():
+                result["linters"].append({"name": "tsc", "cmd": ["npx", "tsc", "--noEmit"]})
+            
+            # Check for Prettier
+            if "prettier" in deps or (project_path / ".prettierrc").exists():
+                result["linters"].append({"name": "prettier", "cmd": ["npx", "prettier", "--check", "."]})
+                
+        except:
+            pass
+    
+    # Python project
+    if (project_path / "pyproject.toml").exists() or (project_path / "requirements.txt").exists():
+        result["type"] = "python"
+        result["linters"].append({"name": "ruff", "cmd": ["ruff", "check", "."]})
+        
+        if (project_path / "mypy.ini").exists() or (project_path / "pyproject.toml").exists():
+            result["linters"].append({"name": "mypy", "cmd": ["mypy", "."]})
+    
+    return result
+
+
+def run_linter(linter: dict, cwd: Path) -> dict:
+    """Run a single linter and return results."""
+    result = {
+        "name": linter["name"],
+        "passed": False,
+        "output": "",
+        "error": ""
+    }
+    
+    try:
+        cmd = linter["cmd"]
+        
+        # Windows compatibility
+        if platform.system() == "Windows":
+            if cmd[0] in ["npm", "npx"]:
+                cmd[0] = f"{cmd[0]}.cmd"
+        
+        proc = subprocess.run(
+            cmd,
+            cwd=str(cwd),
+            capture_output=True,
+            text=True,
+            encoding='utf-8',
+            errors='replace',
+            timeout=120,
+            shell=platform.system() == "Windows"
+        )
+        
+        result["output"] = proc.stdout[:2000] if proc.stdout else ""
+        result["error"] = proc.stderr[:500] if proc.stderr else ""
+        result["passed"] = proc.returncode == 0
+        
+    except FileNotFoundError:
+        result["error"] = f"Command not found: {linter['cmd'][0]}"
+    except subprocess.TimeoutExpired:
+        result["error"] = "Timeout after 120s"
+    except Exception as e:
+        result["error"] = str(e)
+    
+    return result
+
+
+def main():
+    project_path = Path(sys.argv[1] if len(sys.argv) > 1 else ".").resolve()
+    fix_mode = "--fix" in sys.argv
+    
+    print(f"\n{'='*60}")
+    print(f"[AGT-KIT LINT RUNNER] Code Quality Check")
+    print(f"{'='*60}")
+    print(f"Project: {project_path}")
+    print(f"Time: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
+    print(f"Fix Mode: {fix_mode}")
+    
+    # Detect project type
+    project_info = detect_project_type(project_path)
+    print(f"Type: {project_info['type']}")
+    print(f"Linters: {len(project_info['linters'])}")
+    print("-"*60)
+    
+    if not project_info["linters"]:
+        print("No linters found for this project type.")
+        output = {
+            "script": "lint_runner",
+            "skill": "clean-code",
+            "project": str(project_path),
+            "type": project_info["type"],
+            "checks": [],
+            "passed": True,
+            "message": "No linters configured"
+        }
+        print(json.dumps(output, indent=2))
+        sys.exit(0)
+    
+    # Run each linter
+    results = []
+    all_passed = True
+    
+    for linter in project_info["linters"]:
+        print(f"\nRunning: {linter['name']}...")
+        result = run_linter(linter, project_path)
+        results.append(result)
+        
+        if result["passed"]:
+            print(f"  ✅ {linter['name']}: PASSED")
+        else:
+            print(f"  ❌ {linter['name']}: FAILED")
+            if result["error"]:
+                print(f"  Error: {result['error'][:200]}")
+            all_passed = False
+    
+    # Summary
+    print("\n" + "="*60)
+    print("SUMMARY")
+    print("="*60)
+    
+    for r in results:
+        icon = "✅" if r["passed"] else "❌"
+        print(f"{icon} {r['name']}")
+    
+    output = {
+        "script": "lint_runner",
+        "skill": "clean-code",
+        "project": str(project_path),
+        "type": project_info["type"],
+        "checks": results,
+        "passed": all_passed
+    }
+    
+    print("\n" + json.dumps(output, indent=2))
+    
+    sys.exit(0 if all_passed else 1)
+
+
+if __name__ == "__main__":
+    main()

package/kits/coder/skills/clean-code/scripts/validate.py

@@ -0,0 +1,56 @@
+#!/usr/bin/env python3
+"""
+Example validator for clean-code
+
+Usage:
+    python validate.py <project_path>
+"""
+
+import sys
+from pathlib import Path
+
+
+def validate(project_path: str) -> dict:
+    """Main validation logic"""
+    results = {
+        'errors': [],
+        'warnings': [],
+        'passed': []
+    }
+    
+    # TODO: Add validation logic
+    results['passed'].append('Placeholder validation passed')
+    
+    return results
+
+
+def print_results(results: dict):
+    """Pretty print results"""
+    print("\n🔍 Validation Results\n")
+    
+    if results['errors']:
+        print(f"❌ Errors ({len(results['errors'])})")
+        for error in results['errors']:
+            print(f"  - {error}")
+    
+    if results['warnings']:
+        print(f"\n⚠️  Warnings ({len(results['warnings'])})")
+        for warning in results['warnings']:
+            print(f"  - {warning}")
+    
+    if results['passed']:
+        print(f"\n✅ Passed ({len(results['passed'])})")
+        for passed in results['passed']:
+            print(f"  - {passed}")
+
+
+if __name__ == "__main__":
+    if len(sys.argv) < 2:
+        print("Usage: python validate.py <project_path>")
+        sys.exit(1)
+    
+    project_path = sys.argv[1]
+    results = validate(project_path)
+    print_results(results)
+    
+    sys.exit(1 if results['errors'] else 0)

package/kits/coder/skills/database-design/SKILL.md

@@ -0,0 +1,255 @@
+---
+name: database-design
+description: Database design principles and decision-making. Use when designing schemas, choosing databases, selecting ORMs, or optimizing queries. Covers schema design, indexing strategy, ORM selection, migrations.
+allowed-tools: Read, Write, Edit, Glob, Grep
+version: 2.0
+---
+
+# Database Design - Principles & Decision Making
+
+> **Philosophy:** Choose the right database and design for the context. Learn to THINK, not copy SQL patterns.
+
+---
+
+## Database Selection Decision Tree
+
+```
+What are your requirements?
+│
+├─ Simple app / Embedded / Edge?
+│  └─ → SQLite / Turso / LibSQL
+│
+├─ Full relational / Complex queries?
+│  └─ → PostgreSQL (self-hosted or managed)
+│
+├─ Serverless / Edge-first?
+│  └─ → Neon / PlanetScale / Turso
+│
+├─ Document-oriented / Flexible schema?
+│  └─ → MongoDB / Firestore
+│
+├─ Real-time updates required?
+│  └─ → Firebase / Supabase Realtime
+│
+├─ Time-series data?
+│  └─ → TimescaleDB / InfluxDB
+│
+└─ Graph relationships?
+   └─ → Neo4j / ArangoDB
+```
+
+---
+
+## Schema Design Principles
+
+### Normalization Levels
+
+| Level            | Description                        | Use Case              |
+| ---------------- | ---------------------------------- | --------------------- |
+| **1NF**          | Atomic values, no repeating groups | Always                |
+| **2NF**          | 1NF + no partial dependencies      | Standard apps         |
+| **3NF**          | 2NF + no transitive dependencies   | Most applications     |
+| **BCNF**         | Stronger 3NF                       | Complex schemas       |
+| **Denormalized** | Intentional redundancy             | Read-heavy, analytics |
+
+### When to Denormalize
+
+| Scenario                      | Consider Denormalization |
+| ----------------------------- | ------------------------ |
+| Frequent JOINs on same tables | ✅ Yes                   |
+| Read-heavy workload           | ✅ Yes                   |
+| Real-time analytics           | ✅ Yes                   |
+| Write-heavy workload          | ❌ No                    |
+| Data integrity critical       | ❌ No                    |
+
+---
+
+## Primary Key Selection
+
+| Strategy           | Pros               | Cons             | Best For        |
+| ------------------ | ------------------ | ---------------- | --------------- |
+| **Auto-increment** | Simple, sequential | Not distributed  | Single DB       |
+| **UUID v4**        | Globally unique    | Random, 36 chars | Distributed     |
+| **ULID**           | Sortable, unique   | 26 chars         | Time-ordered    |
+| **UUID v7**        | Sortable, unique   | Newer standard   | Modern apps     |
+| **Composite**      | Natural keys       | Complex JOINs    | Junction tables |
+
+**Recommendation:** Use UUID v7 or ULID for new projects (time-sortable + unique).
+
+---
+
+## Indexing Strategy
+
+### Index Types
+
+| Type          | Use Case                   | Example                    |
+| ------------- | -------------------------- | -------------------------- |
+| **B-Tree**    | Equality, range queries    | `WHERE status = 'active'`  |
+| **Hash**      | Exact match only           | `WHERE id = 123`           |
+| **GIN**       | Full-text, arrays, JSONB   | `WHERE tags @> ARRAY['a']` |
+| **GiST**      | Geometric, range types     | `WHERE location <@ box`    |
+| **Composite** | Multi-column queries       | `WHERE a = 1 AND b = 2`    |
+| **Partial**   | Subset of rows             | `WHERE deleted_at IS NULL` |
+| **Covering**  | Include all SELECT columns | Avoid table lookup         |
+
+### Indexing Rules
+
+| ✅ Index                 | ❌ Don't Index               |
+| ------------------------ | ---------------------------- |
+| WHERE clause columns     | Low cardinality (bool, enum) |
+| JOIN condition columns   | Frequently updated columns   |
+| ORDER BY columns         | Small tables (<1000 rows)    |
+| Foreign keys             | Columns rarely queried       |
+| High cardinality columns | Already indexed via PK       |
+
+### Composite Index Order
+
+```sql
+-- Query: WHERE a = 1 AND b = 2 ORDER BY c
+-- Index should be: (a, b, c)
+
+-- Rule: Equality → Range → Sort
+CREATE INDEX idx_example ON table (a, b, c);
+```
+
+---
+
+## ORM Selection
+
+| ORM            | Language   | Type Safety | Best For                |
+| -------------- | ---------- | ----------- | ----------------------- |
+| **Drizzle**    | TypeScript | ⭐⭐⭐      | Type-first, lightweight |
+| **Prisma**     | TypeScript | ⭐⭐⭐      | Full-featured, DX focus |
+| **Kysely**     | TypeScript | ⭐⭐⭐      | SQL-first, type-safe    |
+| **TypeORM**    | TypeScript | ⭐⭐        | Enterprise, decorators  |
+| **SQLAlchemy** | Python     | ⭐⭐⭐      | Full-featured, flexible |
+| **GORM**       | Go         | ⭐⭐        | Go standard             |
+| **Eloquent**   | PHP        | ⭐⭐        | Laravel ecosystem       |
+
+### ORM Decision Tree
+
+```
+TypeScript project?
+├─ Yes → Need raw SQL control?
+│  ├─ Yes → Kysely or Drizzle
+│  └─ No → Prisma
+│
+└─ No → Use language-native ORM
+   ├─ Python → SQLAlchemy
+   ├─ Go → GORM
+   └─ PHP → Eloquent
+```
+
+---
+
+## Query Optimization
+
+### N+1 Problem
+
+```typescript
+// ❌ N+1 Problem
+const users = await db.query("SELECT * FROM users");
+for (const user of users) {
+  user.posts = await db.query("SELECT * FROM posts WHERE user_id = ?", user.id);
+}
+
+// ✅ Eager Loading
+const users = await db.query(`
+  SELECT users.*, posts.*
+  FROM users
+  LEFT JOIN posts ON posts.user_id = users.id
+`);
+```
+
+### EXPLAIN ANALYZE
+
+```sql
+EXPLAIN ANALYZE SELECT * FROM users WHERE email = 'test@example.com';
+
+-- Look for:
+-- ❌ Seq Scan (full table scan)
+-- ✅ Index Scan (using index)
+-- ❌ High "actual time"
+-- ✅ Low "actual time"
+```
+
+---
+
+## Migration Best Practices
+
+### Safe Migrations
+
+| Operation     | Risk   | Safe Approach                                   |
+| ------------- | ------ | ----------------------------------------------- |
+| Add column    | Low    | Add nullable first, backfill, then set NOT NULL |
+| Drop column   | High   | Stop reading first, deploy, then drop           |
+| Rename column | High   | Add new, sync, drop old (multi-step)            |
+| Add index     | Medium | CREATE INDEX CONCURRENTLY                       |
+| Change type   | High   | Add new column, migrate, swap                   |
+
+### Migration Checklist
+
+- [ ] Tested on production-like data?
+- [ ] Backward compatible?
+- [ ] Rollback plan exists?
+- [ ] No locks on large tables?
+- [ ] Index created concurrently?
+
+---
+
+## Data Types Best Practices
+
+| Data       | ✅ Use          | ❌ Avoid                |
+| ---------- | --------------- | ----------------------- |
+| Money      | `DECIMAL(19,4)` | `FLOAT`, `DOUBLE`       |
+| Timestamps | `TIMESTAMPTZ`   | `TIMESTAMP` (no TZ)     |
+| Short text | `VARCHAR(n)`    | `TEXT` for small fields |
+| Long text  | `TEXT`          | `VARCHAR(10000)`        |
+| Boolean    | `BOOLEAN`       | `INT`, `CHAR(1)`        |
+| UUID       | `UUID` type     | `VARCHAR(36)`           |
+| JSON       | `JSONB`         | `JSON` (no indexing)    |
+
+---
+
+## Anti-Patterns
+
+| ❌ Don't                             | ✅ Do                    |
+| ------------------------------------ | ------------------------ |
+| Default to PostgreSQL for everything | Choose based on needs    |
+| Use `SELECT *` in production         | Select specific columns  |
+| Skip indexing                        | Index WHERE/JOIN columns |
+| Store structured data as JSON        | Use proper columns       |
+| Ignore N+1 queries                   | Use eager loading        |
+| Run migrations without testing       | Test on prod-like data   |
+| Store dates as strings               | Use proper DATE types    |
+| No foreign key constraints           | Define relationships     |
+
+---
+
+## Database Design Checklist
+
+Before implementation:
+
+- [ ] Identified write vs read patterns?
+- [ ] Chosen appropriate database type?
+- [ ] Designed normalized schema (3NF)?
+- [ ] Identified denormalization needs?
+- [ ] Selected primary key strategy?
+- [ ] Planned indexing strategy?
+- [ ] Chosen ORM for project?
+- [ ] Defined migration strategy?
+
+---
+
+## Related Skills
+
+| Need              | Skill                   |
+| ----------------- | ----------------------- |
+| API design        | `api-patterns`          |
+| Backend patterns  | `nodejs-best-practices` |
+| Query performance | `performance-profiling` |
+| Security          | `security-fundamentals` |
+
+---
+
+> **Remember:** The best database design is one that matches your access patterns. Design for how data is used, not just how it's stored.

package/kits/coder/skills/database-design/assets/.gitkeep

@@ -0,0 +1 @@
+# Assets directory - add templates, images, etc.

package/kits/coder/skills/database-design/references/deep-dive.md

@@ -0,0 +1,21 @@
+# Reference Documentation for Database Design
+
+[TODO: Add detailed reference content here]
+
+## Overview
+
+[Detailed explanation of concepts]
+
+## Deep Dive Topics
+
+### Topic 1
+
+[Content]
+
+### Topic 2
+
+[Content]
+
+## Examples
+
+[Real-world examples]