@posthog/agent 1.11.0 → 1.13.0

package/src/workflow/steps/plan.ts

@@ -0,0 +1,112 @@
+import { query } from '@anthropic-ai/claude-agent-sdk';
+import { PLANNING_SYSTEM_PROMPT } from '../../agents/planning.js';
+import type { WorkflowStepRunner } from '../types.js';
+import { finalizeStepGitActions } from '../utils.js';
+
+export const planStep: WorkflowStepRunner = async ({ step, context }) => {
+    const {
+        task,
+        cwd,
+        isCloudMode,
+        options,
+        logger,
+        fileManager,
+        gitManager,
+        promptBuilder,
+        adapter,
+        mcpServers,
+        emitEvent,
+    } = context;
+
+    const stepLogger = logger.child('PlanStep');
+
+    const existingPlan = await fileManager.readPlan(task.id);
+    if (existingPlan) {
+        stepLogger.info('Plan already exists, skipping step', { taskId: task.id });
+        return { status: 'skipped' };
+    }
+
+    const questionsData = await fileManager.readQuestions(task.id);
+    if (!questionsData || !questionsData.answered) {
+        stepLogger.info('Waiting for answered research questions', { taskId: task.id });
+        emitEvent(adapter.createStatusEvent('phase_complete', { phase: 'research_questions' }));
+        return { status: 'skipped', halt: true };
+    }
+
+    stepLogger.info('Starting planning phase', { taskId: task.id });
+    emitEvent(adapter.createStatusEvent('phase_start', { phase: 'planning' }));
+
+    const researchContent = await fileManager.readResearch(task.id);
+    let researchContext = '';
+    if (researchContent) {
+        researchContext += `## Research Analysis\n\n${researchContent}\n\n`;
+    }
+
+    researchContext += `## Implementation Decisions\n\n`;
+    for (const question of questionsData.questions) {
+        const answer = questionsData.answers?.find(
+            (a: any) => a.questionId === question.id
+        );
+
+        researchContext += `### ${question.question}\n\n`;
+        if (answer) {
+            researchContext += `**Selected:** ${answer.selectedOption}\n`;
+            if (answer.customInput) {
+                researchContext += `**Details:** ${answer.customInput}\n`;
+            }
+        } else {
+            researchContext += `**Selected:** Not answered\n`;
+        }
+        researchContext += `\n`;
+    }
+
+    const planningPrompt = await promptBuilder.buildPlanningPrompt(task, cwd);
+    const fullPrompt = `${PLANNING_SYSTEM_PROMPT}\n\n${planningPrompt}\n\n${researchContext}`;
+
+    const baseOptions: Record<string, any> = {
+        model: step.model,
+        cwd,
+        permissionMode: 'plan',
+        settingSources: ['local'],
+        mcpServers,
+    };
+
+    const response = query({
+        prompt: fullPrompt,
+        options: { ...baseOptions, ...(options.queryOverrides || {}) },
+    });
+
+    let planContent = '';
+    for await (const message of response) {
+        emitEvent(adapter.createRawSDKEvent(message));
+        const transformed = adapter.transform(message);
+        if (transformed) {
+            emitEvent(transformed);
+        }
+        if (message.type === 'assistant' && message.message?.content) {
+            for (const c of message.message.content) {
+                if (c.type === 'text' && c.text) {
+                    planContent += `${c.text}\n`;
+                }
+            }
+        }
+    }
+
+    if (planContent.trim()) {
+        await fileManager.writePlan(task.id, planContent.trim());
+        stepLogger.info('Plan completed', { taskId: task.id });
+    }
+
+    await gitManager.addAllPostHogFiles();
+    await finalizeStepGitActions(context, step, {
+        commitMessage: `Planning phase for ${task.title}`,
+    });
+
+    if (!isCloudMode) {
+        emitEvent(adapter.createStatusEvent('phase_complete', { phase: 'planning' }));
+        return { status: 'completed', halt: true };
+    }
+
+    emitEvent(adapter.createStatusEvent('phase_complete', { phase: 'planning' }));
+    return { status: 'completed' };
+};

package/src/workflow/steps/research.ts

@@ -0,0 +1,156 @@
+import { query } from '@anthropic-ai/claude-agent-sdk';
+import { RESEARCH_SYSTEM_PROMPT } from '../../agents/research.js';
+import type { ExtractedQuestionWithAnswer } from '../../structured-extraction.js';
+import type { WorkflowStepRunner } from '../types.js';
+import { finalizeStepGitActions } from '../utils.js';
+
+export const researchStep: WorkflowStepRunner = async ({ step, context }) => {
+    const {
+        task,
+        cwd,
+        isCloudMode,
+        options,
+        logger,
+        fileManager,
+        gitManager,
+        promptBuilder,
+        adapter,
+        mcpServers,
+        extractor,
+        emitEvent,
+    } = context;
+
+    const stepLogger = logger.child('ResearchStep');
+
+    const existingResearch = await fileManager.readResearch(task.id);
+    if (existingResearch) {
+        stepLogger.info('Research already exists, skipping step', { taskId: task.id });
+        return { status: 'skipped' };
+    }
+
+    stepLogger.info('Starting research phase', { taskId: task.id });
+    emitEvent(adapter.createStatusEvent('phase_start', { phase: 'research' }));
+
+    const researchPrompt = await promptBuilder.buildResearchPrompt(task, cwd);
+    const fullPrompt = `${RESEARCH_SYSTEM_PROMPT}\n\n${researchPrompt}`;
+
+    const baseOptions: Record<string, any> = {
+        model: step.model,
+        cwd,
+        permissionMode: 'plan',
+        settingSources: ['local'],
+        mcpServers,
+    };
+
+    const response = query({
+        prompt: fullPrompt,
+        options: { ...baseOptions, ...(options.queryOverrides || {}) },
+    });
+
+    let researchContent = '';
+    for await (const message of response) {
+        emitEvent(adapter.createRawSDKEvent(message));
+        const transformed = adapter.transform(message);
+        if (transformed) {
+            emitEvent(transformed);
+        }
+        if (message.type === 'assistant' && message.message?.content) {
+            for (const c of message.message.content) {
+                if (c.type === 'text' && c.text) {
+                    researchContent += `${c.text}\n`;
+                }
+            }
+        }
+    }
+
+    if (researchContent.trim()) {
+        await fileManager.writeResearch(task.id, researchContent.trim());
+        stepLogger.info('Research completed', { taskId: task.id });
+    }
+
+    await gitManager.addAllPostHogFiles();
+    await finalizeStepGitActions(context, step, {
+        commitMessage: `Research phase for ${task.title}`,
+    });
+
+    if (extractor && researchContent.trim()) {
+        try {
+            stepLogger.info('Extracting questions from research.md', { taskId: task.id });
+            const parsedQuestions = await extractor.extractQuestions(researchContent);
+
+            await fileManager.writeQuestions(task.id, {
+                questions: parsedQuestions,
+                answered: false,
+                answers: null,
+            });
+
+            emitEvent({
+                type: 'artifact',
+                ts: Date.now(),
+                kind: 'research_questions',
+                content: parsedQuestions,
+            });
+
+            stepLogger.info('Questions extracted successfully', {
+                taskId: task.id,
+                count: parsedQuestions.length,
+            });
+        } catch (error) {
+            stepLogger.error('Failed to extract questions', {
+                taskId: task.id,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            emitEvent({
+                type: 'error',
+                ts: Date.now(),
+                message: `Failed to extract questions: ${
+                    error instanceof Error ? error.message : String(error)
+                }`,
+            });
+        }
+    } else if (!extractor) {
+        stepLogger.warn(
+            'Question extractor not available, skipping question extraction. Ensure LLM gateway is configured.'
+        );
+        emitEvent({
+            type: 'status',
+            ts: Date.now(),
+            phase: 'extraction_skipped',
+            message: 'Question extraction skipped - extractor not configured',
+        });
+    }
+
+    if (!isCloudMode) {
+        emitEvent(adapter.createStatusEvent('phase_complete', { phase: 'research' }));
+        return { status: 'completed', halt: true };
+    }
+
+    const questionsData = await fileManager.readQuestions(task.id);
+    if (questionsData && !questionsData.answered && extractor && researchContent.trim()) {
+        const researchQuestions = await extractor.extractQuestionsWithAnswers(researchContent);
+        const answers = (researchQuestions as ExtractedQuestionWithAnswer[]).map((qa) => ({
+            questionId: qa.id,
+            selectedOption: qa.recommendedAnswer,
+            customInput: qa.justification,
+        }));
+
+        await fileManager.writeQuestions(task.id, {
+            questions: researchQuestions.map((qa) => ({
+                id: qa.id,
+                question: qa.question,
+                options: qa.options,
+            })),
+            answered: true,
+            answers,
+        });
+
+        await gitManager.addAllPostHogFiles();
+        await finalizeStepGitActions(context, step, {
+            commitMessage: `Answer research questions for ${task.title}`,
+        });
+        stepLogger.info('Auto-answered research questions', { taskId: task.id });
+    }
+
+    emitEvent(adapter.createStatusEvent('phase_complete', { phase: 'research' }));
+    return { status: 'completed' };
+};

package/src/workflow/types.ts

@@ -0,0 +1,53 @@
+import type { Task, TaskExecutionOptions, PermissionMode } from '../types.js';
+import type { Logger } from '../utils/logger.js';
+import type { PostHogFileManager } from '../file-manager.js';
+import type { GitManager } from '../git-manager.js';
+import type { PromptBuilder } from '../prompt-builder.js';
+import type { TaskProgressReporter } from '../task-progress-reporter.js';
+import type { ProviderAdapter } from '../adapters/types.js';
+import type { PostHogAPIClient } from '../posthog-api.js';
+import type { StructuredExtractor } from '../structured-extraction.js';
+
+export interface WorkflowRuntime {
+    task: Task;
+    taskSlug: string;
+    cwd: string;
+    isCloudMode: boolean;
+    options: TaskExecutionOptions;
+    logger: Logger;
+    fileManager: PostHogFileManager;
+    gitManager: GitManager;
+    promptBuilder: PromptBuilder;
+    progressReporter: TaskProgressReporter;
+    adapter: ProviderAdapter;
+    mcpServers?: Record<string, any>;
+    posthogAPI?: PostHogAPIClient;
+    extractor?: StructuredExtractor;
+    emitEvent: (event: any) => void;
+    stepResults: Record<string, any>;
+}
+
+export interface WorkflowStepDefinition {
+    id: string;
+    name: string;
+    agent: string;
+    model: string;
+    permissionMode?: PermissionMode | string;
+    commit?: boolean;
+    push?: boolean;
+    run: WorkflowStepRunner;
+}
+
+export interface WorkflowStepRuntime {
+    step: WorkflowStepDefinition;
+    context: WorkflowRuntime;
+}
+
+export interface WorkflowStepResult {
+    status: 'completed' | 'skipped';
+    halt?: boolean;
+}
+
+export type WorkflowStepRunner = (runtime: WorkflowStepRuntime) => Promise<WorkflowStepResult>;
+
+export type WorkflowDefinition = WorkflowStepDefinition[];

package/src/workflow/utils.ts

@@ -0,0 +1,50 @@
+import type { WorkflowRuntime, WorkflowStepDefinition } from './types.js';
+
+interface FinalizeGitOptions {
+    commitMessage: string;
+    allowEmptyCommit?: boolean;
+}
+
+/**
+ * Commits (and optionally pushes) any staged changes according to the step configuration.
+ * Returns true if a commit was created.
+ */
+export async function finalizeStepGitActions(
+    context: WorkflowRuntime,
+    step: WorkflowStepDefinition,
+    options: FinalizeGitOptions
+): Promise<boolean> {
+    if (!step.commit) {
+        return false;
+    }
+
+    const { gitManager, logger } = context;
+    const hasStagedChanges = await gitManager.hasStagedChanges();
+
+    if (!hasStagedChanges && !options.allowEmptyCommit) {
+        logger.debug('No staged changes to commit for step', { stepId: step.id });
+        return false;
+    }
+
+    try {
+        await gitManager.commitChanges(options.commitMessage);
+        logger.info('Committed changes for step', {
+            stepId: step.id,
+            message: options.commitMessage,
+        });
+    } catch (error) {
+        logger.error('Failed to commit changes for step', {
+            stepId: step.id,
+            error: error instanceof Error ? error.message : String(error),
+        });
+        throw error;
+    }
+
+    if (step.push) {
+        const branchName = await gitManager.getCurrentBranch();
+        await gitManager.pushBranch(branchName);
+        logger.info('Pushed branch after step', { stepId: step.id, branch: branchName });
+    }
+
+    return true;
+}

package/dist/src/agent-registry.d.ts

@@ -1,16 +0,0 @@
-import type { AgentDefinition, AgentType } from './workflow-types.js';
-export declare class AgentRegistry {
-    private agentsByName;
-    constructor(definitions?: AgentDefinition[]);
-    static getDefaultAgents(): AgentDefinition[];
-    register(def: AgentDefinition): void;
-    getAgent(name: string): AgentDefinition | undefined;
-    listAgents(): AgentDefinition[];
-    exportForPostHog(): {
-        id: string;
-        name: string;
-        agent_type: AgentType;
-        description?: string;
-    }[];
-}
-//# sourceMappingURL=agent-registry.d.ts.map

package/dist/src/agent-registry.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"agent-registry.d.ts","sourceRoot":"","sources":["../../src/agent-registry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAEtE,qBAAa,aAAa;IACxB,OAAO,CAAC,YAAY,CAA2C;gBAEnD,WAAW,CAAC,EAAE,eAAe,EAAE;IAQ3C,MAAM,CAAC,gBAAgB,IAAI,eAAe,EAAE;IAmC5C,QAAQ,CAAC,GAAG,EAAE,eAAe,GAAG,IAAI;IAIpC,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,eAAe,GAAG,SAAS;IAInD,UAAU,IAAI,eAAe,EAAE;IAI/B,gBAAgB,IAAI;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,SAAS,CAAC;QAAC,WAAW,CAAC,EAAE,MAAM,CAAA;KAAE,EAAE;CAGhG"}

package/dist/src/agent-registry.js

@@ -1,62 +0,0 @@
-class AgentRegistry {
-    agentsByName = new Map();
-    constructor(definitions) {
-        if (definitions) {
-            for (const def of definitions)
-                this.register(def);
-        }
-        else {
-            for (const def of AgentRegistry.getDefaultAgents())
-                this.register(def);
-        }
-    }
-    static getDefaultAgents() {
-        return [
-            {
-                id: 'research',
-                name: 'research',
-                agent_type: 'research',
-                description: 'Explore codebase and generate clarifying questions',
-            },
-            {
-                id: 'planning',
-                name: 'planning',
-                agent_type: 'planning',
-                description: 'Analyze repo and produce implementation plan',
-            },
-            {
-                id: 'code_generation',
-                name: 'code_generation',
-                agent_type: 'execution',
-                description: 'Implements code changes using Claude SDK',
-            },
-            {
-                id: 'review',
-                name: 'review',
-                agent_type: 'review',
-                description: 'Reviews changes and suggests fixes',
-            },
-            {
-                id: 'testing',
-                name: 'testing',
-                agent_type: 'testing',
-                description: 'Runs tests and reports results',
-            },
-        ];
-    }
-    register(def) {
-        this.agentsByName.set(def.name, def);
-    }
-    getAgent(name) {
-        return this.agentsByName.get(name);
-    }
-    listAgents() {
-        return Array.from(this.agentsByName.values());
-    }
-    exportForPostHog() {
-        return this.listAgents().map(({ id, name, agent_type, description }) => ({ id, name, agent_type, description }));
-    }
-}
-
-export { AgentRegistry };
-//# sourceMappingURL=agent-registry.js.map

package/dist/src/agent-registry.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"agent-registry.js","sources":["../../src/agent-registry.ts"],"sourcesContent":["import type { AgentDefinition, AgentType } from './workflow-types.js';\n\nexport class AgentRegistry {\n  private agentsByName: Map<string, AgentDefinition> = new Map();\n\n  constructor(definitions?: AgentDefinition[]) {\n    if (definitions) {\n      for (const def of definitions) this.register(def);\n    } else {\n      for (const def of AgentRegistry.getDefaultAgents()) this.register(def);\n    }\n  }\n\n  static getDefaultAgents(): AgentDefinition[] {\n    return [\n      {\n        id: 'research',\n        name: 'research',\n        agent_type: 'research',\n        description: 'Explore codebase and generate clarifying questions',\n      },\n      {\n        id: 'planning',\n        name: 'planning',\n        agent_type: 'planning',\n        description: 'Analyze repo and produce implementation plan',\n      },\n      {\n        id: 'code_generation',\n        name: 'code_generation',\n        agent_type: 'execution',\n        description: 'Implements code changes using Claude SDK',\n      },\n      {\n        id: 'review',\n        name: 'review',\n        agent_type: 'review',\n        description: 'Reviews changes and suggests fixes',\n      },\n      {\n        id: 'testing',\n        name: 'testing',\n        agent_type: 'testing',\n        description: 'Runs tests and reports results',\n      },\n    ];\n  }\n\n  register(def: AgentDefinition): void {\n    this.agentsByName.set(def.name, def);\n  }\n\n  getAgent(name: string): AgentDefinition | undefined {\n    return this.agentsByName.get(name);\n  }\n\n  listAgents(): AgentDefinition[] {\n    return Array.from(this.agentsByName.values());\n  }\n\n  exportForPostHog(): { id: string; name: string; agent_type: AgentType; description?: string }[] {\n    return this.listAgents().map(({ id, name, agent_type, description }) => ({ id, name, agent_type, description }));\n  }\n}\n\n"],"names":[],"mappings":"MAEa,aAAa,CAAA;AAChB,IAAA,YAAY,GAAiC,IAAI,GAAG,EAAE;AAE9D,IAAA,WAAA,CAAY,WAA+B,EAAA;QACzC,IAAI,WAAW,EAAE;YACf,KAAK,MAAM,GAAG,IAAI,WAAW;AAAE,gBAAA,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC;QACnD;aAAO;AACL,YAAA,KAAK,MAAM,GAAG,IAAI,aAAa,CAAC,gBAAgB,EAAE;AAAE,gBAAA,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC;QACxE;IACF;AAEA,IAAA,OAAO,gBAAgB,GAAA;QACrB,OAAO;AACL,YAAA;AACE,gBAAA,EAAE,EAAE,UAAU;AACd,gBAAA,IAAI,EAAE,UAAU;AAChB,gBAAA,UAAU,EAAE,UAAU;AACtB,gBAAA,WAAW,EAAE,oDAAoD;AAClE,aAAA;AACD,YAAA;AACE,gBAAA,EAAE,EAAE,UAAU;AACd,gBAAA,IAAI,EAAE,UAAU;AAChB,gBAAA,UAAU,EAAE,UAAU;AACtB,gBAAA,WAAW,EAAE,8CAA8C;AAC5D,aAAA;AACD,YAAA;AACE,gBAAA,EAAE,EAAE,iBAAiB;AACrB,gBAAA,IAAI,EAAE,iBAAiB;AACvB,gBAAA,UAAU,EAAE,WAAW;AACvB,gBAAA,WAAW,EAAE,0CAA0C;AACxD,aAAA;AACD,YAAA;AACE,gBAAA,EAAE,EAAE,QAAQ;AACZ,gBAAA,IAAI,EAAE,QAAQ;AACd,gBAAA,UAAU,EAAE,QAAQ;AACpB,gBAAA,WAAW,EAAE,oCAAoC;AAClD,aAAA;AACD,YAAA;AACE,gBAAA,EAAE,EAAE,SAAS;AACb,gBAAA,IAAI,EAAE,SAAS;AACf,gBAAA,UAAU,EAAE,SAAS;AACrB,gBAAA,WAAW,EAAE,gCAAgC;AAC9C,aAAA;SACF;IACH;AAEA,IAAA,QAAQ,CAAC,GAAoB,EAAA;QAC3B,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,EAAE,GAAG,CAAC;IACtC;AAEA,IAAA,QAAQ,CAAC,IAAY,EAAA;QACnB,OAAO,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,IAAI,CAAC;IACpC;IAEA,UAAU,GAAA;QACR,OAAO,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,MAAM,EAAE,CAAC;IAC/C;IAEA,gBAAgB,GAAA;AACd,QAAA,OAAO,IAAI,CAAC,UAAU,EAAE,CAAC,GAAG,CAAC,CAAC,EAAE,EAAE,EAAE,IAAI,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,EAAE,EAAE,EAAE,IAAI,EAAE,UAAU,EAAE,WAAW,EAAE,CAAC,CAAC;IAClH;AACD;;;;"}

package/dist/src/stage-executor.d.ts

@@ -1,20 +0,0 @@
-import { Logger } from './utils/logger.js';
-import { AgentRegistry } from './agent-registry.js';
-import type { AgentEvent, Task, McpServerConfig } from './types.js';
-import type { WorkflowStage, WorkflowStageExecutionResult, WorkflowExecutionOptions } from './workflow-types.js';
-import { PromptBuilder } from './prompt-builder.js';
-export declare class StageExecutor {
-    private registry;
-    private logger;
-    private adapter;
-    private promptBuilder;
-    private eventHandler?;
-    private mcpServers?;
-    constructor(registry: AgentRegistry, logger: Logger, promptBuilder?: PromptBuilder, eventHandler?: (event: AgentEvent) => void, mcpServers?: Record<string, McpServerConfig>);
-    setEventHandler(handler?: (event: AgentEvent) => void): void;
-    execute(task: Task, stage: WorkflowStage, options: WorkflowExecutionOptions): Promise<WorkflowStageExecutionResult>;
-    private runResearch;
-    private runPlanning;
-    private runExecution;
-}
-//# sourceMappingURL=stage-executor.d.ts.map

package/dist/src/stage-executor.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"stage-executor.d.ts","sourceRoot":"","sources":["../../src/stage-executor.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAE3C,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,KAAK,EAAE,UAAU,EAAE,IAAI,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AACpE,OAAO,KAAK,EAAE,aAAa,EAAE,4BAA4B,EAAE,wBAAwB,EAAE,MAAM,qBAAqB,CAAC;AAIjH,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAEpD,qBAAa,aAAa;IACxB,OAAO,CAAC,QAAQ,CAAgB;IAChC,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,OAAO,CAAgB;IAC/B,OAAO,CAAC,aAAa,CAAgB;IACrC,OAAO,CAAC,YAAY,CAAC,CAA8B;IACnD,OAAO,CAAC,UAAU,CAAC,CAAkC;gBAGnD,QAAQ,EAAE,aAAa,EACvB,MAAM,EAAE,MAAM,EACd,aAAa,CAAC,EAAE,aAAa,EAC7B,YAAY,CAAC,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,IAAI,EAC1C,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC;IAc9C,eAAe,CAAC,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,IAAI,GAAG,IAAI;IAItD,OAAO,CAAC,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,aAAa,EAAE,OAAO,EAAE,wBAAwB,GAAG,OAAO,CAAC,4BAA4B,CAAC;YAiC3G,WAAW;YA+CX,WAAW;YA+CX,YAAY;CAwC3B"}

package/dist/src/stage-executor.js

@@ -1,178 +0,0 @@
-import { query } from '@anthropic-ai/claude-agent-sdk';
-import './utils/logger.js';
-import { ClaudeAdapter } from './adapters/claude/claude-adapter.js';
-import { RESEARCH_SYSTEM_PROMPT } from './agents/research.js';
-import { PLANNING_SYSTEM_PROMPT } from './agents/planning.js';
-import { EXECUTION_SYSTEM_PROMPT } from './agents/execution.js';
-import { PromptBuilder } from './prompt-builder.js';
-
-class StageExecutor {
-    registry;
-    logger;
-    adapter;
-    promptBuilder;
-    eventHandler;
-    mcpServers;
-    constructor(registry, logger, promptBuilder, eventHandler, mcpServers) {
-        this.registry = registry;
-        this.logger = logger.child('StageExecutor');
-        this.adapter = new ClaudeAdapter();
-        this.promptBuilder = promptBuilder || new PromptBuilder({
-            getTaskFiles: async () => [],
-            generatePlanTemplate: async () => '',
-            logger,
-        });
-        this.eventHandler = eventHandler;
-        this.mcpServers = mcpServers;
-    }
-    setEventHandler(handler) {
-        this.eventHandler = handler;
-    }
-    async execute(task, stage, options) {
-        const isManual = stage.is_manual_only === true;
-        if (isManual) {
-            this.logger.info('Manual stage detected; skipping agent execution', { stage: stage.key });
-            return { results: [] };
-        }
-        const inferredAgent = stage.key.toLowerCase().includes('plan') ? 'planning_basic' : 'code_generation';
-        const agentName = stage.agent_name || inferredAgent;
-        const agent = this.registry.getAgent(agentName);
-        if (!agent) {
-            throw new Error(`Unknown agent '${agentName}' for stage '${stage.key}'`);
-        }
-        const permissionMode = options.permissionMode || 'acceptEdits';
-        const cwd = options.repositoryPath || process.cwd();
-        switch (agent.agent_type) {
-            case 'research':
-                return this.runResearch(task, cwd, options, stage.key);
-            case 'planning':
-                return this.runPlanning(task, cwd, options, stage.key);
-            case 'execution':
-                return this.runExecution(task, cwd, permissionMode, options, stage.key);
-            case 'review': // TODO: Implement review
-            case 'testing': // TODO: Implement testing
-            default:
-                // throw new Error(`Unsupported agent type: ${agent.agent_type}`);
-                console.warn(`Unsupported agent type: ${agent.agent_type}`);
-                return { results: [] };
-        }
-    }
-    async runResearch(task, cwd, options, stageKey) {
-        const contextPrompt = await this.promptBuilder.buildResearchPrompt(task, cwd);
-        let prompt = RESEARCH_SYSTEM_PROMPT + '\n\n' + contextPrompt;
-        const stageOverrides = options.stageOverrides?.[stageKey] || options.stageOverrides?.['research'];
-        const mergedOverrides = {
-            ...(options.queryOverrides || {}),
-            ...(stageOverrides?.queryOverrides || {}),
-        };
-        const baseOptions = {
-            model: 'claude-sonnet-4-5-20250929',
-            cwd,
-            permissionMode: 'plan',
-            settingSources: ['local'],
-            mcpServers: this.mcpServers
-        };
-        const response = query({
-            prompt,
-            options: { ...baseOptions, ...mergedOverrides },
-        });
-        let research = '';
-        for await (const message of response) {
-            // Emit raw SDK event first
-            this.eventHandler?.(this.adapter.createRawSDKEvent(message));
-            // Then emit transformed event
-            const transformed = this.adapter.transform(message);
-            if (transformed) {
-                if (transformed.type !== 'token') {
-                    this.logger.debug('Research event', { type: transformed.type });
-                }
-                this.eventHandler?.(transformed);
-            }
-            if (message.type === 'assistant' && message.message?.content) {
-                for (const c of message.message.content) {
-                    if (c.type === 'text' && c.text)
-                        research += c.text + '\n';
-                }
-            }
-        }
-        return { plan: research.trim() }; // Return as 'plan' field to match existing interface
-    }
-    async runPlanning(task, cwd, options, stageKey) {
-        const contextPrompt = await this.promptBuilder.buildPlanningPrompt(task, cwd);
-        let prompt = PLANNING_SYSTEM_PROMPT + '\n\n' + contextPrompt;
-        const stageOverrides = options.stageOverrides?.[stageKey] || options.stageOverrides?.['plan'];
-        const mergedOverrides = {
-            ...(options.queryOverrides || {}),
-            ...(stageOverrides?.queryOverrides || {}),
-        };
-        const baseOptions = {
-            model: 'claude-sonnet-4-5-20250929',
-            cwd,
-            permissionMode: 'plan',
-            settingSources: ['local'],
-            mcpServers: this.mcpServers
-        };
-        const response = query({
-            prompt,
-            options: { ...baseOptions, ...mergedOverrides },
-        });
-        let plan = '';
-        for await (const message of response) {
-            // Emit raw SDK event first
-            this.eventHandler?.(this.adapter.createRawSDKEvent(message));
-            // Then emit transformed event
-            const transformed = this.adapter.transform(message);
-            if (transformed) {
-                if (transformed.type !== 'token') {
-                    this.logger.debug('Planning event', { type: transformed.type });
-                }
-                this.eventHandler?.(transformed);
-            }
-            if (message.type === 'assistant' && message.message?.content) {
-                for (const c of message.message.content) {
-                    if (c.type === 'text' && c.text)
-                        plan += c.text + '\n';
-                }
-            }
-        }
-        return { plan: plan.trim() };
-    }
-    async runExecution(task, cwd, permissionMode, options, stageKey) {
-        const contextPrompt = await this.promptBuilder.buildExecutionPrompt(task, cwd);
-        let prompt = EXECUTION_SYSTEM_PROMPT + '\n\n' + contextPrompt;
-        const stageOverrides = options.stageOverrides?.[stageKey];
-        const mergedOverrides = {
-            ...(options.queryOverrides || {}),
-            ...(stageOverrides?.queryOverrides || {}),
-        };
-        const baseOptions = {
-            model: 'claude-sonnet-4-5-20250929',
-            cwd,
-            permissionMode,
-            settingSources: ['local'],
-            mcpServers: this.mcpServers
-        };
-        const response = query({
-            prompt,
-            options: { ...baseOptions, ...mergedOverrides },
-        });
-        const results = [];
-        for await (const message of response) {
-            // Emit raw SDK event first
-            this.eventHandler?.(this.adapter.createRawSDKEvent(message));
-            // Then emit transformed event
-            const transformed = this.adapter.transform(message);
-            if (transformed) {
-                if (transformed.type !== 'token') {
-                    this.logger.debug('Execution event', { type: transformed.type });
-                }
-                this.eventHandler?.(transformed);
-            }
-            results.push(message);
-        }
-        return { results };
-    }
-}
-
-export { StageExecutor };
-//# sourceMappingURL=stage-executor.js.map