@windagency/valora 2.0.1

package/data/prompts/02_context/scan-codebase.md

@@ -0,0 +1,270 @@
+---
+id: context.scan-codebase
+version: 1.0.0
+category: context
+experimental: true
+name: Scan Codebase
+description: Analyze codebase structure, tech stack, and entry points
+tags:
+  - codebase-analysis
+  - structure-mapping
+  - tech-stack
+model_requirements:
+  min_context: 128000
+  recommended:
+    - claude-sonnet-4.5
+    - gpt-5-thinking-high
+agents:
+  - lead
+dependencies:
+  requires:
+    - context.use-modern-cli-tools
+inputs:
+  - name: scope
+    description: Analysis scope (project or task)
+    type: string
+    required: false
+    default: project
+    validation:
+      enum: ['project', 'task']
+  - name: domain
+    description: Domain filter for focused analysis
+    type: string
+    required: false
+    default: all
+    validation:
+      enum: ['backend', 'frontend', 'infrastructure', 'data', 'all']
+  - name: depth
+    description: Analysis depth level
+    type: string
+    required: false
+    default: deep
+    validation:
+      enum: ['shallow', 'deep']
+outputs:
+  - codebase_structure
+  - tech_stack
+  - entry_points
+tokens:
+  avg: 4000
+  max: 8000
+  min: 2000
+---
+
+# Scan Codebase
+
+## Objective
+
+Create a high-level map of codebase organization, identify tech stack, and locate entry points based on common project patterns and file structures.
+
+## Instructions
+
+You are an AI assistant with knowledge of common codebase structures and technologies. Analyze the project based on typical file naming conventions, directory structures, and technology patterns. Provide your analysis in the specified JSON format.
+
+### Step 1: Identify Project Type & Tech Stack
+
+Based on typical project structures and file patterns, determine:
+
+**Project Analysis Approach**:
+
+- Examine file extensions (.ts, .js, .py, .java, .go, .rs) to identify primary languages
+- Look for configuration files that indicate frameworks and build systems
+- Check for common directory structures (src/, packages/, lib/, app/, etc.)
+- Identify runtime environments from common patterns
+
+**Technology Detection Patterns**:
+
+- **Node.js/npm**: package.json, node_modules/, .nvmrc, yarn.lock/pnpm-lock.yaml
+- **Python**: requirements.txt, pyproject.toml, setup.py, venv/
+- **Java**: pom.xml, build.gradle, src/main/java/
+- **Go**: go.mod, go.sum, cmd/, internal/
+- **Rust**: Cargo.toml, Cargo.lock, src/, target/
+- **Docker**: Dockerfile, docker-compose.yml, .dockerignore
+- **CI/CD**: .github/workflows/, .gitlab-ci.yml, Jenkinsfile
+
+### Step 2: Structure Analysis
+
+**Directory Structure Analysis**:
+Based on the technology stack identified, map the expected directory structure:
+
+**Final Output**:
+Provide the complete analysis in this exact JSON structure:
+
+```json
+{
+	"codebase_structure": {
+		"project_type": "web_app",
+		"organization": "monorepo",
+		"directories": {
+			".github/": {
+				"purpose": "CI/CD workflows",
+				"pattern": "GitHub Actions configuration"
+			},
+			"packages/": {
+				"purpose": "Source code for all applications and libraries",
+				"pattern": "pnpm workspace modules"
+			}
+		},
+		"modules": [
+			{
+				"name": "api",
+				"path": "packages/api",
+				"type": "Express.js API"
+			},
+			{
+				"name": "web",
+				"path": "packages/web",
+				"type": "React application"
+			}
+		]
+	},
+	"tech_stack": {
+		"languages": ["TypeScript"],
+		"frameworks": {
+			"backend": ["Express 4.18.2"],
+			"frontend": ["React 18.2.0", "Vite 5.2.0"]
+		},
+		"build_system": "pnpm (workspaces)",
+		"testing": ["Vitest"],
+		"runtime": "Node.js (unspecified version, likely >=18 based on ecosystem)"
+	},
+	"entry_points": [
+		{
+			"type": "backend",
+			"file": "packages/api/src/index.ts",
+			"purpose": "Express API server entry point"
+		},
+		{
+			"type": "frontend",
+			"file": "packages/web/src/main.tsx",
+			"purpose": "React application root"
+		}
+	]
+}
+```
+
+### Step 2: Map Directory Structure
+
+Based on common project patterns, map the expected directory structure and purposes:
+
+**Common Directory Patterns**:
+
+- `src/` or `lib/` or `packages/`: Source code (feature-based, layer-based, or domain-driven)
+- `tests/` or `__tests__/` or `spec/`: Test files
+- `docs/` or `README.md`: Documentation
+- `scripts/` or `tools/`: Build/deployment scripts
+- `config/` or `.github/`: Configuration and CI/CD
+- `public/` or `static/` or `assets/`: Static assets
+
+**Organization Pattern Detection**:
+
+- **Feature-based**: `src/features/user/`, `src/features/auth/`
+- **Layer-based**: `src/controllers/`, `src/services/`, `src/models/`
+- **Domain-driven**: `src/user/`, `src/order/`, `src/payment/`
+
+**Domain-Specific Focus** (if filter provided):
+
+- `domain=backend`: API routes, services, models, database configs
+- `domain=frontend`: Components, pages, styles, state management
+- `domain=infrastructure`: Docker, deployment, CI/CD configs
+- `domain=data`: Schemas, migrations, seed files, data access layers
+
+### Step 4: Identify Module Boundaries
+
+**For monorepos/multi-module projects**:
+
+- List all packages/modules
+- Document inter-module dependencies
+- Note shared libraries
+
+**For single-module projects**:
+
+- Identify logical module boundaries
+- Document layer separation (if applicable)
+
+### Step 5: Apply Depth Level
+
+**If depth = "shallow"**:
+
+- High-level structure only
+- Main directories and purposes
+- Key entry points
+- Skip detailed file analysis
+
+**If depth = "deep"**:
+
+- Detailed directory analysis
+- File organization patterns
+- Module relationships
+- Configuration details
+
+## Output Format
+
+```json
+{
+	"codebase_structure": {
+		"project_type": "web_app",
+		"organization": "monorepo|single|multi-module",
+		"directories": {
+			"src/": { "purpose": "...", "pattern": "..." },
+			"tests/": { "purpose": "...", "pattern": "..." }
+		},
+		"modules": [
+			{
+				"name": "frontend",
+				"path": "packages/frontend",
+				"type": "React app"
+			}
+		]
+	},
+	"tech_stack": {
+		"languages": ["TypeScript", "Python"],
+		"frameworks": {
+			"backend": ["Express 4.18"],
+			"frontend": ["React 18.2", "Vite 5.0"]
+		},
+		"build_system": "pnpm",
+		"testing": ["Vitest", "Playwright"],
+		"runtime": "Node.js 20.x"
+	},
+	"entry_points": [
+		{
+			"type": "backend",
+			"file": "src/server.ts",
+			"purpose": "Express API server"
+		},
+		{
+			"type": "frontend",
+			"file": "src/main.tsx",
+			"purpose": "React app entry"
+		}
+	]
+}
+```
+
+## Success Criteria
+
+- ✅ `codebase_structure` object with project_type, organization, directories, and modules
+- ✅ `tech_stack` object with languages, frameworks, build_system, testing, and runtime
+- ✅ `entry_points` array with type, file, and purpose for each entry point
+- ✅ JSON structure matches the specified format exactly
+- ✅ All fields populated based on typical project patterns
+- ✅ Analysis appropriate for the specified domain and depth parameters
+
+## Rules
+
+**DO**:
+
+- ✅ Base analysis on common project patterns and file structures
+- ✅ Use typical naming conventions and directory layouts
+- ✅ Provide realistic technology stack based on file patterns
+- ✅ Structure output exactly as specified in the JSON format
+- ✅ Apply domain and depth filters appropriately
+
+**DON'T**:
+
+- ❌ Don't execute any commands or scripts
+- ❌ Don't reference actual file contents you can't read
+- ❌ Don't make assumptions beyond common patterns
+- ❌ Don't deviate from the specified JSON structure
+- ❌ Don't include explanatory text outside the JSON

package/data/prompts/02_context/understand-intent.md

@@ -0,0 +1,145 @@
+---
+id: context.understand-intent
+version: 1.0.0
+category: context
+experimental: true
+name: Understand Intent
+description: Capture the essence of what the user wants to build and confirm initial understanding
+tags:
+  - context-gathering
+  - requirements
+  - initial-analysis
+model_requirements:
+  min_context: 128000
+  recommended:
+    - gpt-5-thinking-high
+agents:
+  - product-manager
+inputs:
+  - name: initial_concept
+    description: The user's initial concept or project idea
+    type: string
+    required: true
+    validation:
+      min: 10
+  - name: domain
+    description: Optional domain or industry context
+    type: string
+    required: false
+outputs:
+  - user_intent
+  - initial_scope
+  - problem_statement
+  - target_users
+  - constraints_identified
+tokens:
+  avg: 2500
+  max: 5000
+  min: 1500
+---
+
+# Understand Intent
+
+## Objective
+
+Capture the essence of what the user wants to build and confirm your understanding before diving into detailed clarification.
+
+## Context
+
+You are receiving the user's initial concept. This may range from a vague idea to a partially formed specification. Your job is to extract signal from noise and confirm alignment.
+
+## Instructions
+
+### Step 1: Read and Analyze
+
+Examine the user's input (`$initial_concept`) and identify:
+
+1. **The Problem Being Solved**
+   - What pain point or need is being addressed?
+   - Why does this problem matter?
+   - What are the consequences of not solving it?
+
+2. **The Target Users or Beneficiaries**
+   - Who will use or benefit from this?
+   - What are their characteristics (technical proficiency, context, constraints)?
+   - Are there primary vs. secondary user groups?
+
+3. **The Desired Outcomes or Success Metrics**
+   - What does success look like?
+   - What measurable improvements are expected?
+   - What is the minimum viable outcome?
+
+4. **Any Constraints Mentioned**
+   - **Time**: Are there deadlines or timeline expectations?
+   - **Budget**: Are there cost limitations?
+   - **Technical**: Are there existing systems, platforms, or technologies to consider?
+   - **Regulatory/Legal**: Are there compliance requirements?
+   - **Resources**: Are there team size or skill limitations?
+
+### Step 2: Synthesize Understanding
+
+Create a concise understanding statement (2-3 sentences) that captures:
+
+- The core problem
+- The intended solution direction
+- The primary user/beneficiary
+- Key constraints (if any)
+
+**Example Format**:
+
+> **Initial Understanding**: This project aims to [solve problem X] for [target users Y] by [high-level approach Z]. The primary constraint is [constraint if applicable], and success will be measured by [outcome].
+
+**Note on Interaction**:
+Do not ask the user for confirmation. Instead, provide your analysis in the required JSON format. Use the `confidence_score` and `missing_information` fields to indicate uncertainty.
+
+## Output Format
+
+Return ONLY a structured JSON object. Do not output any conversational text before or after the JSON.
+
+```json
+{
+	"user_intent": {
+		"problem": "Clear problem statement",
+		"solution_direction": "High-level approach",
+		"target_users": "Primary and secondary users",
+		"success_criteria": "Initial success indicators"
+	},
+	"initial_scope": {
+		"in_scope": ["Item 1", "Item 2"],
+		"likely_out_of_scope": ["Item 1", "Item 2"],
+		"unclear": ["Item 1", "Item 2"]
+	},
+	"constraints_identified": {
+		"time": "Description or null",
+		"budget": "Description or null",
+		"technical": "Description or null",
+		"regulatory": "Description or null",
+		"other": "Description or null"
+	},
+	"confidence_score": 0.75,
+	"missing_information": ["Critical gap 1", "Critical gap 2"],
+	"recommended_next_questions": ["Question 1", "Question 2", "Question 3"]
+}
+```
+
+## Success Criteria
+
+- ✅ Core problem is clearly identified
+- ✅ Target users are described (even if broadly)
+- ✅ At least one success criterion is identified
+- ✅ Constraints are explicitly listed or marked as "none identified"
+- ✅ User confirms understanding is accurate
+
+## Failure Modes
+
+- ❌ **Assuming too much**: If unclear, mark as "unclear" rather than guessing
+- ❌ **Being too vague**: "Improve user experience" is not a problem statement
+- ❌ **Skipping confirmation**: Always confirm before proceeding
+- ❌ **Overcomplicating**: Keep this stage simple and high-level
+
+## Notes
+
+- This is a **divergent** phase: cast a wide net
+- Don't worry about completeness yet
+- Focus on alignment, not detail
+- If the user provides very detailed input, extract the essence rather than restating everything