vibe-fabric 0.3.1 → 0.3.3

package/.claude/prompts/analyze/assess.md

@@ -0,0 +1,208 @@
+# Repository Analysis Assessment
+
+## Variables
+
+| Variable | Description | Required |
+|----------|-------------|----------|
+| {PROJECT_PATH} | Path to the project directory | Yes |
+| {OUTPUT_FILE} | Path to write the assessment output | Yes |
+
+---
+
+## Context
+
+You are helping analyze external repositories to extract structural maps (entities, APIs, services). These maps are used for:
+- Understanding existing codebases
+- Gap analysis against PRD
+- Generating PRD from existing code
+- Planning migrations or integrations
+
+Project: {PROJECT_PATH}
+
+---
+
+## Your Task
+
+Analyze configured repositories and prepare analysis tasks.
+
+### Step 1: Load Repository Configuration
+
+Read the vibe configuration:
+- `.vibe/config.json` - Main config with repo list
+- `docs/sync-cache/*/` - Already synced repos
+
+Repository config format:
+```json
+{
+  "repos": [
+    {
+      "alias": "backend",
+      "url": "github.com/org/backend",
+      "branch": "main"
+    }
+  ]
+}
+```
+
+### Step 2: Assess Each Repository
+
+For each configured repository, determine:
+- **Already synced:** Maps exist in `docs/sync-cache/{alias}/maps/`
+- **Needs sync:** No maps or outdated
+- **Framework:** Detected from package.json, requirements.txt, etc.
+- **Size estimate:** File count indicator (S/M/L)
+
+### Step 3: Present Findings
+
+Summarize:
+- Number of configured repositories
+- Repos already analyzed (with dates)
+- Repos needing analysis
+- Detected frameworks
+
+### Step 4: Ask User Intent
+
+Ask the user: **"What would you like to analyze?"**
+
+Options:
+1. **All repositories** - Analyze everything
+2. **Specific repo** - Analyze one repository (e.g., "analyze backend")
+3. **Refresh all** - Re-analyze even if maps exist
+4. **Just checking** - Show summary only
+
+### Step 5: Create Task List
+
+Based on findings and user intent, create tasks:
+
+**Task Types:**
+- `task-analyze-repo` - Analyze a single repository (non-interactive)
+
+---
+
+## Output Format
+
+Write to: {OUTPUT_FILE}
+
+```json
+{
+  "complexity": "S|M|L",
+  "assessment": {
+    "config_exists": true,
+    "repo_count": 2,
+    "repos": [
+      {
+        "alias": "backend",
+        "url": "github.com/org/backend",
+        "framework": "nestjs",
+        "synced": true,
+        "last_sync": "2026-01-20T10:00:00Z",
+        "maps_exist": true
+      },
+      {
+        "alias": "frontend",
+        "url": "github.com/org/frontend",
+        "framework": "nextjs",
+        "synced": false,
+        "last_sync": null,
+        "maps_exist": false
+      }
+    ],
+    "user_intent": "analyze frontend"
+  },
+  "tasks": [
+    {
+      "id": 1,
+      "name": "analyze-frontend",
+      "description": "Analyze frontend repository (Next.js)",
+      "prompt": "task-analyze-repo",
+      "interactive": false,
+      "context": {
+        "alias": "frontend",
+        "url": "github.com/org/frontend",
+        "branch": "main",
+        "framework": "nextjs"
+      }
+    }
+  ]
+}
+```
+
+---
+
+## Rules
+
+- Focus ONLY on repository analysis
+- Maximum 5 tasks (one per repo to analyze)
+- Detect framework from manifest files (package.json, etc.)
+- If no repos configured, explain how to add with `vibe repo add`
+- Skip repos that are already synced unless user requests refresh
+- If user says "just checking", output empty tasks array
+- Be concise in your analysis
+
+---
+
+## Framework Detection
+
+Detect framework from files:
+
+| File | Framework |
+|------|-----------|
+| `package.json` with `@nestjs/core` | NestJS |
+| `package.json` with `next` | Next.js |
+| `package.json` with `react` (no next) | React |
+| `package.json` with `express` | Express |
+| `requirements.txt` with `fastapi` | FastAPI |
+| `requirements.txt` with `django` | Django |
+| `requirements.txt` with `flask` | Flask |
+| `go.mod` | Go |
+| `Cargo.toml` | Rust |
+
+---
+
+## Examples
+
+**User says "just checking":**
+```json
+{
+  "complexity": "S",
+  "assessment": {...},
+  "tasks": []
+}
+```
+
+**User says "analyze all":**
+```json
+{
+  "complexity": "M",
+  "assessment": {...},
+  "tasks": [
+    {"id": 1, "name": "analyze-backend", "prompt": "task-analyze-repo", ...},
+    {"id": 2, "name": "analyze-frontend", "prompt": "task-analyze-repo", ...}
+  ]
+}
+```
+
+**User says "analyze backend":**
+```json
+{
+  "complexity": "S",
+  "assessment": {...},
+  "tasks": [
+    {"id": 1, "name": "analyze-backend", "prompt": "task-analyze-repo", ...}
+  ]
+}
+```
+
+**No repos configured:**
+```json
+{
+  "complexity": "S",
+  "assessment": {
+    "config_exists": true,
+    "repo_count": 0,
+    "repos": [],
+    "error": "No repositories configured. Add repos with: vibe repo add <url>"
+  },
+  "tasks": []
+}
+```

package/.claude/prompts/analyze/synthesize.md

@@ -0,0 +1,239 @@
+# Synthesize Repository Maps
+
+## Variables
+
+| Variable | Description | Required |
+|----------|-------------|----------|
+| {PROJECT_PATH} | Path to the project directory | Yes |
+| {TASK_OUTPUTS} | JSON array of task output file paths | Yes |
+| {TOTAL_TASKS} | Number of tasks completed | Yes |
+
+---
+
+## Context
+
+You are synthesizing repository analysis results. Each task analyzed one repository and generated maps. Now you need to:
+- Save maps to the correct locations
+- Create a summary of all repositories
+- Prepare for gap analysis or PRD generation
+
+Project: {PROJECT_PATH}
+Task outputs: {TASK_OUTPUTS}
+Total tasks: {TOTAL_TASKS}
+
+---
+
+## Your Task
+
+Combine all repository analyses and save to the sync cache.
+
+### Step 1: Load Task Outputs
+
+Read each task output file from {TASK_OUTPUTS}.
+
+### Step 2: Save Maps to Sync Cache
+
+For each repository analyzed, create the directory structure:
+
+```
+docs/sync-cache/{alias}/
+├── maps/
+│   ├── entities.json
+│   ├── api.json
+│   ├── services.json
+│   └── modules.json
+└── metadata.json
+```
+
+**entities.json:**
+```json
+{
+  "version": "1.0",
+  "source": "prisma/schema.prisma",
+  "generated_at": "2026-01-21T10:00:00Z",
+  "models": {...},
+  "enums": {...}
+}
+```
+
+**api.json:**
+```json
+{
+  "version": "1.0",
+  "generated_at": "2026-01-21T10:00:00Z",
+  "endpoints": {...}
+}
+```
+
+**services.json:**
+```json
+{
+  "version": "1.0",
+  "generated_at": "2026-01-21T10:00:00Z",
+  "services": {...}
+}
+```
+
+**modules.json:**
+```json
+{
+  "version": "1.0",
+  "generated_at": "2026-01-21T10:00:00Z",
+  "modules": {...}
+}
+```
+
+**metadata.json:**
+```json
+{
+  "alias": "backend",
+  "url": "github.com/org/backend",
+  "branch": "main",
+  "framework": "nestjs",
+  "analyzed_at": "2026-01-21T10:00:00Z",
+  "summary": {
+    "models": 24,
+    "endpoints": 47,
+    "services": 18,
+    "modules": 12
+  }
+}
+```
+
+### Step 3: Generate Summary
+
+Create a consolidated summary of all repositories.
+
+### Step 4: Display Results
+
+Print analysis summary and next steps.
+
+---
+
+## Output
+
+### Console Output
+
+Print a summary:
+
+```
+Repository Analysis Complete
+============================
+
+Repositories Analyzed: 2
+
+Backend (github.com/org/backend)
+  Framework: NestJS
+  Models: 24
+  Endpoints: 47
+  Services: 18
+  Modules: 12
+
+Frontend (github.com/org/frontend)
+  Framework: Next.js
+  Models: 8
+  API Routes: 12
+  Components: 45
+
+Maps saved to:
+  docs/sync-cache/backend/maps/
+  docs/sync-cache/frontend/maps/
+
+Next Steps:
+- Run gap analysis with: vibe gaps
+- Generate PRD from maps with: vibe prd --from-maps
+- View sync status with: vibe sync --status
+```
+
+### File Operations
+
+Create these directories and files:
+
+```
+docs/sync-cache/
+├── backend/
+│   ├── maps/
+│   │   ├── entities.json
+│   │   ├── api.json
+│   │   ├── services.json
+│   │   └── modules.json
+│   └── metadata.json
+├── frontend/
+│   ├── maps/
+│   │   ├── entities.json
+│   │   ├── api.json
+│   │   ├── services.json
+│   │   └── modules.json
+│   └── metadata.json
+└── _summary.json
+```
+
+**_summary.json:**
+```json
+{
+  "generated_at": "2026-01-21T10:00:00Z",
+  "repositories": [
+    {
+      "alias": "backend",
+      "framework": "nestjs",
+      "summary": {
+        "models": 24,
+        "endpoints": 47,
+        "services": 18,
+        "modules": 12
+      }
+    },
+    {
+      "alias": "frontend",
+      "framework": "nextjs",
+      "summary": {
+        "models": 8,
+        "endpoints": 12,
+        "services": 5,
+        "modules": 0
+      }
+    }
+  ],
+  "totals": {
+    "repositories": 2,
+    "models": 32,
+    "endpoints": 59,
+    "services": 23
+  }
+}
+```
+
+---
+
+## Rules
+
+- Create directories if they don't exist
+- Overwrite existing maps (this is a refresh)
+- Preserve timestamps for tracking
+- Use consistent JSON formatting (2-space indent)
+- Include version numbers in all maps for future compatibility
+- Handle empty/missing data gracefully
+- Show clear summary with counts
+
+---
+
+## Error Handling
+
+If a task output is invalid:
+- Log warning
+- Skip that repository
+- Continue with others
+
+If write fails:
+- Show error message
+- Suggest checking permissions
+
+---
+
+## Integration Notes
+
+After maps are saved, they can be used by:
+- `vibe gaps` - Compare PRD to maps
+- `vibe prd --from-maps` - Generate PRD from implementation
+- `vibe sync --status` - Check sync freshness
+- `vibe send` - Include maps in scope packages

package/.claude/prompts/analyze/task-analyze-repo.md

@@ -0,0 +1,260 @@
+# Analyze Repository
+
+## Variables
+
+| Variable | Description | Required |
+|----------|-------------|----------|
+| {PROJECT_PATH} | Path to the project directory | Yes |
+| {TASK_NAME} | Name of this task | Yes |
+| {TASK_DESCRIPTION} | Description of this task | Yes |
+| {OUTPUT_FILE} | Path to write the task output | Yes |
+| {PREVIOUS_OUTPUTS} | JSON array of previous task output paths | Yes |
+| {ALIAS} | Repository alias (e.g., "backend") | Yes |
+| {URL} | Repository URL | Yes |
+| {BRANCH} | Branch to analyze | Yes |
+| {FRAMEWORK} | Detected framework | Yes |
+
+---
+
+## Context
+
+You are analyzing a repository to extract structural maps. These maps capture the repository's architecture without needing full code access.
+
+Project: {PROJECT_PATH}
+Repository: {ALIAS}
+URL: {URL}
+Branch: {BRANCH}
+Framework: {FRAMEWORK}
+
+---
+
+## Your Task
+
+Extract structural information from the repository and generate maps.
+
+### Step 1: Access Repository
+
+Use the GitHub CLI to fetch key files:
+
+```bash
+# Fetch directory structure
+gh api repos/{owner}/{repo}/git/trees/{branch}?recursive=1
+
+# Fetch specific files
+gh api repos/{owner}/{repo}/contents/{path}?ref={branch}
+```
+
+### Step 2: Identify Key Files (Framework-Specific)
+
+**NestJS:**
+- `prisma/schema.prisma` - Data models
+- `src/**/*.controller.ts` - API endpoints
+- `src/**/*.service.ts` - Business logic
+- `src/**/*.module.ts` - Module structure
+
+**Next.js:**
+- `prisma/schema.prisma` or `src/db/schema.ts` - Data models
+- `pages/api/**/*.ts` or `app/api/**/route.ts` - API routes
+- `src/lib/**/*.ts` - Utilities and services
+- `src/components/**/*.tsx` - Components
+
+**FastAPI:**
+- `app/models/*.py` - Data models
+- `app/routers/*.py` or `app/api/*.py` - API endpoints
+- `app/services/*.py` - Business logic
+- `app/schemas/*.py` - Pydantic schemas
+
+**Express:**
+- `src/models/*.js` or `src/models/*.ts` - Data models
+- `src/routes/*.js` or `src/routes/*.ts` - API routes
+- `src/controllers/*.js` - Controllers
+- `src/services/*.js` - Services
+
+### Step 3: Parse and Extract
+
+For each key file type, extract structured data:
+
+**Entities (from ORM/schema):**
+- Model names
+- Fields with types
+- Relations
+- Enums
+
+**API (from routes/controllers):**
+- HTTP method
+- Path
+- Handler/controller
+- Request/response types
+
+**Services (from service files):**
+- Service name
+- Methods
+- Dependencies
+
+**Modules (from module structure):**
+- Module name
+- Controllers
+- Services
+- Imports
+
+### Step 4: Generate Maps
+
+Create structured maps for each category.
+
+---
+
+## Output Format
+
+Write to: {OUTPUT_FILE}
+
+```json
+{
+  "repo": "{ALIAS}",
+  "url": "{URL}",
+  "branch": "{BRANCH}",
+  "framework": "{FRAMEWORK}",
+  "analyzed_at": "2026-01-21T10:00:00Z",
+  "maps": {
+    "entities": {
+      "version": "1.0",
+      "source": "prisma/schema.prisma",
+      "models": {
+        "User": {
+          "fields": {
+            "id": { "type": "String", "attributes": ["@id", "@default(cuid())"] },
+            "email": { "type": "String", "attributes": ["@unique"] },
+            "name": { "type": "String", "attributes": ["?"] },
+            "posts": { "type": "Post[]", "relation": true }
+          }
+        },
+        "Post": {
+          "fields": {
+            "id": { "type": "String", "attributes": ["@id"] },
+            "title": { "type": "String", "attributes": [] },
+            "authorId": { "type": "String", "attributes": [] },
+            "author": { "type": "User", "relation": true }
+          }
+        }
+      },
+      "enums": {
+        "Role": ["USER", "ADMIN"]
+      }
+    },
+    "api": {
+      "version": "1.0",
+      "endpoints": {
+        "POST /users": {
+          "method": "POST",
+          "path": "/users",
+          "controller": "UsersController.create",
+          "description": "Create a new user",
+          "request_body": "CreateUserDto",
+          "response": "User"
+        },
+        "GET /users/:id": {
+          "method": "GET",
+          "path": "/users/:id",
+          "controller": "UsersController.findOne",
+          "description": "Get user by ID",
+          "params": ["id"],
+          "response": "User"
+        }
+      }
+    },
+    "services": {
+      "version": "1.0",
+      "services": {
+        "UsersService": {
+          "file": "src/users/users.service.ts",
+          "methods": ["create", "findAll", "findOne", "update", "remove"],
+          "dependencies": ["PrismaService"]
+        },
+        "AuthService": {
+          "file": "src/auth/auth.service.ts",
+          "methods": ["login", "logout", "validateUser"],
+          "dependencies": ["UsersService", "JwtService"]
+        }
+      }
+    },
+    "modules": {
+      "version": "1.0",
+      "modules": {
+        "UsersModule": {
+          "file": "src/users/users.module.ts",
+          "controllers": ["UsersController"],
+          "services": ["UsersService"],
+          "imports": ["PrismaModule"]
+        },
+        "AuthModule": {
+          "file": "src/auth/auth.module.ts",
+          "controllers": ["AuthController"],
+          "services": ["AuthService"],
+          "imports": ["UsersModule", "JwtModule"]
+        }
+      }
+    }
+  },
+  "summary": {
+    "models": 2,
+    "enums": 1,
+    "endpoints": 2,
+    "services": 2,
+    "modules": 2
+  }
+}
+```
+
+---
+
+## Rules
+
+- Use GitHub API to fetch files (requires GITHUB_TOKEN)
+- Focus on structural information, not implementation details
+- Don't include actual code, only signatures and structure
+- Handle missing files gracefully (some repos won't have all components)
+- Use consistent naming (camelCase for JSON keys)
+- Include source file paths for traceability
+- Timestamp the analysis
+
+---
+
+## Error Handling
+
+If file not found:
+```json
+{
+  "maps": {
+    "entities": {
+      "version": "1.0",
+      "source": null,
+      "error": "No Prisma schema found",
+      "models": {}
+    }
+  }
+}
+```
+
+If access denied:
+```json
+{
+  "error": "GitHub API access denied. Check GITHUB_TOKEN permissions.",
+  "maps": {}
+}
+```
+
+---
+
+## Map Storage
+
+After analysis, maps should be saved to:
+```
+docs/sync-cache/{ALIAS}/
+├── maps/
+│   ├── entities.json
+│   ├── api.json
+│   ├── services.json
+│   └── modules.json
+└── metadata.json
+```
+
+The synthesis phase will handle the actual file creation.