agent-workflow-kit-cli 1.0.0-mvp → 1.2.0

package/dist/core/analyzer.js

@@ -0,0 +1,462 @@
+/**
+ * @license
+ * SPDX-License-Identifier: MIT
+ */
+import { promises as fs } from "fs";
+import path from "path";
+/**
+ * Helper to recursively find files with a specific extension, avoiding node_modules and build directories.
+ */
+async function findFilesRecursively(dir, extension, limit = 20) {
+    const results = [];
+    async function traverse(currentDir) {
+        if (results.length >= limit)
+            return;
+        try {
+            const entries = await fs.readdir(currentDir, { withFileTypes: true });
+            for (const entry of entries) {
+                if (results.length >= limit)
+                    return;
+                const fullPath = path.join(currentDir, entry.name);
+                if (entry.isDirectory()) {
+                    // Skip build and package manager folders
+                    if (entry.name.startsWith(".") ||
+                        entry.name === "node_modules" ||
+                        entry.name === "target" ||
+                        entry.name === "build" ||
+                        entry.name === "dist" ||
+                        entry.name === "bin" ||
+                        entry.name === "out" ||
+                        entry.name === "gradle") {
+                        continue;
+                    }
+                    await traverse(fullPath);
+                }
+                else if (entry.isFile() && entry.name.endsWith(extension)) {
+                    results.push(fullPath);
+                }
+            }
+        }
+        catch {
+            // Ignore read errors
+        }
+    }
+    await traverse(dir);
+    return results;
+}
+/**
+ * Simple parser for properties files.
+ */
+export function parsePropertiesSimple(content) {
+    const lines = content.split("\n");
+    let appName;
+    let port;
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith("#") || trimmed.startsWith("!"))
+            continue;
+        const eqIndex = trimmed.indexOf("=");
+        const colonIndex = trimmed.indexOf(":");
+        let sepIndex = -1;
+        if (eqIndex !== -1 && colonIndex !== -1) {
+            sepIndex = Math.min(eqIndex, colonIndex);
+        }
+        else {
+            sepIndex = eqIndex !== -1 ? eqIndex : colonIndex;
+        }
+        if (sepIndex !== -1) {
+            const key = trimmed.substring(0, sepIndex).trim();
+            const value = trimmed.substring(sepIndex + 1).trim().replace(/^['"]|['"]$/g, "");
+            if (key === "spring.application.name") {
+                appName = value;
+            }
+            else if (key === "server.port") {
+                port = value;
+            }
+        }
+    }
+    return { appName, port };
+}
+/**
+ * Simple parser for YAML files.
+ */
+export function parseYamlSimple(content) {
+    const lines = content.split("\n");
+    const contextPath = [];
+    let appName;
+    let port;
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith("#"))
+            continue;
+        // Determine indentation
+        const indent = line.length - line.trimStart().length;
+        // Pop context paths that are deeper or equal to current indent level
+        while (contextPath.length > 0 && indent <= contextPath[contextPath.length - 1].indent) {
+            contextPath.pop();
+        }
+        const colonIndex = trimmed.indexOf(":");
+        if (colonIndex !== -1) {
+            const key = trimmed.substring(0, colonIndex).trim();
+            const value = trimmed.substring(colonIndex + 1).trim();
+            contextPath.push({ key, indent });
+            const fullKeyPath = contextPath.map((c) => c.key).join(".");
+            if (value) {
+                const cleanVal = value.replace(/^['"]|['"]$/g, "");
+                if (fullKeyPath === "spring.application.name") {
+                    appName = cleanVal;
+                }
+                else if (fullKeyPath === "server.port") {
+                    port = cleanVal;
+                }
+            }
+        }
+    }
+    return { appName, port };
+}
+/**
+ * Analyzes Java Spring Boot project details.
+ */
+async function analyzeSpringBoot(dir) {
+    // 1. Detect Build Tool & Commands
+    let buildTool = "maven";
+    let buildCommand = "./mvnw";
+    let buildVerifyArgs = "verify";
+    let isMicroservice = false;
+    try {
+        const isGradle = (await fs.stat(path.join(dir, "build.gradle")).then((s) => s.isFile()).catch(() => false)) ||
+            (await fs.stat(path.join(dir, "build.gradle.kts")).then((s) => s.isFile()).catch(() => false));
+        if (isGradle) {
+            buildTool = "gradle";
+            const hasWrapper = await fs.stat(path.join(dir, "gradlew")).then((s) => s.isFile()).catch(() => false);
+            buildCommand = hasWrapper ? "./gradlew" : "gradle";
+            buildVerifyArgs = "check";
+        }
+        else {
+            const hasWrapper = await fs.stat(path.join(dir, "mvnw")).then((s) => s.isFile()).catch(() => false);
+            buildCommand = hasWrapper ? "./mvnw" : "mvn";
+            buildVerifyArgs = "verify";
+        }
+    }
+    catch {
+        // Use default maven settings
+    }
+    // Check build files for microservice dependencies
+    const buildFilesToCheck = ["pom.xml", "build.gradle", "build.gradle.kts"];
+    for (const file of buildFilesToCheck) {
+        try {
+            const content = await fs.readFile(path.join(dir, file), "utf8");
+            if (content.includes("spring-cloud") ||
+                content.includes("eureka") ||
+                content.includes("openfeign") ||
+                content.includes("consul") ||
+                content.includes("nacos")) {
+                isMicroservice = true;
+            }
+        }
+        catch {
+            // Ignore if file doesn't exist
+        }
+    }
+    // 2. Base Package Path and package-to-dot-notation detection
+    let basePackage = "com.acme.app";
+    let packagePath = "com/acme/app";
+    const javaSrcRoot = path.join(dir, "src/main/java");
+    let javaSrcRootExists = false;
+    try {
+        const stat = await fs.stat(javaSrcRoot);
+        javaSrcRootExists = stat.isDirectory();
+    }
+    catch {
+        // src/main/java doesn't exist
+    }
+    let basePackageFullPath = javaSrcRoot;
+    if (javaSrcRootExists) {
+        let currentDir = javaSrcRoot;
+        const packageParts = [];
+        while (true) {
+            try {
+                const entries = await fs.readdir(currentDir, { withFileTypes: true });
+                const subdirs = entries.filter((e) => e.isDirectory() && !e.name.startsWith("."));
+                const files = entries.filter((e) => e.isFile());
+                // Traverse down if exactly one subdirectory and no Java/static files inside this directory level
+                if (subdirs.length === 1 && files.length === 0) {
+                    const subDirName = subdirs[0].name;
+                    packageParts.push(subDirName);
+                    currentDir = path.join(currentDir, subDirName);
+                }
+                else {
+                    break;
+                }
+            }
+            catch {
+                break;
+            }
+        }
+        if (packageParts.length > 0) {
+            basePackage = packageParts.join(".");
+            packagePath = packageParts.join("/");
+            basePackageFullPath = currentDir;
+        }
+    }
+    // 3. Package Layout Detection (feature-first vs layer-first)
+    let packageLayout = "feature-first";
+    if (javaSrcRootExists) {
+        try {
+            const entries = await fs.readdir(basePackageFullPath, { withFileTypes: true });
+            const subdirs = entries.filter((e) => e.isDirectory() && !e.name.startsWith("."));
+            const layerKeywords = new Set([
+                "controller",
+                "controllers",
+                "service",
+                "services",
+                "repository",
+                "repositories",
+                "entity",
+                "entities",
+                "model",
+                "models",
+                "dto",
+                "dtos",
+                "mapper",
+                "mappers",
+                "config",
+                "configs",
+                "web",
+            ]);
+            let matchingLayerDirsCount = 0;
+            for (const subdir of subdirs) {
+                if (layerKeywords.has(subdir.name.toLowerCase())) {
+                    matchingLayerDirsCount++;
+                }
+            }
+            if (matchingLayerDirsCount >= 2) {
+                packageLayout = "layer-first";
+            }
+            else {
+                // Try sampling child packages to see if they hold feature sub-packages with layers inside
+                let looksLikeFeatureFirst = false;
+                const sampleLimit = Math.min(subdirs.length, 3);
+                for (let i = 0; i < sampleLimit; i++) {
+                    const subDirPath = path.join(basePackageFullPath, subdirs[i].name);
+                    const subEntries = await fs.readdir(subDirPath, { withFileTypes: true });
+                    const nestedDirs = subEntries.filter((e) => e.isDirectory() && !e.name.startsWith("."));
+                    const hasLayerInside = nestedDirs.some((nd) => layerKeywords.has(nd.name.toLowerCase()));
+                    if (hasLayerInside) {
+                        looksLikeFeatureFirst = true;
+                        break;
+                    }
+                }
+                packageLayout = looksLikeFeatureFirst ? "feature-first" : "feature-first"; // Default to feature-first
+            }
+        }
+        catch {
+            // Fallback
+        }
+    }
+    // 4. Validation Library Detection (Jakarta vs Javax)
+    let validationLibrary = "jakarta.validation";
+    if (javaSrcRootExists) {
+        try {
+            const javaFiles = await findFilesRecursively(basePackageFullPath, ".java", 20);
+            for (const file of javaFiles) {
+                const content = await fs.readFile(file, "utf8");
+                if (content.includes("import javax.validation.")) {
+                    validationLibrary = "javax.validation";
+                    break;
+                }
+                else if (content.includes("import jakarta.validation.")) {
+                    validationLibrary = "jakarta.validation";
+                    break;
+                }
+            }
+        }
+        catch {
+            // Fallback
+        }
+    }
+    // 5. Test Framework Detection
+    let testFramework = "JUnit 5";
+    const javaTestRoot = path.join(dir, "src/test/java");
+    let javaTestRootExists = false;
+    try {
+        const stat = await fs.stat(javaTestRoot);
+        javaTestRootExists = stat.isDirectory();
+    }
+    catch {
+        // src/test/java doesn't exist
+    }
+    if (javaTestRootExists) {
+        try {
+            const testFiles = await findFilesRecursively(javaTestRoot, ".java", 20);
+            for (const file of testFiles) {
+                const content = await fs.readFile(file, "utf8");
+                if (content.includes("org.junit.jupiter.")) {
+                    testFramework = "JUnit 5";
+                    break;
+                }
+                else if (content.includes("org.junit.Test")) {
+                    testFramework = "JUnit 4";
+                    break;
+                }
+            }
+        }
+        catch {
+            // Fallback
+        }
+    }
+    // 6. Microservice properties scanning (service name and port)
+    let springApplicationName = path.basename(dir);
+    let serverPort = "8080";
+    const configFiles = [
+        "application.properties",
+        "application.yml",
+        "application.yaml",
+        "bootstrap.properties",
+        "bootstrap.yml",
+        "bootstrap.yaml",
+    ];
+    const resourcesDir = path.join(dir, "src/main/resources");
+    for (const file of configFiles) {
+        try {
+            const filePath = path.join(resourcesDir, file);
+            const content = await fs.readFile(filePath, "utf8");
+            const parsed = file.endsWith(".properties")
+                ? parsePropertiesSimple(content)
+                : parseYamlSimple(content);
+            if (parsed.appName) {
+                springApplicationName = parsed.appName;
+                isMicroservice = true;
+            }
+            if (parsed.port) {
+                serverPort = parsed.port;
+            }
+        }
+        catch {
+            // Ignore if file doesn't exist or is unreadable
+        }
+    }
+    return {
+        buildTool,
+        buildCommand,
+        buildVerifyArgs,
+        packageLayout,
+        basePackage,
+        packagePath,
+        validationLibrary,
+        testFramework,
+        isMicroservice,
+        springApplicationName,
+        serverPort,
+    };
+}
+/**
+ * Analyzes React TypeScript project details.
+ */
+async function analyzeReactTs(dir) {
+    let packageManager = "npm";
+    let runCommand = "npm run";
+    try {
+        const hasYarnLock = await fs.stat(path.join(dir, "yarn.lock")).then((s) => s.isFile()).catch(() => false);
+        const hasPnpmLock = await fs.stat(path.join(dir, "pnpm-lock.yaml")).then((s) => s.isFile()).catch(() => false);
+        if (hasYarnLock) {
+            packageManager = "yarn";
+            runCommand = "yarn";
+        }
+        else if (hasPnpmLock) {
+            packageManager = "pnpm";
+            runCommand = "pnpm";
+        }
+    }
+    catch {
+        // Use default
+    }
+    return { packageManager, runCommand };
+}
+/**
+ * Analyzes FastAPI project details.
+ */
+async function analyzeFastApi(dir) {
+    let packageManager = "pip";
+    let runCommand = "python";
+    try {
+        const hasPoetry = await fs.stat(path.join(dir, "poetry.lock")).then((s) => s.isFile()).catch(() => false);
+        const hasPipenv = await fs.stat(path.join(dir, "Pipfile")).then((s) => s.isFile()).catch(() => false);
+        if (hasPoetry) {
+            packageManager = "poetry";
+            runCommand = "poetry run";
+        }
+        else if (hasPipenv) {
+            packageManager = "pipenv";
+            runCommand = "pipenv run";
+        }
+    }
+    catch {
+        // Use default
+    }
+    return { packageManager, runCommand };
+}
+/**
+ * Analyzes Python AI project details.
+ */
+async function analyzePythonAi(dir) {
+    let packageManager = "pip";
+    let runCommand = "python";
+    let hasGpuLibraries = false;
+    let hasHardwareLibraries = false;
+    try {
+        const hasPoetry = await fs.stat(path.join(dir, "poetry.lock")).then((s) => s.isFile()).catch(() => false);
+        const hasPipenv = await fs.stat(path.join(dir, "Pipfile")).then((s) => s.isFile()).catch(() => false);
+        if (hasPoetry) {
+            packageManager = "poetry";
+            runCommand = "poetry run python";
+        }
+        else if (hasPipenv) {
+            packageManager = "pipenv";
+            runCommand = "pipenv run python";
+        }
+    }
+    catch {
+        // Use default
+    }
+    // Scan requirements / pyproject to check for GPU and Hardware references
+    const checkGpuKws = ["torch", "tensorflow", "cuda", "onnxruntime-gpu"];
+    const checkHwKws = ["opencv-python", "mediapipe", "pyserial", "pyaudio", "picamera", "opencv"];
+    const buildFiles = ["requirements.txt", "pyproject.toml", "Pipfile"];
+    for (const file of buildFiles) {
+        try {
+            const content = await fs.readFile(path.join(dir, file), "utf8");
+            if (checkGpuKws.some(kw => content.includes(kw))) {
+                hasGpuLibraries = true;
+            }
+            if (checkHwKws.some(kw => content.includes(kw))) {
+                hasHardwareLibraries = true;
+            }
+        }
+        catch {
+            // Ignore
+        }
+    }
+    return { packageManager, runCommand, hasGpuLibraries, hasHardwareLibraries };
+}
+/**
+ * Entry point to analyze module configurations.
+ */
+export async function analyzeModule(dir, stacks) {
+    const context = {};
+    for (const stack of stacks) {
+        if (stack === "spring-boot") {
+            context["spring-boot"] = await analyzeSpringBoot(dir);
+        }
+        else if (stack === "react-ts") {
+            context["react-ts"] = await analyzeReactTs(dir);
+        }
+        else if (stack === "fastapi") {
+            context["fastapi"] = await analyzeFastApi(dir);
+        }
+        else if (stack === "python-ai") {
+            context["python-ai"] = await analyzePythonAi(dir);
+        }
+    }
+    return context;
+}

package/dist/core/detector.js

@@ -9,7 +9,7 @@ import path from "path";
  */
 async function detectProjectStackDirect(cwd) {
     const stacks = [];
-    // 1. Detect Java Spring Boot (pom.xml)
+    // 1. Detect Java Spring Boot (pom.xml, build.gradle, or build.gradle.kts)
     try {
         const pomPath = path.join(cwd, "pom.xml");
         const stat = await fs.stat(pomPath);
@@ -18,7 +18,25 @@ async function detectProjectStackDirect(cwd) {
         }
     }
     catch {
-        // Ignore
+        try {
+            const gradlePath = path.join(cwd, "build.gradle");
+            const stat = await fs.stat(gradlePath);
+            if (stat.isFile()) {
+                stacks.push("spring-boot");
+            }
+        }
+        catch {
+            try {
+                const gradleKtsPath = path.join(cwd, "build.gradle.kts");
+                const stat = await fs.stat(gradleKtsPath);
+                if (stat.isFile()) {
+                    stacks.push("spring-boot");
+                }
+            }
+            catch {
+                // Ignore
+            }
+        }
     }
     // 2. Detect React + TypeScript (package.json containing react dependency)
     try {
@@ -34,13 +52,28 @@ async function detectProjectStackDirect(cwd) {
     catch {
         // Ignore
     }
-    // 3. Detect Python FastAPI (pyproject.toml or requirements.txt containing fastapi)
+    // 3. Detect Python FastAPI & Python AI
+    const aiKeywords = [
+        "torch",
+        "tensorflow",
+        "scikit-learn",
+        "transformers",
+        "langchain",
+        "llama-index",
+        "opencv-python",
+        "mediapipe",
+        "numpy",
+        "pandas"
+    ];
     try {
         const pyprojectPath = path.join(cwd, "pyproject.toml");
         const content = await fs.readFile(pyprojectPath, "utf8");
         if (content.includes("fastapi")) {
             stacks.push("fastapi");
         }
+        if (aiKeywords.some(kw => content.includes(kw))) {
+            stacks.push("python-ai");
+        }
     }
     catch {
         try {
@@ -49,75 +82,89 @@ async function detectProjectStackDirect(cwd) {
             if (content.includes("fastapi")) {
                 stacks.push("fastapi");
             }
+            if (aiKeywords.some(kw => content.includes(kw))) {
+                stacks.push("python-ai");
+            }
         }
         catch {
-            // Ignore
-        }
-    }
-    return stacks;
-}
-/**
- * Scans the workspace directory and subfolders (1-level deep) for monorepo detection.
- */
-export async function detectProjectStack(cwd) {
-    const stacks = await detectProjectStackDirect(cwd);
-    // Scan 1-level deep subdirectories for potential monorepos/multimodules
-    try {
-        const entries = await fs.readdir(cwd, { withFileTypes: true });
-        for (const entry of entries) {
-            if (entry.isDirectory() &&
-                !entry.name.startsWith(".") &&
-                entry.name !== "node_modules" &&
-                entry.name !== "dist") {
-                const subPath = path.join(cwd, entry.name);
-                const subStacks = await detectProjectStackDirect(subPath);
-                for (const stack of subStacks) {
-                    if (!stacks.includes(stack)) {
-                        stacks.push(stack);
-                    }
+            try {
+                const pipfilePath = path.join(cwd, "Pipfile");
+                const content = await fs.readFile(pipfilePath, "utf8");
+                if (content.includes("fastapi")) {
+                    stacks.push("fastapi");
+                }
+                if (aiKeywords.some(kw => content.includes(kw))) {
+                    stacks.push("python-ai");
                 }
             }
+            catch {
+                // Ignore
+            }
         }
     }
-    catch {
-        // Ignore
-    }
     return stacks;
 }
 /**
- * Detects stacks grouped by module directories (root + 1-level deep directories).
+ * Helper to recursively search for modules containing manifest configurations up to maxDepth.
  */
-export async function detectProjectModules(cwd) {
+async function findModulesRecursively(baseDir, currentDir, maxDepth, currentDepth = 0) {
     const modules = [];
-    const rootStacks = await detectProjectStackDirect(cwd);
-    if (rootStacks.length > 0) {
+    // Skip standard build and internal directories to avoid deep scans
+    const dirName = path.basename(currentDir);
+    if (dirName.startsWith(".") ||
+        dirName === "node_modules" ||
+        dirName === "target" ||
+        dirName === "build" ||
+        dirName === "dist" ||
+        dirName === "bin" ||
+        dirName === "out" ||
+        dirName === "venv" ||
+        dirName === ".venv") {
+        return modules;
+    }
+    // Detect direct stack presets in this current directory
+    const directStacks = await detectProjectStackDirect(currentDir);
+    if (directStacks.length > 0) {
         modules.push({
-            dir: cwd,
-            name: ".",
-            stacks: rootStacks,
+            dir: currentDir,
+            name: currentDir === baseDir ? "." : path.relative(baseDir, currentDir).replace(/\\/g, "/"),
+            stacks: directStacks,
         });
     }
-    try {
-        const entries = await fs.readdir(cwd, { withFileTypes: true });
-        for (const entry of entries) {
-            if (entry.isDirectory() &&
-                !entry.name.startsWith(".") &&
-                entry.name !== "node_modules" &&
-                entry.name !== "dist") {
-                const subPath = path.join(cwd, entry.name);
-                const subStacks = await detectProjectStackDirect(subPath);
-                if (subStacks.length > 0) {
-                    modules.push({
-                        dir: subPath,
-                        name: entry.name,
-                        stacks: subStacks,
-                    });
+    // If we haven't hit max depth, traverse subdirectories
+    if (currentDepth < maxDepth) {
+        try {
+            const entries = await fs.readdir(currentDir, { withFileTypes: true });
+            for (const entry of entries) {
+                if (entry.isDirectory()) {
+                    const subPath = path.join(currentDir, entry.name);
+                    const subModules = await findModulesRecursively(baseDir, subPath, maxDepth, currentDepth + 1);
+                    modules.push(...subModules);
                 }
             }
         }
-    }
-    catch {
-        // Ignore
+        catch {
+            // Ignore directory read errors
+        }
     }
     return modules;
 }
+/**
+ * Scans the workspace directory and subfolders (up to 3 levels deep) for monorepo detection.
+ */
+export async function detectProjectStack(cwd) {
+    const modules = await detectProjectModules(cwd);
+    const stacks = new Set();
+    for (const mod of modules) {
+        for (const stack of mod.stacks) {
+            stacks.add(stack);
+        }
+    }
+    return Array.from(stacks);
+}
+/**
+ * Detects stacks grouped by module directories (root + up to 3 levels deep directories).
+ */
+export async function detectProjectModules(cwd) {
+    return findModulesRecursively(cwd, cwd, 3);
+}