@skyramp/mcp 0.2.1 → 0.2.3

package/build/utils/uiPageEnumerator.js

@@ -29,7 +29,9 @@
  */
 import * as fs from "fs";
 import * as path from "path";
+import { extractDartRoutes } from "./dartRouteExtractor.js";
 import { extractSourceRoutes } from "./sourceRouteExtractor.js";
+import { hasFlutterSdkDep } from "../prompts/test-recommendation/scopeAssessment.js";
 import { readWorkspaceConfigRaw } from "./workspaceAuth.js";
 // ── Strategy 1: framework route grep ────────────────────────────────────────
 /**
@@ -228,6 +230,68 @@ export function findCandidatePagesBySourceRoute(frontendFiles, baseUrl, reposito
     }
     return Array.from(byUrl.values());
 }
+// ── Strategy 2.5: Dart GoRouter routes ─────────────────────────────────────
+/**
+ * Strategy 2.5: walk the repo's Dart files for GoRoute(path: '...') calls.
+ * Gated on `hasFlutterSdkDep(repoPath)` so non-Flutter Dart projects (e.g.
+ * shelf_router servers) don't accidentally emit URLs.
+ *
+ * Diff-matching: each GoRoute references its screen widget via
+ * `builder:`/`pageBuilder:` (e.g. `AuthorsScreen`). The extractor resolves
+ * those identifiers through the route file's imports to absolute screen
+ * file paths. We surface only routes whose screen file appears in the
+ * changed-file list. Falls back to all-routes when no route's screen
+ * file matches — preserves coverage for "router untouched, screen edited"
+ * cases when the import-resolution heuristic doesn't find a match.
+ *
+ * Filters applied:
+ *   1. Drop redirect-only routes (`redirect:` with no `builder:`/`pageBuilder:`).
+ *      These have no UI to render — navigating there is wasted work.
+ *   2. Drop nested relative children (paths that don't start with `/`).
+ *      Without parent-path composition the URL is meaningless.
+ *
+ * Returns empty when the repo isn't Flutter or no GoRoute calls are
+ * found — caller falls through to root-fallback.
+ */
+export function findCandidatePagesByDartRoute(repositoryPath, baseUrl, frontendFiles) {
+    if (!hasFlutterSdkDep(repositoryPath))
+        return [];
+    const dartRoutes = extractDartRoutes(repositoryPath);
+    if (dartRoutes.length === 0)
+        return [];
+    // Strip redirect-only and relative routes — they're never valid candidates.
+    const renderable = dartRoutes.filter((r) => !r.isRedirectOnly && r.path.startsWith("/"));
+    if (renderable.length === 0)
+        return [];
+    // Diff-match each route against frontendFiles via its screenFiles.
+    const changedAbs = new Set(frontendFiles.map((f) => path.resolve(repositoryPath, f)));
+    const matched = renderable.filter((r) => r.screenFiles.some((sf) => changedAbs.has(sf)));
+    // Fall back to all renderable routes when nothing diff-matches. The
+    // import-resolution heuristic isn't perfect (custom widget naming, multiple
+    // screens per file, factory functions); a zero-match should not collapse
+    // the candidate list to empty when the repo clearly has UI changes.
+    const surfaced = matched.length > 0 ? matched : renderable;
+    const normalizedBase = baseUrl.replace(/\/$/, "");
+    const byUrl = new Map();
+    for (const route of surfaced) {
+        const fullUrl = normalizedBase + route.path;
+        const sourceFile = path.relative(repositoryPath, route.declaredIn);
+        const existing = byUrl.get(fullUrl);
+        if (existing) {
+            if (!existing.sourcedFrom.includes(sourceFile)) {
+                existing.sourcedFrom.push(sourceFile);
+            }
+        }
+        else {
+            byUrl.set(fullUrl, {
+                url: fullUrl,
+                sourcedFrom: [sourceFile],
+                strategy: "dart-go-router",
+            });
+        }
+    }
+    return Array.from(byUrl.values());
+}
 // ── Strategy 3: root fallback ───────────────────────────────────────────────
 /**
  * Strategy 3: when strategies 1+2 yield nothing, fall back to the workspace's
@@ -314,6 +378,9 @@ export async function enumerateCandidateUiPages(repositoryPath, frontendFiles) {
     const fromSource = findCandidatePagesBySourceRoute(frontendFiles, baseUrl, repositoryPath);
     if (fromSource.length > 0)
         return fromSource;
+    const fromDart = findCandidatePagesByDartRoute(repositoryPath, baseUrl, frontendFiles);
+    if (fromDart.length > 0)
+        return fromDart;
     const fallback = await findRootFallbackPage(repositoryPath);
     return fallback ? [fallback] : [];
 }

package/build/utils/uiPageEnumerator.test.js

@@ -240,6 +240,48 @@ describe("pickFrontendBaseUrl", () => {
         });
         expect(await pickFrontendBaseUrl("/repo")).toBe("http://localhost:8000");
     });
+    // Flutter support — the load-bearing assumption from the Confluence plan.
+    // init_workspace writes a single service with framework: playwright for a
+    // Flutter web app. Heuristic 1 must match by serviceName suffix
+    // (e.g. "birdle-frontend") because Heuristic 2 only knows JS/TS frontend
+    // frameworks. Without this, the agent never reaches the browser regardless
+    // of the .dart classifier fix.
+    it("picks the Flutter playwright-framework service by name suffix", async () => {
+        readSpy.mockResolvedValue({
+            services: [
+                {
+                    serviceName: "birdle-frontend",
+                    language: "typescript",
+                    framework: "playwright",
+                    api: { baseUrl: "http://localhost:8080" },
+                },
+            ],
+        });
+        expect(await pickFrontendBaseUrl("/repo")).toBe("http://localhost:8080");
+    });
+    // Edge case: Flutter service has no "frontend"/"ui"/"app"/"web" suffix
+    // (so H1 misses) and `framework: playwright` isn't in H2's TS/JS framework
+    // allow-list. The chosen URL must come from H3 (first service with baseUrl).
+    // We add a second service to prove H3 picked the first, not H1 by accident.
+    it("falls back to first service when name+framework don't match H1 or H2", async () => {
+        readSpy.mockResolvedValue({
+            services: [
+                {
+                    serviceName: "birdle",
+                    language: "typescript",
+                    framework: "playwright",
+                    api: { baseUrl: "http://localhost:8080" },
+                },
+                {
+                    serviceName: "other-service",
+                    language: "go",
+                    framework: "gin",
+                    api: { baseUrl: "http://localhost:9000" },
+                },
+            ],
+        });
+        expect(await pickFrontendBaseUrl("/repo")).toBe("http://localhost:8080");
+    });
 });
 // ---------------------------------------------------------------------------
 // findRootFallbackPage
@@ -375,6 +417,186 @@ export default function App() { return <Routes><Route path="/cart" element={<Car
         });
         fs.rmSync(repo, { recursive: true, force: true });
     });
+    // Flutter end-to-end: pubspec.yaml declares the Flutter SDK, .dart files
+    // appear in the diff (passed in by callers after isFrontendFile filtering),
+    // workspace.yml has a baseUrl. Strategies 1, 2, and 2.5 don't match
+    // (no framework config; TS extractor doesn't see .dart; no GoRoute calls).
+    // Result: root-fallback with the workspace baseUrl.
+    it("returns root-fallback for a Flutter repo with no GoRoute declarations", async () => {
+        readSpy.mockResolvedValue({
+            services: [
+                {
+                    serviceName: "birdle-frontend",
+                    framework: "playwright",
+                    api: { baseUrl: "http://localhost:8080" },
+                },
+            ],
+        });
+        const repo = fs.mkdtempSync(path.join(os.tmpdir(), "skyramp-flutter-enum-"));
+        fs.writeFileSync(path.join(repo, "pubspec.yaml"), "name: birdle\ndependencies:\n  flutter:\n    sdk: flutter\n");
+        fs.mkdirSync(path.join(repo, "lib"), { recursive: true });
+        fs.writeFileSync(path.join(repo, "lib", "main.dart"), "void main() => runApp(MyApp());");
+        const pages = await enumerateCandidateUiPages(repo, ["lib/main.dart"]);
+        expect(pages).toHaveLength(1);
+        expect(pages[0]).toMatchObject({
+            url: "http://localhost:8080",
+            strategy: "root-fallback",
+        });
+        fs.rmSync(repo, { recursive: true, force: true });
+    });
+    // Strategy 2.5: Flutter repo with GoRouter declarations and no diff-match
+    // (frontendFiles names a screen file that's not imported by the router)
+    // surfaces every absolute route as a candidate URL via the all-routes
+    // fallback. Diff-match narrowing is exercised by the next test.
+    it("returns dart-go-router URLs for a Flutter repo with GoRoute declarations", async () => {
+        readSpy.mockResolvedValue({
+            services: [
+                {
+                    serviceName: "books-frontend",
+                    framework: "playwright",
+                    api: { baseUrl: "http://localhost:8080" },
+                },
+            ],
+        });
+        const repo = fs.mkdtempSync(path.join(os.tmpdir(), "skyramp-go-router-"));
+        fs.writeFileSync(path.join(repo, "pubspec.yaml"), "name: books\ndependencies:\n  flutter:\n    sdk: flutter\n  go_router: ^14.0.0\n");
+        fs.mkdirSync(path.join(repo, "lib"), { recursive: true });
+        fs.writeFileSync(path.join(repo, "lib", "main.dart"), `
+final router = GoRouter(routes: [
+  GoRoute(path: '/signin', builder: (c, s) => SignIn()),
+  GoRoute(path: '/authors', builder: (c, s) => Authors()),
+  GoRoute(path: '/settings', builder: (c, s) => Settings()),
+]);
+`);
+        const pages = await enumerateCandidateUiPages(repo, ["lib/screens/authors.dart"]);
+        const urls = pages.map((p) => p.url).sort();
+        expect(urls).toEqual([
+            "http://localhost:8080/authors",
+            "http://localhost:8080/settings",
+            "http://localhost:8080/signin",
+        ]);
+        expect(pages.every((p) => p.strategy === "dart-go-router")).toBe(true);
+        fs.rmSync(repo, { recursive: true, force: true });
+    });
+    // Diff-matching: Strategy 2.5 should narrow candidate URLs to only those
+    // whose screen file is in frontendFiles. The fixture has 3 routes; only
+    // /authors's screen file (lib/src/screens/authors.dart) is in the diff.
+    it("narrows GoRouter candidates to routes whose screen file is in the diff", async () => {
+        readSpy.mockResolvedValue({
+            services: [
+                {
+                    serviceName: "books-frontend",
+                    framework: "playwright",
+                    api: { baseUrl: "http://localhost:8080" },
+                },
+            ],
+        });
+        const repo = fs.mkdtempSync(path.join(os.tmpdir(), "skyramp-go-router-diff-"));
+        fs.writeFileSync(path.join(repo, "pubspec.yaml"), "name: books\ndependencies:\n  flutter:\n    sdk: flutter\n");
+        fs.mkdirSync(path.join(repo, "lib", "src", "screens"), { recursive: true });
+        fs.writeFileSync(path.join(repo, "lib", "main.dart"), `
+import 'src/screens/authors.dart';
+import 'src/screens/settings.dart';
+import 'src/screens/sign_in.dart';
+
+final router = GoRouter(routes: [
+  GoRoute(path: '/sign_in', builder: (c, s) => SignInScreen()),
+  GoRoute(path: '/authors', builder: (c, s) => AuthorsScreen()),
+  GoRoute(path: '/settings', builder: (c, s) => SettingsScreen()),
+]);
+`);
+        fs.writeFileSync(path.join(repo, "lib", "src", "screens", "authors.dart"), "// authors");
+        fs.writeFileSync(path.join(repo, "lib", "src", "screens", "settings.dart"), "// settings");
+        fs.writeFileSync(path.join(repo, "lib", "src", "screens", "sign_in.dart"), "// signin");
+        const pages = await enumerateCandidateUiPages(repo, ["lib/src/screens/authors.dart"]);
+        const urls = pages.map((p) => p.url).sort();
+        // Only /authors should surface — its screen file is the only one in the diff.
+        expect(urls).toEqual(["http://localhost:8080/authors"]);
+        fs.rmSync(repo, { recursive: true, force: true });
+    });
+    // Redirect-only routes (`redirect:` with no builder) must not surface — they
+    // have no UI to navigate to. Same fixture shape but the only diff-matching
+    // route is redirect-only, so we should fall back to the non-redirect-only
+    // routes.
+    it("filters out redirect-only GoRoutes", async () => {
+        readSpy.mockResolvedValue({
+            services: [
+                {
+                    serviceName: "frontend",
+                    framework: "playwright",
+                    api: { baseUrl: "http://localhost:8080" },
+                },
+            ],
+        });
+        const repo = fs.mkdtempSync(path.join(os.tmpdir(), "skyramp-go-router-redirect-"));
+        fs.writeFileSync(path.join(repo, "pubspec.yaml"), "name: app\ndependencies:\n  flutter:\n    sdk: flutter\n");
+        fs.mkdirSync(path.join(repo, "lib"), { recursive: true });
+        fs.writeFileSync(path.join(repo, "lib", "main.dart"), `
+final router = GoRouter(routes: [
+  GoRoute(path: '/', redirect: (_, _) => '/home'),
+  GoRoute(path: '/home', builder: (c, s) => Home()),
+]);
+`);
+        const pages = await enumerateCandidateUiPages(repo, ["lib/main.dart"]);
+        const urls = pages.map((p) => p.url).sort();
+        // / is redirect-only — must not appear. Only /home is renderable.
+        expect(urls).toEqual(["http://localhost:8080/home"]);
+        fs.rmSync(repo, { recursive: true, force: true });
+    });
+    // Fallback path: when no route's screen file matches the diff (e.g. router
+    // file edited but our import-resolution heuristic missed the screen), surface
+    // ALL renderable routes rather than collapsing to empty.
+    it("falls back to all renderable routes when no screen file matches the diff", async () => {
+        readSpy.mockResolvedValue({
+            services: [
+                {
+                    serviceName: "frontend",
+                    framework: "playwright",
+                    api: { baseUrl: "http://localhost:8080" },
+                },
+            ],
+        });
+        const repo = fs.mkdtempSync(path.join(os.tmpdir(), "skyramp-go-router-fallback-"));
+        fs.writeFileSync(path.join(repo, "pubspec.yaml"), "name: app\ndependencies:\n  flutter:\n    sdk: flutter\n");
+        fs.mkdirSync(path.join(repo, "lib"), { recursive: true });
+        fs.writeFileSync(path.join(repo, "lib", "main.dart"), `
+final router = GoRouter(routes: [
+  GoRoute(path: '/foo', builder: (c, s) => FooScreen()),
+  GoRoute(path: '/bar', builder: (c, s) => BarScreen()),
+]);
+`);
+        // Diff touches only main.dart (the router itself, not any screen). The
+        // import-resolution heuristic finds zero matches against frontendFiles, so
+        // we surface all renderable routes.
+        const pages = await enumerateCandidateUiPages(repo, ["lib/main.dart"]);
+        const urls = pages.map((p) => p.url).sort();
+        expect(urls).toEqual([
+            "http://localhost:8080/bar",
+            "http://localhost:8080/foo",
+        ]);
+        fs.rmSync(repo, { recursive: true, force: true });
+    });
+    // Negative gate: pure-Dart server with a `GoRoute(`-shaped string in source
+    // (e.g. shelf_router uses similar names in tests) must NOT trigger Strategy
+    // 2.5 — pubspec.yaml lacks `sdk: flutter`, hasFlutterSdkDep returns false.
+    it("does not invoke Dart extractor when pubspec.yaml lacks sdk: flutter", async () => {
+        readSpy.mockResolvedValue({
+            services: [
+                {
+                    serviceName: "server-frontend",
+                    framework: "playwright",
+                    api: { baseUrl: "http://localhost:8080" },
+                },
+            ],
+        });
+        const repo = fs.mkdtempSync(path.join(os.tmpdir(), "skyramp-dart-server-"));
+        fs.writeFileSync(path.join(repo, "pubspec.yaml"), "name: server\ndependencies:\n  shelf: ^1.0.0\n");
+        fs.mkdirSync(path.join(repo, "lib"), { recursive: true });
+        fs.writeFileSync(path.join(repo, "lib", "routes.dart"), `GoRoute(path: '/api/v1', handler: (req) => Response.ok(''))`);
+        const pages = await enumerateCandidateUiPages(repo, ["lib/routes.dart"]);
+        expect(pages.map((p) => p.strategy)).toEqual(["root-fallback"]);
+        fs.rmSync(repo, { recursive: true, force: true });
+    });
 });
 // ---------------------------------------------------------------------------
 // detectsFilesystemRouting

package/node_modules/playwright/lib/mcp/skyramp/common/mouseActions.js

@@ -0,0 +1,123 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var mouseActions_exports = {};
+__export(mouseActions_exports, {
+  DEFAULT_DRAG_STEPS: () => DEFAULT_DRAG_STEPS,
+  decodeModifierKeys: () => decodeModifierKeys,
+  decomposeDrag: () => decomposeDrag,
+  mouseActionToJsonl: () => mouseActionToJsonl,
+  mouseJsonlToCode: () => mouseJsonlToCode
+});
+module.exports = __toCommonJS(mouseActions_exports);
+const DEFAULT_DRAG_STEPS = 10;
+function decodeModifierKeys(mask, platform = typeof process !== "undefined" ? process.platform : "linux") {
+  if (!mask)
+    return [];
+  const keys = [];
+  if (mask & 1) keys.push("Alt");
+  if ((mask & 6) === 6) {
+    keys.push(platform === "darwin" ? "Meta" : "Control");
+  } else {
+    if (mask & 2) keys.push("Control");
+    if (mask & 4) keys.push("Meta");
+  }
+  if (mask & 8) keys.push("Shift");
+  return keys;
+}
+function decomposeDrag(start, end, steps = DEFAULT_DRAG_STEPS) {
+  return [
+    { name: "mouse.move", position: start },
+    { name: "mouse.down" },
+    { name: "mouse.move", position: end, steps },
+    { name: "mouse.up" }
+  ];
+}
+function mouseActionToJsonl(params) {
+  const button = params.button ?? "left";
+  const modifiers = params.modifiers ?? 0;
+  switch (params.action) {
+    case "move": {
+      if (params.x === void 0 || params.y === void 0)
+        return { error: 'mouse action "move" requires x and y.' };
+      const move = params.steps !== void 0 ? { name: "mouse.move", position: { x: params.x, y: params.y }, steps: params.steps } : { name: "mouse.move", position: { x: params.x, y: params.y } };
+      return { actions: [move] };
+    }
+    case "down":
+      return { actions: [button === "left" ? { name: "mouse.down" } : { name: "mouse.down", button }] };
+    case "up":
+      return { actions: [button === "left" ? { name: "mouse.up" } : { name: "mouse.up", button }] };
+    case "wheel": {
+      if (params.deltaX === void 0 && params.deltaY === void 0)
+        return { error: 'mouse action "wheel" requires deltaX and/or deltaY.' };
+      if (params.x === void 0 || params.y === void 0)
+        return { error: 'mouse action "wheel" requires x and y (the scroll target) so the pointer is moved there before scrolling.' };
+      const position = { x: params.x, y: params.y };
+      return { actions: [
+        { name: "mouse.move", position },
+        { name: "mouse.wheel", position, deltaX: params.deltaX ?? 0, deltaY: params.deltaY ?? 0, modifiers }
+      ] };
+    }
+    case "click": {
+      if (params.x === void 0 || params.y === void 0)
+        return { error: 'mouse action "click" requires x and y.' };
+      return { actions: [{ name: "click", selector: "body", position: { x: params.x, y: params.y }, button, modifiers, clickCount: params.clickCount ?? 1 }] };
+    }
+    case "drag": {
+      if (params.x === void 0 || params.y === void 0 || params.endX === void 0 || params.endY === void 0)
+        return { error: 'mouse action "drag" requires x, y, endX and endY.' };
+      return { actions: decomposeDrag({ x: params.x, y: params.y }, { x: params.endX, y: params.endY }, params.steps) };
+    }
+    default:
+      return { error: `Unknown mouse action: ${params.action}` };
+  }
+}
+function mouseJsonlToCode(a) {
+  switch (a.name) {
+    case "mouse.move":
+      return [a.steps !== void 0 ? `await page.mouse.move(${a.position.x}, ${a.position.y}, { steps: ${a.steps} });` : `await page.mouse.move(${a.position.x}, ${a.position.y});`];
+    case "mouse.down":
+      return [a.button && a.button !== "left" ? `await page.mouse.down({ button: '${a.button}' });` : `await page.mouse.down();`];
+    case "mouse.up":
+      return [a.button && a.button !== "left" ? `await page.mouse.up({ button: '${a.button}' });` : `await page.mouse.up();`];
+    case "mouse.wheel":
+      return withModifierLines(a.modifiers, `await page.mouse.wheel(${a.deltaX}, ${a.deltaY});`);
+    case "click": {
+      const opts = a.button !== "left" || a.clickCount !== 1 ? `, { button: '${a.button}', clickCount: ${a.clickCount} }` : "";
+      return withModifierLines(a.modifiers, `await page.mouse.click(${a.position.x}, ${a.position.y}${opts});`);
+    }
+  }
+}
+function withModifierLines(mask, line) {
+  const keys = decodeModifierKeys(mask);
+  if (!keys.length)
+    return [line];
+  return [
+    ...keys.map((k) => `await page.keyboard.down('${k}');`),
+    line,
+    ...[...keys].reverse().map((k) => `await page.keyboard.up('${k}');`)
+  ];
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_DRAG_STEPS,
+  decodeModifierKeys,
+  decomposeDrag,
+  mouseActionToJsonl,
+  mouseJsonlToCode
+});

package/node_modules/playwright/lib/mcp/skyramp/index.js

@@ -20,17 +20,27 @@ var skyramp_exports = {};
 __export(skyramp_exports, {
   ARGS_ONLY_TOOLS: () => import_types.ARGS_ONLY_TOOLS,
   TraceRecordingBackend: () => import_traceRecordingBackend.TraceRecordingBackend,
+  actionsFromPath: () => import_skyRampImport.actionsFromPath,
   buildJsonlContent: () => import_skyRampExport.buildJsonlContent,
+  loadTraceMcpTool: () => import_loadTraceTool.loadTraceMcpTool,
+  loadTraceSchema: () => import_loadTraceTool.loadTraceSchema,
+  parseJsonl: () => import_skyRampImport.parseJsonl,
   writeSkyrampZip: () => import_skyRampExport.writeSkyrampZip
 });
 module.exports = __toCommonJS(skyramp_exports);
 var import_traceRecordingBackend = require("./traceRecordingBackend");
 var import_types = require("./types");
 var import_skyRampExport = require("../test/skyRampExport");
+var import_loadTraceTool = require("./loadTraceTool");
+var import_skyRampImport = require("./skyRampImport");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ARGS_ONLY_TOOLS,
   TraceRecordingBackend,
+  actionsFromPath,
   buildJsonlContent,
+  loadTraceMcpTool,
+  loadTraceSchema,
+  parseJsonl,
   writeSkyrampZip
 });