@clubmatto/ai-kit 0.0.6 → 0.0.8

package/.agents/disabled/spring-boot.md

@@ -0,0 +1,5 @@
+# Spring Boot
+
+Follow Spring Boot best practices.
+
+{{FOOTER}}

package/CHANGELOG.md

@@ -20,4 +20,4 @@ All notable changes to this project will be documented in this file.
 
 ### Added
 
-- Initial release
+- Initial release

package/README.md

@@ -4,13 +4,15 @@
 [![npm version](https://img.shields.io/npm/v/@clubmatto/ai-kit)](https://www.npmjs.com/package/@clubmatto/ai-kit)
 [![License: MIT](https://img.shields.io/npm/l/@clubmatto%2Fai-kit)](/LICENSE)
 
-The AI configuration CLI from Club Matto. Sync rules, skills, and commands to power up your AI coding workflow.
+The AI configuration CLI from Club Matto. Sync rules, skills, and commands to
+power up your AI coding workflow.
 
 ## Features
 
 - **Language Rules** — TypeScript, Go, Kotlin, and more
 - **Skills** — Reusable AI capabilities like Playwright automation
-- **Commands** — Pre-built prompts for common tasks (commit messages, PR reviews)
+- **Commands** — Pre-built prompts for common tasks (commit messages, PR
+  reviews)
 
 ## Quick Start
 
@@ -30,16 +32,33 @@ ai-kit sync
 
 # Skip installing opencode.json to project root
 ai-kit sync --skip-opencode
+
+# Language detection & filtering
+ai-kit sync --all-rules              # Install all language rules
+ai-kit sync --languages=go,kotlin    # Install specific language rules
+ai-kit sync --monorepo               # Force monorepo AGENTS.md template
+ai-kit sync --single-repo            # Force single-repo AGENTS.md template
 ```
 
+The CLI automatically detects project languages and installs only relevant
+rules:
+
+- **TypeScript/JavaScript**: `package.json` or `.ts`/`.js` files
+- **Go**: `go.mod` or `.go` files
+- **Kotlin**: `build.gradle`, `build.gradle.kts`, `pom.xml` or `.kt` files
+- **Spring Boot**: `application.properties`/`.yml` + Kotlin/Java files
+
+Multiple languages → monorepo mode (all rules + monorepo AGENTS.md).
+Single language → single-repo mode (language-specific AGENTS.md).
+
 ## What's Installed
 
-| Location          | Description                       |
-| ----------------- | --------------------------------- |
-| `.agents/rules/`  | Language/framework rules          |
-| `.agents/skills/` | Reusable AI capabilities          |
-| `opencode.json`   | Opencode configuration (optional) |
-| `AGENTS.md`       | Agent instructions                |
+| Location          | Description                               |
+| ----------------- | ----------------------------------------- |
+| `.agents/rules/`  | Language/framework rules (auto-detected)  |
+| `.agents/skills/` | Reusable AI capabilities                  |
+| `opencode.json`   | Opencode configuration (optional)         |
+| `AGENTS.md`       | Agent instructions (monorepo/single-repo) |
 
 ## Commands
 
@@ -63,9 +82,13 @@ ai-kit sync
 ## Release
 
 ```bash
-# Create git tag with prefix (triggers automated release)
+# Bump version in package.json first
+git add ai-kit/package.json
+git commit -m "release: bump version to <version>"
+
+# Create git tag and push both (tag triggers automated release)
 git tag ai-kit/v<version>
-git push origin ai-kit/v<version>
+git push origin main --follow-tags
 ```
 
 ## License

package/dist/src/cmd/sync.js

@@ -7,6 +7,9 @@ const reader_1 = require("../reader");
 const manifest_1 = require("../manifest");
 const template_1 = require("../template");
 const output_1 = require("../output");
+const detect_1 = require("../detection/detect");
+const language_detectors_1 = require("../detection/language-detectors");
+const plan_1 = require("../plan");
 const rootDir = (0, path_1.join)(__dirname, "..", "..", "..");
 const defaultSourceDirs = {
     rules: (0, path_1.join)(rootDir, "src", "rules"),
@@ -15,95 +18,166 @@ const defaultSourceDirs = {
     commands: (0, path_1.join)(rootDir, "src", "commands"),
 };
 async function sync(cwd, version, options, logger = output_1.log, sourceDirs = defaultSourceDirs) {
-    const manifest = (0, manifest_1.readManifest)(cwd);
     logger.logo(version);
-    if (manifest && manifest.version === version) {
-        logger.success(`Already at latest version (${version})`);
-        return;
-    }
     logger.welcome();
-    const counts = await doSync(cwd, version, options, logger, sourceDirs);
-    logger.summary(counts);
-}
-function writeItem(aiDir, file) {
-    const targetDir = (0, path_1.join)(aiDir, file.type);
-    if (!(0, fs_1.existsSync)(targetDir)) {
-        (0, fs_1.mkdirSync)(targetDir, { recursive: true });
-    }
-    const targetPath = (0, path_1.join)(targetDir, file.name);
-    const parentDir = (0, path_1.dirname)(targetPath);
-    if (!(0, fs_1.existsSync)(parentDir)) {
-        (0, fs_1.mkdirSync)(parentDir, { recursive: true });
-    }
-    (0, fs_1.writeFileSync)(targetPath, (0, template_1.processTemplate)(file.content));
-}
-async function doSync(cwd, version, options, logger, sourceDirs) {
     const aiDir = (0, path_1.join)(cwd, ".agents");
     if (!(0, fs_1.existsSync)(aiDir)) {
         (0, fs_1.mkdirSync)(aiDir, { recursive: true });
     }
+    const manifest = (0, manifest_1.readManifest)(cwd);
+    const desired = buildDesiredFiles(sourceDirs, cwd, options);
+    const actions = (0, plan_1.diffDesired)(desired, manifest, cwd);
+    const changes = executeActions(actions, cwd, logger);
+    const newFiles = {};
+    for (const [relPath, df] of desired) {
+        newFiles[relPath] = { sourceHash: df.identity };
+    }
+    (0, manifest_1.writeManifest)(cwd, { version, files: newFiles });
+    logger.summary(changes);
+}
+function buildDesiredFiles(sourceDirs, cwd, options) {
+    const desired = new Map();
     const contentFiles = (0, reader_1.readContent)(sourceDirs.rules, sourceDirs.skills);
     const rootFiles = (0, reader_1.readConfigs)(sourceDirs.agents);
-    const agentsFile = (0, reader_1.readAgents)(sourceDirs.agents);
-    const rules = contentFiles.filter((f) => f.type === "rules");
-    const stats = { rules: 0, skills: 0, commands: 0 };
-    const installedRootFiles = [];
+    const detectionResult = (0, detect_1.detectLanguages)(cwd);
+    let languages = detectionResult.languages;
+    let isMonorepo = detectionResult.isMonorepo;
+    const primaryLanguage = detectionResult.primaryLanguage;
+    if (options.allRules) {
+        languages = language_detectors_1.detectors.map((d) => d.name);
+        isMonorepo = true;
+    }
+    else if (options.monorepo) {
+        isMonorepo = true;
+    }
+    else if (options.singleRepo) {
+        isMonorepo = false;
+    }
+    if (options.languages && options.languages.length > 0) {
+        languages = options.languages;
+        isMonorepo = languages.length > 1;
+    }
+    if (languages.length === 0) {
+        isMonorepo = true;
+    }
+    const agentsFile = (0, reader_1.readAgents)(sourceDirs.agents, isMonorepo, primaryLanguage);
+    const ruleFilesToInclude = options.allRules
+        ? (0, detect_1.getAllRuleFiles)()
+        : (0, detect_1.getRuleFilesForLanguages)(languages);
+    const rules = contentFiles.filter((f) => {
+        if (f.type !== "rules")
+            return false;
+        if (!(0, detect_1.isLanguageSpecificRule)(f.name))
+            return true;
+        return ruleFilesToInclude.includes(f.name);
+    });
     if (!options.skipOpencode) {
         const commandConfig = (0, reader_1.getCommandConfig)(sourceDirs.commands);
-        stats.commands = Object.keys(commandConfig).length;
-        if (Object.keys(commandConfig).length > 0) {
-            logger.section("commands");
-            for (const name of Object.keys(commandConfig)) {
-                logger.success(`${name}.md`);
-            }
-        }
-        if (rootFiles.length > 0) {
-            logger.section("configs");
-            for (const file of rootFiles) {
-                let content = file.content;
-                if (file.name === "opencode.json" &&
-                    Object.keys(commandConfig).length > 0) {
-                    const config = JSON.parse(content);
-                    config.command = commandConfig;
-                    content = JSON.stringify(config, null, 2) + "\n";
-                }
-                const targetPath = (0, path_1.join)(cwd, file.name);
-                (0, fs_1.writeFileSync)(targetPath, content);
-                logger.success(`${file.name}`);
-                installedRootFiles.push(file.name);
+        for (const file of rootFiles) {
+            let content = file.content;
+            if (file.name === "opencode.json" &&
+                Object.keys(commandConfig).length > 0) {
+                const config = JSON.parse(content);
+                config.command = commandConfig;
+                content = JSON.stringify(config, null, 2) + "\n";
             }
+            desired.set(file.name, {
+                path: file.name,
+                identity: (0, manifest_1.hashContent)(content),
+                content,
+                category: file.name === "opencode.json"
+                    ? "opencode-json"
+                    : "static",
+            });
         }
     }
     if (agentsFile) {
-        const targetPath = (0, path_1.join)(cwd, agentsFile.name);
-        (0, fs_1.writeFileSync)(targetPath, (0, template_1.processTemplate)(agentsFile.content));
-        logger.success(`${agentsFile.name}`);
+        desired.set(agentsFile.name, {
+            path: agentsFile.name,
+            identity: (0, manifest_1.hashContent)(agentsFile.content),
+            content: (0, template_1.processTemplate)(agentsFile.content),
+            category: "agents-md",
+        });
     }
-    if (rules.length > 0) {
-        logger.section("rules");
-        for (const file of rules) {
-            writeItem(aiDir, file);
-            logger.success(`${file.name}`);
-            stats.rules++;
-        }
+    for (const file of rules) {
+        const relPath = (0, path_1.join)(".agents", file.type, file.name);
+        desired.set(relPath, {
+            path: relPath,
+            identity: (0, manifest_1.hashContent)(file.content),
+            content: (0, template_1.processTemplate)(file.content),
+            category: "static",
+        });
     }
     const skills = contentFiles.filter((f) => f.type === "skills");
-    if (skills.length > 0) {
-        logger.section("skills");
-        const skillDirs = [...new Set(skills.map((f) => f.name.split("/")[0]))];
-        stats.skills = skillDirs.length;
-        for (const dir of skillDirs) {
-            const dirFiles = skills.filter((f) => f.name.startsWith(dir + "/"));
-            logger.success(`${dir} (${dirFiles.length} files)`);
-            for (const file of dirFiles) {
-                writeItem(aiDir, file);
+    for (const file of skills) {
+        const relPath = (0, path_1.join)(".agents", file.type, file.name);
+        desired.set(relPath, {
+            path: relPath,
+            identity: (0, manifest_1.hashContent)(file.content),
+            content: (0, template_1.processTemplate)(file.content),
+            category: "static",
+        });
+    }
+    return desired;
+}
+function executeActions(actions, cwd, logger) {
+    const changes = (0, plan_1.emptySyncChanges)();
+    for (const action of actions) {
+        const targetPath = (0, path_1.join)(cwd, action.relPath);
+        switch (action.action) {
+            case "add": {
+                const dir = (0, path_1.dirname)(targetPath);
+                if (!(0, fs_1.existsSync)(dir))
+                    (0, fs_1.mkdirSync)(dir, { recursive: true });
+                (0, fs_1.writeFileSync)(targetPath, action.content);
+                changes.added++;
+                logger.success(`+ ${action.relPath}`);
+                break;
+            }
+            case "update": {
+                const dir = (0, path_1.dirname)(targetPath);
+                if (!(0, fs_1.existsSync)(dir))
+                    (0, fs_1.mkdirSync)(dir, { recursive: true });
+                (0, fs_1.writeFileSync)(targetPath, action.content);
+                changes.updated++;
+                logger.success(`~ ${action.relPath}`);
+                break;
+            }
+            case "skip":
+                changes.skipped++;
+                break;
+            case "merge": {
+                const currentContent = (0, fs_1.readFileSync)(targetPath, "utf-8");
+                const merged = (0, plan_1.mergeOpencodeJson)(action.content, currentContent);
+                (0, fs_1.writeFileSync)(targetPath, merged);
+                changes.merged++;
+                logger.success(`M ${action.relPath}`);
+                break;
+            }
+            case "backup": {
+                const currentContent = (0, fs_1.readFileSync)(targetPath, "utf-8");
+                const backupDir = (0, path_1.join)(cwd, ".agents");
+                if (!(0, fs_1.existsSync)(backupDir))
+                    (0, fs_1.mkdirSync)(backupDir, { recursive: true });
+                const backupPath = (0, path_1.join)(backupDir, `${action.relPath}.bak.${Date.now()}`);
+                (0, fs_1.writeFileSync)(backupPath, currentContent);
+                (0, fs_1.writeFileSync)(targetPath, action.content);
+                changes.backedUp++;
+                logger.success(`! ${action.relPath}`);
+                break;
+            }
+            case "remove": {
+                (0, fs_1.rmSync)(targetPath, { force: true });
+                changes.removed++;
+                logger.success(`- ${action.relPath}`);
+                break;
+            }
+            case "warn": {
+                changes.warned++;
+                logger.warn(`${action.relPath} (modified — skipped)`);
+                break;
             }
         }
     }
-    (0, manifest_1.writeManifest)(cwd, {
-        version,
-        installedAt: new Date().toISOString(),
-        rootFiles: installedRootFiles,
-    });
-    return stats;
+    return changes;
 }

package/dist/src/detection/detect.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectLanguages = detectLanguages;
+exports.getRuleFilesForLanguages = getRuleFilesForLanguages;
+exports.getAllRuleFiles = getAllRuleFiles;
+exports.isLanguageSpecificRule = isLanguageSpecificRule;
+const language_detectors_1 = require("./language-detectors");
+const scanner_1 = require("./scanner");
+function hasMatchingFile(files, names) {
+    return names.some((name) => files.some((f) => f === name || f.endsWith("/" + name)));
+}
+function hasMatchingExtension(files, extensions) {
+    return extensions.some((ext) => files.some((f) => f.endsWith(ext)));
+}
+function detectLanguages(cwd) {
+    const { allFiles, rootFiles } = (0, scanner_1.scanTree)(cwd);
+    const detected = new Set();
+    for (const detector of language_detectors_1.detectors) {
+        const hasConfigAtRoot = hasMatchingFile(rootFiles, detector.configFiles);
+        const hasConfigInTree = hasMatchingFile(allFiles, detector.configFiles);
+        const hasSource = hasMatchingExtension(allFiles, detector.extensions);
+        if (hasConfigAtRoot || hasConfigInTree || hasSource) {
+            detected.add(detector.name);
+        }
+    }
+    const languages = Array.from(detected);
+    const isMonorepo = languages.length > 1;
+    const primaryLanguage = languages.length > 0 ? languages[0] : undefined;
+    return { languages, isMonorepo, primaryLanguage };
+}
+function getRuleFilesForLanguages(languages) {
+    const ruleFiles = new Set();
+    for (const language of languages) {
+        const detector = language_detectors_1.detectors.find((d) => d.name === language);
+        if (detector) {
+            ruleFiles.add(detector.ruleFile);
+        }
+    }
+    return Array.from(ruleFiles);
+}
+function getAllRuleFiles() {
+    return language_detectors_1.detectors.map((detector) => detector.ruleFile);
+}
+function isLanguageSpecificRule(ruleFile) {
+    return language_detectors_1.detectors.some((detector) => detector.ruleFile === ruleFile);
+}

package/dist/src/detection/language-detectors.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectors = void 0;
+exports.detectors = [
+    {
+        name: "typescript",
+        ruleFile: "typescript.md",
+        configFiles: ["package.json", "tsconfig.json"],
+        extensions: [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"],
+    },
+    {
+        name: "go",
+        ruleFile: "go.md",
+        configFiles: ["go.mod"],
+        extensions: [".go"],
+    },
+    {
+        name: "kotlin",
+        ruleFile: "kotlin.md",
+        configFiles: ["build.gradle", "build.gradle.kts", "pom.xml"],
+        extensions: [".kt", ".kts", ".java"],
+    },
+];

package/dist/src/detection/scanner.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scanTree = scanTree;
+const fdir_1 = require("fdir");
+const IGNORE_DIRS = [
+    "node_modules",
+    ".git",
+    "dist",
+    "build",
+    "target",
+    ".next",
+    ".nuxt",
+];
+function scanTree(cwd, maxDepth = 4) {
+    const allFiles = new fdir_1.fdir()
+        .withRelativePaths()
+        .withMaxDepth(maxDepth)
+        .exclude((name) => IGNORE_DIRS.includes(name) || name.startsWith("."))
+        .crawl(cwd)
+        .sync();
+    const rootFiles = allFiles.filter((f) => !f.includes("/"));
+    return { allFiles, rootFiles };
+}

package/dist/src/index.js

@@ -15,5 +15,17 @@ program
 program
     .command("sync")
     .description("Initialize or update AI configuration")
-    .action(() => (0, sync_1.sync)(process.cwd(), version, program.opts()));
+    .option("--all-rules", "Install all language rules regardless of detection")
+    .option("--monorepo", "Force treat project as monorepo")
+    .option("--single-repo", "Force treat project as single repository")
+    .option("--languages <languages>", "Specify languages to install rules for (comma-separated)")
+    .action((cmdOptions) => {
+    const options = { ...program.opts(), ...cmdOptions };
+    if (options.languages && typeof options.languages === "string") {
+        options.languages = options.languages
+            .split(",")
+            .map((lang) => lang.trim());
+    }
+    (0, sync_1.sync)(process.cwd(), version, options);
+});
 program.parse();

package/dist/src/manifest.js

@@ -1,24 +1,38 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.hashContent = hashContent;
 exports.readManifest = readManifest;
 exports.writeManifest = writeManifest;
 const fs_1 = require("fs");
 const path_1 = require("path");
+const crypto_1 = require("crypto");
 const AI_DIR = ".agents";
 const MANIFEST_FILE = ".ai-kit";
 function getManifestPath(cwd) {
     return (0, path_1.join)(cwd, AI_DIR, MANIFEST_FILE);
 }
+function hashContent(content) {
+    return (0, crypto_1.createHash)("sha256").update(content, "utf-8").digest("hex");
+}
 function readManifest(cwd) {
     const path = getManifestPath(cwd);
     if (!(0, fs_1.existsSync)(path))
         return null;
-    return JSON.parse((0, fs_1.readFileSync)(path, "utf-8"));
+    try {
+        const data = JSON.parse((0, fs_1.readFileSync)(path, "utf-8"));
+        if (!data.files) {
+            return { version: data.version || "0.0.0", files: {} };
+        }
+        return data;
+    }
+    catch {
+        return null;
+    }
 }
 function writeManifest(cwd, manifest) {
     const dir = (0, path_1.join)(cwd, AI_DIR);
     if (!(0, fs_1.existsSync)(dir)) {
         (0, fs_1.mkdirSync)(dir, { recursive: true });
     }
-    (0, fs_1.writeFileSync)(getManifestPath(cwd), JSON.stringify(manifest, null, 2));
+    (0, fs_1.writeFileSync)(getManifestPath(cwd), JSON.stringify(manifest, null, 2) + "\n");
 }

package/dist/src/output.js

@@ -30,17 +30,28 @@ exports.log = {
     },
     section: (msg) => console.log(colorize(`  → ${msg}`, "cyan")),
     success: (msg) => console.log(colorize(`    ✓ ${msg}`, "green")),
+    warn: (msg) => console.log(colorize(`    ! ${msg}`, "yellow")),
     final: (msg) => console.log(colorize(`  ✓ ${msg}`, "green")),
     summary: (counts) => {
-        console.log(colorize("\n  ✓ Done!", "green"));
-        console.log(colorize(`  → `, "dim") +
-            colorize(counts.commands.toString(), "white") +
-            colorize(` commands`, "dim") +
-            colorize(`, `, "dim") +
-            colorize(counts.rules.toString(), "white") +
-            colorize(` rules`, "dim") +
-            colorize(`, `, "dim") +
-            colorize(counts.skills.toString(), "white") +
-            colorize(` skills`, "dim"));
+        const parts = [];
+        if (counts.added > 0)
+            parts.push(colorize(`+${counts.added} added`, "green"));
+        if (counts.updated > 0)
+            parts.push(colorize(`~${counts.updated} updated`, "white"));
+        if (counts.merged > 0)
+            parts.push(colorize(`M${counts.merged} merged`, "yellow"));
+        if (counts.backedUp > 0)
+            parts.push(colorize(`!${counts.backedUp} backed up`, "yellow"));
+        if (counts.removed > 0)
+            parts.push(colorize(`-${counts.removed} removed`, "red"));
+        if (counts.warned > 0)
+            parts.push(colorize(`!${counts.warned} modified (skipped)`, "yellow"));
+        if (parts.length === 0) {
+            console.log(colorize("\n  ✓ Everything up to date!", "green"));
+        }
+        else {
+            console.log(colorize("\n  ✓ Done!", "green"));
+            console.log("  " + parts.join(colorize(", ", "dim")));
+        }
     },
 };

package/dist/src/plan.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.emptySyncChanges = emptySyncChanges;
+exports.diffDesired = diffDesired;
+exports.mergeOpencodeJson = mergeOpencodeJson;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const template_1 = require("./template");
+function emptySyncChanges() {
+    return {
+        added: 0,
+        updated: 0,
+        merged: 0,
+        backedUp: 0,
+        removed: 0,
+        skipped: 0,
+        warned: 0,
+    };
+}
+function diffDesired(desired, manifest, cwd) {
+    const actions = [];
+    for (const [relPath, df] of desired) {
+        const lastEntry = manifest?.files[relPath];
+        const targetPath = (0, path_1.join)(cwd, relPath);
+        let onDiskContent = null;
+        try {
+            onDiskContent = (0, fs_1.readFileSync)(targetPath, "utf-8");
+        }
+        catch {
+            // file doesn't exist
+        }
+        if (onDiskContent === null) {
+            actions.push({ action: "add", relPath, content: df.content });
+            continue;
+        }
+        const normalizedDisk = (0, template_1.stripDates)(onDiskContent);
+        const normalizedDesired = (0, template_1.stripDates)(df.content);
+        if (normalizedDisk === normalizedDesired) {
+            actions.push({ action: "skip", relPath });
+            continue;
+        }
+        const sourceChanged = !lastEntry || lastEntry.sourceHash !== df.identity;
+        if (df.category === "opencode-json") {
+            actions.push({ action: "merge", relPath, content: df.content });
+        }
+        else if (sourceChanged && df.category === "agents-md") {
+            actions.push({ action: "backup", relPath, content: df.content });
+        }
+        else if (sourceChanged) {
+            actions.push({ action: "update", relPath, content: df.content });
+        }
+        else {
+            actions.push({ action: "warn", relPath });
+        }
+    }
+    if (manifest) {
+        for (const relPath of Object.keys(manifest.files)) {
+            if (!desired.has(relPath)) {
+                actions.push({ action: "remove", relPath });
+            }
+        }
+    }
+    return actions;
+}
+function mergeOpencodeJson(desiredContent, currentContent) {
+    const desired = JSON.parse(desiredContent);
+    const current = JSON.parse(currentContent);
+    const result = { ...desired };
+    if (current.mcp && typeof current.mcp === "object") {
+        const resultMcp = result.mcp;
+        for (const [key, value] of Object.entries(current.mcp)) {
+            if (!(key in resultMcp)) {
+                resultMcp[key] = value;
+            }
+        }
+    }
+    if (current.command && typeof current.command === "object") {
+        const resultCmd = result.command;
+        for (const [key, value] of Object.entries(current.command)) {
+            if (!(key in resultCmd)) {
+                resultCmd[key] = value;
+            }
+        }
+    }
+    for (const key of Object.keys(current)) {
+        if (!(key in result)) {
+            result[key] = current[key];
+        }
+    }
+    return JSON.stringify(result, null, 2) + "\n";
+}

package/dist/src/reader.js

@@ -84,13 +84,20 @@ function readConfigs(agentsDir) {
         return [];
     }
 }
-function readAgents(agentsDir) {
-    const sourcePath = (0, path_1.join)(agentsDir, "monorepo.md");
+function readAgents(agentsDir, isMonorepo = true, primaryLanguage) {
+    const templateName = isMonorepo ? "monorepo.md" : "single-repo.md";
+    const sourcePath = (0, path_1.join)(agentsDir, templateName);
     try {
+        let content = (0, fs_1.readFileSync)(sourcePath, "utf-8");
+        if (!isMonorepo && primaryLanguage) {
+            content = content
+                .replace(/{{LANGUAGE}}/g, primaryLanguage)
+                .replace(/{{LANGUAGE_RULE_FILE}}/g, `${primaryLanguage}.md`);
+        }
         return {
             type: "config",
             name: "AGENTS.md",
-            content: (0, fs_1.readFileSync)(sourcePath, "utf-8"),
+            content,
         };
     }
     catch {

package/dist/src/template.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.processTemplate = processTemplate;
+exports.stripDates = stripDates;
 function processTemplate(content) {
     const now = new Date();
     const isoDate = now.toISOString().split("T")[0];
@@ -8,3 +9,8 @@ function processTemplate(content) {
         .replace(/\{\{FOOTER}}/g, `Last updated: ${isoDate}. This file extends the global rules in @AGENTS.md. Always check both files.`)
         .replace(/\{\{AGENTS_FOOTER}}/g, `This file was last updated: ${isoDate}. Always check the \`.agents/rules/\` directory for the most current language-specific guidelines.`);
 }
+function stripDates(content) {
+    return content
+        .replace(/Last updated: \d{4}-\d{2}-\d{2}\. This file extends the global rules in @AGENTS\.md\. Always check both files\./g, "{{FOOTER}}")
+        .replace(/This file was last updated: \d{4}-\d{2}-\d{2}\. Always check the `\.agents\/rules\/` directory for the most current language-specific guidelines\./g, "{{AGENTS_FOOTER}}");
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clubmatto/ai-kit",
-  "version": "0.0.6",
+  "version": "0.0.8",
   "description": "The AI configuration CLI from Club Matto",
   "repository": {
     "type": "git",
@@ -26,10 +26,11 @@
     "prettier:check": "prettier --check .",
     "format": "prettier --write .",
     "lint": "eslint . && knip",
-    "ci": "npm run typecheck && npm run lint && npm run test && npm run test:integration"
+    "ci": "npm run prettier:check && npm run typecheck && npm run lint && npm run test && npm run test:integration"
   },
   "dependencies": {
     "commander": "^14.0.3",
+    "fdir": "6.5.0",
     "gradient-string": "^2.0.0"
   },
   "devDependencies": {

package/src/agents/monorepo.md

@@ -1,6 +1,6 @@
 # Agents.md
 
-This is a monorepo containing apps in many languages.
+This is a monorepo containing projects in many languages.
 
 You MUST follow the specific rules for each language. **ALWAYS** start from
 checking out the closest README.md.

package/src/agents/single-repo.md

@@ -0,0 +1,15 @@
+# Agents.md
+
+This project uses {{LANGUAGE}}. Follow these rules when working with {{LANGUAGE}} code. **ALWAYS** start from
+checking out the closest README.md.
+
+## Primary Rules
+
+Navigate to `.agents/rules/` and open `{{LANGUAGE_RULE_FILE}}`.
+
+## Additional Guidelines
+
+- [Plan Mode](.agents/rules/plan-mode.md)
+- [When You're Unsure](.agents/rules/unsure.md)
+
+_{{AGENTS_FOOTER}}_

package/src/rules/spring-boot.md

@@ -1,549 +0,0 @@
-# ☕ Spring Boot Specialist Agent Rules
-
-## 🎯 Your Spring Boot Persona
-
-You are a senior Spring Boot engineer with expertise in:
-
-- Modern Spring Boot 3.x with Kotlin
-- Spring Boot starters (web, graphql, oauth2, data, etc.)
-- Gradle with Kotlin DSL and version catalogs
-- Coroutines and structured concurrency
-- Repository pattern with JOOQ
-- GraphQL with Netflix DGS
-- Type-safe configuration with `@ConfigurationProperties`
-- Testing with JUnit 5, Kotest, and Testcontainers
-
-**Your primary values**: Type safety, convention over configuration, and pragmatic functional programming.
-
-## 📁 Spring Boot Project Structure
-
-Follow this exact structure for all Spring Boot projects:
-
-```
-[project-name]/
-├── src/
-│   ├── main/
-│   │   ├── kotlin/
-│   │   │   └── com/[company]/[project]/
-│   │   │       ├── [ApplicationName].kt           # Main application class
-│   │   │       ├── config/                        # Configuration classes
-│   │   │       ├── controller/                    # REST/GraphQL controllers
-│   │   │       ├── service/                       # Business logic
-│   │   │       ├── repository/                    # Data access layer
-│   │   │       ├── model/                         # Domain models
-│   │   │       ├── dto/                           # Data transfer objects
-│   │   │       ├── mapper/                        # Mappers between layers
-│   │   │       ├── errors/                        # Custom exceptions
-│   │   │       └── security/                      # Security configuration
-│   │   └── resources/
-│   │       ├── application.yml                    # Main configuration
-│   │       ├── application-dev.yml                # Development config
-│   │       ├── application-test.yml               # Test config
-│   │       └── graphql/                           # GraphQL schemas (if applicable)
-│   └── test/
-│       ├── kotlin/
-│       │   └── com/[company]/[project]/           # Unit tests
-│       └── resources/
-├── build.gradle.kts                               # Build configuration
-└── settings.gradle.kts                            # Project settings
-```
-
-## 🛠️ Development Commands
-
-### Essential Workflow Commands
-
-```bash
-# Run the application
-./gradlew :api:bootRun
-
-# Run tests
-./gradlew test                                    # All unit tests
-./gradlew test --info                            # With detailed output
-./gradlew integrationTest                        # Integration tests
-
-# Build
-./gradlew bootBuildImage                         # Build Docker image
-./gradlew bootJar                                # Build JAR
-
-# Code quality
-./gradlew spotlessCheck                          # Check formatting
-./gradlew spotlessApply                          # Apply formatting
-
-# Dependency updates
-./gradlew useLatestVersions                      # Update dependencies
-```
-
-### Common Build Configuration
-
-```kotlin
-// build.gradle.kts
-plugins {
-    alias(libs.plugins.kotlin.jvm)
-    alias(libs.plugins.kotlin.spring)
-    alias(libs.plugins.spring)
-    alias(libs.plugins.spring.dependency.management)
-    alias(libs.plugins.spotless)
-}
-
-java {
-    sourceCompatibility = JavaVersion.VERSION_21
-    targetCompatibility = JavaVersion.VERSION_21
-}
-
-dependencies {
-    implementation(libs.spring.boot.starter.web)
-    implementation(libs.spring.boot.starter.graphql)
-    implementation(libs.spring.boot.starter.oauth2.resourceserver)
-    implementation(libs.kotlinx.coroutines.core)
-    implementation(libs.kotlinx.coroutines.slf4j)
-
-    testImplementation(libs.spring.boot.starter.test)
-    testImplementation(libs.bundles.junit5)
-    testImplementation(libs.kotest.assertions)
-    testImplementation(libs.mockk)
-    testImplementation(libs.testcontainers)
-}
-
-tasks.test {
-    useJUnitPlatform {
-        excludeTags("integration")
-    }
-}
-```
-
-## 📝 Spring Boot Code Standards
-
-### Application Class
-
-```kotlin
-// ✅ GOOD: Clean application class with config properties scan
-@SpringBootApplication
-@ConfigurationPropertiesScan
-class ActoApiApplication
-
-fun main(args: Array<String>) {
-    runApplication<ActoApiApplication>(*args)
-}
-
-// ❌ BAD: Bloated application class
-@SpringBootApplication
-class ActoApiApplication {
-    @Bean
-    fun someBean() = ...
-
-    @PostConstruct
-    fun init() { ... }
-}
-```
-
-### Configuration Properties
-
-```kotlin
-// ✅ GOOD: Type-safe configuration properties
-@ConfigurationProperties(prefix = "app.feature-flags")
-@ConstructorBinding
-data class FeatureFlagProperties(
-    val newDashboardEnabled: Boolean = false,
-    val betaFeatures: List<String> = emptyList(),
-)
-
-// ✅ GOOD: Validate configuration
-@ConfigurationProperties(prefix = "mail")
-@Validated
-data class MailConfiguration(
-    @NotBlank val host: String,
-    @NotNull val port: Int,
-    val credentials: MailCredentials,
-)
-
-data class MailCredentials(
-    @NotBlank val username: String,
-    @NotBlank val password: String,
-)
-```
-
-### Service Layer
-
-```kotlin
-// ✅ GOOD: Constructor injection with repository pattern
-@Service
-class TeamService(
-    private val repositoryProvider: RepositoryProvider,
-    private val employeeService: EmployeeService,
-    private val analyticsServiceClient: AnalyticsServiceClient,
-    private val clock: Clock,
-) {
-    fun getManagedEmployees(
-        authentication: JwtTenantUserAuthentication,
-        first: Int,
-        after: EmployeeCursor?,
-    ): PagedResult<ManagedEmployee> {
-        val (regions, branches) = authentication.user.managerAccessFilters
-        val userRepository = repositoryProvider.get<UserRepository>()
-
-        // Implementation
-    }
-
-    // ✅ GOOD: Coroutine suspend functions for async operations
-    suspend fun getTeamKpiSummaries(
-        authentication: JwtTenantUserAuthentication,
-        period: StandardPeriod,
-        granularity: Granularity,
-        kpis: List<Kpi>,
-    ): KpiSummaries? {
-        // Implementation with coroutines
-    }
-}
-
-// ❌ BAD: Field injection
-@Service
-class UserService {
-    @Autowired
-    lateinit var repository: UserRepository
-}
-```
-
-### Repository Pattern
-
-```kotlin
-// ✅ GOOD: Repository interface with JOOQ
-@Repository
-class UserRepository(
-    private val dsl: DSLContext,
-) {
-    fun findById(id: UUID): User? {
-        return dsl.selectFrom(USER)
-            .where(USER.ID.eq(id))
-            .fetchOneInto(User::class.java)
-    }
-
-    fun findManagedUsers(
-        managerRegions: List<String>,
-        managerBranches: List<String>,
-        limit: Int,
-        afterUserDetailsId: Int?,
-    ): PagedResult<User> {
-        // Implementation with cursor pagination
-    }
-}
-
-// ✅ GOOD: Repository provider for dependency injection
-@Service
-class TeamService(
-    private val repositoryProvider: RepositoryProvider,
-) {
-    fun someMethod() {
-        val userRepository = repositoryProvider.get<UserRepository>()
-        // Use repository
-    }
-}
-```
-
-### Controller Layer (GraphQL)
-
-```kotlin
-// ✅ GOOD: GraphQL controller with batch mapping
-@Controller
-class TeamController(
-    private val teamService: TeamService,
-    private val cursorService: CursorService,
-    private val repositoryProvider: RepositoryProvider,
-) {
-    @QueryMapping
-    fun team(authentication: JwtTenantUserAuthentication): Team? {
-        val role = TenantUserRole.getMostPowerful(authentication.roles)
-        if (role == null || !role.isManager) {
-            return null
-        }
-        return Team
-    }
-
-    // ✅ GOOD: Schema mapping for nested fields
-    @SchemaMapping(typeName = "Team", field = "employees")
-    suspend fun employees(
-        @Argument first: Int?,
-        @Argument after: String?,
-        authentication: JwtTenantUserAuthentication,
-    ): EmployeeConnection {
-        val cursorData = after?.let { cursorService.decode(it, cursorStrategy) }
-        val result = teamService.getSortedManagedEmployees(
-            authentication = authentication,
-            first = first ?: 10,
-            after = cursorData,
-        )
-        // Return connection
-    }
-
-    // ✅ GOOD: Batch mapping to solve N+1 problem
-    @BatchMapping(typeName = "Employee", field = "meetings")
-    fun meetings(
-        employees: List<Employee>,
-        authentication: JwtTenantUserAuthentication,
-    ): Map<Employee, MeetingConnection> {
-        val employeeUuids = employees.map { UUID.fromString(it.id.toString()) }
-        // Batch fetch meetings
-    }
-}
-
-// ❌ BAD: No batch mapping causing N+1 queries
-```
-
-### Pagination
-
-```kotlin
-// ✅ GOOD: Cursor-based pagination
-data class EmployeeCursor(
-    val userDetailsId: Int,
-    val orderBy: String,
-    val sortValue: Double?,
-    val sortName: String,
-)
-
-data class PagedResult<T>(
-    val items: List<T>,
-    val hasMore: Boolean,
-)
-
-// ✅ GOOD: Pagination options
-data class PaginationOptions<T>(
-    val first: Int,
-    val after: T?,
-)
-```
-
-### Coroutines & Structured Concurrency
-
-```kotlin
-// ✅ GOOD: Parallel execution with coroutines
-suspend fun getEmployeeData(
-    employeeIds: List<UUID>,
-): EmployeeData = coroutineScope {
-    val employeesDeferred = async {
-        employeeService.getEmployees(employeeIds)
-    }
-
-    val kpisDeferred = async {
-        analyticsService.getKpis(employeeIds)
-    }
-
-    val employees = employeesDeferred.await()
-    val kpis = kpisDeferred.await()
-
-    // Combine results
-}
-
-// ✅ GOOD: WithContext for dispatcher switching
-suspend fun fetchData(): Data = withContext(Dispatchers.IO) {
-    repository.findAll()
-}
-
-// ❌ BAD: Blocking calls in coroutines
-suspend fun badExample() {
-    val result = Thread.sleep(1000) // Never do this
-}
-```
-
-### Error Handling
-
-```kotlin
-// ✅ GOOD: Custom exceptions
-sealed class ApiError(message: String) : Exception(message) {
-    data class EntityNotFoundError(val entityType: String, val id: UUID) :
-        ApiError("$entityType with ID: $id not found")
-
-    data class AuthorizationError(val user: User, val action: String) :
-        ApiError("User ${user.id} not authorized for $action")
-}
-
-// ✅ GOOD: Global exception handler
-@ControllerAdvice
-class GlobalExceptionHandler {
-    @ExceptionHandler(ApiError::class)
-    fun handleApiError(error: ApiError): ResponseEntity<ErrorResponse> {
-        return ResponseEntity
-            .status(HttpStatus.BAD_REQUEST)
-            .body(ErrorResponse(error.message))
-    }
-}
-```
-
-### Logging
-
-```kotlin
-// ✅ GOOD: Structured logging with context
-@Service
-class TeamService(
-    private val repositoryProvider: RepositoryProvider,
-) {
-    private val logger = LoggerFactory.getLogger(TeamService::class.java)
-
-    fun getManagedEmployees(...): PagedResult<ManagedEmployee> {
-        logger.debug(
-            "Fetching managed employees: regions={}, branches={}",
-            regions, branches
-        )
-
-        WideEventContext.addContext(
-            mapOf(
-                "operation" to "team.employees",
-                "first" to first,
-                "has_cursor" to (after != null),
-            )
-        )
-
-        // Implementation
-    }
-}
-```
-
-## 🧪 Testing Standards
-
-### Unit Tests
-
-```kotlin
-// ✅ GOOD: JUnit 5 with Kotest assertions
-class TeamServiceTest {
-    private lateinit var teamService: TeamService
-    private val repositoryProvider = mockk<RepositoryProvider>()
-    private val employeeService = mockk<EmployeeService>()
-
-    @BeforeEach
-    fun setup() {
-        teamService = TeamService(
-            repositoryProvider = repositoryProvider,
-            employeeService = employeeService,
-            analyticsServiceClient = mockk(),
-            clock = Clock.systemDefaultZone(),
-        )
-    }
-
-    @Test
-    fun `getManagedEmployees returns empty list when no employees`() {
-        // Given
-        val authentication = createTestAuthentication()
-        every { repositoryProvider.get<UserRepository>() } returns mockk {
-            every { findManagedUsers(...) } returns PagedResult(emptyList(), false)
-        }
-
-        // When
-        val result = teamService.getManagedEmployees(authentication, 10, null)
-
-        // Then
-        result.items shouldBeEmpty()
-        result.hasMore shouldBe false
-    }
-}
-```
-
-### Integration Tests
-
-```kotlin
-// ✅ GOOD: Integration test with testcontainers
-@IntegrationTest
-class UserRepositoryIntegrationTest {
-    private lateinit var repository: UserRepository
-    private val postgresContainer = PostgreSQLContainer<Nothing>("postgres:16")
-
-    @BeforeEach
-    fun setup() {
-        postgresContainer.start()
-        val datasource = DataSourceBuilder.create()
-            .url(postgresContainer.jdbcUrl)
-            .username(postgresContainer.username)
-            .password(postgresContainer.password)
-            .build()
-
-        repository = UserRepository(DSLContextFactory.from(datasource))
-    }
-
-    @Test
-    fun `findById returns user when exists`() {
-        // Given
-        val user = createTestUser()
-        repository.save(user)
-
-        // When
-        val result = repository.findById(user.id)
-
-        // Then
-        result shouldBeEqualTo user
-    }
-}
-
-// Tag integration tests
-@Tag("integration")
-class IntegrationTests { ... }
-```
-
-### Test Helpers
-
-```kotlin
-// ✅ GOOD: Reusable test extensions
-@ExtendWith(PostgresLifecycleExtension::class)
-class PostgresTest {
-    // Access to postgresContainer via ExtensionContext
-}
-
-// ✅ GOOD: Test fixtures
-object TestFixtures {
-    fun createTestUser(
-        id: UUID = UUID.randomUUID(),
-        name: String = "Test User",
-    ) = User(id = id, name = name)
-}
-```
-
-## 📦 Dependency Management
-
-### Version Catalogs (libs.versions.toml)
-
-```toml
-[versions]
-spring-boot = "3.5.10"
-kotlin = "2.3.0"
-kotest = "5.9.1"
-
-[plugins]
-kotlin-jvm = { id = "org.jetbrains.kotlin.jvm", version.ref = "kotlin" }
-kotlin-spring = { id = "org.jetbrains.kotlin.plugin.spring", version.ref = "kotlin" }
-spring = { id = "org.springframework.boot", version.ref = "spring-boot" }
-
-[libraries]
-spring-boot-starter-web = { group = "org.springframework.boot", name = "spring-boot-starter-web" }
-spring-boot-starter-graphql = { group = "org.springframework.boot", name = "spring-boot-starter-graphql" }
-kotest-assertions = { group = "io.kotest", name = "kotest-assertions-core", version.ref = "kotest" }
-
-[bundles]
-kotlin = ["kotlin-reflect", "kotlinx-coroutines-core"]
-testing = ["junit5-jupiter", "kotest-assertions", "mockk"]
-```
-
-### Dependency Rules
-
-- Use version catalogs for centralized dependency management
-- Pin exact versions – avoid floating dependencies like `1.+`
-- Use Spring Boot BOM for transitive dependency versions
-- Prefer platform-specific starters over generic dependencies
-
-## 🚫 Spring Boot-Specific Restrictions
-
-### Never Do These:
-
-- ❌ Never use field injection (`@Autowired lateinit var`) – use constructor injection
-- ❌ Never block coroutines with `.get()` or `.join()` – use suspend functions
-- ❌ Never commit transactions in service layer – keep transactions at repository level
-- ❌ Never return JPA entities from controllers – use DTOs
-- ❌ Never ignore nullable types – use `?` and safe calls
-- ❌ Never use `any` in Kotlin code – use proper types
-- ❌ Never hardcode configuration – use `application.yml`
-- ❌ Never write business logic in controllers – delegate to services
-
-### Avoid These When Possible:
-
-- ⚠️ Avoid circular dependencies between services
-- ⚠️ Avoid monolithic controllers – delegate to services
-- ⚠️ Avoid mutable data classes – use `val` properties
-- ⚠️ Avoid `!!` operator – use safe calls or `requireNotNull`
-- ⚠️ Avoid complex inheritance hierarchies – prefer composition
-
-{{FOOTER}}