@windagency/valora 2.0.1

package/data/prompts/02_context/analyze-git-branch.md

@@ -0,0 +1,137 @@
+---
+id: context.analyze-git-branch
+version: 1.0.0
+category: context
+experimental: true
+name: Analyze Git Branch
+description: Analyze current Git branch state and determine base branch for PR
+tags:
+  - git
+  - branch-analysis
+  - pr-context
+model_requirements:
+  min_context: 128000
+  recommended:
+    - claude-sonnet-4.5
+agents:
+  - lead
+  - software-engineer
+dependencies:
+  requires:
+    - context.use-modern-cli-tools
+inputs:
+  - name: base_branch_arg
+    description: Optional user-specified base branch
+    type: string
+    required: false
+outputs:
+  - current_branch
+  - base_branch
+  - branch_name_convention
+  - commits_ahead
+  - commits_behind
+tokens:
+  avg: 1500
+  max: 3000
+  min: 800
+---
+
+# Analyze Git Branch
+
+## Objective
+
+Determine the current branch state, identify the appropriate base branch, and count commits ahead/behind.
+
+## Instructions
+
+### Step 1: Identify Current Branch
+
+Run:
+
+```bash
+git rev-parse --abbrev-ref HEAD
+```
+
+**Output**: Current branch name (e.g., `feature/oauth2-implementation`)
+
+### Step 2: Detect Base Branch
+
+If `base_branch_arg` is provided, use it. Otherwise, auto-detect:
+
+1. Check if `main` exists: `git rev-parse --verify main`
+2. If not, check if `master` exists: `git rev-parse --verify master`
+3. If not, check if `develop` exists: `git rev-parse --verify develop`
+4. Otherwise, use default remote branch: `git symbolic-ref refs/remotes/origin/HEAD`
+
+**Output**: Base branch name (e.g., `main`)
+
+### Step 3: Extract Branch Naming Convention
+
+Analyze the current branch name to identify the convention:
+
+- **feature/**: Feature branches
+- **bugfix/** or **fix/**: Bug fix branches
+- **hotfix/**: Hotfix branches
+- **chore/**: Maintenance branches
+- **refactor/**: Refactoring branches
+- **docs/**: Documentation branches
+- **PROJ-123-**: Ticket-first naming
+- Other patterns
+
+**Output**: Convention identifier (e.g., `feature/`, `ticket-first`)
+
+### Step 4: Count Commits Ahead and Behind
+
+**Commits ahead** (how many commits on current branch not in base):
+
+```bash
+git rev-list --count origin/<base>..HEAD
+```
+
+**Commits behind** (how many commits on base not in current branch):
+
+```bash
+git rev-list --count HEAD..origin/<base>
+```
+
+**Note**: If branch is not pushed to remote, use local base branch instead of `origin/<base>`.
+
+### Step 5: Validate Branch State
+
+Check for potential issues:
+
+- **No commits ahead**: Cannot create PR (nothing to merge)
+- **Too many commits behind**: May have merge conflicts
+- **Uncommitted changes**: Warn user (use `git status --porcelain`)
+
+## Output Format
+
+```json
+{
+	"current_branch": "feature/oauth2-implementation",
+	"base_branch": "main",
+	"branch_name_convention": "feature/",
+	"commits_ahead": 7,
+	"commits_behind": 3,
+	"validation": {
+		"can_create_pr": true,
+		"warnings": ["Branch is 3 commits behind main - may have conflicts"],
+		"uncommitted_changes": false
+	}
+}
+```
+
+## Success Criteria
+
+- ✅ Current branch identified
+- ✅ Base branch determined (auto-detect or user-specified)
+- ✅ Commits ahead/behind calculated
+- ✅ Branch naming convention extracted
+- ✅ Validation checks performed
+
+## Error Handling
+
+- **Not in a Git repository**: Exit with error
+- **Detached HEAD**: Cannot create PR from detached state
+- **No commits ahead**: Cannot create empty PR
+- **Base branch doesn't exist**: Suggest valid branches

package/data/prompts/02_context/analyze-git-status.md

@@ -0,0 +1,184 @@
+---
+id: context.analyze-git-status
+version: 1.0.0
+category: context
+experimental: true
+name: Analyze Git Status
+description: Analyze current git repository status and identify all changes ready for commit
+tags:
+  - git
+  - status-analysis
+  - change-detection
+model_requirements:
+  min_context: 128000
+  recommended:
+    - claude-sonnet-4.5
+agents:
+  - lead
+  - software-engineer
+dependencies:
+  requires:
+    - context.use-modern-cli-tools
+inputs: []
+outputs:
+  - changed_files
+  - staged_files
+  - untracked_files
+  - git_status_summary
+tokens:
+  avg: 2000
+  max: 4000
+  min: 1000
+---
+
+# Analyze Git Status
+
+## Objective
+
+Understand the current repository state and identify all changes available for commit.
+
+## Instructions
+
+### Step 1: Get Porcelain Status
+
+Execute machine-readable git status:
+
+```bash
+git status --porcelain
+```
+
+**Output format**:
+
+- `M ` = Modified (not staged)
+- ` M` = Modified (staged)
+- `MM` = Modified, staged, then modified again
+- `A ` = Added (new file, staged)
+- `??` = Untracked
+- `D ` = Deleted
+- `R ` = Renamed
+
+### Step 2: Get Change Statistics
+
+For modified tracked files:
+
+```bash
+git diff --stat
+```
+
+For staged files:
+
+```bash
+git diff --cached --stat
+```
+
+**Extract**:
+
+- Files changed
+- Lines added (+)
+- Lines deleted (-)
+- Total change magnitude
+
+### Step 3: Categorize Files
+
+Group files by status:
+
+**Modified files** (not staged):
+
+- Extract from status where first column is `M`, `D`, or `R`
+
+**Staged files**:
+
+- Extract where second column is `M`, `A`, or first column is `A`
+
+**Untracked files**:
+
+- Extract where status is `??`
+
+**Deleted files**:
+
+- Extract where status includes `D`
+
+**Renamed files**:
+
+- Extract where status is `R ` with old→new path
+
+### Step 4: Calculate Change Magnitude
+
+```plaintext
+total_additions = sum(additions from all files)
+total_deletions = sum(deletions from all files)
+total_changes = total_additions + total_deletions
+file_count = count(changed_files)
+
+magnitude =
+  if total_changes < 100: "small"
+  else if total_changes < 500: "medium"
+  else: "large"
+```
+
+### Step 5: Validate Repository State
+
+Check for issues:
+
+- **Clean working tree**: No changes to commit
+- **Unresolved conflicts**: Check for conflict markers
+- **Detached HEAD**: Cannot commit safely
+
+```bash
+# Check for conflicts
+git diff --check
+
+# Check HEAD state
+git symbolic-ref -q HEAD
+```
+
+## Output Format
+
+```json
+{
+	"changed_files": [
+		{
+			"path": "src/auth/oauth.ts",
+			"status": "modified",
+			"staged": false,
+			"additions": 95,
+			"deletions": 12
+		},
+		{
+			"path": "src/auth/tokens.ts",
+			"status": "modified",
+			"staged": false,
+			"additions": 50,
+			"deletions": 11
+		}
+	],
+	"staged_files": [],
+	"untracked_files": ["tests/auth/oauth.test.ts"],
+	"deleted_files": [],
+	"renamed_files": [],
+	"git_status_summary": {
+		"total_files": 2,
+		"total_additions": 145,
+		"total_deletions": 23,
+		"magnitude": "medium",
+		"clean": false,
+		"conflicts": false,
+		"detached_head": false
+	}
+}
+```
+
+## Success Criteria
+
+- ✅ All changed files identified
+- ✅ Files categorized by status (modified/staged/untracked)
+- ✅ Change statistics calculated
+- ✅ Repository state validated
+- ✅ No uncommitted conflicts
+
+## Error Handling
+
+- **Not in git repository**: Exit with error - cannot commit
+- **Clean working tree**: No changes to commit
+- **Unresolved conflicts**: Cannot commit until resolved
+- **Detached HEAD**: Warn user - commits will be orphaned

package/data/prompts/02_context/analyze-task-context.md

@@ -0,0 +1,397 @@
+---
+id: context.analyze-task-context
+version: 1.0.0
+category: context
+experimental: true
+name: Analyze Task Context
+description: Parse task requirements and identify affected components and scope
+tags:
+  - task-analysis
+  - scope-definition
+  - component-mapping
+model_requirements:
+  min_context: 128000
+  recommended:
+    - claude-sonnet-4.5
+    - gpt-5-thinking-high
+agents:
+  - lead
+dependencies:
+  requires:
+    - context.scan-codebase
+    - context.use-modern-cli-tools
+  optional:
+    - context.understand-intent
+inputs:
+  - name: task_description
+    description: The task requirements and description
+    type: string
+    required: true
+    validation:
+      min: 10
+  - name: gathered_knowledge
+    description: Optional gathered knowledge from knowledge base
+    type: object
+    required: false
+outputs:
+  - task_scope
+  - affected_components
+  - relevant_files
+  - scope_boundaries
+tokens:
+  avg: 3500
+  max: 7000
+  min: 2000
+---
+
+# Analyze Task Context
+
+## Objective
+
+Parse task requirements, understand what needs to be built, and identify which components of the codebase will be affected.
+
+## Context
+
+You are receiving a task description that may range from well-defined to vague. Your job is to extract actionable scope, map it to the existing codebase, and define clear boundaries.
+
+## Instructions
+
+### Step 1: Parse Task Requirements
+
+Extract key elements from `task_description`:
+
+**Identify**:
+
+1. **What** needs to be built/changed
+2. **Why** it's needed (problem being solved)
+3. **Who** will benefit (target users/systems)
+4. **Success criteria** (how we know it's done)
+5. **Constraints** (limitations, requirements)
+
+**Output**:
+
+```json
+{
+	"what": "Clear description of the change",
+	"why": "Problem or need being addressed",
+	"who": "Target users or systems",
+	"success_criteria": ["Criterion 1", "Criterion 2"],
+	"constraints": ["Constraint 1", "Constraint 2"]
+}
+```
+
+### Step 2: Define Scope Boundaries
+
+Clearly establish what IS and IS NOT included:
+
+**In Scope**:
+
+- Components/features to be modified or created
+- Required tests
+- Necessary documentation updates
+- Configuration changes
+
+**Out of Scope**:
+
+- Related features NOT included in this task
+- Future enhancements
+- Adjacent concerns deferred
+
+**Uncertain/Needs Clarification**:
+
+- Ambiguous requirements
+- Missing acceptance criteria
+- Unclear dependencies
+
+**Output**:
+
+```json
+{
+	"in_scope": ["Item 1", "Item 2", "Item 3"],
+	"out_of_scope": ["Item 1", "Item 2"],
+	"needs_clarification": ["Question 1", "Question 2"]
+}
+```
+
+### Step 3: Identify Affected Components
+
+Use `codebase_search` and `grep` to locate components that will be modified:
+
+**Areas to Map**:
+
+1. **Backend Components**:
+   - API endpoints to create/modify
+   - Services and business logic
+   - Data models and schemas
+   - Middleware or utilities
+
+2. **Frontend Components**:
+   - UI components to create/modify
+   - State management (Redux, Zustand, etc.)
+   - Routing changes
+   - Hooks or utilities
+
+3. **Data Layer**:
+   - Database schema changes
+   - Migrations needed
+   - Data validation rules
+
+4. **Infrastructure**:
+   - Configuration changes
+   - Environment variables
+   - Deployment updates
+   - CI/CD modifications
+
+5. **Testing**:
+   - Test files to create/update
+   - Test fixtures or mocks
+
+6. **Documentation**:
+   - API documentation
+   - User guides
+   - Code comments
+
+**For Each Component**:
+
+```json
+{
+	"component": "UserService",
+	"path": "src/services/user.service.ts",
+	"type": "backend",
+	"change_type": "modify",
+	"reason": "Add email verification logic",
+	"confidence": "high"
+}
+```
+
+**Use Tools**:
+
+- `codebase_search`: Find components by meaning (e.g., "Where is user authentication handled?")
+- `grep`: Find exact symbols (e.g., class names, function names)
+- `read_file`: Review relevant files to understand current implementation
+- `list_dir`: Explore directory structure
+
+### Step 4: Identify Relevant Files
+
+List specific files that need to be read or modified:
+
+**Categorize**:
+
+- **Critical**: Must be modified for the task
+- **Supporting**: May need updates (tests, docs)
+- **Reference**: Should be reviewed for context
+
+**Output**:
+
+```json
+{
+	"critical_files": [
+		{
+			"path": "src/api/auth.ts",
+			"reason": "Add new endpoint for email verification",
+			"estimated_changes": "medium"
+		}
+	],
+	"supporting_files": [
+		{
+			"path": "tests/api/auth.test.ts",
+			"reason": "Add tests for new endpoint"
+		}
+	],
+	"reference_files": [
+		{
+			"path": "src/services/email.service.ts",
+			"reason": "Understand email sending patterns"
+		}
+	]
+}
+```
+
+### Step 5: Map to Architecture
+
+Understand how the task fits into the system:
+
+**Questions**:
+
+- Which architectural layers are affected? (presentation, business, data)
+- Are there cross-cutting concerns? (logging, auth, validation)
+- Does this follow existing patterns or introduce new ones?
+- Are there similar implementations to reference?
+
+**Output**:
+
+```json
+{
+	"architectural_layers": ["api", "service", "data"],
+	"cross_cutting_concerns": ["authentication", "validation"],
+	"follows_patterns": true,
+	"similar_implementations": [
+		{
+			"feature": "Password reset flow",
+			"location": "src/api/password-reset.ts",
+			"relevance": "Similar verification token pattern"
+		}
+	]
+}
+```
+
+### Step 6: Assess Completeness
+
+Check if you have enough information to proceed:
+
+**Completeness Checklist**:
+
+- [ ] Task requirements are clear
+- [ ] Scope boundaries are defined
+- [ ] Affected components identified
+- [ ] Key files located
+- [ ] Architectural fit understood
+- [ ] No major ambiguities remain
+
+**If incomplete**:
+
+- List specific questions that need answers
+- Identify missing information
+- Suggest where to look for answers
+
+**Output**:
+
+```json
+{
+	"completeness_score": 0.85,
+	"ready_for_planning": true,
+	"missing_information": ["Clarify: Should email be required or optional?"],
+	"recommended_actions": ["Review existing email validation in UserModel"]
+}
+```
+
+## Output Format
+
+```json
+{
+	"task_scope": {
+		"summary": "Add email verification to user registration flow",
+		"what": "Implement email verification with token-based confirmation",
+		"why": "Prevent fake accounts and verify user identity",
+		"who": "New users during registration",
+		"success_criteria": [
+			"User receives verification email upon registration",
+			"User can verify email by clicking token link",
+			"Unverified users cannot access protected features"
+		],
+		"constraints": [
+			"Must use existing email service",
+			"Token expires in 24 hours",
+			"Must be backward compatible with existing users"
+		]
+	},
+	"scope_boundaries": {
+		"in_scope": [
+			"Email verification endpoint",
+			"Token generation and validation",
+			"Email template",
+			"User model update (verified_email field)",
+			"Middleware to check verification status"
+		],
+		"out_of_scope": ["Two-factor authentication", "Phone verification", "Social login integration"],
+		"needs_clarification": []
+	},
+	"affected_components": [
+		{
+			"component": "AuthAPI",
+			"path": "src/api/auth.ts",
+			"type": "backend",
+			"change_type": "modify",
+			"reason": "Add verification endpoints",
+			"confidence": "high"
+		},
+		{
+			"component": "UserModel",
+			"path": "src/models/user.model.ts",
+			"type": "data",
+			"change_type": "modify",
+			"reason": "Add email verification fields",
+			"confidence": "high"
+		},
+		{
+			"component": "EmailService",
+			"path": "src/services/email.service.ts",
+			"type": "backend",
+			"change_type": "extend",
+			"reason": "Add verification email template",
+			"confidence": "medium"
+		}
+	],
+	"relevant_files": {
+		"critical": ["src/api/auth.ts", "src/models/user.model.ts", "src/services/email.service.ts"],
+		"supporting": ["tests/api/auth.test.ts", "tests/services/email.test.ts", "docs/api/authentication.md"],
+		"reference": ["src/api/password-reset.ts"]
+	},
+	"architectural_context": {
+		"layers_affected": ["api", "service", "data"],
+		"cross_cutting_concerns": ["authentication", "email"],
+		"follows_existing_patterns": true,
+		"pattern_references": [
+			{
+				"pattern": "Token-based verification",
+				"example": "Password reset flow (src/api/password-reset.ts)"
+			}
+		]
+	},
+	"completeness_assessment": {
+		"score": 0.9,
+		"ready_for_planning": true,
+		"confidence": "high",
+		"missing_information": [],
+		"recommendations": ["Review password reset implementation for token pattern", "Check email service rate limits"]
+	}
+}
+```
+
+## Success Criteria
+
+- ✅ Task scope clearly defined with success criteria
+- ✅ Scope boundaries explicit (in/out/unclear)
+- ✅ All affected components identified
+- ✅ Critical files located
+- ✅ Architectural fit understood
+- ✅ Completeness > 80% to proceed
+- ✅ No major ambiguities remain
+
+## Rules
+
+**DO**:
+
+- ✅ Use codebase search to find relevant components
+- ✅ Be explicit about what's in and out of scope
+- ✅ Flag ambiguities immediately
+- ✅ Reference similar implementations
+- ✅ Consider all layers (API, service, data, UI)
+
+**DON'T**:
+
+- ❌ Don't assume scope - be explicit
+- ❌ Don't skip codebase exploration
+- ❌ Don't ignore existing patterns
+- ❌ Don't proceed with low completeness (<70%)
+
+## Edge Cases
+
+**Scenario: Task is vague**
+
+- Extract what you can
+- List specific clarification questions
+- Provide examples to help user clarify
+- Mark completeness as low
+
+**Scenario: No similar implementations exist**
+
+- Mark as greenfield development
+- Flag need for pattern establishment
+- Increase complexity estimate
+
+**Scenario: Multiple valid interpretations**
+
+- List all interpretations
+- Ask user to choose
+- Provide pros/cons for each