codeloop-mcp-server 0.1.9 → 0.1.11

package/dist/index.js

@@ -44,7 +44,7 @@ const config = loadConfig(projectDir);
 const apiKey = process.env.CODELOOP_API_KEY || config.api_key;
 const server = new McpServer({
     name: "codeloop",
-    version: "0.1.5",
+    version: "0.1.10",
 });
 async function withAuth(fn) {
     const result = await validateApiKey(apiKey);
@@ -867,6 +867,31 @@ The agent MUST then write the report to docs/DEVELOPMENT_LOG.md and present it t
                 }
             }
         }
+        // Parse interaction_log.jsonl from each run for the interaction history
+        const interactionHistory = [];
+        const interactionSummary = { total: 0, succeeded: 0, failed: 0, actions: {}, console_errors: 0 };
+        for (const runId of runs) {
+            const runDir = getRunDir(runId, baseDir);
+            const iLogPath = join(runDir, "logs", "interaction_log.jsonl");
+            if (existsSync(iLogPath)) {
+                const lines = readFileSync(iLogPath, "utf-8").trim().split("\n").filter(l => l.length > 0);
+                for (const line of lines) {
+                    try {
+                        const entry = JSON.parse(line);
+                        interactionHistory.push({ run_id: runId, ...entry });
+                        interactionSummary.total++;
+                        if (entry.success)
+                            interactionSummary.succeeded++;
+                        else
+                            interactionSummary.failed++;
+                        interactionSummary.actions[entry.action] = (interactionSummary.actions[entry.action] || 0) + 1;
+                        if (entry.console_errors?.length)
+                            interactionSummary.console_errors += entry.console_errors.length;
+                    }
+                    catch { /* skip malformed lines */ }
+                }
+            }
+        }
         // Check for interaction replay results
         const replayDir = join(baseDir, "replay_frames");
         const hasReplayFrames = existsSync(replayDir) && readdirSync(replayDir).length > 0;
@@ -888,6 +913,8 @@ The agent MUST then write the report to docs/DEVELOPMENT_LOG.md and present it t
             log_files: logFiles,
             errors_found_in_logs: errorsFound,
             interaction_replay_performed: hasReplayFrames,
+            interaction_summary: interactionSummary,
+            interaction_history: interactionHistory.slice(-50),
             run_timeline: runSummaries,
         };
         await trackUsage(apiKey, "verification_run");
@@ -936,6 +963,10 @@ For EACH video recording session, document:
 - What issues were found in the extracted frames
 - How those issues were fixed
 - Which OS and interaction method was used (osascript, Playwright, adb, xdotool, PowerShell)
+- Interaction summary: ${report.interaction_summary?.total || 0} total interactions (${report.interaction_summary?.succeeded || 0} succeeded, ${report.interaction_summary?.failed || 0} failed)
+- Action breakdown: ${JSON.stringify(report.interaction_summary?.actions || {})}
+- Browser console errors captured during interactions: ${report.interaction_summary?.console_errors || 0}
+- Include a table of key interactions with their input args, success/failure, and any console errors
 
 **6. Quality Gates Passed**
 - Build passes
@@ -1033,6 +1064,46 @@ Returns: checklist of completed and pending verification steps.`, {
         }
         const gateIsPassing = hasGateCheck && latestMeta?.gate_result === "passed";
         const gateConfidence = latestMeta?.confidence ?? 0;
+        // Interaction coverage: compare interaction_log selectors/URLs against discover_screens
+        let interactionCount = 0;
+        const coveredRoutes = new Set();
+        let discoveredRoutes = [];
+        let uncoveredRoutes = [];
+        if (isUIProject) {
+            try {
+                const { readFileSync: rfs } = await import("fs");
+                // Collect all interaction entries across runs
+                for (const rid of runs) {
+                    const runDir = getRunDir(rid, baseDir);
+                    const iLogPath = join(runDir, "logs", "interaction_log.jsonl");
+                    if (existsSync(iLogPath)) {
+                        const lines = rfs(iLogPath, "utf-8").trim().split("\n").filter(l => l.length > 0);
+                        for (const line of lines) {
+                            try {
+                                const entry = JSON.parse(line);
+                                interactionCount++;
+                                const args = entry.input_args || {};
+                                if (args.url)
+                                    coveredRoutes.add(new URL(args.url, "http://localhost").pathname);
+                                if (args.selector)
+                                    coveredRoutes.add(args.selector);
+                                if (entry.action === "navigate_url" && args.url)
+                                    coveredRoutes.add(args.url);
+                            }
+                            catch { /* skip malformed lines */ }
+                        }
+                    }
+                }
+                // Compare against discover_screens
+                const { discoverScreens } = await import("./tools/discover_screens.js");
+                const screenResult = discoverScreens(cwd, platform);
+                discoveredRoutes = screenResult.screens.map(s => s.route);
+                uncoveredRoutes = discoveredRoutes.filter(route => {
+                    return !coveredRoutes.has(route) && ![...coveredRoutes].some(c => c.includes(route) || route.includes(c));
+                });
+            }
+            catch { /* best-effort coverage check */ }
+        }
         const steps = [
             {
                 step: "1. codeloop_verify",
@@ -1075,6 +1146,23 @@ Returns: checklist of completed and pending verification steps.`, {
                     ? "docs/DEVELOPMENT_LOG.md exists"
                     : "No development log found. Call codeloop_generate_dev_report and write docs/DEVELOPMENT_LOG.md.",
             },
+            {
+                step: "6. Interaction coverage",
+                status: !isUIProject
+                    ? "n/a"
+                    : discoveredRoutes.length === 0
+                        ? "n/a"
+                        : uncoveredRoutes.length === 0
+                            ? "done"
+                            : "PENDING",
+                detail: !isUIProject
+                    ? "Not a UI project — interaction coverage not applicable"
+                    : discoveredRoutes.length === 0
+                        ? "No screens discovered from source code (run codeloop_discover_screens first)"
+                        : uncoveredRoutes.length === 0
+                            ? `All ${discoveredRoutes.length} discovered routes covered by ${interactionCount} interactions`
+                            : `${uncoveredRoutes.length} of ${discoveredRoutes.length} routes NOT covered by interactions. Uncovered: ${uncoveredRoutes.join(", ")}. Navigate to these routes and interact with their elements.`,
+            },
         ];
         const pendingSteps = steps.filter(s => s.status === "PENDING" || s.status === "NEEDS_RERUN");
         const allDone = pendingSteps.length === 0;
@@ -1207,7 +1295,13 @@ Wait 1-2 seconds between interactions so video frames capture state changes.`, {
                     success = await wm.simctlTap(params.x, params.y);
                 }
                 else if (params.selector) {
-                    success = await wm.clickElementInBrowser(params.selector);
+                    if (process.platform === "win32") {
+                        const wa = await import("./runners/win_accessibility.js");
+                        success = await wa.automateElement(params.app_name || "", params.selector, "invoke");
+                    }
+                    else {
+                        success = await wm.clickElementInBrowser(params.selector);
+                    }
                 }
                 else if (params.x != null && params.y != null) {
                     success = await wm.clickAtPosition(params.x, params.y);
@@ -1270,6 +1364,21 @@ Wait 1-2 seconds between interactions so video frames capture state changes.`, {
                         };
                         success = await wm.adbKey(adbKeyMap[params.key.toLowerCase()] || `KEYCODE_${params.key.toUpperCase()}`);
                     }
+                    else if (tt === "ios_simulator") {
+                        const simKeyMap = {
+                            enter: "return", tab: "tab", escape: "escape", backspace: "delete",
+                            delete: "forwardDelete", up: "up-arrow", down: "down-arrow",
+                            left: "left-arrow", right: "right-arrow", space: "space",
+                            home: "home", end: "end",
+                        };
+                        const mapped = simKeyMap[params.key.toLowerCase()];
+                        if (mapped) {
+                            success = await wm.simctlKey(mapped);
+                        }
+                        else {
+                            success = await wm.simctlType(params.key);
+                        }
+                    }
                     else {
                         success = await wm.sendKeyByName(params.key);
                     }
@@ -1298,6 +1407,14 @@ Wait 1-2 seconds between interactions so video frames capture state changes.`, {
                     const ex = dir === "left" ? sx + 600 : dir === "right" ? sx - 600 : sx;
                     success = await wm.adbSwipe(sx, sy, ex, ey, 300);
                 }
+                else if (tt === "ios_simulator") {
+                    const dir = params.direction || "down";
+                    const sx = params.x || 195, sy = params.y || 420;
+                    const dist = params.amount || 300;
+                    const ey = dir === "down" ? sy - dist : dir === "up" ? sy + dist : sy;
+                    const ex = dir === "left" ? sx + dist : dir === "right" ? sx - dist : sx;
+                    success = await wm.simctlSwipe(sx, sy, ex, ey);
+                }
                 else {
                     success = await wm.scrollAtPosition(params.x || 500, params.y || 400, params.direction || "down", params.amount || 3);
                 }
@@ -1358,15 +1475,30 @@ Wait 1-2 seconds between interactions so video frames capture state changes.`, {
                 }
                 else if (params.fields) {
                     let allOk = true;
-                    for (const field of params.fields) {
-                        const filled = await wm.fillFieldInBrowser(field.selector, field.value);
-                        if (!filled)
-                            allOk = false;
-                        await new Promise(r => setTimeout(r, 300));
+                    if (process.platform === "win32") {
+                        const wa = await import("./runners/win_accessibility.js");
+                        for (const field of params.fields) {
+                            const filled = await wa.automateElement(params.app_name || "", field.selector, "setValue", field.value);
+                            if (!filled)
+                                allOk = false;
+                            await new Promise(r => setTimeout(r, 300));
+                        }
+                        if (params.submit_selector) {
+                            await new Promise(r => setTimeout(r, 500));
+                            await wa.automateElement(params.app_name || "", params.submit_selector, "invoke");
+                        }
                     }
-                    if (params.submit_selector) {
-                        await new Promise(r => setTimeout(r, 500));
-                        await wm.clickElementInBrowser(params.submit_selector);
+                    else {
+                        for (const field of params.fields) {
+                            const filled = await wm.fillFieldInBrowser(field.selector, field.value);
+                            if (!filled)
+                                allOk = false;
+                            await new Promise(r => setTimeout(r, 300));
+                        }
+                        if (params.submit_selector) {
+                            await new Promise(r => setTimeout(r, 500));
+                            await wm.clickElementInBrowser(params.submit_selector);
+                        }
                     }
                     success = allOk;
                 }
@@ -1419,7 +1551,8 @@ Wait 1-2 seconds between interactions so video frames capture state changes.`, {
                     success = await bi.browserGoBack();
                 }
                 else {
-                    success = await wm.sendHotkey("cmd+[");
+                    const backKey = process.platform === "darwin" ? "cmd+[" : "alt+left";
+                    success = await wm.sendHotkey(backKey);
                 }
                 detail = "navigate_back";
                 break;
@@ -1427,6 +1560,10 @@ Wait 1-2 seconds between interactions so video frames capture state changes.`, {
                 if (tt === "browser") {
                     success = await bi.browserGoForward();
                 }
+                else {
+                    const fwdKey = process.platform === "darwin" ? "cmd+]" : "alt+right";
+                    success = await wm.sendHotkey(fwdKey);
+                }
                 detail = "navigate_forward";
                 break;
             case "wait":
@@ -1537,16 +1674,67 @@ Wait 1-2 seconds between interactions so video frames capture state changes.`, {
                 break;
             case "sequence":
                 if (params.steps) {
-                    const allOk = true;
+                    let allOk = true;
+                    const stepResults = [];
                     for (const step of params.steps) {
-                        const stepParams = { ...step.params, action: step.action, target_type: tt };
-                        // Recursive call handled by dispatching the same tool logic
-                        // For simplicity, just dispatch core actions inline
                         if (step.delay_ms)
                             await new Promise(r => setTimeout(r, step.delay_ms));
+                        const stepAction = step.action;
+                        const sp = (step.params || {});
+                        let stepOk = false;
+                        try {
+                            if (stepAction === "click" && tt === "browser" && sp.selector) {
+                                stepOk = await bi.browserClick(sp.selector);
+                            }
+                            else if (stepAction === "click" && sp.x != null && sp.y != null) {
+                                stepOk = await wm.clickAtPosition(sp.x, sp.y);
+                            }
+                            else if (stepAction === "type" && tt === "browser" && sp.selector && sp.text) {
+                                stepOk = await bi.browserType(sp.selector, sp.text);
+                            }
+                            else if (stepAction === "type" && sp.text) {
+                                stepOk = await wm.typeText(sp.text);
+                            }
+                            else if (stepAction === "fill_form" && tt === "browser" && sp.fields) {
+                                stepOk = await bi.browserFillForm(sp.fields, sp.submit_selector);
+                            }
+                            else if (stepAction === "navigate_url" && sp.url) {
+                                if (tt === "browser")
+                                    stepOk = await bi.browserNavigate(sp.url);
+                                else
+                                    stepOk = await wm.navigateDesktopBrowser(sp.url);
+                            }
+                            else if (stepAction === "hotkey" && sp.keys) {
+                                stepOk = tt === "browser" ? await bi.browserHotkey(sp.keys) : await wm.sendHotkey(sp.keys);
+                            }
+                            else if (stepAction === "keystroke" && sp.key) {
+                                stepOk = tt === "browser" ? await bi.browserKeystroke(sp.key) : await wm.sendKeyByName(sp.key);
+                            }
+                            else if (stepAction === "scroll") {
+                                stepOk = tt === "browser"
+                                    ? await bi.browserScroll(sp.direction || "down", sp.amount || 300)
+                                    : await wm.scrollAtPosition(sp.x || 500, sp.y || 400, sp.direction || "down", sp.amount || 3);
+                            }
+                            else if (stepAction === "wait") {
+                                await new Promise(r => setTimeout(r, sp.duration_ms || 1000));
+                                stepOk = true;
+                            }
+                            else if (stepAction === "hover" && tt === "browser" && sp.selector) {
+                                stepOk = await bi.browserHover(sp.selector);
+                            }
+                            else if (stepAction === "double_click" && tt === "browser" && sp.selector) {
+                                stepOk = await bi.browserDoubleClick(sp.selector);
+                            }
+                        }
+                        catch {
+                            stepOk = false;
+                        }
+                        stepResults.push({ action: stepAction, success: stepOk });
+                        if (!stepOk)
+                            allOk = false;
                     }
                     success = allOk;
-                    detail = `sequence (${params.steps.length} steps)`;
+                    detail = `sequence (${params.steps.length} steps, ${stepResults.filter(s => s.success).length} passed)`;
                 }
                 break;
             default:
@@ -1554,6 +1742,72 @@ Wait 1-2 seconds between interactions so video frames capture state changes.`, {
                 return { success: false, action, detail };
         }
         await trackUsage(apiKey, "interaction");
+        // Build structured input args for the log entry
+        const inputArgs = {};
+        if (params.selector)
+            inputArgs.selector = params.selector;
+        if (params.x != null)
+            inputArgs.x = params.x;
+        if (params.y != null)
+            inputArgs.y = params.y;
+        if (params.x2 != null)
+            inputArgs.x2 = params.x2;
+        if (params.y2 != null)
+            inputArgs.y2 = params.y2;
+        if (params.text)
+            inputArgs.text = params.text.substring(0, 200);
+        if (params.key)
+            inputArgs.key = params.key;
+        if (params.keys)
+            inputArgs.keys = params.keys;
+        if (params.url)
+            inputArgs.url = params.url;
+        if (params.value)
+            inputArgs.value = params.value;
+        if (params.direction)
+            inputArgs.direction = params.direction;
+        if (params.amount != null)
+            inputArgs.amount = params.amount;
+        if (params.fields)
+            inputArgs.field_count = params.fields.length;
+        if (params.submit_selector)
+            inputArgs.submit_selector = params.submit_selector;
+        if (params.duration_ms != null)
+            inputArgs.duration_ms = params.duration_ms;
+        if (params.steps)
+            inputArgs.step_count = params.steps.length;
+        if (params.app_name)
+            inputArgs.app_name = params.app_name;
+        // Drain browser console errors that occurred during this interaction
+        const consoleErrors = tt === "browser" ? bi.drainRecentConsoleErrors() : [];
+        // Log interaction result for post-recording analysis
+        const interactionEntry = {
+            timestamp: new Date().toISOString(),
+            action,
+            target_type: tt,
+            success,
+            detail,
+            input_args: inputArgs,
+        };
+        if (consoleErrors.length > 0)
+            interactionEntry.console_errors = consoleErrors;
+        try {
+            const activeIds = vr.getActiveRecordingIds();
+            if (activeIds.length > 0) {
+                const { appendFileSync, mkdirSync } = await import("fs");
+                const { dirname } = await import("path");
+                for (const rid of activeIds) {
+                    const logPath = vr.getActiveRecordingLogPath(rid);
+                    if (logPath) {
+                        const logDir = dirname(logPath);
+                        mkdirSync(logDir, { recursive: true });
+                        const logFile = `${logDir}/interaction_log.jsonl`;
+                        appendFileSync(logFile, JSON.stringify(interactionEntry) + "\n");
+                    }
+                }
+            }
+        }
+        catch { /* best-effort logging */ }
         return { success, action, detail };
     });
     return {