agent-workflow-kit-cli 1.1.0 → 1.2.1

package/dist/cli/commands/add.js

@@ -0,0 +1,172 @@
+/**
+ * @license
+ * SPDX-License-Identifier: MIT
+ */
+import chalk from "chalk";
+import { promises as fs } from "fs";
+import path from "path";
+import { renderTemplate, readStaticTemplateFile, getStackRules, getStackSkills, } from "../../core/renderer.js";
+import { updateFileWithBlock, writeRuleWithChunking, } from "../../core/emitter.js";
+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", "fastapi", "python-ai"];
+    if (!validStacks.includes(targetStack)) {
+        console.error(chalk.red(`Error: Invalid stack '${stack}'. Supported stacks are: ${validStacks.join(", ")}`));
+        process.exit(1);
+    }
+    const targetDir = path.resolve(options.path);
+    console.log(chalk.bold.cyan("\n🚀 Agent Workflow Kit - Adding Stack Pack..."));
+    console.log(chalk.dim("------------------------------------------"));
+    console.log(`${chalk.bold("Target Folder:")}  ${chalk.green(targetDir)}`);
+    console.log(`${chalk.bold("Stack Pack:")}     ${chalk.green(targetStack)}`);
+    console.log(`${chalk.bold("Agent Profile:")}  ${chalk.green(options.agent)}`);
+    console.log(`${chalk.bold("Dry Run:")}        ${options.dryRun ? chalk.yellow("Enabled 🧪") : chalk.gray("Disabled")}`);
+    console.log(chalk.dim("------------------------------------------\n"));
+    // 1. Analyze the target directory for this specific stack
+    const analysis = await analyzeModule(targetDir, [targetStack]);
+    // 2. Render stack guidelines for AGENTS.md
+    let stackContent = "";
+    try {
+        const stackCtx = analysis[targetStack] || {};
+        const rendered = await renderTemplate(`${targetStack}/AGENTS.md.hbs`, stackCtx);
+        stackContent = rendered.trim();
+    }
+    catch (err) {
+        console.error(chalk.red(`Error loading template for stack '${targetStack}': ${err instanceof Error ? err.message : String(err)}`));
+        process.exit(1);
+    }
+    // 3. Write or Update AGENTS.md and/or GEMINI.md in the target directory
+    const geminiPath = path.join(targetDir, "GEMINI.md");
+    const agentsPath = path.join(targetDir, "AGENTS.md");
+    const moduleAgentsContent = await renderTemplate("common/AGENTS.md.hbs", {
+        stackContent,
+    });
+    if (options.agent === "antigravity" || options.agent === "both") {
+        if (options.dryRun) {
+            console.log(chalk.gray(`[Dry Run] Would write/update GEMINI.md at ${geminiPath}`));
+        }
+        else {
+            try {
+                await fs.access(geminiPath);
+                await updateFileWithBlock(geminiPath, "STACK_PACK", stackContent);
+                console.log(chalk.green(`✔️ Updated STACK_PACK block in ${geminiPath}`));
+            }
+            catch {
+                await fs.mkdir(targetDir, { recursive: true });
+                await fs.writeFile(geminiPath, moduleAgentsContent, "utf8");
+                console.log(chalk.green(`✔️ Created ${geminiPath}`));
+            }
+        }
+    }
+    if (options.agent === "codex" || options.agent === "both") {
+        if (options.dryRun) {
+            console.log(chalk.gray(`[Dry Run] Would write/update AGENTS.md at ${agentsPath}`));
+        }
+        else {
+            try {
+                await fs.access(agentsPath);
+                await updateFileWithBlock(agentsPath, "STACK_PACK", stackContent);
+                console.log(chalk.green(`✔️ Updated STACK_PACK block in ${agentsPath}`));
+            }
+            catch {
+                await fs.mkdir(targetDir, { recursive: true });
+                await fs.writeFile(agentsPath, moduleAgentsContent, "utf8");
+                console.log(chalk.green(`✔️ Created ${agentsPath}`));
+            }
+        }
+    }
+    // Write IDE Rules to target directory
+    const ideRulesContent = await renderTemplate("common/ide-rules.hbs", {
+        agent: options.agent,
+    });
+    const ideFiles = [".cursorrules", ".copilot-instructions.md", ".clinerules"];
+    for (const file of ideFiles) {
+        if (options.dryRun) {
+            console.log(chalk.gray(`[Dry Run] Would write IDE rule file to ${path.join(targetDir, file)}`));
+        }
+        else {
+            await fs.writeFile(path.join(targetDir, file), ideRulesContent, "utf8");
+        }
+    }
+    if (!options.dryRun) {
+        console.log(chalk.green(`✔️ Created IDE prompt anchors at ${targetDir} (.cursorrules, .copilot-instructions.md, .clinerules)`));
+    }
+    await updateGitignore(targetDir, options.dryRun);
+    // 4. Copy rules and skills for the target stack
+    const stackCtx = analysis[targetStack] || {};
+    // A. Copy Rules
+    const rules = await getStackRules(targetStack);
+    for (const rule of rules) {
+        if (rule === "microservice-style.md" && stackCtx.isMicroservice !== true) {
+            continue;
+        }
+        const relativeRulePath = `${targetStack}/rules/${rule}`;
+        try {
+            const ruleContent = await readStaticTemplateFile(relativeRulePath, stackCtx);
+            const targetRulePath = path.join(targetDir, ".agents", "rules", rule);
+            if (options.dryRun) {
+                console.log(chalk.gray(`[Dry Run] Would write rule to ${targetRulePath}`));
+            }
+            else {
+                await writeRuleWithChunking(targetRulePath, ruleContent);
+                console.log(chalk.green(`✔️ Wrote rule ${rule} to ${targetRulePath}`));
+            }
+        }
+        catch (err) {
+            console.error(chalk.red(`Failed to copy rule ${rule}: ${err instanceof Error ? err.message : String(err)}`));
+        }
+    }
+    // B. Copy Skills
+    const skills = await getStackSkills(targetStack);
+    for (const skill of skills) {
+        const relativeSkillPath = `${targetStack}/skills/${skill}`;
+        try {
+            const skillContent = await readStaticTemplateFile(relativeSkillPath, stackCtx);
+            const targetSkillPath = path.join(targetDir, ".agents", "skills", skill);
+            if (options.dryRun) {
+                console.log(chalk.gray(`[Dry Run] Would write skill to ${targetSkillPath}`));
+            }
+            else {
+                await fs.mkdir(path.dirname(targetSkillPath), { recursive: true });
+                await fs.writeFile(targetSkillPath, skillContent, "utf8");
+                console.log(chalk.green(`✔️ Wrote skill ${skill} to ${targetSkillPath}`));
+            }
+        }
+        catch (err) {
+            console.error(chalk.red(`Failed to copy skill ${skill}: ${err instanceof Error ? err.message : String(err)}`));
+        }
+    }
+    // C. Copy Common Skills if not present
+    try {
+        const commonSkills = await getStackSkills("common");
+        for (const skill of commonSkills) {
+            const relativeSkillPath = `common/skills/${skill}`;
+            try {
+                const skillContent = await readStaticTemplateFile(relativeSkillPath, {});
+                const targetSkillPath = path.join(targetDir, ".agents", "skills", skill);
+                if (options.dryRun) {
+                    console.log(chalk.gray(`[Dry Run] Would ensure common skill ${skill} exists`));
+                }
+                else {
+                    try {
+                        await fs.access(targetSkillPath);
+                    }
+                    catch {
+                        await fs.mkdir(path.dirname(targetSkillPath), { recursive: true });
+                        await fs.writeFile(targetSkillPath, skillContent, "utf8");
+                        console.log(chalk.green(`✔️ Wrote common skill ${skill} to ${targetSkillPath}`));
+                    }
+                }
+            }
+            catch (err) {
+                console.error(chalk.red(`Failed to copy common skill ${skill}: ${err instanceof Error ? err.message : String(err)}`));
+            }
+        }
+    }
+    catch {
+        // Ignore
+    }
+    console.log(chalk.bold.green("\n🎉 Add completed successfully!"));
+}

package/dist/cli/commands/export.js

@@ -58,8 +58,9 @@ export function parseSkillFile(content, defaultName) {
     return { name, description, body: body.trim() };
 }
 export async function runExport(target, options) {
-    if (target.toLowerCase() !== "antigravity") {
-        console.warn(chalk.yellow(`Warning: Currently, only 'antigravity' target is officially optimized, but trying to export custom rules anyway.`));
+    const normTarget = target.toLowerCase();
+    if (normTarget !== "antigravity" && normTarget !== "codex") {
+        console.warn(chalk.yellow(`Warning: Currently, only 'antigravity' and 'codex' targets are officially optimized, but trying to export custom rules anyway.`));
     }
     const cwd = process.cwd();
     const skillsDir = path.join(cwd, ".agents", "skills");

package/dist/cli/commands/init.js

@@ -18,7 +18,8 @@ function printSuccessAndNextSteps(options) {
         console.log(chalk.bold.cyan("\n👉 Next Steps:"));
         console.log(chalk.dim("------------------------------------------"));
         console.log(chalk.white(`1. Open & review the generated guidelines:`));
-        console.log(chalk.gray(`   - Root: ${chalk.underline("AGENTS.md")}`));
+        const targetFile = options.agent === "antigravity" ? "GEMINI.md" : "AGENTS.md";
+        console.log(chalk.gray(`   - Root: ${chalk.underline(targetFile)}`));
         console.log(chalk.gray(`   - Stack rules: ${chalk.underline(".agents/rules/")}`));
         console.log(chalk.white(`2. Setup automatic git pre-commit hook validation:`));
         console.log(chalk.cyan(`   npx agent-workflow-kit-cli doctor --install-hook`));
@@ -27,6 +28,56 @@ function printSuccessAndNextSteps(options) {
         console.log(chalk.dim("------------------------------------------\n"));
     }
 }
+export async function updateGitignore(targetDir, dryRun) {
+    const gitignorePath = path.join(targetDir, ".gitignore");
+    const rulesToIgnore = [".cursorrules", ".copilot-instructions.md", ".clinerules"];
+    if (dryRun) {
+        console.log(chalk.gray(`[Dry Run] Would update .gitignore in ${targetDir} to exclude IDE rule files.`));
+        return;
+    }
+    try {
+        let content = "";
+        try {
+            content = await fs.readFile(gitignorePath, "utf8");
+        }
+        catch {
+            // gitignore does not exist
+        }
+        const lines = content.split("\n").map((l) => l.trim());
+        const missingRules = rulesToIgnore.filter((rule) => !lines.includes(rule));
+        if (missingRules.length > 0) {
+            const separator = content.length > 0 && !content.endsWith("\n") ? "\n\n" : "";
+            const newContent = content +
+                separator +
+                "# Agent Workflow Kit IDE rules\n" +
+                missingRules.join("\n") +
+                "\n";
+            await fs.writeFile(gitignorePath, newContent, "utf8");
+            console.log(chalk.green("✔️ Updated .gitignore to exclude IDE rules."));
+        }
+    }
+    catch (err) {
+        console.warn(chalk.yellow(`Could not update .gitignore: ${err instanceof Error ? err.message : String(err)}`));
+    }
+}
+async function writeWorkspaceIdeRulesAndGitignore(cwd, options) {
+    const ideRulesContent = await renderTemplate("common/ide-rules.hbs", {
+        agent: options.agent,
+    });
+    const ideFiles = [".cursorrules", ".copilot-instructions.md", ".clinerules"];
+    for (const file of ideFiles) {
+        if (options.dryRun) {
+            console.log(chalk.gray(`[Dry Run] Would write root ${file}`));
+        }
+        else {
+            await fs.writeFile(path.join(cwd, file), ideRulesContent, "utf8");
+        }
+    }
+    if (!options.dryRun) {
+        console.log(chalk.green("✔️ Created workspace IDE prompt anchors (.cursorrules, .copilot-instructions.md, .clinerules)"));
+    }
+    await updateGitignore(cwd, options.dryRun);
+}
 export async function runInit(options) {
     const cwd = process.cwd();
     console.log(chalk.bold.cyan("\n🚀 Agent Workflow Kit - Initializing..."));
@@ -47,40 +98,74 @@ export async function runInit(options) {
         const finalAgentsContent = await renderTemplate("common/AGENTS.md.hbs", {
             stackContent: "",
         });
-        if (options.dryRun) {
-            console.log(chalk.gray(`[Dry Run] Would write root AGENTS.md`));
+        if (options.agent === "antigravity" || options.agent === "both") {
+            if (options.dryRun) {
+                console.log(chalk.gray(`[Dry Run] Would write root GEMINI.md`));
+            }
+            else {
+                const geminiPath = path.join(cwd, "GEMINI.md");
+                await fs.writeFile(geminiPath, finalAgentsContent, "utf8");
+                console.log(chalk.green("✔️ Created root GEMINI.md with general guidelines."));
+            }
         }
-        else {
-            const agentsPath = path.join(cwd, "AGENTS.md");
-            await fs.writeFile(agentsPath, finalAgentsContent, "utf8");
-            console.log(chalk.green("✔️ Created root AGENTS.md with general guidelines."));
+        if (options.agent === "codex" || options.agent === "both") {
+            if (options.dryRun) {
+                console.log(chalk.gray(`[Dry Run] Would write root AGENTS.md`));
+            }
+            else {
+                const agentsPath = path.join(cwd, "AGENTS.md");
+                await fs.writeFile(agentsPath, finalAgentsContent, "utf8");
+                console.log(chalk.green("✔️ Created root AGENTS.md with general guidelines."));
+            }
         }
+        await writeWorkspaceIdeRulesAndGitignore(cwd, options);
         printSuccessAndNextSteps(options);
         return;
     }
     const isMonorepo = modules.length > 1 || (modules.length === 1 && modules[0].name !== ".");
-    // Write root AGENTS.md with monorepo details
+    // Write root files with monorepo details
     if (isMonorepo) {
         let monorepoContent = "### 📦 Monorepo Multi-Module Project Structure\n\nThis repository is configured as a monorepo. Please load and follow the stack-specific guidelines in each subdirectory:\n\n";
         for (const mod of modules) {
-            monorepoContent += `- **${mod.name}** (${mod.stacks.join(", ")}): Stack rules and guidelines are located at [${mod.name}/AGENTS.md](file:///${mod.dir.replace(/\\/g, "/")}/AGENTS.md)\n`;
+            const isAntigravity = options.agent === "antigravity";
+            const targetFileName = isAntigravity ? "GEMINI.md" : "AGENTS.md";
+            monorepoContent += `- **${mod.name}** (${mod.stacks.join(", ")}): Stack rules and guidelines are located at [${mod.name}/${targetFileName}](file:///${mod.dir.replace(/\\/g, "/")}/${targetFileName})\n`;
         }
         const rootAgentsContent = await renderTemplate("common/AGENTS.md.hbs", {
             stackContent: monorepoContent.trim(),
         });
+        const rootGeminiPath = path.join(cwd, "GEMINI.md");
         const rootAgentsPath = path.join(cwd, "AGENTS.md");
-        if (options.dryRun) {
-            console.log(chalk.gray(`[Dry Run] Would write root AGENTS.md containing monorepo navigation:\n${monorepoContent}`));
+        if (options.agent === "antigravity" || options.agent === "both") {
+            if (options.dryRun) {
+                console.log(chalk.gray(`[Dry Run] Would write root GEMINI.md containing monorepo navigation:\n${monorepoContent}`));
+            }
+            else {
+                try {
+                    await fs.access(rootGeminiPath);
+                    await updateFileWithBlock(rootGeminiPath, "STACK_PACK", monorepoContent.trim());
+                    console.log(chalk.green("✔️ Updated STACK_PACK block in root GEMINI.md."));
+                }
+                catch {
+                    await fs.writeFile(rootGeminiPath, rootAgentsContent, "utf8");
+                    console.log(chalk.green("✔️ Created root GEMINI.md for monorepo."));
+                }
+            }
         }
-        else {
-            try {
-                await fs.access(rootAgentsPath);
-                await updateFileWithBlock(rootAgentsPath, "STACK_PACK", monorepoContent.trim());
-                console.log(chalk.green("✔️ Updated STACK_PACK block in root AGENTS.md."));
+        if (options.agent === "codex" || options.agent === "both") {
+            if (options.dryRun) {
+                console.log(chalk.gray(`[Dry Run] Would write root AGENTS.md containing monorepo navigation:\n${monorepoContent}`));
             }
-            catch {
-                await fs.writeFile(rootAgentsPath, rootAgentsContent, "utf8");
-                console.log(chalk.green("✔️ Created root AGENTS.md for monorepo."));
+            else {
+                try {
+                    await fs.access(rootAgentsPath);
+                    await updateFileWithBlock(rootAgentsPath, "STACK_PACK", monorepoContent.trim());
+                    console.log(chalk.green("✔️ Updated STACK_PACK block in root AGENTS.md."));
+                }
+                catch {
+                    await fs.writeFile(rootAgentsPath, rootAgentsContent, "utf8");
+                    console.log(chalk.green("✔️ Created root AGENTS.md for monorepo."));
+                }
             }
         }
     }
@@ -100,23 +185,42 @@ export async function runInit(options) {
             }
         }
         stackContent = stackContent.trim();
-        // Render AGENTS.md for this module
+        // Render agent files for this module
+        const geminiPath = path.join(mod.dir, "GEMINI.md");
         const agentsPath = path.join(mod.dir, "AGENTS.md");
         const moduleAgentsContent = await renderTemplate("common/AGENTS.md.hbs", {
             stackContent,
         });
-        if (options.dryRun) {
-            console.log(chalk.gray(`[Dry Run] Would write AGENTS.md at ${agentsPath}`));
+        if (options.agent === "antigravity" || options.agent === "both") {
+            if (options.dryRun) {
+                console.log(chalk.gray(`[Dry Run] Would write GEMINI.md at ${geminiPath}`));
+            }
+            else {
+                try {
+                    await fs.access(geminiPath);
+                    await updateFileWithBlock(geminiPath, "STACK_PACK", stackContent);
+                    console.log(chalk.green(`✔️ Updated STACK_PACK block in ${mod.name}/GEMINI.md`));
+                }
+                catch {
+                    await fs.writeFile(geminiPath, moduleAgentsContent, "utf8");
+                    console.log(chalk.green(`✔️ Created ${mod.name}/GEMINI.md`));
+                }
+            }
         }
-        else {
-            try {
-                await fs.access(agentsPath);
-                await updateFileWithBlock(agentsPath, "STACK_PACK", stackContent);
-                console.log(chalk.green(`✔️ Updated STACK_PACK block in ${mod.name}/AGENTS.md`));
+        if (options.agent === "codex" || options.agent === "both") {
+            if (options.dryRun) {
+                console.log(chalk.gray(`[Dry Run] Would write AGENTS.md at ${agentsPath}`));
             }
-            catch {
-                await fs.writeFile(agentsPath, moduleAgentsContent, "utf8");
-                console.log(chalk.green(`✔️ Created ${mod.name}/AGENTS.md`));
+            else {
+                try {
+                    await fs.access(agentsPath);
+                    await updateFileWithBlock(agentsPath, "STACK_PACK", stackContent);
+                    console.log(chalk.green(`✔️ Updated STACK_PACK block in ${mod.name}/AGENTS.md`));
+                }
+                catch {
+                    await fs.writeFile(agentsPath, moduleAgentsContent, "utf8");
+                    console.log(chalk.green(`✔️ Created ${mod.name}/AGENTS.md`));
+                }
             }
         }
         // Copy common skills for this module
@@ -186,5 +290,7 @@ export async function runInit(options) {
             }
         }
     }
+    // Write workspace-level IDE rules and update gitignore
+    await writeWorkspaceIdeRulesAndGitignore(cwd, options);
     printSuccessAndNextSteps(options);
 }

package/dist/cli/index.js

@@ -5,6 +5,7 @@
 import { Command } from "commander";
 import chalk from "chalk";
 import { runInit } from "./commands/init.js";
+import { runAdd } from "./commands/add.js";
 import { runSync } from "./commands/sync.js";
 import { runDoctor } from "./commands/doctor.js";
 import { runExport } from "./commands/export.js";
@@ -13,7 +14,7 @@ export function runCli() {
     program
         .name("agent-workflow-kit")
         .description("Generate AI coding workflows/rules/templates for Codex and Antigravity")
-        .version("1.1.0");
+        .version("1.2.1");
     program
         .command("init")
         .description("Initialize agent guidelines and skills for the repository")
@@ -29,6 +30,21 @@ export function runCli() {
             process.exit(1);
         }
     });
+    program
+        .command("add <stack>")
+        .description("Manually add/install a stack pack to a specific folder")
+        .option("--path <path>", "Target folder path to install the guidelines", ".")
+        .option("--agent <agent>", "Specify target agent profile: both | codex | antigravity", "both")
+        .option("--dry-run", "Output actions to console without writing any files", false)
+        .action(async (stack, options) => {
+        try {
+            await runAdd(stack, options);
+        }
+        catch (err) {
+            console.error(chalk.red(`Error running add: ${err instanceof Error ? err.message : String(err)}`));
+            process.exit(1);
+        }
+    });
     program
         .command("sync")
         .description("Sync generated guidelines and skills inside managed blocks")

package/dist/core/detector.js

@@ -87,73 +87,84 @@ async function detectProjectStackDirect(cwd) {
             }
         }
         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);
+}

package/package.json

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

package/templates/common/ide-rules.hbs

@@ -0,0 +1,12 @@
+# Agent Workflow Kit - IDE System Instructions
+
+You are an AI assistant ({{#if (eq agent "antigravity")}}Antigravity{{else}}{{#if (eq agent "codex")}}Codex{{else}}Antigravity / Codex{{/if}}{{/if}}) coding inside this repository. You MUST follow these repository standards for every query:
+
+1. Always check for and follow {{#if (eq agent "antigravity")}}[GEMINI.md](file:///GEMINI.md){{else}}{{#if (eq agent "codex")}}[AGENTS.md](file:///AGENTS.md){{else}}[GEMINI.md](file:///GEMINI.md) (if you are Antigravity) or [AGENTS.md](file:///AGENTS.md) (if you are Codex){{/if}}{{/if}} at the workspace root (or current module workspace) before executing any task.
+2. Follow the strict 5-Step Execution Workflow:
+   - Step 1: Research & Context Analysis (scan workspace, read relevant rules in `.agents/rules/` matching the active stack, e.g. `react-style.md` for React. Do not scan irrelevant files).
+   - Step 2: Formulate Implementation Plan (list files to create, modify, or delete).
+   - Step 3: Implementation & Clean Coding (maintain type-safety, styles, and layering).
+   - Step 4: Verification (run validation commands: compile, lint, test, build).
+   - Step 5: Self-Review & QA (review diff, clean logs, summarize edits).
+3. Check and execute custom skills defined inside `.agents/skills/` (like `/spring-feature` or `/react-feature`) by reading their `SKILL.md` instruction file.