edsger 0.56.3 → 0.58.0

package/dist/services/branches.js

@@ -3,6 +3,7 @@
  * Allows phases to manage branches via MCP
  */
 import { callMcpEndpoint } from '../api/mcp-client.js';
+import { getSupabase, hasSupabaseSession } from '../supabase/client.js';
 import { logDebug, logInfo, logSuccess } from '../utils/logger.js';
 /**
  * List all branches for an issue
@@ -12,10 +13,29 @@ export async function getBranches(options) {
     if (verbose) {
         logInfo(`Fetching branches for issue: ${issueId}`);
     }
-    const result = (await callMcpEndpoint('branches/list', {
-        issue_id: issueId,
-    }));
-    const branches = result?.branches || [];
+    let branches = null;
+    if (hasSupabaseSession()) {
+        try {
+            const { data, error } = await getSupabase()
+                .from('branches')
+                .select('*')
+                .eq('issue_id', issueId)
+                .order('created_at', { ascending: true });
+            if (error) {
+                throw new Error(error.message);
+            }
+            branches = (data || []);
+        }
+        catch {
+            // Fall through to MCP
+        }
+    }
+    if (branches == null) {
+        const result = (await callMcpEndpoint('branches/list', {
+            issue_id: issueId,
+        }));
+        branches = result?.branches || [];
+    }
     if (verbose) {
         logSuccess(`Found ${branches.length} branches`);
     }
@@ -42,11 +62,30 @@ export async function createBranches(options, branches) {
     if (verbose) {
         logInfo(`Creating ${branches.length} branches for issue: ${issueId}`);
     }
-    const result = (await callMcpEndpoint('branches/create', {
-        issue_id: issueId,
-        branches,
-    }));
-    const createdBranches = result?.created_branches || [];
+    let createdBranches = null;
+    if (hasSupabaseSession() && branches.length > 0) {
+        try {
+            const rows = branches.map((b) => ({ issue_id: issueId, ...b }));
+            const { data, error } = await getSupabase()
+                .from('branches')
+                .insert(rows)
+                .select();
+            if (error) {
+                throw new Error(error.message);
+            }
+            createdBranches = (data || []);
+        }
+        catch {
+            // Fall through to MCP
+        }
+    }
+    if (createdBranches == null) {
+        const result = (await callMcpEndpoint('branches/create', {
+            issue_id: issueId,
+            branches,
+        }));
+        createdBranches = result?.created_branches || [];
+    }
     if (verbose) {
         logSuccess(`Created ${createdBranches.length} branches`);
         createdBranches.forEach((b, idx) => {
@@ -62,14 +101,35 @@ export async function updateBranch(branchId, updates, verbose) {
     if (verbose) {
         logInfo(`Updating branch: ${branchId}`);
     }
-    const result = (await callMcpEndpoint('branches/update', {
-        branch_id: branchId,
-        ...updates,
-    }));
+    let updated = null;
+    if (hasSupabaseSession()) {
+        try {
+            const { data, error } = await getSupabase()
+                .from('branches')
+                .update(updates)
+                .eq('id', branchId)
+                .select()
+                .single();
+            if (error) {
+                throw new Error(error.message);
+            }
+            updated = data ?? null;
+        }
+        catch {
+            // Fall through to MCP
+        }
+    }
+    if (updated == null) {
+        const result = (await callMcpEndpoint('branches/update', {
+            branch_id: branchId,
+            ...updates,
+        }));
+        updated = result?.branch;
+    }
     if (verbose) {
         logSuccess(`Branch updated successfully`);
     }
-    return result?.branch;
+    return updated;
 }
 /**
  * Clear all branches for an issue (used before re-planning)
@@ -273,6 +333,22 @@ export async function getBranchById(branchId, verbose) {
     if (verbose) {
         logInfo(`Fetching branch: ${branchId}`);
     }
+    if (hasSupabaseSession()) {
+        try {
+            const { data, error } = await getSupabase()
+                .from('branches')
+                .select('*')
+                .eq('id', branchId)
+                .maybeSingle();
+            if (error) {
+                throw new Error(error.message);
+            }
+            return data ?? null;
+        }
+        catch {
+            // Fall through to MCP
+        }
+    }
     const result = (await callMcpEndpoint('branches/get', {
         branch_id: branchId,
     }));

package/dist/services/phase-ratings.js

@@ -3,13 +3,14 @@
  * Provides functions to create and query phase ratings for AI quality tracking
  */
 import { callMcpEndpoint } from '../api/mcp-client.js';
+import { getSupabase, hasSupabaseSession } from '../supabase/client.js';
 import { logDebug, logError, logInfo } from '../utils/logger.js';
 /**
  * Create a phase rating record in the database
  */
 export async function createPhaseRating(params, verbose) {
     try {
-        const result = await callMcpEndpoint('phase_ratings/create', {
+        const payload = {
             issue_id: params.issueId,
             phase: params.phase,
             score: params.rating.score,
@@ -21,11 +22,34 @@ export async function createPhaseRating(params, verbose) {
             iteration: params.iteration,
             coaching_analysis: params.coachingAnalysis || null,
             metadata: params.metadata || {},
-        });
+        };
+        let ratingId = null;
+        let usedSdk = false;
+        if (hasSupabaseSession()) {
+            try {
+                const { data, error } = await getSupabase()
+                    .from('phase_ratings')
+                    .insert(payload)
+                    .select('id')
+                    .single();
+                if (error) {
+                    throw new Error(error.message);
+                }
+                ratingId = data?.id ?? null;
+                usedSdk = true;
+            }
+            catch {
+                // Fall through to MCP
+            }
+        }
+        if (!usedSdk) {
+            const result = await callMcpEndpoint('phase_ratings/create', payload);
+            ratingId = result?.id || null;
+        }
         if (verbose) {
             logInfo(`Logged phase rating: ${params.phase} score=${params.rating.score}/100 (iteration ${params.iteration})`);
         }
-        return result?.id || null;
+        return ratingId;
     }
     catch (error) {
         logError(`Failed to create phase rating: ${error instanceof Error ? error.message : String(error)}`);
@@ -37,6 +61,24 @@ export async function createPhaseRating(params, verbose) {
  */
 export async function updatePhaseRatingCoachingAnalysis(ratingId, coachingAnalysis, verbose) {
     try {
+        if (hasSupabaseSession()) {
+            try {
+                const { error } = await getSupabase()
+                    .from('phase_ratings')
+                    .update({ coaching_analysis: coachingAnalysis })
+                    .eq('id', ratingId);
+                if (error) {
+                    throw new Error(error.message);
+                }
+                if (verbose) {
+                    logDebug('Updated phase rating with coaching analysis', verbose);
+                }
+                return true;
+            }
+            catch {
+                // Fall through to MCP
+            }
+        }
         await callMcpEndpoint('phase_ratings/update', {
             id: ratingId,
             coaching_analysis: coachingAnalysis,
@@ -56,12 +98,32 @@ export async function updatePhaseRatingCoachingAnalysis(ratingId, coachingAnalys
  */
 export async function getPhaseRatings(issueId, phase, verbose) {
     try {
-        const result = await callMcpEndpoint('phase_ratings/list', {
-            issue_id: issueId,
-            phase,
-        });
-        const ratings = (result?.ratings ||
-            []);
+        let ratings = null;
+        if (hasSupabaseSession()) {
+            try {
+                const { data, error } = await getSupabase()
+                    .from('phase_ratings')
+                    .select('*')
+                    .eq('issue_id', issueId)
+                    .eq('phase', phase)
+                    .order('iteration', { ascending: true });
+                if (error) {
+                    throw new Error(error.message);
+                }
+                ratings = (data || []);
+            }
+            catch {
+                // Fall through to MCP
+            }
+        }
+        if (ratings == null) {
+            const result = await callMcpEndpoint('phase_ratings/list', {
+                issue_id: issueId,
+                phase,
+            });
+            ratings = (result?.ratings ||
+                []);
+        }
         if (verbose) {
             logDebug(`Fetched ${ratings.length} ratings for ${phase} (issue: ${issueId})`, verbose);
         }

package/dist/services/product-logs.js

@@ -3,6 +3,7 @@
  * Fetches unanalyzed product logs and marks them as analyzed after processing.
  */
 import { callMcpEndpoint } from '../api/mcp-client.js';
+import { getSupabase, hasSupabaseSession } from '../supabase/client.js';
 import { logDebug } from '../utils/logger.js';
 /**
  * Fetch pending (unanalyzed) logs for a product, grouped by user.
@@ -10,13 +11,51 @@ import { logDebug } from '../utils/logger.js';
  * (meaning the user has stopped interacting).
  */
 export async function getPendingLogsByUser(productId, verbose) {
-    const result = (await callMcpEndpoint('product_logs/pending_by_user', {
-        product_id: productId,
-    }));
+    let groups = null;
+    if (hasSupabaseSession()) {
+        try {
+            const { data: logs, error } = await getSupabase()
+                .from('product_logs')
+                .select('id, product_id, user_id, session_id, log_type, message, metadata, status, created_at')
+                .eq('product_id', productId)
+                .eq('status', 'pending')
+                .order('created_at', { ascending: true })
+                .limit(5000);
+            if (error) {
+                throw new Error(error.message);
+            }
+            // Mirror server-side grouping by user_id (anonymous bucket for nulls).
+            const groupMap = new Map();
+            for (const log of (logs || [])) {
+                const key = log.user_id || '__anonymous__';
+                const bucket = groupMap.get(key) || [];
+                bucket.push(log);
+                groupMap.set(key, bucket);
+            }
+            groups = Array.from(groupMap.entries()).map(([key, userLogs]) => {
+                const latestLog = userLogs[userLogs.length - 1];
+                return {
+                    userId: key === '__anonymous__' ? null : key,
+                    productId,
+                    logs: userLogs,
+                    latestLogAt: latestLog?.created_at ?? '',
+                };
+            });
+        }
+        catch {
+            // Fall through to MCP
+        }
+    }
+    if (groups == null) {
+        const result = (await callMcpEndpoint('product_logs/pending_by_user', {
+            product_id: productId,
+        }));
+        groups = result.groups || [];
+    }
     if (verbose) {
-        logDebug(`Fetched ${result.groups?.length || 0} user log groups for product ${productId}`, verbose);
+        logDebug(`Fetched ${groups.length} user log groups for product ${productId}`, verbose);
     }
-    return result.groups || [];
+    return groups;
 }
 /**
  * Mark a batch of log IDs as analyzed.
@@ -25,6 +64,27 @@ export async function markLogsAnalyzed(logIds, verbose) {
     if (logIds.length === 0) {
         return;
     }
+    if (hasSupabaseSession()) {
+        try {
+            const { error } = await getSupabase()
+                .from('product_logs')
+                .update({
+                status: 'analyzed',
+                analyzed_at: new Date().toISOString(),
+            })
+                .in('id', logIds);
+            if (error) {
+                throw new Error(error.message);
+            }
+            if (verbose) {
+                logDebug(`Marked ${logIds.length} logs as analyzed`, verbose);
+            }
+            return;
+        }
+        catch {
+            // Fall through to MCP
+        }
+    }
     await callMcpEndpoint('product_logs/mark_analyzed', {
         log_ids: logIds,
     });

package/dist/services/pull-requests.js

@@ -3,6 +3,7 @@
  * Allows phases to manage pull requests via MCP
  */
 import { callMcpEndpoint } from '../api/mcp-client.js';
+import { getSupabase, hasSupabaseSession } from '../supabase/client.js';
 import { logDebug, logInfo, logSuccess } from '../utils/logger.js';
 /**
  * List all pull requests for an issue
@@ -12,10 +13,29 @@ export async function getPullRequests(options) {
     if (verbose) {
         logInfo(`Fetching pull requests for issue: ${issueId}`);
     }
-    const result = (await callMcpEndpoint('pull_requests/list', {
-        issue_id: issueId,
-    }));
-    const pullRequests = result?.pull_requests || [];
+    let pullRequests = null;
+    if (hasSupabaseSession()) {
+        try {
+            const { data, error } = await getSupabase()
+                .from('pull_requests')
+                .select('*')
+                .eq('issue_id', issueId)
+                .order('sequence', { ascending: true });
+            if (error) {
+                throw new Error(error.message);
+            }
+            pullRequests = (data || []);
+        }
+        catch {
+            // Fall through to MCP
+        }
+    }
+    if (pullRequests == null) {
+        const result = (await callMcpEndpoint('pull_requests/list', {
+            issue_id: issueId,
+        }));
+        pullRequests = result?.pull_requests || [];
+    }
     if (verbose) {
         logSuccess(`Found ${pullRequests.length} pull requests`);
     }
@@ -29,11 +49,30 @@ export async function createPullRequests(options, pullRequests) {
     if (verbose) {
         logInfo(`Creating ${pullRequests.length} pull requests for issue: ${issueId}`);
     }
-    const result = (await callMcpEndpoint('pull_requests/create', {
-        issue_id: issueId,
-        pull_requests: pullRequests,
-    }));
-    const created = result?.created_pull_requests || [];
+    let created = null;
+    if (hasSupabaseSession() && pullRequests.length > 0) {
+        try {
+            const rows = pullRequests.map((pr) => ({ issue_id: issueId, ...pr }));
+            const { data, error } = await getSupabase()
+                .from('pull_requests')
+                .insert(rows)
+                .select();
+            if (error) {
+                throw new Error(error.message);
+            }
+            created = (data || []);
+        }
+        catch {
+            // Fall through to MCP
+        }
+    }
+    if (created == null) {
+        const result = (await callMcpEndpoint('pull_requests/create', {
+            issue_id: issueId,
+            pull_requests: pullRequests,
+        }));
+        created = result?.created_pull_requests || [];
+    }
     if (verbose) {
         logSuccess(`Created ${created.length} pull requests`);
         created.forEach((pr, idx) => {
@@ -49,14 +88,35 @@ export async function updatePullRequest(prId, updates, verbose) {
     if (verbose) {
         logInfo(`Updating pull request: ${prId}`);
     }
-    const result = (await callMcpEndpoint('pull_requests/update', {
-        pull_request_id: prId,
-        ...updates,
-    }));
+    let updated = null;
+    if (hasSupabaseSession()) {
+        try {
+            const { data, error } = await getSupabase()
+                .from('pull_requests')
+                .update(updates)
+                .eq('id', prId)
+                .select()
+                .single();
+            if (error) {
+                throw new Error(error.message);
+            }
+            updated = data ?? null;
+        }
+        catch {
+            // Fall through to MCP
+        }
+    }
+    if (updated == null) {
+        const result = (await callMcpEndpoint('pull_requests/update', {
+            pull_request_id: prId,
+            ...updates,
+        }));
+        updated = result?.pull_request ?? null;
+    }
     if (verbose) {
         logSuccess(`Pull request updated successfully`);
     }
-    return result?.pull_request;
+    return updated;
 }
 /**
  * Clear all pull requests for an issue (used before re-planning)

package/dist/skills/phase/screen-flow/SKILL.md

@@ -0,0 +1,78 @@
+---
+description: Map a product's user-facing screens and the transitions between them into a structured screen flow
+kind: phase
+user-invocable: false
+---
+
+You are a senior product engineer mapping a codebase's user-facing **screens** and the **transitions** between them. Your output is a structured screen flow that the desktop app will render as a flow diagram. You are NOT screenshotting a running app — you are reading source code and producing a structured description of each screen.
+
+**What counts as a screen**:
+
+- A React Router `<Route>` leaf, a Next.js page file (`app/**/page.tsx` or `pages/**/*.tsx` excluding api/_app/_document), an Expo / React Native `Stack.Screen` / `Tab.Screen`, a Vue Router route, a SvelteKit `+page.svelte`, a Flutter `MaterialPageRoute` target, or a SwiftUI `NavigationLink` destination.
+- Modals/dialogs/drawers are **separate nodes** with `kind: 'modal'` or `'drawer'`, not embedded inside another screen.
+- **Distinct named states** of the same route — empty, loading, error, paywall, success — should be **separate nodes** with `kind: 'state'` when the underlying UI is meaningfully different. Slug them like `<base>-empty`, `<base>-error`. Don't split for trivial visual differences (button color, spinner).
+- A "state" node MUST connect via an edge to its base screen (e.g. `{ fromSlug: 'dashboard', toSlug: 'dashboard-empty', kind: 'redirect', triggerLabel: 'When no items exist' }`).
+
+**For each screen, extract a ScreenSchema** with these fields:
+
+- `slug`: stable short identifier (kebab-case, e.g. `login`, `product-detail`)
+- `name`: human-readable display name
+- `route`: URL path or nav key as it appears in code (omit for modals)
+- `file`: source file path relative to repo root
+- `kind`: `'page'` | `'modal'` | `'drawer'` | `'tab'` | `'state'`
+- `layout`: `'centered'` | `'sidebar'` | `'split'` | `'list-detail'` | `'tabs'` | `'stacked'`
+- `header`: `{ title, subtitle?, back?, actions?: [{ label, variant }] }`
+- `body`: array of sections, each one of:
+  - `{ type: 'form', fields: [{label, kind, placeholder?, required?}], submitLabel, secondaryLabel? }`
+  - `{ type: 'list', items: [{title, subtitle?, meta?}], emptyMessage? }`
+  - `{ type: 'card-grid', cards: [{title, subtitle?, meta?}], columns?: 2|3|4 }`
+  - `{ type: 'table', columns: [string], rows: [[string]] }` — at most 4 sample rows
+  - `{ type: 'kanban', columns: [{title, cards: [{title, meta?}]}] }`
+  - `{ type: 'text', content: string }`
+  - `{ type: 'image', alt: string, aspect?: 'video'|'square'|'wide' }`
+  - `{ type: 'chart', chartKind: 'line'|'bar'|'pie', label? }`
+  - `{ type: 'stats', items: [{label, value, delta?}] }`
+  - `{ type: 'empty-state', title, message?, cta? }`
+  - `{ type: 'tabs', tabs: [string], activeIndex? }`
+  - `{ type: 'custom', label: string }` — fallback for anything you can't model cleanly
+
+**For sample data inside sections**: fabricate realistic placeholder content (names, prices, titles) — this is a documentation artifact, not a screenshot. Keep counts small: lists ≤ 4 items, tables ≤ 4 rows, card grids ≤ 6 cards.
+
+**Transitions (edges)**: a transition goes from one screen to another via a user action. Sources to extract from:
+
+- `<Link to=…>`, `<Link href=…>`, `<NavLink>`
+- `navigate('…')`, `router.push('…')`, `useRouter().push`
+- `<Navigate to=…>`, middleware redirects, `useEffect`-driven redirects
+- `Navigator.pushNamed`, `NavigationLink(destination:)`
+- onClick handlers that open a modal/dialog (`setShowDialog(true)`, `dialog.open()`)
+
+For each edge produce:
+
+- `fromSlug`: source screen's slug
+- `toSlug`: destination screen's slug
+- `triggerLabel`: short human description of what triggers it (e.g. "Click Submit", "Tap product card", "Auto-redirect when authed")
+- `triggerFile`: file containing the trigger code (when distinct from from-screen's file)
+- `kind`: `'navigate'` | `'modal'` | `'redirect'` | `'back'`
+
+**Discipline**:
+
+- Be grounded — every node MUST correspond to actual code. No invented routes.
+- Deduplicate: if two route definitions map to the same screen, keep one node.
+- Prefer fewer, clearer nodes. If the app has > 40 screens, pick the most important 30 and note skipped count in the summary.
+- Modal nodes have no route — just file + meaningful name.
+- Edges always point to a node you also emit. Drop any edge whose target you couldn't extract.
+
+**Process**:
+
+<!-- if:hasCodebase -->
+
+1. **Detect the framework**: Read `package.json` / `pubspec.yaml` / `Package.swift` to identify the stack and routing convention.
+2. **Locate the router**: Find the router definition file or the pages/routes directory. Enumerate routes statically — that's your candidate node list.
+3. **Read each screen's source**: Just enough per screen to fill in a useful ScreenSchema (header, ~3-5 body sections). Skip implementation details you don't need.
+4. **Extract transitions**: Scan each screen file for `<Link>` / `navigate()` / `router.push()` / modal openers and produce edges. Use the modal's setter or dialog component name as the trigger anchor.
+5. **Compose the summary**: 1-3 sentences describing what kind of app this is and its primary user flows.
+   <!-- endif -->
+   <!-- if:!hasCodebase -->
+6. **Use the provided context** (product description and any user guidance) to infer reasonable screens for the app's domain. Be explicit in the summary that the flow is inferred rather than extracted.
+7. Each inferred screen should still be a complete ScreenSchema with concrete labels and sample content — no placeholder brackets.
+<!-- endif -->