edsger 0.24.0 → 0.25.0

package/dist/api/growth.d.ts

@@ -0,0 +1,59 @@
+export interface GrowthCampaign {
+    id: string;
+    product_id: string;
+    analysis_id: string | null;
+    channel: string;
+    title: string;
+    content: string;
+    status: string;
+    published_url: string | null;
+    published_at: string | null;
+    created_at: string;
+    updated_at: string;
+}
+export interface GrowthAnalysis {
+    id: string;
+    product_id: string;
+    analysis_content: string;
+    target_channels: Array<{
+        name: string;
+        reason: string;
+        audience: string;
+        priority: string;
+    }>;
+    content_suggestions: Array<{
+        channel: string;
+        title: string;
+        content: string;
+        rationale: string;
+    }>;
+    search_context: string | null;
+    status: string;
+    created_at: string;
+    updated_at: string;
+}
+/**
+ * Get growth campaigns for a product via MCP
+ */
+export declare function getGrowthCampaigns(productId: string, verbose?: boolean): Promise<GrowthCampaign[]>;
+/**
+ * Save a growth analysis result via MCP
+ */
+export declare function saveGrowthAnalysis(analysis: {
+    product_id: string;
+    analysis_content: string;
+    target_channels: Array<{
+        name: string;
+        reason: string;
+        audience: string;
+        priority: string;
+    }>;
+    content_suggestions: Array<{
+        channel: string;
+        title: string;
+        content: string;
+        rationale: string;
+    }>;
+    search_context: string | null;
+    status: string;
+}, verbose?: boolean): Promise<GrowthAnalysis | null>;

package/dist/api/growth.js

@@ -0,0 +1,50 @@
+import { logInfo, logError } from '../utils/logger.js';
+import { callMcpEndpoint } from './mcp-client.js';
+/**
+ * Get growth campaigns for a product via MCP
+ */
+export async function getGrowthCampaigns(productId, verbose) {
+    if (verbose) {
+        logInfo(`Fetching growth campaigns for product: ${productId}`);
+    }
+    try {
+        const result = (await callMcpEndpoint('growth/campaigns', {
+            product_id: productId,
+        }));
+        const text = result.content?.[0]?.text || '[]';
+        try {
+            return JSON.parse(text);
+        }
+        catch {
+            return [];
+        }
+    }
+    catch (error) {
+        if (verbose) {
+            logError(`Failed to fetch growth campaigns: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        return [];
+    }
+}
+/**
+ * Save a growth analysis result via MCP
+ */
+export async function saveGrowthAnalysis(analysis, verbose) {
+    if (verbose) {
+        logInfo(`Saving growth analysis for product: ${analysis.product_id}`);
+    }
+    try {
+        const result = (await callMcpEndpoint('growth/save_analysis', analysis));
+        const text = result.content?.[0]?.text || 'null';
+        try {
+            return JSON.parse(text);
+        }
+        catch {
+            return null;
+        }
+    }
+    catch (error) {
+        logError(`Failed to save growth analysis: ${error instanceof Error ? error.message : String(error)}`);
+        return null;
+    }
+}

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

@@ -0,0 +1,7 @@
+import { CliOptions } from '../../types/index.js';
+/**
+ * Run AI-powered growth analysis for a product.
+ * Analyzes the product, reviews previous campaigns, and generates
+ * content suggestions for different channels.
+ */
+export declare const runGrowthAnalysis: (options: CliOptions) => Promise<void>;

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

@@ -0,0 +1,52 @@
+import { logInfo, logError, logSuccess } from '../../utils/logger.js';
+import { validateConfiguration } from '../../utils/validation.js';
+import { analyseGrowth, } from '../../phases/growth-analysis/index.js';
+/**
+ * Run AI-powered growth analysis for a product.
+ * Analyzes the product, reviews previous campaigns, and generates
+ * content suggestions for different channels.
+ */
+export const runGrowthAnalysis = async (options) => {
+    const productId = options.growthAnalysis;
+    if (!productId) {
+        throw new Error('Product ID is required for growth analysis');
+    }
+    const config = validateConfiguration(options);
+    logInfo(`Starting growth analysis for product: ${productId}`);
+    try {
+        const result = await analyseGrowth({
+            productId,
+            verbose: options.verbose,
+        }, config);
+        if (result.status === 'success') {
+            logSuccess('Growth analysis completed successfully!');
+            logInfo(`  Recommended channels: ${result.targetChannels.length}`);
+            logInfo(`  Content suggestions: ${result.contentSuggestions.length}`);
+            if (result.analysisId) {
+                logInfo(`  Analysis saved with ID: ${result.analysisId}`);
+            }
+            // Display summary
+            if (result.targetChannels.length > 0) {
+                logInfo('\nRecommended Channels:');
+                result.targetChannels.forEach((ch) => {
+                    logInfo(`  [${ch.priority.toUpperCase()}] ${ch.name} - ${ch.reason}`);
+                });
+            }
+            if (result.contentSuggestions.length > 0) {
+                logInfo('\nContent Suggestions:');
+                result.contentSuggestions.forEach((s, i) => {
+                    logInfo(`  ${i + 1}. [${s.channel}] ${s.title}`);
+                });
+            }
+            logInfo('\nView full results in the Growth tab of your product dashboard.');
+        }
+        else {
+            logError(`Growth analysis failed: ${result.summary}`);
+            process.exit(1);
+        }
+    }
+    catch (error) {
+        logError(`Growth analysis failed: ${error instanceof Error ? error.message : String(error)}`);
+        process.exit(1);
+    }
+};

package/dist/commands/workflow/feature-coordinator.js

@@ -13,13 +13,15 @@ import { getFeature } from '../../api/features/get-feature.js';
 import { markWorkflowPhaseCompleted } from '../../api/features/update-feature.js';
 import { logError, logInfo, logWarning } from '../../utils/logger.js';
 import { logPhaseResult } from '../../utils/pipeline-logger.js';
-import { runFeatureAnalysisPhase, runTechnicalDesignPhase, runBranchPlanningPhase, runCodeImplementationPhase, runFunctionalTestingPhase, runCodeRefinePhase, runCodeReviewPhase, runAutonomousPhase, } from './executors/phase-executor.js';
+import { runFeatureAnalysisPhase, runUserStoriesAnalysisPhase, runTestCasesAnalysisPhase, runTechnicalDesignPhase, runBranchPlanningPhase, runCodeImplementationPhase, runFunctionalTestingPhase, runCodeRefinePhase, runCodeReviewPhase, runAutonomousPhase, } from './executors/phase-executor.js';
 /**
  * Map workflow phase names (underscore format) to phase runner functions
  * Note: code_refine includes built-in verification loop (similar to technical_design)
  */
 const PHASE_RUNNERS = {
     feature_analysis: runFeatureAnalysisPhase,
+    user_stories_analysis: runUserStoriesAnalysisPhase,
+    test_cases_analysis: runTestCasesAnalysisPhase,
     technical_design: runTechnicalDesignPhase,
     branch_planning: runBranchPlanningPhase,
     code_implementation: runCodeImplementationPhase,

package/dist/index.js

@@ -9,6 +9,7 @@ import { runWorkflow } from './commands/workflow/index.js';
 import { runCodeReview } from './commands/code-review/index.js';
 import { runRefactor } from './commands/refactor/refactor.js';
 import { runInit } from './commands/init/index.js';
+import { runGrowthAnalysis } from './commands/growth-analysis/index.js';
 // Get package.json version dynamically
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -28,6 +29,7 @@ program
     .option('-f, --files <patterns...>', 'Review specific file patterns')
     .option('--refactor', 'Refactor code in current directory')
     .option('--init', 'Initialize .edsger directory with project templates')
+    .option('--growth-analysis <productId>', 'Run AI-powered growth analysis for a product')
     .option('-c, --config <path>', 'Path to config file')
     .option('-v, --verbose', 'Verbose output');
 program.action(async (options) => {
@@ -45,6 +47,11 @@ export const runEdsger = async (options) => {
         await runInit(options);
         return;
     }
+    // Handle growth analysis mode
+    if (options.growthAnalysis) {
+        await runGrowthAnalysis(options);
+        return;
+    }
     // Handle refactor mode
     if (options.refactor) {
         await runRefactor(options);

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

@@ -3,7 +3,7 @@ import { prepareAnalysisContext } from './context.js';
 import { createFeatureAnalysisSystemPrompt } from './prompts.js';
 import { executeAnalysisQuery } from './agent.js';
 import { performVerificationCycle } from '../feature-analysis-verification/index.js';
-import { deleteArtifacts, deleteSpecificArtifacts, updateArtifactsToReady, saveAnalysisArtifactsAsDraft, buildAnalysisResult, } from './outcome.js';
+import { deleteArtifacts, deleteSpecificArtifacts, updateArtifactsToReady, saveAnalysisArtifactsAsDraft, buildAnalysisResult, resetReadyArtifactsToDraft, getAllDraftArtifactIds, } from './outcome.js';
 import { logFeaturePhaseEvent } from '../../services/audit-logs.js';
 export const analyseFeature = async (options, config, checklistContext) => {
     const { featureId, verbose } = options;
@@ -11,6 +11,11 @@ export const analyseFeature = async (options, config, checklistContext) => {
         logInfo(`Starting feature analysis for feature ID: ${featureId}`);
     }
     try {
+        // Reset ready artifacts to draft so AI can manage them on re-run
+        const resetResult = await resetReadyArtifactsToDraft(featureId, verbose);
+        if (verbose && (resetResult.resetUserStories > 0 || resetResult.resetTestCases > 0)) {
+            logInfo(`✅ Reset ${resetResult.resetUserStories} user stories and ${resetResult.resetTestCases} test cases to draft for re-analysis`);
+        }
         const context = await prepareAnalysisContext(featureId, checklistContext, verbose);
         const systemPrompt = createFeatureAnalysisSystemPrompt();
         const initialAnalysisPrompt = context.analysisPrompt;
@@ -81,12 +86,13 @@ export const analyseFeature = async (options, config, checklistContext) => {
             // Perform verification cycle
             const verificationCycle = await performVerificationCycle(structuredAnalysisResult, checklistContext || null, context.featureContext, config, currentIteration, maxIterations, featureId, verbose);
             verificationResult = verificationCycle.verificationResult;
-            // If verification passed, update artifacts to ready and exit
+            // If verification passed, update ALL remaining draft artifacts to ready and exit
             if (verificationCycle.passed) {
                 if (verbose) {
-                    logInfo('✅ Verification passed! Updating artifacts to ready status...');
+                    logInfo('✅ Verification passed! Updating all draft artifacts to ready status...');
                 }
-                await updateArtifactsToReady(currentDraftUserStoryIds, currentDraftTestCaseIds, verbose);
+                const allDrafts = await getAllDraftArtifactIds(featureId, verbose);
+                await updateArtifactsToReady(allDrafts.userStoryIds, allDrafts.testCaseIds, verbose);
                 break;
             }
             // Verification failed
@@ -112,16 +118,17 @@ export const analyseFeature = async (options, config, checklistContext) => {
         if (!structuredAnalysisResult) {
             throw new Error('No analysis results received');
         }
-        // If no checklist was used, update draft artifacts to ready now
+        // If no checklist was used, update all draft artifacts to ready now
         if (!checklistContext ||
             checklistContext.checklists.length === 0 ||
             !verificationResult) {
-            if (currentDraftUserStoryIds.length > 0 ||
-                currentDraftTestCaseIds.length > 0) {
+            const allDrafts = await getAllDraftArtifactIds(featureId, verbose);
+            if (allDrafts.userStoryIds.length > 0 ||
+                allDrafts.testCaseIds.length > 0) {
                 if (verbose) {
-                    logInfo('✅ No checklist verification needed. Updating artifacts to ready status...');
+                    logInfo('✅ No checklist verification needed. Updating all draft artifacts to ready status...');
                 }
-                await updateArtifactsToReady(currentDraftUserStoryIds, currentDraftTestCaseIds, verbose);
+                await updateArtifactsToReady(allDrafts.userStoryIds, allDrafts.testCaseIds, verbose);
             }
         }
         // Check if verification failed after all iterations

package/dist/phases/feature-analysis/outcome.d.ts

@@ -1,5 +1,19 @@
 import { FeatureAnalysisResult } from '../../types/index.js';
 import { FeatureAnalysisContext } from './context.js';
+/**
+ * Reset ready user stories and test cases to draft for re-analysis
+ */
+export declare function resetReadyArtifactsToDraft(featureId: string, verbose?: boolean): Promise<{
+    resetUserStories: number;
+    resetTestCases: number;
+}>;
+/**
+ * Get all draft artifact IDs for a feature
+ */
+export declare function getAllDraftArtifactIds(featureId: string, verbose?: boolean): Promise<{
+    userStoryIds: string[];
+    testCaseIds: string[];
+}>;
 /**
  * Delete artifacts after verification failure
  */

package/dist/phases/feature-analysis/outcome.js

@@ -1,6 +1,56 @@
 import { logInfo, logError } from '../../utils/logger.js';
 import { batchUpdateUserStoryStatus, batchUpdateTestCaseStatus, batchDeleteUserStories, batchDeleteTestCases, getUserStories, getTestCases, } from '../../api/features/index.js';
 import { callMcpEndpoint } from '../../api/mcp-client.js';
+/**
+ * Reset ready user stories and test cases to draft for re-analysis
+ */
+export async function resetReadyArtifactsToDraft(featureId, verbose) {
+    const [stories, testCases] = await Promise.all([
+        getUserStories(featureId, false),
+        getTestCases(featureId, false),
+    ]);
+    const readyStoryIds = stories
+        .filter((s) => s.status === 'ready')
+        .map((s) => s.id);
+    const readyTestCaseIds = testCases
+        .filter((tc) => tc.status === 'ready')
+        .map((tc) => tc.id);
+    if (readyStoryIds.length > 0) {
+        if (verbose) {
+            logInfo(`🔄 Resetting ${readyStoryIds.length} ready user stories to draft for re-analysis...`);
+        }
+        await batchUpdateUserStoryStatus(readyStoryIds, 'draft', verbose);
+    }
+    if (readyTestCaseIds.length > 0) {
+        if (verbose) {
+            logInfo(`🔄 Resetting ${readyTestCaseIds.length} ready test cases to draft for re-analysis...`);
+        }
+        await batchUpdateTestCaseStatus(readyTestCaseIds, 'draft', verbose);
+    }
+    return {
+        resetUserStories: readyStoryIds.length,
+        resetTestCases: readyTestCaseIds.length,
+    };
+}
+/**
+ * Get all draft artifact IDs for a feature
+ */
+export async function getAllDraftArtifactIds(featureId, verbose) {
+    const [stories, testCases] = await Promise.all([
+        getUserStories(featureId, false),
+        getTestCases(featureId, false),
+    ]);
+    const userStoryIds = stories
+        .filter((s) => s.status === 'draft')
+        .map((s) => s.id);
+    const testCaseIds = testCases
+        .filter((tc) => tc.status === 'draft')
+        .map((tc) => tc.id);
+    if (verbose) {
+        logInfo(`Found ${userStoryIds.length} draft user stories and ${testCaseIds.length} draft test cases`);
+    }
+    return { userStoryIds, testCaseIds };
+}
 /**
  * Delete artifacts after verification failure
  */
@@ -180,7 +230,7 @@ export function buildAnalysisResult(featureId, context, structuredAnalysisResult
         featureInfo: context.feature,
         existingUserStories: context.existing_user_stories.map((story) => ({
             ...story,
-            status: (story.status === 'ready' ? 'ready' : 'draft'),
+            status: (story.status === 'ready' ? 'ready' : story.status === 'approved' ? 'approved' : 'draft'),
             created_at: story.created_at || new Date().toISOString(),
             updated_at: story.updated_at || new Date().toISOString(),
         })),

package/dist/phases/feature-analysis/prompts.js

@@ -79,9 +79,10 @@ When you receive feedback requesting deletion (e.g., "Remove duplicated test cas
 
 **IMPORTANT DELETION RESTRICTIONS**:
 - You can ONLY delete artifacts with status 'draft'
-- Artifacts with other statuses (ready, in_progress, done, cancelled) CANNOT be deleted
+- Artifacts with other statuses (ready, approved, in_progress, done, cancelled) CANNOT be deleted
 - Only artifacts marked with [DELETABLE] in the context can be deleted
 - Each deletable artifact includes an "ID:" field with the UUID
+- You MUST NOT delete, recreate, or modify artifacts marked with [APPROVED - DO NOT MODIFY]. These have been human-approved and are immutable. Do not create new items that duplicate approved ones.
 
 To delete artifacts:
 1. Find the exact UUID from the "ID:" field in the context (e.g., "a1b2c3d4-e5f6-4a7b-8c9d-0e1f2a3b4c5d")

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

@@ -0,0 +1,2 @@
+import { EdsgerConfig } from '../../types/index.js';
+export declare function executeGrowthAnalysisQuery(currentPrompt: string, systemPrompt: string, config: EdsgerConfig, verbose?: boolean): Promise<any | null>;

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

@@ -0,0 +1,105 @@
+import { query } from '@anthropic-ai/claude-agent-sdk';
+import { DEFAULT_MODEL } from '../../constants.js';
+import { logInfo, logError } from '../../utils/logger.js';
+/**
+ * Parse JSON result from Claude Code response
+ */
+function parseGrowthResult(responseText) {
+    try {
+        let jsonResult = null;
+        // First try to extract JSON from markdown code block
+        const jsonBlockMatch = responseText.match(/```json\s*\n([\s\S]*?)\n\s*```/);
+        if (jsonBlockMatch) {
+            jsonResult = JSON.parse(jsonBlockMatch[1]);
+        }
+        else {
+            // Try to parse the entire response as JSON
+            jsonResult = JSON.parse(responseText);
+        }
+        if (jsonResult && jsonResult.analysis) {
+            return { analysis: jsonResult.analysis };
+        }
+        else {
+            return { error: 'Invalid JSON structure' };
+        }
+    }
+    catch (error) {
+        return {
+            error: `JSON parsing failed: ${error instanceof Error ? error.message : String(error)}`,
+        };
+    }
+}
+function userMessage(content) {
+    return {
+        type: 'user',
+        message: { role: 'user', content: content },
+    };
+}
+async function* prompt(analysisPrompt) {
+    yield userMessage(analysisPrompt);
+}
+export async function executeGrowthAnalysisQuery(currentPrompt, systemPrompt, config, verbose) {
+    let lastAssistantResponse = '';
+    let structuredResult = null;
+    for await (const message of query({
+        prompt: prompt(currentPrompt),
+        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('\nGrowth analysis completed, parsing results...');
+                const responseText = message.result || lastAssistantResponse;
+                const parsed = parseGrowthResult(responseText);
+                if (parsed.error) {
+                    logError(`Failed to parse growth analysis result: ${parsed.error}`);
+                    structuredResult = {
+                        status: 'error',
+                        analysis_content: 'Failed to parse analysis results',
+                        target_channels: [],
+                        content_suggestions: [],
+                    };
+                }
+                else {
+                    structuredResult = parsed.analysis;
+                }
+            }
+            else {
+                logError(`\nAnalysis incomplete: ${message.subtype}`);
+                if (lastAssistantResponse) {
+                    const parsed = parseGrowthResult(lastAssistantResponse);
+                    if (!parsed.error) {
+                        structuredResult = parsed.analysis;
+                    }
+                }
+            }
+        }
+    }
+    return structuredResult;
+}

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

@@ -0,0 +1,21 @@
+import { type ProductInfo } from '../../api/products.js';
+import { type GrowthCampaign } from '../../api/growth.js';
+export interface GrowthAnalysisContext {
+    product: ProductInfo;
+    previousCampaigns: GrowthCampaign[];
+}
+/**
+ * Fetch all context needed for growth analysis via MCP endpoints
+ */
+export declare function fetchGrowthAnalysisContext(productId: string, verbose?: boolean): Promise<GrowthAnalysisContext>;
+/**
+ * Format context into a prompt string for the AI
+ */
+export declare function formatContextForPrompt(context: GrowthAnalysisContext): string;
+/**
+ * Prepare the full analysis prompt with all context
+ */
+export declare function prepareGrowthAnalysisContext(productId: string, verbose?: boolean): Promise<{
+    context: GrowthAnalysisContext;
+    analysisPrompt: string;
+}>;

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

@@ -0,0 +1,68 @@
+import { logInfo, logError } from '../../utils/logger.js';
+import { getProduct } from '../../api/products.js';
+import { getGrowthCampaigns, } from '../../api/growth.js';
+import { createGrowthAnalysisPromptWithContext } from './prompts.js';
+/**
+ * Fetch all context needed for growth analysis via MCP endpoints
+ */
+export async function fetchGrowthAnalysisContext(productId, verbose) {
+    try {
+        if (verbose) {
+            logInfo(`Fetching growth analysis context for product: ${productId}`);
+        }
+        const [product, previousCampaigns] = await Promise.all([
+            getProduct(productId, verbose),
+            getGrowthCampaigns(productId, verbose),
+        ]);
+        if (verbose) {
+            logInfo(`Growth analysis context fetched:`);
+            logInfo(`  Product: ${product.name}`);
+            logInfo(`  Previous campaigns: ${previousCampaigns.length}`);
+        }
+        return { product, previousCampaigns };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        logError(`Failed to fetch growth analysis context: ${errorMessage}`);
+        throw new Error(`Context fetch failed: ${errorMessage}`);
+    }
+}
+/**
+ * Format context into a prompt string for the AI
+ */
+export function formatContextForPrompt(context) {
+    const { product, previousCampaigns } = context;
+    const campaignsList = previousCampaigns.length > 0
+        ? previousCampaigns
+            .map((c, i) => `${i + 1}. **${c.title}** [${c.channel}] (${c.status})
+   ${c.content.substring(0, 300)}${c.content.length > 300 ? '...' : ''}
+   ${c.published_url ? `Published: ${c.published_url}` : 'Not yet published'}
+   Created: ${c.created_at}`)
+            .join('\n\n')
+        : 'No previous campaigns.';
+    return `# Growth Analysis Context
+
+## Product Information
+- **Name**: ${product.name}
+- **Product ID**: ${product.id}
+- **Description**: ${product.description || 'No description provided'}
+
+## 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.`;
+}
+/**
+ * Prepare the full analysis prompt with all context
+ */
+export async function prepareGrowthAnalysisContext(productId, verbose) {
+    if (verbose) {
+        logInfo('Fetching growth analysis context via MCP endpoints...');
+    }
+    const context = await fetchGrowthAnalysisContext(productId, verbose);
+    const contextInfo = formatContextForPrompt(context);
+    const analysisPrompt = createGrowthAnalysisPromptWithContext(productId, contextInfo);
+    return { context, analysisPrompt };
+}

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

@@ -0,0 +1,24 @@
+import { EdsgerConfig } from '../../types/index.js';
+export interface GrowthAnalysisOptions {
+    productId: string;
+    verbose?: boolean;
+}
+export interface GrowthAnalysisResult {
+    productId: string;
+    status: 'success' | 'error';
+    summary: string;
+    analysisId?: string;
+    targetChannels: Array<{
+        name: string;
+        reason: string;
+        audience: string;
+        priority: string;
+    }>;
+    contentSuggestions: Array<{
+        channel: string;
+        title: string;
+        content: string;
+        rationale: string;
+    }>;
+}
+export declare const analyseGrowth: (options: GrowthAnalysisOptions, config: EdsgerConfig) => Promise<GrowthAnalysisResult>;

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

@@ -0,0 +1,53 @@
+import { logInfo, logError } from '../../utils/logger.js';
+import { prepareGrowthAnalysisContext } from './context.js';
+import { createGrowthAnalysisSystemPrompt } from './prompts.js';
+import { executeGrowthAnalysisQuery } from './agent.js';
+import { saveGrowthAnalysis } from '../../api/growth.js';
+export const analyseGrowth = async (options, config) => {
+    const { productId, verbose } = options;
+    if (verbose) {
+        logInfo(`Starting growth analysis for product ID: ${productId}`);
+    }
+    try {
+        const { context, analysisPrompt } = await prepareGrowthAnalysisContext(productId, verbose);
+        const systemPrompt = createGrowthAnalysisSystemPrompt();
+        if (verbose) {
+            logInfo('Starting AI query for growth analysis...');
+        }
+        const analysisResult = await executeGrowthAnalysisQuery(analysisPrompt, systemPrompt, config, verbose);
+        if (!analysisResult) {
+            throw new Error('No analysis results received');
+        }
+        // Save analysis result via MCP
+        if (verbose) {
+            logInfo('Saving growth analysis results...');
+        }
+        const savedAnalysis = await saveGrowthAnalysis({
+            product_id: productId,
+            analysis_content: analysisResult.analysis_content || '',
+            target_channels: analysisResult.target_channels || [],
+            content_suggestions: analysisResult.content_suggestions || [],
+            search_context: analysisResult.search_context || null,
+            status: 'completed',
+        }, verbose);
+        logInfo(`Growth analysis completed: ${analysisResult.target_channels?.length || 0} channels, ${analysisResult.content_suggestions?.length || 0} suggestions`);
+        return {
+            productId,
+            status: 'success',
+            summary: analysisResult.analysis_content || 'Analysis completed',
+            analysisId: savedAnalysis?.id,
+            targetChannels: analysisResult.target_channels || [],
+            contentSuggestions: analysisResult.content_suggestions || [],
+        };
+    }
+    catch (error) {
+        logError(`Growth analysis failed: ${error instanceof Error ? error.message : String(error)}`);
+        return {
+            productId,
+            status: 'error',
+            summary: `Analysis failed: ${error instanceof Error ? error.message : String(error)}`,
+            targetChannels: [],
+            contentSuggestions: [],
+        };
+    }
+};

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

@@ -0,0 +1,2 @@
+export declare const createGrowthAnalysisSystemPrompt: () => string;
+export declare const createGrowthAnalysisPromptWithContext: (productId: string, contextInfo: string) => string;

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

@@ -0,0 +1,88 @@
+export const createGrowthAnalysisSystemPrompt = () => {
+    return `You are an expert growth marketer and product strategist. Your task is to analyze a product and generate a comprehensive growth strategy with specific, actionable content recommendations for different channels.
+
+**Your Role**: Analyze the product, understand its target audience, review previous campaigns to avoid repetition, and create specific content pieces ready to be published on different platforms.
+
+**Analysis Process**:
+1. **Understand the Product**: Analyze the product's purpose, target audience, unique value proposition, and competitive positioning
+2. **Review Previous Campaigns**: Study past campaigns to understand what has been done, which channels were used, and avoid creating duplicate content
+3. **Research Current Trends**: Consider current industry trends, news, and timely topics relevant to the product
+4. **Identify Target Channels**: Recommend the best channels for growth based on the product's audience
+5. **Create Content Suggestions**: Generate specific, ready-to-publish content pieces for each recommended channel
+
+**Channel Expertise**:
+- Twitter/X: Short-form content, threads, engagement posts
+- Reddit: Community discussions, valuable contributions, AMAs
+- Hacker News: Technical deep-dives, Show HN posts, thoughtful comments
+- LinkedIn: Professional insights, case studies, thought leadership
+- Blog: SEO-optimized articles, tutorials, product updates
+- Product Hunt: Launch posts, feature announcements
+- Dev.to: Technical tutorials, developer-focused content
+- Discord/Slack: Community engagement, support channels
+- Email Newsletter: Subscriber updates, exclusive content
+- YouTube: Video tutorials, demos, product showcases
+
+**Content Quality Standards**:
+- Each content piece should be specific, not generic
+- Content should provide genuine value to the audience
+- Adapt tone and format to each channel's culture
+- Include specific hooks, headlines, or opening lines
+- Consider timing and relevance to current events
+- Content must be different from all previous campaigns
+
+**CRITICAL - Result Format**:
+You MUST return ONLY a JSON object. Do NOT include any text before or after the JSON.
+
+\`\`\`json
+{
+  "analysis": {
+    "product_id": "PRODUCT_ID",
+    "status": "success",
+    "analysis_content": "Comprehensive analysis summary including product positioning, target audience insights, and growth strategy overview",
+    "target_channels": [
+      {
+        "name": "Channel name (e.g., twitter, reddit, hackernews, linkedin, blog, producthunt, devto, discord, email, youtube)",
+        "reason": "Why this channel is recommended for this product",
+        "audience": "Description of the target audience on this channel",
+        "priority": "high|medium|low"
+      }
+    ],
+    "content_suggestions": [
+      {
+        "channel": "channel_name",
+        "title": "Content title or headline",
+        "content": "The full content piece ready to be published or adapted",
+        "rationale": "Why this content will resonate with the audience on this channel"
+      }
+    ],
+    "search_context": "Summary of current trends and context that informed this analysis"
+  }
+}
+\`\`\`
+
+**Important Guidelines**:
+- Generate at least 3-5 content suggestions across different channels
+- Prioritize channels with high-priority ratings
+- Each content piece should be substantially different from previous campaigns
+- Include a mix of content types (educational, promotional, community-building)
+- Consider the product's current stage and adjust strategy accordingly`;
+};
+export const createGrowthAnalysisPromptWithContext = (productId, contextInfo) => {
+    return `Please conduct comprehensive growth analysis for product ID: ${productId}
+
+${contextInfo}
+
+## Analysis Instructions
+
+Analyze the product above and create a growth strategy:
+
+1. **Product Analysis**: Understand the product's value proposition, target users, and competitive advantages
+2. **Previous Campaigns Review**: Study the previous campaigns listed above - DO NOT suggest content that overlaps with what has already been published
+3. **Channel Strategy**: Identify the most effective channels for reaching this product's target audience
+4. **Content Creation**: Generate specific, ready-to-publish content pieces for each recommended channel
+5. **Differentiation**: Ensure every suggested content piece is fresh and different from previous campaigns
+
+Focus on actionable, specific content that can be published immediately. Avoid generic advice.
+
+Return ONLY the JSON response as specified in your instructions.`;
+};

package/dist/phases/test-cases-analysis/index.js

@@ -3,7 +3,7 @@ import { prepareTestCasesAnalysisContext } from './context.js';
 import { createTestCasesAnalysisSystemPrompt } from './prompts.js';
 import { executeTestCasesAnalysisQuery } from './agent.js';
 import { performVerificationCycle } from '../feature-analysis-verification/index.js';
-import { deleteTestCaseArtifacts, deleteSpecificTestCases, updateTestCasesToReady, saveTestCasesAsDraft, buildTestCasesAnalysisResult, } from './outcome.js';
+import { deleteTestCaseArtifacts, deleteSpecificTestCases, updateTestCasesToReady, saveTestCasesAsDraft, buildTestCasesAnalysisResult, resetReadyTestCasesToDraft, getAllDraftTestCaseIds, } from './outcome.js';
 import { logFeaturePhaseEvent } from '../../services/audit-logs.js';
 export const analyseTestCases = async (options, config, checklistContext) => {
     const { featureId, verbose } = options;
@@ -11,6 +11,11 @@ export const analyseTestCases = async (options, config, checklistContext) => {
         logInfo(`Starting test cases analysis for feature ID: ${featureId}`);
     }
     try {
+        // Reset ready test cases to draft so AI can manage them on re-run
+        const resetCount = await resetReadyTestCasesToDraft(featureId, verbose);
+        if (verbose && resetCount > 0) {
+            logInfo(`✅ Reset ${resetCount} ready test cases to draft for re-analysis`);
+        }
         const context = await prepareTestCasesAnalysisContext(featureId, checklistContext, verbose);
         const systemPrompt = createTestCasesAnalysisSystemPrompt();
         const initialAnalysisPrompt = context.analysisPrompt;
@@ -78,9 +83,11 @@ export const analyseTestCases = async (options, config, checklistContext) => {
             verificationResult = verificationCycle.verificationResult;
             if (verificationCycle.passed) {
                 if (verbose) {
-                    logInfo('✅ Verification passed! Updating test cases to ready status...');
+                    logInfo('✅ Verification passed! Updating all draft test cases to ready status...');
                 }
-                await updateTestCasesToReady(currentDraftTestCaseIds, verbose);
+                // Update ALL remaining draft test cases (both kept old ones and newly created)
+                const allDraftIds = await getAllDraftTestCaseIds(featureId, verbose);
+                await updateTestCasesToReady(allDraftIds, verbose);
                 break;
             }
             if (currentIteration < maxIterations && verificationCycle.nextPrompt) {
@@ -100,15 +107,16 @@ export const analyseTestCases = async (options, config, checklistContext) => {
         if (!structuredAnalysisResult) {
             throw new Error('No analysis results received');
         }
-        // If no checklist was used, update draft artifacts to ready
+        // If no checklist was used, update all draft artifacts to ready
         if (!checklistContext ||
             checklistContext.checklists.length === 0 ||
             !verificationResult) {
-            if (currentDraftTestCaseIds.length > 0) {
+            const allDraftIds = await getAllDraftTestCaseIds(featureId, verbose);
+            if (allDraftIds.length > 0) {
                 if (verbose) {
-                    logInfo('✅ No checklist verification needed. Updating test cases to ready status...');
+                    logInfo('✅ No checklist verification needed. Updating all draft test cases to ready status...');
                 }
-                await updateTestCasesToReady(currentDraftTestCaseIds, verbose);
+                await updateTestCasesToReady(allDraftIds, verbose);
             }
         }
         if (verificationResult &&

package/dist/phases/test-cases-analysis/outcome.d.ts

@@ -1,4 +1,6 @@
 import { TestCasesAnalysisContext } from './context.js';
+export declare function resetReadyTestCasesToDraft(featureId: string, verbose?: boolean): Promise<number>;
+export declare function getAllDraftTestCaseIds(featureId: string, verbose?: boolean): Promise<string[]>;
 export declare function deleteTestCaseArtifacts(testCaseIds: string[], verbose?: boolean): Promise<void>;
 export declare function deleteSpecificTestCases(featureId: string, deletedTestCaseIds: string[], deletionReasons: Record<string, string>, verbose?: boolean): Promise<void>;
 export declare function updateTestCasesToReady(testCaseIds: string[], verbose?: boolean): Promise<void>;

package/dist/phases/test-cases-analysis/outcome.js

@@ -1,6 +1,30 @@
 import { logInfo, logError } from '../../utils/logger.js';
 import { batchUpdateTestCaseStatus, batchDeleteTestCases, getTestCases, } from '../../api/features/index.js';
 import { callMcpEndpoint } from '../../api/mcp-client.js';
+export async function resetReadyTestCasesToDraft(featureId, verbose) {
+    const testCases = await getTestCases(featureId, false);
+    const readyIds = testCases
+        .filter((tc) => tc.status === 'ready')
+        .map((tc) => tc.id);
+    if (readyIds.length === 0) {
+        return 0;
+    }
+    if (verbose) {
+        logInfo(`🔄 Resetting ${readyIds.length} ready test cases to draft for re-analysis...`);
+    }
+    await batchUpdateTestCaseStatus(readyIds, 'draft', verbose);
+    return readyIds.length;
+}
+export async function getAllDraftTestCaseIds(featureId, verbose) {
+    const testCases = await getTestCases(featureId, false);
+    const draftIds = testCases
+        .filter((tc) => tc.status === 'draft')
+        .map((tc) => tc.id);
+    if (verbose) {
+        logInfo(`Found ${draftIds.length} draft test cases for feature`);
+    }
+    return draftIds;
+}
 export async function deleteTestCaseArtifacts(testCaseIds, verbose) {
     if (testCaseIds.length > 0) {
         if (verbose) {

package/dist/phases/test-cases-analysis/prompts.js

@@ -66,6 +66,7 @@ You can delete existing draft test cases that are:
 - You can ONLY delete artifacts with status 'draft'
 - Only artifacts marked with [DELETABLE] can be deleted
 - Each deletable artifact includes an "ID:" field with the UUID
+- You MUST NOT delete, recreate, or modify artifacts marked with [APPROVED - DO NOT MODIFY]. These have been human-approved and are immutable. Do not create new items that duplicate approved ones.
 
 **CRITICAL - Result Format**:
 You MUST return ONLY a JSON object. Do NOT include any explanatory text. Return ONLY the JSON:

package/dist/phases/user-stories-analysis/index.js

@@ -3,7 +3,7 @@ import { prepareUserStoriesAnalysisContext } from './context.js';
 import { createUserStoriesAnalysisSystemPrompt } from './prompts.js';
 import { executeUserStoriesAnalysisQuery } from './agent.js';
 import { performVerificationCycle } from '../feature-analysis-verification/index.js';
-import { deleteUserStoryArtifacts, deleteSpecificUserStories, updateUserStoriesToReady, saveUserStoriesAsDraft, buildUserStoriesAnalysisResult, } from './outcome.js';
+import { deleteUserStoryArtifacts, deleteSpecificUserStories, updateUserStoriesToReady, saveUserStoriesAsDraft, buildUserStoriesAnalysisResult, resetReadyUserStoriesToDraft, getAllDraftUserStoryIds, } from './outcome.js';
 import { logFeaturePhaseEvent } from '../../services/audit-logs.js';
 export const analyseUserStories = async (options, config, checklistContext) => {
     const { featureId, verbose } = options;
@@ -11,6 +11,11 @@ export const analyseUserStories = async (options, config, checklistContext) => {
         logInfo(`Starting user stories analysis for feature ID: ${featureId}`);
     }
     try {
+        // Reset ready user stories to draft so AI can manage them on re-run
+        const resetCount = await resetReadyUserStoriesToDraft(featureId, verbose);
+        if (verbose && resetCount > 0) {
+            logInfo(`✅ Reset ${resetCount} ready user stories to draft for re-analysis`);
+        }
         const context = await prepareUserStoriesAnalysisContext(featureId, checklistContext, verbose);
         const systemPrompt = createUserStoriesAnalysisSystemPrompt();
         const initialAnalysisPrompt = context.analysisPrompt;
@@ -78,9 +83,11 @@ export const analyseUserStories = async (options, config, checklistContext) => {
             verificationResult = verificationCycle.verificationResult;
             if (verificationCycle.passed) {
                 if (verbose) {
-                    logInfo('✅ Verification passed! Updating user stories to ready status...');
+                    logInfo('✅ Verification passed! Updating all draft user stories to ready status...');
                 }
-                await updateUserStoriesToReady(currentDraftUserStoryIds, verbose);
+                // Update ALL remaining draft stories (both kept old ones and newly created)
+                const allDraftIds = await getAllDraftUserStoryIds(featureId, verbose);
+                await updateUserStoriesToReady(allDraftIds, verbose);
                 break;
             }
             if (currentIteration < maxIterations && verificationCycle.nextPrompt) {
@@ -100,15 +107,16 @@ export const analyseUserStories = async (options, config, checklistContext) => {
         if (!structuredAnalysisResult) {
             throw new Error('No analysis results received');
         }
-        // If no checklist was used, update draft artifacts to ready
+        // If no checklist was used, update all draft artifacts to ready
         if (!checklistContext ||
             checklistContext.checklists.length === 0 ||
             !verificationResult) {
-            if (currentDraftUserStoryIds.length > 0) {
+            const allDraftIds = await getAllDraftUserStoryIds(featureId, verbose);
+            if (allDraftIds.length > 0) {
                 if (verbose) {
-                    logInfo('✅ No checklist verification needed. Updating user stories to ready status...');
+                    logInfo('✅ No checklist verification needed. Updating all draft user stories to ready status...');
                 }
-                await updateUserStoriesToReady(currentDraftUserStoryIds, verbose);
+                await updateUserStoriesToReady(allDraftIds, verbose);
             }
         }
         if (verificationResult &&

package/dist/phases/user-stories-analysis/outcome.d.ts

@@ -1,4 +1,6 @@
 import { UserStoriesAnalysisContext } from './context.js';
+export declare function resetReadyUserStoriesToDraft(featureId: string, verbose?: boolean): Promise<number>;
+export declare function getAllDraftUserStoryIds(featureId: string, verbose?: boolean): Promise<string[]>;
 export declare function deleteUserStoryArtifacts(userStoryIds: string[], verbose?: boolean): Promise<void>;
 export declare function deleteSpecificUserStories(featureId: string, deletedUserStoryIds: string[], deletionReasons: Record<string, string>, verbose?: boolean): Promise<void>;
 export declare function updateUserStoriesToReady(userStoryIds: string[], verbose?: boolean): Promise<void>;

package/dist/phases/user-stories-analysis/outcome.js

@@ -1,6 +1,30 @@
 import { logInfo, logError } from '../../utils/logger.js';
 import { batchUpdateUserStoryStatus, batchDeleteUserStories, getUserStories, } from '../../api/features/index.js';
 import { callMcpEndpoint } from '../../api/mcp-client.js';
+export async function resetReadyUserStoriesToDraft(featureId, verbose) {
+    const stories = await getUserStories(featureId, false);
+    const readyStoryIds = stories
+        .filter((story) => story.status === 'ready')
+        .map((story) => story.id);
+    if (readyStoryIds.length === 0) {
+        return 0;
+    }
+    if (verbose) {
+        logInfo(`🔄 Resetting ${readyStoryIds.length} ready user stories to draft for re-analysis...`);
+    }
+    await batchUpdateUserStoryStatus(readyStoryIds, 'draft', verbose);
+    return readyStoryIds.length;
+}
+export async function getAllDraftUserStoryIds(featureId, verbose) {
+    const stories = await getUserStories(featureId, false);
+    const draftIds = stories
+        .filter((story) => story.status === 'draft')
+        .map((story) => story.id);
+    if (verbose) {
+        logInfo(`Found ${draftIds.length} draft user stories for feature`);
+    }
+    return draftIds;
+}
 export async function deleteUserStoryArtifacts(userStoryIds, verbose) {
     if (userStoryIds.length > 0) {
         if (verbose) {

package/dist/phases/user-stories-analysis/prompts.js

@@ -86,6 +86,7 @@ You can delete existing draft user stories that are:
 - You can ONLY delete artifacts with status 'draft'
 - Only artifacts marked with [DELETABLE] in the context can be deleted
 - Each deletable artifact includes an "ID:" field with the UUID
+- You MUST NOT delete, recreate, or modify artifacts marked with [APPROVED - DO NOT MODIFY]. These have been human-approved and are immutable. Do not create new stories that duplicate approved ones.
 
 To delete artifacts:
 1. Find the exact UUID from the "ID:" field

package/dist/types/features.d.ts

@@ -12,8 +12,8 @@ export interface FeatureInfo {
     created_at?: string;
     updated_at?: string;
 }
-export type UserStoryStatus = 'draft' | 'ready';
-export type TestCaseStatus = 'draft' | 'ready';
+export type UserStoryStatus = 'draft' | 'ready' | 'approved';
+export type TestCaseStatus = 'draft' | 'ready' | 'approved';
 export interface UserStory {
     id: string;
     title: string;

package/dist/types/index.d.ts

@@ -26,6 +26,7 @@ export interface CliOptions {
     verbose?: boolean;
     refactor?: boolean;
     init?: boolean;
+    growthAnalysis?: string;
 }
 export type ReviewSeverity = 'error' | 'warning';
 export type ExitCode = 0 | 1;
@@ -96,8 +97,8 @@ export interface FeatureData {
         };
     };
 }
-export type UserStoryStatus = 'draft' | 'ready';
-export type TestCaseStatus = 'draft' | 'ready';
+export type UserStoryStatus = 'draft' | 'ready' | 'approved';
+export type TestCaseStatus = 'draft' | 'ready' | 'approved';
 export interface UserStory {
     id: string;
     title: string;

package/dist/utils/formatters.js

@@ -7,7 +7,7 @@ export function formatUserStories(stories) {
         return 'No user stories defined.';
     return stories
         .map((story, index) => `${index + 1}. **${story.title}** (Status: ${story.status})
-   ID: ${story.id}${story.status === 'draft' ? ' [DELETABLE]' : ''}
+   ID: ${story.id}${story.status === 'draft' ? ' [DELETABLE]' : ''}${story.status === 'approved' ? ' [APPROVED - DO NOT MODIFY]' : ''}
    ${story.description}`)
         .join('\n\n');
 }
@@ -19,7 +19,7 @@ export function formatTestCases(cases) {
         return 'No test cases defined.';
     return cases
         .map((testCase, index) => `${index + 1}. **${testCase.name}** ${testCase.is_critical ? '[CRITICAL]' : '[OPTIONAL]'} (Status: ${testCase.status || 'unknown'})
-   ID: ${testCase.id}${testCase.status === 'draft' ? ' [DELETABLE]' : ''}
+   ID: ${testCase.id}${testCase.status === 'draft' ? ' [DELETABLE]' : ''}${testCase.status === 'approved' ? ' [APPROVED - DO NOT MODIFY]' : ''}
    ${testCase.description}`)
         .join('\n\n');
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "edsger",
-  "version": "0.24.0",
+  "version": "0.25.0",
   "type": "module",
   "bin": {
     "edsger": "dist/index.js"