@skyramp/mcp 0.3.0-rc.1 → 0.3.0

package/build/utils/walkerCharacterization.test.js

@@ -0,0 +1,233 @@
+// Characterization tests for the SIX callers that were migrated onto the shared
+// walkDir/collectFiles primitives. These pin each caller's directory-walking
+// behavior (skip-dirs, dotfile skipping, depth caps, count caps, match
+// predicates, first-match, path normalization, best-effort) through real
+// filesystem fixtures, so the pre-refactor hand-rolled walkers and the
+// post-refactor walkDir-based ones are proven to behave identically.
+//
+// They deliberately exercise the PUBLIC entry points (plus the two
+// TestExecutionService helpers, exported for this purpose) rather than the
+// primitives — the primitives have their own unit tests in fileWalk.test.ts;
+// here we verify each caller wires the primitive up the same way it walked
+// before.
+import { jest } from "@jest/globals";
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+// TestExecutionService imports dockerode at module load; stub it so importing
+// the module needs no Docker daemon. Everything else uses the REAL fs.
+jest.unstable_mockModule("dockerode", () => ({
+    default: jest
+        .fn()
+        .mockImplementation(() => ({ run: jest.fn(), listImages: jest.fn() })),
+}));
+const { extractDartRoutes } = await import("./dartRouteExtractor.js");
+const { extractSourceRoutes } = await import("./sourceRouteExtractor.js");
+const { discoverTraceFiles, discoverPlaywrightZips } = await import("./trace-parser.js");
+const { checkFrontendFileIntegration } = await import("./frontendIntegration.js");
+const { collectVideoPath, findExcludedPaths } = await import("../services/TestExecutionService.js");
+/** Materialize a file tree under a fresh temp dir; values are file contents. */
+function makeTree(files) {
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), "walker-char-"));
+    for (const [rel, content] of Object.entries(files)) {
+        const abs = path.join(root, rel);
+        fs.mkdirSync(path.dirname(abs), { recursive: true });
+        fs.writeFileSync(abs, content);
+    }
+    return root;
+}
+function relSorted(root, abs) {
+    return abs
+        .map((p) => path.relative(root, p).replace(/\\/g, "/"))
+        .sort();
+}
+// ── dartRouteExtractor.findDartFiles ────────────────────────────────────────
+describe("extractDartRoutes — findDartFiles traversal", () => {
+    const GO_ROUTE = (p) => `GoRoute(path: '${p}', builder: (c, s) => Screen());`;
+    it("discovers .dart files in normal nested directories", () => {
+        const root = makeTree({
+            "lib/router.dart": GO_ROUTE("/home"),
+            "lib/feature/routes.dart": GO_ROUTE("/feature"),
+        });
+        expect(extractDartRoutes(root).map((r) => r.path).sort()).toEqual([
+            "/feature",
+            "/home",
+        ]);
+    });
+    it("skips dotfile directories not listed in SKIP_DIRS (startsWith '.')", () => {
+        // `.cache` is NOT in dart SKIP_DIRS — only the generic dotfile-dir rule
+        // (entry.name.startsWith(".")) keeps it out of the walk.
+        const root = makeTree({
+            "lib/router.dart": GO_ROUTE("/home"),
+            ".cache/hidden.dart": GO_ROUTE("/secret"),
+        });
+        expect(extractDartRoutes(root).map((r) => r.path)).toEqual(["/home"]);
+    });
+    it("skips SKIP_DIRS entries (build, ios)", () => {
+        const root = makeTree({
+            "lib/router.dart": GO_ROUTE("/home"),
+            "build/generated.dart": GO_ROUTE("/built"),
+            "ios/Runner.dart": GO_ROUTE("/ios"),
+        });
+        expect(extractDartRoutes(root).map((r) => r.path)).toEqual(["/home"]);
+    });
+});
+// ── sourceRouteExtractor.findRouterFiles ─────────────────────────────────────
+describe("extractSourceRoutes — findRouterFiles traversal", () => {
+    const APP = (p) => `
+import { Routes, Route } from 'react-router-dom';
+export default function App() {
+  return (<Routes><Route path="${p}" element={<X />} /></Routes>);
+}
+`;
+    it("skips router files inside node_modules and dotfile directories", () => {
+        const root = makeTree({
+            "src/App.tsx": APP("/ok"),
+            "node_modules/pkg/App.tsx": APP("/dep"),
+            ".backup/App.tsx": APP("/bak"),
+        });
+        expect(extractSourceRoutes(root).map((r) => r.path)).toEqual(["/ok"]);
+    });
+    const DEFINE_MODULE = `
+import { defineModule } from '@directus/extensions';
+import Coll from './routes/collection.vue';
+export default defineModule({
+  id: 'notes',
+  routes: [{ name: 'notes', path: '', component: Coll }],
+});
+`;
+    it("treats an index.* file as a router candidate ONLY under a modules/ segment", () => {
+        const underModules = makeTree({
+            "src/modules/notes/index.ts": DEFINE_MODULE,
+        });
+        expect(extractSourceRoutes(underModules).map((r) => r.path)).toEqual([
+            "/notes",
+        ]);
+        // Same defineModule file, but not under a `modules/` segment: findRouterFiles
+        // must not pick `index.ts` as a candidate, so no routes are extracted.
+        const notUnderModules = makeTree({
+            "src/features/notes/index.ts": DEFINE_MODULE,
+        });
+        expect(extractSourceRoutes(notUnderModules)).toEqual([]);
+    });
+});
+// ── trace-parser.scanDir (via discoverTraceFiles / discoverPlaywrightZips) ───
+describe("discoverTraceFiles / discoverPlaywrightZips — scanDir traversal", () => {
+    it("skips SKIP_DIRS while scanning an artifact directory", () => {
+        const root = makeTree({
+            "tests/trace.json": "{}",
+            "tests/node_modules/dep/trace.json": "{}",
+        });
+        expect(relSorted(root, discoverTraceFiles(root))).toEqual([
+            "tests/trace.json",
+        ]);
+    });
+    it("finds trace files nested several levels deep inside an artifact dir", () => {
+        const root = makeTree({
+            ".skyramp/a/b/c/playwright_trace.json": "{}",
+        });
+        expect(relSorted(root, discoverTraceFiles(root))).toEqual([
+            ".skyramp/a/b/c/playwright_trace.json",
+        ]);
+    });
+    it("does not descend into non-artifact dirs beyond the root (depth scoping)", () => {
+        const root = makeTree({
+            "src/components/trace.json": "{}", // src is not an artifact dir → depth 0 only
+        });
+        expect(discoverTraceFiles(root)).toEqual([]);
+    });
+    it("discovers playwright zips only within artifact dirs", () => {
+        const root = makeTree({
+            "e2e/run_trace.zip": "zip",
+            "frontend/public/traces/demo.playwright.zip": "zip",
+        });
+        expect(relSorted(root, discoverPlaywrightZips(root))).toEqual([
+            "e2e/run_trace.zip",
+        ]);
+    });
+});
+// ── frontendIntegration.manualWalkGrep (non-git fallback) ────────────────────
+describe("checkFrontendFileIntegration — manualWalkGrep traversal (non-git)", () => {
+    it("finds an importer in a normal directory (real content grep)", () => {
+        const repo = makeTree({
+            "src/components/Foo.tsx": `export function Foo() { return null; }\n`,
+            "src/components/Bar.tsx": `import { Foo } from './Foo';\nexport function Bar() { return Foo(); }\n`,
+        });
+        const [result] = checkFrontendFileIntegration(repo, [
+            "src/components/Foo.tsx",
+        ]);
+        expect(result.integrated).toBe(true);
+        expect(result.importers).toEqual(["src/components/Bar.tsx"]);
+    });
+    it("does not count importers inside EXCLUDED_DIR_PATTERN dirs (node_modules)", () => {
+        // Only importer lives under node_modules — the walk must skip that dir, so
+        // the component reads as unintegrated.
+        const repo = makeTree({
+            "src/components/Foo.tsx": `export function Foo() { return null; }\n`,
+            "node_modules/pkg/Consumer.tsx": `import { Foo } from '../../src/components/Foo';\n`,
+        });
+        const [result] = checkFrontendFileIntegration(repo, [
+            "src/components/Foo.tsx",
+        ]);
+        expect(result.integrated).toBe(false);
+        expect(result.reason).toBe("no-importers");
+    });
+});
+// ── TestExecutionService.collectVideoPath ────────────────────────────────────
+describe("collectVideoPath — first-match recursive walk", () => {
+    it("returns undefined for an empty/missing directory", () => {
+        const root = makeTree({ "other.txt": "" });
+        expect(collectVideoPath(root)).toBeUndefined();
+        expect(collectVideoPath("")).toBeUndefined();
+    });
+    it("finds video.webm nested several levels deep", () => {
+        const root = makeTree({ "a/b/c/video.webm": "data" });
+        const found = collectVideoPath(root);
+        expect(found).toBe(path.join(root, "a", "b", "c", "video.webm"));
+    });
+    it("returns a single video.webm path when several exist (first match wins)", () => {
+        const root = makeTree({
+            "x/video.webm": "1",
+            "y/video.webm": "2",
+        });
+        const found = collectVideoPath(root);
+        expect(found).toBeDefined();
+        expect(path.basename(found ?? "")).toBe("video.webm");
+    });
+});
+// ── TestExecutionService.findExcludedPaths ───────────────────────────────────
+describe("findExcludedPaths — name-list recursive walk", () => {
+    it("collects every matching file recursively, as absolute paths", () => {
+        const root = makeTree({
+            "package.json": "{}",
+            "sub/package.json": "{}",
+            "sub/deep/package.json": "{}",
+            "sub/other.json": "{}",
+        });
+        const out = findExcludedPaths(root, ["package.json"]);
+        expect(relSorted(root, out)).toEqual([
+            "package.json",
+            "sub/deep/package.json",
+            "sub/package.json",
+        ]);
+    });
+    it("does not descend into EXCLUDED_MOUNT_ITEMS directories (node_modules)", () => {
+        const root = makeTree({
+            "package.json": "{}",
+            "node_modules/pkg/package.json": "{}",
+        });
+        const out = findExcludedPaths(root, ["package.json"]);
+        expect(relSorted(root, out)).toEqual(["package.json"]);
+    });
+    it("does not descend into directories whose name is itself excluded", () => {
+        // A directory named like an excluded item is skipped for recursion, so a
+        // matching file *inside* it is never collected — matching the pre-refactor
+        // shouldSkipDir. `keep/config.json` (a real match) is still found.
+        const root = makeTree({
+            "keep/config.json": "{}",
+            "config.json/config.json": "{}", // parent dir excluded → inner file skipped
+        });
+        const out = findExcludedPaths(root, ["config.json"]);
+        expect(relSorted(root, out)).toEqual(["keep/config.json"]);
+    });
+});

package/node_modules/playwright/lib/common/config.js

@@ -264,7 +264,7 @@ function resolveScript(id, rootDir) {
 }
 const defaultGrep = /.*/;
 const defaultReporter = process.env.CI ? "dot" : "list";
-const configInternalSymbol = /* @__PURE__ */ Symbol("configInternalSymbol");
+const configInternalSymbol = Symbol("configInternalSymbol");
 function getProjectId(project) {
   return project.__projectId;
 }

package/node_modules/playwright/lib/common/configLoader.js

@@ -44,7 +44,7 @@ var import_util = require("../util");
 var import_config = require("./config");
 var import_esmLoaderHost = require("./esmLoaderHost");
 var import_compilationCache = require("../transform/compilationCache");
-const kDefineConfigWasUsed = /* @__PURE__ */ Symbol("defineConfigWasUsed");
+const kDefineConfigWasUsed = Symbol("defineConfigWasUsed");
 const defineConfig = (...configs) => {
   let result = configs[0];
   for (let i = 1; i < configs.length; ++i) {

package/node_modules/playwright/lib/common/fixtures.js

@@ -194,7 +194,7 @@ Make it top-level in the test file or put in the configuration file.`, location)
     this._onLoadError({ message, location });
   }
 }
-const signatureSymbol = /* @__PURE__ */ Symbol("signature");
+const signatureSymbol = Symbol("signature");
 function formatPotentiallyInternalLocation(location) {
   const isUserFixture = location && (0, import_util.filterStackFile)(location.file);
   return isUserFixture ? (0, import_util.formatLocation)(location) : "<builtin>";

package/node_modules/playwright/lib/common/testType.js

@@ -30,7 +30,7 @@ var import_test = require("./test");
 var import_expect = require("../matchers/expect");
 var import_transform = require("../transform/transform");
 var import_validators = require("./validators");
-const testTypeSymbol = /* @__PURE__ */ Symbol("testType");
+const testTypeSymbol = Symbol("testType");
 class TestTypeImpl {
   constructor(fixtures) {
     this.fixtures = fixtures;

package/node_modules/playwright/lib/index.js

@@ -508,7 +508,7 @@ function resolveClientCerticates(clientCertificates) {
   }
   return clientCertificates;
 }
-const kTracingStarted = /* @__PURE__ */ Symbol("kTracingStarted");
+const kTracingStarted = Symbol("kTracingStarted");
 function connectOptionsFromEnv() {
   const wsEndpoint = process.env.PW_TEST_CONNECT_WS_ENDPOINT;
   if (!wsEndpoint)
@@ -595,7 +595,7 @@ class ArtifactsRecorder {
     this._playwright = playwright;
     this._artifactsDir = artifactsDir;
     const screenshotOptions = typeof screenshot === "string" ? void 0 : screenshot;
-    this._startedCollectingArtifacts = /* @__PURE__ */ Symbol("startedCollectingArtifacts");
+    this._startedCollectingArtifacts = Symbol("startedCollectingArtifacts");
     this._screenshotRecorder = new SnapshotRecorder(this, normalizeScreenshotMode(screenshot), "screenshot", "image/png", ".png", async (page, path2) => {
       await page._wrapApiCall(async () => {
         await page.screenshot({ ...screenshotOptions, timeout: 5e3, path: path2, caret: "initial" });

package/node_modules/playwright/lib/isomorphic/testTree.js

@@ -320,7 +320,7 @@ function collectTestIds(treeItem) {
   visit(treeItem);
   return { testIds, locations };
 }
-const statusEx = /* @__PURE__ */ Symbol("statusEx");
+const statusEx = Symbol("statusEx");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   TestTree,

package/node_modules/playwright/lib/matchers/expect.js

@@ -34,7 +34,7 @@ var import_testInfo = require("../worker/testInfo");
 function createMatchers(actual, info, prefix) {
   return new Proxy((0, import_expectBundle.expect)(actual), new ExpectMetaInfoProxyHandler(actual, info, prefix));
 }
-const userMatchersSymbol = /* @__PURE__ */ Symbol("userMatchers");
+const userMatchersSymbol = Symbol("userMatchers");
 function qualifiedMatcherName(qualifier, matcherName) {
   return qualifier.join(":") + "$" + matcherName;
 }

package/node_modules/playwright/lib/mcp/browser/tab.js

@@ -432,7 +432,7 @@ function consoleLevelForMessageType(type) {
       return "info";
   }
 }
-const tabSymbol = /* @__PURE__ */ Symbol("tabSymbol");
+const tabSymbol = Symbol("tabSymbol");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   Tab,

package/node_modules/playwright/lib/mcp/browser/tools/navigate.js

@@ -28,7 +28,7 @@ const navigate = (0, import_tool.defineTool)({
   schema: {
     name: "browser_navigate",
     title: "Navigate to a URL",
-    description: "Navigate to a URL. Prefer direct navigation to known URLs over clicking menus or carousels \u2014 menus may open unwanted popups and carousel items cause strict-mode violations. To reload the current page, navigate to the same URL \u2014 the backend converts this to page.reload(). After navigating to a folder where content was just created/edited, always call browser_wait_for with the file name before interacting with it.",
+    description: "Navigate to a URL. Prefer direct navigation to known, stable URLs (login page, top-level app sections) over clicking menus or carousels \u2014 menus may open unwanted popups and carousel items cause strict-mode violations. EXCEPTION: to open a specific record/resource whose URL embeds an id (e.g. /workflow/edit/389363994986, /file/12345, /folder/67890), do NOT navigate to that URL directly \u2014 click the item in its list instead, so the recorded trace uses a reusable selector rather than a hardcoded id that breaks reuse on other data. To reload the current page, navigate to the same URL \u2014 the backend converts this to page.reload(). After navigating to a folder where content was just created/edited, always call browser_wait_for with the file name before interacting with it.",
     inputSchema: import_mcpBundle.z.object({
       url: import_mcpBundle.z.string().describe("The URL to navigate to")
     }),

package/node_modules/playwright/lib/mcp/browser/tools/tracing.js

@@ -71,4 +71,4 @@ var tracing_default = [
   tracingStart,
   tracingStop
 ];
-const traceLegendSymbol = /* @__PURE__ */ Symbol("tracesDir");
+const traceLegendSymbol = Symbol("tracesDir");

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

@@ -223,6 +223,13 @@ async function performClientAction(page, actionInContext) {
     await page.goto(action.url, { ...opts, waitUntil: "domcontentloaded" });
     return;
   }
+  if (action.name === "evaluate") {
+    const expr = typeof action.expression === "string" ? action.expression.trim().replace(/;+$/, "") : "";
+    if (expr)
+      await page.evaluate(`(${expr}
+)()`);
+    return;
+  }
   if (action.name === "waitForTimeout") {
     await new Promise((resolve) => setTimeout(resolve, action.duration ?? 0));
     return;

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

@@ -79,7 +79,8 @@ const ACTION_NAMES = /* @__PURE__ */ new Set([
   "iframeLoad",
   "assertApiRequest",
   "waitForSelector",
-  "waitForTimeout"
+  "waitForTimeout",
+  "evaluate"
 ]);
 function isActionName(name) {
   return ACTION_NAMES.has(name);

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

@@ -1977,7 +1977,9 @@ Cell row ${params.row}, column ${params.column} has "${actual}", expected "${par
       const errParsed = (0, import_response.parseResponse)(result);
       const errText = (errParsed?.error ?? errParsed?.text ?? "unknown error").replace(/\s+/g, " ").trim().slice(0, 300);
       this._droppedActions.push({ toolName, error: errText });
-      traceDebug(`Dropped failed action: ${toolName} args=${JSON.stringify(args).slice(0, 200)} \u2014 ${errText} (dropped total: ${this._droppedActions.length})`);
+      process.stderr.write(`[skyramp] Dropped failed action: ${toolName} \u2014 ${errText} (dropped total: ${this._droppedActions.length})
+`);
+      traceDebug(`Dropped failed action: ${toolName} args=${JSON.stringify(args).slice(0, 200)} \u2014 ${errText}`);
       return;
     }
     const parsed = (0, import_response.parseResponse)(result);

package/node_modules/playwright/lib/reporters/base.js

@@ -52,7 +52,7 @@ var import_utilsBundle = require("playwright-core/lib/utilsBundle");
 var import_utils2 = require("playwright-core/lib/utils");
 var import_util = require("../util");
 var import_utilsBundle2 = require("../utilsBundle");
-const kOutputSymbol = /* @__PURE__ */ Symbol("output");
+const kOutputSymbol = Symbol("output");
 const DEFAULT_TTY_WIDTH = 100;
 const DEFAULT_TTY_HEIGHT = 40;
 const originalProcessStdout = process.stdout;
@@ -402,7 +402,7 @@ function quotePathIfNeeded(path2) {
     return `"${path2}"`;
   return path2;
 }
-const kReportedSymbol = /* @__PURE__ */ Symbol("reported");
+const kReportedSymbol = Symbol("reported");
 function markErrorsAsReported(result) {
   result[kReportedSymbol] = result.errors.length;
 }

package/node_modules/playwright/lib/reporters/list.js

@@ -249,5 +249,5 @@ class ListReporter extends import_base.TerminalReporter {
     this.epilogue(true);
   }
 }
-const lastStepOrdinalSymbol = /* @__PURE__ */ Symbol("lastStepOrdinal");
+const lastStepOrdinalSymbol = Symbol("lastStepOrdinal");
 var list_default = ListReporter;

package/node_modules/playwright/lib/reporters/teleEmitter.js

@@ -40,7 +40,7 @@ class TeleReporterEmitter {
     this._resultKnownErrorCounts = /* @__PURE__ */ new Map();
     // In case there is blob reporter and UI mode, make sure one doesn't override
     // the id assigned by the other.
-    this._idSymbol = /* @__PURE__ */ Symbol("id");
+    this._idSymbol = Symbol("id");
     this._messageSink = messageSink;
     this._emitterOptions = options;
   }

package/node_modules/playwright/lib/worker/testInfo.js

@@ -76,7 +76,7 @@ class TestInfoImpl {
     this._startTime = (0, import_utils.monotonicTime)();
     this._startWallTime = Date.now();
     this._requireFile = test?._requireFile ?? "";
-    this._uniqueSymbol = /* @__PURE__ */ Symbol("testInfoUniqueSymbol");
+    this._uniqueSymbol = Symbol("testInfoUniqueSymbol");
     this._workerParams = workerParams;
     this.repeatEachIndex = workerParams.repeatEachIndex;
     this.retry = retry;
@@ -525,7 +525,7 @@ class TestSkipError extends Error {
 }
 class StepSkipError extends Error {
 }
-const stepSymbol = /* @__PURE__ */ Symbol("step");
+const stepSymbol = Symbol("step");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   StepSkipError,