edsger 0.76.0 → 0.78.0

package/dist/services/video/video-assembler.js

@@ -1,351 +0,0 @@
-/**
- * Video assembler that combines screenshots and audio narration into a video.
- * Uses ffmpeg for professional-quality video output.
- */
-import { execFileSync, execSync } from 'child_process';
-import { mkdir, writeFile } from 'fs/promises';
-import { join } from 'path';
-import { logError, logInfo, logWarning } from '../../utils/logger.js';
-import { ensureFFmpeg } from '../../utils/validation.js';
-import { getAudioDuration } from './tts-generator.js';
-/**
- * Check if ffmpeg is available on the system
- */
-export function isFfmpegAvailable() {
-    try {
-        execSync('ffmpeg -version', { stdio: 'ignore' });
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-/**
- * Detect the resolution of a screenshot image using ffprobe.
- * Returns null if detection fails (falls back to defaults).
- */
-function detectScreenshotResolution(imagePath) {
-    if (!imagePath) {
-        return null;
-    }
-    try {
-        const output = execSync(`ffprobe -v quiet -select_streams v:0 -show_entries stream=width,height -of csv=p=0:s=x "${imagePath}"`, { encoding: 'utf-8' }).trim();
-        const [w, h] = output.split('x').map(Number);
-        if (w > 0 && h > 0) {
-            // Ensure even dimensions (required by h264)
-            return { width: w % 2 === 0 ? w : w + 1, height: h % 2 === 0 ? h : h + 1 };
-        }
-    }
-    catch {
-        // Detection failed, will use defaults
-    }
-    return null;
-}
-function concatenateWithCrossfade(opts) {
-    const { segmentPaths, outputPath, fadeDuration, width: _width, height: _height, fps, codec, preset, verbose, } = opts;
-    // For 2 segments: simple single xfade
-    // For N segments: chain xfade filters [0][1]xfade -> [v01], [v01][2]xfade -> [v012], etc.
-    // We also need to merge audio with acrossfade.
-    // Get segment durations via ffprobe to calculate xfade offsets
-    const durations = [];
-    for (const seg of segmentPaths) {
-        try {
-            const durationOutput = execSync(`ffprobe -v quiet -show_entries format=duration -of csv=p=0 "${seg}"`, { encoding: 'utf-8' }).trim();
-            durations.push(parseFloat(durationOutput));
-        }
-        catch {
-            durations.push(5); // fallback
-        }
-    }
-    // Build input args
-    const inputArgs = [];
-    for (const seg of segmentPaths) {
-        inputArgs.push('-i', seg);
-    }
-    // Build xfade filter chain
-    // offset for xfade between segment i and i+1 = cumulative_duration - (i+1)*fadeDuration
-    const n = segmentPaths.length;
-    const videoFilters = [];
-    const audioFilters = [];
-    let cumulativeDuration = durations[0];
-    for (let i = 0; i < n - 1; i++) {
-        const offset = Math.max(0, cumulativeDuration - fadeDuration);
-        const inputA = i === 0 ? `[${i}:v]` : `[vfade${i}]`;
-        const inputB = `[${i + 1}:v]`;
-        const output = i === n - 2 ? '[vout]' : `[vfade${i + 1}]`;
-        videoFilters.push(`${inputA}${inputB}xfade=transition=fade:duration=${fadeDuration}:offset=${offset.toFixed(3)}${output}`);
-        const audioA = i === 0 ? `[${i}:a]` : `[afade${i}]`;
-        const audioB = `[${i + 1}:a]`;
-        const audioOut = i === n - 2 ? '[aout]' : `[afade${i + 1}]`;
-        audioFilters.push(`${audioA}${audioB}acrossfade=d=${fadeDuration}:c1=tri:c2=tri${audioOut}`);
-        // Update cumulative duration (xfade shortens total by fadeDuration per transition)
-        cumulativeDuration = offset + durations[i + 1];
-    }
-    const filterComplex = [...videoFilters, ...audioFilters].join(';');
-    const args = [
-        '-y',
-        ...inputArgs,
-        '-filter_complex',
-        filterComplex,
-        '-map',
-        '[vout]',
-        '-map',
-        '[aout]',
-        '-c:v',
-        codec,
-        '-c:a',
-        'aac',
-        '-b:a',
-        '192k',
-        '-pix_fmt',
-        'yuv420p',
-        '-r',
-        String(fps),
-        '-preset',
-        preset,
-        '-movflags',
-        '+faststart',
-        outputPath,
-    ];
-    if (verbose) {
-        logInfo(`Applying crossfade (${fadeDuration}s) between ${n} segments`);
-    }
-    execFileSync('ffmpeg', args, {
-        stdio: verbose ? 'inherit' : 'ignore',
-        timeout: 600000, // longer timeout for complex filter graphs
-    });
-}
-/**
- * Simple concatenation without transitions (fallback for old ffmpeg versions).
- */
-async function simpleConcatenate(segmentPaths, outputPath, tempDir, verbose) {
-    const concatFilePath = join(tempDir, 'concat.txt');
-    const concatContent = segmentPaths.map((p) => `file '${p}'`).join('\n');
-    await writeFile(concatFilePath, concatContent);
-    const concatArgs = [
-        '-y',
-        '-f',
-        'concat',
-        '-safe',
-        '0',
-        '-i',
-        concatFilePath,
-        '-c',
-        'copy',
-        '-movflags',
-        '+faststart',
-        outputPath,
-    ];
-    execFileSync('ffmpeg', concatArgs, {
-        stdio: verbose ? 'inherit' : 'ignore',
-        timeout: 300000,
-    });
-}
-/**
- * Assemble a video from captured screenshots and audio narration.
- * Each screenshot is displayed for the duration of its corresponding audio.
- */
-// eslint-disable-next-line complexity -- sequential video assembly with scene processing and ffmpeg orchestration
-export async function assembleVideo(scenes, audioFiles, options, verbose) {
-    ensureFFmpeg(isFfmpegAvailable);
-    const { outputPath, width: optWidth, height: optHeight, fps = 30, codec = 'libx264', preset = 'medium', crossfadeDuration = 0.5, } = options;
-    // Ensure output directory exists
-    const outputDir = join(outputPath, '..');
-    await mkdir(outputDir, { recursive: true });
-    // Auto-detect resolution from first screenshot if not explicitly set
-    let width = optWidth || 1280;
-    let height = optHeight || 720;
-    if (!optWidth || !optHeight) {
-        const detected = detectScreenshotResolution(scenes[0]?.screenshotPath);
-        if (detected) {
-            ;
-            ({ width, height } = detected);
-            if (verbose) {
-                logInfo(`Auto-detected video resolution: ${width}x${height}`);
-            }
-        }
-    }
-    if (verbose) {
-        logInfo(`Assembling video with ${scenes.length} scenes at ${width}x${height}`);
-    }
-    // Sort scenes and match with audio
-    const sortedScenes = [...scenes].sort((a, b) => a.order - b.order);
-    const audioMap = new Map(audioFiles.map((a) => [a.sceneOrder, a]));
-    // Get actual audio durations
-    const sceneDurations = [];
-    for (const scene of sortedScenes) {
-        const audio = audioMap.get(scene.order);
-        let { duration } = scene;
-        if (audio) {
-            try {
-                duration = await getAudioDuration(audio.audioPath);
-                // Add a small buffer at the end
-                duration += 0.5;
-            }
-            catch {
-                // Use scene-defined duration as fallback
-            }
-        }
-        sceneDurations.push({ scene, audio, duration });
-    }
-    // Strategy: Create individual scene videos, then concatenate
-    const tempDir = join(outputPath, '..', 'temp-assembly');
-    await mkdir(tempDir, { recursive: true });
-    const segmentPaths = [];
-    for (let i = 0; i < sceneDurations.length; i++) {
-        const { scene, audio, duration } = sceneDurations[i];
-        const segmentPath = join(tempDir, `segment-${String(i).padStart(3, '0')}.mp4`);
-        if (verbose) {
-            logInfo(`Creating segment ${i + 1}/${sceneDurations.length} (${duration.toFixed(1)}s)`);
-        }
-        try {
-            if (audio) {
-                // Create video segment from image + audio
-                const args = [
-                    '-y',
-                    '-loop',
-                    '1',
-                    '-i',
-                    scene.screenshotPath,
-                    '-i',
-                    audio.audioPath,
-                    '-c:v',
-                    codec,
-                    '-tune',
-                    'stillimage',
-                    '-c:a',
-                    'aac',
-                    '-b:a',
-                    '192k',
-                    '-pix_fmt',
-                    'yuv420p',
-                    '-vf',
-                    `scale=${width}:${height}:force_original_aspect_ratio=decrease,pad=${width}:${height}:(ow-iw)/2:(oh-ih)/2:black`,
-                    '-r',
-                    String(fps),
-                    '-shortest',
-                    '-preset',
-                    preset,
-                    '-movflags',
-                    '+faststart',
-                    segmentPath,
-                ];
-                execFileSync('ffmpeg', args, {
-                    stdio: verbose ? 'inherit' : 'ignore',
-                    timeout: 120000,
-                });
-            }
-            else {
-                // Create silent video segment from image with specified duration
-                const args = [
-                    '-y',
-                    '-loop',
-                    '1',
-                    '-i',
-                    scene.screenshotPath,
-                    '-f',
-                    'lavfi',
-                    '-i',
-                    'anullsrc=r=44100:cl=stereo',
-                    '-c:v',
-                    codec,
-                    '-tune',
-                    'stillimage',
-                    '-c:a',
-                    'aac',
-                    '-b:a',
-                    '128k',
-                    '-pix_fmt',
-                    'yuv420p',
-                    '-vf',
-                    `scale=${width}:${height}:force_original_aspect_ratio=decrease,pad=${width}:${height}:(ow-iw)/2:(oh-ih)/2:black`,
-                    '-r',
-                    String(fps),
-                    '-t',
-                    String(duration),
-                    '-preset',
-                    preset,
-                    '-movflags',
-                    '+faststart',
-                    segmentPath,
-                ];
-                execFileSync('ffmpeg', args, {
-                    stdio: verbose ? 'inherit' : 'ignore',
-                    timeout: 120000,
-                });
-            }
-            segmentPaths.push(segmentPath);
-        }
-        catch (error) {
-            logError(`Failed to create segment ${i + 1}: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-    if (segmentPaths.length === 0) {
-        throw new Error('No video segments were created successfully');
-    }
-    // Concatenate segments with crossfade transitions
-    if (verbose) {
-        logInfo('Concatenating segments with crossfade transitions...');
-    }
-    try {
-        if (segmentPaths.length === 1) {
-            // Single segment — just copy it
-            const { copyFileSync } = await import('fs');
-            copyFileSync(segmentPaths[0], outputPath);
-        }
-        else if (crossfadeDuration > 0 && segmentPaths.length >= 2) {
-            // Try xfade crossfade, fall back to simple concat if ffmpeg version doesn't support it
-            try {
-                concatenateWithCrossfade({
-                    segmentPaths,
-                    outputPath,
-                    fadeDuration: crossfadeDuration,
-                    width,
-                    height,
-                    fps,
-                    codec,
-                    preset,
-                    verbose,
-                });
-            }
-            catch (xfadeError) {
-                logWarning(`Crossfade failed (ffmpeg may not support xfade filter, requires 4.3+): ${xfadeError instanceof Error ? xfadeError.message : String(xfadeError)}`);
-                logInfo('Falling back to simple concatenation...');
-                await simpleConcatenate(segmentPaths, outputPath, tempDir, verbose);
-            }
-        }
-        else {
-            await simpleConcatenate(segmentPaths, outputPath, tempDir, verbose);
-        }
-    }
-    catch (error) {
-        throw new Error(`Failed to concatenate video segments: ${error instanceof Error ? error.message : String(error)}`);
-    }
-    // Get final video info
-    const { statSync } = await import('fs');
-    const stats = statSync(outputPath);
-    let totalDuration = 0;
-    try {
-        const durationOutput = execSync(`ffprobe -v quiet -show_entries format=duration -of csv=p=0 "${outputPath}"`, { encoding: 'utf-8' }).trim();
-        totalDuration = parseFloat(durationOutput);
-    }
-    catch {
-        totalDuration = sceneDurations.reduce((sum, s) => sum + s.duration, 0);
-    }
-    // Clean up temp directory
-    try {
-        const { rmSync } = await import('fs');
-        rmSync(tempDir, { recursive: true, force: true });
-    }
-    catch {
-        logWarning('Could not clean up temporary assembly files');
-    }
-    const result = {
-        videoPath: outputPath,
-        duration: totalDuration,
-        fileSize: stats.size,
-        sceneCount: segmentPaths.length,
-    };
-    logInfo(`Video assembled: ${result.sceneCount} scenes, ${totalDuration.toFixed(1)}s, ${(stats.size / 1024 / 1024).toFixed(1)}MB`);
-    return result;
-}

package/dist/services/video/video-uploader.d.ts

@@ -1,28 +0,0 @@
-/**
- * Video uploader for growth videos.
- * Uploads generated videos directly to Supabase Storage REST API and saves locally.
- */
-export interface VideoUploadResult {
-    /** Public URL of the uploaded video */
-    publicUrl: string;
-    /** Storage path in Supabase */
-    storagePath: string;
-    /** Local backup path */
-    localPath: string;
-}
-/**
- * Upload a video file directly to Supabase Storage REST API.
- * Uses streaming binary upload instead of base64 encoding via MCP JSON-RPC.
- */
-export declare function uploadGrowthVideo(videoPath: string, productId: string, analysisId: string, verbose?: boolean): Promise<VideoUploadResult>;
-/**
- * Save video metadata to the growth analysis record via MCP.
- */
-export declare function saveVideoMetadata(analysisId: string, videoData: {
-    video_url: string;
-    video_storage_path: string;
-    video_local_path: string;
-    video_duration: number;
-    video_file_size: number;
-    video_scene_count: number;
-}, verbose?: boolean): Promise<void>;

package/dist/services/video/video-uploader.js

@@ -1,108 +0,0 @@
-/**
- * Video uploader for growth videos.
- * Uploads generated videos directly to Supabase Storage REST API and saves locally.
- */
-import { copyFile, mkdir, readFile } from 'fs/promises';
-import { homedir } from 'os';
-import { join } from 'path';
-import { callMcpEndpoint } from '../../api/mcp-client.js';
-import { getSignedUploadUrls } from '../../api/storage.js';
-import { getMcpServerUrl } from '../../auth/auth-store.js';
-import { logError, logInfo } from '../../utils/logger.js';
-import { fetchWithRetry } from './retry.js';
-/**
- * Get the local backup directory for growth videos
- */
-function getLocalVideoDir() {
-    return join(homedir(), '.edsger', 'growth-videos');
-}
-/**
- * Derive the Supabase Storage REST API base URL from the MCP server URL.
- * MCP URL format: https://<project>.supabase.co/functions/v1
- * Storage URL:    https://<project>.supabase.co/storage/v1
- */
-function getStorageBaseUrl() {
-    const mcpUrl = getMcpServerUrl();
-    if (!mcpUrl) {
-        return null;
-    }
-    // Replace /functions/v1 with /storage/v1
-    const url = new URL(mcpUrl);
-    url.pathname = '/storage/v1';
-    return url.toString().replace(/\/$/, '');
-}
-/**
- * Upload a video file directly to Supabase Storage REST API.
- * Uses streaming binary upload instead of base64 encoding via MCP JSON-RPC.
- */
-export async function uploadGrowthVideo(videoPath, productId, analysisId, verbose) {
-    // 1. Save local backup
-    const localDir = join(getLocalVideoDir(), productId);
-    await mkdir(localDir, { recursive: true });
-    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
-    const localFileName = `growth-${timestamp}.mp4`;
-    const localPath = join(localDir, localFileName);
-    await copyFile(videoPath, localPath);
-    logInfo(`Local backup saved: ${localPath}`);
-    // 2. Upload directly to Supabase Storage REST API
-    const storagePath = `${productId}/${analysisId}/${localFileName}`;
-    try {
-        const storageBaseUrl = getStorageBaseUrl();
-        if (!storageBaseUrl) {
-            throw new Error('Not authenticated. Run `edsger login` to configure storage access.');
-        }
-        const videoBuffer = await readFile(videoPath);
-        if (verbose) {
-            logInfo(`Uploading video to Supabase Storage (${(videoBuffer.length / 1024 / 1024).toFixed(1)}MB)...`);
-        }
-        // Get a signed upload URL from the MCP server
-        const signedUrls = await getSignedUploadUrls('growth-videos', [storagePath], verbose);
-        if (!signedUrls.length) {
-            throw new Error('Failed to get signed upload URL for video');
-        }
-        // Upload using the signed URL (PUT, no auth header needed)
-        await fetchWithRetry(signedUrls[0].signed_url, {
-            method: 'PUT',
-            headers: {
-                'Content-Type': 'video/mp4',
-            },
-            body: new Uint8Array(videoBuffer),
-        }, { label: 'Supabase Storage upload' });
-        // Build the public URL
-        const publicUrl = `${storageBaseUrl}/object/public/growth-videos/${storagePath}`;
-        const uploadResult = {
-            publicUrl,
-            storagePath,
-            localPath,
-        };
-        logInfo(`Video uploaded successfully: ${uploadResult.publicUrl}`);
-        return uploadResult;
-    }
-    catch (error) {
-        logError(`Failed to upload video to remote storage: ${error instanceof Error ? error.message : String(error)}`);
-        logInfo('Video is still saved locally and can be uploaded later.');
-        return {
-            publicUrl: '',
-            storagePath,
-            localPath,
-        };
-    }
-}
-/**
- * Save video metadata to the growth analysis record via MCP.
- */
-export async function saveVideoMetadata(analysisId, videoData, verbose) {
-    try {
-        if (verbose) {
-            logInfo(`Saving video metadata for analysis: ${analysisId}`);
-        }
-        await callMcpEndpoint('growth/save_video_metadata', {
-            analysis_id: analysisId,
-            ...videoData,
-        });
-        logInfo('Video metadata saved successfully');
-    }
-    catch (error) {
-        logError(`Failed to save video metadata: ${error instanceof Error ? error.message : String(error)}`);
-    }
-}

package/dist/skills/phase/adr-generation/SKILL.md

@@ -1,51 +0,0 @@
----
-description: Lay out the realistic options for an architecture decision with an honest, context-grounded pros/cons analysis for a human to choose from
-kind: phase
-user-invocable: false
----
-
-You are a principal engineer producing an Architecture Decision Record (ADR). The human will state a decision that needs to be made. Your job is to lay out the realistic options with an honest, context-grounded pros/cons analysis so a human can choose — you do NOT make the final choice, but you DO give a clear recommendation.
-
-<!-- if:hasCodebase -->
-
-You have the project's codebase available in your working directory. Read the relevant files to ground your analysis: inspect the existing architecture, dependencies, conventions, and constraints before forming options. Cite what you find.
-
-<!-- endif -->
-<!-- if:!hasCodebase -->
-
-You do NOT have the codebase available. Reason from the provided context and your engineering knowledge, and be explicit about assumptions you are making.
-
-<!-- endif -->
-
-**Approach**:
-
-1. Make sure you understand exactly what is being decided and why it matters.
-2. Investigate the relevant context (codebase, constraints, prior art).
-3. Enumerate the credible options. For each, weigh benefits against costs, risks, migration effort, and how well it fits the existing system.
-4. Recommend one, briefly justified by the trade-offs.
-
-## Output contract
-
-When you have finished investigating, output a SINGLE JSON object (in a ```json code block) and nothing else after it. Shape:
-
-```json
-{
-  "options": [
-    {
-      "title": "Short name of the option (one line)",
-      "summary": "1-3 sentences describing the approach concretely",
-      "pros": ["benefit 1", "benefit 2"],
-      "cons": ["drawback 1", "drawback 2"],
-      "is_recommended": false
-    }
-  ]
-}
-```
-
-Rules:
-
-- Provide 2 to 4 genuinely distinct options that a competent engineer would realistically weigh. Avoid strawman options.
-- Ground pros/cons in THIS codebase and context — reference concrete files, libraries, patterns, or constraints you observed, not generic textbook points.
-- Mark exactly ONE option `"is_recommended": true` — your best judgement given the trade-offs. Be opinionated.
-- `pros` and `cons` are arrays of short strings. Keep each to one sentence.
-- Output ONLY the JSON object at the end. Do not wrap it in prose.

package/dist/skills/phase/analyze-logs/SKILL.md

@@ -1,24 +0,0 @@
----
-description: Analyze user behavior logs to identify issues and improvement opportunities
-kind: phase
-user-invocable: false
----
-
-You are a product analyst AI. You analyze user behavior logs from a product to identify issues, pain points, and improvement opportunities.
-
-Your job is to:
-
-1. Read through the user's interaction logs carefully
-2. Identify patterns that suggest problems (errors, repeated actions, abandoned flows, confusion)
-3. Identify opportunities for product improvement
-4. Generate actionable feedback items that the product team can act on
-
-For each issue or improvement you find, output a structured feedback item.
-
-IMPORTANT RULES:
-
-- Only report genuine issues or meaningful improvements, not noise
-- Be specific about what happened and what should change
-- Prioritize by impact: bugs > usability issues > minor improvements
-- If the logs show normal, successful usage with no issues, say so and return an empty array
-- Do NOT fabricate issues that aren't supported by the log data

package/dist/skills/phase/app-store-generation/SKILL.md

@@ -1,60 +0,0 @@
----
-description: Generate professional app store listings and screenshot compositions for a product
-kind: phase
-user-invocable: false
----
-
-You are an expert app store optimization (ASO) specialist and UI/UX designer. Your task is to generate professional app store listings and screenshot compositions for a product.
-
-**Your Role**: Create compelling store listings and visually stunning screenshot HTML templates that showcase the product's key issues with realistic mock data, professional text overlays, and gradient backgrounds.
-
-**Analysis Process**:
-
-<!-- if:hasCodebase -->
-
-1. **Explore the Codebase**: Use your tools to read README, CLAUDE.md, package.json, landing pages, and key source files to deeply understand the product.
-2. **Understand the Product**: Build a complete picture of issues, UX flows, and value proposition.
-3. **Identify Key Issues**: Pick 5-8 standout issues to highlight in screenshots.
-4. **Create Screenshot Compositions**: Design each as a complete HTML page with gradient background, headline text overlay, and a device-framed mock app UI.
-5. **Write Store Listings**: Generate optimized app name, subtitle, description, and keywords.
-   <!-- endif -->
-   <!-- if:!hasCodebase -->
-6. **Understand the Product**: Analyze the product from the provided context.
-7. **Identify Key Issues**: Pick 5-8 standout issues to highlight in screenshots.
-8. **Create Screenshot Compositions**: Design each as a complete HTML page with gradient background, headline text overlay, and a device-framed mock app UI.
-9. **Write Store Listings**: Generate optimized app name, subtitle, description, and keywords.
-<!-- endif -->
-
-**Screenshot Design Standards**:
-
-- Each screenshot must tell a story about a specific issue
-- Professional gradient backgrounds (not flat colors)
-- Bold headline text (2-5 words) at top or bottom, large and readable
-- Optional subheadline with supporting detail
-- The "app mock" area should show realistic UI with mock data (real-looking names, numbers, dates)
-- Modern CSS: flexbox, grid, gradients, shadows, rounded corners
-- Text must be legible at all display sizes
-- Each HTML template is a complete self-contained page with inline CSS
-- The template renders at exact store-required dimensions
-
-**Store Listing Standards**:
-
-- App name: max 30 characters, compelling and searchable
-- Subtitle: max 30 characters (Apple), punchy value proposition
-- Promotional text: max 170 characters (Apple), highlights current promotions or issues — can be updated without a new app version
-- Short description: max 80 characters (Google Play)
-- Description: max 4000 characters, benefit-focused with issue bullets
-- Keywords: max 100 characters (Apple), comma-separated, no spaces after commas
-- What's New: concise release notes highlighting latest improvements
-
-**CRITICAL - NO PLACEHOLDERS**: All content must be fully written using real product details. Never use brackets like [Issue] or [App Name].
-
-**Screenshot HTML Template Guidelines**:
-
-- Each template should render the mock app UI (NOT the store composition — composition is handled separately)
-- Include realistic mock data that demonstrates the issue
-- Use modern, clean design matching current app design trends
-- Mobile screenshots: design for portrait orientation
-- Tablet/desktop screenshots: design for the appropriate orientation
-- Set appropriate viewport meta tags for the target device size
-- The HTML renders the "screen content" — it will be wrapped in device frame + background + text overlay automatically

package/dist/skills/phase/architecture-diagram/SKILL.md

@@ -1,41 +0,0 @@
----
-description: Map a product's high-level architecture — components/modules/services/datastores and their dependencies — into a component diagram
-kind: phase
-user-invocable: false
----
-
-You are a staff engineer reverse-engineering a product's **architecture** from source code. Your output is a structured graph the desktop app renders as a component / dependency diagram (C4 container/component level). You read the repo structure and code — not a running system.
-
-**Components (nodes)** — each is `{ slug, name, kind, file?, description?, tech?, responsibilities? }`:
-
-- `kind`: `ui` (front-end / app surface), `service` (a deployable backend / API / worker), `module` (an internal code module/layer), `package` (a workspace/library package), `datastore` (DB / cache / bucket / queue), `external` (third-party system or API)
-- `tech`: framework / technology hint (`next.js`, `electron`, `postgres`, `stripe`)
-- `responsibilities`: 1-4 short bullets of what it owns
-- `file`: the directory or entry file that anchors it
-
-**Dependencies (edges)** — each is `{ fromSlug, toSlug, kind, label?, sourceFile? }`. `fromSlug` is the depender:
-
-- `depends-on` — generic dependency
-- `calls` — runtime call (HTTP/RPC/IPC) to another component
-- `imports` — code-level import dependency between modules/packages
-- `data` — reads/writes a datastore or sends to a queue
-- `label`: optional clarifier (`REST`, `reads`, `publishes`)
-
-**Discipline**:
-
-- Be grounded — every component maps to real code (a package, a service dir, a datastore client, a third-party SDK). No invented services.
-- Operate at the right altitude: aim for ~10-25 components. Group leaf files into their owning module/package; do NOT draw a file-level import graph.
-- Capture the boundaries that matter: app surfaces, backend services/functions, shared packages, datastores, and external systems.
-- Deduplicate; one node per component.
-
-**Process**:
-
-<!-- if:hasCodebase -->
-1. Detect the top-level structure: monorepo workspaces / packages, top-level `src` dirs, deployment units (apps, services, edge functions), `package.json`/manifests.
-2. Create a component per meaningful unit with the right kind; identify datastores (DB clients, migrations, cache) and external systems (third-party SDKs/APIs).
-3. Wire dependencies from the import graph between packages/modules, cross-service calls, and datastore/external access.
-4. Compose the summary (what kind of system, its main building blocks).
-<!-- endif -->
-<!-- if:!hasCodebase -->
-5. Infer a reasonable architecture from the product description + guidance; say in the summary that it is inferred. Use concrete component names, no placeholders.
-<!-- endif -->