ai-first-cli 1.3.1 → 1.3.6

package/tests/entrypoints-languages.test.ts

@@ -0,0 +1,373 @@
+import { describe, it, expect } from "vitest";
+import { discoverEntrypoints, Entrypoint } from "../src/analyzers/entrypoints.js";
+import { FileInfo } from "../src/core/repoScanner.js";
+import fs from "fs";
+import path from "path";
+import os from "os";
+
+function createTempProjectDir(files: Record<string, string>): string {
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "ai-first-entrypoints-test-"));
+  for (const [filePath, content] of Object.entries(files)) {
+    const fullPath = path.join(tempDir, filePath);
+    const dir = path.dirname(fullPath);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    fs.writeFileSync(fullPath, content);
+  }
+  return tempDir;
+}
+
+function createFileInfo(relativePath: string, name: string, extension: string): FileInfo {
+  return {
+    path: path.join("/tmp", relativePath),
+    relativePath,
+    name,
+    extension,
+  };
+}
+
+describe("Entrypoints - Go Language", () => {
+  it("should detect main.go with func main()", () => {
+    const tempDir = createTempProjectDir({
+      "main.go": `package main
+
+import "net/http"
+
+func main() {
+    http.ListenAndServe(":8080", nil)
+}`,
+    });
+
+    const files: FileInfo[] = [createFileInfo("main.go", "main.go", "go")];
+    const entrypoints = discoverEntrypoints(files, tempDir);
+
+    const mainEntry = entrypoints.find(ep => ep.name === "main.go");
+    expect(mainEntry).toBeDefined();
+    expect(mainEntry?.type).toBe("server");
+    expect(mainEntry?.path).toBe("main.go");
+
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  it("should detect HTTP handlers in Go", () => {
+    const tempDir = createTempProjectDir({
+      "main.go": `package main
+
+import "net/http"
+
+func main() {
+    http.HandleFunc("/users", handleUsers)
+    http.HandleFunc("/posts", handlePosts)
+    http.ListenAndServe(":3000", nil)
+}
+
+func handleUsers(w http.ResponseWriter, r *http.Request) {}
+func handlePosts(w http.ResponseWriter, r *http.Request) {}`,
+    });
+
+    const files: FileInfo[] = [createFileInfo("main.go", "main.go", "go")];
+    const entrypoints = discoverEntrypoints(files, tempDir);
+
+    const mainEntry = entrypoints.find(ep => ep.name === "main.go");
+    expect(mainEntry).toBeDefined();
+    expect(mainEntry?.description).toContain("/users");
+    expect(mainEntry?.description).toContain("/posts");
+    expect(mainEntry?.description).toContain(":3000");
+
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  it("should detect go.mod file", () => {
+    const tempDir = createTempProjectDir({
+      "main.go": "package main\n\nfunc main() {}",
+      "go.mod": "module github.com/example/app\n\ngo 1.21",
+    });
+
+    const files: FileInfo[] = [
+      createFileInfo("main.go", "main.go", "go"),
+      createFileInfo("go.mod", "go.mod", ""),
+    ];
+    const entrypoints = discoverEntrypoints(files, tempDir);
+
+    const modEntry = entrypoints.find(ep => ep.name === "go.mod");
+    expect(modEntry).toBeDefined();
+    expect(modEntry?.type).toBe("config");
+    expect(modEntry?.description).toContain("github.com/example/app");
+
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  it("should detect structs in Go modules", () => {
+    const tempDir = createTempProjectDir({
+      "models.go": `package models
+
+type User struct {
+    ID   int
+    Name string
+}
+
+type Post struct {
+    Title string
+    Body  string
+}`,
+    });
+
+    const files: FileInfo[] = [createFileInfo("models.go", "models.go", "go")];
+    const entrypoints = discoverEntrypoints(files, tempDir);
+
+    const modelEntry = entrypoints.find(ep => ep.name === "models.go");
+    expect(modelEntry).toBeDefined();
+    expect(modelEntry?.type).toBe("library");
+    expect(modelEntry?.description).toContain("User");
+    expect(modelEntry?.description).toContain("Post");
+
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  });
+});
+
+describe("Entrypoints - Rust Language", () => {
+  it("should detect main.rs with fn main()", () => {
+    const tempDir = createTempProjectDir({
+      "src/main.rs": `fn main() {
+    println!("Hello, world!");
+}`,
+    });
+
+    const files: FileInfo[] = [createFileInfo("src/main.rs", "main.rs", "rs")];
+    const entrypoints = discoverEntrypoints(files, tempDir);
+
+    const mainEntry = entrypoints.find(ep => ep.name === "main.rs");
+    expect(mainEntry).toBeDefined();
+    expect(mainEntry?.type).toBe("cli");
+    expect(mainEntry?.path).toBe("src/main.rs");
+
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  it("should detect structs and implementations in main.rs", () => {
+    const tempDir = createTempProjectDir({
+      "src/main.rs": `struct Config {
+    name: String,
+}
+
+impl Config {
+    fn new() -> Self {
+        Config { name: "app".to_string() }
+    }
+}
+
+fn main() {}`,
+    });
+
+    const files: FileInfo[] = [createFileInfo("src/main.rs", "main.rs", "rs")];
+    const entrypoints = discoverEntrypoints(files, tempDir);
+
+    const mainEntry = entrypoints.find(ep => ep.name === "main.rs");
+    expect(mainEntry).toBeDefined();
+    expect(mainEntry?.description).toContain("Config");
+    expect(mainEntry?.description).toContain("implementations");
+
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  it("should detect lib.rs as library", () => {
+    const tempDir = createTempProjectDir({
+      "src/lib.rs": `pub fn public_function() {}
+
+pub fn another_public_fn() {}`,
+    });
+
+    const files: FileInfo[] = [createFileInfo("src/lib.rs", "lib.rs", "rs")];
+    const entrypoints = discoverEntrypoints(files, tempDir);
+
+    const libEntry = entrypoints.find(ep => ep.name === "lib.rs");
+    expect(libEntry).toBeDefined();
+    expect(libEntry?.type).toBe("library");
+    expect(libEntry?.description).toContain("public_function");
+
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  it("should detect Cargo.toml with project info", () => {
+    const tempDir = createTempProjectDir({
+      "src/main.rs": "fn main() {}",
+      "Cargo.toml": `[package]
+name = "my-app"
+version = "1.0.0"
+edition = "2021"`,
+    });
+
+    const files: FileInfo[] = [
+      createFileInfo("src/main.rs", "main.rs", "rs"),
+      createFileInfo("Cargo.toml", "Cargo.toml", ""),
+    ];
+    const entrypoints = discoverEntrypoints(files, tempDir);
+
+    const cargoEntry = entrypoints.find(ep => ep.name === "Cargo.toml");
+    expect(cargoEntry).toBeDefined();
+    expect(cargoEntry?.type).toBe("config");
+    expect(cargoEntry?.description).toContain("my-app");
+    expect(cargoEntry?.description).toContain("v1.0.0");
+
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  });
+});
+
+describe("Entrypoints - PHP Language", () => {
+  it("should detect index.php", () => {
+    const tempDir = createTempProjectDir({
+      "index.php": `<?php
+echo "Hello, World!";`,
+    });
+
+    const files: FileInfo[] = [createFileInfo("index.php", "index.php", "php")];
+    const entrypoints = discoverEntrypoints(files, tempDir);
+
+    const indexEntry = entrypoints.find(ep => ep.name === "index.php");
+    expect(indexEntry).toBeDefined();
+    expect(indexEntry?.type).toBe("api");
+    expect(indexEntry?.path).toBe("index.php");
+
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  it("should detect public/index.php as server", () => {
+    const tempDir = createTempProjectDir({
+      "public/index.php": `<?php
+require_once __DIR__ . '/../vendor/autoload.php';`,
+    });
+
+    const files: FileInfo[] = [createFileInfo("public/index.php", "index.php", "php")];
+    const entrypoints = discoverEntrypoints(files, tempDir);
+
+    const indexEntry = entrypoints.find(ep => ep.name === "index.php");
+    expect(indexEntry).toBeDefined();
+    expect(indexEntry?.type).toBe("server");
+
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  it("should detect PHP classes and routes", () => {
+    const tempDir = createTempProjectDir({
+      "index.php": `<?php
+
+class UserController {
+    public function index() {}
+}
+
+class Router {
+    public function add() {}
+}
+
+$router = new Router();
+$router->add('GET', '/users', function() {});`,
+    });
+
+    const files: FileInfo[] = [createFileInfo("index.php", "index.php", "php")];
+    const entrypoints = discoverEntrypoints(files, tempDir);
+
+    const indexEntry = entrypoints.find(ep => ep.name === "index.php");
+    expect(indexEntry).toBeDefined();
+    expect(indexEntry?.description).toContain("UserController");
+    expect(indexEntry?.description).toContain("Router");
+    expect(indexEntry?.description).toContain("/users");
+
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  it("should detect composer.json with Laravel", () => {
+    const tempDir = createTempProjectDir({
+      "index.php": "<?php echo 'Hello';",
+      "composer.json": JSON.stringify({
+        name: "example/laravel-app",
+        description: "My Laravel application",
+        require: {
+          "laravel/framework": "^10.0",
+        },
+      }),
+    });
+
+    const files: FileInfo[] = [
+      createFileInfo("index.php", "index.php", "php"),
+      createFileInfo("composer.json", "composer.json", ""),
+    ];
+    const entrypoints = discoverEntrypoints(files, tempDir);
+
+    const composerEntry = entrypoints.find(ep => ep.name === "composer.json");
+    expect(composerEntry).toBeDefined();
+    expect(composerEntry?.type).toBe("config");
+    expect(composerEntry?.description).toContain("example/laravel-app");
+    expect(composerEntry?.description).toContain("Laravel");
+
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  it("should detect composer.json with Symfony", () => {
+    const tempDir = createTempProjectDir({
+      "index.php": "<?php echo 'Hello';",
+      "composer.json": JSON.stringify({
+        name: "example/symfony-app",
+        require: {
+          "symfony/framework-bundle": "^6.0",
+        },
+      }),
+    });
+
+    const files: FileInfo[] = [
+      createFileInfo("index.php", "index.php", "php"),
+      createFileInfo("composer.json", "composer.json", ""),
+    ];
+    const entrypoints = discoverEntrypoints(files, tempDir);
+
+    const composerEntry = entrypoints.find(ep => ep.name === "composer.json");
+    expect(composerEntry).toBeDefined();
+    expect(composerEntry?.description).toContain("Symfony");
+
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  });
+});
+
+describe("Entrypoints - Integration with Test Projects", () => {
+  it("should detect Go microservice entrypoints", () => {
+    const testProjectPath = path.join(process.cwd(), "test-projects/go-microservice");
+    
+    const files: FileInfo[] = [
+      createFileInfo("main.go", "main.go", "go"),
+    ];
+
+    const entrypoints = discoverEntrypoints(files, testProjectPath);
+
+    const mainEntry = entrypoints.find(ep => ep.name === "main.go");
+    expect(mainEntry).toBeDefined();
+    expect(mainEntry?.type).toBe("server");
+  });
+
+  it("should detect Rust CLI entrypoints", () => {
+    const testProjectPath = path.join(process.cwd(), "test-projects/rust-cli");
+    
+    const files: FileInfo[] = [
+      createFileInfo("src/main.rs", "main.rs", "rs"),
+    ];
+
+    const entrypoints = discoverEntrypoints(files, testProjectPath);
+
+    const mainEntry = entrypoints.find(ep => ep.name === "main.rs");
+    expect(mainEntry).toBeDefined();
+    expect(mainEntry?.type).toBe("cli");
+  });
+
+  it("should detect PHP vanilla entrypoints", () => {
+    const testProjectPath = path.join(process.cwd(), "test-projects/php-vanilla");
+    
+    const files: FileInfo[] = [
+      createFileInfo("index.php", "index.php", "php"),
+    ];
+
+    const entrypoints = discoverEntrypoints(files, testProjectPath);
+
+    const indexEntry = entrypoints.find(ep => ep.name === "index.php");
+    expect(indexEntry).toBeDefined();
+    expect(indexEntry?.type).toBe("api");
+  });
+});

package/tests/framework-detection.test.ts

@@ -0,0 +1,296 @@
+import { describe, it, expect } from "vitest";
+import { detectTechStack } from "../src/analyzers/techStack.js";
+import { analyzeArchitecture } from "../src/analyzers/architecture.js";
+import { FileInfo } from "../src/core/repoScanner.js";
+import fs from "fs";
+import path from "path";
+import os from "os";
+
+function createTempProjectDir(files: Record<string, string>): string {
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "ai-first-framework-test-"));
+  for (const [filePath, content] of Object.entries(files)) {
+    const fullPath = path.join(tempDir, filePath);
+    const dir = path.dirname(fullPath);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    fs.writeFileSync(fullPath, content);
+  }
+  return tempDir;
+}
+
+function createFileInfo(relativePath: string, name: string, extension: string): FileInfo {
+  return {
+    path: path.join("/tmp", relativePath),
+    relativePath,
+    name,
+    extension,
+  };
+}
+
+describe("Framework Detection - NestJS", () => {
+  it("should detect NestJS from @nestjs/common in dependencies", () => {
+    const tempDir = createTempProjectDir({
+      "package.json": JSON.stringify({
+        name: "nestjs-app",
+        dependencies: {
+          "@nestjs/common": "^10.0.0",
+          "@nestjs/core": "^10.0.0",
+          "@nestjs/platform-express": "^10.0.0",
+        },
+      }),
+      "src/main.ts": "// main file",
+    });
+
+    const files: FileInfo[] = [
+      createFileInfo("package.json", "package.json", ""),
+      createFileInfo("src/main.ts", "main.ts", "ts"),
+    ];
+
+    const techStack = detectTechStack(files, tempDir);
+    
+    expect(techStack.frameworks).toContain("NestJS");
+
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  it("should detect NestJS from @nestjs/* packages in devDependencies", () => {
+    const tempDir = createTempProjectDir({
+      "package.json": JSON.stringify({
+        name: "nestjs-app",
+        devDependencies: {
+          "@nestjs/testing": "^10.0.0",
+          "@nestjs/cli": "^10.0.0",
+        },
+      }),
+    });
+
+    const files: FileInfo[] = [createFileInfo("package.json", "package.json", "")];
+
+    const techStack = detectTechStack(files, tempDir);
+    
+    expect(techStack.frameworks).toContain("NestJS");
+
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  it("should not detect NestJS when only 'nest' is present without @nestjs/*", () => {
+    const tempDir = createTempProjectDir({
+      "package.json": JSON.stringify({
+        name: "other-app",
+        dependencies: {
+          "nestjs-stuff": "1.0.0",
+        },
+      }),
+    });
+
+    const files: FileInfo[] = [createFileInfo("package.json", "package.json", "")];
+
+    const techStack = detectTechStack(files, tempDir);
+    
+    // Should not detect NestJS from "nestjs-stuff" package
+    expect(techStack.frameworks).not.toContain("NestJS");
+
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  });
+});
+
+describe("Framework Detection - Spring Boot", () => {
+  it("should detect Spring Boot from pom.xml", () => {
+    const tempDir = createTempProjectDir({
+      "pom.xml": `<?xml version="1.0" encoding="UTF-8"?>
+<project>
+  <parent>
+    <groupId>org.springframework.boot</groupId>
+    <artifactId>spring-boot-starter-parent</artifactId>
+    <version>3.0.0</version>
+  </parent>
+  <dependencies>
+    <dependency>
+      <groupId>org.springframework.boot</groupId>
+      <artifactId>spring-boot-starter-web</artifactId>
+    </dependency>
+  </dependencies>
+</project>`,
+      "src/main/java/com/example/Application.java": "package com.example;",
+    });
+
+    const files: FileInfo[] = [
+      createFileInfo("pom.xml", "pom.xml", ""),
+      createFileInfo("src/main/java/com/example/Application.java", "Application.java", "java"),
+    ];
+
+    const techStack = detectTechStack(files, tempDir);
+    
+    expect(techStack.frameworks).toContain("Spring Boot");
+
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  it("should detect Spring Boot from build.gradle", () => {
+    const tempDir = createTempProjectDir({
+      "build.gradle": `plugins {
+    id 'java'
+    id 'org.springframework.boot' version '3.0.0'
+}
+
+dependencies {
+    implementation 'org.springframework.boot:spring-boot-starter-web'
+}`,
+    });
+
+    const files: FileInfo[] = [
+      createFileInfo("build.gradle", "build.gradle", ""),
+    ];
+
+    const techStack = detectTechStack(files, tempDir);
+    
+    expect(techStack.frameworks).toContain("Spring Boot");
+
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  it("should detect Spring Boot from build.gradle.kts", () => {
+    const tempDir = createTempProjectDir({
+      "build.gradle.kts": `plugins {
+    java
+    id("org.springframework.boot") version "3.0.0"
+}
+
+dependencies {
+    implementation("org.springframework.boot:spring-boot-starter-web")
+}`,
+    });
+
+    const files: FileInfo[] = [
+      createFileInfo("build.gradle.kts", "build.gradle.kts", ""),
+    ];
+
+    const techStack = detectTechStack(files, tempDir);
+    
+    expect(techStack.frameworks).toContain("Spring Boot");
+
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  it("should detect Spring Boot from spring-boot in pom.xml", () => {
+    const tempDir = createTempProjectDir({
+      "pom.xml": `<?xml version="1.0" encoding="UTF-8"?>
+<project>
+  <dependencies>
+    <dependency>
+      <groupId>org.springframework.boot</groupId>
+      <artifactId>spring-boot-starter-data-jpa</artifactId>
+    </dependency>
+  </dependencies>
+</project>`,
+    });
+
+    const files: FileInfo[] = [createFileInfo("pom.xml", "pom.xml", "")];
+
+    const techStack = detectTechStack(files, tempDir);
+    
+    expect(techStack.frameworks).toContain("Spring Boot");
+
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  });
+});
+
+describe("Architecture Detection - Microservices vs API Server", () => {
+  it("should detect API Server for single services directory", () => {
+    const files: FileInfo[] = [
+      createFileInfo("src/controllers/user.js", "user.js", "js"),
+      createFileInfo("src/services/userService.js", "userService.js", "js"),
+      createFileInfo("package.json", "package.json", ""),
+    ];
+
+    const architecture = analyzeArchitecture(files, "/tmp");
+    
+    // Should detect API Server, not Microservices
+    expect(architecture.description).not.toContain("Microservices");
+    expect(architecture.description).toContain("API Server");
+  });
+
+  it("should detect Microservices for multiple service directories", () => {
+    const files: FileInfo[] = [
+      createFileInfo("services/user/src/index.js", "index.js", "js"),
+      createFileInfo("services/order/src/index.js", "index.js", "js"),
+      createFileInfo("services/payment/src/index.js", "index.js", "js"),
+      createFileInfo("package.json", "package.json", ""),
+    ];
+
+    const architecture = analyzeArchitecture(files, "/tmp");
+    
+    // Should detect Microservices when there are multiple service directories
+    expect(architecture.description).toContain("Microservices");
+  });
+
+  it("should detect API Server for single api directory", () => {
+    const files: FileInfo[] = [
+      createFileInfo("api/routes.js", "routes.js", "js"),
+      createFileInfo("api/controllers.js", "controllers.js", "js"),
+    ];
+
+    const architecture = analyzeArchitecture(files, "/tmp");
+    
+    // Should detect API Server, not Microservices
+    expect(architecture.description).not.toContain("Microservices");
+    expect(architecture.description).toContain("API Server");
+  });
+
+  it("should detect API Server for nested api directories", () => {
+    const files: FileInfo[] = [
+      createFileInfo("api/v1/routes.js", "routes.js", "js"),
+      createFileInfo("api/v2/routes.js", "routes.js", "js"),
+      createFileInfo("api/v3/routes.js", "routes.js", "js"),
+    ];
+
+    const architecture = analyzeArchitecture(files, "/tmp");
+    
+    // Should detect API Server for nested api directories, not Microservices
+    expect(architecture.description).not.toContain("Microservices");
+    expect(architecture.description).toContain("API Server");
+  });
+});
+
+describe("Framework Detection - Integration Tests", () => {
+  it("should detect NestJS in nestjs-backend test project", () => {
+    const testProjectPath = path.join(process.cwd(), "test-projects/nestjs-backend");
+    
+    const files: FileInfo[] = [
+      createFileInfo("package.json", "package.json", ""),
+      createFileInfo("src/main.ts", "main.ts", "ts"),
+    ];
+
+    const techStack = detectTechStack(files, testProjectPath);
+    
+    expect(techStack.frameworks).toContain("NestJS");
+  });
+
+  it("should detect Spring Boot in spring-boot-app test project", () => {
+    const testProjectPath = path.join(process.cwd(), "test-projects/spring-boot-app");
+    
+    const files: FileInfo[] = [
+      createFileInfo("pom.xml", "pom.xml", ""),
+    ];
+
+    const techStack = detectTechStack(files, testProjectPath);
+    
+    expect(techStack.frameworks).toContain("Spring Boot");
+  });
+
+  it("should detect API Server for express-api test project", () => {
+    const testProjectPath = path.join(process.cwd(), "test-projects/express-api");
+    
+    const files: FileInfo[] = [
+      createFileInfo("src/routes/index.js", "index.js", "js"),
+      createFileInfo("src/services/dataService.js", "dataService.js", "js"),
+    ];
+
+    const architecture = analyzeArchitecture(files, testProjectPath);
+    
+    // Should detect API Server, not Microservices
+    expect(architecture.description).not.toContain("Microservices");
+    expect(architecture.description).toContain("API Server");
+  });
+});