edsger 0.77.0 → 0.78.0

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

@@ -1,32 +0,0 @@
-import { type GrowthVideoResult } from '../../services/video/index.js';
-import { type EdsgerConfig } from '../../types/index.js';
-export interface GrowthAnalysisOptions {
-    productId: string;
-    verbose?: boolean;
-    guidance?: string;
-    analysisId?: string;
-}
-export interface GrowthAnalysisResult {
-    productId: string;
-    status: 'success' | 'error';
-    summary: string;
-    analysisId?: string;
-    targetChannels: {
-        name: string;
-        reason: string;
-        audience: string;
-        priority: string;
-    }[];
-    contentSuggestions: {
-        channel: string;
-        title: string;
-        content: string;
-        rationale: string;
-        videoPlan?: {
-            shouldGenerateVideo: boolean;
-            videoReason: string;
-            videoResult?: GrowthVideoResult;
-        };
-    }[];
-}
-export declare const analyseGrowth: (options: GrowthAnalysisOptions, config: EdsgerConfig) => Promise<GrowthAnalysisResult>;

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

@@ -1,226 +0,0 @@
-import { getGitHubConfigByProduct } from '../../api/github.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 { cleanupIssueRepo, cloneIssueRepo, ensureWorkspaceDir, } from '../../workspace/workspace-manager.js';
-import { executeGrowthAnalysisQuery } from './agent.js';
-import { prepareGrowthAnalysisContext } from './context.js';
-import { createGrowthAnalysisSystemPrompt } from './prompts.js';
-/**
- * Extract video plans from AI-generated content suggestions
- */
-function extractVideoPlans(
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-contentSuggestions) {
-    const plans = [];
-    for (let i = 0; i < contentSuggestions.length; i++) {
-        const suggestion = contentSuggestions[i];
-        const videoPlan = suggestion.video_plan;
-        if (videoPlan &&
-            videoPlan.should_generate_video &&
-            videoPlan.scenes?.length > 0) {
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            const scenes = videoPlan.scenes.map((s) => ({
-                order: s.order,
-                pagePath: s.page_path || '/',
-                description: s.description,
-                transcript: s.transcript,
-                duration: s.duration || 8,
-                viewportWidth: s.viewport_width,
-                viewportHeight: s.viewport_height,
-                deviceFrame: s.device_frame,
-                frameBackground: s.frame_background,
-                frameBrowserUrl: s.frame_browser_url,
-            }));
-            const htmlTemplates = videoPlan.scenes
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                .map((s) => s.html_template)
-                .filter(Boolean);
-            plans.push({
-                index: i,
-                plan: {
-                    shouldGenerateVideo: true,
-                    videoReason: videoPlan.video_reason || 'Video enhances content understanding',
-                    scenes,
-                    htmlTemplates: htmlTemplates.length > 0 ? htmlTemplates : undefined,
-                },
-            });
-        }
-    }
-    return plans;
-}
-export const analyseGrowth = async (options, config) => {
-    const { productId, verbose, guidance, analysisId } = options;
-    if (verbose) {
-        logInfo(`Starting growth analysis for product ID: ${productId}`);
-    }
-    let repoCwd;
-    let analysisSucceeded = false;
-    try {
-        // Clone product repo if GitHub is configured
-        try {
-            const githubConfig = await getGitHubConfigByProduct(productId, verbose);
-            if (githubConfig.configured &&
-                githubConfig.token &&
-                githubConfig.owner &&
-                githubConfig.repo) {
-                const workspaceRoot = ensureWorkspaceDir();
-                const { repoPath } = cloneIssueRepo(workspaceRoot, `growth-${productId}`, githubConfig.owner, githubConfig.repo, githubConfig.token);
-                repoCwd = repoPath;
-                logInfo(`Repository cloned to: ${repoCwd}`);
-            }
-            else {
-                logInfo(`No GitHub repo configured for product, running without codebase access. ${githubConfig.message || ''}`);
-            }
-        }
-        catch (error) {
-            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, guidance);
-        const systemPrompt = await createGrowthAnalysisSystemPrompt(hasCodebase);
-        if (verbose) {
-            logInfo('Starting AI query for growth analysis...');
-        }
-        const analysisResult = await executeGrowthAnalysisQuery(analysisPrompt, systemPrompt, config, verbose, repoCwd);
-        if (!analysisResult) {
-            throw new Error('No analysis results received');
-        }
-        // Save analysis result via MCP
-        if (verbose) {
-            logInfo('Saving growth analysis results...');
-        }
-        const analysisContent = analysisResult.analysis_content || '';
-        const targetChannels = (analysisResult.target_channels || []);
-        const contentSuggestions = (analysisResult.content_suggestions || []);
-        const searchContext = analysisResult.search_context || null;
-        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`);
-            // Log all planned videos
-            for (const { index, plan } of videoPlans) {
-                const suggestion = contentSuggestions[index];
-                logInfo(`\nVideo planned for: "${suggestion.title}" [${suggestion.channel}]`);
-                logInfo(`  Reason: ${plan.videoReason}`);
-                logInfo(`  Scenes: ${plan.scenes.length}`);
-            }
-            // Generate videos with concurrency limit (max 2 simultaneous)
-            const MAX_CONCURRENT_VIDEOS = 2;
-            logInfo(`\nGenerating ${videoPlans.length} video(s) (max ${MAX_CONCURRENT_VIDEOS} concurrent)...`);
-            const settled = await runWithConcurrencyLimit(videoPlans.map(({ index, plan }) => () => generateGrowthVideo(plan, {
-                productId,
-                analysisId: analysisId ?? '',
-                verbose,
-            }).then((result) => ({ index, result }))), MAX_CONCURRENT_VIDEOS);
-            for (const outcome of settled) {
-                if (outcome.status !== 'fulfilled') {
-                    logError(`Video generation error: ${outcome.reason instanceof Error ? outcome.reason.message : String(outcome.reason)}`);
-                    continue;
-                }
-                const { index, result } = outcome.value;
-                const suggestion = contentSuggestions[index];
-                videoResults.set(index, result);
-                if (!result.success) {
-                    logWarning(`Video generation failed for "${suggestion.title}": ${result.error}`);
-                    continue;
-                }
-                logSuccess(`Video generated for "${suggestion.title}": ${result.duration?.toFixed(1)}s, ${result.sceneCount} scenes`);
-                if (result.localPath) {
-                    logInfo(`  Local: ${result.localPath}`);
-                }
-                if (result.videoUrl) {
-                    logInfo(`  URL: ${result.videoUrl}`);
-                }
-            }
-        }
-        // Build final content suggestions with video results
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        const finalSuggestions = contentSuggestions.map((s, i) => {
-            const videoPlan = s.video_plan;
-            const videoResult = videoResults.get(i);
-            return {
-                channel: s.channel,
-                title: s.title,
-                content: s.content,
-                rationale: s.rationale,
-                ...(videoPlan
-                    ? {
-                        videoPlan: {
-                            shouldGenerateVideo: videoPlan.should_generate_video,
-                            videoReason: videoPlan.video_reason,
-                            ...(videoResult ? { videoResult } : {}),
-                        },
-                    }
-                    : {}),
-            };
-        });
-        analysisSucceeded = true;
-        return {
-            productId,
-            status: 'success',
-            summary: analysisContent || 'Analysis completed',
-            analysisId: savedAnalysis?.id,
-            targetChannels,
-            contentSuggestions: finalSuggestions,
-        };
-    }
-    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: [],
-        };
-    }
-    finally {
-        if (analysisSucceeded) {
-            cleanupIssueRepo(repoCwd);
-        }
-    }
-};
-/**
- * Run async tasks with a concurrency limit.
- * Returns PromiseSettledResult array in the same order as input.
- */
-async function runWithConcurrencyLimit(tasks, limit) {
-    const results = new Array(tasks.length);
-    let nextIndex = 0;
-    async function runNext() {
-        while (nextIndex < tasks.length) {
-            const i = nextIndex++;
-            try {
-                const value = await tasks[i]();
-                results[i] = { status: 'fulfilled', value };
-            }
-            catch (reason) {
-                results[i] = { status: 'rejected', reason };
-            }
-        }
-    }
-    // Start `limit` workers that each pull from the task queue
-    const workers = Array.from({ length: Math.min(limit, tasks.length) }, () => runNext());
-    await Promise.all(workers);
-    return results;
-}

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

@@ -1,2 +0,0 @@
-export declare const createGrowthAnalysisSystemPrompt: (hasCodebase?: boolean, projectDir?: string) => Promise<string>;
-export declare const createGrowthAnalysisPromptWithContext: (productId: string, contextInfo: string, hasCodebase?: boolean) => string;

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

@@ -1,45 +0,0 @@
-import { processConditionals, resolveSkill, } from '../../services/skill-resolver.js';
-import { OUTPUT_CONTRACTS } from '../output-contracts.js';
-export const createGrowthAnalysisSystemPrompt = async (hasCodebase = false, projectDir) => {
-    const skill = await resolveSkill('phase/growth-analysis', { projectDir });
-    if (!skill) {
-        throw new Error('Failed to load skill: phase/growth-analysis');
-    }
-    let { prompt } = skill;
-    prompt = processConditionals(prompt, {
-        hasCodebase,
-    });
-    return `${prompt}
-
-${OUTPUT_CONTRACTS['growth-analysis']}`;
-};
-export const createGrowthAnalysisPromptWithContext = (productId, contextInfo, hasCodebase = false) => {
-    const codebaseInstructions = hasCodebase
-        ? `
-**Step 1 - Explore the codebase FIRST**: Before writing anything, use your file reading and search tools to explore this project's codebase. Look at:
-- README.md, CLAUDE.md, package.json for project overview
-- Landing pages, marketing copy, or documentation for existing messaging
-- Key source files to understand what the product actually does technically
-- Any configuration or deployment files that reveal the tech stack
-
-**Step 2 - Analyze and create strategy**: Using your deep understanding from Step 1 plus the context above:`
-        : `
-**Analyze and create strategy**: Using the product context above:`;
-    return `Please conduct comprehensive growth analysis for product ID: ${productId}
-
-${contextInfo}
-
-## Analysis Instructions
-${codebaseInstructions}
-1. Understand the product's real value proposition, target users, and competitive advantages
-2. Study the previous campaigns listed above - DO NOT suggest content that overlaps with what has already been published
-3. Identify the most effective channels for reaching this product's target audience
-4. Generate specific, ready-to-publish content pieces using REAL details${hasCodebase ? ' from the codebase (actual issue names, real technical details, concrete benefits)' : ' from the product context above'}
-5. For content that would benefit from visual demonstration, create detailed video scene plans with HTML templates and narration scripts
-
-**VIDEO CONTENT**: Decide for each suggestion whether it needs a video. Include a video_plan object in every content_suggestions entry. When video adds value (demos, tutorials, issue showcases), provide complete scene plans with HTML templates featuring realistic mock data. When text is sufficient, set should_generate_video to false with a brief explanation.
-
-**CRITICAL**: Every content piece must be ready to copy-paste and publish. Use actual product details, not placeholders.
-
-Return ONLY the JSON response as specified in your instructions.`;
-};

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

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

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

@@ -1,338 +0,0 @@
-import { query } from '@anthropic-ai/claude-agent-sdk';
-import { DEFAULT_MODEL } from '../../constants.js';
-import { logDebug, logError, logInfo } from '../../utils/logger.js';
-/**
- * Find the index of the matching closer for an opener at `start`.
- * Handles nested brackets/braces and respects JSON string boundaries.
- *
- * @param text  The full text to scan.
- * @param start Index of the opening character (`{` or `[`).
- * @returns     Index of the matching closer, or -1 if not found.
- */
-function findMatchingClose(text, start) {
-    const opener = text[start];
-    const closer = opener === '{' ? '}' : ']';
-    let depth = 0;
-    let inString = false;
-    let escape = false;
-    for (let i = start; i < text.length; i++) {
-        const ch = text[i];
-        if (escape) {
-            escape = false;
-            continue;
-        }
-        if (ch === '\\' && inString) {
-            escape = true;
-            continue;
-        }
-        if (ch === '"') {
-            inString = !inString;
-            continue;
-        }
-        if (inString) {
-            continue;
-        }
-        if (ch === opener) {
-            depth++;
-        }
-        else if (ch === closer) {
-            depth--;
-            if (depth === 0) {
-                return i;
-            }
-        }
-    }
-    return -1;
-}
-/**
- * Try to extract JSON from a string using multiple strategies.
- * Returns the parsed object or null.
- */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-function extractJSON(text) {
-    // Strategy 1: ```json code block (greedy — grab the largest block)
-    const jsonBlocks = [...text.matchAll(/```json\s*\n([\s\S]*?)\n\s*```/g)];
-    if (jsonBlocks.length > 0) {
-        // Pick the largest block (most likely the full result)
-        const largest = jsonBlocks.reduce((a, b) => a[1].length >= b[1].length ? a : b);
-        try {
-            return JSON.parse(largest[1]);
-        }
-        catch {
-            // Try to repair truncated JSON from the largest block
-            const repaired = repairTruncatedJSON(largest[1]);
-            if (repaired) {
-                return repaired;
-            }
-        }
-    }
-    // Strategy 2: Generic code block
-    const codeBlockMatch = text.match(/```\s*\n([\s\S]*?)\n\s*```/);
-    if (codeBlockMatch) {
-        try {
-            return JSON.parse(codeBlockMatch[1]);
-        }
-        catch {
-            /* fall through */
-        }
-    }
-    // Strategy 3: Find balanced { ... } blocks using bracket counting.
-    // Tries each top-level '{' in order — if one balanced block isn't valid
-    // JSON, skip past it and keep scanning for the next '{'.
-    for (let i = 0; i < text.length; i++) {
-        if (text[i] === '{') {
-            const end = findMatchingClose(text, i);
-            if (end !== -1) {
-                try {
-                    return JSON.parse(text.slice(i, end + 1));
-                }
-                catch {
-                    // This balanced block wasn't valid JSON; skip past it and keep looking
-                    i = end;
-                }
-            }
-            else {
-                // No matching close for this '{' — skip it and try the next one
-                // (the unmatched brace might be inside prose text)
-            }
-        }
-    }
-    // Strategy 4: Parse entire text as JSON
-    try {
-        return JSON.parse(text);
-    }
-    catch {
-        return null;
-    }
-}
-/**
- * Attempt to repair truncated JSON by closing open braces/brackets.
- * Handles the common case where AI output is cut off mid-object.
- *
- * Uses a stack (not independent counters) so interleaved nesting like
- * `{ "a": [ {` is closed correctly as `}]}` rather than `]}}`.
- */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-function repairTruncatedJSON(text) {
-    // Strip trailing comma and incomplete value
-    let trimmed = text.replace(/,\s*"[^"]*"?\s*:?\s*$/, '');
-    trimmed = trimmed.replace(/,\s*$/, '');
-    // Track open brackets/braces in a stack so closers are emitted
-    // in the correct reverse order.
-    const stack = [];
-    let inString = false;
-    let escape = false;
-    for (const ch of trimmed) {
-        if (escape) {
-            escape = false;
-            continue;
-        }
-        if (ch === '\\' && inString) {
-            escape = true;
-            continue;
-        }
-        if (ch === '"') {
-            inString = !inString;
-            continue;
-        }
-        if (inString) {
-            continue;
-        }
-        if (ch === '{' || ch === '[') {
-            stack.push(ch);
-        }
-        else if (ch === '}' || ch === ']') {
-            stack.pop();
-        }
-    }
-    // Close any unterminated string
-    if (inString) {
-        trimmed += '"';
-    }
-    // Nothing to close — text is already balanced (or not truncated)
-    if (stack.length === 0) {
-        return null;
-    }
-    // Build suffix by popping the stack — each opener gets its matching closer
-    const suffix = stack
-        .reverse()
-        .map((opener) => (opener === '{' ? '}' : ']'))
-        .join('');
-    try {
-        return JSON.parse(trimmed + suffix);
-    }
-    catch {
-        return null;
-    }
-}
-/**
- * Extract individual fields from response text as a last-resort fallback.
- *
- * For array fields: locates `"field": [` then uses bracket-counting via
- * `findMatchingClose` to find the balanced `]`, correctly handling nested
- * arrays/objects inside the value.
- *
- * For string fields: uses a regex that respects escaped quotes.
- */
-function extractFieldsFallback(text) {
-    const arrayFields = [
-        'key_findings',
-        'recommendations',
-        'discovered_competitors',
-        'competitor_snapshots',
-        'market_signals',
-        'trends',
-        'competitor_highlights',
-    ];
-    const stringFields = {
-        title: /"title"\s*:\s*"((?:[^"\\]|\\.)*)"/,
-        summary: /"summary"\s*:\s*"((?:[^"\\]|\\.)*)"/,
-        report_type: /"report_type"\s*:\s*"((?:[^"\\]|\\.)*)"/,
-    };
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const result = {};
-    let recovered = false;
-    // Array fields — find `"field": [` then bracket-count to the matching `]`
-    for (const field of arrayFields) {
-        const keyPattern = new RegExp(`"${field}"\\s*:\\s*\\[`);
-        const keyMatch = keyPattern.exec(text);
-        if (!keyMatch) {
-            continue;
-        }
-        // Position of the opening `[`
-        const bracketStart = keyMatch.index + keyMatch[0].length - 1;
-        const bracketEnd = findMatchingClose(text, bracketStart);
-        if (bracketEnd === -1) {
-            continue;
-        }
-        try {
-            result[field] = JSON.parse(text.slice(bracketStart, bracketEnd + 1));
-            recovered = true;
-        }
-        catch {
-            /* skip unparseable field */
-        }
-    }
-    // String fields — regex is safe here since values are flat strings
-    for (const [field, regex] of Object.entries(stringFields)) {
-        const match = text.match(regex);
-        if (match) {
-            result[field] = match[1].replace(/\\"/g, '"');
-            recovered = true;
-        }
-    }
-    return recovered ? result : null;
-}
-/**
- * Parse JSON result from Claude Code response.
- *
- * Uses a layered approach:
- * 1. Try clean JSON extraction (code blocks, brace matching)
- * 2. Try repairing truncated JSON
- * 3. Fall back to field-level extraction
- */
-function parseIntelligenceResult(responseText) {
-    // Layer 1: Clean extraction
-    const jsonResult = extractJSON(responseText);
-    if (jsonResult) {
-        if (jsonResult.analysis) {
-            return { analysis: jsonResult.analysis };
-        }
-        // AI may have returned the analysis object directly (without wrapper)
-        if (jsonResult.key_findings || jsonResult.recommendations) {
-            return { analysis: jsonResult };
-        }
-    }
-    // Layer 2: Field-level fallback — salvage whatever we can
-    logInfo('Full JSON parse failed, attempting field-level recovery...');
-    const fallback = extractFieldsFallback(responseText);
-    if (fallback) {
-        logInfo(`Recovered ${Object.keys(fallback).length} fields: ${Object.keys(fallback).join(', ')}`);
-        return {
-            analysis: {
-                title: fallback.title || 'Intelligence Analysis (partial recovery)',
-                summary: fallback.summary ||
-                    'Analysis completed but some results could not be parsed.',
-                ...fallback,
-            },
-        };
-    }
-    return {
-        error: 'JSON parsing failed: could not extract structured data from response',
-    };
-}
-// eslint-disable-next-line @typescript-eslint/require-await
-async function* prompt(analysisPrompt) {
-    yield {
-        type: 'user',
-        message: { role: 'user', content: analysisPrompt },
-    };
-}
-export async function executeIntelligenceQuery(currentPrompt, systemPrompt, _config, verbose, cwd) {
-    let lastAssistantResponse = '';
-    let structuredResult = null;
-    let turnCount = 0;
-    logInfo('Connecting to AI agent for intelligence analysis...');
-    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',
-            ...(cwd ? { cwd } : {}),
-        },
-    })) {
-        if (verbose) {
-            logInfo(`Received message type: ${message.type}`);
-        }
-        if (message.type === 'assistant' && message.message?.content) {
-            turnCount++;
-            for (const content of message.message.content) {
-                if (content.type === 'text') {
-                    lastAssistantResponse += `${content.text}\n`;
-                    logDebug(`${content.text}`, verbose);
-                }
-                else if (content.type === 'tool_use') {
-                    const input = (content.input ?? {});
-                    const desc = input.description ?? input.command ?? 'Running...';
-                    logInfo(`[Turn ${turnCount}] ${content.name}: ${typeof desc === 'string' ? desc.slice(0, 120) : 'Running...'}`);
-                }
-            }
-        }
-        if (message.type === 'result') {
-            if (message.subtype === 'success') {
-                logInfo(`\nIntelligence analysis completed after ${turnCount} turns, parsing results...`);
-                const responseText = message.result || lastAssistantResponse;
-                const parsed = parseIntelligenceResult(responseText);
-                if (parsed.error) {
-                    logError(`Failed to parse intelligence result: ${parsed.error}`);
-                    structuredResult = {
-                        status: 'error',
-                        title: 'Intelligence Analysis (parse error)',
-                        summary: 'Analysis completed but results could not be parsed.',
-                        key_findings: [],
-                        recommendations: [],
-                    };
-                }
-                else {
-                    structuredResult = parsed.analysis;
-                }
-            }
-            else {
-                logError(`\nAnalysis incomplete: ${message.subtype}`);
-                if (lastAssistantResponse) {
-                    const parsed = parseIntelligenceResult(lastAssistantResponse);
-                    if (!parsed.error) {
-                        structuredResult = parsed.analysis;
-                    }
-                }
-            }
-        }
-    }
-    return structuredResult;
-}

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

@@ -1,23 +0,0 @@
-import { type Competitor, type CompetitorSnapshot } from '../../api/intelligence.js';
-import { type ProductInfo } from '../../api/products.js';
-export interface IntelligenceAnalysisContext {
-    product: ProductInfo;
-    confirmedCompetitors: Competitor[];
-    suggestedCompetitors: Competitor[];
-    previousSnapshots: Map<string, CompetitorSnapshot[]>;
-}
-/**
- * Fetch all context needed for intelligence analysis via MCP endpoints
- */
-export declare function fetchIntelligenceContext(productId: string, verbose?: boolean): Promise<IntelligenceAnalysisContext>;
-/**
- * Format context into a prompt string for the AI
- */
-export declare function formatContextForPrompt(context: IntelligenceAnalysisContext, guidance?: string): string;
-/**
- * Prepare the full analysis prompt with all context
- */
-export declare function prepareIntelligenceContext(productId: string, verbose?: boolean, reportType?: string, guidance?: string): Promise<{
-    context: IntelligenceAnalysisContext;
-    analysisPrompt: string;
-}>;