edsger 0.56.2 → 0.57.0

package/dist/api/issues/user-stories.js

@@ -1,3 +1,4 @@
+import { getSupabase, hasSupabaseSession } from '../../supabase/client.js';
 import { logError, logInfo } from '../../utils/logger.js';
 import { callMcpEndpoint } from '../mcp-client.js';
 /**
@@ -7,6 +8,22 @@ export async function getUserStories(issueId, verbose) {
     if (verbose) {
         logInfo(`Fetching user stories for issue: ${issueId}`);
     }
+    if (hasSupabaseSession()) {
+        try {
+            const { data, error } = await getSupabase()
+                .from('user_stories')
+                .select('*')
+                .eq('issue_id', issueId)
+                .order('created_at', { ascending: true });
+            if (error) {
+                throw new Error(error.message);
+            }
+            return (data || []);
+        }
+        catch {
+            // Fall through to MCP
+        }
+    }
     const result = (await callMcpEndpoint('user_stories/list', {
         issue_id: issueId,
     }));
@@ -20,16 +37,38 @@ export async function createUserStory(issueId, userStory, verbose) {
         if (verbose) {
             logInfo(`Creating user story for issue: ${issueId}`);
         }
-        await callMcpEndpoint('user_stories/create', {
-            issue_id: issueId,
-            user_stories: [
-                {
+        let usedSdk = false;
+        if (hasSupabaseSession()) {
+            try {
+                const { error } = await getSupabase()
+                    .from('user_stories')
+                    .insert({
+                    issue_id: issueId,
                     title: userStory.title,
                     description: userStory.description,
                     status: userStory.status || 'draft',
-                },
-            ],
-        });
+                });
+                if (error) {
+                    throw new Error(error.message);
+                }
+                usedSdk = true;
+            }
+            catch {
+                // Fall through to MCP
+            }
+        }
+        if (!usedSdk) {
+            await callMcpEndpoint('user_stories/create', {
+                issue_id: issueId,
+                user_stories: [
+                    {
+                        title: userStory.title,
+                        description: userStory.description,
+                        status: userStory.status || 'draft',
+                    },
+                ],
+            });
+        }
         if (verbose) {
             logInfo('✅ User story created successfully');
         }
@@ -49,9 +88,27 @@ export async function deleteUserStory(userStoryId, verbose) {
         if (verbose) {
             logInfo(`Deleting user story: ${userStoryId}`);
         }
-        await callMcpEndpoint('user_stories/delete', {
-            user_story_id: userStoryId,
-        });
+        let usedSdk = false;
+        if (hasSupabaseSession()) {
+            try {
+                const { error } = await getSupabase()
+                    .from('user_stories')
+                    .delete()
+                    .eq('id', userStoryId);
+                if (error) {
+                    throw new Error(error.message);
+                }
+                usedSdk = true;
+            }
+            catch {
+                // Fall through to MCP
+            }
+        }
+        if (!usedSdk) {
+            await callMcpEndpoint('user_stories/delete', {
+                user_story_id: userStoryId,
+            });
+        }
         if (verbose) {
             logInfo('✅ User story deleted successfully');
         }
@@ -71,10 +128,28 @@ export async function updateUserStoryStatus(userStoryId, status, verbose) {
         if (verbose) {
             logInfo(`Updating user story ${userStoryId} status to: ${status}`);
         }
-        await callMcpEndpoint('user_stories/update_status', {
-            user_story_id: userStoryId,
-            status,
-        });
+        let usedSdk = false;
+        if (hasSupabaseSession()) {
+            try {
+                const { error } = await getSupabase()
+                    .from('user_stories')
+                    .update({ status })
+                    .eq('id', userStoryId);
+                if (error) {
+                    throw new Error(error.message);
+                }
+                usedSdk = true;
+            }
+            catch {
+                // Fall through to MCP
+            }
+        }
+        if (!usedSdk) {
+            await callMcpEndpoint('user_stories/update_status', {
+                user_story_id: userStoryId,
+                status,
+            });
+        }
         if (verbose) {
             logInfo('✅ User story status updated successfully');
         }

package/dist/api/products/test-cases.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Product-scoped test case helpers.
+ *
+ * Issue-scoped helpers live in `api/issues/test-cases.ts`. The MCP
+ * `test_cases/list` and `test_cases/create` endpoints accept either
+ * `issue_id` or `product_id`, so the only difference here is which
+ * parent we send.
+ */
+import { type TestCase } from '../../types/issues.js';
+export interface CreateProductTestCaseInput {
+    name: string;
+    description: string;
+    is_critical?: boolean;
+}
+export declare function getProductTestCases(productId: string, verbose?: boolean): Promise<TestCase[]>;
+export declare function createProductTestCases(productId: string, testCases: CreateProductTestCaseInput[], verbose?: boolean): Promise<{
+    createdIds: string[];
+}>;

package/dist/api/products/test-cases.js

@@ -0,0 +1,51 @@
+/**
+ * Product-scoped test case helpers.
+ *
+ * Issue-scoped helpers live in `api/issues/test-cases.ts`. The MCP
+ * `test_cases/list` and `test_cases/create` endpoints accept either
+ * `issue_id` or `product_id`, so the only difference here is which
+ * parent we send.
+ */
+import { logError, logInfo } from '../../utils/logger.js';
+import { callMcpEndpoint } from '../mcp-client.js';
+export async function getProductTestCases(productId, verbose) {
+    if (verbose) {
+        logInfo(`Fetching test cases for product: ${productId}`);
+    }
+    const result = (await callMcpEndpoint('test_cases/list', {
+        product_id: productId,
+    }));
+    return (result.test_cases || []);
+}
+export async function createProductTestCases(productId, testCases, verbose) {
+    if (testCases.length === 0) {
+        return { createdIds: [] };
+    }
+    try {
+        if (verbose) {
+            logInfo(`Saving ${testCases.length} product test cases as draft...`);
+        }
+        const result = (await callMcpEndpoint('test_cases/create', {
+            product_id: productId,
+            test_cases: testCases.map((tc) => ({
+                name: tc.name,
+                description: tc.description,
+                is_critical: tc.is_critical || false,
+                status: 'draft',
+            })),
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any -- MCP result is loosely typed
+        }));
+        const createdIds = (result.created_test_cases || [])
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            .map((tc) => tc?.id)
+            .filter((id) => typeof id === 'string');
+        if (verbose) {
+            logInfo(`✅ Saved ${createdIds.length} product test cases as draft`);
+        }
+        return { createdIds };
+    }
+    catch (error) {
+        logError(`Failed to save product test cases: ${error instanceof Error ? error.message : String(error)}`);
+        return { createdIds: [] };
+    }
+}

package/dist/api/products.js

@@ -1,3 +1,4 @@
+import { getSupabase, hasSupabaseSession } from '../supabase/client.js';
 import { logInfo } from '../utils/logger.js';
 import { callMcpEndpoint } from './mcp-client.js';
 /**
@@ -7,6 +8,26 @@ export async function getProduct(productId, verbose) {
     if (verbose) {
         logInfo(`Fetching product details for: ${productId}`);
     }
+    if (hasSupabaseSession()) {
+        try {
+            const { data, error } = await getSupabase()
+                .from('products')
+                .select('*')
+                .eq('id', productId)
+                .maybeSingle();
+            if (error) {
+                throw new Error(error.message);
+            }
+            if (data) {
+                return data;
+            }
+            // Fall through to MCP if no row — resources/read may still resolve
+            // the product via slug or a different schema view.
+        }
+        catch {
+            // Fall through to MCP
+        }
+    }
     const result = (await callMcpEndpoint('resources/read', {
         uri: `product://${productId}`,
     }));

package/dist/api/release-test-cases.js

@@ -1,7 +1,24 @@
+import { getSupabase, hasSupabaseSession } from '../supabase/client.js';
 import { logDebug, logInfo } from '../utils/logger.js';
 import { callMcpEndpoint } from './mcp-client.js';
 export async function clearReleaseTestCases(releaseId, verbose) {
     logDebug(`Clearing draft cases for release ${releaseId}`, verbose);
+    if (hasSupabaseSession()) {
+        try {
+            const { error } = await getSupabase()
+                .from('release_test_cases')
+                .delete()
+                .eq('release_id', releaseId)
+                .eq('status', 'draft');
+            if (error) {
+                throw new Error(error.message);
+            }
+            return;
+        }
+        catch {
+            // Fall through to MCP
+        }
+    }
     await callMcpEndpoint('releases/test_cases/clear', {
         release_id: releaseId,
     });
@@ -13,6 +30,27 @@ export async function createReleaseTestCases(releaseId, cases, verbose) {
     if (verbose) {
         logInfo(`Inserting ${cases.length} release test cases`);
     }
+    if (hasSupabaseSession()) {
+        try {
+            const rows = cases.map((c) => ({
+                release_id: releaseId,
+                name: c.name,
+                description: c.description,
+                is_critical: c.is_critical || false,
+            }));
+            const { data, error } = await getSupabase()
+                .from('release_test_cases')
+                .insert(rows)
+                .select('id');
+            if (error) {
+                throw new Error(error.message);
+            }
+            return data?.length ?? rows.length;
+        }
+        catch {
+            // Fall through to MCP
+        }
+    }
     const result = (await callMcpEndpoint('releases/test_cases/create', {
         release_id: releaseId,
         test_cases: cases,

package/dist/api/releases.js

@@ -1,21 +1,90 @@
+import { getSupabase, hasSupabaseSession } from '../supabase/client.js';
 import { logDebug } from '../utils/logger.js';
 import { callMcpEndpoint } from './mcp-client.js';
 export async function upsertRelease(params, verbose) {
     logDebug(`Upserting release ${params.product_id}@${params.tag}`, verbose);
+    if (hasSupabaseSession()) {
+        try {
+            const { data, error } = await getSupabase()
+                .from('releases')
+                .upsert(params, { onConflict: 'product_id,tag' })
+                .select()
+                .single();
+            if (error) {
+                throw new Error(error.message);
+            }
+            return data;
+        }
+        catch {
+            // Fall through to MCP
+        }
+    }
     return (await callMcpEndpoint('releases/upsert', params));
 }
 export async function updateRelease(params, verbose) {
     logDebug(`Updating release ${params.release_id}`, verbose);
+    if (hasSupabaseSession()) {
+        try {
+            const { release_id, ...patch } = params;
+            const { data, error } = await getSupabase()
+                .from('releases')
+                .update(patch)
+                .eq('id', release_id)
+                .select()
+                .single();
+            if (error) {
+                throw new Error(error.message);
+            }
+            return data;
+        }
+        catch {
+            // Fall through to MCP
+        }
+    }
     return (await callMcpEndpoint('releases/update', params));
 }
 export async function getRelease(releaseId, verbose) {
     logDebug(`Fetching release ${releaseId}`, verbose);
+    if (hasSupabaseSession()) {
+        try {
+            const { data, error } = await getSupabase()
+                .from('releases')
+                .select('*')
+                .eq('id', releaseId)
+                .single();
+            if (error) {
+                throw new Error(error.message);
+            }
+            return data;
+        }
+        catch {
+            // Fall through to MCP
+        }
+    }
     return (await callMcpEndpoint('releases/get', {
         release_id: releaseId,
     }));
 }
 export async function getLatestReleaseForProduct(productId, verbose) {
     logDebug(`Fetching latest release for product ${productId}`, verbose);
+    if (hasSupabaseSession()) {
+        try {
+            const { data, error } = await getSupabase()
+                .from('releases')
+                .select('*')
+                .eq('product_id', productId)
+                .order('published_at', { ascending: false, nullsFirst: false })
+                .limit(1)
+                .maybeSingle();
+            if (error) {
+                throw new Error(error.message);
+            }
+            return data ?? null;
+        }
+        catch {
+            // Fall through to MCP
+        }
+    }
     const result = (await callMcpEndpoint('releases/latest_for_product', {
         product_id: productId,
     }));
@@ -23,6 +92,23 @@ export async function getLatestReleaseForProduct(productId, verbose) {
 }
 export async function getReleaseByTag(productId, tag, verbose) {
     logDebug(`Looking up release ${productId}@${tag}`, verbose);
+    if (hasSupabaseSession()) {
+        try {
+            const { data, error } = await getSupabase()
+                .from('releases')
+                .select('*')
+                .eq('product_id', productId)
+                .eq('tag', tag)
+                .maybeSingle();
+            if (error) {
+                throw new Error(error.message);
+            }
+            return data ?? null;
+        }
+        catch {
+            // Fall through to MCP
+        }
+    }
     const result = (await callMcpEndpoint('releases/get_by_tag', {
         product_id: productId,
         tag,

package/dist/api/tasks.js

@@ -1,3 +1,4 @@
+import { getSupabase, hasSupabaseSession } from '../supabase/client.js';
 import { logError, logInfo } from '../utils/logger.js';
 import { callMcpEndpoint } from './mcp-client.js';
 /**
@@ -8,6 +9,24 @@ export async function getProductPendingTasks(productId, verbose) {
         logInfo(`Fetching pending product tasks for: ${productId}`);
     }
     try {
+        if (hasSupabaseSession()) {
+            try {
+                const { data, error } = await getSupabase()
+                    .from('tasks')
+                    .select('*')
+                    .eq('product_id', productId)
+                    .eq('executor', 'ai')
+                    .eq('status', 'pending')
+                    .order('sequence', { ascending: true });
+                if (error) {
+                    throw new Error(error.message);
+                }
+                return (data || []);
+            }
+            catch {
+                // Fall through to MCP
+            }
+        }
         const result = (await callMcpEndpoint('tasks/list_for_product', {
             product_id: productId,
             executor: 'ai',
@@ -31,10 +50,28 @@ export async function updateTaskStatus(taskId, status, verbose) {
         if (verbose) {
             logInfo(`Updating task ${taskId} status to: ${status}`);
         }
-        await callMcpEndpoint('tasks/update', {
-            task_id: taskId,
-            status,
-        });
+        let usedSdk = false;
+        if (hasSupabaseSession()) {
+            try {
+                const { error } = await getSupabase()
+                    .from('tasks')
+                    .update({ status })
+                    .eq('id', taskId);
+                if (error) {
+                    throw new Error(error.message);
+                }
+                usedSdk = true;
+            }
+            catch {
+                // Fall through to MCP
+            }
+        }
+        if (!usedSdk) {
+            await callMcpEndpoint('tasks/update', {
+                task_id: taskId,
+                status,
+            });
+        }
         return true;
     }
     catch (error) {

package/dist/api/test-reports.js

@@ -1,3 +1,4 @@
+import { getSupabase, hasSupabaseSession } from '../supabase/client.js';
 import { logError, logInfo } from '../utils/logger.js';
 import { callMcpEndpoint } from './mcp-client.js';
 /**
@@ -8,10 +9,27 @@ export async function createTestReport(mcpServerUrl, mcpToken, issueId, reportDa
         if (verbose) {
             logInfo(`Creating test report for issue: ${issueId}`);
         }
-        await callMcpEndpoint('test_reports/create', {
-            issue_id: issueId,
-            ...reportData,
-        });
+        let usedSdk = false;
+        if (hasSupabaseSession()) {
+            try {
+                const { error } = await getSupabase()
+                    .from('test_reports')
+                    .insert({ issue_id: issueId, ...reportData });
+                if (error) {
+                    throw new Error(error.message);
+                }
+                usedSdk = true;
+            }
+            catch {
+                // Fall through to MCP
+            }
+        }
+        if (!usedSdk) {
+            await callMcpEndpoint('test_reports/create', {
+                issue_id: issueId,
+                ...reportData,
+            });
+        }
         if (verbose) {
             logInfo('✅ Test report created successfully');
         }

package/dist/api/user-psychology.d.ts

@@ -0,0 +1,101 @@
+export type UserPsychologyAnalysisStatus = 'pending' | 'completed' | 'failed';
+export interface PsychologyPersona {
+    name: string;
+    archetype: string;
+    demographics: Record<string, unknown>;
+    goals: string[];
+    frustrations: string[];
+    values: string;
+    decision_drivers: string[];
+    anti_persona_note?: string;
+    evidence?: string;
+}
+export interface PsychologyJob {
+    statement: string;
+    type: 'functional' | 'emotional' | 'social';
+    current_alternatives: string[];
+    switching_cost: string;
+    persona: string;
+}
+export interface PsychologyPainPoint {
+    pain: string;
+    trigger: string;
+    severity: 'critical' | 'chronic' | 'occasional';
+    evidence?: string;
+}
+export interface PsychologyMotivations {
+    autonomy: string;
+    competence: string;
+    relatedness: string;
+}
+export interface PsychologyBehaviorTrigger {
+    behavior: string;
+    motivation_level: 'high' | 'medium' | 'low';
+    motivation_reason: string;
+    ability_barrier: string;
+    prompt: string;
+    recommendation: string;
+}
+export interface PsychologyMessagingAngle {
+    angle_name: string;
+    hook: string;
+    persona: string;
+    job: string;
+    psychological_lever: string;
+    why_it_works: string;
+}
+export interface UserPsychologyAnalysis {
+    id: string;
+    product_id: string;
+    status: UserPsychologyAnalysisStatus;
+    guidance: string | null;
+    analysis_content: string | null;
+    target_personas: PsychologyPersona[];
+    jobs_to_be_done: PsychologyJob[];
+    pain_points: PsychologyPainPoint[];
+    motivations: PsychologyMotivations | null;
+    behavior_triggers: PsychologyBehaviorTrigger[];
+    messaging_angles: PsychologyMessagingAngle[];
+    created_by: string;
+    created_at: string;
+    updated_at: string;
+}
+interface PsychologyUpdate {
+    analysis_content?: string | null;
+    target_personas?: unknown;
+    jobs_to_be_done?: unknown;
+    pain_points?: unknown;
+    motivations?: unknown;
+    behavior_triggers?: unknown;
+    messaging_angles?: unknown;
+    status?: UserPsychologyAnalysisStatus;
+}
+/**
+ * Update an existing psychology analysis row with the AI-produced result.
+ * The CLI always reserves the row via the desktop UI first (status='pending')
+ * and then fills it in here — so this path expects a real analysisId.
+ */
+export declare function updateUserPsychologyAnalysis(analysisId: string, updates: PsychologyUpdate, verbose?: boolean): Promise<UserPsychologyAnalysis | null>;
+/**
+ * Fetch the most recent completed psychology profile for a product.
+ * Used by the growth-analysis phase to ground content in real personas.
+ * Tries direct Supabase first; falls back to the MCP endpoint when the
+ * CLI is running without a synced session.
+ */
+export declare function getLatestUserPsychologyAnalysis(productId: string, verbose?: boolean): Promise<UserPsychologyAnalysis | null>;
+/**
+ * Best-effort classification of a failure reason into a short, stable code.
+ * The UI doesn't switch on these yet, but storing them keeps the error
+ * actionable (e.g. "ai_quota" → suggest top-up; "parse" → suggest re-run)
+ * and gives future analytics a handle.
+ */
+export type UserPsychologyFailureCode = 'parse' | 'no_result' | 'ai_quota' | 'ai_auth' | 'network' | 'repo_clone' | 'context_fetch' | 'unknown';
+export declare function classifyPsychologyFailure(reason: string): UserPsychologyFailureCode;
+/**
+ * Mark an analysis as failed. Lets the desktop UI surface the error state
+ * instead of leaving a stuck "pending" row. The failure code is embedded
+ * as a leading tag in analysis_content so the UI can render it without a
+ * schema migration.
+ */
+export declare function markUserPsychologyAnalysisFailed(analysisId: string, reason: string, verbose?: boolean): Promise<void>;
+export {};