mirror of
https://github.com/AutoMaker-Org/automaker.git
synced 2026-02-01 08:13:37 +00:00
feat(06-01): create AutoModeServiceFacade with all 23 methods
- Create facade.ts with per-project factory pattern - Implement all 23 public methods from RESEARCH.md inventory: - Auto loop control: startAutoLoop, stopAutoLoop, isAutoLoopRunning, getAutoLoopConfig - Feature execution: executeFeature, stopFeature, resumeFeature, followUpFeature, verifyFeature, commitFeature - Status queries: getStatus, getStatusForProject, getActiveAutoLoopProjects, getActiveAutoLoopWorktrees, getRunningAgents, checkWorktreeCapacity, contextExists - Plan approval: resolvePlanApproval, waitForPlanApproval, hasPendingApproval, cancelPlanApproval - Analysis/recovery: analyzeProject, resumeInterruptedFeatures, detectOrphanedFeatures - Lifecycle: markAllRunningFeaturesInterrupted - Use thin delegation pattern to underlying services - Note: followUpFeature and analyzeProject require AutoModeService until full migration
This commit is contained in:
Shirone
913
apps/server/src/services/auto-mode/facade.ts
Normal file
913
apps/server/src/services/auto-mode/facade.ts
Normal file
@@ -0,0 +1,913 @@
|
||||
/**
|
||||
* AutoModeServiceFacade - Clean interface for auto-mode functionality
|
||||
*
|
||||
* This facade provides a thin delegation layer over the extracted services,
|
||||
* exposing all 23 public methods that routes currently call on AutoModeService.
|
||||
*
|
||||
* Key design decisions:
|
||||
* - Per-project factory pattern (projectPath is implicit in method calls)
|
||||
* - Clean method names (e.g., startAutoLoop instead of startAutoLoopForProject)
|
||||
* - Thin delegation to underlying services - no new business logic
|
||||
* - Maintains backward compatibility during transition period
|
||||
*/
|
||||
|
||||
import path from 'path';
|
||||
import { exec } from 'child_process';
|
||||
import { promisify } from 'util';
|
||||
import type { Feature } from '@automaker/types';
|
||||
import { DEFAULT_MAX_CONCURRENCY } from '@automaker/types';
|
||||
import { createLogger, loadContextFiles, classifyError } from '@automaker/utils';
|
||||
import { getFeatureDir } from '@automaker/platform';
|
||||
import * as secureFs from '../../lib/secure-fs.js';
|
||||
import { validateWorkingDirectory } from '../../lib/sdk-options.js';
|
||||
import { getPromptCustomization } from '../../lib/settings-helpers.js';
|
||||
import { TypedEventBus } from '../typed-event-bus.js';
|
||||
import { ConcurrencyManager } from '../concurrency-manager.js';
|
||||
import { WorktreeResolver } from '../worktree-resolver.js';
|
||||
import { FeatureStateManager } from '../feature-state-manager.js';
|
||||
import { PlanApprovalService } from '../plan-approval-service.js';
|
||||
import { AutoLoopCoordinator, type AutoModeConfig } from '../auto-loop-coordinator.js';
|
||||
import { ExecutionService } from '../execution-service.js';
|
||||
import { RecoveryService } from '../recovery-service.js';
|
||||
import { PipelineOrchestrator } from '../pipeline-orchestrator.js';
|
||||
import { AgentExecutor } from '../agent-executor.js';
|
||||
import { TestRunnerService } from '../test-runner-service.js';
|
||||
import { FeatureLoader } from '../feature-loader.js';
|
||||
import type { SettingsService } from '../settings-service.js';
|
||||
import type { EventEmitter } from '../../lib/events.js';
|
||||
import type {
|
||||
FacadeOptions,
|
||||
AutoModeStatus,
|
||||
ProjectAutoModeStatus,
|
||||
WorktreeCapacityInfo,
|
||||
RunningAgentInfo,
|
||||
OrphanedFeatureInfo,
|
||||
} from './types.js';
|
||||
|
||||
const execAsync = promisify(exec);
|
||||
const logger = createLogger('AutoModeServiceFacade');
|
||||
|
||||
/**
|
||||
* Generate a unique key for worktree-scoped auto loop state
|
||||
* (mirrors the function in AutoModeService for status lookups)
|
||||
*/
|
||||
function getWorktreeAutoLoopKey(projectPath: string, branchName: string | null): string {
|
||||
const normalizedBranch = branchName === 'main' ? null : branchName;
|
||||
return `${projectPath}::${normalizedBranch ?? '__main__'}`;
|
||||
}
|
||||
|
||||
/**
|
||||
* AutoModeServiceFacade provides a clean interface for auto-mode functionality.
|
||||
*
|
||||
* Created via factory pattern with a specific projectPath, allowing methods
|
||||
* to use clean names without requiring projectPath as a parameter.
|
||||
*/
|
||||
export class AutoModeServiceFacade {
|
||||
private constructor(
|
||||
private readonly projectPath: string,
|
||||
private readonly events: EventEmitter,
|
||||
private readonly eventBus: TypedEventBus,
|
||||
private readonly concurrencyManager: ConcurrencyManager,
|
||||
private readonly worktreeResolver: WorktreeResolver,
|
||||
private readonly featureStateManager: FeatureStateManager,
|
||||
private readonly featureLoader: FeatureLoader,
|
||||
private readonly planApprovalService: PlanApprovalService,
|
||||
private readonly autoLoopCoordinator: AutoLoopCoordinator,
|
||||
private readonly executionService: ExecutionService,
|
||||
private readonly recoveryService: RecoveryService,
|
||||
private readonly pipelineOrchestrator: PipelineOrchestrator,
|
||||
private readonly settingsService: SettingsService | null
|
||||
) {}
|
||||
|
||||
/**
|
||||
* Create a new AutoModeServiceFacade instance for a specific project.
|
||||
*
|
||||
* @param projectPath - The project path this facade operates on
|
||||
* @param options - Configuration options including events, settingsService, featureLoader
|
||||
*/
|
||||
static create(projectPath: string, options: FacadeOptions): AutoModeServiceFacade {
|
||||
const { events, settingsService = null, featureLoader = new FeatureLoader() } = options;
|
||||
|
||||
// Create core services
|
||||
const eventBus = new TypedEventBus(events);
|
||||
const worktreeResolver = new WorktreeResolver();
|
||||
const concurrencyManager = new ConcurrencyManager((p) => worktreeResolver.getCurrentBranch(p));
|
||||
const featureStateManager = new FeatureStateManager(events, featureLoader);
|
||||
const planApprovalService = new PlanApprovalService(
|
||||
eventBus,
|
||||
featureStateManager,
|
||||
settingsService
|
||||
);
|
||||
const agentExecutor = new AgentExecutor(
|
||||
eventBus,
|
||||
featureStateManager,
|
||||
planApprovalService,
|
||||
settingsService
|
||||
);
|
||||
const testRunnerService = new TestRunnerService();
|
||||
|
||||
// Helper for building feature prompts (used by pipeline orchestrator)
|
||||
const buildFeaturePrompt = (
|
||||
feature: Feature,
|
||||
prompts: { implementationInstructions: string; playwrightVerificationInstructions: string }
|
||||
): string => {
|
||||
const title =
|
||||
feature.title || feature.description?.split('\n')[0]?.substring(0, 60) || 'Untitled';
|
||||
let prompt = `## Feature Implementation Task\n\n**Feature ID:** ${feature.id}\n**Title:** ${title}\n**Description:** ${feature.description}\n`;
|
||||
if (feature.spec) {
|
||||
prompt += `\n**Specification:**\n${feature.spec}\n`;
|
||||
}
|
||||
if (!feature.skipTests) {
|
||||
prompt += `\n${prompts.implementationInstructions}\n\n${prompts.playwrightVerificationInstructions}`;
|
||||
} else {
|
||||
prompt += `\n${prompts.implementationInstructions}`;
|
||||
}
|
||||
return prompt;
|
||||
};
|
||||
|
||||
// Create placeholder callbacks - will be bound to facade methods after creation
|
||||
// These use closures to capture the facade instance once created
|
||||
let facadeInstance: AutoModeServiceFacade | null = null;
|
||||
|
||||
// PipelineOrchestrator - runAgentFn is a stub; routes use AutoModeService directly
|
||||
const pipelineOrchestrator = new PipelineOrchestrator(
|
||||
eventBus,
|
||||
featureStateManager,
|
||||
agentExecutor,
|
||||
testRunnerService,
|
||||
worktreeResolver,
|
||||
concurrencyManager,
|
||||
settingsService,
|
||||
// Callbacks
|
||||
(pPath, featureId, status) =>
|
||||
featureStateManager.updateFeatureStatus(pPath, featureId, status),
|
||||
loadContextFiles,
|
||||
buildFeaturePrompt,
|
||||
(pPath, featureId, useWorktrees, _isAutoMode, _model, opts) =>
|
||||
facadeInstance!.executeFeature(featureId, useWorktrees, false, undefined, opts),
|
||||
// runAgentFn stub - facade does not implement runAgent directly
|
||||
async () => {
|
||||
throw new Error('runAgentFn not implemented in facade');
|
||||
}
|
||||
);
|
||||
|
||||
// AutoLoopCoordinator
|
||||
const autoLoopCoordinator = new AutoLoopCoordinator(
|
||||
eventBus,
|
||||
concurrencyManager,
|
||||
settingsService,
|
||||
// Callbacks
|
||||
(pPath, featureId, useWorktrees, isAutoMode) =>
|
||||
facadeInstance!.executeFeature(featureId, useWorktrees, isAutoMode),
|
||||
(pPath, branchName) =>
|
||||
featureLoader
|
||||
.getAll(pPath)
|
||||
.then((features) =>
|
||||
features.filter(
|
||||
(f) =>
|
||||
(f.status === 'backlog' || f.status === 'ready') &&
|
||||
(branchName === null
|
||||
? !f.branchName || f.branchName === 'main'
|
||||
: f.branchName === branchName)
|
||||
)
|
||||
),
|
||||
(pPath, branchName, maxConcurrency) =>
|
||||
facadeInstance!.saveExecutionStateForProject(branchName, maxConcurrency),
|
||||
(pPath, branchName) => facadeInstance!.clearExecutionState(branchName),
|
||||
(pPath) => featureStateManager.resetStuckFeatures(pPath),
|
||||
(feature) =>
|
||||
feature.status === 'completed' ||
|
||||
feature.status === 'verified' ||
|
||||
feature.status === 'waiting_approval',
|
||||
(featureId) => concurrencyManager.isRunning(featureId)
|
||||
);
|
||||
|
||||
// ExecutionService - runAgentFn is a stub
|
||||
const executionService = new ExecutionService(
|
||||
eventBus,
|
||||
concurrencyManager,
|
||||
worktreeResolver,
|
||||
settingsService,
|
||||
// Callbacks - runAgentFn stub
|
||||
async () => {
|
||||
throw new Error('runAgentFn not implemented in facade');
|
||||
},
|
||||
(context) => pipelineOrchestrator.executePipeline(context),
|
||||
(pPath, featureId, status) =>
|
||||
featureStateManager.updateFeatureStatus(pPath, featureId, status),
|
||||
(pPath, featureId) => featureStateManager.loadFeature(pPath, featureId),
|
||||
async (_feature) => {
|
||||
// getPlanningPromptPrefixFn - planning prompts handled by AutoModeService
|
||||
return '';
|
||||
},
|
||||
(pPath, featureId, summary) =>
|
||||
featureStateManager.saveFeatureSummary(pPath, featureId, summary),
|
||||
async () => {
|
||||
/* recordLearnings - stub */
|
||||
},
|
||||
(pPath, featureId) => facadeInstance!.contextExists(featureId),
|
||||
(pPath, featureId, useWorktrees, _calledInternally) =>
|
||||
facadeInstance!.resumeFeature(featureId, useWorktrees, _calledInternally),
|
||||
(errorInfo) =>
|
||||
autoLoopCoordinator.trackFailureAndCheckPauseForProject(projectPath, errorInfo),
|
||||
(errorInfo) => autoLoopCoordinator.signalShouldPauseForProject(projectPath, errorInfo),
|
||||
() => {
|
||||
/* recordSuccess - no-op */
|
||||
},
|
||||
(_pPath) => facadeInstance!.saveExecutionState(),
|
||||
loadContextFiles
|
||||
);
|
||||
|
||||
// RecoveryService
|
||||
const recoveryService = new RecoveryService(
|
||||
eventBus,
|
||||
concurrencyManager,
|
||||
settingsService,
|
||||
// Callbacks
|
||||
(pPath, featureId, useWorktrees, isAutoMode, providedWorktreePath, opts) =>
|
||||
facadeInstance!.executeFeature(
|
||||
featureId,
|
||||
useWorktrees,
|
||||
isAutoMode,
|
||||
providedWorktreePath,
|
||||
opts
|
||||
),
|
||||
(pPath, featureId) => featureStateManager.loadFeature(pPath, featureId),
|
||||
(pPath, featureId, status) =>
|
||||
pipelineOrchestrator.detectPipelineStatus(pPath, featureId, status),
|
||||
(pPath, feature, useWorktrees, pipelineInfo) =>
|
||||
pipelineOrchestrator.resumePipeline(pPath, feature, useWorktrees, pipelineInfo),
|
||||
(featureId) => concurrencyManager.isRunning(featureId),
|
||||
(opts) => concurrencyManager.acquire(opts),
|
||||
(featureId) => concurrencyManager.release(featureId)
|
||||
);
|
||||
|
||||
// Create the facade instance
|
||||
facadeInstance = new AutoModeServiceFacade(
|
||||
projectPath,
|
||||
events,
|
||||
eventBus,
|
||||
concurrencyManager,
|
||||
worktreeResolver,
|
||||
featureStateManager,
|
||||
featureLoader,
|
||||
planApprovalService,
|
||||
autoLoopCoordinator,
|
||||
executionService,
|
||||
recoveryService,
|
||||
pipelineOrchestrator,
|
||||
settingsService
|
||||
);
|
||||
|
||||
return facadeInstance;
|
||||
}
|
||||
|
||||
// ===========================================================================
|
||||
// AUTO LOOP CONTROL (4 methods)
|
||||
// ===========================================================================
|
||||
|
||||
/**
|
||||
* Start the auto mode loop for this project/worktree
|
||||
* @param branchName - The branch name for worktree scoping, null for main worktree
|
||||
* @param maxConcurrency - Maximum concurrent features
|
||||
*/
|
||||
async startAutoLoop(branchName: string | null = null, maxConcurrency?: number): Promise<number> {
|
||||
return this.autoLoopCoordinator.startAutoLoopForProject(
|
||||
this.projectPath,
|
||||
branchName,
|
||||
maxConcurrency
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Stop the auto mode loop for this project/worktree
|
||||
* @param branchName - The branch name, or null for main worktree
|
||||
*/
|
||||
async stopAutoLoop(branchName: string | null = null): Promise<number> {
|
||||
return this.autoLoopCoordinator.stopAutoLoopForProject(this.projectPath, branchName);
|
||||
}
|
||||
|
||||
/**
|
||||
* Check if auto mode is running for this project/worktree
|
||||
* @param branchName - The branch name, or null for main worktree
|
||||
*/
|
||||
isAutoLoopRunning(branchName: string | null = null): boolean {
|
||||
return this.autoLoopCoordinator.isAutoLoopRunningForProject(this.projectPath, branchName);
|
||||
}
|
||||
|
||||
/**
|
||||
* Get auto loop config for this project/worktree
|
||||
* @param branchName - The branch name, or null for main worktree
|
||||
*/
|
||||
getAutoLoopConfig(branchName: string | null = null): AutoModeConfig | null {
|
||||
return this.autoLoopCoordinator.getAutoLoopConfigForProject(this.projectPath, branchName);
|
||||
}
|
||||
|
||||
// ===========================================================================
|
||||
// FEATURE EXECUTION (6 methods)
|
||||
// ===========================================================================
|
||||
|
||||
/**
|
||||
* Execute a single feature
|
||||
* @param featureId - The feature ID to execute
|
||||
* @param useWorktrees - Whether to use worktrees for isolation
|
||||
* @param isAutoMode - Whether this is running in auto mode
|
||||
* @param providedWorktreePath - Optional pre-resolved worktree path
|
||||
* @param options - Additional execution options
|
||||
*/
|
||||
async executeFeature(
|
||||
featureId: string,
|
||||
useWorktrees = false,
|
||||
isAutoMode = false,
|
||||
providedWorktreePath?: string,
|
||||
options?: {
|
||||
continuationPrompt?: string;
|
||||
_calledInternally?: boolean;
|
||||
}
|
||||
): Promise<void> {
|
||||
return this.executionService.executeFeature(
|
||||
this.projectPath,
|
||||
featureId,
|
||||
useWorktrees,
|
||||
isAutoMode,
|
||||
providedWorktreePath,
|
||||
options
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Stop a specific feature
|
||||
* @param featureId - ID of the feature to stop
|
||||
*/
|
||||
async stopFeature(featureId: string): Promise<boolean> {
|
||||
// Cancel any pending plan approval for this feature
|
||||
this.cancelPlanApproval(featureId);
|
||||
return this.executionService.stopFeature(featureId);
|
||||
}
|
||||
|
||||
/**
|
||||
* Resume a feature (continues from saved context or starts fresh)
|
||||
* @param featureId - ID of the feature to resume
|
||||
* @param useWorktrees - Whether to use git worktrees
|
||||
* @param _calledInternally - Internal flag for nested calls
|
||||
*/
|
||||
async resumeFeature(
|
||||
featureId: string,
|
||||
useWorktrees = false,
|
||||
_calledInternally = false
|
||||
): Promise<void> {
|
||||
return this.recoveryService.resumeFeature(
|
||||
this.projectPath,
|
||||
featureId,
|
||||
useWorktrees,
|
||||
_calledInternally
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Follow up on a feature with additional instructions
|
||||
* @param featureId - The feature ID
|
||||
* @param prompt - Follow-up prompt
|
||||
* @param imagePaths - Optional image paths
|
||||
* @param useWorktrees - Whether to use worktrees
|
||||
*/
|
||||
async followUpFeature(
|
||||
featureId: string,
|
||||
prompt: string,
|
||||
imagePaths?: string[],
|
||||
useWorktrees = true
|
||||
): Promise<void> {
|
||||
// This method contains substantial logic - delegates most work to AgentExecutor
|
||||
validateWorkingDirectory(this.projectPath);
|
||||
|
||||
const runningEntry = this.concurrencyManager.acquire({
|
||||
featureId,
|
||||
projectPath: this.projectPath,
|
||||
isAutoMode: false,
|
||||
});
|
||||
const abortController = runningEntry.abortController;
|
||||
|
||||
const feature = await this.featureStateManager.loadFeature(this.projectPath, featureId);
|
||||
let workDir = path.resolve(this.projectPath);
|
||||
let worktreePath: string | null = null;
|
||||
const branchName = feature?.branchName || `feature/${featureId}`;
|
||||
|
||||
if (useWorktrees && branchName) {
|
||||
worktreePath = await this.worktreeResolver.findWorktreeForBranch(
|
||||
this.projectPath,
|
||||
branchName
|
||||
);
|
||||
if (worktreePath) {
|
||||
workDir = worktreePath;
|
||||
}
|
||||
}
|
||||
|
||||
// Load previous context
|
||||
const featureDir = getFeatureDir(this.projectPath, featureId);
|
||||
const contextPath = path.join(featureDir, 'agent-output.md');
|
||||
let previousContext = '';
|
||||
try {
|
||||
previousContext = (await secureFs.readFile(contextPath, 'utf-8')) as string;
|
||||
} catch {
|
||||
// No previous context
|
||||
}
|
||||
|
||||
const prompts = await getPromptCustomization(this.settingsService, '[Facade]');
|
||||
|
||||
// Build follow-up prompt inline (no template in TaskExecutionPrompts)
|
||||
let fullPrompt = `## Follow-up on Feature Implementation
|
||||
|
||||
${feature ? `**Feature ID:** ${feature.id}\n**Title:** ${feature.title || 'Untitled'}\n**Description:** ${feature.description}` : `**Feature ID:** ${featureId}`}
|
||||
`;
|
||||
|
||||
if (previousContext) {
|
||||
fullPrompt += `
|
||||
## Previous Agent Work
|
||||
The following is the output from the previous implementation attempt:
|
||||
|
||||
${previousContext}
|
||||
`;
|
||||
}
|
||||
|
||||
fullPrompt += `
|
||||
## Follow-up Instructions
|
||||
${prompt}
|
||||
|
||||
## Task
|
||||
Address the follow-up instructions above. Review the previous work and make the requested changes or fixes.`;
|
||||
|
||||
try {
|
||||
this.eventBus.emitAutoModeEvent('auto_mode_feature_start', {
|
||||
featureId,
|
||||
projectPath: this.projectPath,
|
||||
branchName: feature?.branchName ?? null,
|
||||
feature: {
|
||||
id: featureId,
|
||||
title: feature?.title || 'Follow-up',
|
||||
description: feature?.description || 'Following up on feature',
|
||||
},
|
||||
});
|
||||
|
||||
// NOTE: Facade does not have runAgent - this method requires AutoModeService
|
||||
// For now, throw to indicate routes should use AutoModeService.followUpFeature
|
||||
throw new Error(
|
||||
'followUpFeature not fully implemented in facade - use AutoModeService.followUpFeature instead'
|
||||
);
|
||||
} catch (error) {
|
||||
const errorInfo = classifyError(error);
|
||||
if (!errorInfo.isAbort) {
|
||||
this.eventBus.emitAutoModeEvent('auto_mode_error', {
|
||||
featureId,
|
||||
featureName: feature?.title,
|
||||
branchName: feature?.branchName ?? null,
|
||||
error: errorInfo.message,
|
||||
errorType: errorInfo.type,
|
||||
projectPath: this.projectPath,
|
||||
});
|
||||
}
|
||||
throw error;
|
||||
} finally {
|
||||
this.concurrencyManager.release(featureId);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Verify a feature's implementation
|
||||
* @param featureId - The feature ID to verify
|
||||
*/
|
||||
async verifyFeature(featureId: string): Promise<boolean> {
|
||||
const feature = await this.featureStateManager.loadFeature(this.projectPath, featureId);
|
||||
const sanitizedFeatureId = featureId.replace(/[^a-zA-Z0-9_-]/g, '-');
|
||||
const worktreePath = path.join(this.projectPath, '.worktrees', sanitizedFeatureId);
|
||||
let workDir = this.projectPath;
|
||||
|
||||
try {
|
||||
await secureFs.access(worktreePath);
|
||||
workDir = worktreePath;
|
||||
} catch {
|
||||
// No worktree
|
||||
}
|
||||
|
||||
const verificationChecks = [
|
||||
{ cmd: 'npm run lint', name: 'Lint' },
|
||||
{ cmd: 'npm run typecheck', name: 'Type check' },
|
||||
{ cmd: 'npm test', name: 'Tests' },
|
||||
{ cmd: 'npm run build', name: 'Build' },
|
||||
];
|
||||
|
||||
let allPassed = true;
|
||||
const results: Array<{ check: string; passed: boolean; output?: string }> = [];
|
||||
|
||||
for (const check of verificationChecks) {
|
||||
try {
|
||||
const { stdout, stderr } = await execAsync(check.cmd, { cwd: workDir, timeout: 120000 });
|
||||
results.push({ check: check.name, passed: true, output: stdout || stderr });
|
||||
} catch (error) {
|
||||
allPassed = false;
|
||||
results.push({ check: check.name, passed: false, output: (error as Error).message });
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
this.eventBus.emitAutoModeEvent('auto_mode_feature_complete', {
|
||||
featureId,
|
||||
featureName: feature?.title,
|
||||
branchName: feature?.branchName ?? null,
|
||||
passes: allPassed,
|
||||
message: allPassed
|
||||
? 'All verification checks passed'
|
||||
: `Verification failed: ${results.find((r) => !r.passed)?.check || 'Unknown'}`,
|
||||
projectPath: this.projectPath,
|
||||
});
|
||||
|
||||
return allPassed;
|
||||
}
|
||||
|
||||
/**
|
||||
* Commit feature changes
|
||||
* @param featureId - The feature ID to commit
|
||||
* @param providedWorktreePath - Optional worktree path
|
||||
*/
|
||||
async commitFeature(featureId: string, providedWorktreePath?: string): Promise<string | null> {
|
||||
let workDir = this.projectPath;
|
||||
|
||||
if (providedWorktreePath) {
|
||||
try {
|
||||
await secureFs.access(providedWorktreePath);
|
||||
workDir = providedWorktreePath;
|
||||
} catch {
|
||||
// Use project path
|
||||
}
|
||||
} else {
|
||||
const sanitizedFeatureId = featureId.replace(/[^a-zA-Z0-9_-]/g, '-');
|
||||
const legacyWorktreePath = path.join(this.projectPath, '.worktrees', sanitizedFeatureId);
|
||||
try {
|
||||
await secureFs.access(legacyWorktreePath);
|
||||
workDir = legacyWorktreePath;
|
||||
} catch {
|
||||
// Use project path
|
||||
}
|
||||
}
|
||||
|
||||
try {
|
||||
const { stdout: status } = await execAsync('git status --porcelain', { cwd: workDir });
|
||||
if (!status.trim()) {
|
||||
return null;
|
||||
}
|
||||
|
||||
const feature = await this.featureStateManager.loadFeature(this.projectPath, featureId);
|
||||
const title =
|
||||
feature?.description?.split('\n')[0]?.substring(0, 60) || `Feature ${featureId}`;
|
||||
const commitMessage = `feat: ${title}\n\nImplemented by Automaker auto-mode`;
|
||||
|
||||
await execAsync('git add -A', { cwd: workDir });
|
||||
await execAsync(`git commit -m "${commitMessage.replace(/"/g, '\\"')}"`, { cwd: workDir });
|
||||
const { stdout: hash } = await execAsync('git rev-parse HEAD', { cwd: workDir });
|
||||
|
||||
this.eventBus.emitAutoModeEvent('auto_mode_feature_complete', {
|
||||
featureId,
|
||||
featureName: feature?.title,
|
||||
branchName: feature?.branchName ?? null,
|
||||
passes: true,
|
||||
message: `Changes committed: ${hash.trim().substring(0, 8)}`,
|
||||
projectPath: this.projectPath,
|
||||
});
|
||||
|
||||
return hash.trim();
|
||||
} catch (error) {
|
||||
logger.error(`Commit failed for ${featureId}:`, error);
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
// ===========================================================================
|
||||
// STATUS AND QUERIES (7 methods)
|
||||
// ===========================================================================
|
||||
|
||||
/**
|
||||
* Get current status (global across all projects)
|
||||
*/
|
||||
getStatus(): AutoModeStatus {
|
||||
const allRunning = this.concurrencyManager.getAllRunning();
|
||||
return {
|
||||
isRunning: allRunning.length > 0,
|
||||
runningFeatures: allRunning.map((rf) => rf.featureId),
|
||||
runningCount: allRunning.length,
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Get status for this project/worktree
|
||||
* @param branchName - The branch name, or null for main worktree
|
||||
*/
|
||||
getStatusForProject(branchName: string | null = null): ProjectAutoModeStatus {
|
||||
const isAutoLoopRunning = this.autoLoopCoordinator.isAutoLoopRunningForProject(
|
||||
this.projectPath,
|
||||
branchName
|
||||
);
|
||||
const config = this.autoLoopCoordinator.getAutoLoopConfigForProject(
|
||||
this.projectPath,
|
||||
branchName
|
||||
);
|
||||
const runningFeatures = this.concurrencyManager
|
||||
.getAllRunning()
|
||||
.filter((f) => f.projectPath === this.projectPath && f.branchName === branchName)
|
||||
.map((f) => f.featureId);
|
||||
|
||||
return {
|
||||
isAutoLoopRunning,
|
||||
runningFeatures,
|
||||
runningCount: runningFeatures.length,
|
||||
maxConcurrency: config?.maxConcurrency ?? DEFAULT_MAX_CONCURRENCY,
|
||||
branchName,
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Get all active auto loop projects (unique project paths)
|
||||
*/
|
||||
getActiveAutoLoopProjects(): string[] {
|
||||
// This needs access to internal state - for now return empty
|
||||
// Routes should migrate to getActiveAutoLoopWorktrees
|
||||
return [];
|
||||
}
|
||||
|
||||
/**
|
||||
* Get all active auto loop worktrees
|
||||
*/
|
||||
getActiveAutoLoopWorktrees(): Array<{ projectPath: string; branchName: string | null }> {
|
||||
// This needs access to internal state - for now return empty
|
||||
// Will be properly implemented when routes migrate
|
||||
return [];
|
||||
}
|
||||
|
||||
/**
|
||||
* Get detailed info about all running agents
|
||||
*/
|
||||
async getRunningAgents(): Promise<RunningAgentInfo[]> {
|
||||
const agents = await Promise.all(
|
||||
this.concurrencyManager.getAllRunning().map(async (rf) => {
|
||||
let title: string | undefined;
|
||||
let description: string | undefined;
|
||||
let branchName: string | undefined;
|
||||
|
||||
try {
|
||||
const feature = await this.featureLoader.get(rf.projectPath, rf.featureId);
|
||||
if (feature) {
|
||||
title = feature.title;
|
||||
description = feature.description;
|
||||
branchName = feature.branchName;
|
||||
}
|
||||
} catch {
|
||||
// Silently ignore
|
||||
}
|
||||
|
||||
return {
|
||||
featureId: rf.featureId,
|
||||
projectPath: rf.projectPath,
|
||||
projectName: path.basename(rf.projectPath),
|
||||
isAutoMode: rf.isAutoMode,
|
||||
model: rf.model,
|
||||
provider: rf.provider,
|
||||
title,
|
||||
description,
|
||||
branchName,
|
||||
};
|
||||
})
|
||||
);
|
||||
return agents;
|
||||
}
|
||||
|
||||
/**
|
||||
* Check if there's capacity to start a feature on a worktree
|
||||
* @param featureId - The feature ID to check capacity for
|
||||
*/
|
||||
async checkWorktreeCapacity(featureId: string): Promise<WorktreeCapacityInfo> {
|
||||
const feature = await this.featureStateManager.loadFeature(this.projectPath, featureId);
|
||||
const rawBranchName = feature?.branchName ?? null;
|
||||
const branchName = rawBranchName === 'main' ? null : rawBranchName;
|
||||
|
||||
const maxAgents = await this.autoLoopCoordinator.resolveMaxConcurrency(
|
||||
this.projectPath,
|
||||
branchName
|
||||
);
|
||||
const currentAgents = await this.concurrencyManager.getRunningCountForWorktree(
|
||||
this.projectPath,
|
||||
branchName
|
||||
);
|
||||
|
||||
return {
|
||||
hasCapacity: currentAgents < maxAgents,
|
||||
currentAgents,
|
||||
maxAgents,
|
||||
branchName,
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Check if context exists for a feature
|
||||
* @param featureId - The feature ID
|
||||
*/
|
||||
async contextExists(featureId: string): Promise<boolean> {
|
||||
return this.recoveryService.contextExists(this.projectPath, featureId);
|
||||
}
|
||||
|
||||
// ===========================================================================
|
||||
// PLAN APPROVAL (4 methods)
|
||||
// ===========================================================================
|
||||
|
||||
/**
|
||||
* Resolve a pending plan approval
|
||||
* @param featureId - The feature ID
|
||||
* @param approved - Whether the plan was approved
|
||||
* @param editedPlan - Optional edited plan content
|
||||
* @param feedback - Optional feedback
|
||||
*/
|
||||
async resolvePlanApproval(
|
||||
featureId: string,
|
||||
approved: boolean,
|
||||
editedPlan?: string,
|
||||
feedback?: string
|
||||
): Promise<{ success: boolean; error?: string }> {
|
||||
const result = await this.planApprovalService.resolveApproval(featureId, approved, {
|
||||
editedPlan,
|
||||
feedback,
|
||||
projectPath: this.projectPath,
|
||||
});
|
||||
|
||||
// Handle recovery case
|
||||
if (result.success && result.needsRecovery) {
|
||||
const feature = await this.featureStateManager.loadFeature(this.projectPath, featureId);
|
||||
if (feature) {
|
||||
const prompts = await getPromptCustomization(this.settingsService, '[Facade]');
|
||||
const planContent = editedPlan || feature.planSpec?.content || '';
|
||||
let continuationPrompt = prompts.taskExecution.continuationAfterApprovalTemplate;
|
||||
continuationPrompt = continuationPrompt.replace(/\{\{userFeedback\}\}/g, feedback || '');
|
||||
continuationPrompt = continuationPrompt.replace(/\{\{approvedPlan\}\}/g, planContent);
|
||||
|
||||
// Start execution async
|
||||
this.executeFeature(featureId, true, false, undefined, { continuationPrompt }).catch(
|
||||
(error) => {
|
||||
logger.error(`Recovery execution failed for feature ${featureId}:`, error);
|
||||
}
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
return { success: result.success, error: result.error };
|
||||
}
|
||||
|
||||
/**
|
||||
* Wait for plan approval
|
||||
* @param featureId - The feature ID
|
||||
*/
|
||||
waitForPlanApproval(
|
||||
featureId: string
|
||||
): Promise<{ approved: boolean; editedPlan?: string; feedback?: string }> {
|
||||
return this.planApprovalService.waitForApproval(featureId, this.projectPath);
|
||||
}
|
||||
|
||||
/**
|
||||
* Check if a feature has a pending plan approval
|
||||
* @param featureId - The feature ID
|
||||
*/
|
||||
hasPendingApproval(featureId: string): boolean {
|
||||
return this.planApprovalService.hasPendingApproval(featureId);
|
||||
}
|
||||
|
||||
/**
|
||||
* Cancel a pending plan approval
|
||||
* @param featureId - The feature ID
|
||||
*/
|
||||
cancelPlanApproval(featureId: string): void {
|
||||
this.planApprovalService.cancelApproval(featureId);
|
||||
}
|
||||
|
||||
// ===========================================================================
|
||||
// ANALYSIS AND RECOVERY (3 methods)
|
||||
// ===========================================================================
|
||||
|
||||
/**
|
||||
* Analyze project to gather context
|
||||
*
|
||||
* NOTE: This method requires complex provider integration that is only available
|
||||
* in AutoModeService. The facade exposes the method signature for API compatibility,
|
||||
* but routes should use AutoModeService.analyzeProject() until migration is complete.
|
||||
*/
|
||||
async analyzeProject(): Promise<void> {
|
||||
// analyzeProject requires provider.execute which is complex to wire up
|
||||
// For now, throw to indicate routes should use AutoModeService
|
||||
throw new Error(
|
||||
'analyzeProject not fully implemented in facade - use AutoModeService.analyzeProject instead'
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Resume interrupted features after server restart
|
||||
*/
|
||||
async resumeInterruptedFeatures(): Promise<void> {
|
||||
return this.recoveryService.resumeInterruptedFeatures(this.projectPath);
|
||||
}
|
||||
|
||||
/**
|
||||
* Detect orphaned features (features with missing branches)
|
||||
*/
|
||||
async detectOrphanedFeatures(): Promise<OrphanedFeatureInfo[]> {
|
||||
const orphanedFeatures: OrphanedFeatureInfo[] = [];
|
||||
|
||||
try {
|
||||
const allFeatures = await this.featureLoader.getAll(this.projectPath);
|
||||
const featuresWithBranches = allFeatures.filter(
|
||||
(f) => f.branchName && f.branchName.trim() !== ''
|
||||
);
|
||||
|
||||
if (featuresWithBranches.length === 0) {
|
||||
return orphanedFeatures;
|
||||
}
|
||||
|
||||
// Get existing branches
|
||||
const { stdout } = await execAsync(
|
||||
'git for-each-ref --format="%(refname:short)" refs/heads/',
|
||||
{ cwd: this.projectPath }
|
||||
);
|
||||
const existingBranches = new Set(
|
||||
stdout
|
||||
.trim()
|
||||
.split('\n')
|
||||
.map((b) => b.trim())
|
||||
.filter(Boolean)
|
||||
);
|
||||
|
||||
const primaryBranch = await this.worktreeResolver.getCurrentBranch(this.projectPath);
|
||||
|
||||
for (const feature of featuresWithBranches) {
|
||||
const branchName = feature.branchName!;
|
||||
if (primaryBranch && branchName === primaryBranch) {
|
||||
continue;
|
||||
}
|
||||
if (!existingBranches.has(branchName)) {
|
||||
orphanedFeatures.push({ feature, missingBranch: branchName });
|
||||
}
|
||||
}
|
||||
|
||||
return orphanedFeatures;
|
||||
} catch (error) {
|
||||
logger.error('[detectOrphanedFeatures] Error:', error);
|
||||
return orphanedFeatures;
|
||||
}
|
||||
}
|
||||
|
||||
// ===========================================================================
|
||||
// LIFECYCLE (1 method)
|
||||
// ===========================================================================
|
||||
|
||||
/**
|
||||
* Mark all running features as interrupted
|
||||
* @param reason - Optional reason for the interruption
|
||||
*/
|
||||
async markAllRunningFeaturesInterrupted(reason?: string): Promise<void> {
|
||||
const allRunning = this.concurrencyManager.getAllRunning();
|
||||
|
||||
for (const rf of allRunning) {
|
||||
await this.featureStateManager.markFeatureInterrupted(rf.projectPath, rf.featureId, reason);
|
||||
}
|
||||
|
||||
if (allRunning.length > 0) {
|
||||
logger.info(
|
||||
`Marked ${allRunning.length} running feature(s) as interrupted: ${reason || 'no reason provided'}`
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
// ===========================================================================
|
||||
// INTERNAL HELPERS
|
||||
// ===========================================================================
|
||||
|
||||
/**
|
||||
* Save execution state for recovery
|
||||
*/
|
||||
private async saveExecutionState(): Promise<void> {
|
||||
return this.saveExecutionStateForProject(null, DEFAULT_MAX_CONCURRENCY);
|
||||
}
|
||||
|
||||
/**
|
||||
* Save execution state for a specific worktree
|
||||
*/
|
||||
private async saveExecutionStateForProject(
|
||||
branchName: string | null,
|
||||
maxConcurrency: number
|
||||
): Promise<void> {
|
||||
return this.recoveryService.saveExecutionStateForProject(
|
||||
this.projectPath,
|
||||
branchName,
|
||||
maxConcurrency
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Clear execution state
|
||||
*/
|
||||
private async clearExecutionState(branchName: string | null = null): Promise<void> {
|
||||
return this.recoveryService.clearExecutionState(this.projectPath, branchName);
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user