Crew Init

Crew Init - Project Analysis & Team Setup

Full project initialization that transforms any codebase into a CodeCrew workspace with indexed code, profiled architecture, and a configured agent team.

When to Activate

• User runs /crew init
• User runs /crew with init argument
• First time using CodeCrew in a project

Initialization Pipeline

Phase 1: Project Discovery

Scan the project to understand what we're working with:

1.1 Detect project type and languages:

Use Glob to check for:
- package.json, tsconfig.json → Node.js / TypeScript
- requirements.txt, pyproject.toml, setup.py → Python
- go.mod → Go
- Cargo.toml → Rust
- pom.xml, build.gradle → Java / Kotlin
- Gemfile → Ruby
- composer.json → PHP
- Makefile, CMakeLists.txt → C/C++
- pubspec.yaml → Dart/Flutter
- *.sln, *.csproj → .NET/C#

1.2 Detect frameworks:

Read package.json (or equivalent) for:
- react, next, vue, angular, svelte → Frontend framework
- express, fastify, koa, django, flask, gin, actix → Backend framework
- playwright, jest, pytest, mocha → Testing framework
- eslint, prettier, black, gofmt → Linting/formatting
- docker, kubernetes → Container/orchestration

1.3 Map project structure:

Use Glob for directory layout:
- src/, lib/, app/ → Source code
- test/, tests/, __tests__, spec/ → Tests
- docs/, doc/ → Documentation
- .github/, .gitlab-ci.yml → CI/CD
- Dockerfile, docker-compose.yml → Docker
- scripts/, bin/ → Build/deploy scripts

1.4 Read existing context:

• Read CLAUDE.md if it exists (project-specific instructions)
• Read README.md for project description
• Check git log for recent activity areas (if git repo)

Phase 2: Build Codebase Index

Invoke the codebase-index skill in full-build mode:

1. Discover all source files (excluding node_modules, dist, build, etc.)
2. For each file: read, hash, extract metadata (exports, imports, functions, classes, line count)
3. Build call graph from import/export relationships
4. Write .claude/crew-index.json (Layer 1 - compact)
5. Write .claude/crew-symbols.json (Layer 2 - symbols)

This enables the Index-First Protocol for all future agent interactions.

Phase 3: Generate Project Profile

Write .claude/crew-profile.md with:

# Crew Profile: {project-name}

## Overview
- **Type**: {web-app | api | cli | library | scraper | mobile | etc.}
- **Languages**: {detected languages}
- **Frameworks**: {detected frameworks}
- **Size**: {total files} files, {total lines} lines

## Architecture
- **Entry Point**: {main file}
- **Pipeline/Flow**: {data flow description}
- **Patterns**: {MVC, pipeline, event-driven, microservice, etc.}

## Key Directories
- **Source**: {src paths}
- **Tests**: {test paths}
- **Config**: {config files}
- **Docs**: {doc paths}

## Tech Stack
- **Runtime**: {node, python, go, etc.}
- **Package Manager**: {npm, pip, cargo, etc.}
- **Testing**: {jest, pytest, etc.}
- **Linting**: {eslint, prettier, etc.}
- **CI/CD**: {github actions, gitlab ci, etc.}
- **Deployment**: {docker, k8s, vercel, etc.}

## Index Status
- **Files Indexed**: {count}
- **Symbols Mapped**: {count}
- **Last Indexed**: {timestamp}
- **Index Files**: .claude/crew-index.json, .claude/crew-symbols.json

Phase 4: Configure Agent Team

Based on detected stack, determine which agents are active and what skills they need.

Write .claude/crew-team.json:

{
  "project": "project-name",
  "configured": "2026-04-04T12:00:00Z",
  "agents": {
    "ceo": {
      "model": "opus",
      "active": true,
      "role": "Task triage, decomposition, delegation, architecture decisions"
    },
    "vp-engineering": {
      "model": "sonnet",
      "active": true,
      "role": "Tech decisions, architecture review, complex planning"
    },
    "vp-quality": {
      "model": "sonnet",
      "active": true,
      "role": "Quality gates, test strategy, review coordination"
    },
    "senior-dev": {
      "model": "sonnet",
      "active": true,
      "role": "Complex implementation, multi-file changes"
    },
    "junior-dev": {
      "model": "haiku",
      "active": true,
      "role": "Simple fixes, formatting, small changes"
    },
    "code-reviewer": {
      "model": "sonnet",
      "active": true,
      "role": "Code review, quality assessment"
    },
    "debugger": {
      "model": "sonnet",
      "active": true,
      "role": "Bug investigation, root cause analysis"
    },
    "security-analyst": {
      "model": "sonnet",
      "active": false,
      "activateWhen": "security-related tasks or pre-deploy review"
    },
    "devops-engineer": {
      "model": "haiku",
      "active": false,
      "activateWhen": "Docker/CI/CD/deployment tasks detected"
    },
    "doc-writer": {
      "model": "haiku",
      "active": true,
      "role": "Documentation, comments, READMEs"
    },
    "test-engineer": {
      "model": "sonnet",
      "active": false,
      "activateWhen": "test directory detected or testing tasks"
    }
  },
  "activationRules": {
    "hasDocker": ["devops-engineer"],
    "hasTests": ["test-engineer"],
    "hasSecurity": ["security-analyst"],
    "always": ["ceo", "vp-engineering", "senior-dev", "junior-dev", "code-reviewer", "debugger", "doc-writer"]
  }
}

Activate conditional agents based on detected stack:

• Found Dockerfile or docker-compose.yml → activate devops-engineer
• Found test/ or testing framework → activate test-engineer
• Found .env or security configs → activate security-analyst

Phase 5: Suggest Custom Agents

Based on Phase 1 detection results (languages, frameworks, tools), suggest project-specific custom agents that extend the built-in team. The number of suggestions is dynamic — more frameworks/tools detected = more suggestions.

Step 0: Detect Project Domain

Analyze available project signals to classify the project domain:

1. Project directory name — check for keywords (e.g., "trading", "shop", "health", "game")
2. README.md — read first 50 lines for project description keywords
3. package.json / pyproject.toml — check description and keywords fields
4. Directory names — scan for domain-specific folders (e.g., strategies/, orders/, cart/, patients/)
5. Import patterns — check for domain-specific libraries (e.g., ccxt, alpaca-trade-api, stripe, hl7)

Classify into ONE primary domain:

If domain is general, skip domain-specific suggestions. Otherwise, include domain-specific agents in Step 1 below.

Step 1: Match Detected Stack + Domain to Suggested Agents

Check Phase 1 results and Step 0 domain against these mappings. Only include agents whose detection conditions match:

JavaScript/TypeScript:
  - react-specialist (sonnet)     → if React or Next.js detected
    "Expert in React component architecture, hooks, state management, and performance optimization"
  - nextjs-specialist (sonnet)    → if Next.js detected
    "Expert in Next.js App Router, server components, API routes, and SSR/SSG strategies"
  - vue-specialist (sonnet)       → if Vue detected
    "Expert in Vue 3 composition API, Pinia state management, and component patterns"
  - angular-specialist (sonnet)   → if Angular detected
    "Expert in Angular modules, services, dependency injection, and RxJS patterns"
  - node-api-specialist (sonnet)  → if Express/Fastify/Koa detected
    "Expert in Node.js API design, middleware patterns, route handling, and request validation"
  - styling-specialist (haiku)    → if Tailwind/styled-components/CSS modules detected
    "Expert in styling architecture, responsive design, and CSS optimization"

Python:
  - django-specialist (sonnet)    → if Django detected
    "Expert in Django models, views, serializers, middleware, and ORM optimization"
  - flask-specialist (sonnet)     → if Flask detected
    "Expert in Flask blueprints, extensions, request handling, and API design"
  - fastapi-specialist (sonnet)   → if FastAPI detected
    "Expert in FastAPI endpoints, Pydantic models, dependency injection, and async patterns"
  - data-engineer (sonnet)        → if pandas/numpy/scipy detected
    "Expert in data pipelines, DataFrame operations, data cleaning, and transformation"
  - ml-engineer (sonnet)          → if tensorflow/pytorch/sklearn detected
    "Expert in ML model architecture, training pipelines, and inference optimization"

Go:
  - go-api-specialist (sonnet)    → if Gin/Echo/Fiber detected
    "Expert in Go HTTP handlers, middleware, routing, and concurrent request processing"

Rust:
  - rust-systems (sonnet)         → if Actix/Tokio detected
    "Expert in Rust async patterns, ownership semantics, and systems-level optimization"

Database (any language):
  - database-specialist (sonnet)  → if Prisma/Sequelize/SQLAlchemy/TypeORM/Drizzle detected
    "Expert in database schema design, query optimization, migrations, and ORM patterns"

Mobile:
  - mobile-specialist (sonnet)    → if React Native/Flutter detected
    "Expert in mobile UI patterns, navigation, platform-specific APIs, and performance"

Monorepo:
  - monorepo-specialist (haiku)   → if Turborepo/Nx/Lerna detected
    "Expert in monorepo architecture, workspace dependencies, and shared package management"

Domain-Based Suggestions (from Step 0 domain detection):

trading/finance:

• quant-expert (sonnet) "Expert in trading algorithms, market data processing, order execution, risk calculations, and financial modeling"
• risk-analyst (sonnet) "Expert in risk assessment, portfolio analysis, compliance checks, and financial regulations"

e-commerce:

• payment-specialist (sonnet) "Expert in payment gateway integration, checkout flows, cart logic, and order management"
• catalog-specialist (haiku) "Expert in product catalog management, search/filter, inventory, and pricing logic"

healthcare:

• compliance-specialist (sonnet) "Expert in HIPAA compliance, patient data handling, audit trails, and healthcare regulations"
• ehr-specialist (sonnet) "Expert in electronic health record systems, patient data models, and clinical workflows"

education:

• lms-specialist (sonnet) "Expert in learning management systems, course structures, grading logic, and student progress tracking"

gaming:

• game-logic-specialist (sonnet) "Expert in game state management, physics, rendering pipelines, and multiplayer sync"

ai-ml:

• ml-pipeline-expert (sonnet) "Expert in training pipelines, model serving, feature engineering, and experiment tracking"

iot:

• device-specialist (sonnet) "Expert in device communication protocols, sensor data processing, firmware updates, and telemetry"

media:

• media-pipeline-specialist (sonnet) "Expert in media processing, transcoding, streaming protocols, and content delivery"

saas:

• auth-specialist (sonnet) "Expert in authentication flows, RBAC, multi-tenancy, and session management"
• billing-specialist (sonnet) "Expert in subscription billing, usage metering, invoice generation, and payment processing"

data-pipeline:

• etl-specialist (sonnet) "Expert in data extraction, transformation, loading, scheduling, and pipeline orchestration"

social:

• realtime-specialist (sonnet) "Expert in WebSocket connections, message queuing, presence systems, and notification delivery"

devtools:

• plugin-architect (sonnet) "Expert in plugin/extension architecture, API design, CLI patterns, and developer experience"

If no frameworks/tools AND no domain detected (domain is `general`), skip this phase entirely and proceed to Phase 6.

#### Step 2: Present Agent Catalogue

Display all matched suggestions (both stack-based and domain-based) in a numbered table:

Suggested Custom Agents for This Project:

Based on your stack ({detected frameworks}) and domain ({detected domain}), these specialized agents can improve task routing:

| Agent | Model | Source | Specialization

1 | react-specialist | Sonnet | Stack | React component architecture, hooks, state management 2 | node-api-specialist | Sonnet | Stack | Node.js API design, middleware, route handling 3 | database-specialist | Sonnet | Stack | Database schema design, query optimization, ORM patterns 4 | quant-expert | Sonnet | Domain | Trading algorithms, market data, order execution 5 | risk-analyst | Sonnet | Domain | Risk assessment, portfolio analysis, compliance

These agents extend the built-in team with project-specific expertise. Custom agents are automatically considered by the task router when their specialization matches a task.

#### Step 3: Ask User to Select

Present selection options and wait for user response:

Which agents would you like to add? a) All — add all suggested agents b) None — skip, use only built-in agents c) Select by number — e.g. "1,3" or "1-3"

#### Step 4: Create Selected Agents

For each selected agent:

1. Create `.claude/crew-agents/` directory if it doesn't exist
2. Generate the agent definition file `.claude/crew-agents/{name}.md` using the appropriate model template with **pre-filled responsibilities** specific to the framework (NOT generic placeholders)
3. Register in `.claude/crew-team.json` under the `agents` key with `"custom": true, "active": true`

**Sonnet custom agent template** (pre-filled example for react-specialist):

```markdown
---
name: crew-{name}
description: {description from mapping}
model: sonnet
---

You are the **{Name}** at CodeCrew. {description from mapping}.

## INDEX-FIRST PROTOCOL (MANDATORY)

**INDEX-FIRST**: Read `.claude/crew-index.json` → `crew-symbols.json` → then only specific lines from source files. Never read entire files.

## Your Responsibilities

1. {Framework-specific responsibility 1}
2. {Framework-specific responsibility 2}
3. {Framework-specific responsibility 3}
4. {Framework-specific responsibility 4}
5. Follow project conventions and patterns detected in the codebase
6. Coordinate with other agents when changes span beyond your specialization

## Output Format

When done, report:
- What you changed (file paths + summary)
- FILES_MODIFIED: {list}
- Confidence level: high | medium | low
- Any concerns or dependencies

Haiku custom agent template:

---
name: crew-{name}
description: {description from mapping}
model: haiku
---

You are the **{Name}** at CodeCrew. {description from mapping}.

## INDEX-FIRST PROTOCOL (MANDATORY)

**INDEX-FIRST**: Read `.claude/crew-index.json` → `crew-symbols.json` → then only the lines you need. Never read entire files.

## Your Tasks

1. {Framework-specific task 1}
2. {Framework-specific task 2}
3. {Framework-specific task 3}
4. Follow project conventions detected in the codebase
5. If the task is too complex, report: "ESCALATE: Needs senior-dev or relevant sonnet specialist"

## Output

FILES_MODIFIED: {list}
CONFIDENCE: {high | medium | low}

Fill in the {Framework-specific responsibility/task} lines with real responsibilities relevant to the agent's specialization — do NOT leave them as generic placeholders. Use your knowledge of the framework to write 3-5 concrete responsibilities.

crew-team.json registration — add under agents:

"custom-{name}": {
  "model": "{tier}",
  "active": true,
  "role": "{description}",
  "custom": true,
  "definitionPath": ".claude/crew-agents/{name}.md"
}

Step 5: Confirm

If agents were added:

Custom agents added: {n}
  {name} ({model}), {name} ({model}), ...

These agents will be auto-selected by the task router when tasks match their specialization.
Manage custom agents anytime with /crew agent list|remove

If user selected "None":

No custom agents added. You can add them later with /crew agent create

Phase 6: Build Skill Catalog

Write .claude/crew-skills.json mapping all available ECC skills to categories:

{
  "catalogVersion": 1,
  "totalSkills": 125,
  "relevantSkills": 45,
  "categories": {
    "always": [
      "strategic-compact",
      "context-budget",
      "verification-loop",
      "coding-standards",
      "iterative-retrieval",
      "search-first"
    ],
    "stack": {
      "javascript": ["typescript-patterns", "react-patterns", "nextjs-patterns", "backend-patterns"],
      "python": ["python-patterns", "django-patterns"],
      "go": ["golang-patterns"],
      "rust": ["rust-patterns"]
    },
    "taskType": {
      "bug-fix": ["iterative-retrieval", "deep-research", "codebase-onboarding"],
      "feature": ["architecture-decision-records", "agentic-engineering", "blueprint"],
      "test": ["tdd-workflow", "e2e-testing", "ai-regression-testing"],
      "security": ["security-scanning"],
      "docs": ["article-writing", "documentation-lookup"],
      "devops": ["deployment-patterns", "docker-patterns", "database-migrations", "git-workflow"],
      "review": ["verification-loop"],
      "refactor": ["architecture-decision-records", "backend-patterns"],
      "performance": ["cost-aware-llm-pipeline"]
    }
  },
  "detectedStack": ["javascript"],
  "activeSkills": ["typescript-patterns", "backend-patterns"]
}

Phase 7: Report

Display initialization summary to the user:

CodeCrew ready — {project-name}
  {type} | {languages} | {count} files, {lines} lines
  Agents: {count}/{total} (Opus: 1, Sonnet: X, Haiku: Y) | Skills: {relevant}/{total}

Use /crew task "desc" to delegate work.