agent-rules
Version:
Rules and instructions for agentic coding tools like Cursor, Claude CLI, Gemini CLI, Qodo, Cline and more
209 lines (205 loc) • 9.51 kB
JavaScript
;
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames(from))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
}
return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
// If the importer is in node compatibility mode or this is not an ESM
// file that has been converted to a CommonJS file using a Babel-
// compatible transform (i.e. "__esModule" has not been set), then set
// "default" to the CommonJS "module.exports" for node compatibility.
isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
mod
));
// src/bin/cli.ts
var import_prompts = require("@clack/prompts");
var import_node_util2 = require("util");
// src/main.ts
var import_node_path = __toESM(require("path"), 1);
var import_promises = __toESM(require("fs/promises"), 1);
var import_node_url = require("url");
var import_node_util = require("util");
var import_meta = {};
var debug = (0, import_node_util.debuglog)("agent-rules");
var templateRoot = "__template__";
var mapAiAppsToDirectories = {
"github-copilot": {
directory: ".github/instructions",
filesSuffix: ".instructions.md"
}
};
function resolvePackageRootDirectoryForTemplates() {
let guessedDirName = "";
try {
if (typeof import_meta !== "undefined" && import_meta.url) {
const __filename = (0, import_node_url.fileURLToPath)(import_meta.url);
guessedDirName = import_node_path.default.dirname(__filename);
} else {
guessedDirName = __dirname;
}
} catch (error) {
guessedDirName = __dirname;
}
if (guessedDirName.endsWith("src")) {
return import_node_path.default.resolve(guessedDirName, "..");
} else if (guessedDirName.endsWith("dist/bin") || guessedDirName.endsWith("dist\\bin")) {
return import_node_path.default.resolve(guessedDirName, "..");
} else {
return guessedDirName;
}
}
__name(resolvePackageRootDirectoryForTemplates, "resolvePackageRootDirectoryForTemplates");
function getAiAppDirectory(aiApp) {
const app = Object.hasOwn(mapAiAppsToDirectories, aiApp) ? mapAiAppsToDirectories[aiApp] : null;
if (!app) {
throw new Error(`AI App "${aiApp}" is not supported.`);
}
return app;
}
__name(getAiAppDirectory, "getAiAppDirectory");
async function resolveTemplateDirectory(scaffoldInstructions) {
const { codeLanguage, codeTopic } = scaffoldInstructions;
const currentFileDirectory = resolvePackageRootDirectoryForTemplates();
const templateDirectory = import_node_path.default.join(currentFileDirectory, templateRoot, codeLanguage, codeTopic);
const resolvedTemplateDirectory = import_node_path.default.resolve(templateDirectory);
try {
const templateStats = await import_promises.default.stat(resolvedTemplateDirectory);
if (!templateStats.isDirectory()) {
throw new Error(`Template directory is not a directory: ${resolvedTemplateDirectory}`);
}
} catch (error) {
throw new Error(`Template directory not found: ${resolvedTemplateDirectory}`);
}
return resolvedTemplateDirectory;
}
__name(resolveTemplateDirectory, "resolveTemplateDirectory");
async function createTargetDirectory(directory) {
const resolvedTargetDirectory = import_node_path.default.resolve(directory);
await import_promises.default.mkdir(resolvedTargetDirectory, { recursive: true });
return resolvedTargetDirectory;
}
__name(createTargetDirectory, "createTargetDirectory");
function generateTargetFileName(templateFileName, filesSuffix) {
const parsedFile = import_node_path.default.parse(templateFileName);
let baseName = parsedFile.name;
if (baseName.endsWith(".instructions")) {
baseName = baseName.replace(/\.instructions$/, "");
}
return `${baseName}${filesSuffix}`;
}
__name(generateTargetFileName, "generateTargetFileName");
function validateTargetPath(targetFilePath, resolvedTargetDirectory) {
const resolvedTargetFilePath = import_node_path.default.resolve(targetFilePath);
if (!resolvedTargetFilePath.startsWith(resolvedTargetDirectory)) {
throw new Error(`Invalid target path: ${targetFilePath}`);
}
return resolvedTargetFilePath;
}
__name(validateTargetPath, "validateTargetPath");
async function copyTemplateFile(templateFilePath, targetFilePath, resolvedTargetDirectory, filesSuffix) {
const sanitizedTemplateFile = import_node_path.default.basename(templateFilePath);
const fullTemplatePath = import_node_path.default.join(import_node_path.default.dirname(templateFilePath), sanitizedTemplateFile);
debug("Processing template file:", sanitizedTemplateFile);
try {
const stat = await import_promises.default.stat(fullTemplatePath);
if (stat.isFile()) {
const targetFileName = generateTargetFileName(sanitizedTemplateFile, filesSuffix);
const targetPath = import_node_path.default.join(targetFilePath, targetFileName);
const resolvedTargetFilePath = validateTargetPath(targetPath, resolvedTargetDirectory);
debug("Writing template file to target path:", resolvedTargetFilePath);
const templateContent = await import_promises.default.readFile(fullTemplatePath, "utf-8");
await import_promises.default.writeFile(resolvedTargetFilePath, templateContent, "utf-8");
}
} catch (error) {
console.warn(`Skipping file ${sanitizedTemplateFile}: ${error instanceof Error ? error.message : "Unknown error"}`);
}
}
__name(copyTemplateFile, "copyTemplateFile");
async function copyTemplateFiles(resolvedTemplateDirectory, resolvedTargetDirectory, filesSuffix) {
const templateFiles = await import_promises.default.readdir(resolvedTemplateDirectory);
for (const templateFile of templateFiles) {
const templateFilePath = import_node_path.default.join(resolvedTemplateDirectory, templateFile);
await copyTemplateFile(templateFilePath, resolvedTargetDirectory, resolvedTargetDirectory, filesSuffix);
}
}
__name(copyTemplateFiles, "copyTemplateFiles");
async function scaffoldAiAppInstructions(scaffoldInstructions) {
const { aiApp, codeLanguage, codeTopic } = scaffoldInstructions;
if (!aiApp || !codeLanguage || !codeTopic) {
throw new Error("Scaffold instructions must include aiApp and all other template choices.");
}
const aiAppConfig = getAiAppDirectory(aiApp);
const { directory, filesSuffix } = aiAppConfig;
debug(`Scaffolding AI App instructions in directory: ${directory} with files suffix: ${filesSuffix}`);
const resolvedTemplateDirectory = await resolveTemplateDirectory(scaffoldInstructions);
const resolvedTargetDirectory = await createTargetDirectory(directory);
await copyTemplateFiles(resolvedTemplateDirectory, resolvedTargetDirectory, filesSuffix);
}
__name(scaffoldAiAppInstructions, "scaffoldAiAppInstructions");
// src/bin/cli.ts
var debug2 = (0, import_node_util2.debuglog)("agent-rules");
async function init() {
(0, import_prompts.intro)((0, import_node_util2.styleText)(["bgMagentaBright", "black"], " Agent, rules!"));
const codeLanguage = "nodejs";
debug2("Selected code language:", codeLanguage);
const aiApp = await (0, import_prompts.select)({
message: "Which AI App would you like to generate agentic rules for?",
options: [
{ value: "claude-code", label: "Claude Code" },
{ value: "github-copilot", label: "GitHub Copilot" },
{ value: "cursor", label: "Cursor" }
],
initialValue: "github-copilot"
});
if (typeof aiApp === "symbol") {
throw new Error("Operation cancelled by user");
}
debug2("Selected AI App:", aiApp);
const topicChoices = await (0, import_prompts.multiselect)({
message: "Which topic do you want to generate agentic rules for?",
options: [
{ value: "secure-code", label: "Secure Coding", hint: "Apply security best practices for defensive coding in Node.js" },
{ value: "security-vulnerabilities", label: "Security Vulnerabilities", hint: "Scan and fix security vulnerabilities in Node.js application code and 3rd-party dependencies" },
{ value: "testing", label: "Testing", hint: "Establish mature testing strategy and test code guidelines in Node.js applications" }
],
required: true
});
if (typeof topicChoices === "symbol") {
throw new Error("Operation cancelled by user");
}
debug2("Selected code topic: ", topicChoices.join(", "));
for (const codeTopic of topicChoices) {
const templateChoices = {
aiApp,
codeLanguage,
codeTopic
};
await scaffoldAiAppInstructions(templateChoices);
}
(0, import_prompts.outro)("Aye Captain, godspeed with yar vibe coding \u{1FAE1}");
}
__name(init, "init");
async function main() {
try {
await init();
} catch (error) {
debug2("Full error details:", error);
console.error("\nerror: %s", error.message || error);
console.error("\n\n\u{1F635} Shiver me timbers!\n");
process.exit(1);
}
}
__name(main, "main");
main();