@clubmatto/ai-kit 0.0.1

package/CHANGELOG.md

@@ -0,0 +1,15 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+## [Unreleased]
+
+### Added
+
+- Initial setup for release-it
+
+## [0.0.1] - 2026-02-21
+
+### Added
+
+- Initial release

package/README.md

@@ -0,0 +1,65 @@
+# ai-kit
+
+[![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/ai-kit)](/LICENSE)
+
+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)
+
+## Quick Start
+
+```bash
+# Install globally
+npm install -g @clubmatto/ai-kit
+
+# Sync AI configuration to your project
+ai-kit sync
+```
+
+## Usage
+
+```bash
+# Initialize or update AI configuration
+ai-kit sync
+
+# Skip installing opencode.json to project root
+ai-kit sync --skip-opencode
+```
+
+## What's Installed
+
+| Location        | Description                       |
+| --------------- | --------------------------------- |
+| `.ai/commands/` | Command prompts                   |
+| `.ai/rules/`    | Language/framework rules          |
+| `.ai/skills/`   | Reusable AI capabilities          |
+| `opencode.json` | Opencode configuration (optional) |
+| `AGENTS.md`     | Agent instructions                |
+
+## Commands
+
+| Command       | Description                        |
+| ------------- | ---------------------------------- |
+| `ai-kit sync` | Initialize or update configuration |
+
+## Local Development
+
+```bash
+# Build the CLI
+npm run build
+
+# Link for local testing
+npm link
+
+# Test in any directory
+ai-kit sync
+```
+
+## License
+
+MIT — see [LICENSE](/LICENSE) for details.

package/dist/scripts/fetch-playwright-skills.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = require("fs");
+const path_1 = require("path");
+const rootDir = (0, path_1.join)(__dirname, "..");
+const skillsDir = (0, path_1.join)(rootDir, "src", "skills", "playwright-cli");
+const GITHUB_API = "https://api.github.com";
+const REPO = "microsoft/playwright-cli";
+const args = process.argv.slice(2);
+const VERSION = args[0] || "v0.1.1";
+async function fetchJson(url) {
+    const res = await fetch(url, {
+        headers: {
+            Accept: "application/vnd.github.v3+json",
+            "User-Agent": "ai-kit",
+        },
+    });
+    if (!res.ok) {
+        throw new Error(`Failed to fetch ${url}: ${res.status} ${res.statusText}`);
+    }
+    return (await res.json());
+}
+async function fetchFile(url) {
+    const res = await fetch(url, {
+        headers: {
+            Accept: "application/vnd.github.v3.raw",
+            "User-Agent": "ai-kit",
+        },
+    });
+    if (!res.ok) {
+        throw new Error(`Failed to fetch ${url}: ${res.status} ${res.statusText}`);
+    }
+    return res.text();
+}
+async function main() {
+    console.log(`Fetching playwright-cli skills from ${REPO}@${VERSION}...`);
+    const baseUrl = `${GITHUB_API}/repos/${REPO}/contents/skills/playwright-cli?ref=${VERSION}`;
+    const files = await fetchJson(baseUrl);
+    (0, fs_1.mkdirSync)(skillsDir, { recursive: true });
+    (0, fs_1.mkdirSync)((0, path_1.join)(skillsDir, "references"), { recursive: true });
+    for (const file of files) {
+        if (file.type === "dir" && file.name === "references") {
+            const refs = await fetchJson(file.url);
+            for (const ref of refs) {
+                const content = await fetchFile(ref.download_url);
+                const targetPath = (0, path_1.join)(skillsDir, "references", ref.name);
+                (0, fs_1.writeFileSync)(targetPath, content);
+                console.log(`  - references/${ref.name}`);
+            }
+        }
+        else if (file.type === "file") {
+            const content = await fetchFile(file.download_url);
+            const targetPath = (0, path_1.join)(skillsDir, file.name);
+            (0, fs_1.writeFileSync)(targetPath, content);
+            console.log(`  - ${file.name}`);
+        }
+    }
+    console.log(`\nDone! Skills written to src/skills/playwright-cli/`);
+}
+main().catch((err) => {
+    console.error(err);
+    process.exit(1);
+});

package/dist/src/cmd/sync.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sync = sync;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const reader_1 = require("../reader");
+const manifest_1 = require("../manifest");
+const template_1 = require("../template");
+const output_1 = require("../output");
+const rootDir = (0, path_1.join)(__dirname, "..", "..", "..");
+const defaultSourceDirs = {
+    rules: (0, path_1.join)(rootDir, "src", "rules"),
+    skills: (0, path_1.join)(rootDir, "src", "skills"),
+    agents: (0, path_1.join)(rootDir, "src", "agents"),
+    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 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 = [];
+    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);
+            }
+        }
+    }
+    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}`);
+    }
+    if (rules.length > 0) {
+        logger.section("rules");
+        for (const file of rules) {
+            writeItem(aiDir, file);
+            logger.success(`${file.name}`);
+            stats.rules++;
+        }
+    }
+    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);
+            }
+        }
+    }
+    (0, manifest_1.writeManifest)(cwd, {
+        version,
+        installedAt: new Date().toISOString(),
+        rootFiles: installedRootFiles,
+    });
+    return stats;
+}

package/dist/src/commands/sync.js

@@ -0,0 +1,111 @@
+import { mkdirSync, existsSync, writeFileSync } from "fs";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+import { getContentFiles, getRootFiles, getAgentsFile, getCommandConfig, } from "../content.js";
+import { readManifest, writeManifest } from "../manifest.js";
+import { processTemplate } from "../template.js";
+import { log } from "../output.js";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const rootDir = join(__dirname, "..", "..", "..");
+const defaultSourceDirs = {
+    rules: join(rootDir, "src", "rules"),
+    skills: join(rootDir, "src", "skills"),
+    agents: join(rootDir, "src", "agents"),
+    commands: join(rootDir, "src", "commands"),
+};
+export async function sync(cwd, version, options, logger = log, sourceDirs = defaultSourceDirs) {
+    const manifest = readManifest(cwd);
+    logger.logo(version);
+    if (!manifest) {
+        logger.action("Initializing ai-kit...");
+        const count = await doSync(cwd, version, options, logger, sourceDirs);
+        logger.final(`ai-kit initialized (${count} files)`);
+        return;
+    }
+    if (manifest.version === version) {
+        logger.success(`Already at latest version (${version})`);
+        return;
+    }
+    logger.action(`Updating from ${manifest.version} to ${version}...`);
+    const count = await doSync(cwd, version, options, logger, sourceDirs);
+    logger.final(`Updated to ${version} (${count} files)`);
+}
+async function doSync(cwd, version, options, logger, sourceDirs) {
+    const aiDir = join(cwd, ".agents");
+    if (!existsSync(aiDir)) {
+        mkdirSync(aiDir, { recursive: true });
+    }
+    const contentFiles = getContentFiles(sourceDirs.rules, sourceDirs.skills);
+    const rootFiles = getRootFiles(sourceDirs.agents);
+    const agentsFile = getAgentsFile(sourceDirs.agents);
+    const rules = contentFiles.filter((f) => f.type === "rules");
+    const skills = contentFiles.filter((f) => f.type === "skills");
+    let count = 0;
+    if (rules.length > 0) {
+        logger.section("rules");
+        for (const file of rules) {
+            const targetDir = join(aiDir, file.type);
+            if (!existsSync(targetDir)) {
+                mkdirSync(targetDir, { recursive: true });
+            }
+            const targetPath = join(targetDir, file.name);
+            const parentDir = dirname(targetPath);
+            if (!existsSync(parentDir)) {
+                mkdirSync(parentDir, { recursive: true });
+            }
+            writeFileSync(targetPath, processTemplate(file.content));
+            logger.success(`${file.type}/${file.name}`);
+            count++;
+        }
+    }
+    if (skills.length > 0) {
+        logger.section("skills");
+        for (const file of skills) {
+            const targetDir = join(aiDir, file.type);
+            if (!existsSync(targetDir)) {
+                mkdirSync(targetDir, { recursive: true });
+            }
+            const targetPath = join(targetDir, file.name);
+            const parentDir = dirname(targetPath);
+            if (!existsSync(parentDir)) {
+                mkdirSync(parentDir, { recursive: true });
+            }
+            writeFileSync(targetPath, processTemplate(file.content));
+            logger.success(`${file.type}/${file.name}`);
+            count++;
+        }
+    }
+    const installedRootFiles = [];
+    if (!options.skipOpencode) {
+        const commandConfig = getCommandConfig(sourceDirs.commands);
+        if (rootFiles.length > 0) {
+            logger.section("root files");
+            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 = join(cwd, file.name);
+                writeFileSync(targetPath, content);
+                logger.success(`${file.name}`);
+                installedRootFiles.push(file.name);
+                count++;
+            }
+        }
+    }
+    if (agentsFile) {
+        const targetPath = join(cwd, agentsFile.name);
+        writeFileSync(targetPath, processTemplate(agentsFile.content));
+        logger.success(`${agentsFile.name}`);
+        count++;
+    }
+    writeManifest(cwd, {
+        version,
+        installedAt: new Date().toISOString(),
+        rootFiles: installedRootFiles,
+    });
+    return count;
+}

package/dist/src/content.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCommandConfig = getCommandConfig;
+exports.getContentFiles = getContentFiles;
+exports.getRootFiles = getRootFiles;
+exports.getAgentsFile = getAgentsFile;
+const fs_1 = require("fs");
+const path_1 = require("path");
+function parseFrontmatter(content) {
+    const result = {};
+    const match = content.match(/^---\n([\s\S]*?)\n---/);
+    if (!match)
+        return result;
+    const frontmatter = match[1];
+    for (const line of frontmatter.split("\n")) {
+        const colonIndex = line.indexOf(":");
+        if (colonIndex === -1)
+            continue;
+        const key = line.slice(0, colonIndex).trim();
+        result[key] = line.slice(colonIndex + 1).trim();
+    }
+    return result;
+}
+function getCommandConfig(commandsDir) {
+    const config = {};
+    try {
+        const files = (0, fs_1.readdirSync)(commandsDir);
+        for (const file of files) {
+            if (!file.endsWith(".md"))
+                continue;
+            const filePath = (0, path_1.join)(commandsDir, file);
+            const content = (0, fs_1.readFileSync)(filePath, "utf-8");
+            const frontmatter = parseFrontmatter(content);
+            const name = file.replace(/\.md$/, "");
+            const body = content.replace(/^---[\s\S]*?---\n/, "").trim();
+            config[name] = {
+                description: frontmatter.description || "",
+                template: body,
+            };
+        }
+    }
+    catch {
+        return config;
+    }
+    return config;
+}
+function getFiles(dir, type, baseDir) {
+    if (!(0, fs_1.readdirSync)(dir, { withFileTypes: true }).length) {
+        return [];
+    }
+    const base = baseDir || dir;
+    return (0, fs_1.readdirSync)(dir, { withFileTypes: true }).flatMap((entry) => {
+        const path = (0, path_1.join)(dir, entry.name);
+        const relativePath = path.slice(base.length + 1);
+        if (entry.isDirectory()) {
+            return getFiles(path, type, base);
+        }
+        if (entry.name.endsWith(".md")) {
+            return [
+                {
+                    type,
+                    name: relativePath,
+                    content: (0, fs_1.readFileSync)(path, "utf-8"),
+                },
+            ];
+        }
+        return [];
+    });
+}
+function getContentFiles(rulesDir, skillsDir) {
+    return [...getFiles(rulesDir, "rules"), ...getFiles(skillsDir, "skills")];
+}
+function getRootFiles(agentsDir) {
+    try {
+        return (0, fs_1.readdirSync)(agentsDir, { withFileTypes: true })
+            .filter((entry) => entry.isFile() && entry.name.endsWith(".json"))
+            .map((entry) => ({
+            type: "config",
+            name: entry.name,
+            content: (0, fs_1.readFileSync)((0, path_1.join)(agentsDir, entry.name), "utf-8"),
+        }));
+    }
+    catch {
+        return [];
+    }
+}
+function getAgentsFile(agentsDir) {
+    const sourcePath = (0, path_1.join)(agentsDir, "monorepo.md");
+    try {
+        return {
+            type: "config",
+            name: "AGENTS.md",
+            content: (0, fs_1.readFileSync)(sourcePath, "utf-8"),
+        };
+    }
+    catch {
+        return null;
+    }
+}

package/dist/src/index.js

@@ -0,0 +1,19 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const sync_1 = require("./cmd/sync");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const version = JSON.parse((0, fs_1.readFileSync)((0, path_1.join)(__dirname, "..", "..", "package.json"), "utf-8")).version;
+const program = new commander_1.Command();
+program
+    .name("@clubmatto/ai-kit")
+    .description("The AI configuration CLI from Club Matto")
+    .version(version)
+    .option("--skip-opencode", "Skip installing opencode.json to project root");
+program
+    .command("sync")
+    .description("Initialize or update AI configuration")
+    .action(() => (0, sync_1.sync)(process.cwd(), version, program.opts()));
+program.parse();

package/dist/src/logger.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/manifest.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readManifest = readManifest;
+exports.writeManifest = writeManifest;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const AI_DIR = ".agents";
+const MANIFEST_FILE = ".ai-kit";
+function getManifestPath(cwd) {
+    return (0, path_1.join)(cwd, AI_DIR, MANIFEST_FILE);
+}
+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"));
+}
+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));
+}

package/dist/src/output.js

@@ -0,0 +1,46 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.log = void 0;
+const gradient_string_1 = __importDefault(require("gradient-string"));
+const brand = (0, gradient_string_1.default)(["#ff006e", "#fb5607", "#ffbe0b", "#8338ec", "#3a86ff"]);
+const colors = {
+    green: "\x1b[32m",
+    cyan: "\x1b[36m",
+    yellow: "\x1b[33m",
+    red: "\x1b[31m",
+    dim: "\x1b[90m",
+    white: "\x1b[37m",
+    reset: "\x1b[0m",
+};
+function colorize(text, color) {
+    return `${colors[color]}${text}${colors.reset}`;
+}
+exports.log = {
+    logo: (version) => {
+        console.log(brand(`ai-kit v${version}`) +
+            "  " +
+            colorize("The AI configuration CLI", "dim"));
+        console.log(colorize("from Club Matto\n", "dim"));
+    },
+    welcome: () => {
+        console.log(colorize("  Syncing AI rules, skills, and commands to your project...\n", "dim"));
+    },
+    section: (msg) => console.log(colorize(`  → ${msg}`, "cyan")),
+    success: (msg) => console.log(colorize(`    ✓ ${msg}`, "green")),
+    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"));
+    },
+};

package/dist/src/reader.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCommandConfig = getCommandConfig;
+exports.readContent = readContent;
+exports.readConfigs = readConfigs;
+exports.readAgents = readAgents;
+const fs_1 = require("fs");
+const path_1 = require("path");
+function parseFrontmatter(content) {
+    const result = {};
+    const match = content.match(/^---\n([\s\S]*?)\n---/);
+    if (!match)
+        return result;
+    const frontmatter = match[1];
+    for (const line of frontmatter.split("\n")) {
+        const colonIndex = line.indexOf(":");
+        if (colonIndex === -1)
+            continue;
+        const key = line.slice(0, colonIndex).trim();
+        result[key] = line.slice(colonIndex + 1).trim();
+    }
+    return result;
+}
+function getCommandConfig(commandsDir) {
+    const config = {};
+    try {
+        const files = (0, fs_1.readdirSync)(commandsDir);
+        for (const file of files) {
+            if (!file.endsWith(".md"))
+                continue;
+            const filePath = (0, path_1.join)(commandsDir, file);
+            const content = (0, fs_1.readFileSync)(filePath, "utf-8");
+            const frontmatter = parseFrontmatter(content);
+            const name = file.replace(/\.md$/, "");
+            const body = content.replace(/^---[\s\S]*?---\n/, "").trim();
+            config[name] = {
+                description: frontmatter.description || "",
+                template: body,
+            };
+        }
+    }
+    catch {
+        return config;
+    }
+    return config;
+}
+function readFiles(dir, type, baseDir) {
+    if (!(0, fs_1.readdirSync)(dir, { withFileTypes: true }).length) {
+        return [];
+    }
+    const base = baseDir || dir;
+    return (0, fs_1.readdirSync)(dir, { withFileTypes: true }).flatMap((entry) => {
+        const path = (0, path_1.join)(dir, entry.name);
+        const relativePath = path.slice(base.length + 1);
+        if (entry.isDirectory()) {
+            return readFiles(path, type, base);
+        }
+        if (entry.name.endsWith(".md")) {
+            return [
+                {
+                    type,
+                    name: relativePath,
+                    content: (0, fs_1.readFileSync)(path, "utf-8"),
+                },
+            ];
+        }
+        return [];
+    });
+}
+function readContent(rulesDir, skillsDir) {
+    return [...readFiles(rulesDir, "rules"), ...readFiles(skillsDir, "skills")];
+}
+function readConfigs(agentsDir) {
+    try {
+        return (0, fs_1.readdirSync)(agentsDir, { withFileTypes: true })
+            .filter((entry) => entry.isFile() && entry.name.endsWith(".json"))
+            .map((entry) => ({
+            type: "config",
+            name: entry.name,
+            content: (0, fs_1.readFileSync)((0, path_1.join)(agentsDir, entry.name), "utf-8"),
+        }));
+    }
+    catch {
+        return [];
+    }
+}
+function readAgents(agentsDir) {
+    const sourcePath = (0, path_1.join)(agentsDir, "monorepo.md");
+    try {
+        return {
+            type: "config",
+            name: "AGENTS.md",
+            content: (0, fs_1.readFileSync)(sourcePath, "utf-8"),
+        };
+    }
+    catch {
+        return null;
+    }
+}

package/dist/src/template.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processTemplate = processTemplate;
+function processTemplate(content) {
+    const now = new Date();
+    const isoDate = now.toISOString().split("T")[0];
+    return 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 \`.ai/rules/\` directory for the most current language-specific guidelines.`);
+}