agent-workflow-kit-cli 1.0.0-mvp → 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/doctor.js

@@ -75,6 +75,27 @@ npx agent-workflow-kit-cli doctor || exit 1
                 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", "."];
+                    }
+                    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", "."];
+                        }
+                    }
+                }
+                catch { }
+                console.log(chalk.gray(`Running: ${cmd} ${args.join(" ")}`));
+                await execa(cmd, args, { cwd, stdio: "inherit" });
+            }
             else if (stack === "react-ts") {
                 console.log(chalk.gray("Running: npx tsc --noEmit"));
                 await execa("npx", ["tsc", "--noEmit"], { cwd, stdio: "inherit" });

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

@@ -9,6 +9,7 @@ import { fileURLToPath } from "url";
 import { detectProjectModules } from "../../core/detector.js";
 import { renderTemplate, readStaticTemplateFile, getStackRules, getStackSkills, } from "../../core/renderer.js";
 import { updateFileWithBlock, writeRuleWithChunking, } from "../../core/emitter.js";
+import { analyzeModule } from "../../core/analyzer.js";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 function printSuccessAndNextSteps(options) {
@@ -20,9 +21,9 @@ function printSuccessAndNextSteps(options) {
         console.log(chalk.gray(`   - Root: ${chalk.underline("AGENTS.md")}`));
         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(`   run: npx agent-workflow-kit-cli doctor --install-hook`));
+        console.log(chalk.cyan(`   npx agent-workflow-kit-cli doctor --install-hook`));
         console.log(chalk.white(`3. Export custom skills to register with your AI agent (e.g. Antigravity):`));
-        console.log(chalk.cyan(`   run: npx agent-workflow-kit-cli export antigravity`));
+        console.log(chalk.cyan(`   npx agent-workflow-kit-cli export antigravity`));
         console.log(chalk.dim("------------------------------------------\n"));
     }
 }
@@ -86,10 +87,12 @@ export async function runInit(options) {
     // Process each module
     for (const mod of modules) {
         console.log(chalk.cyan(`\nProcessing module: ${mod.name} (stacks: ${mod.stacks.join(", ")})`));
+        const analysis = await analyzeModule(mod.dir, mod.stacks);
         let stackContent = "";
         for (const stack of mod.stacks) {
             try {
-                const rendered = await renderTemplate(`${stack}/AGENTS.md.hbs`, {});
+                const stackCtx = analysis[stack] || {};
+                const rendered = await renderTemplate(`${stack}/AGENTS.md.hbs`, stackCtx);
                 stackContent += rendered + "\n\n";
             }
             catch (err) {
@@ -116,14 +119,38 @@ export async function runInit(options) {
                 console.log(chalk.green(`✔️ Created ${mod.name}/AGENTS.md`));
             }
         }
+        // Copy common skills for this module
+        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(mod.dir, ".agents", "skills", skill);
+                    await fs.mkdir(path.dirname(targetSkillPath), { recursive: true });
+                    await fs.writeFile(targetSkillPath, skillContent, "utf8");
+                    console.log(chalk.green(`✔️ Wrote common skill ${skill} to ${mod.name}/.agents/skills/${skill}`));
+                }
+                catch (err) {
+                    console.error(chalk.red(`Failed to copy common skill ${skill}: ${err instanceof Error ? err.message : String(err)}`));
+                }
+            }
+        }
+        catch {
+            // Ignore
+        }
         // Copy rules and skills for each stack in this module
         for (const stack of mod.stacks) {
+            const stackCtx = analysis[stack] || {};
             // A. Rules
             const rules = await getStackRules(stack);
             for (const rule of rules) {
+                if (rule === "microservice-style.md" && stackCtx.isMicroservice !== true) {
+                    continue;
+                }
                 const relativeRulePath = `${stack}/rules/${rule}`;
                 try {
-                    const ruleContent = await readStaticTemplateFile(relativeRulePath);
+                    const ruleContent = await readStaticTemplateFile(relativeRulePath, stackCtx);
                     const targetRulePath = path.join(mod.dir, ".agents", "rules", rule);
                     if (options.dryRun) {
                         console.log(chalk.gray(`[Dry Run] Would write rule to ${targetRulePath} (length: ${ruleContent.length} chars)`));
@@ -142,7 +169,7 @@ export async function runInit(options) {
             for (const skill of skills) {
                 const relativeSkillPath = `${stack}/skills/${skill}`;
                 try {
-                    const skillContent = await readStaticTemplateFile(relativeSkillPath);
+                    const skillContent = await readStaticTemplateFile(relativeSkillPath, stackCtx);
                     const targetSkillPath = path.join(mod.dir, ".agents", "skills", skill);
                     if (options.dryRun) {
                         console.log(chalk.gray(`[Dry Run] Would write skill to ${targetSkillPath}`));

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.0.0-mvp");
+        .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")