edsger 0.41.1 → 0.41.2

package/dist/services/lifecycle-agent/phase-criteria.js

@@ -1,335 +0,0 @@
-/**
- * Phase Quality Criteria Definitions
- *
- * Defines the quality criteria the lifecycle agent uses to evaluate
- * each phase's outputs. These criteria determine whether a phase
- * should advance, be re-run, or be escalated to a human.
- *
- * Each phase has:
- * - An advance threshold: minimum score to auto-advance
- * - An escalate threshold: score below which to escalate to human
- * - A set of weighted criteria for evaluation
- * - A max retry count before escalation
- */
-/**
- * User Stories Analysis quality criteria
- * Evaluates whether generated user stories adequately capture the feature requirements
- */
-export const USER_STORIES_ANALYSIS_CRITERIA = {
-    phase: 'user_stories_analysis',
-    advanceThreshold: 75,
-    escalateThreshold: 40,
-    maxAutoRetries: 2,
-    criteria: [
-        {
-            id: 'us_completeness',
-            name: 'Feature Coverage',
-            description: 'All significant aspects of the feature are captured in user stories',
-            weight: 0.3,
-            minimumScore: 60,
-            evaluationGuidance: 'Check that the user stories collectively cover all major aspects of the feature description. Look for gaps where important functionality is not represented by any user story. Consider edge cases and error scenarios.',
-        },
-        {
-            id: 'us_clarity',
-            name: 'Story Clarity',
-            description: 'User stories follow standard format and are clear, specific, and actionable',
-            weight: 0.25,
-            minimumScore: 60,
-            evaluationGuidance: 'Verify each user story follows the "As a [role], I want [goal], so that [benefit]" format or equivalent clear structure. Stories should be specific enough to implement without ambiguity. Check for vague terms like "improve", "enhance", or "better" without quantifiable criteria.',
-        },
-        {
-            id: 'us_testability',
-            name: 'Testability',
-            description: 'Each user story has implicit or explicit acceptance criteria',
-            weight: 0.2,
-            minimumScore: 50,
-            evaluationGuidance: 'Assess whether each user story can be tested. The story should describe behavior that is observable and verifiable. Stories like "the system should be fast" without measurable criteria score low.',
-        },
-        {
-            id: 'us_independence',
-            name: 'Story Independence',
-            description: 'User stories are reasonably independent and avoid unnecessary coupling',
-            weight: 0.15,
-            minimumScore: 40,
-            evaluationGuidance: 'Check that stories can be developed and delivered somewhat independently. High coupling between stories (where one cannot be started without completing another) reduces flexibility. Some dependencies are natural, but excessive chaining scores low.',
-        },
-        {
-            id: 'us_sizing',
-            name: 'Appropriate Sizing',
-            description: 'Stories are neither too large (epics) nor too small (tasks)',
-            weight: 0.1,
-            minimumScore: 40,
-            evaluationGuidance: 'Stories should represent a meaningful unit of user-visible functionality. Stories that are too large (spanning multiple features) or too small (implementation details disguised as stories) score low.',
-        },
-    ],
-};
-/**
- * Test Cases Analysis quality criteria
- * Evaluates whether generated test cases provide adequate coverage
- */
-export const TEST_CASES_ANALYSIS_CRITERIA = {
-    phase: 'test_cases_analysis',
-    advanceThreshold: 75,
-    escalateThreshold: 40,
-    maxAutoRetries: 2,
-    criteria: [
-        {
-            id: 'tc_coverage',
-            name: 'Story Coverage',
-            description: 'Test cases cover the critical paths for all user stories',
-            weight: 0.3,
-            minimumScore: 60,
-            evaluationGuidance: 'Verify that each user story has at least one corresponding test case for its happy path. Critical stories should have multiple test cases covering edge cases. Calculate the ratio of stories with tests to total stories.',
-        },
-        {
-            id: 'tc_critical_paths',
-            name: 'Critical Path Coverage',
-            description: 'Critical and high-risk scenarios are tested',
-            weight: 0.25,
-            minimumScore: 60,
-            evaluationGuidance: 'Check that error handling, boundary conditions, and security-sensitive paths have test cases. Look for tests that cover authentication, authorization, data validation, and failure recovery scenarios where applicable.',
-        },
-        {
-            id: 'tc_specificity',
-            name: 'Test Specificity',
-            description: 'Test cases have clear steps, inputs, and expected outcomes',
-            weight: 0.25,
-            minimumScore: 50,
-            evaluationGuidance: 'Each test case should specify: preconditions, steps to execute, test data/inputs, and expected outcomes. Vague test cases like "verify the feature works" without specific steps score low.',
-        },
-        {
-            id: 'tc_priority',
-            name: 'Priority Assignment',
-            description: 'Critical tests are properly identified and prioritized',
-            weight: 0.2,
-            minimumScore: 40,
-            evaluationGuidance: 'Verify that is_critical flags are assigned appropriately. Core functionality and data integrity tests should be marked critical. Cosmetic or nice-to-have tests should not be critical.',
-        },
-    ],
-};
-/**
- * Technical Design quality criteria
- * Evaluates the technical design document quality
- */
-export const TECHNICAL_DESIGN_CRITERIA = {
-    phase: 'technical_design',
-    advanceThreshold: 70,
-    escalateThreshold: 35,
-    maxAutoRetries: 2,
-    criteria: [
-        {
-            id: 'td_feasibility',
-            name: 'Implementation Feasibility',
-            description: 'Design is technically feasible and can be implemented with the available technology stack',
-            weight: 0.3,
-            minimumScore: 60,
-            evaluationGuidance: 'Check that the design uses technologies and patterns consistent with the existing codebase. The design should not require major infrastructure changes or introduce incompatible dependencies. Implementation steps should be realistic.',
-        },
-        {
-            id: 'td_completeness',
-            name: 'Design Completeness',
-            description: 'Design addresses all user stories and specifies key implementation details',
-            weight: 0.25,
-            minimumScore: 60,
-            evaluationGuidance: 'Verify the design covers database schema changes, API endpoints, UI components, and business logic for all user stories. Check for missing details that would block implementation: undefined data models, unclear API contracts, or missing error handling strategies.',
-        },
-        {
-            id: 'td_architecture',
-            name: 'Architectural Quality',
-            description: 'Design follows good architectural practices and is consistent with the existing system',
-            weight: 0.25,
-            minimumScore: 50,
-            evaluationGuidance: 'Assess separation of concerns, appropriate abstraction levels, and consistency with existing architectural patterns. Check for anti-patterns like tight coupling, god objects, or bypassing established data flows.',
-        },
-        {
-            id: 'td_risks',
-            name: 'Risk Identification',
-            description: 'Key risks, assumptions, and trade-offs are identified',
-            weight: 0.2,
-            minimumScore: 40,
-            evaluationGuidance: 'Check that the design acknowledges technical risks, performance implications, and security considerations. A design that claims no risks or trade-offs is likely incomplete.',
-        },
-    ],
-};
-/**
- * Branch Planning quality criteria
- * Evaluates whether the feature is well-split into branches
- */
-export const BRANCH_PLANNING_CRITERIA = {
-    phase: 'branch_planning',
-    advanceThreshold: 70,
-    escalateThreshold: 35,
-    maxAutoRetries: 1,
-    criteria: [
-        {
-            id: 'bp_coverage',
-            name: 'Feature Coverage',
-            description: 'All user stories are assigned to branches',
-            weight: 0.35,
-            minimumScore: 60,
-            evaluationGuidance: 'Verify every user story is covered by at least one planned branch. No functionality should be left unassigned.',
-        },
-        {
-            id: 'bp_ordering',
-            name: 'Dependency Ordering',
-            description: 'Branches are ordered logically with proper dependency tracking',
-            weight: 0.35,
-            minimumScore: 50,
-            evaluationGuidance: 'Check that branches with dependencies on other branches correctly specify base_branch_id relationships. Foundation work (data models, APIs) should come before UI or integration branches.',
-        },
-        {
-            id: 'bp_sizing',
-            name: 'Branch Sizing',
-            description: 'Branches represent reviewable, incremental units of work',
-            weight: 0.3,
-            minimumScore: 50,
-            evaluationGuidance: 'Branches should be small enough for meaningful code review (not too many files changed) but large enough to represent a coherent unit of functionality. A single branch containing the entire feature scores low.',
-        },
-    ],
-};
-/**
- * Code Implementation quality criteria
- * Evaluates the code output after implementation
- */
-export const CODE_IMPLEMENTATION_CRITERIA = {
-    phase: 'code_implementation',
-    advanceThreshold: 70,
-    escalateThreshold: 30,
-    maxAutoRetries: 2,
-    criteria: [
-        {
-            id: 'ci_functionality',
-            name: 'Core Functionality',
-            description: 'Code implements the specified user stories and design',
-            weight: 0.35,
-            minimumScore: 60,
-            evaluationGuidance: 'Verify the code addresses the user stories and follows the technical design. Check that key API endpoints, database operations, and UI components are implemented.',
-        },
-        {
-            id: 'ci_compilability',
-            name: 'Build Success',
-            description: 'Code compiles/builds without errors',
-            weight: 0.3,
-            minimumScore: 70,
-            evaluationGuidance: 'Check for compilation errors, type errors, or missing imports. Code that does not build gets a very low score. Warnings are acceptable but should be minimal.',
-        },
-        {
-            id: 'ci_patterns',
-            name: 'Code Quality',
-            description: 'Code follows established patterns and conventions in the codebase',
-            weight: 0.2,
-            minimumScore: 50,
-            evaluationGuidance: 'Check that the code follows the project\'s existing patterns: naming conventions, file organization, error handling patterns, and architectural layers. New patterns introduced without justification score low.',
-        },
-        {
-            id: 'ci_pr_quality',
-            name: 'PR Quality',
-            description: 'Pull request is well-formed with clear description',
-            weight: 0.15,
-            minimumScore: 40,
-            evaluationGuidance: 'Verify the PR has a clear title, description referencing the feature, and reasonable diff size. PRs with thousands of changed lines or no description score low.',
-        },
-    ],
-};
-/**
- * Functional Testing quality criteria
- * Evaluates test execution results
- */
-export const FUNCTIONAL_TESTING_CRITERIA = {
-    phase: 'functional_testing',
-    advanceThreshold: 80,
-    escalateThreshold: 40,
-    maxAutoRetries: 3,
-    criteria: [
-        {
-            id: 'ft_pass_rate',
-            name: 'Test Pass Rate',
-            description: 'Percentage of tests that pass',
-            weight: 0.5,
-            minimumScore: 70,
-            evaluationGuidance: 'Calculate the pass rate: (passing tests / total tests) * 100. All critical tests must pass for a high score. Non-critical test failures reduce the score proportionally.',
-        },
-        {
-            id: 'ft_critical_pass',
-            name: 'Critical Test Pass Rate',
-            description: 'All tests marked as critical must pass',
-            weight: 0.35,
-            minimumScore: 80,
-            evaluationGuidance: 'Check specifically that all tests marked is_critical=true pass. Any critical test failure is a significant quality concern. Score 0 if any critical test fails, 100 if all pass.',
-        },
-        {
-            id: 'ft_coverage',
-            name: 'Test Execution Coverage',
-            description: 'Tests actually execute meaningful scenarios',
-            weight: 0.15,
-            minimumScore: 50,
-            evaluationGuidance: 'Verify tests are not trivially passing (e.g., empty test bodies, always-true assertions). Tests should exercise real functionality and verify meaningful outcomes.',
-        },
-    ],
-};
-/**
- * Code Review quality criteria
- * Evaluates the AI code review output
- */
-export const CODE_REVIEW_CRITERIA = {
-    phase: 'code_review',
-    advanceThreshold: 75,
-    escalateThreshold: 35,
-    maxAutoRetries: 1,
-    criteria: [
-        {
-            id: 'cr_thoroughness',
-            name: 'Review Thoroughness',
-            description: 'Review covers all significant changes in the PR',
-            weight: 0.35,
-            minimumScore: 50,
-            evaluationGuidance: 'Check that the review addresses the main files and logic changes in the PR. Reviews that only comment on superficial issues (formatting, naming) while missing logic errors score low.',
-        },
-        {
-            id: 'cr_actionability',
-            name: 'Actionable Feedback',
-            description: 'Review comments are specific and actionable',
-            weight: 0.35,
-            minimumScore: 50,
-            evaluationGuidance: 'Verify review comments suggest specific improvements rather than vague observations. Comments like "this could be better" without explanation score low. Comments with code suggestions or specific alternatives score high.',
-        },
-        {
-            id: 'cr_severity',
-            name: 'Issue Severity Accuracy',
-            description: 'Issues are appropriately categorized by severity',
-            weight: 0.3,
-            minimumScore: 40,
-            evaluationGuidance: 'Check that blocking issues (bugs, security) are flagged appropriately and not buried among style nits. Conversely, check that cosmetic issues are not marked as blocking.',
-        },
-    ],
-};
-/**
- * All default phase criteria indexed by phase name
- */
-export const DEFAULT_PHASE_CRITERIA = {
-    user_stories_analysis: USER_STORIES_ANALYSIS_CRITERIA,
-    test_cases_analysis: TEST_CASES_ANALYSIS_CRITERIA,
-    technical_design: TECHNICAL_DESIGN_CRITERIA,
-    branch_planning: BRANCH_PLANNING_CRITERIA,
-    code_implementation: CODE_IMPLEMENTATION_CRITERIA,
-    functional_testing: FUNCTIONAL_TESTING_CRITERIA,
-    code_review: CODE_REVIEW_CRITERIA,
-};
-/**
- * Get quality criteria for a phase, with optional overrides from config
- */
-export function getPhaseQualityCriteria(phase, overrides) {
-    const defaults = DEFAULT_PHASE_CRITERIA[phase];
-    if (!defaults) {
-        return null;
-    }
-    const phaseOverrides = overrides?.[phase];
-    if (!phaseOverrides) {
-        return defaults;
-    }
-    return {
-        ...defaults,
-        ...phaseOverrides,
-        criteria: phaseOverrides.criteria ?? defaults.criteria,
-    };
-}

package/dist/services/lifecycle-agent/transition-rules.d.ts

@@ -1,60 +0,0 @@
-/**
- * Transition Rules Engine
- *
- * Defines the rules for transitioning between phases and provides
- * the core decision-making logic for the lifecycle agent.
- *
- * The engine uses phase evaluation results combined with configurable
- * thresholds to determine the appropriate action:
- * - advance: Move to the next phase
- * - rerun: Re-execute the current phase with feedback
- * - escalate: Request human intervention
- */
-import type { FeatureStatus } from '../../types/index.js';
-import type { ExecutionMode } from '../../types/pipeline.js';
-import type { TransitionRule, PhaseEvaluationResult, LifecycleAgentConfig, LifecycleDecision, LifecycleDecisionResult, CriterionEvaluation, PhaseQualityCriteria } from './types.js';
-/**
- * Default transition rules mapping each phase to its successor
- * These mirror the existing getNextExecutionMode() logic but are structured
- * as data rather than code, making them configurable and testable
- */
-export declare const DEFAULT_TRANSITION_RULES: readonly TransitionRule[];
-/**
- * Get the transition rule for advancing from a given phase
- */
-export declare function getTransitionRule(fromPhase: string): TransitionRule | undefined;
-/**
- * Get the execution mode for re-running a phase
- * Maps phase names to their "only_*" execution mode
- */
-export declare function getRerunExecutionMode(phase: string): ExecutionMode;
-/**
- * Get the verification status for a phase
- * This is the status set after a phase completes while awaiting review
- */
-export declare function getVerificationStatus(phase: string): FeatureStatus | undefined;
-/**
- * Calculate the weighted quality score from individual criterion evaluations
- */
-export declare function calculateQualityScore(evaluations: readonly CriterionEvaluation[], criteria: PhaseQualityCriteria): number;
-/**
- * Determine the lifecycle decision based on evaluation results
- *
- * Decision logic:
- * 1. If quality score >= advanceThreshold AND confidence >= confidenceThreshold → advance
- * 2. If quality score < escalateThreshold → escalate (quality too low for auto-fix)
- * 3. If rerun count >= maxAutoRetries → escalate (exhausted retries)
- * 4. If confidence < confidenceThreshold → escalate (agent uncertain)
- * 5. Otherwise → rerun (quality between escalate and advance thresholds)
- */
-export declare function determineDecision(qualityScore: number, confidence: number, rerunCount: number, phaseCriteria: PhaseQualityCriteria, config: LifecycleAgentConfig): LifecycleDecision;
-/**
- * Build the complete decision result from an evaluation
- * Combines the evaluation with transition rules to produce an actionable result
- */
-export declare function buildDecisionResult(evaluation: PhaseEvaluationResult): LifecycleDecisionResult;
-/**
- * Default lifecycle agent configuration
- * Conservative defaults that prioritize safety over automation speed
- */
-export declare const DEFAULT_LIFECYCLE_AGENT_CONFIG: LifecycleAgentConfig;

package/dist/services/lifecycle-agent/transition-rules.js

@@ -1,184 +0,0 @@
-/**
- * Transition Rules Engine
- *
- * Defines the rules for transitioning between phases and provides
- * the core decision-making logic for the lifecycle agent.
- *
- * The engine uses phase evaluation results combined with configurable
- * thresholds to determine the appropriate action:
- * - advance: Move to the next phase
- * - rerun: Re-execute the current phase with feedback
- * - escalate: Request human intervention
- */
-/**
- * Default transition rules mapping each phase to its successor
- * These mirror the existing getNextExecutionMode() logic but are structured
- * as data rather than code, making them configurable and testable
- */
-export const DEFAULT_TRANSITION_RULES = [
-    {
-        fromPhase: 'user_stories_analysis',
-        toPhase: 'test_cases_analysis',
-        executionMode: 'only_test_cases_analysis',
-        targetStatus: 'test_cases_analysis',
-    },
-    {
-        fromPhase: 'test_cases_analysis',
-        toPhase: 'technical_design',
-        executionMode: 'only_technical_design',
-        targetStatus: 'technical_design',
-    },
-    {
-        fromPhase: 'technical_design',
-        toPhase: 'branch_planning',
-        executionMode: 'only_branch_planning',
-        targetStatus: 'branch_planning',
-    },
-    {
-        fromPhase: 'branch_planning',
-        toPhase: 'code_implementation',
-        executionMode: 'from_code_implementation',
-        targetStatus: 'code_implementation',
-    },
-    {
-        fromPhase: 'code_implementation',
-        toPhase: 'functional_testing',
-        executionMode: 'from_functional_testing',
-        targetStatus: 'functional_testing',
-    },
-    {
-        fromPhase: 'functional_testing',
-        toPhase: 'code_review',
-        executionMode: 'from_code_review',
-        targetStatus: 'code_review',
-    },
-    {
-        fromPhase: 'code_review',
-        toPhase: 'code_refine',
-        executionMode: 'only_code_refine',
-        targetStatus: 'code_refine',
-    },
-];
-/**
- * Get the transition rule for advancing from a given phase
- */
-export function getTransitionRule(fromPhase) {
-    return DEFAULT_TRANSITION_RULES.find((rule) => rule.fromPhase === fromPhase);
-}
-/**
- * Get the execution mode for re-running a phase
- * Maps phase names to their "only_*" execution mode
- */
-export function getRerunExecutionMode(phase) {
-    const rerunModes = {
-        user_stories_analysis: 'only_user_stories_analysis',
-        test_cases_analysis: 'only_test_cases_analysis',
-        technical_design: 'only_technical_design',
-        branch_planning: 'only_branch_planning',
-        code_implementation: 'only_code_implementation',
-        functional_testing: 'only_functional_testing',
-        code_review: 'only_code_review',
-        code_refine: 'only_code_refine',
-    };
-    return rerunModes[phase] || 'full_pipeline';
-}
-/**
- * Get the verification status for a phase
- * This is the status set after a phase completes while awaiting review
- */
-export function getVerificationStatus(phase) {
-    const verificationStatuses = {
-        user_stories_analysis: 'user_stories_analysis_verification',
-        test_cases_analysis: 'test_cases_analysis_verification',
-        technical_design: 'technical_design_verification',
-        branch_planning: 'branch_planning_verification',
-        code_implementation: 'code_implementation_verification',
-        code_refine: 'code_refine_verification',
-    };
-    return verificationStatuses[phase];
-}
-/**
- * Calculate the weighted quality score from individual criterion evaluations
- */
-export function calculateQualityScore(evaluations, criteria) {
-    if (evaluations.length === 0)
-        return 0;
-    const criteriaMap = new Map(criteria.criteria.map((c) => [c.id, c]));
-    let weightedSum = 0;
-    let totalWeight = 0;
-    for (const evaluation of evaluations) {
-        const definition = criteriaMap.get(evaluation.criterionId);
-        if (definition) {
-            weightedSum += evaluation.score * definition.weight;
-            totalWeight += definition.weight;
-        }
-    }
-    if (totalWeight === 0)
-        return 0;
-    return Math.round(weightedSum / totalWeight);
-}
-/**
- * Determine the lifecycle decision based on evaluation results
- *
- * Decision logic:
- * 1. If quality score >= advanceThreshold AND confidence >= confidenceThreshold → advance
- * 2. If quality score < escalateThreshold → escalate (quality too low for auto-fix)
- * 3. If rerun count >= maxAutoRetries → escalate (exhausted retries)
- * 4. If confidence < confidenceThreshold → escalate (agent uncertain)
- * 5. Otherwise → rerun (quality between escalate and advance thresholds)
- */
-export function determineDecision(qualityScore, confidence, rerunCount, phaseCriteria, config) {
-    const maxRetries = Math.min(phaseCriteria.maxAutoRetries, config.maxAutoRetries);
-    // Check confidence first - if agent is uncertain, escalate
-    if (confidence < config.confidenceThreshold) {
-        return 'escalate';
-    }
-    // Quality meets the advance threshold - auto-advance
-    if (qualityScore >= phaseCriteria.advanceThreshold) {
-        return 'advance';
-    }
-    // Quality below escalation threshold - needs human help
-    if (qualityScore < phaseCriteria.escalateThreshold) {
-        return 'escalate';
-    }
-    // Quality is between thresholds - could improve with a re-run
-    // But check if we've exhausted retries
-    if (rerunCount >= maxRetries) {
-        return 'escalate';
-    }
-    return 'rerun';
-}
-/**
- * Build the complete decision result from an evaluation
- * Combines the evaluation with transition rules to produce an actionable result
- */
-export function buildDecisionResult(evaluation) {
-    if (evaluation.decision === 'advance') {
-        const transition = getTransitionRule(evaluation.phase);
-        return {
-            evaluation,
-            transition,
-            executionMode: transition?.executionMode,
-            targetStatus: transition?.targetStatus,
-        };
-    }
-    if (evaluation.decision === 'rerun') {
-        return {
-            evaluation,
-            executionMode: getRerunExecutionMode(evaluation.phase),
-        };
-    }
-    // escalate - no automatic action, just return the evaluation
-    return { evaluation };
-}
-/**
- * Default lifecycle agent configuration
- * Conservative defaults that prioritize safety over automation speed
- */
-export const DEFAULT_LIFECYCLE_AGENT_CONFIG = {
-    enabled: false,
-    autoAdvanceEnabled: false,
-    autoRerunEnabled: true,
-    maxAutoRetries: 3,
-    confidenceThreshold: 60,
-};