edsger 0.76.0 → 0.78.0

package/dist/api/intelligence.js

@@ -1,402 +0,0 @@
-import { ensureSupabaseSession, getSupabase, hasSupabaseSession, } from '../supabase/client.js';
-import { logError, logInfo } from '../utils/logger.js';
-import { normalizeReportArrays, toNumberOrNull, } from './intelligence-normalize.js';
-import { callMcpEndpoint } from './mcp-client.js';
-// =============================================================================
-// MCP response helper
-// =============================================================================
-function parseMcpResponse(result, fallback) {
-    const res = result;
-    const text = res?.content?.[0]?.text;
-    if (!text) {
-        return fallback;
-    }
-    try {
-        return JSON.parse(text);
-    }
-    catch {
-        return fallback;
-    }
-}
-// =============================================================================
-// Competitors
-// =============================================================================
-export async function getCompetitors(productId, status, verbose) {
-    if (verbose) {
-        logInfo(`Fetching competitors for product: ${productId}`);
-    }
-    try {
-        const result = await callMcpEndpoint('intelligence/competitors/list', {
-            product_id: productId,
-            ...(status ? { status } : {}),
-        });
-        return parseMcpResponse(result, []);
-    }
-    catch (error) {
-        if (verbose) {
-            logError(`Failed to fetch competitors: ${error instanceof Error ? error.message : String(error)}`);
-        }
-        return [];
-    }
-}
-export async function createCompetitor(competitor, verbose) {
-    if (verbose) {
-        logInfo(`Creating competitor: ${competitor.name}`);
-    }
-    try {
-        const result = await callMcpEndpoint('intelligence/competitors/create', competitor);
-        return parseMcpResponse(result, null);
-    }
-    catch (error) {
-        logError(`Failed to create competitor: ${error instanceof Error ? error.message : String(error)}`);
-        return null;
-    }
-}
-export async function batchCreateCompetitors(productId, competitors, verbose) {
-    if (verbose) {
-        logInfo(`Batch creating ${competitors.length} competitors`);
-    }
-    try {
-        const result = await callMcpEndpoint('intelligence/competitors/batch_create', {
-            product_id: productId,
-            competitors,
-        });
-        return parseMcpResponse(result, []);
-    }
-    catch (error) {
-        logError(`Failed to batch create competitors: ${error instanceof Error ? error.message : String(error)}`);
-        return [];
-    }
-}
-export async function updateCompetitor(competitorId, updates, verbose) {
-    if (verbose) {
-        logInfo(`Updating competitor: ${competitorId}`);
-    }
-    try {
-        if (hasSupabaseSession()) {
-            try {
-                const { data, error } = await getSupabase()
-                    .from('product_competitors')
-                    .update(updates)
-                    .eq('id', competitorId)
-                    .select()
-                    .single();
-                if (error) {
-                    throw new Error(error.message);
-                }
-                return data ?? null;
-            }
-            catch {
-                // Fall through to MCP
-            }
-        }
-        const result = await callMcpEndpoint('intelligence/competitors/update', {
-            competitor_id: competitorId,
-            ...updates,
-        });
-        return parseMcpResponse(result, null);
-    }
-    catch (error) {
-        logError(`Failed to update competitor: ${error instanceof Error ? error.message : String(error)}`);
-        return null;
-    }
-}
-export async function deleteCompetitor(competitorId, verbose) {
-    if (verbose) {
-        logInfo(`Deleting competitor: ${competitorId}`);
-    }
-    try {
-        if (hasSupabaseSession()) {
-            try {
-                const { error } = await getSupabase()
-                    .from('product_competitors')
-                    .delete()
-                    .eq('id', competitorId);
-                if (error) {
-                    throw new Error(error.message);
-                }
-                return true;
-            }
-            catch {
-                // Fall through to MCP
-            }
-        }
-        await callMcpEndpoint('intelligence/competitors/delete', {
-            competitor_id: competitorId,
-        });
-        return true;
-    }
-    catch (error) {
-        logError(`Failed to delete competitor: ${error instanceof Error ? error.message : String(error)}`);
-        return false;
-    }
-}
-// =============================================================================
-// Snapshots
-// =============================================================================
-export async function getSnapshots(opts, verbose) {
-    if (verbose) {
-        logInfo(`Fetching snapshots`);
-    }
-    try {
-        if (hasSupabaseSession()) {
-            try {
-                let query = getSupabase().from('competitor_snapshots').select('*');
-                if (opts.competitorId) {
-                    query = query.eq('competitor_id', opts.competitorId);
-                }
-                if (opts.productId) {
-                    query = query.eq('product_id', opts.productId);
-                }
-                query = query.order('created_at', { ascending: false });
-                if (opts.limit) {
-                    query = query.limit(opts.limit);
-                }
-                const { data, error } = await query;
-                if (error) {
-                    throw new Error(error.message);
-                }
-                return (data || []);
-            }
-            catch {
-                // Fall through to MCP
-            }
-        }
-        const result = await callMcpEndpoint('intelligence/snapshots/list', {
-            competitor_id: opts.competitorId,
-            product_id: opts.productId,
-            limit: opts.limit,
-        });
-        return parseMcpResponse(result, []);
-    }
-    catch (error) {
-        if (verbose) {
-            logError(`Failed to fetch snapshots: ${error instanceof Error ? error.message : String(error)}`);
-        }
-        return [];
-    }
-}
-export async function saveSnapshot(snapshot, verbose) {
-    if (verbose) {
-        logInfo(`Saving snapshot for competitor: ${snapshot.competitor_id}`);
-    }
-    try {
-        // Direct SDK write under the user's RLS session — no MCP fallback.
-        // Await the synced session first so the insert carries the user JWT
-        // (otherwise it races out as `anon` and trips RLS).
-        const ready = await ensureSupabaseSession();
-        if (!ready) {
-            logError('Failed to save snapshot: no Supabase session (sign in to the desktop app)');
-            return null;
-        }
-        const source = ['ai_analysis', 'manual', 'scheduled'].includes(snapshot.source)
-            ? snapshot.source
-            : 'ai_analysis';
-        const { data, error } = await getSupabase()
-            .from('competitor_snapshots')
-            .insert({
-            competitor_id: snapshot.competitor_id,
-            product_id: snapshot.product_id,
-            issues: snapshot.issues ?? [],
-            pricing: snapshot.pricing ?? {},
-            tech_stack: snapshot.tech_stack ?? [],
-            app_rating: toNumberOrNull(snapshot.app_rating),
-            app_review_count: toNumberOrNull(snapshot.app_review_count),
-            app_version: snapshot.app_version ?? null,
-            app_last_updated: snapshot.app_last_updated ?? null,
-            recent_reviews: snapshot.recent_reviews ?? [],
-            social_mentions: snapshot.social_mentions ?? {},
-            changes_detected: snapshot.changes_detected ?? [],
-            source,
-            raw_data: snapshot.raw_data ?? null,
-        })
-            .select()
-            .single();
-        if (error) {
-            throw new Error(error.message);
-        }
-        return data ?? null;
-    }
-    catch (error) {
-        logError(`Failed to save snapshot: ${error instanceof Error ? error.message : String(error)}`);
-        return null;
-    }
-}
-// =============================================================================
-// Reports
-// =============================================================================
-export async function getReports(productId, opts, verbose) {
-    if (verbose) {
-        logInfo(`Fetching intelligence reports for product: ${productId}`);
-    }
-    try {
-        if (hasSupabaseSession()) {
-            try {
-                let query = getSupabase()
-                    .from('intelligence_reports')
-                    .select('*')
-                    .eq('product_id', productId);
-                if (opts?.reportType) {
-                    query = query.eq('report_type', opts.reportType);
-                }
-                if (opts?.status) {
-                    query = query.eq('status', opts.status);
-                }
-                query = query.order('created_at', { ascending: false });
-                if (opts?.limit) {
-                    query = query.limit(opts.limit);
-                }
-                const { data, error } = await query;
-                if (error) {
-                    throw new Error(error.message);
-                }
-                return (data || []);
-            }
-            catch {
-                // Fall through to MCP
-            }
-        }
-        const result = await callMcpEndpoint('intelligence/reports/list', {
-            product_id: productId,
-            report_type: opts?.reportType,
-            status: opts?.status,
-            limit: opts?.limit,
-        });
-        return parseMcpResponse(result, []);
-    }
-    catch (error) {
-        if (verbose) {
-            logError(`Failed to fetch reports: ${error instanceof Error ? error.message : String(error)}`);
-        }
-        return [];
-    }
-}
-export async function getReport(reportId, verbose) {
-    if (verbose) {
-        logInfo(`Fetching report: ${reportId}`);
-    }
-    try {
-        if (hasSupabaseSession()) {
-            try {
-                const { data, error } = await getSupabase()
-                    .from('intelligence_reports')
-                    .select('*')
-                    .eq('id', reportId)
-                    .maybeSingle();
-                if (error) {
-                    throw new Error(error.message);
-                }
-                return data ?? null;
-            }
-            catch {
-                // Fall through to MCP
-            }
-        }
-        const result = await callMcpEndpoint('intelligence/reports/get', {
-            report_id: reportId,
-        });
-        return parseMcpResponse(result, null);
-    }
-    catch (error) {
-        logError(`Failed to fetch report: ${error instanceof Error ? error.message : String(error)}`);
-        return null;
-    }
-}
-export async function saveReport(report, verbose) {
-    if (verbose) {
-        logInfo(`Saving intelligence report: ${report.title}`);
-    }
-    try {
-        // Direct SDK write — no MCP fallback. intelligence_reports.created_by is
-        // NOT NULL and RLS checks `created_by = auth.uid()`, so we resolve the
-        // user from the synced session and canonicalize the LLM arrays first.
-        const ready = await ensureSupabaseSession();
-        if (!ready) {
-            logError('Failed to save report: no Supabase session (sign in to the desktop app)');
-            return null;
-        }
-        const { data: sessionData } = await getSupabase().auth.getSession();
-        const userId = sessionData.session?.user?.id;
-        if (!userId) {
-            logError('Failed to save report: could not resolve user from session');
-            return null;
-        }
-        const normalized = normalizeReportArrays({
-            key_findings: report.key_findings ?? [],
-            recommendations: report.recommendations ?? [],
-            competitor_highlights: report.competitor_highlights ?? [],
-            market_signals: report.market_signals ?? [],
-            trends: report.trends ?? [],
-        });
-        const { data, error } = await getSupabase()
-            .from('intelligence_reports')
-            .insert({
-            product_id: report.product_id,
-            report_type: report.report_type,
-            title: report.title,
-            summary: report.summary ?? null,
-            full_report: report.full_report ?? null,
-            key_findings: normalized.key_findings,
-            recommendations: normalized.recommendations,
-            competitor_highlights: normalized.competitor_highlights,
-            market_signals: normalized.market_signals,
-            trends: normalized.trends,
-            persona_updates: report.persona_updates ?? null,
-            pmf_score: toNumberOrNull(report.pmf_score),
-            pmf_signals: report.pmf_signals ?? null,
-            guidance: report.guidance ?? null,
-            status: report.status ?? 'completed',
-            snapshot_ids: report.snapshot_ids ?? [],
-            created_by: userId,
-        })
-            .select()
-            .single();
-        if (error) {
-            throw new Error(error.message);
-        }
-        return data ?? null;
-    }
-    catch (error) {
-        logError(`Failed to save report: ${error instanceof Error ? error.message : String(error)}`);
-        return null;
-    }
-}
-export async function updateReport(reportId, updates, verbose) {
-    if (verbose) {
-        logInfo(`Updating report: ${reportId}`);
-    }
-    try {
-        // Direct SDK write — no MCP fallback.
-        const ready = await ensureSupabaseSession();
-        if (!ready) {
-            logError('Failed to update report: no Supabase session (sign in to the desktop app)');
-            return null;
-        }
-        // Only send keys the caller provided so a partial update doesn't clobber
-        // stored columns. Numeric/array fields are coerced/canonicalized.
-        const payload = {};
-        for (const [key, value] of Object.entries(updates)) {
-            if (value !== undefined) {
-                payload[key] = value;
-            }
-        }
-        if ('pmf_score' in payload) {
-            payload.pmf_score = toNumberOrNull(payload.pmf_score);
-        }
-        const normalized = normalizeReportArrays(payload);
-        const { data, error } = await getSupabase()
-            .from('intelligence_reports')
-            .update(normalized)
-            .eq('id', reportId)
-            .select()
-            .single();
-        if (error) {
-            throw new Error(error.message);
-        }
-        return data ?? null;
-    }
-    catch (error) {
-        logError(`Failed to update report: ${error instanceof Error ? error.message : String(error)}`);
-        return null;
-    }
-}

package/dist/api/issues/approval-checker.d.ts

@@ -1,22 +0,0 @@
-/**
- * Approval workflow integration for issue phases.
- *
- * Under the 2D model, approvals are gated on the PHASE the worker is
- * about to enter (e.g. "approve before technical_design runs"), not on
- * the issue's lifecycle status. The phase-executor passes the target
- * phase name; we look up the approval config for that phase and block
- * execution if pending approval is required.
- */
-interface ApprovalCheckResult {
-    canProceed: boolean;
-    requiresApproval: boolean;
-    approvalId?: string;
-    message?: string;
-}
-/**
- * Check if a phase requires approval before the worker enters it.
- * Called by phase-executor with the snake_case phase name (e.g.
- * 'technical_design').
- */
-export declare function checkApprovalBeforePhaseExecution(issueId: string, phase: string, verbose?: boolean): Promise<ApprovalCheckResult>;
-export {};

package/dist/api/issues/approval-checker.js

@@ -1,141 +0,0 @@
-/**
- * Approval workflow integration for issue phases.
- *
- * Under the 2D model, approvals are gated on the PHASE the worker is
- * about to enter (e.g. "approve before technical_design runs"), not on
- * the issue's lifecycle status. The phase-executor passes the target
- * phase name; we look up the approval config for that phase and block
- * execution if pending approval is required.
- */
-import { logError, logInfo, logWarning } from '../../utils/logger.js';
-import { callMcpEndpoint } from '../mcp-client.js';
-import { getIssue } from './get-issue.js';
-/**
- * Check if a phase requires approval before the worker enters it.
- * Called by phase-executor with the snake_case phase name (e.g.
- * 'technical_design').
- */
-export async function checkApprovalBeforePhaseExecution(issueId, phase, verbose = false) {
-    try {
-        const issue = await getIssue(issueId, verbose);
-        const productId = issue.product_id;
-        if (verbose) {
-            logInfo(`🔍 Checking approval for phase: ${phase}`);
-            logInfo(`📦 Product ID: ${productId}`);
-        }
-        const requiresApprovalResult = (await callMcpEndpoint('approvals/requires_approval', {
-            product_id: productId,
-            issue_status: phase,
-        }));
-        if (verbose) {
-            logInfo(`📋 MCP requires_approval response: ${JSON.stringify(requiresApprovalResult)}`);
-        }
-        const requiresApproval = requiresApprovalResult?.requires_approval === true;
-        if (!requiresApproval) {
-            if (verbose) {
-                logInfo(`✅ Phase ${phase} does not require approval. Proceeding.`);
-            }
-            return {
-                canProceed: true,
-                requiresApproval: false,
-            };
-        }
-        if (verbose) {
-            logInfo(`🔒 Phase ${phase} requires approval`);
-        }
-        const existingApprovals = (await callMcpEndpoint('approvals/issue_approvals', {
-            issue_id: issueId,
-        }));
-        const approvedApproval = existingApprovals?.approvals?.find((approval) => approval.requested_status === phase &&
-            approval.approval_status === 'approved');
-        if (approvedApproval) {
-            if (verbose) {
-                logInfo(`✅ Found approved approval for ${phase}. Proceeding.`);
-            }
-            return {
-                canProceed: true,
-                requiresApproval: true,
-                approvalId: approvedApproval.id,
-            };
-        }
-        const pendingApproval = existingApprovals?.approvals?.find((approval) => approval.requested_status === phase &&
-            approval.approval_status === 'pending');
-        if (pendingApproval) {
-            if (verbose) {
-                logWarning(`⏳ Approval already pending for ${phase}. Waiting.`);
-            }
-            return {
-                canProceed: false,
-                requiresApproval: true,
-                approvalId: pendingApproval.id,
-                message: `Waiting for approval of phase: ${phase}`,
-            };
-        }
-        if (verbose) {
-            logInfo(`🔔 No approval exists for ${phase}. Creating approval request...`);
-        }
-        const approvalId = await createApprovalRequestWithEmail(issueId, productId, phase, verbose);
-        if (approvalId) {
-            return {
-                canProceed: false,
-                requiresApproval: true,
-                approvalId,
-                message: `Approval request created for phase: ${phase}`,
-            };
-        }
-        logError('Failed to create approval request');
-        return {
-            canProceed: false,
-            requiresApproval: true,
-            message: `Failed to create approval request for phase: ${phase}`,
-        };
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        logError(`Error checking approval before phase execution: ${errorMessage}`);
-        // On error, block execution to be safe
-        return {
-            canProceed: false,
-            requiresApproval: true,
-            message: `Error checking approval: ${errorMessage}`,
-        };
-    }
-}
-/**
- * Create an approval request for a phase. The approval is asking:
- * "Can we proceed into this phase?"
- */
-async function createApprovalRequestWithEmail(issueId, productId, phase, verbose = false) {
-    try {
-        if (verbose) {
-            logInfo(`Creating approval request for phase: ${phase}`);
-        }
-        const result = (await callMcpEndpoint('approvals/create', {
-            issue_id: issueId,
-            requested_status: phase,
-            previous_status: null,
-        }));
-        const approvalId = result?.approval_id;
-        if (!approvalId) {
-            logError('Failed to create approval request: No approval_id returned');
-            return null;
-        }
-        if (verbose) {
-            logInfo(`✅ Approval request created: ${approvalId}`);
-            if (result?.emails_sent) {
-                const sentCount = result.emails_sent.filter((e) => e.status === 'sent').length;
-                const failedCount = result.emails_sent.filter((e) => e.status !== 'sent').length;
-                logInfo(`📧 Sent approval emails to ${sentCount} assignee(s)`);
-                if (failedCount > 0) {
-                    logWarning(`⚠️ Failed to send ${failedCount} email(s)`);
-                }
-            }
-        }
-        return approvalId;
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        logError(`Failed to create approval request: ${errorMessage}`);
-        return null;
-    }
-}

package/dist/api/issues/batch-operations.d.ts

@@ -1,17 +0,0 @@
-import { type TestCaseStatus, type UserStoryStatus } from '../../types/index.js';
-/**
- * Batch update user story statuses
- */
-export declare function batchUpdateUserStoryStatus(userStoryIds: string[], status: UserStoryStatus, verbose?: boolean): Promise<boolean>;
-/**
- * Batch update test case statuses
- */
-export declare function batchUpdateTestCaseStatus(testCaseIds: string[], status: TestCaseStatus, verbose?: boolean): Promise<boolean>;
-/**
- * Batch delete user stories
- */
-export declare function batchDeleteUserStories(userStoryIds: string[], verbose?: boolean): Promise<boolean>;
-/**
- * Batch delete test cases
- */
-export declare function batchDeleteTestCases(testCaseIds: string[], verbose?: boolean): Promise<boolean>;

package/dist/api/issues/batch-operations.js

@@ -1,100 +0,0 @@
-import { logError, logInfo } from '../../utils/logger.js';
-import { callMcpEndpoint } from '../mcp-client.js';
-/**
- * Batch update user story statuses
- */
-export async function batchUpdateUserStoryStatus(userStoryIds, status, verbose) {
-    try {
-        if (verbose) {
-            logInfo(`Batch updating ${userStoryIds.length} user stories to status: ${status}`);
-        }
-        for (const id of userStoryIds) {
-            await callMcpEndpoint('user_stories/update_status', {
-                user_story_id: id,
-                status,
-            });
-        }
-        if (verbose) {
-            logInfo('✅ Batch user story status update completed');
-        }
-        return true;
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        logError(`Failed to batch update user story statuses: ${errorMessage}`);
-        return false;
-    }
-}
-/**
- * Batch update test case statuses
- */
-export async function batchUpdateTestCaseStatus(testCaseIds, status, verbose) {
-    try {
-        if (verbose) {
-            logInfo(`Batch updating ${testCaseIds.length} test cases to status: ${status}`);
-        }
-        for (const id of testCaseIds) {
-            await callMcpEndpoint('test_cases/update_status', {
-                test_case_id: id,
-                status,
-            });
-        }
-        if (verbose) {
-            logInfo('✅ Batch test case status update completed');
-        }
-        return true;
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        logError(`Failed to batch update test case statuses: ${errorMessage}`);
-        return false;
-    }
-}
-/**
- * Batch delete user stories
- */
-export async function batchDeleteUserStories(userStoryIds, verbose) {
-    try {
-        if (verbose) {
-            logInfo(`Batch deleting ${userStoryIds.length} user stories`);
-        }
-        for (const id of userStoryIds) {
-            await callMcpEndpoint('user_stories/delete', {
-                user_story_id: id,
-            });
-        }
-        if (verbose) {
-            logInfo('✅ Batch user story deletion completed');
-        }
-        return true;
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        logError(`Failed to batch delete user stories: ${errorMessage}`);
-        return false;
-    }
-}
-/**
- * Batch delete test cases
- */
-export async function batchDeleteTestCases(testCaseIds, verbose) {
-    try {
-        if (verbose) {
-            logInfo(`Batch deleting ${testCaseIds.length} test cases`);
-        }
-        for (const id of testCaseIds) {
-            await callMcpEndpoint('test_cases/delete', {
-                test_case_id: id,
-            });
-        }
-        if (verbose) {
-            logInfo('✅ Batch test case deletion completed');
-        }
-        return true;
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        logError(`Failed to batch delete test cases: ${errorMessage}`);
-        return false;
-    }
-}

package/dist/api/issues/get-issue.d.ts

@@ -1,5 +0,0 @@
-import { type IssueInfo } from '../../types/issues.js';
-/**
- * Get issue details by ID
- */
-export declare function getIssue(issueId: string, verbose?: boolean): Promise<IssueInfo>;