@ronkovic/aad 0.3.0

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

@@ -0,0 +1,525 @@
+// Project Detection - port from .aad/scripts/lib/project-detection.sh
+// Detects project type, package manager, framework, test framework, ORM, and architecture patterns
+
+import path from "node:path";
+
+// Type Definitions
+export type ProjectType =
+  | "go"
+  | "go-workspace"
+  | "rust"
+  | "python"
+  | "nodejs"
+  | "nextjs"
+  | "express"
+  | "react"
+  | "terraform"
+  | "unknown";
+
+export type PackageManager =
+  | "uv"
+  | "poetry"
+  | "pipenv"
+  | "pip"
+  | "pnpm"
+  | "yarn"
+  | "npm"
+  | "bun"
+  | "cargo"
+  | "go"
+  | "unknown";
+
+export type TestFramework =
+  | "pytest"
+  | "unittest"
+  | "vitest"
+  | "jest"
+  | "bun:test"
+  | "mocha"
+  | "go-test"
+  | "cargo-test"
+  | "terraform-validate"
+  | "unknown";
+
+export type Framework =
+  | "nextjs"
+  | "express"
+  | "react"
+  | "fastapi"
+  | "django"
+  | "flask"
+  | "gin"
+  | "echo"
+  | "actix"
+  | "unknown";
+
+export type OrmType =
+  | "prisma"
+  | "drizzle"
+  | "typeorm"
+  | "sequelize"
+  | "sqlalchemy"
+  | "tortoise"
+  | "gorm"
+  | "sqlx"
+  | "sqlc"
+  | "diesel"
+  | "sea-orm"
+  | "unknown";
+
+export type ArchitecturePattern =
+  | "hexagonal"
+  | "clean-architecture"
+  | "ddd-layered"
+  | "go-standard-layout"
+  | "react-standard"
+  | "custom"
+  | "unknown";
+
+export interface WorkspaceInfo {
+  path: string;
+  projectType: ProjectType;
+  packageManager: PackageManager;
+  testFramework: TestFramework;
+  framework?: Framework;
+  orm?: OrmType;
+  architecture?: ArchitecturePattern;
+}
+
+export interface ProjectAnalysis {
+  projectType: ProjectType;
+  packageManager: PackageManager;
+  isMonorepo: boolean;
+  workspaces: WorkspaceInfo[];
+  framework?: Framework;
+  orm?: OrmType;
+  architecture?: ArchitecturePattern;
+}
+
+// FileChecker interface for dependency injection (testability)
+export interface FileChecker {
+  exists(path: string): Promise<boolean>;
+  readText(path: string): Promise<string>;
+  glob(pattern: string, cwd: string): Promise<string[]>;
+}
+
+// Bun-based FileChecker implementation
+export function createBunFileChecker(): FileChecker {
+  return {
+    async exists(filePath: string): Promise<boolean> {
+      return await Bun.file(filePath).exists();
+    },
+    async readText(filePath: string): Promise<string> {
+      try {
+        return await Bun.file(filePath).text();
+      } catch {
+        return "";
+      }
+    },
+    async glob(pattern: string, cwd: string): Promise<string[]> {
+      const globber = new Bun.Glob(pattern);
+      const matches: string[] = [];
+      for await (const file of globber.scan({
+        cwd,
+        absolute: false,
+        onlyFiles: true,
+      })) {
+        // Exclude node_modules, .git, and .aad directories
+        if (
+          !file.includes("node_modules/") &&
+          !file.includes(".git/") &&
+          !file.includes(".aad/")
+        ) {
+          matches.push(file);
+        }
+      }
+      return matches;
+    },
+  };
+}
+
+// ============================================================
+// Project Type Detection
+// ============================================================
+
+export async function detectProjectType(
+  projectRoot: string,
+  checker: FileChecker
+): Promise<ProjectType> {
+  // Go
+  if (await checker.exists(path.join(projectRoot, "go.work"))) {
+    return "go-workspace";
+  }
+  if (await checker.exists(path.join(projectRoot, "go.mod"))) {
+    return "go";
+  }
+
+  // Rust
+  if (await checker.exists(path.join(projectRoot, "Cargo.toml"))) {
+    return "rust";
+  }
+
+  // Python
+  if (await checker.exists(path.join(projectRoot, "pyproject.toml"))) {
+    return "python";
+  }
+  if (await checker.exists(path.join(projectRoot, "requirements.txt"))) {
+    return "python";
+  }
+
+  // Node.js/TypeScript
+  const packageJsonPath = path.join(projectRoot, "package.json");
+  if (await checker.exists(packageJsonPath)) {
+    const content = await checker.readText(packageJsonPath);
+    if (content.includes('"next"')) return "nextjs";
+    if (content.includes('"express"')) return "express";
+    if (content.includes('"react"')) return "react";
+    return "nodejs";
+  }
+
+  // Terraform
+  const tfFiles = await checker.glob("*.tf", projectRoot);
+  if (tfFiles.length > 0) {
+    return "terraform";
+  }
+
+  return "unknown";
+}
+
+// ============================================================
+// Package Manager Detection
+// ============================================================
+
+export async function detectPackageManager(
+  projectRoot: string,
+  checker: FileChecker
+): Promise<PackageManager> {
+  // Python
+  if (await checker.exists(path.join(projectRoot, "uv.lock"))) return "uv";
+  if (await checker.exists(path.join(projectRoot, "poetry.lock"))) return "poetry";
+  if (await checker.exists(path.join(projectRoot, "Pipfile.lock"))) return "pipenv";
+  if (await checker.exists(path.join(projectRoot, "requirements.txt"))) return "pip";
+
+  // Node.js
+  if (await checker.exists(path.join(projectRoot, "pnpm-lock.yaml"))) return "pnpm";
+  if (await checker.exists(path.join(projectRoot, "yarn.lock"))) return "yarn";
+  if (await checker.exists(path.join(projectRoot, "package-lock.json"))) return "npm";
+  if (await checker.exists(path.join(projectRoot, "bun.lockb"))) return "bun";
+
+  // Rust/Go
+  if (await checker.exists(path.join(projectRoot, "Cargo.lock"))) return "cargo";
+  if (await checker.exists(path.join(projectRoot, "go.sum"))) return "go";
+
+  return "unknown";
+}
+
+// ============================================================
+// Framework Detection
+// ============================================================
+
+export async function detectFramework(
+  projectRoot: string,
+  projectType: ProjectType,
+  checker: FileChecker
+): Promise<Framework> {
+  switch (projectType) {
+    case "python": {
+      const pyprojectPath = path.join(projectRoot, "pyproject.toml");
+      if (await checker.exists(pyprojectPath)) {
+        const content = await checker.readText(pyprojectPath);
+        if (content.includes("fastapi")) return "fastapi";
+        if (content.includes("django")) return "django";
+        if (content.includes("flask")) return "flask";
+      }
+      break;
+    }
+    case "rust": {
+      const cargoPath = path.join(projectRoot, "Cargo.toml");
+      if (await checker.exists(cargoPath)) {
+        const content = await checker.readText(cargoPath);
+        if (content.includes("actix")) return "actix";
+      }
+      break;
+    }
+    case "go":
+    case "go-workspace":
+      return "unknown"; // Go typically doesn't use heavy frameworks
+    case "nextjs":
+      return "nextjs";
+    case "express":
+      return "express";
+    case "react":
+      return "react";
+  }
+  return "unknown";
+}
+
+// ============================================================
+// Test Framework Detection
+// ============================================================
+
+export async function detectTestFramework(
+  projectRoot: string,
+  projectType: ProjectType,
+  checker: FileChecker
+): Promise<TestFramework> {
+  switch (projectType) {
+    case "go":
+    case "go-workspace":
+      return "go-test";
+
+    case "rust":
+      return "cargo-test";
+
+    case "python": {
+      const pyprojectPath = path.join(projectRoot, "pyproject.toml");
+      if (await checker.exists(pyprojectPath)) {
+        const content = await checker.readText(pyprojectPath);
+        if (content.includes("pytest")) return "pytest";
+      }
+      return "unittest";
+    }
+
+    case "nextjs":
+    case "react":
+    case "express":
+    case "nodejs": {
+      const packageJsonPath = path.join(projectRoot, "package.json");
+      if (await checker.exists(packageJsonPath)) {
+        const content = await checker.readText(packageJsonPath);
+        if (content.includes('"bun-types"') || content.includes('"@types/bun"')) {
+          return "bun:test";
+        }
+        if (content.includes('"vitest"')) return "vitest";
+        if (content.includes('"jest"')) return "jest";
+        if (content.includes('"mocha"')) return "mocha";
+      }
+      return "unknown";
+    }
+
+    case "terraform":
+      return "terraform-validate";
+
+    default:
+      return "unknown";
+  }
+}
+
+// ============================================================
+// ORM Detection
+// ============================================================
+
+export async function detectOrm(
+  projectRoot: string,
+  projectType: ProjectType,
+  checker: FileChecker
+): Promise<OrmType> {
+  switch (projectType) {
+    case "go":
+    case "go-workspace": {
+      if (await checker.exists(path.join(projectRoot, "sqlc.yaml"))) return "sqlc";
+      const goModPath = path.join(projectRoot, "go.mod");
+      if (await checker.exists(goModPath)) {
+        const content = await checker.readText(goModPath);
+        if (content.includes("gorm.io/gorm")) return "gorm";
+        if (content.includes("jmoiron/sqlx")) return "sqlx";
+      }
+      break;
+    }
+
+    case "python": {
+      const pyprojectPath = path.join(projectRoot, "pyproject.toml");
+      if (await checker.exists(pyprojectPath)) {
+        const content = await checker.readText(pyprojectPath);
+        if (content.includes("sqlalchemy")) return "sqlalchemy";
+        if (content.includes("tortoise")) return "tortoise";
+      }
+      break;
+    }
+
+    case "rust": {
+      const cargoPath = path.join(projectRoot, "Cargo.toml");
+      if (await checker.exists(cargoPath)) {
+        const content = await checker.readText(cargoPath);
+        if (content.includes("sqlx")) return "sqlx";
+        if (content.includes("diesel")) return "diesel";
+        if (content.includes("sea-orm")) return "sea-orm";
+      }
+      break;
+    }
+
+    case "nextjs":
+    case "react":
+    case "express":
+    case "nodejs": {
+      const packageJsonPath = path.join(projectRoot, "package.json");
+      if (await checker.exists(packageJsonPath)) {
+        const content = await checker.readText(packageJsonPath);
+        if (content.includes('"prisma"')) return "prisma";
+        if (content.includes('"drizzle-orm"')) return "drizzle";
+        if (content.includes('"typeorm"')) return "typeorm";
+        if (content.includes('"sequelize"')) return "sequelize";
+      }
+      break;
+    }
+  }
+  return "unknown";
+}
+
+// ============================================================
+// Architecture Pattern Detection
+// ============================================================
+
+export async function detectArchitecturePattern(
+  projectRoot: string,
+  checker: FileChecker
+): Promise<ArchitecturePattern> {
+  // Go standard layout
+  if (
+    (await checker.exists(path.join(projectRoot, "internal"))) &&
+    (await checker.exists(path.join(projectRoot, "cmd")))
+  ) {
+    return "go-standard-layout";
+  }
+
+  // Clean Architecture
+  if (
+    (await checker.exists(path.join(projectRoot, "usecases"))) &&
+    (await checker.exists(path.join(projectRoot, "gateways")))
+  ) {
+    return "clean-architecture";
+  }
+
+  // DDD Layered
+  if (
+    (await checker.exists(path.join(projectRoot, "domain"))) &&
+    (await checker.exists(path.join(projectRoot, "infrastructure")))
+  ) {
+    return "ddd-layered";
+  }
+
+  // React standard
+  if (await checker.exists(path.join(projectRoot, "src/components"))) {
+    return "react-standard";
+  }
+
+  return "custom";
+}
+
+// ============================================================
+// Monorepo Detection
+// ============================================================
+
+export async function isMonorepo(
+  projectRoot: string,
+  checker: FileChecker
+): Promise<boolean> {
+  // Go workspace
+  if (await checker.exists(path.join(projectRoot, "go.work"))) {
+    return true;
+  }
+
+  // npm/yarn/pnpm workspaces
+  const packageJsonPath = path.join(projectRoot, "package.json");
+  if (await checker.exists(packageJsonPath)) {
+    const content = await checker.readText(packageJsonPath);
+    if (content.includes('"workspaces"')) {
+      return true;
+    }
+  }
+
+  // Multiple language files in subdirectories
+  const patterns = ["**/go.mod", "**/package.json", "**/Cargo.toml", "**/pyproject.toml"];
+  let totalCount = 0;
+
+  for (const pattern of patterns) {
+    const matches = await checker.glob(pattern, projectRoot);
+    totalCount += matches.length;
+  }
+
+  return totalCount > 1;
+}
+
+// ============================================================
+// Workspace Detection
+// ============================================================
+
+export async function detectWorkspaces(
+  projectRoot: string,
+  checker: FileChecker
+): Promise<string[]> {
+  if (!(await isMonorepo(projectRoot, checker))) {
+    // Single project: return root only
+    return [projectRoot];
+  }
+
+  const workspaces = new Set<string>();
+  workspaces.add(projectRoot);
+
+  // Scan for language-specific project files
+  const patterns = [
+    { pattern: "**/go.mod", maxDepth: 3 },
+    { pattern: "**/package.json", maxDepth: 3 },
+    { pattern: "**/Cargo.toml", maxDepth: 3 },
+    { pattern: "**/pyproject.toml", maxDepth: 3 },
+  ];
+
+  for (const { pattern } of patterns) {
+    const matches = await checker.glob(pattern, projectRoot);
+    for (const match of matches) {
+      const dir = path.dirname(path.join(projectRoot, match));
+      workspaces.add(dir);
+    }
+  }
+
+  return Array.from(workspaces).sort();
+}
+
+// ============================================================
+// Full Project Analysis
+// ============================================================
+
+export async function analyzeProject(
+  projectRoot: string,
+  checker: FileChecker = createBunFileChecker()
+): Promise<ProjectAnalysis> {
+  const projectType = await detectProjectType(projectRoot, checker);
+  const packageManager = await detectPackageManager(projectRoot, checker);
+  const mono = await isMonorepo(projectRoot, checker);
+  const workspacePaths = await detectWorkspaces(projectRoot, checker);
+
+  const framework = await detectFramework(projectRoot, projectType, checker);
+  const orm = await detectOrm(projectRoot, projectType, checker);
+  const architecture = await detectArchitecturePattern(projectRoot, checker);
+
+  const workspaces: WorkspaceInfo[] = await Promise.all(
+    workspacePaths.map(async (wsPath) => {
+      const wsType = await detectProjectType(wsPath, checker);
+      const wsPkgMgr = await detectPackageManager(wsPath, checker);
+      const wsTestFw = await detectTestFramework(wsPath, wsType, checker);
+      const wsFw = await detectFramework(wsPath, wsType, checker);
+      const wsOrm = await detectOrm(wsPath, wsType, checker);
+      const wsArch = await detectArchitecturePattern(wsPath, checker);
+
+      return {
+        path: wsPath,
+        projectType: wsType,
+        packageManager: wsPkgMgr,
+        testFramework: wsTestFw,
+        framework: wsFw !== "unknown" ? wsFw : undefined,
+        orm: wsOrm !== "unknown" ? wsOrm : undefined,
+        architecture: wsArch !== "custom" ? wsArch : undefined,
+      };
+    })
+  );
+
+  return {
+    projectType,
+    packageManager,
+    isMonorepo: mono,
+    workspaces,
+    framework: framework !== "unknown" ? framework : undefined,
+    orm: orm !== "unknown" ? orm : undefined,
+    architecture: architecture !== "custom" ? architecture : undefined,
+  };
+}

package/src/modules/plugin/__tests__/plugin-loader.test.ts

@@ -0,0 +1,83 @@
+import { describe, test, expect } from "bun:test";
+import { loadPlugin } from "../plugin-loader";
+import { join } from "node:path";
+import { writeFileSync, mkdirSync, rmSync } from "node:fs";
+
+const fixturesDir = join(import.meta.dir, "__fixtures__");
+
+function setupFixtures() {
+  mkdirSync(fixturesDir, { recursive: true });
+
+  // Valid plugin
+  writeFileSync(
+    join(fixturesDir, "valid-plugin.ts"),
+    `export default {
+      name: "valid-plugin",
+      version: "1.0.0",
+      activate() {},
+      deactivate() {},
+    };`
+  );
+
+  // Invalid plugin (missing activate)
+  writeFileSync(
+    join(fixturesDir, "invalid-plugin.ts"),
+    `export default {
+      name: "invalid",
+      version: "1.0.0",
+    };`
+  );
+
+  // Invalid plugin (missing name)
+  writeFileSync(
+    join(fixturesDir, "no-name-plugin.ts"),
+    `export default {
+      version: "1.0.0",
+      activate() {},
+    };`
+  );
+}
+
+function cleanupFixtures() {
+  try {
+    rmSync(fixturesDir, { recursive: true, force: true });
+  } catch {
+    // ignore
+  }
+}
+
+describe("loadPlugin", () => {
+  test("loads a valid plugin from absolute path", async () => {
+    setupFixtures();
+    try {
+      const plugin = await loadPlugin(join(fixturesDir, "valid-plugin.ts"));
+      expect(plugin.name).toBe("valid-plugin");
+      expect(plugin.version).toBe("1.0.0");
+      expect(typeof plugin.activate).toBe("function");
+    } finally {
+      cleanupFixtures();
+    }
+  });
+
+  test("rejects invalid plugin (missing activate)", async () => {
+    setupFixtures();
+    try {
+      await expect(loadPlugin(join(fixturesDir, "invalid-plugin.ts"))).rejects.toThrow("Invalid plugin");
+    } finally {
+      cleanupFixtures();
+    }
+  });
+
+  test("rejects invalid plugin (missing name)", async () => {
+    setupFixtures();
+    try {
+      await expect(loadPlugin(join(fixturesDir, "no-name-plugin.ts"))).rejects.toThrow("Invalid plugin");
+    } finally {
+      cleanupFixtures();
+    }
+  });
+
+  test("rejects non-existent path", async () => {
+    await expect(loadPlugin("/nonexistent/path/plugin.ts")).rejects.toThrow("Failed to load plugin");
+  });
+});