@simplysm/sd-cli 13.0.99 → 14.0.1

package/tests/replace-deps.spec.ts

@@ -1,308 +0,0 @@
-import { afterEach, beforeEach, describe, expect, test } from "vitest";
-import {
-  parseWorkspaceGlobs,
-  resolveReplaceDepEntries,
-  setupReplaceDeps,
-  watchReplaceDeps,
-} from "../src/utils/replace-deps";
-import fs from "fs";
-import path from "path";
-import os from "os";
-
-describe("resolveReplaceDepEntries", () => {
-  test("captures glob * pattern and substitutes it in source path", () => {
-    const result = resolveReplaceDepEntries({ "@simplysm/*": "../simplysm/packages/*" }, [
-      "@simplysm/solid",
-      "@simplysm/core-common",
-    ]);
-    expect(result).toEqual([
-      { targetName: "@simplysm/solid", sourcePath: "../simplysm/packages/solid" },
-      { targetName: "@simplysm/core-common", sourcePath: "../simplysm/packages/core-common" },
-    ]);
-  });
-
-  test("matches exact package names without *", () => {
-    const result = resolveReplaceDepEntries({ "@other/lib": "../other-project/lib" }, [
-      "@other/lib",
-      "@other/unused",
-    ]);
-    expect(result).toEqual([{ targetName: "@other/lib", sourcePath: "../other-project/lib" }]);
-  });
-
-  test("non-matching packages are not included in results", () => {
-    const result = resolveReplaceDepEntries({ "@simplysm/*": "../simplysm/packages/*" }, [
-      "@other/lib",
-    ]);
-    expect(result).toEqual([]);
-  });
-
-  test("processes multiple replaceDeps entries", () => {
-    const result = resolveReplaceDepEntries(
-      {
-        "@simplysm/*": "../simplysm/packages/*",
-        "@other/lib": "../other/lib",
-      },
-      ["@simplysm/solid", "@other/lib"],
-    );
-    expect(result).toEqual([
-      { targetName: "@simplysm/solid", sourcePath: "../simplysm/packages/solid" },
-      { targetName: "@other/lib", sourcePath: "../other/lib" },
-    ]);
-  });
-});
-
-describe("parseWorkspaceGlobs", () => {
-  test("parses packages glob array", () => {
-    const yaml = `packages:\n  - "packages/*"\n  - "tools/*"`;
-    expect(parseWorkspaceGlobs(yaml)).toEqual(["packages/*", "tools/*"]);
-  });
-
-  test("parses glob without quotes", () => {
-    const yaml = `packages:\n  - packages/*\n  - tools/*`;
-    expect(parseWorkspaceGlobs(yaml)).toEqual(["packages/*", "tools/*"]);
-  });
-
-  test("returns empty array for empty content", () => {
-    expect(parseWorkspaceGlobs("")).toEqual([]);
-  });
-
-  test("returns empty array if packages section is missing", () => {
-    const yaml = `# some comment\nsomething: value`;
-    expect(parseWorkspaceGlobs(yaml)).toEqual([]);
-  });
-});
-
-describe("setupReplaceDeps", () => {
-  let tmpDir: string;
-
-  beforeEach(async () => {
-    // Create test project structure in temporary directory
-    tmpDir = await fs.promises.mkdtemp(path.join(os.tmpdir(), "sd-replace-deps-"));
-
-    // Source package (simplysm/packages/solid)
-    const sourceDir = path.join(tmpDir, "simplysm", "packages", "solid");
-    await fs.promises.mkdir(sourceDir, { recursive: true });
-    await fs.promises.writeFile(path.join(sourceDir, "index.js"), "export default 1;");
-    await fs.promises.writeFile(path.join(sourceDir, "README.md"), "readme");
-
-    // Create items to be excluded
-    await fs.promises.mkdir(path.join(sourceDir, "node_modules"), { recursive: true });
-    await fs.promises.writeFile(path.join(sourceDir, "node_modules", "dep.js"), "dep");
-    await fs.promises.writeFile(path.join(sourceDir, "package.json"), '{"name":"solid"}');
-    await fs.promises.mkdir(path.join(sourceDir, ".cache"), { recursive: true });
-    await fs.promises.writeFile(path.join(sourceDir, ".cache", "file.txt"), "cache");
-    await fs.promises.mkdir(path.join(sourceDir, "tests"), { recursive: true });
-    await fs.promises.writeFile(path.join(sourceDir, "tests", "test.spec.ts"), "test");
-
-    // Target project (app/node_modules/@simplysm/solid)
-    // pnpm style: app/node_modules/@simplysm/solid → symlink to .pnpm store
-    const appRoot = path.join(tmpDir, "app");
-
-    // .pnpm store directory (where actual contents are)
-    const pnpmStoreTarget = path.join(
-      appRoot,
-      "node_modules",
-      ".pnpm",
-      "@simplysm+solid@1.0.0",
-      "node_modules",
-      "@simplysm",
-      "solid",
-    );
-    await fs.promises.mkdir(pnpmStoreTarget, { recursive: true });
-    await fs.promises.writeFile(path.join(pnpmStoreTarget, "index.js"), "old");
-
-    // node_modules/@simplysm/solid → symlink to .pnpm store
-    const nodeModulesSymlink = path.join(appRoot, "node_modules", "@simplysm", "solid");
-    await fs.promises.mkdir(path.dirname(nodeModulesSymlink), { recursive: true });
-    const relativeToStore = path.relative(path.dirname(nodeModulesSymlink), pnpmStoreTarget);
-    await fs.promises.symlink(relativeToStore, nodeModulesSymlink, "dir");
-  });
-
-  afterEach(async () => {
-    await fs.promises.rm(tmpDir, { recursive: true, force: true });
-  });
-
-  test("replaces package in node_modules by copying from source directory", async () => {
-    const appRoot = path.join(tmpDir, "app");
-
-    await setupReplaceDeps(appRoot, {
-      "@simplysm/*": "../simplysm/packages/*",
-    });
-
-    const targetPath = path.join(appRoot, "node_modules", "@simplysm", "solid");
-
-    // Symlink is preserved
-    const stat = await fs.promises.lstat(targetPath);
-    expect(stat.isSymbolicLink()).toBe(true);
-
-    // Verify source files are copied to symlink's actual path (.pnpm store)
-    const realPath = await fs.promises.realpath(targetPath);
-    const indexContent = await fs.promises.readFile(path.join(realPath, "index.js"), "utf-8");
-    expect(indexContent).toBe("export default 1;");
-
-    const readmeContent = await fs.promises.readFile(path.join(targetPath, "README.md"), "utf-8");
-    expect(readmeContent).toBe("readme");
-  });
-
-  test("excludes node_modules, package.json, .cache, and tests when copying", async () => {
-    const appRoot = path.join(tmpDir, "app");
-
-    await setupReplaceDeps(appRoot, {
-      "@simplysm/*": "../simplysm/packages/*",
-    });
-
-    const targetPath = path.join(appRoot, "node_modules", "@simplysm", "solid");
-
-    // Files to be copied
-    expect(fs.existsSync(path.join(targetPath, "index.js"))).toBe(true);
-    expect(fs.existsSync(path.join(targetPath, "README.md"))).toBe(true);
-
-    // Items to be excluded
-    expect(fs.existsSync(path.join(targetPath, "node_modules"))).toBe(false);
-    expect(fs.existsSync(path.join(targetPath, "package.json"))).toBe(false);
-    expect(fs.existsSync(path.join(targetPath, ".cache"))).toBe(false);
-    expect(fs.existsSync(path.join(targetPath, "tests"))).toBe(false);
-  });
-
-  test("skips package if source path does not exist", async () => {
-    const appRoot = path.join(tmpDir, "app");
-
-    // Create .pnpm store for no-exist package
-    const pnpmStoreNoExist = path.join(
-      appRoot,
-      "node_modules",
-      ".pnpm",
-      "@simplysm+no-exist@1.0.0",
-      "node_modules",
-      "@simplysm",
-      "no-exist",
-    );
-    await fs.promises.mkdir(pnpmStoreNoExist, { recursive: true });
-    await fs.promises.writeFile(path.join(pnpmStoreNoExist, "index.js"), "no-exist-old");
-
-    // node_modules/@simplysm/no-exist → symlink to .pnpm store
-    const noExistSymlink = path.join(appRoot, "node_modules", "@simplysm", "no-exist");
-    await fs.promises.mkdir(path.dirname(noExistSymlink), { recursive: true });
-    const relativeToStore = path.relative(path.dirname(noExistSymlink), pnpmStoreNoExist);
-    await fs.promises.symlink(relativeToStore, noExistSymlink, "dir");
-
-    // Should complete without error
-    await setupReplaceDeps(appRoot, {
-      "@simplysm/*": "../simplysm/packages/*",
-    });
-
-    // solid symlink is preserved, no-exist symlink remains unchanged
-    const solidPath = path.join(appRoot, "node_modules", "@simplysm", "solid");
-    const solidStat = await fs.promises.lstat(solidPath);
-    expect(solidStat.isSymbolicLink()).toBe(true);
-
-    const noExistStat = await fs.promises.lstat(noExistSymlink);
-    expect(noExistStat.isSymbolicLink()).toBe(true);
-  });
-
-  test("processes node_modules in workspace packages", async () => {
-    const appRoot = path.join(tmpDir, "app");
-
-    // Create workspace package structure (.pnpm store style)
-    const pkgPnpmStore = path.join(
-      appRoot,
-      "packages",
-      "client",
-      "node_modules",
-      ".pnpm",
-      "@simplysm+solid@1.0.0",
-      "node_modules",
-      "@simplysm",
-      "solid",
-    );
-    await fs.promises.mkdir(pkgPnpmStore, { recursive: true });
-    await fs.promises.writeFile(path.join(pkgPnpmStore, "index.js"), "old");
-
-    // node_modules/@simplysm/solid → symlink to .pnpm store
-    const pkgNodeModulesSymlink = path.join(
-      appRoot,
-      "packages",
-      "client",
-      "node_modules",
-      "@simplysm",
-      "solid",
-    );
-    await fs.promises.mkdir(path.dirname(pkgNodeModulesSymlink), { recursive: true });
-    const relativeToStore = path.relative(path.dirname(pkgNodeModulesSymlink), pkgPnpmStore);
-    await fs.promises.symlink(relativeToStore, pkgNodeModulesSymlink, "dir");
-
-    // Create pnpm-workspace.yaml
-    await fs.promises.writeFile(
-      path.join(appRoot, "pnpm-workspace.yaml"),
-      "packages:\n  - packages/*\n",
-    );
-
-    await setupReplaceDeps(appRoot, {
-      "@simplysm/*": "../simplysm/packages/*",
-    });
-
-    // Workspace package's node_modules symlink is also preserved
-    const stat = await fs.promises.lstat(pkgNodeModulesSymlink);
-    expect(stat.isSymbolicLink()).toBe(true);
-
-    // Verify source files are copied to symlink's actual path
-    const realPath = await fs.promises.realpath(pkgNodeModulesSymlink);
-    const indexContent = await fs.promises.readFile(path.join(realPath, "index.js"), "utf-8");
-    expect(indexContent).toBe("export default 1;");
-  });
-});
-
-describe("watchReplaceDeps", () => {
-  let tmpDir: string;
-
-  beforeEach(async () => {
-    tmpDir = await fs.promises.mkdtemp(path.join(os.tmpdir(), "sd-watch-replace-"));
-
-    // Source package (simplysm/packages/solid)
-    const sourceDir = path.join(tmpDir, "simplysm", "packages", "solid");
-    await fs.promises.mkdir(sourceDir, { recursive: true });
-    await fs.promises.writeFile(path.join(sourceDir, "index.js"), "export default 1;");
-
-    // Target project (.pnpm store style)
-    const appRoot = path.join(tmpDir, "app");
-    const pnpmStoreTarget = path.join(
-      appRoot,
-      "node_modules",
-      ".pnpm",
-      "@simplysm+solid@1.0.0",
-      "node_modules",
-      "@simplysm",
-      "solid",
-    );
-    await fs.promises.mkdir(pnpmStoreTarget, { recursive: true });
-    await fs.promises.writeFile(path.join(pnpmStoreTarget, "index.js"), "old");
-
-    const nodeModulesSymlink = path.join(appRoot, "node_modules", "@simplysm", "solid");
-    await fs.promises.mkdir(path.dirname(nodeModulesSymlink), { recursive: true });
-    const relativeToStore = path.relative(path.dirname(nodeModulesSymlink), pnpmStoreTarget);
-    await fs.promises.symlink(relativeToStore, nodeModulesSymlink, "dir");
-  });
-
-  afterEach(async () => {
-    await fs.promises.rm(tmpDir, { recursive: true, force: true });
-  });
-
-  test("copies source files to target when modified after watch starts", async () => {
-    const appRoot = path.join(tmpDir, "app");
-    const sourceDir = path.join(tmpDir, "simplysm", "packages", "solid");
-    const targetPath = path.join(appRoot, "node_modules", "@simplysm", "solid");
-
-    const { dispose } = await watchReplaceDeps(appRoot, {
-      "@simplysm/*": "../simplysm/packages/*",
-    });
-
-    // Modify source file
-    await fs.promises.writeFile(path.join(sourceDir, "index.js"), "export default 2;");
-    await new Promise((resolve) => setTimeout(resolve, 500)); // 300ms delay + buffer
-
-    const indexContent = await fs.promises.readFile(path.join(targetPath, "index.js"), "utf-8");
-    expect(indexContent).toBe("export default 2;");
-
-    dispose();
-  });
-});

package/tests/run-lint.spec.ts

@@ -1,366 +0,0 @@
-import { describe, expect, it, vi, beforeEach, afterEach } from "vitest";
-import path from "path";
-
-// State management hoisted via vi.hoisted
-const { mockState, mockJitiImportFn } = vi.hoisted(() => ({
-  mockState: {
-    lintResults: [] as Array<{ errorCount: number; warningCount: number }>,
-    lintedFiles: [] as string[],
-    outputFixesCalled: false,
-  },
-  mockJitiImportFn: vi.fn(),
-}));
-
-// Mock external dependencies
-
-vi.mock("eslint", () => {
-  class MockESLint {
-    lintFiles(files: string[]) {
-      mockState.lintedFiles = files;
-      return Promise.resolve(mockState.lintResults);
-    }
-    loadFormatter() {
-      return Promise.resolve({
-        format: () => Promise.resolve(""),
-      });
-    }
-    static outputFixes(_results: unknown) {
-      mockState.outputFixesCalled = true;
-    }
-  }
-
-  return { ESLint: MockESLint };
-});
-
-vi.mock("@simplysm/core-node", () => {
-  const posix = (p: string) => p.replace(/\\/g, "/");
-  const isChildPath = (child: string, parent: string) => {
-    if (child === parent) return false;
-    const parentWithSlash = parent.endsWith("/") ? parent : parent + "/";
-    return child.startsWith(parentWithSlash);
-  };
-  return {
-    fsx: {
-      exists: vi.fn(),
-      glob: vi.fn(),
-    },
-    pathx: {
-      posix: vi.fn(posix),
-      isChildPath: vi.fn(isChildPath),
-      filterByTargets: vi.fn((files: string[], targets: string[], cwd: string) => {
-        if (targets.length === 0) return files;
-        return files.filter((file) => {
-          const relativePath = posix(file.replace(cwd + "/", ""));
-          return targets.some(
-            (target) => relativePath === target || isChildPath(relativePath, target),
-          );
-        });
-      }),
-    },
-  };
-});
-
-vi.mock("jiti", () => ({
-  createJiti: vi.fn(() => ({
-    import: (configPath: string) => mockJitiImportFn(configPath),
-  })),
-}));
-
-vi.mock("consola", () => {
-  const mockLogger = {
-    debug: vi.fn(),
-    info: vi.fn(),
-    error: vi.fn(),
-    warn: vi.fn(),
-    start: vi.fn(),
-    success: vi.fn(),
-    fail: vi.fn(),
-    withTag: vi.fn(() => mockLogger),
-    level: 3, // info level
-  };
-  return {
-    consola: mockLogger,
-    default: mockLogger,
-    LogLevels: { debug: 4, info: 3, warn: 2, error: 1 },
-  };
-});
-
-import { fsx } from "@simplysm/core-node";
-import { runLint, executeLint } from "../src/commands/lint";
-
-describe("runLint", () => {
-  let originalExitCode: typeof process.exitCode;
-  let originalCwd: () => string;
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-    originalExitCode = process.exitCode;
-    originalCwd = process.cwd;
-    process.cwd = vi.fn().mockReturnValue("/project");
-
-    // Reset state
-    mockState.lintResults = [];
-    mockState.lintedFiles = [];
-    mockState.outputFixesCalled = false;
-  });
-
-  afterEach(() => {
-    vi.restoreAllMocks();
-    process.exitCode = originalExitCode;
-    process.cwd = originalCwd;
-  });
-
-  it("sets exitCode to 1 when lint errors occur", async () => {
-    const cwd = "/project";
-    vi.mocked(fsx.exists).mockImplementation((filePath: string) => {
-      return Promise.resolve(filePath === path.join(cwd, "eslint.config.ts"));
-    });
-
-    mockJitiImportFn.mockResolvedValue({
-      default: [{ ignores: ["node_modules/**"] }],
-    });
-
-    vi.mocked(fsx.glob).mockResolvedValue(["/project/src/index.ts"]);
-
-    mockState.lintResults = [{ errorCount: 2, warningCount: 0 }];
-
-    await runLint({ targets: [], fix: false, timing: false });
-
-    expect(process.exitCode).toBe(1);
-  });
-
-  it("does not set exitCode when no lint errors", async () => {
-    const cwd = "/project";
-    vi.mocked(fsx.exists).mockImplementation((filePath: string) => {
-      return Promise.resolve(filePath === path.join(cwd, "eslint.config.ts"));
-    });
-
-    mockJitiImportFn.mockResolvedValue({
-      default: [{ ignores: ["node_modules/**"] }],
-    });
-
-    vi.mocked(fsx.glob).mockResolvedValue(["/project/src/index.ts"]);
-
-    mockState.lintResults = [{ errorCount: 0, warningCount: 0 }];
-
-    await runLint({ targets: [], fix: false, timing: false });
-
-    expect(process.exitCode).toBeUndefined();
-  });
-
-  it("filters files using targets option", async () => {
-    const cwd = "/project";
-    vi.mocked(fsx.exists).mockImplementation((filePath: string) => {
-      return Promise.resolve(filePath === path.join(cwd, "eslint.config.ts"));
-    });
-
-    mockJitiImportFn.mockResolvedValue({
-      default: [{ ignores: ["node_modules/**"] }],
-    });
-
-    vi.mocked(fsx.glob).mockResolvedValue([
-      "/project/packages/core-common/src/index.ts",
-      "/project/packages/core-node/src/index.ts",
-      "/project/packages/cli/src/index.ts",
-    ]);
-
-    mockState.lintResults = [{ errorCount: 0, warningCount: 0 }];
-
-    await runLint({
-      targets: ["packages/core-common"],
-      fix: false,
-      timing: false,
-    });
-
-    expect(mockState.lintedFiles).toHaveLength(1);
-    expect(mockState.lintedFiles[0]).toContain("core-common");
-  });
-
-  it("filters files from all paths when multiple targets specified", async () => {
-    const cwd = "/project";
-    vi.mocked(fsx.exists).mockImplementation((filePath: string) => {
-      return Promise.resolve(filePath === path.join(cwd, "eslint.config.ts"));
-    });
-
-    mockJitiImportFn.mockResolvedValue({
-      default: [{ ignores: ["node_modules/**"] }],
-    });
-
-    vi.mocked(fsx.glob).mockResolvedValue([
-      "/project/packages/core-common/src/index.ts",
-      "/project/packages/core-node/src/index.ts",
-      "/project/packages/cli/src/index.ts",
-      "/project/tests/orm/src/test.spec.ts",
-    ]);
-
-    mockState.lintResults = [{ errorCount: 0, warningCount: 0 }];
-
-    await runLint({
-      targets: ["packages/core-common", "packages/cli"],
-      fix: false,
-      timing: false,
-    });
-
-    expect(mockState.lintedFiles).toHaveLength(2);
-    expect(mockState.lintedFiles.some((f) => f.includes("core-common"))).toBe(true);
-    expect(mockState.lintedFiles.some((f) => f.includes("cli"))).toBe(true);
-    expect(mockState.lintedFiles.some((f) => f.includes("core-node"))).toBe(false);
-    expect(mockState.lintedFiles.some((f) => f.includes("tests/orm"))).toBe(false);
-  });
-
-  it("calls ESLint.outputFixes when fix option is enabled", async () => {
-    const cwd = "/project";
-    vi.mocked(fsx.exists).mockImplementation((filePath: string) => {
-      return Promise.resolve(filePath === path.join(cwd, "eslint.config.ts"));
-    });
-
-    mockJitiImportFn.mockResolvedValue({
-      default: [{ ignores: ["node_modules/**"] }],
-    });
-
-    vi.mocked(fsx.glob).mockResolvedValue(["/project/src/index.ts"]);
-
-    mockState.lintResults = [{ errorCount: 0, warningCount: 0 }];
-
-    await runLint({ targets: [], fix: true, timing: false });
-
-    expect(mockState.outputFixesCalled).toBe(true);
-  });
-
-  it("exits early when no files to lint", async () => {
-    const cwd = "/project";
-    vi.mocked(fsx.exists).mockImplementation((filePath: string) => {
-      return Promise.resolve(filePath === path.join(cwd, "eslint.config.ts"));
-    });
-
-    mockJitiImportFn.mockResolvedValue({
-      default: [{ ignores: ["node_modules/**"] }],
-    });
-
-    vi.mocked(fsx.glob).mockResolvedValue([]);
-
-    await runLint({ targets: [], fix: false, timing: false });
-
-    // ESLint is not called, so lintedFiles stays empty
-    expect(mockState.lintedFiles).toHaveLength(0);
-    expect(process.exitCode).toBeUndefined();
-  });
-
-  it("throws error when ESLint config file is not found", async () => {
-    // When all config files are missing
-    vi.mocked(fsx.exists).mockResolvedValue(false);
-
-    await expect(runLint({ targets: [], fix: false, timing: false })).rejects.toThrow(
-      "Cannot find ESLint config file",
-    );
-
-    // Since error is thrown, exitCode must be set by caller (not set inside runLint)
-    // ESLint is not called
-    expect(mockState.lintedFiles).toHaveLength(0);
-  });
-
-  it("sets TIMING environment variable when timing option is enabled", async () => {
-    const cwd = "/project";
-    vi.mocked(fsx.exists).mockImplementation((filePath: string) => {
-      return Promise.resolve(filePath === path.join(cwd, "eslint.config.ts"));
-    });
-
-    mockJitiImportFn.mockResolvedValue({
-      default: [{ ignores: ["node_modules/**"] }],
-    });
-
-    vi.mocked(fsx.glob).mockResolvedValue(["/project/src/index.ts"]);
-
-    mockState.lintResults = [{ errorCount: 0, warningCount: 0 }];
-
-    const originalTiming = process.env["TIMING"];
-    delete process.env["TIMING"];
-
-    await runLint({ targets: [], fix: false, timing: true });
-
-    // Verify TIMING is set (set inside the function)
-    expect(process.env["TIMING"]).toBe("1");
-
-    // cleanup
-    if (originalTiming !== undefined) {
-      process.env["TIMING"] = originalTiming;
-    } else {
-      delete process.env["TIMING"];
-    }
-  });
-
-  it("uses eslint.config.mts when eslint.config.ts is not found", async () => {
-    const cwd = "/project";
-    vi.mocked(fsx.exists).mockImplementation((filePath: string) => {
-      // eslint.config.ts does not exist, only eslint.config.mts
-      return Promise.resolve(filePath === path.join(cwd, "eslint.config.mts"));
-    });
-
-    mockJitiImportFn.mockResolvedValue({
-      default: [{ ignores: ["dist/**"] }],
-    });
-
-    vi.mocked(fsx.glob).mockResolvedValue(["/project/src/index.ts"]);
-
-    mockState.lintResults = [{ errorCount: 0, warningCount: 0 }];
-
-    await runLint({ targets: [], fix: false, timing: false });
-
-    // Verify that mts file was loaded
-    expect(mockJitiImportFn).toHaveBeenCalledWith(expect.stringContaining("eslint.config.mts"));
-    expect(process.exitCode).toBeUndefined();
-  });
-
-});
-
-describe("executeLint", () => {
-  let originalCwd: () => string;
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-    originalCwd = process.cwd;
-    process.cwd = vi.fn().mockReturnValue("/project");
-
-    // Reset state
-    mockState.lintResults = [];
-    mockState.lintedFiles = [];
-    mockState.outputFixesCalled = false;
-
-    // Default ESLint config mock
-    const cwd = "/project";
-    vi.mocked(fsx.exists).mockImplementation((filePath: string) => {
-      return Promise.resolve(filePath === path.join(cwd, "eslint.config.ts"));
-    });
-    mockJitiImportFn.mockResolvedValue({
-      default: [{ ignores: ["node_modules/**"] }],
-    });
-  });
-
-  afterEach(() => {
-    vi.restoreAllMocks();
-    process.cwd = originalCwd;
-  });
-
-  it("returns success result when no errors", async () => {
-    mockState.lintResults = [{ errorCount: 0, warningCount: 0 }];
-    vi.mocked(fsx.glob).mockResolvedValue(["/project/packages/core-common/src/index.ts"]);
-
-    const result = await executeLint({ targets: [], fix: false, timing: false });
-
-    expect(result.success).toBe(true);
-    expect(result.errorCount).toBe(0);
-    expect(result.warningCount).toBe(0);
-  });
-
-  it("returns failure result when errors exist", async () => {
-    mockState.lintResults = [{ errorCount: 2, warningCount: 1 }];
-    vi.mocked(fsx.glob).mockResolvedValue(["/project/packages/core-common/src/index.ts"]);
-
-    const result = await executeLint({ targets: [], fix: false, timing: false });
-
-    expect(result.success).toBe(false);
-    expect(result.errorCount).toBe(2);
-    expect(result.warningCount).toBe(1);
-  });
-
-});