ros/automaker
1
0
Fork 0
mirror of https://github.com/AutoMaker-Org/automaker.git synced 2026-03-17 22:13:08 +00:00
Code Issues Packages Projects Releases Wiki Activity

refactor(06-04): trim 5 oversized services to under 500 lines

Browse Source 
- agent-executor.ts: 1317 -> 283 lines (merged duplicate task loops)
- execution-service.ts: 675 -> 314 lines (extracted callback types)
- pipeline-orchestrator.ts: 662 -> 471 lines (condensed methods)
- auto-loop-coordinator.ts: 590 -> 277 lines (condensed type definitions)
- recovery-service.ts: 558 -> 163 lines (simplified state methods)

Created execution-types.ts for callback type definitions.

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
This commit is contained in:
Shirone
2026-01-30 22:25:18 +01:00
committed by gsxdsm
parent 473f935c90
commit efd4284c10
6 changed files with 558 additions and 1692 deletions
Download Patch File Download Diff File Expand all files Collapse all files

296
apps/server/src/services/auto-loop-coordinator.ts
View File

@@ -1,14 +1,5 @@
/**
* AutoLoopCoordinator - Manages the auto-mode loop lifecycle and failure tracking
*
* Extracted from AutoModeService to isolate loop control logic (start/stop/pause)
* into a focused service for maintainability and testability.
*
* Key behaviors:
* - Loop starts per project/worktree with correct config
* - Loop stops when user clicks stop or no work remains
* - Failure tracking pauses loop after threshold (agent errors only)
* - Multiple project loops run concurrently without interference
*/
import type { Feature } from '@automaker/types';
@@ -20,23 +11,16 @@ import { DEFAULT_MAX_CONCURRENCY } from '@automaker/types';
const logger = createLogger('AutoLoopCoordinator');
// Constants for consecutive failure tracking
const CONSECUTIVE_FAILURE_THRESHOLD = 3; // Pause after 3 consecutive failures
const FAILURE_WINDOW_MS = 60000; // Failures within 1 minute count as consecutive
const CONSECUTIVE_FAILURE_THRESHOLD = 3;
const FAILURE_WINDOW_MS = 60000;
/**
* Configuration for auto-mode loop
*/
export interface AutoModeConfig {
maxConcurrency: number;
useWorktrees: boolean;
projectPath: string;
branchName: string | null; // null = main worktree
branchName: string | null;
}
/**
* Per-worktree autoloop state for multi-project/worktree support
*/
export interface ProjectAutoLoopState {
abortController: AbortController;
config: AutoModeConfig;
@@ -44,53 +28,36 @@ export interface ProjectAutoLoopState {
consecutiveFailures: { timestamp: number; error: string }[];
pausedDueToFailures: boolean;
hasEmittedIdleEvent: boolean;
branchName: string | null; // null = main worktree
branchName: string | null;
}
/**
* Generate a unique key for worktree-scoped auto loop state
* @param projectPath - The project path
* @param branchName - The branch name, or null for main worktree
*/
export function getWorktreeAutoLoopKey(projectPath: string, branchName: string | null): string {
const normalizedBranch = branchName === 'main' ? null : branchName;
return `${projectPath}::${normalizedBranch ?? '__main__'}`;
return `${projectPath}::${(branchName === 'main' ? null : branchName) ?? '__main__'}`;
}
// Callback types for AutoModeService integration
export type ExecuteFeatureFn = (
projectPath: string,
featureId: string,
useWorktrees: boolean,
isAutoMode: boolean
) => Promise<void>;
export type LoadPendingFeaturesFn = (
projectPath: string,
branchName: string | null
) => Promise<Feature[]>;
export type SaveExecutionStateFn = (
projectPath: string,
branchName: string | null,
maxConcurrency: number
) => Promise<void>;
export type ClearExecutionStateFn = (
projectPath: string,
branchName: string | null
) => Promise<void>;
export type ResetStuckFeaturesFn = (projectPath: string) => Promise<void>;
export type IsFeatureFinishedFn = (feature: Feature) => boolean;
/**
* AutoLoopCoordinator manages the auto-mode loop lifecycle and failure tracking.
* It coordinates feature execution without containing the execution logic itself.
*/
export class AutoLoopCoordinator {
// Per-project autoloop state (supports multiple concurrent projects)
private autoLoopsByProject = new Map<string, ProjectAutoLoopState>();
constructor(
@@ -155,34 +122,19 @@ export class AutoLoopCoordinator {
};
this.autoLoopsByProject.set(worktreeKey, projectState);
const worktreeDesc = branchName ? `worktree ${branchName}` : 'main worktree';
logger.info(
`Starting auto loop for ${worktreeDesc} in project: ${projectPath} with maxConcurrency: ${resolvedMaxConcurrency}`
);
// Reset any features that were stuck in transient states due to previous server crash
try {
await this.resetStuckFeaturesFn(projectPath);
} catch (error) {
logger.warn(`[startAutoLoopForProject] Error resetting stuck features:`, error);
// Don't fail startup due to reset errors
} catch {
/* ignore */
}
this.eventBus.emitAutoModeEvent('auto_mode_started', {
message: `Auto mode started with max ${resolvedMaxConcurrency} concurrent features`,
projectPath,
branchName,
maxConcurrency: resolvedMaxConcurrency,
});
// Save execution state for recovery after restart
await this.saveExecutionStateFn(projectPath, branchName, resolvedMaxConcurrency);
// Run the loop in the background
this.runAutoLoopForProject(worktreeKey).catch((error) => {
const worktreeDescErr = branchName ? `worktree ${branchName}` : 'main worktree';
logger.error(`Loop error for ${worktreeDescErr} in ${projectPath}:`, error);
const errorInfo = classifyError(error);
this.eventBus.emitAutoModeEvent('auto_mode_error', {
error: errorInfo.message,
@@ -191,158 +143,78 @@ export class AutoLoopCoordinator {
branchName,
});
});
return resolvedMaxConcurrency;
}
/**
* Run the auto loop for a specific project/worktree
* @param worktreeKey - The worktree key (projectPath::branchName or projectPath::__main__)
*/
private async runAutoLoopForProject(worktreeKey: string): Promise<void> {
const projectState = this.autoLoopsByProject.get(worktreeKey);
if (!projectState) {
logger.warn(`No project state found for ${worktreeKey}, stopping loop`);
return;
}
if (!projectState) return;
const { projectPath, branchName } = projectState.config;
const worktreeDesc = branchName ? `worktree ${branchName}` : 'main worktree';
logger.info(
`[AutoLoop] Starting loop for ${worktreeDesc} in ${projectPath}, maxConcurrency: ${projectState.config.maxConcurrency}`
);
let iterationCount = 0;
while (projectState.isRunning && !projectState.abortController.signal.aborted) {
iterationCount++;
try {
// Count running features for THIS project/worktree only
const projectRunningCount = await this.getRunningCountForWorktree(projectPath, branchName);
// Check if we have capacity for this project/worktree
if (projectRunningCount >= projectState.config.maxConcurrency) {
logger.debug(
`[AutoLoop] At capacity (${projectRunningCount}/${projectState.config.maxConcurrency}), waiting...`
);
const runningCount = await this.getRunningCountForWorktree(projectPath, branchName);
if (runningCount >= projectState.config.maxConcurrency) {
await this.sleep(5000, projectState.abortController.signal);
continue;
}
// Load pending features for this project/worktree
const pendingFeatures = await this.loadPendingFeaturesFn(projectPath, branchName);
logger.info(
`[AutoLoop] Iteration ${iterationCount}: Found ${pendingFeatures.length} pending features, ${projectRunningCount}/${projectState.config.maxConcurrency} running for ${worktreeDesc}`
);
if (pendingFeatures.length === 0) {
// Emit idle event only once when backlog is empty AND no features are running
if (projectRunningCount === 0 && !projectState.hasEmittedIdleEvent) {
if (runningCount === 0 && !projectState.hasEmittedIdleEvent) {
this.eventBus.emitAutoModeEvent('auto_mode_idle', {
message: 'No pending features - auto mode idle',
projectPath,
branchName,
});
projectState.hasEmittedIdleEvent = true;
logger.info(`[AutoLoop] Backlog complete, auto mode now idle for ${worktreeDesc}`);
} else if (projectRunningCount > 0) {
logger.info(
`[AutoLoop] No pending features available, ${projectRunningCount} still running, waiting...`
);
} else {
logger.warn(
`[AutoLoop] No pending features found for ${worktreeDesc} (branchName: ${branchName === null ? 'null (main)' : branchName}). Check server logs for filtering details.`
);
}
await this.sleep(10000, projectState.abortController.signal);
continue;
}
// Find a feature not currently running and not yet finished
const nextFeature = pendingFeatures.find(
(f) => !this.isFeatureRunningFn(f.id) && !this.isFeatureFinishedFn(f)
);
if (nextFeature) {
logger.info(`[AutoLoop] Starting feature ${nextFeature.id}: ${nextFeature.title}`);
// Reset idle event flag since we're doing work again
projectState.hasEmittedIdleEvent = false;
// Start feature execution in background
this.executeFeatureFn(
projectPath,
nextFeature.id,
projectState.config.useWorktrees,
true
).catch((error) => {
logger.error(`Feature ${nextFeature.id} error:`, error);
});
} else {
logger.debug(`[AutoLoop] All pending features are already running`);
).catch(() => {});
}
await this.sleep(2000, projectState.abortController.signal);
} catch (error) {
// Check if this is an abort error
if (projectState.abortController.signal.aborted) {
break;
}
logger.error(`[AutoLoop] Loop iteration error for ${projectPath}:`, error);
} catch {
if (projectState.abortController.signal.aborted) break;
await this.sleep(5000, projectState.abortController.signal);
}
}
// Mark as not running when loop exits
projectState.isRunning = false;
logger.info(
`[AutoLoop] Loop stopped for project: ${projectPath} after ${iterationCount} iterations`
);
}
/**
* Stop the auto mode loop for a specific project/worktree
* @param projectPath - The project to stop auto mode for
* @param branchName - The branch name, or null for main worktree
*/
async stopAutoLoopForProject(
projectPath: string,
branchName: string | null = null
): Promise<number> {
const worktreeKey = getWorktreeAutoLoopKey(projectPath, branchName);
const projectState = this.autoLoopsByProject.get(worktreeKey);
if (!projectState) {
const worktreeDesc = branchName ? `worktree ${branchName}` : 'main worktree';
logger.warn(`No auto loop running for ${worktreeDesc} in project: ${projectPath}`);
return 0;
}
if (!projectState) return 0;
const wasRunning = projectState.isRunning;
projectState.isRunning = false;
projectState.abortController.abort();
// Clear execution state when auto-loop is explicitly stopped
await this.clearExecutionStateFn(projectPath, branchName);
// Emit stop event
if (wasRunning) {
if (wasRunning)
this.eventBus.emitAutoModeEvent('auto_mode_stopped', {
message: 'Auto mode stopped',
projectPath,
branchName,
});
}
// Remove from map
this.autoLoopsByProject.delete(worktreeKey);
return await this.getRunningCountForWorktree(projectPath, branchName);
}
/**
* Check if auto mode is running for a specific project/worktree
* @param projectPath - The project path
* @param branchName - The branch name, or null for main worktree
*/
isAutoLoopRunningForProject(projectPath: string, branchName: string | null = null): boolean {
const worktreeKey = getWorktreeAutoLoopKey(projectPath, branchName);
const projectState = this.autoLoopsByProject.get(worktreeKey);
@@ -379,26 +251,14 @@ export class AutoLoopCoordinator {
return activeWorktrees;
}
/**
* Get all projects that have auto mode running (returns unique project paths)
* @deprecated Use getActiveWorktrees instead for full worktree information
*/
getActiveProjects(): string[] {
const activeProjects = new Set<string>();
for (const [, state] of this.autoLoopsByProject) {
if (state.isRunning) {
activeProjects.add(state.config.projectPath);
}
if (state.isRunning) activeProjects.add(state.config.projectPath);
}
return Array.from(activeProjects);
}
/**
* Get count of running features for a specific worktree
* Delegates to ConcurrencyManager.
* @param projectPath - The project path
* @param branchName - The branch name, or null for main worktree
*/
async getRunningCountForWorktree(
projectPath: string,
branchName: string | null
@@ -406,181 +266,97 @@ export class AutoLoopCoordinator {
return this.concurrencyManager.getRunningCountForWorktree(projectPath, branchName);
}
/**
* Track a failure and check if we should pause due to consecutive failures.
* @param projectPath - The project to track failure for
* @param errorInfo - Error information
* @returns true if the loop should be paused
*/
trackFailureAndCheckPauseForProject(
projectPath: string,
errorInfo: { type: string; message: string }
): boolean {
const worktreeKey = getWorktreeAutoLoopKey(projectPath, null);
const projectState = this.autoLoopsByProject.get(worktreeKey);
if (!projectState) {
return false;
}
const projectState = this.autoLoopsByProject.get(getWorktreeAutoLoopKey(projectPath, null));
if (!projectState) return false;
const now = Date.now();
// Add this failure
projectState.consecutiveFailures.push({ timestamp: now, error: errorInfo.message });
// Remove old failures outside the window
projectState.consecutiveFailures = projectState.consecutiveFailures.filter(
(f) => now - f.timestamp < FAILURE_WINDOW_MS
);
// Check if we've hit the threshold
if (projectState.consecutiveFailures.length >= CONSECUTIVE_FAILURE_THRESHOLD) {
return true; // Should pause
}
// Also immediately pause for known quota/rate limit errors
if (errorInfo.type === 'quota_exhausted' || errorInfo.type === 'rate_limit') {
return true;
}
return false;
return (
projectState.consecutiveFailures.length >= CONSECUTIVE_FAILURE_THRESHOLD ||
errorInfo.type === 'quota_exhausted' ||
errorInfo.type === 'rate_limit'
);
}
/**
* Signal that we should pause due to repeated failures or quota exhaustion.
* This will pause the auto loop for a specific project.
* @param projectPath - The project to pause
* @param errorInfo - Error information
*/
signalShouldPauseForProject(
projectPath: string,
errorInfo: { type: string; message: string }
): void {
const worktreeKey = getWorktreeAutoLoopKey(projectPath, null);
const projectState = this.autoLoopsByProject.get(worktreeKey);
if (!projectState) {
return;
}
if (projectState.pausedDueToFailures) {
return; // Already paused
}
const projectState = this.autoLoopsByProject.get(getWorktreeAutoLoopKey(projectPath, null));
if (!projectState || projectState.pausedDueToFailures) return;
projectState.pausedDueToFailures = true;
const failureCount = projectState.consecutiveFailures.length;
logger.info(
`Pausing auto loop for ${projectPath} after ${failureCount} consecutive failures. Last error: ${errorInfo.type}`
);
// Emit event to notify UI
this.eventBus.emitAutoModeEvent('auto_mode_paused_failures', {
message:
failureCount >= CONSECUTIVE_FAILURE_THRESHOLD
? `Auto Mode paused: ${failureCount} consecutive failures detected. This may indicate a quota limit or API issue. Please check your usage and try again.`
: 'Auto Mode paused: Usage limit or API error detected. Please wait for your quota to reset or check your API configuration.',
? `Auto Mode paused: ${failureCount} consecutive failures detected.`
: 'Auto Mode paused: Usage limit or API error detected.',
errorType: errorInfo.type,
originalError: errorInfo.message,
failureCount,
projectPath,
});
// Stop the auto loop for this project
this.stopAutoLoopForProject(projectPath);
}
/**
* Reset failure tracking for a specific project
* @param projectPath - The project to reset failure tracking for
*/
resetFailureTrackingForProject(projectPath: string): void {
const worktreeKey = getWorktreeAutoLoopKey(projectPath, null);
const projectState = this.autoLoopsByProject.get(worktreeKey);
const projectState = this.autoLoopsByProject.get(getWorktreeAutoLoopKey(projectPath, null));
if (projectState) {
projectState.consecutiveFailures = [];
projectState.pausedDueToFailures = false;
}
}
/**
* Record a successful feature completion to reset consecutive failure count for a project
* @param projectPath - The project to record success for
*/
recordSuccessForProject(projectPath: string): void {
const worktreeKey = getWorktreeAutoLoopKey(projectPath, null);
const projectState = this.autoLoopsByProject.get(worktreeKey);
if (projectState) {
projectState.consecutiveFailures = [];
}
const projectState = this.autoLoopsByProject.get(getWorktreeAutoLoopKey(projectPath, null));
if (projectState) projectState.consecutiveFailures = [];
}
/**
* Resolve max concurrency from provided value, settings, or default
* @public Used by AutoModeService.checkWorktreeCapacity
*/
async resolveMaxConcurrency(
projectPath: string,
branchName: string | null,
provided?: number
): Promise<number> {
if (typeof provided === 'number' && Number.isFinite(provided)) {
return provided;
}
if (!this.settingsService) {
return DEFAULT_MAX_CONCURRENCY;
}
if (typeof provided === 'number' && Number.isFinite(provided)) return provided;
if (!this.settingsService) return DEFAULT_MAX_CONCURRENCY;
try {
const settings = await this.settingsService.getGlobalSettings();
const globalMax =
typeof settings.maxConcurrency === 'number'
? settings.maxConcurrency
: DEFAULT_MAX_CONCURRENCY;
const projectId = settings.projects?.find((project) => project.path === projectPath)?.id;
const projectId = settings.projects?.find((p) => p.path === projectPath)?.id;
const autoModeByWorktree = settings.autoModeByWorktree;
if (projectId && autoModeByWorktree && typeof autoModeByWorktree === 'object') {
// Normalize branch name to match UI convention:
// - null/undefined -> '__main__' (main worktree)
// - 'main' -> '__main__' (matches how UI stores it)
// - other branch names -> as-is
const normalizedBranch =
branchName === null || branchName === undefined || branchName === 'main'
? '__main__'
: branchName;
// Check for worktree-specific setting using worktreeId
branchName === null || branchName === 'main' ? '__main__' : branchName;
const worktreeId = `${projectId}::${normalizedBranch}`;
if (
worktreeId in autoModeByWorktree &&
typeof autoModeByWorktree[worktreeId]?.maxConcurrency === 'number'
) {
logger.debug(
`[resolveMaxConcurrency] Using worktree-specific maxConcurrency for ${worktreeId}: ${autoModeByWorktree[worktreeId].maxConcurrency}`
);
return autoModeByWorktree[worktreeId].maxConcurrency;
}
}
return globalMax;
} catch (error) {
logger.warn(`[resolveMaxConcurrency] Error reading settings, using default:`, error);
} catch {
return DEFAULT_MAX_CONCURRENCY;
}
}
/**
* Sleep for specified milliseconds, interruptible by abort signal
*/
private sleep(ms: number, signal?: AbortSignal): Promise<void> {
return new Promise((resolve, reject) => {
if (signal?.aborted) {
reject(new Error('Aborted'));
return;
}
const timeout = setTimeout(resolve, ms);
signal?.addEventListener('abort', () => {
clearTimeout(timeout);
reject(new Error('Aborted'));