@ronkovic/aad 0.3.0

package/src/modules/planning/__tests__/project-detection.test.ts

@@ -0,0 +1,707 @@
+import { describe, test, expect } from "bun:test";
+import type { FileChecker } from "../project-detection";
+import {
+  detectProjectType,
+  detectPackageManager,
+  detectFramework,
+  detectTestFramework,
+  detectOrm,
+  detectArchitecturePattern,
+  isMonorepo,
+  detectWorkspaces,
+  analyzeProject,
+} from "../project-detection";
+
+// Mock FileChecker for testing
+function createMockFileChecker(files: Record<string, string>): FileChecker {
+  return {
+    async exists(filePath: string): Promise<boolean> {
+      // Extract basename for matching
+      const basename = filePath.split("/").pop() || filePath;
+      return basename in files || filePath in files;
+    },
+    async readText(filePath: string): Promise<string> {
+      const basename = filePath.split("/").pop() || filePath;
+      if (basename in files) {
+        if (typeof files[basename] === "string") return files[basename];
+      }
+      if (filePath in files) {
+        if (typeof files[filePath] === "string") return files[filePath];
+      }
+      throw new Error(`File not found: ${filePath}`);
+    },
+    async glob(pattern: string, _: string): Promise<string[]> {
+      // Simple mock: convert glob pattern to regex
+      const regexPattern = pattern
+        .replace(/\./g, "\\.")
+        .replace(/\*\*/g, "___DOUBLESTAR___")
+        .replace(/\*/g, "[^/]*")
+        .replace(/___DOUBLESTAR___/g, ".*");
+      const regex = new RegExp(`^${regexPattern}$`);
+      return Object.keys(files).filter((f) => regex.test(f));
+    },
+  };
+}
+
+describe("detectProjectType", () => {
+  test("detects Go project", async () => {
+    const checker = createMockFileChecker({ "go.mod": "" });
+    const result = await detectProjectType("/test", checker);
+    expect(result).toBe("go");
+  });
+
+  test("detects Go workspace", async () => {
+    const checker = createMockFileChecker({ "go.work": "" });
+    const result = await detectProjectType("/test", checker);
+    expect(result).toBe("go-workspace");
+  });
+
+  test("detects Rust project", async () => {
+    const checker = createMockFileChecker({ "Cargo.toml": "" });
+    const result = await detectProjectType("/test", checker);
+    expect(result).toBe("rust");
+  });
+
+  test("detects Python project with pyproject.toml", async () => {
+    const checker = createMockFileChecker({ "pyproject.toml": "" });
+    const result = await detectProjectType("/test", checker);
+    expect(result).toBe("python");
+  });
+
+  test("detects Python project with requirements.txt", async () => {
+    const checker = createMockFileChecker({ "requirements.txt": "" });
+    const result = await detectProjectType("/test", checker);
+    expect(result).toBe("python");
+  });
+
+  test("detects Next.js project", async () => {
+    const checker = createMockFileChecker({
+      "package.json": '{"dependencies": {"next": "^14.0.0"}}',
+    });
+    const result = await detectProjectType("/test", checker);
+    expect(result).toBe("nextjs");
+  });
+
+  test("detects Express project", async () => {
+    const checker = createMockFileChecker({
+      "package.json": '{"dependencies": {"express": "^4.0.0"}}',
+    });
+    const result = await detectProjectType("/test", checker);
+    expect(result).toBe("express");
+  });
+
+  test("detects React project", async () => {
+    const checker = createMockFileChecker({
+      "package.json": '{"dependencies": {"react": "^18.0.0"}}',
+    });
+    const result = await detectProjectType("/test", checker);
+    expect(result).toBe("react");
+  });
+
+  test("detects generic Node.js project", async () => {
+    const checker = createMockFileChecker({
+      "package.json": '{"dependencies": {"lodash": "^4.0.0"}}',
+    });
+    const result = await detectProjectType("/test", checker);
+    expect(result).toBe("nodejs");
+  });
+
+  test("detects Terraform project", async () => {
+    const checker = createMockFileChecker({ "main.tf": "" });
+    const result = await detectProjectType("/test", checker);
+    expect(result).toBe("terraform");
+  });
+
+  test("returns unknown for unrecognized project", async () => {
+    const checker = createMockFileChecker({ "README.md": "" });
+    const result = await detectProjectType("/test", checker);
+    expect(result).toBe("unknown");
+  });
+});
+
+describe("detectPackageManager", () => {
+  test("detects uv", async () => {
+    const checker = createMockFileChecker({ "uv.lock": "" });
+    const result = await detectPackageManager("/test", checker);
+    expect(result).toBe("uv");
+  });
+
+  test("detects poetry", async () => {
+    const checker = createMockFileChecker({ "poetry.lock": "" });
+    const result = await detectPackageManager("/test", checker);
+    expect(result).toBe("poetry");
+  });
+
+  test("detects pipenv", async () => {
+    const checker = createMockFileChecker({ "Pipfile.lock": "" });
+    const result = await detectPackageManager("/test", checker);
+    expect(result).toBe("pipenv");
+  });
+
+  test("detects pip", async () => {
+    const checker = createMockFileChecker({ "requirements.txt": "" });
+    const result = await detectPackageManager("/test", checker);
+    expect(result).toBe("pip");
+  });
+
+  test("detects pnpm", async () => {
+    const checker = createMockFileChecker({ "pnpm-lock.yaml": "" });
+    const result = await detectPackageManager("/test", checker);
+    expect(result).toBe("pnpm");
+  });
+
+  test("detects yarn", async () => {
+    const checker = createMockFileChecker({ "yarn.lock": "" });
+    const result = await detectPackageManager("/test", checker);
+    expect(result).toBe("yarn");
+  });
+
+  test("detects npm", async () => {
+    const checker = createMockFileChecker({ "package-lock.json": "" });
+    const result = await detectPackageManager("/test", checker);
+    expect(result).toBe("npm");
+  });
+
+  test("detects bun", async () => {
+    const checker = createMockFileChecker({ "bun.lockb": "" });
+    const result = await detectPackageManager("/test", checker);
+    expect(result).toBe("bun");
+  });
+
+  test("detects cargo", async () => {
+    const checker = createMockFileChecker({ "Cargo.lock": "" });
+    const result = await detectPackageManager("/test", checker);
+    expect(result).toBe("cargo");
+  });
+
+  test("detects go", async () => {
+    const checker = createMockFileChecker({ "go.sum": "" });
+    const result = await detectPackageManager("/test", checker);
+    expect(result).toBe("go");
+  });
+
+  test("returns unknown for unrecognized package manager", async () => {
+    const checker = createMockFileChecker({ "README.md": "" });
+    const result = await detectPackageManager("/test", checker);
+    expect(result).toBe("unknown");
+  });
+});
+
+describe("detectFramework", () => {
+  test("detects FastAPI", async () => {
+    const checker = createMockFileChecker({
+      "pyproject.toml": '[tool.poetry.dependencies]\nfastapi = "^0.100.0"',
+    });
+    const result = await detectFramework("/test", "python", checker);
+    expect(result).toBe("fastapi");
+  });
+
+  test("detects Django", async () => {
+    const checker = createMockFileChecker({
+      "pyproject.toml": '[tool.poetry.dependencies]\ndjango = "^4.0"',
+    });
+    const result = await detectFramework("/test", "python", checker);
+    expect(result).toBe("django");
+  });
+
+  test("detects Actix for Rust", async () => {
+    const checker = createMockFileChecker({
+      "Cargo.toml": '[dependencies]\nactix-web = "4.0"',
+    });
+    const result = await detectFramework("/test", "rust", checker);
+    expect(result).toBe("actix");
+  });
+
+  test("returns unknown for no framework", async () => {
+    const checker = createMockFileChecker({ "pyproject.toml": "" });
+    const result = await detectFramework("/test", "python", checker);
+    expect(result).toBe("unknown");
+  });
+
+  test("detects Flask for Python", async () => {
+    const checker = createMockFileChecker({
+      "pyproject.toml": '[tool.poetry.dependencies]\nflask = "^3.0"',
+    });
+    const result = await detectFramework("/test", "python", checker);
+    expect(result).toBe("flask");
+  });
+
+  test("returns unknown for Go", async () => {
+    const checker = createMockFileChecker({});
+    const result = await detectFramework("/test", "go", checker);
+    expect(result).toBe("unknown");
+  });
+
+  test("returns unknown for Go workspace", async () => {
+    const checker = createMockFileChecker({});
+    const result = await detectFramework("/test", "go-workspace", checker);
+    expect(result).toBe("unknown");
+  });
+
+  test("returns nextjs for nextjs project type", async () => {
+    const checker = createMockFileChecker({});
+    const result = await detectFramework("/test", "nextjs", checker);
+    expect(result).toBe("nextjs");
+  });
+
+  test("returns express for express project type", async () => {
+    const checker = createMockFileChecker({});
+    const result = await detectFramework("/test", "express", checker);
+    expect(result).toBe("express");
+  });
+
+  test("returns react for react project type", async () => {
+    const checker = createMockFileChecker({});
+    const result = await detectFramework("/test", "react", checker);
+    expect(result).toBe("react");
+  });
+
+  test("returns unknown for Rust without actix", async () => {
+    const checker = createMockFileChecker({ "Cargo.toml": "[dependencies]" });
+    const result = await detectFramework("/test", "rust", checker);
+    expect(result).toBe("unknown");
+  });
+
+  test("returns unknown for unknown project type", async () => {
+    const checker = createMockFileChecker({});
+    const result = await detectFramework("/test", "unknown", checker);
+    expect(result).toBe("unknown");
+  });
+
+  test("returns unknown for python without pyproject.toml", async () => {
+    const checker = createMockFileChecker({});
+    const result = await detectFramework("/test", "python", checker);
+    expect(result).toBe("unknown");
+  });
+
+  test("returns unknown for rust without Cargo.toml", async () => {
+    const checker = createMockFileChecker({});
+    const result = await detectFramework("/test", "rust", checker);
+    expect(result).toBe("unknown");
+  });
+});
+
+describe("detectTestFramework", () => {
+  test("detects go-test for Go", async () => {
+    const checker = createMockFileChecker({});
+    const result = await detectTestFramework("/test", "go", checker);
+    expect(result).toBe("go-test");
+  });
+
+  test("detects cargo-test for Rust", async () => {
+    const checker = createMockFileChecker({});
+    const result = await detectTestFramework("/test", "rust", checker);
+    expect(result).toBe("cargo-test");
+  });
+
+  test("detects pytest for Python", async () => {
+    const checker = createMockFileChecker({
+      "pyproject.toml": '[tool.poetry.dependencies]\npytest = "^7.0"',
+    });
+    const result = await detectTestFramework("/test", "python", checker);
+    expect(result).toBe("pytest");
+  });
+
+  test("defaults to unittest for Python", async () => {
+    const checker = createMockFileChecker({ "pyproject.toml": "" });
+    const result = await detectTestFramework("/test", "python", checker);
+    expect(result).toBe("unittest");
+  });
+
+  test("detects vitest for Node.js", async () => {
+    const checker = createMockFileChecker({
+      "package.json": '{"devDependencies": {"vitest": "^1.0.0"}}',
+    });
+    const result = await detectTestFramework("/test", "nodejs", checker);
+    expect(result).toBe("vitest");
+  });
+
+  test("detects jest for Node.js", async () => {
+    const checker = createMockFileChecker({
+      "package.json": '{"devDependencies": {"jest": "^29.0.0"}}',
+    });
+    const result = await detectTestFramework("/test", "nodejs", checker);
+    expect(result).toBe("jest");
+  });
+
+  test("detects bun:test for Bun projects", async () => {
+    const checker = createMockFileChecker({
+      "package.json": '{"devDependencies": {"bun-types": "^1.0.0"}}',
+    });
+    const result = await detectTestFramework("/test", "nodejs", checker);
+    expect(result).toBe("bun:test");
+  });
+
+  test("returns unknown for unknown project type", async () => {
+    const checker = createMockFileChecker({});
+    const result = await detectTestFramework("/test", "unknown", checker);
+    expect(result).toBe("unknown");
+  });
+
+  test("detects go-test for go-workspace", async () => {
+    const checker = createMockFileChecker({});
+    const result = await detectTestFramework("/test", "go-workspace", checker);
+    expect(result).toBe("go-test");
+  });
+
+  test("detects terraform-validate", async () => {
+    const checker = createMockFileChecker({});
+    const result = await detectTestFramework("/test", "terraform", checker);
+    expect(result).toBe("terraform-validate");
+  });
+
+  test("detects mocha for nodejs", async () => {
+    const checker = createMockFileChecker({
+      "package.json": '{"devDependencies": {"mocha": "^10.0.0"}}',
+    });
+    const result = await detectTestFramework("/test", "nodejs", checker);
+    expect(result).toBe("mocha");
+  });
+
+  test("returns unknown for nodejs without test framework", async () => {
+    const checker = createMockFileChecker({
+      "package.json": '{"dependencies": {"lodash": "^4.0"}}',
+    });
+    const result = await detectTestFramework("/test", "nodejs", checker);
+    expect(result).toBe("unknown");
+  });
+
+  test("returns unknown for nodejs without package.json", async () => {
+    const checker = createMockFileChecker({});
+    const result = await detectTestFramework("/test", "nodejs", checker);
+    expect(result).toBe("unknown");
+  });
+
+  test("detects python unittest without pyproject.toml", async () => {
+    const checker = createMockFileChecker({});
+    const result = await detectTestFramework("/test", "python", checker);
+    expect(result).toBe("unittest");
+  });
+
+  test("detects bun:test via @types/bun", async () => {
+    const checker = createMockFileChecker({
+      "package.json": '{"devDependencies": {"@types/bun": "^1.0.0"}}',
+    });
+    const result = await detectTestFramework("/test", "nextjs", checker);
+    expect(result).toBe("bun:test");
+  });
+
+  test("detects test framework for react project type", async () => {
+    const checker = createMockFileChecker({
+      "package.json": '{"devDependencies": {"vitest": "^1.0.0"}}',
+    });
+    const result = await detectTestFramework("/test", "react", checker);
+    expect(result).toBe("vitest");
+  });
+
+  test("detects test framework for express project type", async () => {
+    const checker = createMockFileChecker({
+      "package.json": '{"devDependencies": {"jest": "^29.0.0"}}',
+    });
+    const result = await detectTestFramework("/test", "express", checker);
+    expect(result).toBe("jest");
+  });
+});
+
+describe("detectOrm", () => {
+  test("detects GORM for Go", async () => {
+    const checker = createMockFileChecker({
+      "go.mod": "module example\n\nrequire gorm.io/gorm v1.25.0",
+    });
+    const result = await detectOrm("/test", "go", checker);
+    expect(result).toBe("gorm");
+  });
+
+  test("detects SQLAlchemy for Python", async () => {
+    const checker = createMockFileChecker({
+      "pyproject.toml": '[tool.poetry.dependencies]\nsqlalchemy = "^2.0"',
+    });
+    const result = await detectOrm("/test", "python", checker);
+    expect(result).toBe("sqlalchemy");
+  });
+
+  test("detects Diesel for Rust", async () => {
+    const checker = createMockFileChecker({
+      "Cargo.toml": '[dependencies]\ndiesel = "2.0"',
+    });
+    const result = await detectOrm("/test", "rust", checker);
+    expect(result).toBe("diesel");
+  });
+
+  test("detects Prisma for Node.js", async () => {
+    const checker = createMockFileChecker({
+      "package.json": '{"devDependencies": {"prisma": "^5.0.0"}}',
+    });
+    const result = await detectOrm("/test", "nodejs", checker);
+    expect(result).toBe("prisma");
+  });
+
+  test("returns unknown for no ORM", async () => {
+    const checker = createMockFileChecker({ "package.json": "{}" });
+    const result = await detectOrm("/test", "nodejs", checker);
+    expect(result).toBe("unknown");
+  });
+
+  test("detects sqlc for Go", async () => {
+    const checker = createMockFileChecker({ "sqlc.yaml": "" });
+    const result = await detectOrm("/test", "go", checker);
+    expect(result).toBe("sqlc");
+  });
+
+  test("detects sqlx for Go", async () => {
+    const checker = createMockFileChecker({
+      "go.mod": "module example\n\nrequire jmoiron/sqlx v1.0",
+    });
+    const result = await detectOrm("/test", "go", checker);
+    expect(result).toBe("sqlx");
+  });
+
+  test("returns unknown for Go without ORM", async () => {
+    const checker = createMockFileChecker({ "go.mod": "module example" });
+    const result = await detectOrm("/test", "go", checker);
+    expect(result).toBe("unknown");
+  });
+
+  test("returns unknown for Go without go.mod", async () => {
+    const checker = createMockFileChecker({});
+    const result = await detectOrm("/test", "go", checker);
+    expect(result).toBe("unknown");
+  });
+
+  test("detects tortoise for Python", async () => {
+    const checker = createMockFileChecker({
+      "pyproject.toml": '[tool.poetry.dependencies]\ntortoise = "^0.20"',
+    });
+    const result = await detectOrm("/test", "python", checker);
+    expect(result).toBe("tortoise");
+  });
+
+  test("returns unknown for Python without ORM", async () => {
+    const checker = createMockFileChecker({ "pyproject.toml": "" });
+    const result = await detectOrm("/test", "python", checker);
+    expect(result).toBe("unknown");
+  });
+
+  test("returns unknown for Python without pyproject.toml", async () => {
+    const checker = createMockFileChecker({});
+    const result = await detectOrm("/test", "python", checker);
+    expect(result).toBe("unknown");
+  });
+
+  test("detects sqlx for Rust", async () => {
+    const checker = createMockFileChecker({
+      "Cargo.toml": '[dependencies]\nsqlx = "0.7"',
+    });
+    const result = await detectOrm("/test", "rust", checker);
+    expect(result).toBe("sqlx");
+  });
+
+  test("detects sea-orm for Rust", async () => {
+    const checker = createMockFileChecker({
+      "Cargo.toml": '[dependencies]\nsea-orm = "0.12"',
+    });
+    const result = await detectOrm("/test", "rust", checker);
+    expect(result).toBe("sea-orm");
+  });
+
+  test("returns unknown for Rust without ORM", async () => {
+    const checker = createMockFileChecker({ "Cargo.toml": "[dependencies]" });
+    const result = await detectOrm("/test", "rust", checker);
+    expect(result).toBe("unknown");
+  });
+
+  test("returns unknown for Rust without Cargo.toml", async () => {
+    const checker = createMockFileChecker({});
+    const result = await detectOrm("/test", "rust", checker);
+    expect(result).toBe("unknown");
+  });
+
+  test("detects drizzle for nodejs", async () => {
+    const checker = createMockFileChecker({
+      "package.json": '{"dependencies": {"drizzle-orm": "^0.29"}}',
+    });
+    const result = await detectOrm("/test", "nodejs", checker);
+    expect(result).toBe("drizzle");
+  });
+
+  test("detects typeorm for nodejs", async () => {
+    const checker = createMockFileChecker({
+      "package.json": '{"dependencies": {"typeorm": "^0.3"}}',
+    });
+    const result = await detectOrm("/test", "nodejs", checker);
+    expect(result).toBe("typeorm");
+  });
+
+  test("detects sequelize for nodejs", async () => {
+    const checker = createMockFileChecker({
+      "package.json": '{"dependencies": {"sequelize": "^6"}}',
+    });
+    const result = await detectOrm("/test", "nodejs", checker);
+    expect(result).toBe("sequelize");
+  });
+
+  test("returns unknown for nodejs without package.json", async () => {
+    const checker = createMockFileChecker({});
+    const result = await detectOrm("/test", "nodejs", checker);
+    expect(result).toBe("unknown");
+  });
+
+  test("detects ORM for go-workspace", async () => {
+    const checker = createMockFileChecker({ "sqlc.yaml": "" });
+    const result = await detectOrm("/test", "go-workspace", checker);
+    expect(result).toBe("sqlc");
+  });
+
+  test("detects ORM for nextjs", async () => {
+    const checker = createMockFileChecker({
+      "package.json": '{"dependencies": {"prisma": "^5"}}',
+    });
+    const result = await detectOrm("/test", "nextjs", checker);
+    expect(result).toBe("prisma");
+  });
+
+  test("detects ORM for react", async () => {
+    const checker = createMockFileChecker({
+      "package.json": '{"dependencies": {"drizzle-orm": "^0.29"}}',
+    });
+    const result = await detectOrm("/test", "react", checker);
+    expect(result).toBe("drizzle");
+  });
+
+  test("detects ORM for express", async () => {
+    const checker = createMockFileChecker({
+      "package.json": '{"dependencies": {"sequelize": "^6"}}',
+    });
+    const result = await detectOrm("/test", "express", checker);
+    expect(result).toBe("sequelize");
+  });
+
+  test("returns unknown for unknown project type", async () => {
+    const checker = createMockFileChecker({});
+    const result = await detectOrm("/test", "unknown", checker);
+    expect(result).toBe("unknown");
+  });
+
+  test("returns unknown for terraform", async () => {
+    const checker = createMockFileChecker({});
+    const result = await detectOrm("/test", "terraform", checker);
+    expect(result).toBe("unknown");
+  });
+});
+
+describe("isMonorepo", () => {
+  test("detects Go workspace as monorepo", async () => {
+    const checker = createMockFileChecker({ "go.work": "" });
+    const result = await isMonorepo("/test", checker);
+    expect(result).toBe(true);
+  });
+
+  test("detects npm workspaces as monorepo", async () => {
+    const checker = createMockFileChecker({
+      "package.json": '{"workspaces": ["packages/*"]}',
+    });
+    const result = await isMonorepo("/test", checker);
+    expect(result).toBe(true);
+  });
+
+  test("detects multiple language files as monorepo", async () => {
+    const checker = createMockFileChecker({
+      "backend/go.mod": "",
+      "frontend/package.json": "",
+    });
+    const result = await isMonorepo("/test", checker);
+    expect(result).toBe(true);
+  });
+
+  test("returns false for single project", async () => {
+    const checker = createMockFileChecker({ "go.mod": "" });
+    const result = await isMonorepo("/test", checker);
+    expect(result).toBe(false);
+  });
+});
+
+describe("detectWorkspaces", () => {
+  test("returns root for single project", async () => {
+    const checker = createMockFileChecker({ "go.mod": "" });
+    const result = await detectWorkspaces("/test", checker);
+    expect(result).toEqual(["/test"]);
+  });
+
+  test("detects multiple workspaces in monorepo", async () => {
+    const checker = createMockFileChecker({
+      "go.work": "",
+      "backend/go.mod": "",
+      "frontend/package.json": "",
+    });
+    const result = await detectWorkspaces("/test", checker);
+    expect(result.length).toBeGreaterThan(0);
+  });
+});
+
+describe("detectArchitecturePattern", () => {
+  test("detects go-standard-layout", async () => {
+    const checker = createMockFileChecker({ internal: "", cmd: "" });
+    const result = await detectArchitecturePattern("/test", checker);
+    expect(result).toBe("go-standard-layout");
+  });
+
+  test("detects clean-architecture", async () => {
+    const checker = createMockFileChecker({ usecases: "", gateways: "" });
+    const result = await detectArchitecturePattern("/test", checker);
+    expect(result).toBe("clean-architecture");
+  });
+
+  test("detects ddd-layered", async () => {
+    const checker = createMockFileChecker({ domain: "", infrastructure: "" });
+    const result = await detectArchitecturePattern("/test", checker);
+    expect(result).toBe("ddd-layered");
+  });
+
+  test("detects react-standard", async () => {
+    const mockChecker: FileChecker = {
+      async exists(filePath: string): Promise<boolean> {
+        return filePath.endsWith("src/components");
+      },
+      async readText(): Promise<string> { return ""; },
+      async glob(): Promise<string[]> { return []; },
+    };
+    const result = await detectArchitecturePattern("/test", mockChecker);
+    expect(result).toBe("react-standard");
+  });
+
+  test("returns custom for no recognized pattern", async () => {
+    const checker = createMockFileChecker({});
+    const result = await detectArchitecturePattern("/test", checker);
+    expect(result).toBe("custom");
+  });
+});
+
+describe("analyzeProject", () => {
+  test("analyzes single Go project", async () => {
+    const checker = createMockFileChecker({
+      "go.mod": "module example",
+      "go.sum": "",
+    });
+    const result = await analyzeProject("/test", checker);
+
+    expect(result.projectType).toBe("go");
+    expect(result.packageManager).toBe("go");
+    expect(result.isMonorepo).toBe(false);
+    expect(result.workspaces).toHaveLength(1);
+    expect(result.workspaces[0]?.path).toBe("/test");
+  });
+
+  test("analyzes Next.js monorepo", async () => {
+    const checker = createMockFileChecker({
+      "package.json": '{"workspaces": ["apps/*"], "dependencies": {"next": "14.0.0"}}',
+      "pnpm-lock.yaml": "",
+      "apps/web/package.json": '{"dependencies": {"next": "14.0.0"}}',
+    });
+    const result = await analyzeProject("/test", checker);
+
+    expect(result.projectType).toBe("nextjs");
+    expect(result.packageManager).toBe("pnpm");
+    expect(result.isMonorepo).toBe(true);
+    expect(result.framework).toBe("nextjs");
+  });
+});