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

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/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

@@ -13,7 +13,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.1.0");
     program
         .command("init")
         .description("Initialize agent guidelines and skills for the repository")

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,6 +82,9 @@ async function detectProjectStackDirect(cwd) {
             if (content.includes("fastapi")) {
                 stacks.push("fastapi");
             }
+            if (aiKeywords.some(kw => content.includes(kw))) {
+                stacks.push("python-ai");
+            }
         }
         catch {
             // Ignore

package/dist/core/renderer.js

@@ -6,6 +6,10 @@ import handlebars from "handlebars";
 import { promises as fs } from "fs";
 import path from "path";
 import { fileURLToPath } from "url";
+// Register custom Handlebars helpers
+handlebars.registerHelper("eq", function (a, b) {
+    return a === b;
+});
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 // The templates directory is located at '../../templates' relative to 'dist/core/renderer.js'
@@ -22,12 +26,18 @@ export async function renderTemplate(templatePath, context) {
     return compiled(context);
 }
 /**
- * Reads a static rules file as-is without Handlebars interpolation.
+ * Reads a static template file (rules or skills) with optional Handlebars interpolation.
  * @param filePath Relative path inside templates folder (e.g. 'spring-boot/rules/java-style.md')
+ * @param context Optional key-value data for compilation
  */
-export async function readStaticTemplateFile(filePath) {
+export async function readStaticTemplateFile(filePath, context) {
     const fullPath = path.join(TEMPLATES_DIR, filePath);
-    return fs.readFile(fullPath, "utf8");
+    const fileContent = await fs.readFile(fullPath, "utf8");
+    if (context) {
+        const compiled = handlebars.compile(fileContent);
+        return compiled(context);
+    }
+    return fileContent;
 }
 /**
  * Gets all rules files for a stack.