agent-workflow-kit-cli 1.3.3 → 1.3.4

package/dist/cli/commands/add.js

@@ -11,7 +11,7 @@ import { analyzeModule } from "../../core/analyzer.js";
 import { updateGitignore } from "./init.js";
 export async function runAdd(stack, options) {
     const targetStack = stack.toLowerCase();
-    const validStacks = ["spring-boot", "react-ts", "next-js", "nestjs", "express", "fastapi", "python-ai", "dotnet", "golang", "rust"];
+    const validStacks = ["spring-boot", "react-ts", "next-js", "nestjs", "express", "fastapi", "python-ai", "dotnet", "golang", "rust", "diagram", "devops"];
     if (!validStacks.includes(targetStack)) {
         console.error(chalk.red(`Error: Invalid stack '${stack}'. Supported stacks are: ${validStacks.join(", ")}`));
         process.exit(1);

package/dist/cli/commands/doctor.js

@@ -6,7 +6,7 @@ import chalk from "chalk";
 import { promises as fs } from "fs";
 import path from "path";
 import { execa } from "execa";
-import { detectProjectStack } from "../../core/detector.js";
+import { detectProjectModules } from "../../core/detector.js";
 export async function runDoctor(options) {
     const cwd = process.cwd();
     if (options.installHook) {
@@ -55,63 +55,161 @@ npx agent-workflow-kit-cli doctor || exit 1
         return;
     }
     console.log(chalk.blue("Running doctor checks on repository..."));
-    // 1. Detect Stack
-    const stacks = await detectProjectStack(cwd);
-    console.log(chalk.gray(`Detected stacks: ${stacks.join(", ") || "None"}`));
-    if (stacks.length === 0) {
-        console.log(chalk.yellow("No standard stack pack detected. Nothing to validate."));
+    // 1. Detect Modules
+    const modules = await detectProjectModules(cwd);
+    if (modules.length === 0) {
+        console.log(chalk.yellow("No standard project modules detected. Nothing to validate."));
         return;
     }
+    console.log(chalk.gray(`Detected modules: ${modules.map(m => `${m.name} [${m.stacks.join(", ")}]`).join(", ")}`));
     // 2. Validate
     let passed = true;
-    for (const stack of stacks) {
-        console.log(chalk.blue(`\nValidating stack: ${stack}...`));
-        try {
-            if (stack === "spring-boot") {
-                console.log(chalk.gray("Running: ./mvnw clean compile"));
-                await execa("./mvnw", ["clean", "compile"], { cwd, stdio: "inherit" });
-            }
-            else if (stack === "fastapi") {
-                console.log(chalk.gray("Running: ruff check ."));
-                await execa("ruff", ["check", "."], { cwd, stdio: "inherit" });
-            }
-            else if (stack === "python-ai") {
-                let cmd = "ruff";
-                let args = ["check", "."];
-                try {
-                    const hasPoetry = await fs.stat(path.join(cwd, "poetry.lock")).then(s => s.isFile()).catch(() => false);
-                    if (hasPoetry) {
-                        cmd = "poetry";
-                        args = ["run", "python", "-m", "ruff", "check", "."];
+    for (const mod of modules) {
+        console.log(chalk.blue(`\nValidating module: ${mod.name === "." ? "root" : mod.name}...`));
+        for (const stack of mod.stacks) {
+            console.log(chalk.cyan(`  Validating stack: ${stack}...`));
+            try {
+                if (stack === "spring-boot") {
+                    // Check for maven wrapper or gradle wrapper
+                    const hasGradle = (await fs.stat(path.join(mod.dir, "build.gradle")).then((s) => s.isFile()).catch(() => false)) ||
+                        (await fs.stat(path.join(mod.dir, "build.gradle.kts")).then((s) => s.isFile()).catch(() => false));
+                    if (hasGradle) {
+                        let gradlewPath = "./gradlew";
+                        try {
+                            await fs.access(path.join(mod.dir, "gradlew"));
+                        }
+                        catch {
+                            try {
+                                await fs.access(path.join(cwd, "gradlew"));
+                                gradlewPath = path.relative(mod.dir, path.join(cwd, "gradlew")).replace(/\\/g, "/");
+                                if (!gradlewPath.startsWith("."))
+                                    gradlewPath = "./" + gradlewPath;
+                            }
+                            catch {
+                                gradlewPath = "gradle";
+                            }
+                        }
+                        console.log(chalk.gray(`Running: ${gradlewPath} check in ${mod.dir}`));
+                        await execa(gradlewPath, ["check"], { cwd: mod.dir, stdio: "inherit" });
                     }
                     else {
-                        const hasPipenv = await fs.stat(path.join(cwd, "Pipfile")).then(s => s.isFile()).catch(() => false);
-                        if (hasPipenv) {
-                            cmd = "pipenv";
-                            args = ["run", "python", "-m", "ruff", "check", "."];
+                        let mvnwPath = "./mvnw";
+                        try {
+                            await fs.access(path.join(mod.dir, "mvnw"));
                         }
+                        catch {
+                            try {
+                                await fs.access(path.join(cwd, "mvnw"));
+                                mvnwPath = path.relative(mod.dir, path.join(cwd, "mvnw")).replace(/\\/g, "/");
+                                if (!mvnwPath.startsWith("."))
+                                    mvnwPath = "./" + mvnwPath;
+                            }
+                            catch {
+                                mvnwPath = "mvn";
+                            }
+                        }
+                        console.log(chalk.gray(`Running: ${mvnwPath} clean compile in ${mod.dir}`));
+                        await execa(mvnwPath, ["clean", "compile"], { cwd: mod.dir, stdio: "inherit" });
                     }
                 }
-                catch { }
-                console.log(chalk.gray(`Running: ${cmd} ${args.join(" ")}`));
-                await execa(cmd, args, { cwd, stdio: "inherit" });
-            }
-            else if (stack === "react-ts" ||
-                stack === "next-js" ||
-                stack === "nestjs" ||
-                stack === "express") {
-                console.log(chalk.gray("Running: npx tsc --noEmit"));
-                await execa("npx", ["tsc", "--noEmit"], { cwd, stdio: "inherit" });
+                else if (stack === "fastapi") {
+                    console.log(chalk.gray(`Running: ruff check . in ${mod.dir}`));
+                    await execa("ruff", ["check", "."], { cwd: mod.dir, stdio: "inherit" });
+                }
+                else if (stack === "python-ai") {
+                    let cmd = "ruff";
+                    let args = ["check", "."];
+                    try {
+                        const hasPoetry = await fs.stat(path.join(mod.dir, "poetry.lock")).then(s => s.isFile()).catch(() => false);
+                        if (hasPoetry) {
+                            cmd = "poetry";
+                            args = ["run", "ruff", "check", "."];
+                        }
+                        else {
+                            const hasPipenv = await fs.stat(path.join(mod.dir, "Pipfile")).then(s => s.isFile()).catch(() => false);
+                            if (hasPipenv) {
+                                cmd = "pipenv";
+                                args = ["run", "ruff", "check", "."];
+                            }
+                        }
+                    }
+                    catch { }
+                    console.log(chalk.gray(`Running: ${cmd} ${args.join(" ")} in ${mod.dir}`));
+                    await execa(cmd, args, { cwd: mod.dir, stdio: "inherit" });
+                }
+                else if (stack === "react-ts" ||
+                    stack === "next-js" ||
+                    stack === "nestjs" ||
+                    stack === "express") {
+                    let pm = "npm";
+                    try {
+                        const hasYarnLock = await fs.stat(path.join(mod.dir, "yarn.lock")).then((s) => s.isFile()).catch(() => false);
+                        const hasPnpmLock = await fs.stat(path.join(mod.dir, "pnpm-lock.yaml")).then((s) => s.isFile()).catch(() => false);
+                        const hasBunLockb = await fs.stat(path.join(mod.dir, "bun.lockb")).then((s) => s.isFile()).catch(() => false);
+                        const hasBunLock = await fs.stat(path.join(mod.dir, "bun.lock")).then((s) => s.isFile()).catch(() => false);
+                        if (hasYarnLock)
+                            pm = "yarn";
+                        else if (hasPnpmLock)
+                            pm = "pnpm";
+                        else if (hasBunLockb || hasBunLock)
+                            pm = "bun";
+                    }
+                    catch { }
+                    try {
+                        const pkgContent = await fs.readFile(path.join(mod.dir, "package.json"), "utf8");
+                        const pkg = JSON.parse(pkgContent);
+                        const scripts = pkg.scripts || {};
+                        if (scripts.lint) {
+                            console.log(chalk.gray(`Running: ${pm} run lint in ${mod.dir}`));
+                            await execa(pm, ["run", "lint"], { cwd: mod.dir, stdio: "inherit" });
+                        }
+                        console.log(chalk.gray(`Running: npx tsc --noEmit in ${mod.dir}`));
+                        await execa("npx", ["tsc", "--noEmit"], { cwd: mod.dir, stdio: "inherit" });
+                        if (scripts.test) {
+                            const hasVitest = pkg.dependencies?.vitest || pkg.devDependencies?.vitest;
+                            const hasJest = pkg.dependencies?.jest || pkg.devDependencies?.jest;
+                            let args = ["run", "test"];
+                            if (hasVitest || hasJest) {
+                                if (pm === "npm") {
+                                    args = ["run", "test", "--", "--run"];
+                                }
+                                else {
+                                    args = ["run", "test", "--run"];
+                                }
+                            }
+                            console.log(chalk.gray(`Running: ${pm} ${args.join(" ")} in ${mod.dir}`));
+                            await execa(pm, args, { cwd: mod.dir, stdio: "inherit", env: { ...process.env, CI: "true" } });
+                        }
+                    }
+                    catch {
+                        console.log(chalk.gray(`Running: npx tsc --noEmit in ${mod.dir}`));
+                        await execa("npx", ["tsc", "--noEmit"], { cwd: mod.dir, stdio: "inherit" });
+                    }
+                }
+                else if (stack === "dotnet") {
+                    console.log(chalk.gray(`Running: dotnet build in ${mod.dir}`));
+                    await execa("dotnet", ["build"], { cwd: mod.dir, stdio: "inherit" });
+                    console.log(chalk.gray(`Running: dotnet test in ${mod.dir}`));
+                    await execa("dotnet", ["test"], { cwd: mod.dir, stdio: "inherit" });
+                }
+                else if (stack === "golang") {
+                    console.log(chalk.gray(`Running: go build ./... in ${mod.dir}`));
+                    await execa("go", ["build", "./..."], { cwd: mod.dir, stdio: "inherit" });
+                    console.log(chalk.gray(`Running: go test ./... in ${mod.dir}`));
+                    await execa("go", ["test", "./..."], { cwd: mod.dir, stdio: "inherit" });
+                }
+                else if (stack === "rust") {
+                    console.log(chalk.gray(`Running: cargo check in ${mod.dir}`));
+                    await execa("cargo", ["check"], { cwd: mod.dir, stdio: "inherit" });
+                    console.log(chalk.gray(`Running: cargo test in ${mod.dir}`));
+                    await execa("cargo", ["test"], { cwd: mod.dir, stdio: "inherit" });
+                }
+                console.log(chalk.green(`  ✔️ ${stack} validation passed!`));
             }
-            else if (stack === "dotnet") {
-                console.log(chalk.gray("Running: dotnet build"));
-                await execa("dotnet", ["build"], { cwd, stdio: "inherit" });
+            catch (err) {
+                console.error(chalk.red(`  ❌ ${stack} validation failed: ${err instanceof Error ? err.message : String(err)}`));
+                passed = false;
             }
-            console.log(chalk.green(`✔️ ${stack} validation passed!`));
-        }
-        catch (err) {
-            console.error(chalk.red(`❌ ${stack} validation failed: ${err instanceof Error ? err.message : String(err)}`));
-            passed = false;
         }
     }
     if (passed) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-workflow-kit-cli",
-  "version": "1.3.3",
+  "version": "1.3.4",
   "description": "AI-Ready Repository Workflow Generator & Guideline Optimizer for Codex and Antigravity",
   "type": "module",
   "main": "./dist/index.js",

package/templates/devops/AGENTS.md.hbs

@@ -0,0 +1,32 @@
+## 🚀 DevOps & Deployment Automation Guide
+
+### 🔄 DevOps Workflow
+When setting up CI/CD pipelines or containerizing applications, apply these core principles:
+1. **Analyze Project Runtime:** Identify the language ecosystem (Node.js, Python, Go, Rust, Java, .NET) and detect package manager/lockfiles (e.g. `package-lock.json`, `poetry.lock`, `Cargo.lock`, `go.sum`).
+2. **Implement Secure Multi-Stage Builds:** Separate build dependencies from runtime dependencies. The runtime image must be minimal (e.g., alpine, distroless) and must never run as `root`.
+3. **Establish CI/CD Pipelines:** Setup linting, automated testing, and secure Docker image publication workflows inside GitHub Actions.
+
+---
+
+### 🏗️ Available DevOps Templates
+Refer to the detailed rules below:
+- Scaffolding secure Dockerfiles and GitHub Actions workflows: `@devops`
+
+---
+
+### 🏛️ Strict Container & Pipeline Standards
+
+#### 1. Dockerfile Guidelines
+- **Multi-Stage Builds:** Always use a builder stage to download tools, compile source code, and install development headers, then copy only the compiled binaries/compiled assets to the final stage.
+- **Rootless Execution:** Declare a non-privileged user (e.g., `nobody`, `appuser`, `node`) using the `USER` directive in the final stage.
+- **Caching Optimization:** Copy dependency manifest files (like `package.json`, `go.mod`, `Cargo.toml`) and perform installation steps *before* copying the source code directory to maximize layer caching efficiency.
+- **Base Images:** Prefer minimal, stable base images (like `node:20-alpine`, `python:3.11-slim`, `gcr.io/distroless/static`).
+
+#### 2. GitHub Actions CI/CD Rules
+- **Security:** Use secrets (`secrets.GITHUB_TOKEN` or custom registry credentials) to authenticate with registries. Never hardcode credentials.
+- **Phases:** Ensure the pipeline follows a clear linear progression: `Lint` -> `Test` -> `Build Docker` -> `Publish Image` -> `Verify`.
+- **Environment:** Run tests inside appropriate isolation, specifying necessary environment variables as configuration variables.
+
+### 🧪 Verification
+- Validate the Dockerfile builds locally: `docker build -t app:local .`
+- Ensure GitHub Actions workflow schema checks out correctly using visual validators or linting tools.