agent-workflow-kit-cli 1.1.0 → 1.2.0

package/dist/cli/commands/add.js

@@ -0,0 +1,134 @@
+/**
+ * @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";
+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 in the target directory
+    const agentsPath = path.join(targetDir, "AGENTS.md");
+    const moduleAgentsContent = await renderTemplate("common/AGENTS.md.hbs", {
+        stackContent,
+    });
+    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}`));
+        }
+    }
+    // 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/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.0");
     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.0",
   "description": "AI-Ready Repository Workflow Generator & Guideline Optimizer for Codex and Antigravity",
   "type": "module",
   "main": "./dist/index.js",