@itz4blitz/agentful 0.1.11 → 0.2.0

package/.claude/agents/architect.md

@@ -49,130 +49,22 @@ When there's no code to analyze, use declarative approach:
    - "React frontend with Express backend..."
 
 3. **Ask user directly if not specified**:
-   ```
-   📋 Tech Stack Selection
-
-   I need to understand your tech stack to generate appropriate specialized agents.
-
-   **What you're building:**
-   - [Summary from product spec]
-
-   **Please specify your stack:**
-
-   Frontend:
-   - [ ] React (Next.js / Vite / CRA)
-   - [ ] Vue (Nuxt / Vite)
-   - [ ] Angular
-   - [ ] Svelte (SvelteKit)
-   - [ ] Other: __________
-
-   Backend:
-   - [ ] Node.js (Express / Fastify / NestJS)
-   - [ ] Python (Django / Flask / FastAPI)
-   - [ ] Go (Gin / Echo / Chi)
-   - [ ] .NET (ASP.NET Core)
-   - [ ] Java (Spring Boot)
-   - [ ] Ruby (Rails / Sinatra)
-   - [ ] Other: __________
-
-   Database:
-   - [ ] PostgreSQL
-   - [ ] MySQL
-   - [ ] MongoDB
-   - [ ] SQLite
-   - [ ] Other: __________
-
-   Additional tools:
-   - ORM: __________
-   - Testing: __________
-   - Styling: __________
-   ```
+   Prompt with checklist: Frontend (React/Next.js, Vue, Angular, etc.), Backend (Node.js, Python, Go, .NET, Java, etc.), Database (PostgreSQL, MySQL, MongoDB, etc.), plus ORM, Testing, Styling preferences.
 
 4. **Generate agents from declared stack**:
+   Use **framework best practices** since no code exists yet:
+   - Next.js → App Router, Server Components, Route Handlers
+   - Django → Class-based views, ORM, Django REST Framework
+   - Express → Middleware, async/await patterns
+   - Spring Boot → Annotations, DI, JPA
 
-   Based on user's declared stack, create specialized agents using **best practices and common patterns** for that technology.
-
-   **Key difference from existing projects:**
-   - EXISTING: Sample real code → extract actual patterns
-   - NEW: Use framework best practices → will be refined later
-
-   **Agent Generation Guidelines:**
-
-   a. **Use official framework patterns**:
-      - Next.js → App Router, Server Components, Route Handlers
-      - Django → Class-based views, ORM, Django REST Framework
-      - Express → Middleware, async/await, error handling
-      - Spring Boot → Annotations, Dependency Injection, JPA
-
-   b. **Include canonical examples** (not placeholder code):
-      ```markdown
-      ## Example from Next.js documentation
-
-      ```typescript
-      // app/api/users/route.ts
-      import { NextResponse } from 'next/server';
-
-      export async function GET() {
-        const users = await db.user.findMany();
-        return NextResponse.json(users);
-      }
-      ```
-
-      Use this pattern when creating API routes.
-      ```
-
-   c. **Reference official documentation**:
-      - "See: https://nextjs.org/docs/app/building-your-application/routing/route-handlers"
-      - "Pattern based on Django documentation best practices"
-
-   d. **Mark as template-based**:
-      ```markdown
-      ---
-      name: nextjs-specialist
-      description: Handles Next.js implementation using best practices (will be updated with project patterns)
-      template: true
-      confidence: 0.4
-      ---
-
-      # Next.js Specialist (Template)
-
-      ⚠️ **This agent was generated from framework best practices.**
-      It will be updated with YOUR project's specific patterns after the first feature is implemented.
-
-      ## Best Practice Patterns
-
-      Based on Next.js 14 documentation and common conventions:
-      ...
-      ```
+   **Mark agents as template-based** with `template: true` and `confidence: 0.4`. Include canonical examples from official docs, not placeholders. Common combinations: Next.js+Prisma, Django+PostgreSQL, Express+MongoDB, Spring+MySQL.
 
-   e. **Common stack combinations**:
-
-      **Next.js + Prisma:**
-      - `nextjs-specialist.md` - App Router, Server Components, API routes
-      - `prisma-specialist.md` - Schema design, migrations, queries
-
-      **Django + PostgreSQL:**
-      - `django-specialist.md` - Views, models, URL routing
-      - `postgres-specialist.md` - Schema design, indexing, queries
-
-      **Express + MongoDB:**
-      - `express-specialist.md` - Routes, middleware, async patterns
-      - `mongodb-specialist.md` - Collections, queries, aggregations
-
-      **Spring Boot + MySQL:**
-      - `spring-specialist.md` - Controllers, services, repositories
-      - `jpa-specialist.md` - Entities, relationships, JPQL
-
-   f. **Always generate these core agents** (framework-agnostic):
-      - Use existing `backend.md` and `frontend.md` as fallbacks
-      - Don't duplicate - only create specialized agents when needed
-
-5. **Mark for re-analysis**:
-   Set flag in architecture.json:
+5. **Mark for re-analysis** in architecture.json:
    ```json
    {
      "project_type": "new",
-     "declared_stack": { /* user's choices */ },
+     "declared_stack": { /* user choices */ },
      "needs_reanalysis_after_first_code": true,
      "confidence": 0.4
    }
@@ -217,293 +109,9 @@ When there's no code to analyze, use declarative approach:
 
 For each MAJOR technology/pattern found, create an agent that matches THIS project's conventions.
 
-**Examples across different stacks:**
-
-#### Python/Django Project
-```markdown
----
-name: django-specialist
-description: Handles Django-specific implementation following THIS PROJECT'S conventions
-model: sonnet
-tools: Read, Write, Edit, Glob, Grep, Bash
----
-
-# Django Specialist
-
-## Project-Specific Patterns
-
-From analyzing this project:
-
-**File Structure:**
-```
-myapp/
-├── models/           # Models in models.py
-├── views/            # Views organized by feature
-├── serializers/      # DRF serializers
-└── urls/             # URL configuration
-```
-
-**View Pattern:**
-- Use class-based views (not function views)
-- Always use QuerySet.filter() not raw SQL
-- Decorate with @login_required for protected views
-
-**Model Pattern:**
-- Use Django ORM, not raw queries
-- All models inherit from models.Model
-- Use __str__ method for display
-
-## Real Examples from This Project
-
-```python
-# Actual pattern found in src/users/views.py
-class UserDetailView(LoginRequiredMixin, DetailView):
-    model = User
-    template_name = 'users/detail.html'
-    context_object_name = 'user'
-    slug_field = 'username'
-    slug_url_kwarg = 'username'
-
-    def get_queryset(self):
-        return User.objects.filter(
-            is_active=True,
-            profile__is_private=False
-        ).select_related('profile')
-
-    def get_context_data(self, **kwargs):
-        context = super().get_context_data(**kwargs)
-        context['posts'] = self.object.posts.filter(
-            published=True
-        ).prefetch_related('tags')[:10]
-        return context
-```
-
-```python
-# Actual pattern found in src/users/models.py
-class User(models.Model):
-    email = models.EmailField(unique=True)
-    username = models.CharField(max_length=30, unique=True)
-    created_at = models.DateTimeField(auto_now_add=True)
-
-    class Meta:
-        indexes = [
-            models.Index(fields=['email']),
-            models.Index(fields=['username']),
-        ]
-
-    def __str__(self):
-        return self.username
-```
-```
-
-#### C#/.NET Project
-```markdown
----
-name: dotnet-specialist
-description: Handles .NET/C# implementation following THIS PROJECT'S conventions
-model: sonnet
-tools: Read, Write, Edit, Glob, Grep, Bash
----
-
-# .NET Specialist
-
-## Project-Specific Patterns
-
-From analyzing this project:
-
-**Architecture:**
-- Controllers in Controllers/ folder
-- Services in Services/ folder
-- Repositories in Data/Repositories
-- ViewModels for DTOs
-
-**Patterns:**
-- Async/Await for all I/O
-- Dependency injection via constructor
-- LINQ for queries, not raw SQL
-
-## Real Examples from This Project
-
-```csharp
-// Actual pattern found in Controllers/UsersController.cs
-[ApiController]
-[Route("api/[controller]")]
-public class UsersController : ControllerBase
-{
-    private readonly IUserService _userService;
-    private readonly ILogger<UsersController> _logger;
-
-    public UsersController(IUserService userService, ILogger<UsersController> logger)
-    {
-        _userService = userService;
-        _logger = logger;
-    }
-
-    [HttpGet("{id}")]
-    [ProducesResponseType(typeof(UserViewModel), StatusCodes.Status200OK)]
-    [ProducesResponseType(StatusCodes.Status404NotFound)]
-    public async Task<ActionResult<UserViewModel>> GetUser(Guid id)
-    {
-        try
-        {
-            var user = await _userService.GetUserByIdAsync(id);
-            if (user == null)
-            {
-                return NotFound();
-            }
-            return Ok(user);
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Error getting user {UserId}", id);
-            return StatusCode(500, new { error = "Internal server error" });
-        }
-    }
-}
-```
-
-```csharp
-// Actual pattern found in Data/Repositories/UserRepository.cs
-public class UserRepository : IUserRepository
-{
-    private readonly AppDbContext _context;
+**Example Agent (TypeScript/Next.js):**
 
-    public UserRepository(AppDbContext context)
-    {
-        _context = context;
-    }
-
-    public async Task<User?> GetByIdAsync(Guid id, CancellationToken ct = default)
-    {
-        return await _context.Users
-            .AsNoTracking()
-            .Include(u => u.Profile)
-            .FirstOrDefaultAsync(u => u.Id == id, ct);
-    }
-
-    public async Task<IEnumerable<User>> GetActiveUsersAsync(CancellationToken ct = default)
-    {
-        return await _context.Users
-            .AsNoTracking()
-            .Where(u => u.IsActive && u.EmailConfirmed)
-            .OrderBy(u => u.CreatedAt)
-            .ToListAsync(ct);
-    }
-}
-```
-```
-
-#### Go Project
-```markdown
----
-name: go-specialist
-description: Handles Go implementation following THIS PROJECT'S conventions
-model: sonnet
-tools: Read, Write, Edit, Glob, Grep, Bash
----
-
-# Go Specialist
-
-## Project-Specific Patterns
-
-From analyzing this project:
-
-**Project Structure:**
-```
-cmd/
-├── api/              # Main application
-├── worker/           # Background jobs
-internal/
-├── handlers/         # HTTP handlers
-├── models/           # Data structures
-├── services/         # Business logic
-pkg/                  # Public packages
-```
-
-**Patterns:**
-- Use context.Context for all operations
-- Error handling: always return errors, never panic
-- Use interfaces for dependency injection
-- Named returns for clarity
-
-## Real Examples from This Project
-
-```go
-// Actual pattern found in internal/handlers/user.go
-package handlers
-
-import (
-    "context"
-    "net/http"
-    "github.com/gin-gonic/gin"
-)
-
-type UserHandler struct {
-    userService UserService
-    logger      *zap.Logger
-}
-
-func NewUserHandler(us UserService, l *zap.Logger) *UserHandler {
-    return &UserHandler{
-        userService: us,
-        logger:      l,
-    }
-}
-
-func (h *UserHandler) GetUser(c *gin.Context) {
-    ctx := c.Request.Context()
-    id := c.Param("id")
-
-    user, err := h.userService.GetUserByID(ctx, id)
-    if err != nil {
-        if errors.Is(err, ErrUserNotFound) {
-            c.JSON(http.StatusNotFound, gin.H{"error": "user not found"})
-            return
-        }
-        h.logger.Error("failed to get user", zap.Error(err))
-        c.JSON(http.StatusInternalServerError, gin.H{"error": "internal error"})
-        return
-    }
-
-    c.JSON(http.StatusOK, user)
-}
-```
-
-```go
-// Actual pattern found in internal/services/user.go
-type UserService struct {
-    repo   UserRepository
-    cache  CacheService
-    logger *zap.Logger
-}
-
-func (s *UserService) GetUserByID(ctx context.Context, id string) (*User, error) {
-    // Try cache first
-    if user, err := s.cache.Get(ctx, "user:"+id); err == nil {
-        return user, nil
-    }
-
-    // Fall back to database
-    user, err := s.repo.FindByID(ctx, id)
-    if err != nil {
-        if errors.Is(err, sql.ErrNoRows) {
-            return nil, ErrUserNotFound
-        }
-        return nil, fmt.Errorf("failed to find user: %w", err)
-    }
-
-    // Populate cache
-    if err := s.cache.Set(ctx, "user:"+id, user, 5*time.Minute); err != nil {
-        s.logger.Warn("failed to cache user", zap.Error(err))
-    }
-
-    return user, nil
-}
-```
-```
-
-#### Node.js/Express Project
-Create `.claude/agents/auto-generated/express-specialist.md`:
+For other stacks (Python/Django, Go/Gin, C#/.NET, etc.), follow the same pattern but adapt to the framework's conventions. See generated agents in `.claude/agents/auto-generated/` for examples.
 
 ```markdown
 ---
@@ -864,130 +472,25 @@ Task("tailwind-specialist", "Style the form following project conventions")
 
 ## Language Detection Guide
 
-Look for these indicators:
-
-### Web & Frontend
-- **JavaScript/TypeScript**: `package.json`, `.ts`/`.js`/`.tsx`/`.jsx` files, import/export
-  - **React**: `react`, `react-dom` in dependencies, `.jsx`/`.tsx`, JSX syntax
-  - **Vue**: `vue`, `@vue/*` in dependencies, `.vue` files
-  - **Angular**: `@angular/*` in dependencies, `.component.ts`
-  - **Svelte**: `svelte` in dependencies, `.svelte` files
-  - **Next.js**: `next` in dependencies, `next.config.js`
-  - **Nuxt**: `nuxt` in dependencies, `nuxt.config.js`
-  - **Remix**: `@remix-run/*` in dependencies
-
-### Backend & API
-- **Python**: `requirements.txt`, `pyproject.toml`, `setup.py`, `.py` files
-  - **Django**: `django` in dependencies, `settings.py`, `urls.py`, `models.py`
-  - **Flask**: `flask` in dependencies, `@app.route` decorators
-  - **FastAPI**: `fastapi` in dependencies, `@app.get`/`@app.post` decorators
-  - **Tornado**: `tornado` in dependencies
-  - **Falcon**: `falcon` in dependencies
-- **C#/.NET**: `.csproj`, `.vbproj`, `.sln`, `.cs`/`.vb` files, `using` statements
-  - **ASP.NET Core**: `Microsoft.AspNetCore.*`, `Program.cs` with `WebApplication.CreateBuilder()`
-  - **Entity Framework**: `Microsoft.EntityFrameworkCore.*`
-  - **Nancy**: `Nancy` in dependencies
-- **Go**: `go.mod`, `go.sum`, `.go` files, `package` declarations, `func main()`
-  - **Gin**: `gin-gonic/gin` in dependencies, `router := gin.Default()`
-  - **Echo**: `labstack/echo` in dependencies, `e := echo.New()`
-  - **Fiber**: `gofiber/fiber` in dependencies
-  - **net/http**: Standard library only
-- **Java**: `pom.xml`, `build.gradle`, `gradle.properties`, `.java` files, `public class`
-  - **Spring Boot**: `spring-boot-starter-*` in dependencies, `@SpringBootApplication`
-  - **Micronaut**: `io.micronaut.*` in dependencies
-  - **Quarkus**: `io.quarkus:*` in dependencies
-  - **Jakarta EE**: `jakarta.*` imports
-  - **Vert.x**: `io.vertx:*` in dependencies
-- **Ruby**: `Gemfile`, `*.gemspec`, `.rb` files, `require`, `class`
-  - **Rails**: `rails` in Gemfile, `app/controllers/`, `app/models/`
-  - **Sinatra**: `sinatra` in Gemfile
-  - **Grape**: `grape` in Gemfile
-- **PHP**: `composer.json`, `.php` files, `use` statements, `namespace`
-  - **Laravel**: `laravel/framework` in composer.json, `routes/`, `app/Http/Controllers/`
-  - **Symfony**: `symfony/*` in composer.json
-  - **Slim**: `slim/slim` in composer.json
-- **Node.js**: `package.json`, `.js`/`.ts` files
-  - **Express**: `express` in dependencies, `app = express()`
-  - **Koa**: `koa` in dependencies
-  - **NestJS**: `@nestjs/*` in dependencies, `@Controller()` decorators
-  - **Hapi**: `@hapi/hapi` in dependencies
-  - **Fastify**: `fastify` in dependencies
-
-### Systems & Compiled Languages
-- **Rust**: `Cargo.toml`, `Cargo.lock`, `.rs` files, `fn main()`, `use` statements
-  - **Actix Web**: `actix-web` in dependencies
-  - **Rocket**: `rocket` in dependencies, `#[get("/")]`
-  - **Warp**: `warp` in dependencies
-- **C/C++**: `Makefile`, `CMakeLists.txt`, `.c`/`.cpp`/`.h`/`.hpp` files
-  - **libcurl**: HTTP client
-  - **libmicrohttpd**: Embedded HTTP server
-  - **Pistache**: C++ REST framework
-- **Elixir/Erlang**: `mix.exs`, `.ex`/`.exs` files
-  - **Phoenix**: `phoenix` in mix.exs, `lib/*_web/`, `endpoint.ex`
-  - **Plug**: `plug` in dependencies
-  - **Sugar**: `sugar` in dependencies
-- **Dart/Flutter**: `pubspec.yaml`, `.dart` files
-  - **Flutter**: `flutter` in dependencies, `lib/main.dart`
-  - **Angel**: `angel` in dependencies
-  - **Shelf**: `shelf` in dependencies
-- **Scala**: `build.sbt`, `pom.xml`, `.scala` files
-  - **Play Framework**: `com.typesafe.play` in dependencies
-  - **http4s**: `org.http4s` in dependencies
-  - **Akka HTTP**: `com.typesafe.akka` in dependencies
-- **Clojure**: `project.clj`, `build.boot`, `deps.edn`, `.clj`/`.cljs` files
-  - **Ring**: `ring` in dependencies
-  - **Reitit**: `reitit` in dependencies
-  - **Pedestal**: `io.pedestal` in dependencies
-
-### Mobile & Cross-Platform
-- **Swift (iOS)**: `Package.swift`, `.swift` files, `import UIKit`
-  - **Vapor**: `vapor` in Package.swift
-- **Kotlin (Android)**: `build.gradle.kts`, `.kt` files
-  - **Ktor**: `io.ktor:*` in dependencies
-  - **Spring Boot**: Also used on Android
-- **Flutter (iOS/Android)**: `pubspec.yaml`, `lib/main.dart`
-- **React Native**: `package.json`, `react-native` in dependencies
-- **Ionic**: `package.json`, `@ionic/*` in dependencies
-- **Xamarin**: `.csproj`, `Xamarin.*` in dependencies
-
-### Database & Data
-- **SQL**: Direct database queries
-  - **PostgreSQL**: `postgresql`, `pg` in dependencies
-  - **MySQL**: `mysql`, `mysql2` in dependencies
-  - **SQLite**: `sqlite3`, `better-sqlite3` in dependencies
-  - **MSSQL**: `mssql`, `tedious` in dependencies
-- **ORM/Query Builders**:
-  - **Prisma**: `@prisma/client`, `schema.prisma`
-  - **TypeORM**: `typeorm` in dependencies
-  - **Sequelize**: `sequelize` in dependencies
-  - **SQLAlchemy**: `sqlalchemy` in Python requirements
-  - **Hibernate**: `hibernate-*` in Java dependencies
-  - **Entity Framework**: `Microsoft.EntityFrameworkCore` in .NET
-  - **Ecto**: `ecto` in Elixir mix.exs
-  - **Diesel**: `diesel` in Rust Cargo.toml
-
-### Testing & Quality
-- **JavaScript/TypeScript**: `jest.config.js`, `vitest.config.js`, `karma.conf.js`, `.spec.ts`
-- **Python**: `pytest.ini`, `unittest`, `test_*.py`
-- **Java**: JUnit (`@Test`), TestNG, Mockito
-- **.NET**: xUnit, NUnit, MSTest
-- **Go**: `_test.go` files, `testing` package
-- **Ruby**: `spec/`, `test/`, RSpec, Minitest
-- **PHP**: PHPUnit, `phpunit.xml`
-
-### DevOps & Infrastructure
-- **Docker**: `Dockerfile`, `docker-compose.yml`, `.dockerignore`
-- **Kubernetes**: `deployment.yaml`, `service.yaml`, `k8s/`
-- **Terraform**: `*.tf` files, `main.tf`
-- **Ansible**: `playbook.yml`, `ansible.cfg`
-- **CI/CD**:
-  - GitHub Actions: `.github/workflows/*.yml`
-  - GitLab CI: `.gitlab-ci.yml`
-  - Travis CI: `.travis.yml`
-  - CircleCI: `.circleci/config.yml`
-  - Jenkins: `Jenkinsfile`
-
-### And ANY other language or framework - Claude understands them all!
+Detect tech stack by looking for these key indicators:
+
+| Language/Stack | Key Files | Framework Indicators |
+|---------------|-----------|---------------------|
+| **TypeScript/JS** | `package.json`, `.ts`/`.tsx`/`.js`/`.jsx` | React (`react`), Next.js (`next`), Vue (`vue`), Angular (`@angular/*`), Express (`express`), NestJS (`@nestjs/*`) |
+| **Python** | `requirements.txt`, `pyproject.toml`, `.py` | Django (`django`, `settings.py`), Flask (`flask`, `@app.route`), FastAPI (`fastapi`) |
+| **Go** | `go.mod`, `go.sum`, `.go` | Gin (`gin-gonic/gin`), Echo (`labstack/echo`), Fiber (`gofiber/fiber`) |
+| **C#/.NET** | `.csproj`, `.sln`, `.cs` | ASP.NET Core (`Microsoft.AspNetCore.*`), Entity Framework (`Microsoft.EntityFrameworkCore.*`) |
+| **Java** | `pom.xml`, `build.gradle`, `.java` | Spring Boot (`spring-boot-starter-*`, `@SpringBootApplication`), Micronaut, Quarkus |
+| **Ruby** | `Gemfile`, `.rb` | Rails (`rails`, `app/controllers/`), Sinatra (`sinatra`) |
+| **PHP** | `composer.json`, `.php` | Laravel (`laravel/framework`, `routes/`), Symfony (`symfony/*`) |
+| **Rust** | `Cargo.toml`, `.rs` | Actix Web (`actix-web`), Rocket (`rocket`) |
+| **Elixir** | `mix.exs`, `.ex` | Phoenix (`phoenix`, `lib/*_web/`) |
+
+**Database/ORM**: Check dependencies for Prisma (`@prisma/client`), TypeORM, Sequelize, SQLAlchemy, Hibernate, Entity Framework, Ecto, Diesel.
+
+**Testing**: Look for Jest, Vitest, Pytest, JUnit, xUnit, RSpec in configs and dependencies.
+
+Claude understands all major languages and frameworks - adapt to whatever the project uses!
 
 ## Example Flow