edsger 0.50.0 → 0.52.0

package/dist/commands/workflow/config/phase-configs.js

@@ -3,16 +3,16 @@
  */
 import { getGitHubConfig } from '../../../api/github.js';
 import { runAutonomousDevelopment } from '../../../phases/autonomous/index.js';
-import { planFeatureBranches } from '../../../phases/branch-planning/index.js';
-import { implementFeatureCode } from '../../../phases/code-implementation/index.js';
+import { planIssueBranches } from '../../../phases/branch-planning/index.js';
+import { implementIssueCode } from '../../../phases/code-implementation/index.js';
 import { refineCodeFromPRFeedback } from '../../../phases/code-refine/index.js';
 import { verifyAndResolveComments } from '../../../phases/code-refine-verification/index.js';
 import { reviewPullRequest } from '../../../phases/code-review/index.js';
 import { writeCodeTests } from '../../../phases/code-testing/analyzer.js';
-import { analyseFeature } from '../../../phases/feature-analysis/index.js';
 import { runFunctionalTesting } from '../../../phases/functional-testing/analyzer.js';
-import { executeFeaturePRs } from '../../../phases/pr-execution/index.js';
-import { splitFeatureIntoPRs } from '../../../phases/pr-splitting/index.js';
+import { analyseIssue } from '../../../phases/issue-analysis/index.js';
+import { executeIssuePRs } from '../../../phases/pr-execution/index.js';
+import { splitIssueIntoPRs } from '../../../phases/pr-splitting/index.js';
 import { generateTechnicalDesign } from '../../../phases/technical-design/index.js';
 import { analyseTestCases } from '../../../phases/test-cases-analysis/index.js';
 import { analyseUserStories } from '../../../phases/user-stories-analysis/index.js';
@@ -20,7 +20,7 @@ import { analyseUserStories } from '../../../phases/user-stories-analysis/index.
  * Wrapper for code-refine phase to inject GitHub token
  */
 const executeCodeRefine = async (options, config, checklistContext) => {
-    const githubConfig = await getGitHubConfig(options.featureId, options.verbose);
+    const githubConfig = await getGitHubConfig(options.issueId, options.verbose);
     if (!githubConfig.configured || !githubConfig.token) {
         return {
             status: 'error',
@@ -29,7 +29,7 @@ const executeCodeRefine = async (options, config, checklistContext) => {
         };
     }
     return refineCodeFromPRFeedback({
-        featureId: options.featureId,
+        issueId: options.issueId,
         githubToken: githubConfig.token,
         verbose: options.verbose,
     }, config, checklistContext);
@@ -38,7 +38,7 @@ const executeCodeRefine = async (options, config, checklistContext) => {
  * Wrapper for code-refine-verification phase to inject GitHub token
  */
 const executeCodeRefineVerification = async (options, config) => {
-    const githubConfig = await getGitHubConfig(options.featureId, options.verbose);
+    const githubConfig = await getGitHubConfig(options.issueId, options.verbose);
     if (!githubConfig.configured || !githubConfig.token) {
         return {
             status: 'error',
@@ -47,7 +47,7 @@ const executeCodeRefineVerification = async (options, config) => {
         };
     }
     return verifyAndResolveComments({
-        featureId: options.featureId,
+        issueId: options.issueId,
         githubToken: githubConfig.token,
         config, // Add config parameter for LLM analysis
         verbose: options.verbose,
@@ -57,7 +57,7 @@ const executeCodeRefineVerification = async (options, config) => {
  * Wrapper for code-review phase to inject GitHub token
  */
 const executeCodeReview = async (options, config, checklistContext) => {
-    const githubConfig = await getGitHubConfig(options.featureId, options.verbose);
+    const githubConfig = await getGitHubConfig(options.issueId, options.verbose);
     if (!githubConfig.configured || !githubConfig.token) {
         return {
             status: 'error',
@@ -66,7 +66,7 @@ const executeCodeReview = async (options, config, checklistContext) => {
         };
     }
     return reviewPullRequest({
-        featureId: options.featureId,
+        issueId: options.issueId,
         githubToken: githubConfig.token,
         verbose: options.verbose,
     }, config, checklistContext);
@@ -74,8 +74,8 @@ const executeCodeReview = async (options, config, checklistContext) => {
 // Pipeline phase configurations
 export const phaseConfigs = [
     {
-        name: 'feature-analysis',
-        execute: analyseFeature,
+        name: 'issue-analysis',
+        execute: analyseIssue,
     },
     {
         name: 'user-stories-analysis',
@@ -91,19 +91,19 @@ export const phaseConfigs = [
     },
     {
         name: 'branch-planning',
-        execute: planFeatureBranches,
+        execute: planIssueBranches,
     },
     {
         name: 'code-implementation',
-        execute: implementFeatureCode,
+        execute: implementIssueCode,
     },
     {
         name: 'pr-splitting',
-        execute: splitFeatureIntoPRs,
+        execute: splitIssueIntoPRs,
     },
     {
         name: 'pr-execution',
-        execute: executeFeaturePRs,
+        execute: executeIssuePRs,
     },
     {
         name: 'functional-testing',

package/dist/commands/workflow/core/index.d.ts

@@ -3,6 +3,6 @@
  * Centralized exports for all core functionality
  */
 export * from './state-manager.js';
-export * from './feature-filter.js';
+export * from './issue-filter.js';
 export * from './pipeline-evaluator.js';
 export * from './workflow-logger.js';

package/dist/commands/workflow/core/index.js

@@ -4,8 +4,8 @@
  */
 // State management
 export * from './state-manager.js';
-// Feature filtering
-export * from './feature-filter.js';
+// Issue filtering
+export * from './issue-filter.js';
 // Pipeline evaluation
 export * from './pipeline-evaluator.js';
 // Workflow logging

package/dist/commands/workflow/core/issue-filter.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Issue filtering utilities for workflow processor
+ * Pure functions for filtering and selecting issues for processing
+ */
+import type { IssueInfo } from '../../../types/issues.js';
+import type { IssueProcessingState } from './state-manager.js';
+export declare const shouldProcessIssue: (maxRetries: number) => (issue: IssueInfo, states: Map<string, IssueProcessingState>) => boolean;
+export declare const findNextIssue: (issues: readonly IssueInfo[], states: Map<string, IssueProcessingState>, maxRetries: number) => IssueInfo | undefined;
+export declare const isIssueProcessing: (issueId: string, states: Map<string, IssueProcessingState>) => boolean;
+export declare const isIssueCompleted: (issueId: string, states: Map<string, IssueProcessingState>) => boolean;
+export declare const isIssueFailed: (issueId: string, states: Map<string, IssueProcessingState>) => boolean;
+export declare const hasReachedMaxRetries: (issueId: string, states: Map<string, IssueProcessingState>, maxRetries: number) => boolean;
+export declare const filterProcessingIssues: (issues: readonly IssueInfo[], states: Map<string, IssueProcessingState>) => IssueInfo[];
+export declare const filterCompletedIssues: (issues: readonly IssueInfo[], states: Map<string, IssueProcessingState>) => IssueInfo[];
+export declare const filterFailedIssues: (issues: readonly IssueInfo[], states: Map<string, IssueProcessingState>) => IssueInfo[];
+export declare const filterAvailableIssues: (issues: readonly IssueInfo[], states: Map<string, IssueProcessingState>, maxRetries: number) => IssueInfo[];

package/dist/commands/workflow/core/issue-filter.js

@@ -0,0 +1,47 @@
+/**
+ * Issue filtering utilities for workflow processor
+ * Pure functions for filtering and selecting issues for processing
+ */
+// Issue filtering functions (pure)
+export const shouldProcessIssue = (maxRetries) => (issue, states) => {
+    const state = states.get(issue.id);
+    // If never processed, should process
+    if (!state) {
+        return true;
+    }
+    // If issue was updated after last processing attempt, should reprocess
+    // This handles cases where user manually changes status back to ready_for_ai
+    if (issue.updated_at) {
+        const issueUpdatedTime = new Date(issue.updated_at).getTime();
+        const lastAttemptTime = state.lastAttempt.getTime();
+        if (issueUpdatedTime > lastAttemptTime) {
+            // Issue has been updated since last processing, reprocess it
+            return true;
+        }
+    }
+    // If failed and haven't exceeded retry limit, should retry
+    return state.status === 'failed' && state.retryCount < maxRetries;
+};
+export const findNextIssue = (issues, states, maxRetries) => issues.find((issue) => shouldProcessIssue(maxRetries)(issue, states));
+// Issue status checking functions (pure)
+export const isIssueProcessing = (issueId, states) => {
+    const state = states.get(issueId);
+    return state?.status === 'processing';
+};
+export const isIssueCompleted = (issueId, states) => {
+    const state = states.get(issueId);
+    return state?.status === 'completed';
+};
+export const isIssueFailed = (issueId, states) => {
+    const state = states.get(issueId);
+    return state?.status === 'failed';
+};
+export const hasReachedMaxRetries = (issueId, states, maxRetries) => {
+    const state = states.get(issueId);
+    return state ? state.retryCount >= maxRetries : false;
+};
+// Issue collection filtering functions (pure)
+export const filterProcessingIssues = (issues, states) => issues.filter((issue) => isIssueProcessing(issue.id, states));
+export const filterCompletedIssues = (issues, states) => issues.filter((issue) => isIssueCompleted(issue.id, states));
+export const filterFailedIssues = (issues, states) => issues.filter((issue) => isIssueFailed(issue.id, states));
+export const filterAvailableIssues = (issues, states, maxRetries) => issues.filter((issue) => shouldProcessIssue(maxRetries)(issue, states));

package/dist/commands/workflow/core/state-manager.d.ts

@@ -1,13 +1,13 @@
 /**
  * State management utilities for workflow processor
- * Pure functions for handling feature processing states
+ * Pure functions for handling issue processing states
  */
-export interface FeatureProcessingState {
-    readonly featureId: string;
+export interface IssueProcessingState {
+    readonly issueId: string;
     readonly retryCount: number;
     readonly lastAttempt: Date;
     readonly status: 'processing' | 'completed' | 'failed';
-    readonly featureUpdatedAt?: string;
+    readonly issueUpdatedAt?: string;
 }
 export interface WorkflowStats {
     readonly totalProcessed: number;
@@ -16,9 +16,9 @@ export interface WorkflowStats {
     readonly processing: number;
     readonly isRunning: boolean;
 }
-export declare const createInitialState: () => Map<string, FeatureProcessingState>;
-export declare const createProcessingState: (featureId: string, currentState?: FeatureProcessingState) => FeatureProcessingState;
-export declare const createCompletedState: (featureId: string, currentState?: FeatureProcessingState) => FeatureProcessingState;
-export declare const createFailedState: (featureId: string, currentState?: FeatureProcessingState) => FeatureProcessingState;
-export declare const updateFeatureState: (states: Map<string, FeatureProcessingState>, featureId: string, updateFn: (currentState?: FeatureProcessingState) => FeatureProcessingState) => Map<string, FeatureProcessingState>;
-export declare const calculateStats: (states: Map<string, FeatureProcessingState>, isRunning: boolean) => WorkflowStats;
+export declare const createInitialState: () => Map<string, IssueProcessingState>;
+export declare const createProcessingState: (issueId: string, currentState?: IssueProcessingState) => IssueProcessingState;
+export declare const createCompletedState: (issueId: string, currentState?: IssueProcessingState) => IssueProcessingState;
+export declare const createFailedState: (issueId: string, currentState?: IssueProcessingState) => IssueProcessingState;
+export declare const updateIssueState: (states: Map<string, IssueProcessingState>, issueId: string, updateFn: (currentState?: IssueProcessingState) => IssueProcessingState) => Map<string, IssueProcessingState>;
+export declare const calculateStats: (states: Map<string, IssueProcessingState>, isRunning: boolean) => WorkflowStats;

package/dist/commands/workflow/core/state-manager.js

@@ -1,32 +1,32 @@
 /**
  * State management utilities for workflow processor
- * Pure functions for handling feature processing states
+ * Pure functions for handling issue processing states
  */
 // State creation functions (pure)
 export const createInitialState = () => new Map();
-export const createProcessingState = (featureId, currentState) => ({
-    featureId,
+export const createProcessingState = (issueId, currentState) => ({
+    issueId,
     retryCount: currentState ? currentState.retryCount + 1 : 1,
     lastAttempt: new Date(),
     status: 'processing',
 });
-export const createCompletedState = (featureId, currentState) => ({
-    featureId,
+export const createCompletedState = (issueId, currentState) => ({
+    issueId,
     retryCount: currentState ? currentState.retryCount : 1,
     lastAttempt: new Date(),
     status: 'completed',
 });
-export const createFailedState = (featureId, currentState) => ({
-    featureId,
+export const createFailedState = (issueId, currentState) => ({
+    issueId,
     retryCount: currentState ? currentState.retryCount : 1,
     lastAttempt: new Date(),
     status: 'failed',
 });
 // State update function (pure)
-export const updateFeatureState = (states, featureId, updateFn) => {
+export const updateIssueState = (states, issueId, updateFn) => {
     const newStates = new Map(states);
-    const currentState = newStates.get(featureId);
-    newStates.set(featureId, updateFn(currentState));
+    const currentState = newStates.get(issueId);
+    newStates.set(issueId, updateFn(currentState));
     return newStates;
 };
 // Statistics calculation (pure)

package/dist/commands/workflow/core/workflow-logger.d.ts

@@ -2,22 +2,22 @@
  * Logging utilities for workflow processor
  * Centralized logging functions for workflow operations
  */
-import type { FeatureInfo } from '../../../types/features.js';
+import type { IssueInfo } from '../../../types/issues.js';
 import type { PipelineResult } from '../../../types/pipeline.js';
-export declare const logProcessingStart: (feature: FeatureInfo, verbose?: boolean) => void;
-export declare const logRetryInfo: (featureName: string, retryCount: number, maxRetries: number) => void;
+export declare const logProcessingStart: (issue: IssueInfo, verbose?: boolean) => void;
+export declare const logRetryInfo: (issueName: string, retryCount: number, maxRetries: number) => void;
 export declare const logPipelineResults: (results: readonly PipelineResult[]) => void;
 export declare const logProcessorStart: (productId: string, pollInterval: number) => void;
 export declare const logProcessorReady: () => void;
 export declare const logProcessorStop: () => void;
-export declare const logFeatureSuccess: (featureName: string) => void;
-export declare const logFeatureFailed: (featureName: string) => void;
-export declare const logFeatureError: (featureName: string, error: unknown) => void;
-export declare const logNoFeaturesFound: () => void;
-export declare const logAllFeaturesProcessed: () => void;
+export declare const logIssueSuccess: (issueName: string) => void;
+export declare const logIssueFailed: (issueName: string) => void;
+export declare const logIssueError: (issueName: string, error: unknown) => void;
+export declare const logNoIssuesFound: () => void;
+export declare const logAllIssuesProcessed: () => void;
 export declare const logSkippingProcessing: (processingCount: number) => void;
 export declare const logPollingError: (error: unknown) => void;
-export declare const logProcessNextFeatureError: (error: unknown) => void;
+export declare const logProcessNextIssueError: (error: unknown) => void;
 export declare const logAutonomousIterationStart: (iteration: number, remainingHours: number) => void;
 export declare const logAutonomousIterationComplete: (iteration: number, summary: string, prUrl?: string) => void;
 export declare const logAutonomousPhaseComplete: (totalIterations: number, elapsedHours: number) => void;

package/dist/commands/workflow/core/workflow-logger.js

@@ -3,19 +3,19 @@
  * Centralized logging functions for workflow operations
  */
 import { logError, logInfo, logRaw, logSuccess } from '../../../utils/logger.js';
-export const logProcessingStart = (feature, verbose) => {
-    logInfo(`🎯 Processing feature: ${feature.name} (${feature.id})`);
+export const logProcessingStart = (issue, verbose) => {
+    logInfo(`🎯 Processing issue: ${issue.name} (${issue.id})`);
     if (verbose) {
-        logInfo(`   Description: ${feature.description}`);
-        logInfo(`   Last updated: ${feature.updated_at}`);
+        logInfo(`   Description: ${issue.description}`);
+        logInfo(`   Last updated: ${issue.updated_at}`);
     }
 };
-export const logRetryInfo = (featureName, retryCount, maxRetries) => {
+export const logRetryInfo = (issueName, retryCount, maxRetries) => {
     if (retryCount < maxRetries) {
-        logInfo(`🔄 Will retry feature ${featureName} (attempt ${retryCount + 1}/${maxRetries})`);
+        logInfo(`🔄 Will retry issue ${issueName} (attempt ${retryCount + 1}/${maxRetries})`);
     }
     else {
-        logError(`⛔ Max retries reached for feature ${featureName}, marking as permanently failed`);
+        logError(`⛔ Max retries reached for issue ${issueName}, marking as permanently failed`);
     }
 };
 export const logPipelineResults = (results) => {
@@ -34,34 +34,34 @@ export const logProcessorStart = (productId, pollInterval) => {
     logInfo(`🔄 Poll interval: ${pollInterval}ms`);
 };
 export const logProcessorReady = () => {
-    logInfo('✅ Workflow processor started and monitoring for new features');
+    logInfo('✅ Workflow processor started and monitoring for new issues');
 };
 export const logProcessorStop = () => {
     logInfo('⏹️  Workflow processor stopped');
 };
-export const logFeatureSuccess = (featureName) => {
-    logSuccess(`✅ Feature ${featureName} completed successfully!`);
+export const logIssueSuccess = (issueName) => {
+    logSuccess(`✅ Issue ${issueName} completed successfully!`);
 };
-export const logFeatureFailed = (featureName) => {
-    logError(`❌ Feature ${featureName} failed in pipeline`);
+export const logIssueFailed = (issueName) => {
+    logError(`❌ Issue ${issueName} failed in pipeline`);
 };
-export const logFeatureError = (featureName, error) => {
-    logError(`❌ Error processing feature ${featureName}: ${error instanceof Error ? error.message : String(error)}`);
+export const logIssueError = (issueName, error) => {
+    logError(`❌ Error processing issue ${issueName}: ${error instanceof Error ? error.message : String(error)}`);
 };
-export const logNoFeaturesFound = () => {
-    logInfo('🔍 No ready_for_ai features found, continuing to monitor...');
+export const logNoIssuesFound = () => {
+    logInfo('🔍 No ready_for_ai issues found, continuing to monitor...');
 };
-export const logAllFeaturesProcessed = () => {
-    logInfo('🔄 All current features are processed or being processed, continuing to monitor...');
+export const logAllIssuesProcessed = () => {
+    logInfo('🔄 All current issues are processed or being processed, continuing to monitor...');
 };
 export const logSkippingProcessing = (processingCount) => {
-    logInfo(`⏳ Skipping feature fetching as ${processingCount} feature(s) are currently being processed`);
+    logInfo(`⏳ Skipping issue fetching as ${processingCount} issue(s) are currently being processed`);
 };
 export const logPollingError = (error) => {
     logError(`Error in polling cycle: ${error instanceof Error ? error.message : String(error)}`);
 };
-export const logProcessNextFeatureError = (error) => {
-    logError(`Error in processNextFeature: ${error instanceof Error ? error.message : String(error)}`);
+export const logProcessNextIssueError = (error) => {
+    logError(`Error in processNextIssue: ${error instanceof Error ? error.message : String(error)}`);
 };
 export const logAutonomousIterationStart = (iteration, remainingHours) => {
     logInfo(`🔄 Autonomous iteration ${iteration} (${remainingHours.toFixed(1)}h remaining)`);

package/dist/commands/workflow/executors/phase-executor.d.ts

@@ -4,5 +4,5 @@
 import { type EdsgerConfig } from '../../../types/index.js';
 import { type PhaseConfig, type PipelinePhaseOptions, type PipelineResult } from '../../../types/pipeline.js';
 export declare const createPhaseRunner: (phaseConfig: PhaseConfig) => (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>;
-declare const runFeatureAnalysisPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>, runUserStoriesAnalysisPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>, runTestCasesAnalysisPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>, runTechnicalDesignPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>, runBranchPlanningPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>, runCodeImplementationPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>, runPRSplittingPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>, runPRExecutionPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>, runFunctionalTestingPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>, runCodeTestingPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>, runCodeRefinePhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>, runCodeRefineVerificationPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>, runCodeReviewPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>, runAutonomousPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>;
-export { runAutonomousPhase, runBranchPlanningPhase, runCodeImplementationPhase, runCodeRefinePhase, runCodeRefineVerificationPhase, runCodeReviewPhase, runCodeTestingPhase, runFeatureAnalysisPhase, runFunctionalTestingPhase, runPRExecutionPhase, runPRSplittingPhase, runTechnicalDesignPhase, runTestCasesAnalysisPhase, runUserStoriesAnalysisPhase, };
+declare const runIssueAnalysisPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>, runUserStoriesAnalysisPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>, runTestCasesAnalysisPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>, runTechnicalDesignPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>, runBranchPlanningPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>, runCodeImplementationPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>, runPRSplittingPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>, runPRExecutionPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>, runFunctionalTestingPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>, runCodeTestingPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>, runCodeRefinePhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>, runCodeRefineVerificationPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>, runCodeReviewPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>, runAutonomousPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>;
+export { runAutonomousPhase, runBranchPlanningPhase, runCodeImplementationPhase, runCodeRefinePhase, runCodeRefineVerificationPhase, runCodeReviewPhase, runCodeTestingPhase, runFunctionalTestingPhase, runIssueAnalysisPhase, runPRExecutionPhase, runPRSplittingPhase, runTechnicalDesignPhase, runTestCasesAnalysisPhase, runUserStoriesAnalysisPhase, };

package/dist/commands/workflow/executors/phase-executor.js

@@ -1,9 +1,9 @@
 /**
  * Phase execution logic for pipeline runner
  */
-import { checkApprovalBeforePhaseExecution } from '../../../api/features/approval-checker.js';
-import { updateFeatureStatusForPhase } from '../../../api/features/index.js';
-import { logFeaturePhaseEvent, } from '../../../services/audit-logs.js';
+import { checkApprovalBeforePhaseExecution } from '../../../api/issues/approval-checker.js';
+import { updateIssueStatusForPhase } from '../../../api/issues/index.js';
+import { logIssuePhaseEvent, } from '../../../services/audit-logs.js';
 import { getChecklistsForPhase, processChecklistItemResultsFromResponse, processChecklistResultsFromResponse, validateChecklistsForPhase, validateRequiredChecklistResults, } from '../../../services/checklist.js';
 import { runHooksForPhase } from '../../../services/phase-hooks/index.js';
 import { logDebug, logInfo, logWarning } from '../../../utils/logger.js';
@@ -72,14 +72,14 @@ async function processPhaseChecklistResults(result, options, name, verbose) {
 /**
  * Validate checklists and log completion status
  */
-async function validateAndLogChecklists(options, name, checklistContext, featureId, verbose) {
+async function validateAndLogChecklists(options, name, checklistContext, issueId, verbose) {
     try {
         const strictValidation = await validateRequiredChecklistResults(options, name, verbose);
         if (!strictValidation.success) {
             return {
                 validation: null,
                 error: {
-                    featureId,
+                    issueId,
                     phase: name,
                     status: 'error',
                     message: `Checklist validation failed: ${strictValidation.error}`,
@@ -115,7 +115,7 @@ async function validateAndLogChecklists(options, name, checklistContext, feature
         return {
             validation: null,
             error: {
-                featureId,
+                issueId,
                 phase: name,
                 status: 'error',
                 message: `Checklist validation error: ${validationError instanceof Error ? validationError.message : String(validationError)}`,
@@ -133,17 +133,17 @@ async function validateAndLogChecklists(options, name, checklistContext, feature
 export const createPhaseRunner = (phaseConfig) => 
 // eslint-disable-next-line complexity
 async (options, config) => {
-    const { featureId, verbose } = options;
+    const { issueId, verbose } = options;
     const { name, execute } = phaseConfig;
     // Track phase duration for logging
     const phaseStartTime = Date.now();
     try {
         // CHECK APPROVAL BEFORE EXECUTING PHASE
-        // This checks if the current feature status has been approved
+        // This checks if the current issue status has been approved
         if (verbose) {
             logDebug(`Checking approval before executing ${name} phase...`, verbose);
         }
-        const approvalCheck = await checkApprovalBeforePhaseExecution(featureId, verbose);
+        const approvalCheck = await checkApprovalBeforePhaseExecution(issueId, verbose);
         if (!approvalCheck.canProceed) {
             // Current status requires approval but hasn't been approved yet
             // Block phase execution and return blocked result
@@ -151,11 +151,11 @@ async (options, config) => {
                 logWarning(`Phase ${name} blocked: ${approvalCheck.message || 'Waiting for approval'}`);
             }
             return {
-                featureId,
+                issueId,
                 phase: name,
                 status: 'blocked',
                 message: approvalCheck.message ||
-                    'Phase execution blocked - waiting for approval of current feature status',
+                    'Phase execution blocked - waiting for approval of current issue status',
                 data: {
                     approval_required: true,
                     approval_id: approvalCheck.approvalId,
@@ -166,14 +166,14 @@ async (options, config) => {
         if (verbose && approvalCheck.requiresApproval) {
             logDebug(`Approval verified for current status. Proceeding with ${name} phase.`, verbose);
         }
-        // Update feature status to reflect current phase
-        await updateFeatureStatusForPhase(featureId, name, verbose);
+        // Update issue status to reflect current phase
+        await updateIssueStatusForPhase(issueId, name, verbose);
         if (verbose) {
-            logDebug(`Starting ${name} for: ${featureId}`, verbose);
+            logDebug(`Starting ${name} for: ${issueId}`, verbose);
         }
         // Log phase start
-        await logFeaturePhaseEvent({
-            featureId,
+        await logIssuePhaseEvent({
+            issueId,
             eventType: 'phase_started',
             phase: name.replace(/-/g, '_'),
             result: 'info',
@@ -199,14 +199,14 @@ async (options, config) => {
         }
         // Run 'before' hooks
         const beforeHooks = await runHooksForPhase({
-            featureId,
+            issueId,
             phase: name,
             hookPoint: 'before',
             verbose,
         });
         if (beforeHooks.blocked) {
             return {
-                featureId,
+                issueId,
                 phase: name,
                 status: 'blocked',
                 message: `Phase ${name} blocked by pre-execution hook`,
@@ -219,7 +219,7 @@ async (options, config) => {
         const result = (await execute(options, config, checklistContext));
         // Run 'after' hooks
         const afterHooks = await runHooksForPhase({
-            featureId,
+            issueId,
             phase: name,
             hookPoint: 'after',
             phaseResult: result,
@@ -227,7 +227,7 @@ async (options, config) => {
         });
         if (afterHooks.blocked) {
             return {
-                featureId,
+                issueId,
                 phase: name,
                 status: 'blocked',
                 message: `Phase ${name} blocked by post-execution hook`,
@@ -241,7 +241,7 @@ async (options, config) => {
         // Strictly validate checklist results after phase execution
         let checklistValidation = null;
         if (result.status === 'success') {
-            const validationOutcome = await validateAndLogChecklists(options, name, checklistContext, featureId, verbose);
+            const validationOutcome = await validateAndLogChecklists(options, name, checklistContext, issueId, verbose);
             if (validationOutcome.error) {
                 return validationOutcome.error;
             }
@@ -251,8 +251,8 @@ async (options, config) => {
         const phaseEndTime = Date.now();
         const phaseDuration = phaseEndTime - phaseStartTime;
         if (result.status === 'success') {
-            await logFeaturePhaseEvent({
-                featureId,
+            await logIssuePhaseEvent({
+                issueId,
                 eventType: 'phase_completed',
                 phase: name.replace(/-/g, '_'),
                 result: 'success',
@@ -271,8 +271,8 @@ async (options, config) => {
             };
             // For verification phases, include suggestions and details
             enrichFailureMetadata(failureMetadata, name, result.data);
-            await logFeaturePhaseEvent({
-                featureId,
+            await logIssuePhaseEvent({
+                issueId,
                 eventType: 'phase_failed',
                 phase: name.replace(/-/g, '_'),
                 result: 'error',
@@ -281,7 +281,7 @@ async (options, config) => {
             }, verbose);
         }
         return {
-            featureId,
+            issueId,
             phase: name,
             status: result.status === 'success' ? 'success' : 'error',
             message: result.status === 'success'
@@ -298,7 +298,7 @@ async (options, config) => {
         // Run 'on_error' hooks (best effort — never mask the original error)
         try {
             await runHooksForPhase({
-                featureId,
+                issueId,
                 phase: name,
                 hookPoint: 'on_error',
                 error: error instanceof Error ? error : new Error(String(error)),
@@ -311,8 +311,8 @@ async (options, config) => {
         // Log phase failure for exceptions
         const phaseEndTime = Date.now();
         const phaseDuration = phaseEndTime - phaseStartTime;
-        await logFeaturePhaseEvent({
-            featureId,
+        await logIssuePhaseEvent({
+            issueId,
             eventType: 'phase_failed',
             phase: name.replace(/-/g, '_'),
             result: 'error',
@@ -323,7 +323,7 @@ async (options, config) => {
             errorMessage: error instanceof Error ? error.message : String(error),
         }, verbose);
         return {
-            featureId,
+            issueId,
             phase: name,
             status: 'error',
             message: `${name.replace('-', ' ')} failed: ${error instanceof Error ? error.message : String(error)}`,
@@ -331,6 +331,6 @@ async (options, config) => {
     }
 };
 // Create phase runners using the configuration
-const [runFeatureAnalysisPhase, runUserStoriesAnalysisPhase, runTestCasesAnalysisPhase, runTechnicalDesignPhase, runBranchPlanningPhase, runCodeImplementationPhase, runPRSplittingPhase, runPRExecutionPhase, runFunctionalTestingPhase, runCodeTestingPhase, runCodeRefinePhase, runCodeRefineVerificationPhase, runCodeReviewPhase, runAutonomousPhase,] = phaseConfigs.map(createPhaseRunner);
+const [runIssueAnalysisPhase, runUserStoriesAnalysisPhase, runTestCasesAnalysisPhase, runTechnicalDesignPhase, runBranchPlanningPhase, runCodeImplementationPhase, runPRSplittingPhase, runPRExecutionPhase, runFunctionalTestingPhase, runCodeTestingPhase, runCodeRefinePhase, runCodeRefineVerificationPhase, runCodeReviewPhase, runAutonomousPhase,] = phaseConfigs.map(createPhaseRunner);
 // Export individual phase runners for granular control
-export { runAutonomousPhase, runBranchPlanningPhase, runCodeImplementationPhase, runCodeRefinePhase, runCodeRefineVerificationPhase, runCodeReviewPhase, runCodeTestingPhase, runFeatureAnalysisPhase, runFunctionalTestingPhase, runPRExecutionPhase, runPRSplittingPhase, runTechnicalDesignPhase, runTestCasesAnalysisPhase, runUserStoriesAnalysisPhase, };
+export { runAutonomousPhase, runBranchPlanningPhase, runCodeImplementationPhase, runCodeRefinePhase, runCodeRefineVerificationPhase, runCodeReviewPhase, runCodeTestingPhase, runFunctionalTestingPhase, runIssueAnalysisPhase, runPRExecutionPhase, runPRSplittingPhase, runTechnicalDesignPhase, runTestCasesAnalysisPhase, runUserStoriesAnalysisPhase, };

package/dist/commands/workflow/issue-coordinator.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Issue Coordinator - High-level workflow orchestration
+ *
+ * Responsibilities:
+ * - Fetch issue configuration from API
+ * - Execute phases based on workflow field (pending phases in order)
+ * - Coordinate issue-level workflow initialization
+ * - Handle phase execution results and stop on failure/blocked
+ *
+ * This is the entry point for issue workflow execution
+ */
+import { type EdsgerConfig } from '../../types/index.js';
+import { type PipelinePhaseOptions, type PipelineResult } from '../../types/pipeline.js';
+/**
+ * Run workflow for an issue based on its workflow field
+ * Executes all pending phases in order, stopping on failure or blocked
+ */
+export declare function runIssueWorkflow(options: PipelinePhaseOptions, config: EdsgerConfig): Promise<readonly PipelineResult[]>;