@skyramp/mcp 0.3.2-rc.pom-3 → 0.3.2

package/build/utils/AnalysisStateManager.test.js

@@ -1,134 +0,0 @@
-import * as fs from "fs";
-import * as os from "os";
-import * as path from "path";
-import { StateManager } from "./AnalysisStateManager.js";
-import { AnalysisScope } from "../types/RepositoryAnalysis.js";
-describe("StateManager.fromStatePath", () => {
-    it("preserves the exact supplied path for a standard-prefixed file", () => {
-        const stdPath = path.join(os.tmpdir(), "skyramp-analysis-some-uuid.json");
-        const manager = StateManager.fromStatePath(stdPath);
-        expect(manager.getStatePath()).toBe(stdPath);
-    });
-    it("preserves the exact supplied path for a custom filename like analyze-changes-state.json", () => {
-        // This is the filename testbot uses — it does NOT match any STATE_FILE_PREFIXES entry.
-        // fromStatePath must pass stateFilePath through to the constructor so the path is not rebuilt.
-        const customPath = path.join(os.tmpdir(), "analyze-changes-state.json");
-        const manager = StateManager.fromStatePath(customPath);
-        expect(manager.getStatePath()).toBe(customPath);
-    });
-});
-describe("StateManager.writeData", () => {
-    it("creates parent directories when they do not exist", async () => {
-        const nestedDir = path.join(os.tmpdir(), `skyramp-test-mkdir-${Date.now()}`);
-        const nestedPath = path.join(nestedDir, "state.json");
-        // Directory must not exist before the test
-        expect(fs.existsSync(nestedDir)).toBe(false);
-        const manager = new StateManager("analysis", undefined, undefined, nestedPath);
-        await expect(manager.writeData({
-            existingTests: [],
-            analysisScope: AnalysisScope.CurrentBranchDiff,
-            newEndpoints: [],
-        })).resolves.not.toThrow();
-        expect(fs.existsSync(nestedPath)).toBe(true);
-        // cleanup
-        await fs.promises.rm(nestedDir, { recursive: true, force: true });
-    });
-});
-describe("StateManager — run-scoped per-repo sections (SKYR-3796)", () => {
-    let stateFile;
-    const mkState = (tag) => ({
-        existingTests: [{ testFile: `${tag}.spec.ts` }],
-        analysisScope: AnalysisScope.CurrentBranchDiff,
-        newEndpoints: [],
-    });
-    beforeEach(() => {
-        stateFile = path.join(os.tmpdir(), `skyramp-analysis-sections-${Date.now()}.json`);
-    });
-    afterEach(async () => {
-        await fs.promises.rm(stateFile, { force: true });
-    });
-    it("keeps the primary at root and additional repos in relatedRepos, all in ONE file", async () => {
-        const mgr = StateManager.fromStatePath(stateFile);
-        // Primary (repo omitted) → root; additional repo → section.
-        await mgr.writeRepoData(mkState("primary"), { repositoryPath: "/work/primary" });
-        await mgr.writeRepoData(mkState("api"), {
-            repo: "letsramp/api-insight",
-            repositoryPath: "/work/api-insight",
-        });
-        // Exactly one file on disk.
-        expect(fs.existsSync(stateFile)).toBe(true);
-        expect(fs.existsSync(`${stateFile}.1.json`)).toBe(false);
-        const raw = JSON.parse(await fs.promises.readFile(stateFile, "utf-8"));
-        // Primary analysis lives at root (backward-compatible single-repo shape).
-        expect(raw.existingTests[0].testFile).toBe("primary.spec.ts");
-        expect(raw.metadata.repositoryPath).toBe("/work/primary");
-        // Additional repo under relatedRepos, keyed by owner/repo.
-        expect(raw.relatedRepos["letsramp/api-insight"].data.existingTests[0].testFile).toBe("api.spec.ts");
-        expect(raw.relatedRepos["letsramp/api-insight"].repositoryPath).toBe("/work/api-insight");
-    });
-    it("reads back the correct section by repo (primary when omitted)", async () => {
-        const mgr = StateManager.fromStatePath(stateFile);
-        await mgr.writeRepoData(mkState("primary"), { repositoryPath: "/work/primary" });
-        await mgr.writeRepoData(mkState("api"), { repo: "letsramp/api-insight", repositoryPath: "/work/api-insight" });
-        expect((await mgr.readRepoData()).existingTests[0].testFile).toBe("primary.spec.ts");
-        expect((await mgr.readRepoData("letsramp/api-insight")).existingTests[0].testFile).toBe("api.spec.ts");
-        expect(await mgr.getRepoRepositoryPath()).toBe("/work/primary");
-        expect(await mgr.getRepoRepositoryPath("letsramp/api-insight")).toBe("/work/api-insight");
-        expect(await mgr.listRelatedRepos()).toEqual(["letsramp/api-insight"]);
-    });
-    it("preserves additional sections when the primary root is rewritten (writeData)", async () => {
-        const mgr = StateManager.fromStatePath(stateFile);
-        await mgr.writeRepoData(mkState("primary"), { repositoryPath: "/work/primary" });
-        await mgr.writeRepoData(mkState("api"), { repo: "letsramp/api-insight", repositoryPath: "/work/api-insight" });
-        // execute_test-style root rewrite must not drop the additional section.
-        const primary = (await mgr.readRepoData());
-        primary.existingTests[0].execution = { marker: "ran" };
-        await mgr.writeData(primary);
-        expect((await mgr.readRepoData("letsramp/api-insight")).existingTests[0].testFile).toBe("api.spec.ts");
-        expect((await mgr.readRepoData()).existingTests[0].execution.marker).toBe("ran");
-    });
-    it("preserves an additional repo's repositoryPath when a later write omits it", async () => {
-        const mgr = StateManager.fromStatePath(stateFile);
-        await mgr.writeRepoData(mkState("primary"), { repositoryPath: "/work/primary" });
-        // analyze_changes records the section WITH its checkout path.
-        await mgr.writeRepoData(mkState("api"), {
-            repo: "letsramp/api-insight",
-            repositoryPath: "/work/api-insight",
-        });
-        // A later write to the same section (e.g. execute_test) omits repositoryPath.
-        await mgr.writeRepoData(mkState("api-ran"), { repo: "letsramp/api-insight" });
-        // The path must survive so getRepoRepositoryPath can still re-absolutize.
-        expect(await mgr.getRepoRepositoryPath("letsramp/api-insight")).toBe("/work/api-insight");
-        expect((await mgr.readRepoData("letsramp/api-insight")).existingTests[0].testFile).toBe("api-ran.spec.ts");
-    });
-    it("routes the primary to root and a related repo to a section when BOTH pass an explicit repo", async () => {
-        const mgr = StateManager.fromStatePath(stateFile);
-        // The agent now always passes an explicit owner/repo, including for the
-        // primary. The FIRST write is the primary → root (tagged on metadata).
-        await mgr.writeRepoData(mkState("primary"), {
-            repo: "letsramp/primary-app",
-            repositoryPath: "/work/primary",
-        });
-        await mgr.writeRepoData(mkState("api"), {
-            repo: "letsramp/api-insight",
-            repositoryPath: "/work/api-insight",
-        });
-        const raw = JSON.parse(await fs.promises.readFile(stateFile, "utf-8"));
-        expect(raw.metadata.repository).toBe("letsramp/primary-app");
-        expect(raw.existingTests[0].testFile).toBe("primary.spec.ts");
-        expect(raw.relatedRepos["letsramp/api-insight"].data.existingTests[0].testFile).toBe("api.spec.ts");
-        // The primary is reachable BOTH by its explicit repo and by omitting it.
-        expect((await mgr.readRepoData("letsramp/primary-app")).existingTests[0].testFile).toBe("primary.spec.ts");
-        expect((await mgr.readRepoData()).existingTests[0].testFile).toBe("primary.spec.ts");
-        expect(await mgr.getRepoRepositoryPath("letsramp/primary-app")).toBe("/work/primary");
-        expect(await mgr.listRelatedRepos()).toEqual(["letsramp/api-insight"]);
-    });
-    it("reads a legacy single-section file (no relatedRepos) as the primary", async () => {
-        const mgr = StateManager.fromStatePath(stateFile);
-        // Legacy write path — no repo, no sections.
-        await mgr.writeData(mkState("legacy"), { repositoryPath: "/work/legacy" });
-        expect((await mgr.readRepoData()).existingTests[0].testFile).toBe("legacy.spec.ts");
-        expect(await mgr.getRepoRepositoryPath()).toBe("/work/legacy");
-        expect(await mgr.listRelatedRepos()).toEqual([]);
-    });
-});

package/build/utils/dartRouteExtractor.test.d.ts

@@ -1 +0,0 @@
-export {};

package/build/utils/dartRouteExtractor.test.js

@@ -1,307 +0,0 @@
-// No external mocks needed — the extractor is pure fs + regex.
-import * as fs from "fs";
-import * as os from "os";
-import * as path from "path";
-import { extractDartRoutes } from "./dartRouteExtractor.js";
-function makeTmpRepo(files) {
-    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "skyramp-dart-route-test-"));
-    for (const f of files) {
-        const fullPath = path.join(dir, f.path);
-        fs.mkdirSync(path.dirname(fullPath), { recursive: true });
-        fs.writeFileSync(fullPath, f.content);
-    }
-    return dir;
-}
-function cleanup(dir) {
-    fs.rmSync(dir, { recursive: true, force: true });
-}
-describe("extractDartRoutes", () => {
-    it("returns empty when repo has no .dart files", () => {
-        const repo = makeTmpRepo([
-            { path: "lib/main.dart", content: "void main() => runApp(MyApp());" },
-        ]);
-        expect(extractDartRoutes(repo)).toEqual([]);
-        cleanup(repo);
-    });
-    it("extracts a single GoRoute with double-quoted path", () => {
-        const repo = makeTmpRepo([
-            {
-                path: "lib/router.dart",
-                content: `
-import 'package:go_router/go_router.dart';
-
-final router = GoRouter(routes: [
-  GoRoute(path: "/login", builder: (ctx, st) => LoginScreen()),
-]);
-`,
-            },
-        ]);
-        const routes = extractDartRoutes(repo);
-        expect(routes).toHaveLength(1);
-        expect(routes[0].path).toBe("/login");
-        expect(routes[0].declaredIn).toMatch(/router\.dart$/);
-        cleanup(repo);
-    });
-    it("extracts a single GoRoute with single-quoted path", () => {
-        const repo = makeTmpRepo([
-            {
-                path: "lib/app.dart",
-                content: `GoRoute(path: '/home', builder: (c, s) => Home())`,
-            },
-        ]);
-        const routes = extractDartRoutes(repo);
-        expect(routes).toHaveLength(1);
-        expect(routes[0].path).toBe("/home");
-        cleanup(repo);
-    });
-    it("extracts multiple GoRoutes from one file", () => {
-        const repo = makeTmpRepo([
-            {
-                path: "lib/router.dart",
-                content: `
-final router = GoRouter(routes: [
-  GoRoute(path: '/login', builder: (c, s) => LoginScreen()),
-  GoRoute(path: '/dashboard', builder: (c, s) => DashboardScreen()),
-  GoRoute(path: '/profile/:id', builder: (c, s) => ProfileScreen()),
-]);
-`,
-            },
-        ]);
-        const routes = extractDartRoutes(repo);
-        expect(routes.map((r) => r.path).sort()).toEqual([
-            "/dashboard",
-            "/login",
-            "/profile/:id",
-        ]);
-        cleanup(repo);
-    });
-    it("extracts nested GoRoutes (sub-routes inside parent)", () => {
-        const repo = makeTmpRepo([
-            {
-                path: "lib/router.dart",
-                content: `
-GoRoute(
-  path: '/settings',
-  builder: (c, s) => SettingsScreen(),
-  routes: [
-    GoRoute(path: 'account', builder: (c, s) => AccountScreen()),
-    GoRoute(path: 'privacy', builder: (c, s) => PrivacyScreen()),
-  ],
-);
-`,
-            },
-        ]);
-        const routes = extractDartRoutes(repo);
-        expect(routes.map((r) => r.path).sort()).toEqual([
-            "/settings",
-            "account",
-            "privacy",
-        ]);
-        cleanup(repo);
-    });
-    it("walks lib/ and skips build, .dart_tool, ios, android, macos, web", () => {
-        const repo = makeTmpRepo([
-            {
-                path: "lib/router.dart",
-                content: `GoRoute(path: '/real', builder: (c, s) => X())`,
-            },
-            {
-                path: "build/app/intermediates/router.dart",
-                content: `GoRoute(path: '/build-fake', builder: (c, s) => X())`,
-            },
-            {
-                path: ".dart_tool/something.dart",
-                content: `GoRoute(path: '/tool-fake', builder: (c, s) => X())`,
-            },
-            {
-                path: "ios/Generated.dart",
-                content: `GoRoute(path: '/ios-fake', builder: (c, s) => X())`,
-            },
-        ]);
-        const routes = extractDartRoutes(repo);
-        expect(routes.map((r) => r.path)).toEqual(["/real"]);
-        cleanup(repo);
-    });
-    it("ignores GoRoute calls without a string-literal path (constants, expressions)", () => {
-        const repo = makeTmpRepo([
-            {
-                path: "lib/router.dart",
-                content: `
-const _kHome = '/home';
-final router = GoRouter(routes: [
-  GoRoute(path: _kHome, builder: (c, s) => H()),
-  GoRoute(path: '/login', builder: (c, s) => L()),
-]);
-`,
-            },
-        ]);
-        const routes = extractDartRoutes(repo);
-        expect(routes.map((r) => r.path)).toEqual(["/login"]);
-        cleanup(repo);
-    });
-    it("returns empty for non-Flutter Dart files (no GoRoute calls)", () => {
-        const repo = makeTmpRepo([
-            {
-                path: "bin/server.dart",
-                content: `
-void main() async {
-  final server = await HttpServer.bind('localhost', 8080);
-  await for (final req in server) { /* ... */ }
-}
-`,
-            },
-        ]);
-        expect(extractDartRoutes(repo)).toEqual([]);
-        cleanup(repo);
-    });
-    it("deduplicates identical GoRoute paths declared multiple times", () => {
-        const repo = makeTmpRepo([
-            {
-                path: "lib/a.dart",
-                content: `GoRoute(path: '/login', builder: (c, s) => A())`,
-            },
-            {
-                path: "lib/b.dart",
-                content: `GoRoute(path: '/login', builder: (c, s) => B())`,
-            },
-        ]);
-        const routes = extractDartRoutes(repo);
-        expect(routes).toHaveLength(1);
-        expect(routes[0].path).toBe("/login");
-        cleanup(repo);
-    });
-    // Real-world: extract all routes from the books example we built locally.
-    // This guards the regex against the actual customer-style GoRouter shape
-    // — multi-line declarations with redirect+pageBuilder mixed in.
-    it("extracts the books example's six routes", () => {
-        const repo = makeTmpRepo([
-            {
-                path: "lib/main.dart",
-                content: `
-import 'package:go_router/go_router.dart';
-
-late final GoRouter _router = GoRouter(
-  routes: <GoRoute>[
-    GoRoute(path: '/', redirect: (_, _) => '/books'),
-    GoRoute(
-      path: '/signin',
-      pageBuilder: (BuildContext context, GoRouterState state) => SignIn(),
-    ),
-    GoRoute(path: '/books', redirect: (_, _) => '/books/popular'),
-    GoRoute(
-      path: '/book/:bookId',
-      redirect: (BuildContext context, GoRouterState state) =>
-          '/books/all/' + state.pathParameters['bookId']!,
-    ),
-    GoRoute(
-      path: '/books/:kind(new|all|popular)',
-      pageBuilder: (BuildContext context, GoRouterState state) => Books(),
-      routes: <GoRoute>[
-        GoRoute(
-          path: ':bookId',
-          builder: (BuildContext context, GoRouterState state) => BookDetails(),
-        ),
-      ],
-    ),
-    GoRoute(
-      path: '/author/:authorId',
-      redirect: (BuildContext context, GoRouterState state) =>
-          '/authors/' + state.pathParameters['authorId']!,
-    ),
-    GoRoute(
-      path: '/authors',
-      pageBuilder: (BuildContext context, GoRouterState state) => Authors(),
-      routes: <GoRoute>[
-        GoRoute(
-          path: ':authorId',
-          builder: (BuildContext context, GoRouterState state) => AuthorDetails(),
-        ),
-      ],
-    ),
-    GoRoute(
-      path: '/settings',
-      pageBuilder: (BuildContext context, GoRouterState state) => Settings(),
-    ),
-  ],
-);
-`,
-            },
-        ]);
-        const routes = extractDartRoutes(repo);
-        const paths = routes.map((r) => r.path).sort();
-        // Top-level absolute paths.
-        expect(paths).toEqual([
-            "/",
-            "/author/:authorId",
-            "/authors",
-            "/book/:bookId",
-            "/books",
-            "/books/:kind(new|all|popular)",
-            "/settings",
-            "/signin",
-            ":authorId",
-            ":bookId",
-        ].sort());
-        cleanup(repo);
-    });
-    // ── New shape: screenWidgets, screenFiles, isRedirectOnly ─────────────────
-    it("flags redirect-only routes (no builder/pageBuilder)", () => {
-        const repo = makeTmpRepo([
-            {
-                path: "lib/router.dart",
-                content: `
-GoRoute(path: '/', redirect: (_, _) => '/home'),
-GoRoute(path: '/home', builder: (c, s) => Home()),
-`,
-            },
-        ]);
-        const routes = extractDartRoutes(repo);
-        const root = routes.find((r) => r.path === "/");
-        const home = routes.find((r) => r.path === "/home");
-        expect(root?.isRedirectOnly).toBe(true);
-        expect(home?.isRedirectOnly).toBe(false);
-        cleanup(repo);
-    });
-    it("captures screen widget identifiers from builder/pageBuilder", () => {
-        const repo = makeTmpRepo([
-            {
-                path: "lib/router.dart",
-                content: `
-GoRoute(path: '/login', builder: (c, s) => LoginScreen()),
-GoRoute(path: '/profile', pageBuilder: (c, s) => MaterialPage(child: ProfileScreen())),
-`,
-            },
-        ]);
-        const routes = extractDartRoutes(repo);
-        const login = routes.find((r) => r.path === "/login");
-        const profile = routes.find((r) => r.path === "/profile");
-        expect(login?.screenWidgets).toContain("LoginScreen");
-        expect(profile?.screenWidgets).toContain("ProfileScreen");
-        // Ignored framework identifiers should NOT appear.
-        expect(login?.screenWidgets).not.toContain("BuildContext");
-        expect(profile?.screenWidgets).not.toContain("MaterialPage");
-        cleanup(repo);
-    });
-    it("resolves screenWidgets to imported file paths via filename heuristic", () => {
-        const repo = makeTmpRepo([
-            {
-                path: "lib/main.dart",
-                content: `
-import 'src/screens/authors.dart';
-import 'src/screens/settings.dart';
-
-GoRoute(path: '/authors', builder: (c, s) => AuthorsScreen()),
-GoRoute(path: '/settings', builder: (c, s) => SettingsScreen()),
-`,
-            },
-            { path: "lib/src/screens/authors.dart", content: "// AuthorsScreen widget" },
-            { path: "lib/src/screens/settings.dart", content: "// SettingsScreen widget" },
-        ]);
-        const routes = extractDartRoutes(repo);
-        const authors = routes.find((r) => r.path === "/authors");
-        const settings = routes.find((r) => r.path === "/settings");
-        expect(authors?.screenFiles[0]).toMatch(/lib\/src\/screens\/authors\.dart$/);
-        expect(settings?.screenFiles[0]).toMatch(/lib\/src\/screens\/settings\.dart$/);
-        cleanup(repo);
-    });
-});

package/build/utils/docker.test.d.ts

@@ -1 +0,0 @@
-export {};

package/build/utils/docker.test.js

@@ -1,114 +0,0 @@
-// @ts-nocheck - Jest ESM type inference issues
-import { jest } from "@jest/globals";
-// Mock logger before importing docker module
-const mockInspect = jest.fn();
-const mockGetImage = jest.fn(() => ({ inspect: mockInspect }));
-const mockFollowProgress = jest.fn();
-const mockPull = jest.fn();
-const mockModem = { followProgress: mockFollowProgress };
-jest.unstable_mockModule("./logger.js", () => ({
-    logger: {
-        debug: jest.fn(),
-        info: jest.fn(),
-        error: jest.fn(),
-        warning: jest.fn(),
-    },
-}));
-jest.mock("dockerode", () => jest.fn().mockImplementation(() => ({
-    getImage: mockGetImage,
-    pull: mockPull,
-    modem: mockModem,
-})));
-const { dockerImageExistsLocally, pullDockerImage } = await import("./docker.js");
-// Helper: make docker.pull succeed (stream ends without error)
-function mockPullSuccess() {
-    const fakeStream = {};
-    mockPull.mockImplementation((_image, _opts, cb) => {
-        cb(null, fakeStream);
-    });
-    mockFollowProgress.mockImplementation((_stream, onFinished) => {
-        onFinished(null);
-    });
-}
-// Helper: make docker.pull fail with the given error
-function mockPullError(err) {
-    mockPull.mockImplementation((_image, _opts, cb) => {
-        cb(err);
-    });
-}
-describe("dockerImageExistsLocally", () => {
-    beforeEach(() => jest.clearAllMocks());
-    it("returns true when inspect succeeds", async () => {
-        mockInspect.mockResolvedValue({});
-        await expect(dockerImageExistsLocally("img:tag")).resolves.toBe(true);
-    });
-    it("returns false on 404 (image not present locally)", async () => {
-        mockInspect.mockRejectedValue({ statusCode: 404 });
-        await expect(dockerImageExistsLocally("img:tag")).resolves.toBe(false);
-    });
-    it("throws and logs a warning when Docker daemon is unreachable", async () => {
-        const { logger } = await import("./logger.js");
-        const daemonErr = new Error("connect ECONNREFUSED /var/run/docker.sock");
-        mockInspect.mockRejectedValue(daemonErr);
-        await expect(dockerImageExistsLocally("img:tag")).rejects.toThrow(daemonErr);
-        expect(logger.warning).toHaveBeenCalledWith("Could not check Docker image locally", expect.objectContaining({ image: "img:tag" }));
-    });
-});
-describe("pullDockerImage", () => {
-    const IMAGE = "skyramp/executor:v1.3.36";
-    beforeEach(() => jest.clearAllMocks());
-    describe("on amd64 host", () => {
-        const originalArch = process.arch;
-        beforeAll(() => Object.defineProperty(process, "arch", { value: "x64", configurable: true }));
-        afterAll(() => Object.defineProperty(process, "arch", { value: originalArch, configurable: true }));
-        it("pulls with linux/amd64 and succeeds", async () => {
-            mockPullSuccess();
-            await expect(pullDockerImage(IMAGE)).resolves.toBeUndefined();
-            expect(mockPull).toHaveBeenCalledTimes(1);
-            expect(mockPull).toHaveBeenCalledWith(IMAGE, { platform: "linux/amd64" }, expect.any(Function));
-        });
-        it("rethrows any pull error without fallback", async () => {
-            const err = new Error("unauthorized: access denied");
-            mockPullError(err);
-            await expect(pullDockerImage(IMAGE)).rejects.toThrow(err);
-            expect(mockPull).toHaveBeenCalledTimes(1);
-        });
-    });
-    describe("on arm64 host", () => {
-        const originalArch = process.arch;
-        beforeAll(() => Object.defineProperty(process, "arch", { value: "arm64", configurable: true }));
-        afterAll(() => Object.defineProperty(process, "arch", { value: originalArch, configurable: true }));
-        it("pulls with linux/arm64 and succeeds without fallback when image lands locally", async () => {
-            mockPullSuccess();
-            mockInspect.mockResolvedValue({}); // post-pull verify: image found
-            await expect(pullDockerImage(IMAGE)).resolves.toBeUndefined();
-            expect(mockPull).toHaveBeenCalledTimes(1);
-            expect(mockPull).toHaveBeenCalledWith(IMAGE, { platform: "linux/arm64" }, expect.any(Function));
-        });
-        it("falls back to linux/amd64 on manifest-mismatch error", async () => {
-            const manifestErr = new Error("no matching manifest for linux/arm64 in the manifest list entries");
-            const fakeStream = {};
-            mockPull
-                .mockImplementationOnce((_image, _opts, cb) => cb(manifestErr))
-                .mockImplementationOnce((_image, _opts, cb) => cb(null, fakeStream));
-            mockFollowProgress.mockImplementation((_stream, onFinished) => onFinished(null));
-            await expect(pullDockerImage(IMAGE)).resolves.toBeUndefined();
-            expect(mockPull).toHaveBeenCalledTimes(2);
-            expect(mockPull).toHaveBeenNthCalledWith(1, IMAGE, { platform: "linux/arm64" }, expect.any(Function));
-            expect(mockPull).toHaveBeenNthCalledWith(2, IMAGE, { platform: "linux/amd64" }, expect.any(Function));
-        });
-        it("rethrows non-manifest errors (auth/network) without falling back", async () => {
-            const authErr = new Error("unauthorized: access denied");
-            mockPullError(authErr);
-            await expect(pullDockerImage(IMAGE)).rejects.toThrow(authErr);
-            expect(mockPull).toHaveBeenCalledTimes(1);
-        });
-        it("falls back to linux/amd64 when arm64 pull succeeds silently but image is not stored locally", async () => {
-            mockPullSuccess();
-            mockInspect.mockRejectedValueOnce({ statusCode: 404 }); // post-pull verify: not found
-            await expect(pullDockerImage(IMAGE)).resolves.toBeUndefined();
-            expect(mockPull).toHaveBeenCalledTimes(2);
-            expect(mockPull).toHaveBeenNthCalledWith(2, IMAGE, { platform: "linux/amd64" }, expect.any(Function));
-        });
-    });
-});

package/build/utils/featureFlags.test.d.ts

@@ -1 +0,0 @@
-export {};

package/build/utils/featureFlags.test.js

@@ -1,81 +0,0 @@
-import { resolveServiceDetailsRef } from "./utils.js";
-import { isTestbotEnabled } from "./featureFlags.js";
-// Capture and restore the original env var so these tests don't pollute other
-// test suites or a developer's shell environment where the var may already be set.
-let originalTestbotEnv;
-beforeAll(() => { originalTestbotEnv = process.env.SKYRAMP_FEATURE_TESTBOT; });
-afterAll(() => {
-    if (originalTestbotEnv === undefined) {
-        delete process.env.SKYRAMP_FEATURE_TESTBOT;
-    }
-    else {
-        process.env.SKYRAMP_FEATURE_TESTBOT = originalTestbotEnv;
-    }
-});
-describe("isTestbotEnabled", () => {
-    afterEach(() => {
-        delete process.env.SKYRAMP_FEATURE_TESTBOT;
-    });
-    it('returns true when SKYRAMP_FEATURE_TESTBOT is "1"', () => {
-        process.env.SKYRAMP_FEATURE_TESTBOT = "1";
-        expect(isTestbotEnabled()).toBe(true);
-    });
-    it("returns false when SKYRAMP_FEATURE_TESTBOT is unset", () => {
-        expect(isTestbotEnabled()).toBe(false);
-    });
-    it('returns false when SKYRAMP_FEATURE_TESTBOT is "0"', () => {
-        process.env.SKYRAMP_FEATURE_TESTBOT = "0";
-        expect(isTestbotEnabled()).toBe(false);
-    });
-    it('returns false when SKYRAMP_FEATURE_TESTBOT is "true"', () => {
-        process.env.SKYRAMP_FEATURE_TESTBOT = "true";
-        expect(isTestbotEnabled()).toBe(false);
-    });
-});
-describe("resolveServiceDetailsRef", () => {
-    afterEach(() => {
-        delete process.env.SKYRAMP_FEATURE_TESTBOT;
-    });
-    describe("testbot mode (SKYRAMP_FEATURE_TESTBOT=1)", () => {
-        beforeEach(() => {
-            process.env.SKYRAMP_FEATURE_TESTBOT = "1";
-        });
-        it("returns <services> block reference for testDirRef", () => {
-            expect(resolveServiceDetailsRef().testDirRef).toContain("<test_directory>");
-            expect(resolveServiceDetailsRef().testDirRef).toContain("<services>");
-        });
-        it("returns <services> block reference for frontendTestDirRef", () => {
-            expect(resolveServiceDetailsRef().frontendTestDirRef).toContain("<test_directory>");
-            expect(resolveServiceDetailsRef().frontendTestDirRef).toContain("<services>");
-        });
-        it("returns <services> block reference for authSourceRef", () => {
-            expect(resolveServiceDetailsRef().authSourceRef).toContain("<services>");
-        });
-        it("returns <services> block reference for baseUrlRef", () => {
-            expect(resolveServiceDetailsRef().baseUrlRef).toContain("<base_url>");
-        });
-        it("does NOT reference workspace.yml in any field", () => {
-            const refs = resolveServiceDetailsRef();
-            for (const val of Object.values(refs)) {
-                expect(val).not.toContain("workspace.yml");
-            }
-        });
-    });
-    describe("MCP mode (SKYRAMP_FEATURE_TESTBOT unset)", () => {
-        it("returns workspace.yml reference for testDirRef", () => {
-            expect(resolveServiceDetailsRef().testDirRef).toContain("workspace.yml");
-        });
-        it("returns workspace.yml reference for frontendTestDirRef", () => {
-            expect(resolveServiceDetailsRef().frontendTestDirRef).toContain("workspace.yml");
-        });
-        it("returns workspace.yml reference for authSourceRef", () => {
-            expect(resolveServiceDetailsRef().authSourceRef).toContain("workspace.yml");
-        });
-        it("does NOT reference <services> in any field", () => {
-            const refs = resolveServiceDetailsRef();
-            for (const val of Object.values(refs)) {
-                expect(val).not.toContain("<services>");
-            }
-        });
-    });
-});

package/build/utils/fileWalk.test.d.ts

@@ -1 +0,0 @@
-export {};