edsger 0.36.2 → 0.37.0

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/growth-analysis/context.d.ts

@@ -11,11 +11,11 @@ export declare function fetchGrowthAnalysisContext(productId: string, verbose?:
 /**
  * Format context into a prompt string for the AI
  */
-export declare function formatContextForPrompt(context: GrowthAnalysisContext): string;
+export declare function formatContextForPrompt(context: GrowthAnalysisContext, guidance?: string): string;
 /**
  * Prepare the full analysis prompt with all context
  */
-export declare function prepareGrowthAnalysisContext(productId: string, verbose?: boolean, hasCodebase?: boolean): Promise<{
+export declare function prepareGrowthAnalysisContext(productId: string, verbose?: boolean, hasCodebase?: boolean, guidance?: string): Promise<{
     context: GrowthAnalysisContext;
     analysisPrompt: string;
 }>;

package/dist/phases/growth-analysis/context.js

@@ -30,7 +30,7 @@ export async function fetchGrowthAnalysisContext(productId, verbose) {
 /**
  * Format context into a prompt string for the AI
  */
-export function formatContextForPrompt(context) {
+export function formatContextForPrompt(context, guidance) {
     const { product, previousCampaigns } = context;
     const campaignsList = previousCampaigns.length > 0
         ? previousCampaigns
@@ -45,6 +45,16 @@ export function formatContextForPrompt(context) {
             .map((f) => `- **${f.name}**: ${f.description || 'No description'} (Status: ${f.status || 'unknown'})`)
             .join('\n')
         : 'No features listed.';
+    const guidanceSection = guidance
+        ? `
+
+## Human Growth Guidance
+The product owner has provided the following direction for this growth analysis. **You MUST follow this guidance closely** — it takes priority over your own judgement for content direction, themes, audience, and channel selection.
+
+${guidance}
+
+---`
+        : '';
     return `# Growth Analysis Context
 
 ## Product Information
@@ -54,23 +64,27 @@ export function formatContextForPrompt(context) {
 
 ## Product Features (${product.features?.length || 0})
 ${featuresList}
+${guidanceSection}
 
 ## Previous Growth Campaigns (${previousCampaigns.length})
 ${campaignsList}
 
 ---
 
-**Important**: Analyze the product above and create a growth strategy. Each content suggestion must be DIFFERENT from all previous campaigns listed above. Use the product name, description, and features to write specific, concrete content — never use placeholder text.`;
+**Important**: Analyze the product above and create a growth strategy.${guidance ? ' Follow the human growth guidance provided above for direction, themes, and tone.' : ''} Each content suggestion must be DIFFERENT from all previous campaigns listed above. Use the product name, description, and features to write specific, concrete content — never use placeholder text.`;
 }
 /**
  * Prepare the full analysis prompt with all context
  */
-export async function prepareGrowthAnalysisContext(productId, verbose, hasCodebase = false) {
+export async function prepareGrowthAnalysisContext(productId, verbose, hasCodebase = false, guidance) {
     if (verbose) {
         logInfo('Fetching growth analysis context via MCP endpoints...');
+        if (guidance) {
+            logInfo(`Human guidance provided: "${guidance.substring(0, 80)}${guidance.length > 80 ? '...' : ''}"`);
+        }
     }
     const context = await fetchGrowthAnalysisContext(productId, verbose);
-    const contextInfo = formatContextForPrompt(context);
+    const contextInfo = formatContextForPrompt(context, guidance);
     const analysisPrompt = createGrowthAnalysisPromptWithContext(productId, contextInfo, hasCodebase);
     return { context, analysisPrompt };
 }

package/dist/phases/growth-analysis/index.d.ts

@@ -3,6 +3,8 @@ import { type EdsgerConfig } from '../../types/index.js';
 export interface GrowthAnalysisOptions {
     productId: string;
     verbose?: boolean;
+    guidance?: string;
+    analysisId?: string;
 }
 export interface GrowthAnalysisResult {
     productId: string;

package/dist/phases/growth-analysis/index.js

@@ -1,5 +1,5 @@
 import { getGitHubConfigByProduct } from '../../api/github.js';
-import { saveGrowthAnalysis } from '../../api/growth.js';
+import { saveGrowthAnalysis, updateGrowthAnalysis } from '../../api/growth.js';
 import { generateGrowthVideo, } from '../../services/video/index.js';
 import { logError, logInfo, logSuccess, logWarning, } from '../../utils/logger.js';
 import { cloneFeatureRepo, ensureWorkspaceDir, } from '../../workspace/workspace-manager.js';
@@ -52,7 +52,7 @@ contentSuggestions) {
 export const analyseGrowth = async (options, config
 // eslint-disable-next-line complexity -- orchestration function with context assembly, agent execution, and result processing
 ) => {
-    const { productId, verbose } = options;
+    const { productId, verbose, guidance, analysisId } = options;
     if (verbose) {
         logInfo(`Starting growth analysis for product ID: ${productId}`);
     }
@@ -78,7 +78,7 @@ export const analyseGrowth = async (options, config
             logInfo(`Could not clone repo (continuing without codebase): ${error instanceof Error ? error.message : String(error)}`);
         }
         const hasCodebase = !!repoCwd;
-        const { context: _context, analysisPrompt } = await prepareGrowthAnalysisContext(productId, verbose, hasCodebase);
+        const { context: _context, analysisPrompt } = await prepareGrowthAnalysisContext(productId, verbose, hasCodebase, guidance);
         const systemPrompt = createGrowthAnalysisSystemPrompt(hasCodebase);
         if (verbose) {
             logInfo('Starting AI query for growth analysis...');
@@ -95,21 +95,29 @@ export const analyseGrowth = async (options, config
         const targetChannels = (analysisResult.target_channels || []);
         const contentSuggestions = (analysisResult.content_suggestions || []);
         const searchContext = analysisResult.search_context || null;
-        const savedAnalysis = await saveGrowthAnalysis({
-            product_id: productId,
-            analysis_content: analysisContent,
-            target_channels: targetChannels,
-            content_suggestions: contentSuggestions,
-            search_context: searchContext,
-            status: 'completed',
-        }, verbose);
+        const savedAnalysis = analysisId
+            ? await updateGrowthAnalysis(analysisId, {
+                analysis_content: analysisContent,
+                target_channels: targetChannels,
+                content_suggestions: contentSuggestions,
+                search_context: searchContext,
+                status: 'completed',
+            }, verbose)
+            : await saveGrowthAnalysis({
+                product_id: productId,
+                analysis_content: analysisContent,
+                target_channels: targetChannels,
+                content_suggestions: contentSuggestions,
+                search_context: searchContext,
+                growth_guidance: guidance ?? null,
+                status: 'completed',
+            }, verbose);
         logInfo(`Growth analysis completed: ${targetChannels.length} channels, ${contentSuggestions.length} suggestions`);
         // Process video generation for applicable content suggestions
         const videoPlans = extractVideoPlans(contentSuggestions);
         const videoResults = new Map();
         if (videoPlans.length > 0) {
             logInfo(`\nFound ${videoPlans.length} content suggestion(s) with video plans`);
-            const analysisId = savedAnalysis?.id || productId;
             // Log all planned videos
             for (const { index, plan } of videoPlans) {
                 const suggestion = contentSuggestions[index];
@@ -122,7 +130,7 @@ export const analyseGrowth = async (options, config
             logInfo(`\nGenerating ${videoPlans.length} video(s) (max ${MAX_CONCURRENT_VIDEOS} concurrent)...`);
             const settled = await runWithConcurrencyLimit(videoPlans.map(({ index, plan }) => () => generateGrowthVideo(plan, {
                 productId,
-                analysisId,
+                analysisId: analysisId ?? '',
                 verbose,
             }).then((result) => ({ index, result }))), MAX_CONCURRENT_VIDEOS);
             for (const outcome of settled) {

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>;