mirror of
https://github.com/catlog22/Claude-Code-Workflow.git
synced 2026-02-28 09:23:08 +08:00
feat: Add roles for issue resolution pipeline including planner, reviewer, integrator, and implementer
- Implemented `planner` role for solution design and task decomposition using issue-plan-agent. - Introduced `reviewer` role for solution review, technical feasibility validation, and risk assessment. - Created `integrator` role for queue formation and conflict detection using issue-queue-agent. - Added `implementer` role for code implementation and test verification via code-developer. - Defined message types and role boundaries for each role to ensure clear responsibilities. - Established a team configuration file to manage roles, pipelines, and collaboration patterns for the issue processing pipeline.
This commit is contained in:
catlog22
@@ -69,9 +69,31 @@ Task Pipeline (generated in Phase 4, executed in Phase 5):
|
||||
/workflow:test-cycle-execute --max-iterations=15
|
||||
```
|
||||
|
||||
## Auto Mode
|
||||
## Interactive Preference Collection
|
||||
|
||||
When `--yes` or `-y`: Auto-select first active session, skip confirmations, auto-complete on success.
|
||||
Before dispatching to phase execution, collect workflow preferences via AskUserQuestion:
|
||||
|
||||
```javascript
|
||||
const prefResponse = AskUserQuestion({
|
||||
questions: [
|
||||
{
|
||||
question: "是否跳过所有确认步骤（自动模式）？",
|
||||
header: "Auto Mode",
|
||||
multiSelect: false,
|
||||
options: [
|
||||
{ label: "Interactive (Recommended)", description: "交互模式，包含确认步骤" },
|
||||
{ label: "Auto", description: "跳过所有确认，自动执行" }
|
||||
]
|
||||
}
|
||||
]
|
||||
})
|
||||
|
||||
workflowPreferences = {
|
||||
autoYes: prefResponse.autoMode === 'Auto'
|
||||
}
|
||||
```
|
||||
|
||||
**workflowPreferences** is passed to phase execution as context variable, referenced as `workflowPreferences.autoYes` within phases.
|
||||
|
||||
## Execution Flow
|
||||
|
||||
|
||||
@@ -11,14 +11,441 @@ Gather test context via coverage analysis or codebase scan.
|
||||
|
||||
### Step 1.2: Gather Test Context
|
||||
|
||||
```
|
||||
// Session Mode - gather from source session
|
||||
Skill(skill="workflow:tools:test-context-gather", args="--session [testSessionId]")
|
||||
Two modes are available depending on whether a source session exists:
|
||||
|
||||
// Prompt Mode - gather from codebase
|
||||
Skill(skill="workflow:tools:context-gather", args="--session [testSessionId] \"[task_description]\"")
|
||||
---
|
||||
|
||||
### Mode A: Session Mode (gather from source session)
|
||||
|
||||
Collect test coverage context using test-context-search-agent and package into standardized test-context JSON.
|
||||
|
||||
#### Core Philosophy
|
||||
|
||||
- **Agent Delegation**: Delegate all test coverage analysis to `test-context-search-agent` for autonomous execution
|
||||
- **Detection-First**: Check for existing test-context-package before executing
|
||||
- **Coverage-First**: Analyze existing test coverage before planning new tests
|
||||
- **Source Context Loading**: Import implementation summaries from source session
|
||||
- **Standardized Output**: Generate `.workflow/active/{test_session_id}/.process/test-context-package.json`
|
||||
|
||||
#### Step A.1: Test-Context-Package Detection
|
||||
|
||||
**Execute First** - Check if valid package already exists:
|
||||
|
||||
```javascript
|
||||
const testContextPath = `.workflow/${test_session_id}/.process/test-context-package.json`;
|
||||
|
||||
if (file_exists(testContextPath)) {
|
||||
const existing = Read(testContextPath);
|
||||
|
||||
// Validate package belongs to current test session
|
||||
if (existing?.metadata?.test_session_id === test_session_id) {
|
||||
console.log("Valid test-context-package found for session:", test_session_id);
|
||||
console.log("Coverage Stats:", existing.test_coverage.coverage_stats);
|
||||
console.log("Framework:", existing.test_framework.framework);
|
||||
console.log("Missing Tests:", existing.test_coverage.missing_tests.length);
|
||||
return existing; // Skip execution, return existing
|
||||
} else {
|
||||
console.warn("Invalid test_session_id in existing package, re-generating...");
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
#### Step A.2: Invoke Test-Context-Search Agent
|
||||
|
||||
**Only execute if Step A.1 finds no valid package**
|
||||
|
||||
```javascript
|
||||
Task(
|
||||
subagent_type="test-context-search-agent",
|
||||
run_in_background=false,
|
||||
description="Gather test coverage context",
|
||||
prompt=`
|
||||
|
||||
## Execution Mode
|
||||
**PLAN MODE** (Comprehensive) - Full Phase 1-3 execution
|
||||
|
||||
## Session Information
|
||||
- **Test Session ID**: ${test_session_id}
|
||||
- **Output Path**: .workflow/${test_session_id}/.process/test-context-package.json
|
||||
|
||||
## Mission
|
||||
Execute complete test-context-search-agent workflow for test generation planning:
|
||||
|
||||
### Phase 1: Session Validation & Source Context Loading
|
||||
1. **Detection**: Check for existing test-context-package (early exit if valid)
|
||||
2. **Test Session Validation**: Load test session metadata, extract source_session reference
|
||||
3. **Source Context Loading**: Load source session implementation summaries, changed files, tech stack
|
||||
|
||||
### Phase 2: Test Coverage Analysis
|
||||
Execute coverage discovery:
|
||||
- **Track 1**: Existing test discovery (find *.test.*, *.spec.* files)
|
||||
- **Track 2**: Coverage gap analysis (match implementation files to test files)
|
||||
- **Track 3**: Coverage statistics (calculate percentages, identify gaps by module)
|
||||
|
||||
### Phase 3: Framework Detection & Packaging
|
||||
1. Framework identification from package.json/requirements.txt
|
||||
2. Convention analysis from existing test patterns
|
||||
3. Generate and validate test-context-package.json
|
||||
|
||||
## Output Requirements
|
||||
Complete test-context-package.json with:
|
||||
- **metadata**: test_session_id, source_session_id, task_type, complexity
|
||||
- **source_context**: implementation_summaries, tech_stack, project_patterns
|
||||
- **test_coverage**: existing_tests[], missing_tests[], coverage_stats
|
||||
- **test_framework**: framework, version, test_pattern, conventions
|
||||
- **assets**: implementation_summary[], existing_test[], source_code[] with priorities
|
||||
- **focus_areas**: Test generation guidance based on coverage gaps
|
||||
|
||||
## Quality Validation
|
||||
Before completion verify:
|
||||
- [ ] Valid JSON format with all required fields
|
||||
- [ ] Source session context loaded successfully
|
||||
- [ ] Test coverage gaps identified
|
||||
- [ ] Test framework detected (or marked as 'unknown')
|
||||
- [ ] Coverage percentage calculated correctly
|
||||
- [ ] Missing tests catalogued with priority
|
||||
- [ ] Execution time < 30 seconds (< 60s for large codebases)
|
||||
|
||||
Execute autonomously following agent documentation.
|
||||
Report completion with coverage statistics.
|
||||
`
|
||||
)
|
||||
```
|
||||
|
||||
#### Step A.3: Output Verification
|
||||
|
||||
After agent completes, verify output:
|
||||
|
||||
```javascript
|
||||
// Verify file was created
|
||||
const outputPath = `.workflow/${test_session_id}/.process/test-context-package.json`;
|
||||
if (!file_exists(outputPath)) {
|
||||
throw new Error("Agent failed to generate test-context-package.json");
|
||||
}
|
||||
|
||||
// Load and display summary
|
||||
const testContext = Read(outputPath);
|
||||
console.log("Test context package generated successfully");
|
||||
console.log("Coverage:", testContext.test_coverage.coverage_stats.coverage_percentage + "%");
|
||||
console.log("Tests to generate:", testContext.test_coverage.missing_tests.length);
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
### Mode B: Prompt Mode (gather from codebase)
|
||||
|
||||
Intelligently collect project context using context-search-agent based on task description, packages into standardized JSON.
|
||||
|
||||
#### Core Philosophy
|
||||
|
||||
- **Agent Delegation**: Delegate all discovery to `context-search-agent` for autonomous execution
|
||||
- **Detection-First**: Check for existing context-package before executing
|
||||
- **Plan Mode**: Full comprehensive analysis (vs lightweight brainstorm mode)
|
||||
- **Standardized Output**: Generate `.workflow/active/{session}/.process/context-package.json`
|
||||
|
||||
#### Step B.1: Context-Package Detection
|
||||
|
||||
**Execute First** - Check if valid package already exists:
|
||||
|
||||
```javascript
|
||||
const contextPackagePath = `.workflow/${session_id}/.process/context-package.json`;
|
||||
|
||||
if (file_exists(contextPackagePath)) {
|
||||
const existing = Read(contextPackagePath);
|
||||
|
||||
// Validate package belongs to current session
|
||||
if (existing?.metadata?.session_id === session_id) {
|
||||
console.log("Valid context-package found for session:", session_id);
|
||||
console.log("Stats:", existing.statistics);
|
||||
console.log("Conflict Risk:", existing.conflict_detection.risk_level);
|
||||
return existing; // Skip execution, return existing
|
||||
} else {
|
||||
console.warn("Invalid session_id in existing package, re-generating...");
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
#### Step B.2: Complexity Assessment & Parallel Explore
|
||||
|
||||
**Only execute if Step B.1 finds no valid package**
|
||||
|
||||
```javascript
|
||||
// B.2.1 Complexity Assessment
|
||||
function analyzeTaskComplexity(taskDescription) {
|
||||
const text = taskDescription.toLowerCase();
|
||||
if (/architect|refactor|restructure|modular|cross-module/.test(text)) return 'High';
|
||||
if (/multiple|several|integrate|migrate|extend/.test(text)) return 'Medium';
|
||||
return 'Low';
|
||||
}
|
||||
|
||||
const ANGLE_PRESETS = {
|
||||
architecture: ['architecture', 'dependencies', 'modularity', 'integration-points'],
|
||||
security: ['security', 'auth-patterns', 'dataflow', 'validation'],
|
||||
performance: ['performance', 'bottlenecks', 'caching', 'data-access'],
|
||||
bugfix: ['error-handling', 'dataflow', 'state-management', 'edge-cases'],
|
||||
feature: ['patterns', 'integration-points', 'testing', 'dependencies'],
|
||||
refactor: ['architecture', 'patterns', 'dependencies', 'testing']
|
||||
};
|
||||
|
||||
function selectAngles(taskDescription, complexity) {
|
||||
const text = taskDescription.toLowerCase();
|
||||
let preset = 'feature';
|
||||
if (/refactor|architect|restructure/.test(text)) preset = 'architecture';
|
||||
else if (/security|auth|permission/.test(text)) preset = 'security';
|
||||
else if (/performance|slow|optimi/.test(text)) preset = 'performance';
|
||||
else if (/fix|bug|error|issue/.test(text)) preset = 'bugfix';
|
||||
|
||||
const count = complexity === 'High' ? 4 : (complexity === 'Medium' ? 3 : 1);
|
||||
return ANGLE_PRESETS[preset].slice(0, count);
|
||||
}
|
||||
|
||||
const complexity = analyzeTaskComplexity(task_description);
|
||||
const selectedAngles = selectAngles(task_description, complexity);
|
||||
const sessionFolder = `.workflow/active/${session_id}/.process`;
|
||||
|
||||
// B.2.2 Launch Parallel Explore Agents
|
||||
const explorationTasks = selectedAngles.map((angle, index) =>
|
||||
Task(
|
||||
subagent_type="cli-explore-agent",
|
||||
run_in_background=false,
|
||||
description=`Explore: ${angle}`,
|
||||
prompt=`
|
||||
## Task Objective
|
||||
Execute **${angle}** exploration for task planning context. Analyze codebase from this specific angle to discover relevant structure, patterns, and constraints.
|
||||
|
||||
## Assigned Context
|
||||
- **Exploration Angle**: ${angle}
|
||||
- **Task Description**: ${task_description}
|
||||
- **Session ID**: ${session_id}
|
||||
- **Exploration Index**: ${index + 1} of ${selectedAngles.length}
|
||||
- **Output File**: ${sessionFolder}/exploration-${angle}.json
|
||||
|
||||
## MANDATORY FIRST STEPS (Execute by Agent)
|
||||
1. Run: ccw tool exec get_modules_by_depth '{}' (project structure)
|
||||
2. Run: rg -l "{keyword_from_task}" --type ts (locate relevant files)
|
||||
3. Execute: cat ~/.ccw/workflows/cli-templates/schemas/explore-json-schema.json (get output schema reference)
|
||||
|
||||
## Exploration Strategy (${angle} focus)
|
||||
|
||||
**Step 1: Structural Scan** (Bash)
|
||||
- get_modules_by_depth.sh -> identify modules related to ${angle}
|
||||
- find/rg -> locate files relevant to ${angle} aspect
|
||||
- Analyze imports/dependencies from ${angle} perspective
|
||||
|
||||
**Step 2: Semantic Analysis** (Gemini CLI)
|
||||
- How does existing code handle ${angle} concerns?
|
||||
- What patterns are used for ${angle}?
|
||||
- Where would new code integrate from ${angle} viewpoint?
|
||||
|
||||
**Step 3: Write Output**
|
||||
- Consolidate ${angle} findings into JSON
|
||||
- Identify ${angle}-specific clarification needs
|
||||
|
||||
## Expected Output
|
||||
|
||||
**File**: ${sessionFolder}/exploration-${angle}.json
|
||||
|
||||
**Schema Reference**: Schema obtained in MANDATORY FIRST STEPS step 3, follow schema exactly
|
||||
|
||||
**Required Fields** (all ${angle} focused):
|
||||
- project_structure: Modules/architecture relevant to ${angle}
|
||||
- relevant_files: Files affected from ${angle} perspective
|
||||
**MANDATORY**: Every file MUST use structured object format with ALL required fields:
|
||||
[{path: "src/file.ts", relevance: 0.85, rationale: "Contains AuthService.login() - entry point for JWT token generation", role: "modify_target", discovery_source: "bash-scan", key_symbols: ["AuthService", "login"]}]
|
||||
- **rationale** (required): Specific selection basis tied to ${angle} topic (>10 chars, not generic)
|
||||
- **role** (required): modify_target|dependency|pattern_reference|test_target|type_definition|integration_point|config|context_only
|
||||
- **discovery_source** (recommended): bash-scan|cli-analysis|ace-search|dependency-trace|manual
|
||||
- **key_symbols** (recommended): Key functions/classes/types in the file relevant to the task
|
||||
- Scores: 0.7+ high priority, 0.5-0.7 medium, <0.5 low
|
||||
- patterns: ${angle}-related patterns to follow
|
||||
- dependencies: Dependencies relevant to ${angle}
|
||||
- integration_points: Where to integrate from ${angle} viewpoint (include file:line locations)
|
||||
- constraints: ${angle}-specific limitations/conventions
|
||||
- clarification_needs: ${angle}-related ambiguities (options array + recommended index)
|
||||
- _metadata.exploration_angle: "${angle}"
|
||||
|
||||
## Success Criteria
|
||||
- [ ] Schema obtained via cat explore-json-schema.json
|
||||
- [ ] get_modules_by_depth.sh executed
|
||||
- [ ] At least 3 relevant files identified with ${angle} rationale
|
||||
- [ ] Patterns are actionable (code examples, not generic advice)
|
||||
- [ ] Integration points include file:line locations
|
||||
- [ ] Constraints are project-specific to ${angle}
|
||||
- [ ] JSON output follows schema exactly
|
||||
- [ ] clarification_needs includes options + recommended
|
||||
|
||||
## Output
|
||||
Write: ${sessionFolder}/exploration-${angle}.json
|
||||
Return: 2-3 sentence summary of ${angle} findings
|
||||
`
|
||||
)
|
||||
);
|
||||
|
||||
// B.2.3 Generate Manifest after all complete
|
||||
const explorationFiles = bash(`find ${sessionFolder} -name "exploration-*.json" -type f`).split('\n').filter(f => f.trim());
|
||||
const explorationManifest = {
|
||||
session_id,
|
||||
task_description,
|
||||
timestamp: new Date().toISOString(),
|
||||
complexity,
|
||||
exploration_count: selectedAngles.length,
|
||||
angles_explored: selectedAngles,
|
||||
explorations: explorationFiles.map(file => {
|
||||
const data = JSON.parse(Read(file));
|
||||
return { angle: data._metadata.exploration_angle, file: file.split('/').pop(), path: file, index: data._metadata.exploration_index };
|
||||
})
|
||||
};
|
||||
Write(`${sessionFolder}/explorations-manifest.json`, JSON.stringify(explorationManifest, null, 2));
|
||||
```
|
||||
|
||||
#### Step B.3: Invoke Context-Search Agent
|
||||
|
||||
**Only execute after Step B.2 completes**
|
||||
|
||||
```javascript
|
||||
// Load user intent from planning-notes.md (from Phase 1)
|
||||
const planningNotesPath = `.workflow/active/${session_id}/planning-notes.md`;
|
||||
let userIntent = { goal: task_description, key_constraints: "None specified" };
|
||||
|
||||
if (file_exists(planningNotesPath)) {
|
||||
const notesContent = Read(planningNotesPath);
|
||||
const goalMatch = notesContent.match(/\*\*GOAL\*\*:\s*(.+)/);
|
||||
const constraintsMatch = notesContent.match(/\*\*KEY_CONSTRAINTS\*\*:\s*(.+)/);
|
||||
if (goalMatch) userIntent.goal = goalMatch[1].trim();
|
||||
if (constraintsMatch) userIntent.key_constraints = constraintsMatch[1].trim();
|
||||
}
|
||||
|
||||
Task(
|
||||
subagent_type="context-search-agent",
|
||||
run_in_background=false,
|
||||
description="Gather comprehensive context for plan",
|
||||
prompt=`
|
||||
## Execution Mode
|
||||
**PLAN MODE** (Comprehensive) - Full Phase 1-3 execution with priority sorting
|
||||
|
||||
## Session Information
|
||||
- **Session ID**: ${session_id}
|
||||
- **Task Description**: ${task_description}
|
||||
- **Output Path**: .workflow/${session_id}/.process/context-package.json
|
||||
|
||||
## User Intent (from Phase 1 - Planning Notes)
|
||||
**GOAL**: ${userIntent.goal}
|
||||
**KEY_CONSTRAINTS**: ${userIntent.key_constraints}
|
||||
|
||||
This is the PRIMARY context source - all subsequent analysis must align with user intent.
|
||||
|
||||
## Exploration Input (from Step B.2)
|
||||
- **Manifest**: ${sessionFolder}/explorations-manifest.json
|
||||
- **Exploration Count**: ${explorationManifest.exploration_count}
|
||||
- **Angles**: ${explorationManifest.angles_explored.join(', ')}
|
||||
- **Complexity**: ${complexity}
|
||||
|
||||
## Mission
|
||||
Execute complete context-search-agent workflow for implementation planning:
|
||||
|
||||
### Phase 1: Initialization & Pre-Analysis
|
||||
1. **Project State Loading**:
|
||||
- Read and parse .workflow/project-tech.json. Use its overview section as the foundational project_context.
|
||||
- Read and parse .workflow/project-guidelines.json. Load conventions, constraints, and learnings into a project_guidelines section.
|
||||
- If files don't exist, proceed with fresh analysis.
|
||||
2. **Detection**: Check for existing context-package (early exit if valid)
|
||||
3. **Foundation**: Initialize CodexLens, get project structure, load docs
|
||||
4. **Analysis**: Extract keywords, determine scope, classify complexity based on task description and project state
|
||||
|
||||
### Phase 2: Multi-Source Context Discovery
|
||||
Execute all discovery tracks (WITH USER INTENT INTEGRATION):
|
||||
- **Track -1**: User Intent & Priority Foundation (EXECUTE FIRST)
|
||||
- Load user intent (GOAL, KEY_CONSTRAINTS) from session input
|
||||
- Map user requirements to codebase entities (files, modules, patterns)
|
||||
- Establish baseline priority scores based on user goal alignment
|
||||
- Output: user_intent_mapping.json with preliminary priority scores
|
||||
|
||||
- **Track 0**: Exploration Synthesis (load explorations-manifest.json, prioritize critical_files, deduplicate patterns/integration_points)
|
||||
- **Track 1**: Historical archive analysis (query manifest.json for lessons learned)
|
||||
- **Track 2**: Reference documentation (CLAUDE.md, architecture docs)
|
||||
- **Track 3**: Web examples (use Exa MCP for unfamiliar tech/APIs)
|
||||
- **Track 4**: Codebase analysis (5-layer discovery: files, content, patterns, deps, config/tests)
|
||||
|
||||
### Phase 3: Synthesis, Assessment & Packaging
|
||||
1. Apply relevance scoring and build dependency graph
|
||||
2. **Synthesize 5-source data** (including Track -1): Merge findings from all sources
|
||||
- Priority order: User Intent > Archive > Docs > Exploration > Code > Web
|
||||
- **Prioritize the context from project-tech.json** for architecture and tech stack unless code analysis reveals it's outdated
|
||||
3. **Context Priority Sorting**:
|
||||
a. Combine scores from Track -1 (user intent alignment) + relevance scores + exploration critical_files
|
||||
b. Classify files into priority tiers:
|
||||
- **Critical** (score >= 0.85): Directly mentioned in user goal OR exploration critical_files
|
||||
- **High** (0.70-0.84): Key dependencies, patterns required for goal
|
||||
- **Medium** (0.50-0.69): Supporting files, indirect dependencies
|
||||
- **Low** (< 0.50): Contextual awareness only
|
||||
c. Generate dependency_order: Based on dependency graph + user goal sequence
|
||||
d. Document sorting_rationale: Explain prioritization logic
|
||||
4. **Populate project_context**: Directly use the overview from project-tech.json
|
||||
5. **Populate project_guidelines**: Load from project-guidelines.json
|
||||
6. Integrate brainstorm artifacts (if .brainstorming/ exists, read content)
|
||||
7. Perform conflict detection with risk assessment
|
||||
8. **Inject historical conflicts** from archive analysis into conflict_detection
|
||||
9. **Generate prioritized_context section**:
|
||||
{
|
||||
"prioritized_context": {
|
||||
"user_intent": { "goal": "...", "scope": "...", "key_constraints": ["..."] },
|
||||
"priority_tiers": {
|
||||
"critical": [{ "path": "...", "relevance": 0.95, "rationale": "..." }],
|
||||
"high": [...], "medium": [...], "low": [...]
|
||||
},
|
||||
"dependency_order": ["module1", "module2", "module3"],
|
||||
"sorting_rationale": "Based on user goal alignment, exploration critical files, and dependency graph"
|
||||
}
|
||||
}
|
||||
10. Generate and validate context-package.json with prioritized_context field
|
||||
|
||||
## Output Requirements
|
||||
Complete context-package.json with:
|
||||
- **metadata**: task_description, keywords, complexity, tech_stack, session_id
|
||||
- **project_context**: description, technology_stack, architecture, key_components (from project-tech.json)
|
||||
- **project_guidelines**: {conventions, constraints, quality_rules, learnings} (from project-guidelines.json)
|
||||
- **assets**: {documentation[], source_code[], config[], tests[]} with relevance scores
|
||||
- **dependencies**: {internal[], external[]} with dependency graph
|
||||
- **brainstorm_artifacts**: {guidance_specification, role_analyses[], synthesis_output} with content
|
||||
- **conflict_detection**: {risk_level, risk_factors, affected_modules[], mitigation_strategy, historical_conflicts[]}
|
||||
- **exploration_results**: {manifest_path, exploration_count, angles, explorations[], aggregated_insights}
|
||||
- **prioritized_context**: {user_intent, priority_tiers{critical, high, medium, low}, dependency_order[], sorting_rationale}
|
||||
|
||||
## Quality Validation
|
||||
Before completion verify:
|
||||
- [ ] Valid JSON format with all required fields
|
||||
- [ ] File relevance accuracy >80%
|
||||
- [ ] Dependency graph complete (max 2 transitive levels)
|
||||
- [ ] Conflict risk level calculated correctly
|
||||
- [ ] No sensitive data exposed
|
||||
- [ ] Total files <= 50 (prioritize high-relevance)
|
||||
|
||||
Execute autonomously following agent documentation.
|
||||
Report completion with statistics.
|
||||
`
|
||||
)
|
||||
```
|
||||
|
||||
#### Step B.4: Output Verification
|
||||
|
||||
After agent completes, verify output:
|
||||
|
||||
```javascript
|
||||
// Verify file was created
|
||||
const outputPath = `.workflow/${session_id}/.process/context-package.json`;
|
||||
if (!file_exists(outputPath)) {
|
||||
throw new Error("Agent failed to generate context-package.json");
|
||||
}
|
||||
|
||||
// Verify exploration_results included
|
||||
const pkg = JSON.parse(Read(outputPath));
|
||||
if (pkg.exploration_results?.exploration_count > 0) {
|
||||
console.log(`Exploration results aggregated: ${pkg.exploration_results.exploration_count} angles`);
|
||||
}
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
**Input**: `testSessionId` from Phase 1
|
||||
|
||||
**Parse Output**:
|
||||
@@ -34,13 +461,13 @@ Skill(skill="workflow:tools:context-gather", args="--session [testSessionId] \"[
|
||||
```json
|
||||
[
|
||||
{"content": "Phase 1: Test Generation", "status": "in_progress"},
|
||||
{"content": " → Create test session", "status": "completed"},
|
||||
{"content": " → Gather test context", "status": "in_progress"},
|
||||
{"content": " → Load source/codebase context", "status": "in_progress"},
|
||||
{"content": " → Analyze test coverage", "status": "pending"},
|
||||
{"content": " → Generate context package", "status": "pending"},
|
||||
{"content": " → Test analysis (Gemini)", "status": "pending"},
|
||||
{"content": " → Generate test tasks", "status": "pending"},
|
||||
{"content": " -> Create test session", "status": "completed"},
|
||||
{"content": " -> Gather test context", "status": "in_progress"},
|
||||
{"content": " -> Load source/codebase context", "status": "in_progress"},
|
||||
{"content": " -> Analyze test coverage", "status": "pending"},
|
||||
{"content": " -> Generate context package", "status": "pending"},
|
||||
{"content": " -> Test analysis (Gemini)", "status": "pending"},
|
||||
{"content": " -> Generate test tasks", "status": "pending"},
|
||||
{"content": "Phase 2: Test Cycle Execution", "status": "pending"}
|
||||
]
|
||||
```
|
||||
@@ -49,10 +476,10 @@ Skill(skill="workflow:tools:context-gather", args="--session [testSessionId] \"[
|
||||
```json
|
||||
[
|
||||
{"content": "Phase 1: Test Generation", "status": "in_progress"},
|
||||
{"content": " → Create test session", "status": "completed"},
|
||||
{"content": " → Gather test context", "status": "completed"},
|
||||
{"content": " → Test analysis (Gemini)", "status": "pending"},
|
||||
{"content": " → Generate test tasks", "status": "pending"},
|
||||
{"content": " -> Create test session", "status": "completed"},
|
||||
{"content": " -> Gather test context", "status": "completed"},
|
||||
{"content": " -> Test analysis (Gemini)", "status": "pending"},
|
||||
{"content": " -> Generate test tasks", "status": "pending"},
|
||||
{"content": "Phase 2: Test Cycle Execution", "status": "pending"}
|
||||
]
|
||||
```
|
||||
|
||||
@@ -9,13 +9,95 @@ Analyze test requirements with Gemini using progressive L0-L3 test layers.
|
||||
- Generate multi-layered test requirements (L0-L3)
|
||||
- Scan for AI code issues
|
||||
|
||||
## Core Philosophy
|
||||
|
||||
- **Coverage-Driven**: Focus on identified test gaps from context analysis
|
||||
- **Pattern-Based**: Learn from existing tests and project conventions
|
||||
- **Gemini-Powered**: Use Gemini for test requirement analysis and strategy design
|
||||
- **Single-Round Analysis**: Comprehensive test analysis in one execution
|
||||
- **No Code Generation**: Strategy and planning only, actual test generation happens in task execution
|
||||
|
||||
## Core Responsibilities
|
||||
|
||||
- Coordinate test analysis workflow using cli-execution-agent
|
||||
- Validate test-context-package.json prerequisites
|
||||
- Execute Gemini analysis via agent for test strategy generation
|
||||
- Validate agent outputs (gemini-test-analysis.md, TEST_ANALYSIS_RESULTS.md)
|
||||
|
||||
## Execution
|
||||
|
||||
### Step 1.3: Test Generation Analysis
|
||||
|
||||
#### Phase 1: Context Preparation
|
||||
|
||||
**Command prepares session context and validates prerequisites.**
|
||||
|
||||
1. **Session Validation**
|
||||
- Load `.workflow/active/{test_session_id}/workflow-session.json`
|
||||
- Verify test session type is "test-gen"
|
||||
- Extract source session reference
|
||||
|
||||
2. **Context Package Validation**
|
||||
- Read `test-context-package.json`
|
||||
- Validate required sections: metadata, source_context, test_coverage, test_framework
|
||||
- Extract coverage gaps and framework details
|
||||
|
||||
3. **Strategy Determination**
|
||||
- **Simple** (1-3 files): Single Gemini analysis
|
||||
- **Medium** (4-6 files): Comprehensive analysis
|
||||
- **Complex** (>6 files): Modular analysis approach
|
||||
|
||||
#### Phase 2: Test Analysis Execution
|
||||
|
||||
**Purpose**: Analyze test coverage gaps and generate comprehensive test strategy.
|
||||
|
||||
```javascript
|
||||
Task(
|
||||
subagent_type="cli-execution-agent",
|
||||
run_in_background=false,
|
||||
description="Analyze test coverage gaps and generate test strategy",
|
||||
prompt=`
|
||||
## TASK OBJECTIVE
|
||||
Analyze test requirements and generate comprehensive test generation strategy using Gemini CLI
|
||||
|
||||
## EXECUTION CONTEXT
|
||||
Session: {test_session_id}
|
||||
Source Session: {source_session_id}
|
||||
Working Dir: .workflow/active/{test_session_id}/.process
|
||||
Template: ~/.ccw/workflows/cli-templates/prompts/test/test-concept-analysis.txt
|
||||
|
||||
## EXECUTION STEPS
|
||||
1. Execute Gemini analysis:
|
||||
ccw cli -p "..." --tool gemini --mode write --rule test-test-concept-analysis --cd .workflow/active/{test_session_id}/.process
|
||||
|
||||
2. Generate TEST_ANALYSIS_RESULTS.md:
|
||||
Synthesize gemini-test-analysis.md into standardized format for task generation
|
||||
Include: coverage assessment, test framework, test requirements, generation strategy, implementation targets
|
||||
|
||||
## EXPECTED OUTPUTS
|
||||
1. gemini-test-analysis.md - Raw Gemini analysis
|
||||
2. TEST_ANALYSIS_RESULTS.md - Standardized test requirements document
|
||||
|
||||
## QUALITY VALIDATION
|
||||
- Both output files exist and are complete
|
||||
- All required sections present in TEST_ANALYSIS_RESULTS.md
|
||||
- Test requirements are actionable and quantified
|
||||
- Test scenarios cover happy path, errors, edge cases
|
||||
- Dependencies and mocks clearly identified
|
||||
`
|
||||
)
|
||||
```
|
||||
Skill(skill="workflow:tools:test-concept-enhanced", args="--session [testSessionId] --context [contextPath]")
|
||||
```
|
||||
|
||||
**Output Files**:
|
||||
- `.workflow/active/{test_session_id}/.process/gemini-test-analysis.md`
|
||||
- `.workflow/active/{test_session_id}/.process/TEST_ANALYSIS_RESULTS.md`
|
||||
|
||||
#### Phase 3: Output Validation
|
||||
|
||||
- Verify `gemini-test-analysis.md` exists and is complete
|
||||
- Validate `TEST_ANALYSIS_RESULTS.md` generated by agent
|
||||
- Check required sections present
|
||||
- Confirm test requirements are actionable
|
||||
|
||||
**Input**:
|
||||
- `testSessionId` from Phase 1
|
||||
@@ -40,7 +122,24 @@ Skill(skill="workflow:tools:test-concept-enhanced", args="--session [testSession
|
||||
- Quality Assurance Criteria
|
||||
- Success Criteria
|
||||
|
||||
**Note**: Detailed specifications for project types, L0-L3 layers, and AI issue detection are defined in `/workflow:tools:test-concept-enhanced`.
|
||||
## Error Handling
|
||||
|
||||
### Validation Errors
|
||||
| Error | Resolution |
|
||||
|-------|------------|
|
||||
| Missing context package | Run test-context-gather first |
|
||||
| No coverage gaps | Skip test generation, proceed to execution |
|
||||
| No test framework detected | Configure test framework |
|
||||
| Invalid source session | Complete implementation first |
|
||||
|
||||
### Execution Errors
|
||||
| Error | Recovery |
|
||||
|-------|----------|
|
||||
| Gemini timeout | Reduce scope, analyze by module |
|
||||
| Output incomplete | Retry with focused analysis |
|
||||
| No output file | Check directory permissions |
|
||||
|
||||
**Fallback Strategy**: Generate basic TEST_ANALYSIS_RESULTS.md from context package if Gemini fails
|
||||
|
||||
## Output
|
||||
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
# Phase 4: Test Task Generate (test-task-generate)
|
||||
|
||||
Generate test task JSONs via action-planning-agent.
|
||||
Generate test task JSONs via test-action-planning-agent.
|
||||
|
||||
## Objective
|
||||
|
||||
@@ -11,13 +11,282 @@ Generate test task JSONs via action-planning-agent.
|
||||
|
||||
### Step 1.4: Generate Test Tasks
|
||||
|
||||
#### Phase 1: Context Preparation
|
||||
|
||||
**Purpose**: Assemble test session paths, load test analysis context, and create test-planning-notes.md.
|
||||
|
||||
**Execution Steps**:
|
||||
1. Parse `--session` flag to get test session ID
|
||||
2. Load `workflow-session.json` for session metadata
|
||||
3. Verify `TEST_ANALYSIS_RESULTS.md` exists (from test-concept-enhanced)
|
||||
4. Load `test-context-package.json` for coverage data
|
||||
5. Create `test-planning-notes.md` with initial context
|
||||
|
||||
**After Phase 1**: Initialize test-planning-notes.md
|
||||
|
||||
```javascript
|
||||
// Create test-planning-notes.md with N+1 context support
|
||||
const testPlanningNotesPath = `.workflow/active/${testSessionId}/test-planning-notes.md`
|
||||
const sessionMetadata = JSON.parse(Read(`.workflow/active/${testSessionId}/workflow-session.json`))
|
||||
const testAnalysis = Read(`.workflow/active/${testSessionId}/.process/TEST_ANALYSIS_RESULTS.md`)
|
||||
const sourceSessionId = sessionMetadata.source_session_id || 'N/A'
|
||||
|
||||
// Extract key info from TEST_ANALYSIS_RESULTS.md
|
||||
const projectType = testAnalysis.match(/Project Type:\s*(.+)/)?.[1] || 'Unknown'
|
||||
const testFramework = testAnalysis.match(/Test Framework:\s*(.+)/)?.[1] || 'Unknown'
|
||||
const coverageTarget = testAnalysis.match(/Coverage Target:\s*(.+)/)?.[1] || '80%'
|
||||
|
||||
Write(testPlanningNotesPath, `# Test Planning Notes
|
||||
|
||||
**Session**: ${testSessionId}
|
||||
**Source Session**: ${sourceSessionId}
|
||||
**Created**: ${new Date().toISOString()}
|
||||
|
||||
## Test Intent (Phase 1)
|
||||
|
||||
- **PROJECT_TYPE**: ${projectType}
|
||||
- **TEST_FRAMEWORK**: ${testFramework}
|
||||
- **COVERAGE_TARGET**: ${coverageTarget}
|
||||
- **SOURCE_SESSION**: ${sourceSessionId}
|
||||
|
||||
---
|
||||
|
||||
## Context Findings (Phase 1)
|
||||
|
||||
### Files with Coverage Gaps
|
||||
(Extracted from TEST_ANALYSIS_RESULTS.md)
|
||||
|
||||
### Test Framework & Conventions
|
||||
- Framework: ${testFramework}
|
||||
- Coverage Target: ${coverageTarget}
|
||||
|
||||
---
|
||||
|
||||
## Gemini Enhancement (Phase 1.5)
|
||||
(To be filled by Gemini analysis)
|
||||
|
||||
### Enhanced Test Suggestions
|
||||
- **L1 (Unit)**: (Pending)
|
||||
- **L2.1 (Integration)**: (Pending)
|
||||
- **L2.2 (API Contracts)**: (Pending)
|
||||
- **L2.4 (External APIs)**: (Pending)
|
||||
- **L2.5 (Failure Modes)**: (Pending)
|
||||
|
||||
### Gemini Analysis Summary
|
||||
(Pending enrichment)
|
||||
|
||||
---
|
||||
|
||||
## Consolidated Test Requirements (Phase 2 Input)
|
||||
1. [Context] ${testFramework} framework conventions
|
||||
2. [Context] ${coverageTarget} coverage target
|
||||
|
||||
---
|
||||
|
||||
## Task Generation (Phase 2)
|
||||
(To be filled by test-action-planning-agent)
|
||||
|
||||
## N+1 Context
|
||||
### Decisions
|
||||
| Decision | Rationale | Revisit? |
|
||||
|----------|-----------|----------|
|
||||
|
||||
### Deferred
|
||||
- [ ] (For N+1)
|
||||
`)
|
||||
```
|
||||
Skill(skill="workflow:tools:test-task-generate", args="--session [testSessionId]")
|
||||
|
||||
---
|
||||
|
||||
#### Phase 1.5: Gemini Test Enhancement
|
||||
|
||||
**Purpose**: Enrich test specifications with comprehensive test suggestions and record to test-planning-notes.md.
|
||||
|
||||
**Execution Steps**:
|
||||
1. Load TEST_ANALYSIS_RESULTS.md from `.workflow/active/{test-session-id}/.process/`
|
||||
2. Invoke `cli-execution-agent` with Gemini for test enhancement analysis
|
||||
3. Use template: `~/.ccw/workflows/cli-templates/prompts/test-suggestions-enhancement.txt`
|
||||
4. Gemini generates enriched test suggestions across L1-L3 layers -> gemini-enriched-suggestions.md
|
||||
5. Record enriched suggestions to test-planning-notes.md (Gemini Enhancement section)
|
||||
|
||||
```javascript
|
||||
Task(
|
||||
subagent_type="cli-execution-agent",
|
||||
run_in_background=false,
|
||||
description="Enhance test specifications with Gemini analysis",
|
||||
prompt=`
|
||||
## Task Objective
|
||||
Analyze TEST_ANALYSIS_RESULTS.md and generate enriched test suggestions using Gemini CLI
|
||||
|
||||
## Input Files
|
||||
- Read: .workflow/active/{test-session-id}/.process/TEST_ANALYSIS_RESULTS.md
|
||||
- Extract: Project type, test framework, coverage gaps, identified files
|
||||
|
||||
## Gemini Analysis Execution
|
||||
Execute Gemini with comprehensive test enhancement prompt:
|
||||
ccw cli -p "[comprehensive test prompt]" --tool gemini --mode analysis --rule analysis-test-strategy-enhancement --cd .workflow/active/{test-session-id}/.process
|
||||
|
||||
## Expected Output
|
||||
Generate gemini-enriched-suggestions.md with structured test enhancements:
|
||||
- L1 (Unit Tests): Edge cases, boundaries, error paths
|
||||
- L2.1 (Integration): Module interactions, dependency injection
|
||||
- L2.2 (API Contracts): Request/response, validation, error responses
|
||||
- L2.4 (External APIs): Mock strategies, failure scenarios, timeouts
|
||||
- L2.5 (Failure Modes): Exception handling, error propagation, recovery
|
||||
|
||||
## Validation
|
||||
- gemini-enriched-suggestions.md created and complete
|
||||
- Suggestions are actionable and specific (not generic)
|
||||
- All L1-L3 layers covered
|
||||
`
|
||||
)
|
||||
```
|
||||
|
||||
**Output**: gemini-enriched-suggestions.md (complete Gemini analysis)
|
||||
|
||||
**After Phase 1.5**: Update test-planning-notes.md with Gemini enhancement findings
|
||||
|
||||
```javascript
|
||||
// Read enriched suggestions from gemini-enriched-suggestions.md
|
||||
const enrichedSuggestionsPath = `.workflow/active/${testSessionId}/.process/gemini-enriched-suggestions.md`
|
||||
const enrichedSuggestions = Read(enrichedSuggestionsPath)
|
||||
|
||||
// Update Phase 1.5 section in test-planning-notes.md with full enriched suggestions
|
||||
Edit(testPlanningNotesPath, {
|
||||
old: '## Gemini Enhancement (Phase 1.5)\n(To be filled by Gemini analysis)\n\n### Enhanced Test Suggestions\n- **L1 (Unit)**: (Pending)\n- **L2.1 (Integration)**: (Pending)\n- **L2.2 (API Contracts)**: (Pending)\n- **L2.4 (External APIs)**: (Pending)\n- **L2.5 (Failure Modes)**: (Pending)\n\n### Gemini Analysis Summary\n(Pending enrichment)',
|
||||
new: `## Gemini Enhancement (Phase 1.5)
|
||||
|
||||
**Analysis Timestamp**: ${new Date().toISOString()}
|
||||
**Template**: test-suggestions-enhancement.txt
|
||||
**Output File**: .process/gemini-enriched-suggestions.md
|
||||
|
||||
### Enriched Test Suggestions (Complete Gemini Analysis)
|
||||
|
||||
${enrichedSuggestions}
|
||||
|
||||
### Gemini Analysis Summary
|
||||
- **Status**: Enrichment complete
|
||||
- **Layers Covered**: L1, L2.1, L2.2, L2.4, L2.5
|
||||
- **Focus Areas**: API contracts, integration patterns, error scenarios, edge cases
|
||||
- **Output Stored**: Full analysis in gemini-enriched-suggestions.md`
|
||||
})
|
||||
|
||||
// Append Gemini constraints to consolidated test requirements
|
||||
const geminiConstraints = [
|
||||
'[Gemini] Implement all suggested L1 edge cases and boundary tests',
|
||||
'[Gemini] Apply L2.1 module interaction patterns from analysis',
|
||||
'[Gemini] Follow L2.2 API contract test matrix from analysis',
|
||||
'[Gemini] Use L2.4 external API mock strategies from analysis',
|
||||
'[Gemini] Cover L2.5 error scenarios from analysis'
|
||||
]
|
||||
|
||||
const currentNotes = Read(testPlanningNotesPath)
|
||||
const constraintCount = (currentNotes.match(/^\d+\./gm) || []).length
|
||||
|
||||
Edit(testPlanningNotesPath, {
|
||||
old: '## Consolidated Test Requirements (Phase 2 Input)',
|
||||
new: `## Consolidated Test Requirements (Phase 2 Input)
|
||||
1. [Context] ${testFramework} framework conventions
|
||||
2. [Context] ${coverageTarget} coverage target
|
||||
${geminiConstraints.map((c, i) => `${i + 3}. ${c}`).join('\n')}`
|
||||
})
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
#### Phase 2: Test Document Generation (Agent)
|
||||
|
||||
**Agent Specialization**: This invokes `@test-action-planning-agent` - a specialized variant of action-planning-agent with:
|
||||
- Progressive L0-L3 test layers (Static, Unit, Integration, E2E)
|
||||
- AI code issue detection (L0.5) with severity levels
|
||||
- Project type templates (React, Node API, CLI, Library, Monorepo)
|
||||
- Test anti-pattern detection with quality gates
|
||||
- Layer completeness thresholds and coverage targets
|
||||
|
||||
**See**: `d:\Claude_dms3\.claude\agents\test-action-planning-agent.md` for complete test specifications.
|
||||
|
||||
```javascript
|
||||
Task(
|
||||
subagent_type="test-action-planning-agent",
|
||||
run_in_background=false,
|
||||
description="Generate test planning documents",
|
||||
prompt=`
|
||||
## TASK OBJECTIVE
|
||||
Generate test planning documents (IMPL_PLAN.md, task JSONs, TODO_LIST.md) for test workflow session
|
||||
|
||||
IMPORTANT: This is TEST PLANNING ONLY - you are generating planning documents, NOT executing tests.
|
||||
|
||||
## SESSION PATHS
|
||||
Input:
|
||||
- Session Metadata: .workflow/active/{test-session-id}/workflow-session.json
|
||||
- TEST_ANALYSIS_RESULTS: .workflow/active/{test-session-id}/.process/TEST_ANALYSIS_RESULTS.md (REQUIRED)
|
||||
- Test Planning Notes: .workflow/active/{test-session-id}/test-planning-notes.md (REQUIRED - contains Gemini enhancement findings)
|
||||
- Test Context Package: .workflow/active/{test-session-id}/.process/test-context-package.json
|
||||
- Context Package: .workflow/active/{test-session-id}/.process/context-package.json
|
||||
- Enriched Suggestions: .workflow/active/{test-session-id}/.process/gemini-enriched-suggestions.md (for reference)
|
||||
- Source Session Summaries: .workflow/active/{source-session-id}/.summaries/IMPL-*.md (if exists)
|
||||
|
||||
Output:
|
||||
- Task Dir: .workflow/active/{test-session-id}/.task/
|
||||
- IMPL_PLAN: .workflow/active/{test-session-id}/IMPL_PLAN.md
|
||||
- TODO_LIST: .workflow/active/{test-session-id}/TODO_LIST.md
|
||||
|
||||
## CONTEXT METADATA
|
||||
Session ID: {test-session-id}
|
||||
Workflow Type: test_session
|
||||
Source Session: {source-session-id} (if exists)
|
||||
MCP Capabilities: {exa_code, exa_web, code_index}
|
||||
|
||||
## CONSOLIDATED CONTEXT
|
||||
**From test-planning-notes.md**:
|
||||
- Test Intent: Project type, test framework, coverage target
|
||||
- Context Findings: Coverage gaps, file analysis
|
||||
- Gemini Enhancement: Complete enriched test suggestions (L1-L3 layers)
|
||||
* Full analysis embedded in planning-notes.md
|
||||
* API contracts, integration patterns, error scenarios
|
||||
- Consolidated Requirements: Combined constraints from all phases
|
||||
|
||||
## YOUR SPECIFICATIONS
|
||||
You are @test-action-planning-agent. Your complete test specifications are defined in:
|
||||
d:\Claude_dms3\.claude\agents\test-action-planning-agent.md
|
||||
|
||||
This includes:
|
||||
- Progressive Test Layers (L0-L3) with L0.1-L0.5, L1.1-L1.5, L2.1-L2.5, L3.1-L3.4
|
||||
- AI Code Issue Detection (L0.5) with 7 categories and severity levels
|
||||
- Project Type Detection & Templates (6 project types)
|
||||
- Test Anti-Pattern Detection (5 categories)
|
||||
- Layer Completeness & Quality Metrics (thresholds and gate decisions)
|
||||
- Task JSON structure requirements (minimum 4 tasks)
|
||||
- Quality validation rules
|
||||
|
||||
**Follow your specification exactly** when generating test task JSONs.
|
||||
|
||||
## EXPECTED DELIVERABLES
|
||||
1. Test Task JSON Files (.task/IMPL-*.json) - Minimum 4:
|
||||
- IMPL-001.json: Test generation (L1-L3 layers per spec)
|
||||
- IMPL-001.3-validation.json: Code validation gate (L0 + AI issues per spec)
|
||||
- IMPL-001.5-review.json: Test quality gate (anti-patterns + coverage per spec)
|
||||
- IMPL-002.json: Test execution & fix cycle
|
||||
|
||||
2. IMPL_PLAN.md: Test implementation plan with quality gates
|
||||
|
||||
3. TODO_LIST.md: Hierarchical task list with test phase indicators
|
||||
|
||||
## SUCCESS CRITERIA
|
||||
- All test planning documents generated successfully
|
||||
- Task count: minimum 4 (expandable for complex projects)
|
||||
- Test framework: {detected from project}
|
||||
- Coverage targets: L0 zero errors, L1 80%+, L2 70%+
|
||||
- L0-L3 layers explicitly defined per spec
|
||||
- AI issue detection configured per spec
|
||||
- Quality gates with measurable thresholds
|
||||
`
|
||||
)
|
||||
```
|
||||
|
||||
**Input**: `testSessionId` from Phase 1
|
||||
|
||||
**Note**: test-task-generate invokes action-planning-agent to generate test-specific IMPL_PLAN.md and task JSONs based on TEST_ANALYSIS_RESULTS.md.
|
||||
**Note**: test-action-planning-agent generates test-specific IMPL_PLAN.md and task JSONs based on TEST_ANALYSIS_RESULTS.md.
|
||||
|
||||
**Expected Output** (minimum 4 tasks):
|
||||
|
||||
@@ -36,6 +305,37 @@ Skill(skill="workflow:tools:test-task-generate", args="--session [testSessionId]
|
||||
- `.workflow/active/[testSessionId]/IMPL_PLAN.md` exists
|
||||
- `.workflow/active/[testSessionId]/TODO_LIST.md` exists
|
||||
|
||||
## Test-Specific Execution Modes
|
||||
|
||||
### Test Generation (IMPL-001)
|
||||
- **Agent Mode** (default): @code-developer generates tests within agent context
|
||||
- **CLI Mode**: Use CLI tools when `command` field present in implementation_approach
|
||||
|
||||
### Test Execution & Fix (IMPL-002+)
|
||||
- **Agent Mode** (default): Gemini diagnosis -> agent applies fixes
|
||||
- **CLI Mode**: Gemini diagnosis -> CLI applies fixes (when `command` field present)
|
||||
|
||||
**CLI Tool Selection**: Determined semantically from user's task description (e.g., "use Codex for fixes")
|
||||
|
||||
## Output Directory Structure
|
||||
|
||||
```
|
||||
.workflow/active/WFS-test-[session]/
|
||||
|-- workflow-session.json # Session metadata
|
||||
|-- IMPL_PLAN.md # Test implementation plan
|
||||
|-- TODO_LIST.md # Task checklist
|
||||
|-- test-planning-notes.md # Consolidated planning notes with full Gemini analysis
|
||||
|-- .task/
|
||||
| |-- IMPL-001.json # Test generation (L1-L3)
|
||||
| |-- IMPL-001.3-validation.json # Code validation gate (L0 + AI)
|
||||
| |-- IMPL-001.5-review.json # Test quality gate
|
||||
| +-- IMPL-002.json # Test execution & fix cycle
|
||||
+-- .process/
|
||||
|-- test-context-package.json # Test coverage and patterns
|
||||
|-- gemini-enriched-suggestions.md # Gemini-generated test enhancements
|
||||
+-- TEST_ANALYSIS_RESULTS.md # L0-L3 requirements (from test-concept-enhanced)
|
||||
```
|
||||
|
||||
## Output
|
||||
|
||||
- **Files**: IMPL_PLAN.md, IMPL-*.json (4+), TODO_LIST.md
|
||||
|
||||
Reference in New Issue
Block a user