edsger 0.28.4 → 0.29.1

package/dist/phases/feature-analysis-verification/verifier.js

@@ -0,0 +1,147 @@
+/**
+ * Checklist verification agent for feature analysis
+ * This agent independently reviews checklist compliance to ensure objectivity
+ */
+import { query } from '@anthropic-ai/claude-code';
+import { logInfo, logError } from '../../utils/logger.js';
+import { createChecklistVerificationPrompt, createChecklistVerificationSystemPrompt, } from './prompts.js';
+function userMessage(content) {
+    return {
+        type: 'user',
+        message: { role: 'user', content: content },
+    };
+}
+async function* prompt(verificationPrompt) {
+    yield userMessage(verificationPrompt);
+}
+/**
+ * Verify checklist compliance using an independent AI agent
+ * This agent acts as a "challenger" to validate the claims made by the analysis agent
+ */
+export async function verifyChecklistCompliance(options, config) {
+    const { checklistContext, analysisContext, createdUserStories, createdTestCases, verbose, } = options;
+    const totalChecklistItems = checklistContext.checklists.reduce((sum, checklist) => sum + checklist.items.length, 0);
+    if (verbose) {
+        logInfo('🔍 Starting checklist verification...');
+        logInfo(`   Verifying ${totalChecklistItems} checklist items`);
+    }
+    try {
+        const systemPrompt = createChecklistVerificationSystemPrompt(config);
+        const verificationPrompt = createChecklistVerificationPrompt({
+            checklistContext,
+            analysisContext,
+            createdUserStories,
+            createdTestCases,
+        });
+        let lastAssistantResponse = '';
+        let verificationResult = null;
+        if (verbose) {
+            logInfo('🤖 Starting verification agent query...');
+        }
+        // Use Claude Code SDK for verification
+        for await (const message of query({
+            prompt: prompt(verificationPrompt),
+            options: {
+                appendSystemPrompt: systemPrompt,
+                model: config.claude.model || 'sonnet',
+                maxTurns: 100,
+                permissionMode: 'bypassPermissions',
+            },
+        })) {
+            if (verbose) {
+                logInfo(`   Received message type: ${message.type}`);
+            }
+            // Capture assistant responses
+            if (message.type === 'assistant' && message.message?.content) {
+                for (const content of message.message.content) {
+                    if (content.type === 'text') {
+                        lastAssistantResponse += content.text + '\n';
+                        if (verbose) {
+                            console.log(`\n🔍 ${content.text}`);
+                        }
+                    }
+                }
+            }
+            if (message.type === 'result') {
+                if (message.subtype === 'success') {
+                    logInfo('\n✅ Verification completed, parsing results...');
+                    try {
+                        const responseText = message.result || lastAssistantResponse;
+                        // Try to extract JSON from markdown code block
+                        const jsonBlockMatch = responseText.match(/```json\s*\n([\s\S]*?)\n\s*```/);
+                        let jsonResult = null;
+                        if (jsonBlockMatch) {
+                            jsonResult = JSON.parse(jsonBlockMatch[1]);
+                        }
+                        else {
+                            jsonResult = JSON.parse(responseText);
+                        }
+                        if (jsonResult && jsonResult.verification) {
+                            verificationResult = jsonResult.verification;
+                        }
+                        else {
+                            throw new Error('Invalid verification JSON structure');
+                        }
+                    }
+                    catch (error) {
+                        logError(`Failed to parse verification result: ${error}`);
+                        // Return default "uncertain" result
+                        verificationResult = createUncertainVerificationResult(checklistContext, 'Failed to parse verification response');
+                    }
+                }
+                else {
+                    logError(`\n⚠️ Verification incomplete: ${message.subtype}`);
+                    verificationResult = createUncertainVerificationResult(checklistContext, `Verification incomplete: ${message.subtype}`);
+                }
+            }
+        }
+        if (!verificationResult) {
+            verificationResult = createUncertainVerificationResult(checklistContext, 'No verification result received');
+        }
+        if (verbose) {
+            logInfo('\n📊 Verification Summary:');
+            logInfo(`   Total items: ${verificationResult.total_items}`);
+            logInfo(`   ✅ Confirmed: ${verificationResult.confirmed_count}`);
+            logInfo(`   ❌ Rejected: ${verificationResult.rejected_count}`);
+            logInfo(`   ⚠️  Uncertain: ${verificationResult.uncertain_count}`);
+            logInfo(`   Summary: ${verificationResult.summary}`);
+            if (verificationResult.rejected_count > 0) {
+                logInfo('\n❌ Rejected items:');
+                verificationResult.item_verifications
+                    .filter((v) => v.verification_status === 'rejected')
+                    .forEach((v) => {
+                    logInfo(`   - ${v.checklist_item_id}`);
+                    logInfo(`     Reason: ${v.verification_reason}`);
+                });
+            }
+        }
+        return verificationResult;
+    }
+    catch (error) {
+        logError(`Checklist verification failed: ${error instanceof Error ? error.message : String(error)}`);
+        return createUncertainVerificationResult(checklistContext, `Verification error: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+/**
+ * Create a default "uncertain" verification result when verification fails
+ */
+function createUncertainVerificationResult(checklistContext, reason) {
+    // Get all checklist items
+    const allItems = checklistContext.checklists.flatMap((checklist) => checklist.items.map((item) => ({
+        checklist_item_id: item.id,
+    })));
+    return {
+        all_verified: false,
+        total_items: allItems.length,
+        confirmed_count: 0,
+        rejected_count: 0,
+        uncertain_count: allItems.length,
+        item_verifications: allItems.map((item) => ({
+            checklist_item_id: item.checklist_item_id,
+            is_satisfied: false,
+            verification_status: 'uncertain',
+            verification_reason: reason,
+        })),
+        summary: `Verification could not be completed: ${reason}`,
+    };
+}

package/dist/phases/task/agent.d.ts

@@ -0,0 +1,10 @@
+import { EdsgerConfig } from '../../types/index.js';
+export interface TaskResult {
+    success: boolean;
+    summary: string;
+}
+/**
+ * Execute a task using Claude Agent SDK.
+ * The agent has access to the codebase and can read/write files.
+ */
+export declare function executeTask(taskPrompt: string, systemPrompt: string, config: EdsgerConfig, verbose?: boolean): Promise<TaskResult>;

package/dist/phases/task/agent.js

@@ -0,0 +1,81 @@
+import { query } from '@anthropic-ai/claude-agent-sdk';
+import { DEFAULT_MODEL } from '../../constants.js';
+import { logInfo, logError } from '../../utils/logger.js';
+function userMessage(content) {
+    return {
+        type: 'user',
+        message: { role: 'user', content: content },
+    };
+}
+async function* prompt(taskPrompt) {
+    yield userMessage(taskPrompt);
+}
+/**
+ * Execute a task using Claude Agent SDK.
+ * The agent has access to the codebase and can read/write files.
+ */
+export async function executeTask(taskPrompt, systemPrompt, config, verbose) {
+    let lastAssistantResponse = '';
+    try {
+        for await (const message of query({
+            prompt: prompt(taskPrompt),
+            options: {
+                systemPrompt: {
+                    type: 'preset',
+                    preset: 'claude_code',
+                    append: systemPrompt,
+                },
+                model: DEFAULT_MODEL,
+                maxTurns: 1000,
+                permissionMode: 'bypassPermissions',
+            },
+        })) {
+            if (verbose) {
+                logInfo(`Received message type: ${message.type}`);
+            }
+            if (message.type === 'assistant' && message.message?.content) {
+                for (const content of message.message.content) {
+                    if (content.type === 'text') {
+                        lastAssistantResponse += content.text + '\n';
+                        if (verbose) {
+                            console.log(`\n${content.text}`);
+                        }
+                    }
+                    else if (content.type === 'tool_use') {
+                        if (verbose) {
+                            console.log(`\n${content.name}: ${content.input.description || 'Running...'}`);
+                        }
+                    }
+                }
+            }
+            if (message.type === 'result') {
+                if (message.subtype === 'success') {
+                    logInfo('Task completed successfully');
+                    return {
+                        success: true,
+                        summary: message.result || lastAssistantResponse || 'Task completed',
+                    };
+                }
+                else {
+                    logError(`Task incomplete: ${message.subtype}`);
+                    return {
+                        success: false,
+                        summary: lastAssistantResponse || `Task ended with status: ${message.subtype}`,
+                    };
+                }
+            }
+        }
+        return {
+            success: !!lastAssistantResponse,
+            summary: lastAssistantResponse || 'No response received',
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        logError(`Task execution failed: ${errorMessage}`);
+        return {
+            success: false,
+            summary: `Execution failed: ${errorMessage}`,
+        };
+    }
+}

package/dist/phases/task/context.d.ts

@@ -0,0 +1,16 @@
+import { type ProductInfo } from '../../api/products.js';
+import { type TaskInfo } from '../../api/tasks.js';
+export interface TaskContext {
+    product: ProductInfo;
+    task: TaskInfo;
+}
+/**
+ * Fetch context for a product task:
+ * - Product info (name, description)
+ * - The task itself
+ */
+export declare function fetchTaskContext(task: TaskInfo, verbose?: boolean): Promise<TaskContext>;
+/**
+ * Format task context into a prompt string
+ */
+export declare function formatTaskContext(context: TaskContext): string;

package/dist/phases/task/context.js

@@ -0,0 +1,50 @@
+import { logInfo, logError } from '../../utils/logger.js';
+import { getProduct } from '../../api/products.js';
+/**
+ * Fetch context for a product task:
+ * - Product info (name, description)
+ * - The task itself
+ */
+export async function fetchTaskContext(task, verbose) {
+    try {
+        if (verbose) {
+            logInfo(`Fetching context for task: ${task.name}`);
+            logInfo(`  Product ID: ${task.product_id}`);
+        }
+        const product = await getProduct(task.product_id, verbose);
+        if (verbose) {
+            logInfo(`Task context fetched:`);
+            logInfo(`  Product: ${product.name}`);
+        }
+        return { product, task };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        logError(`Failed to fetch task context: ${errorMessage}`);
+        throw new Error(`Context fetch failed: ${errorMessage}`);
+    }
+}
+/**
+ * Format task context into a prompt string
+ */
+export function formatTaskContext(context) {
+    const { product, task } = context;
+    return `# Task Context
+
+## Product
+- **Name**: ${product.name}
+- **Product ID**: ${product.id}
+- **Description**: ${product.description || 'No description'}
+
+---
+
+## Current Task
+- **Task Name**: ${task.name}
+- **Task ID**: ${task.id}
+- **Priority**: ${task.priority} (1=low, 2=medium, 3=high, 4=urgent)
+- **Description**: ${task.description || 'No description provided'}
+
+---
+
+**Your objective**: Complete the task described above within the context of this product.`;
+}

package/dist/phases/task/index.d.ts

@@ -0,0 +1,17 @@
+import { EdsgerConfig } from '../../types/index.js';
+import { type TaskInfo } from '../../api/tasks.js';
+import { type TaskResult } from './agent.js';
+export type { TaskResult };
+export interface TaskOptions {
+    task: TaskInfo;
+    verbose?: boolean;
+}
+/**
+ * Execute a product task:
+ * 1. Mark task as in_progress
+ * 2. Fetch product context
+ * 3. Build prompt with context + task description
+ * 4. Run Claude agent to complete the task
+ * 5. Mark task as completed or blocked
+ */
+export declare function runTask(options: TaskOptions, config: EdsgerConfig): Promise<TaskResult>;

package/dist/phases/task/index.js

@@ -0,0 +1,54 @@
+import { logInfo, logError } from '../../utils/logger.js';
+import { updateTaskStatus } from '../../api/tasks.js';
+import { fetchTaskContext, formatTaskContext } from './context.js';
+import { createTaskSystemPrompt, createTaskPrompt } from './prompts.js';
+import { executeTask } from './agent.js';
+/**
+ * Execute a product task:
+ * 1. Mark task as in_progress
+ * 2. Fetch product context
+ * 3. Build prompt with context + task description
+ * 4. Run Claude agent to complete the task
+ * 5. Mark task as completed or blocked
+ */
+export async function runTask(options, config) {
+    const { task, verbose } = options;
+    logInfo(`Starting task: ${task.name} (${task.id})`);
+    // Mark as in_progress
+    await updateTaskStatus(task.id, 'in_progress', verbose);
+    try {
+        // 1. Fetch context
+        if (verbose) {
+            logInfo('Fetching task context...');
+        }
+        const context = await fetchTaskContext(task, verbose);
+        // 2. Build prompts
+        const contextInfo = formatTaskContext(context);
+        const systemPrompt = createTaskSystemPrompt();
+        const taskPrompt = createTaskPrompt(contextInfo);
+        if (verbose) {
+            logInfo('Starting AI agent for task...');
+        }
+        // 3. Execute
+        const result = await executeTask(taskPrompt, systemPrompt, config, verbose);
+        // 4. Update status
+        if (result.success) {
+            await updateTaskStatus(task.id, 'completed', verbose);
+            logInfo(`Task completed: ${task.name}`);
+        }
+        else {
+            await updateTaskStatus(task.id, 'blocked', verbose);
+            logError(`Task blocked: ${task.name} - ${result.summary}`);
+        }
+        return result;
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        logError(`Task failed: ${task.name} - ${errorMessage}`);
+        await updateTaskStatus(task.id, 'blocked', verbose);
+        return {
+            success: false,
+            summary: `Failed: ${errorMessage}`,
+        };
+    }
+}

package/dist/phases/task/prompts.d.ts

@@ -0,0 +1,9 @@
+/**
+ * System prompt for product task execution.
+ * The agent works on a specific task within a product's codebase.
+ */
+export declare function createTaskSystemPrompt(): string;
+/**
+ * Create the user prompt combining context and task instructions
+ */
+export declare function createTaskPrompt(contextInfo: string): string;

package/dist/phases/task/prompts.js

@@ -0,0 +1,28 @@
+/**
+ * System prompt for product task execution.
+ * The agent works on a specific task within a product's codebase.
+ */
+export function createTaskSystemPrompt() {
+    return `You are an AI software engineer working on a specific task for a product.
+
+## Your Role
+You are given a product context and a specific task to complete.
+
+## Guidelines
+1. Focus ONLY on the current task
+2. Write clean, well-tested code
+3. Use the available tools to read, understand, and modify the codebase
+4. If the task is about implementation, write the actual code
+5. If the task is about analysis or planning, provide detailed output
+
+## Output
+When done, provide a brief summary of what you accomplished for this task.`;
+}
+/**
+ * Create the user prompt combining context and task instructions
+ */
+export function createTaskPrompt(contextInfo) {
+    return `${contextInfo}
+
+Please complete the task described above. Use the codebase tools available to you to implement the changes needed.`;
+}

package/dist/phases/technical-design/analyzer-helpers.d.ts

@@ -0,0 +1,25 @@
+import { type ChecklistVerificationResult } from '../technical-design-verification/agent.js';
+export interface TechnicalDesignResult {
+    featureId: string;
+    technicalDesign: string | null;
+    status: 'success' | 'error';
+    summary: string;
+    verificationResult?: ChecklistVerificationResult;
+    iterations?: number;
+    data?: {
+        checklist_item_results?: any[];
+        [key: string]: any;
+    };
+}
+/**
+ * Build successful design result
+ */
+export declare function buildDesignResult(featureId: string, technicalDesign: string, summary: string, iterations: number, checklistItemResults?: any[]): TechnicalDesignResult;
+/**
+ * Build verification failure result
+ */
+export declare function buildVerificationFailureResult(featureId: string, technicalDesign: string, verificationResult: ChecklistVerificationResult, iterations: number): TechnicalDesignResult;
+/**
+ * Build error result when no design was generated
+ */
+export declare function buildNoResultsError(featureId: string): TechnicalDesignResult;

package/dist/phases/technical-design/analyzer-helpers.js

@@ -0,0 +1,39 @@
+/**
+ * Build successful design result
+ */
+export function buildDesignResult(featureId, technicalDesign, summary, iterations, checklistItemResults) {
+    return {
+        featureId,
+        technicalDesign,
+        status: 'success',
+        summary,
+        iterations,
+        data: checklistItemResults
+            ? { checklist_item_results: checklistItemResults }
+            : undefined,
+    };
+}
+/**
+ * Build verification failure result
+ */
+export function buildVerificationFailureResult(featureId, technicalDesign, verificationResult, iterations) {
+    return {
+        featureId,
+        technicalDesign,
+        status: 'error',
+        summary: `Checklist verification failed after ${iterations} iterations: ${verificationResult.summary}`,
+        verificationResult,
+        iterations,
+    };
+}
+/**
+ * Build error result when no design was generated
+ */
+export function buildNoResultsError(featureId) {
+    return {
+        featureId,
+        technicalDesign: null,
+        status: 'error',
+        summary: 'Failed to generate technical design - no valid result received',
+    };
+}

package/dist/phases/technical-design/analyzer.d.ts

@@ -0,0 +1,21 @@
+import { EdsgerConfig } from '../../types/index.js';
+import { ChecklistPhaseContext } from '../../services/checklist.js';
+export interface TechnicalDesignOptions {
+    featureId: string;
+    verbose?: boolean;
+    maxVerificationIterations?: number;
+}
+export interface TechnicalDesignResult {
+    featureId: string;
+    technicalDesign: string | null;
+    status: 'success' | 'error';
+    summary: string;
+    verificationResult?: any;
+    iterations?: number;
+    savedViaHttp?: boolean;
+    data?: {
+        checklist_item_results?: any[];
+        [key: string]: any;
+    };
+}
+export declare const generateTechnicalDesign: (options: TechnicalDesignOptions, config: EdsgerConfig, checklistContext?: ChecklistPhaseContext | null) => Promise<TechnicalDesignResult>;