compose-agentsmd 1.0.0 → 1.0.1

package/dist/compose-agents.js

@@ -1,11 +1,6 @@
 #!/usr/bin/env node
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const node_fs_1 = __importDefault(require("node:fs"));
-const node_path_1 = __importDefault(require("node:path"));
+import fs from "node:fs";
+import path from "node:path";
 const DEFAULT_RULESET_NAME = "agent-ruleset.json";
 const DEFAULT_RULES_ROOT = "agent-rules/rules";
 const DEFAULT_GLOBAL_DIR = "global";
@@ -87,27 +82,27 @@ const normalizeTrailingWhitespace = (content) => content.replace(/\s+$/u, "");
 const normalizePath = (filePath) => filePath.replace(/\\/g, "/");
 const isNonEmptyString = (value) => typeof value === "string" && value.trim() !== "";
 const resolveFrom = (baseDir, targetPath) => {
-    if (node_path_1.default.isAbsolute(targetPath)) {
+    if (path.isAbsolute(targetPath)) {
         return targetPath;
     }
-    return node_path_1.default.resolve(baseDir, targetPath);
+    return path.resolve(baseDir, targetPath);
 };
 const ensureFileExists = (filePath) => {
-    if (!node_fs_1.default.existsSync(filePath)) {
+    if (!fs.existsSync(filePath)) {
         throw new Error(`Missing file: ${filePath}`);
     }
 };
 const ensureDirectoryExists = (dirPath) => {
-    if (!node_fs_1.default.existsSync(dirPath)) {
+    if (!fs.existsSync(dirPath)) {
         throw new Error(`Missing directory: ${dirPath}`);
     }
-    const stat = node_fs_1.default.statSync(dirPath);
+    const stat = fs.statSync(dirPath);
     if (!stat.isDirectory()) {
         throw new Error(`Not a directory: ${dirPath}`);
     }
 };
 const readJsonFile = (filePath) => {
-    const raw = node_fs_1.default.readFileSync(filePath, "utf8");
+    const raw = fs.readFileSync(filePath, "utf8");
     return JSON.parse(raw);
 };
 const readProjectRuleset = (rulesetPath) => {
@@ -151,19 +146,19 @@ const resolveRulesRoot = (rulesetDir, projectRuleset, options) => {
     if (isNonEmptyString(projectRuleset.rulesRoot)) {
         return resolveFrom(rulesetDir, projectRuleset.rulesRoot);
     }
-    return node_path_1.default.resolve(rulesetDir, DEFAULT_RULES_ROOT);
+    return path.resolve(rulesetDir, DEFAULT_RULES_ROOT);
 };
 const resolveGlobalRoot = (rulesRoot, projectRuleset) => {
     const globalDirName = isNonEmptyString(projectRuleset.globalDir)
         ? projectRuleset.globalDir
         : DEFAULT_GLOBAL_DIR;
-    return node_path_1.default.resolve(rulesRoot, globalDirName);
+    return path.resolve(rulesRoot, globalDirName);
 };
 const resolveDomainsRoot = (rulesRoot, projectRuleset) => {
     const domainsDirName = isNonEmptyString(projectRuleset.domainsDir)
         ? projectRuleset.domainsDir
         : DEFAULT_DOMAINS_DIR;
-    return node_path_1.default.resolve(rulesRoot, domainsDirName);
+    return path.resolve(rulesRoot, domainsDirName);
 };
 const collectMarkdownFiles = (rootDir) => {
     ensureDirectoryExists(rootDir);
@@ -174,27 +169,27 @@ const collectMarkdownFiles = (rootDir) => {
         if (!currentDir) {
             continue;
         }
-        const entries = node_fs_1.default.readdirSync(currentDir, { withFileTypes: true });
+        const entries = fs.readdirSync(currentDir, { withFileTypes: true });
         for (const entry of entries) {
-            const entryPath = node_path_1.default.join(currentDir, entry.name);
+            const entryPath = path.join(currentDir, entry.name);
             if (entry.isDirectory()) {
                 pending.push(entryPath);
                 continue;
             }
-            if (entry.isFile() && node_path_1.default.extname(entry.name).toLowerCase() === ".md") {
+            if (entry.isFile() && path.extname(entry.name).toLowerCase() === ".md") {
                 results.push(entryPath);
             }
         }
     }
     return results.sort((a, b) => {
-        const relA = normalizePath(node_path_1.default.relative(rootDir, a));
-        const relB = normalizePath(node_path_1.default.relative(rootDir, b));
+        const relA = normalizePath(path.relative(rootDir, a));
+        const relB = normalizePath(path.relative(rootDir, b));
         return relA.localeCompare(relB);
     });
 };
 const addRulePaths = (rulePaths, resolvedRules, seenRules) => {
     for (const rulePath of rulePaths) {
-        const resolvedRulePath = node_path_1.default.resolve(rulePath);
+        const resolvedRulePath = path.resolve(rulePath);
         if (seenRules.has(resolvedRulePath)) {
             continue;
         }
@@ -204,7 +199,7 @@ const addRulePaths = (rulePaths, resolvedRules, seenRules) => {
     }
 };
 const composeRuleset = (rulesetPath, rootDir, options) => {
-    const rulesetDir = node_path_1.default.dirname(rulesetPath);
+    const rulesetDir = path.dirname(rulesetPath);
     const projectRuleset = readProjectRuleset(rulesetPath);
     const outputFileName = projectRuleset.output ?? DEFAULT_OUTPUT;
     const outputPath = resolveFrom(rulesetDir, outputFileName);
@@ -219,18 +214,18 @@ const composeRuleset = (rulesetPath, rootDir, options) => {
     addRulePaths(collectMarkdownFiles(globalRoot), resolvedRules, seenRules);
     const domains = Array.isArray(projectRuleset.domains) ? projectRuleset.domains : [];
     for (const domain of domains) {
-        const domainRoot = node_path_1.default.resolve(domainsRoot, domain);
+        const domainRoot = path.resolve(domainsRoot, domain);
         addRulePaths(collectMarkdownFiles(domainRoot), resolvedRules, seenRules);
     }
     const directRules = Array.isArray(projectRuleset.rules) ? projectRuleset.rules : [];
     const directRulePaths = directRules.map((rulePath) => resolveFrom(rulesetDir, rulePath));
     addRulePaths(directRulePaths, resolvedRules, seenRules);
-    const parts = resolvedRules.map((rulePath) => normalizeTrailingWhitespace(node_fs_1.default.readFileSync(rulePath, "utf8")));
+    const parts = resolvedRules.map((rulePath) => normalizeTrailingWhitespace(fs.readFileSync(rulePath, "utf8")));
     const lintHeader = "<!-- markdownlint-disable MD025 -->";
     const output = `${lintHeader}\n${parts.join("\n\n")}\n`;
-    node_fs_1.default.mkdirSync(node_path_1.default.dirname(outputPath), { recursive: true });
-    node_fs_1.default.writeFileSync(outputPath, output, "utf8");
-    return normalizePath(node_path_1.default.relative(rootDir, outputPath));
+    fs.mkdirSync(path.dirname(outputPath), { recursive: true });
+    fs.writeFileSync(outputPath, output, "utf8");
+    return normalizePath(path.relative(rootDir, outputPath));
 };
 const findRulesetFiles = (rootDir, rulesetName) => {
     const results = [];
@@ -240,9 +235,9 @@ const findRulesetFiles = (rootDir, rulesetName) => {
         if (!currentDir) {
             continue;
         }
-        const entries = node_fs_1.default.readdirSync(currentDir, { withFileTypes: true });
+        const entries = fs.readdirSync(currentDir, { withFileTypes: true });
         for (const entry of entries) {
-            const entryPath = node_path_1.default.join(currentDir, entry.name);
+            const entryPath = path.join(currentDir, entry.name);
             if (entry.isDirectory()) {
                 if (DEFAULT_IGNORE_DIRS.has(entry.name)) {
                     continue;
@@ -271,7 +266,7 @@ const main = () => {
         process.stdout.write(`${usage}\n`);
         return;
     }
-    const rootDir = args.root ? node_path_1.default.resolve(args.root) : process.cwd();
+    const rootDir = args.root ? path.resolve(args.root) : process.cwd();
     const rulesetName = args.rulesetName || DEFAULT_RULESET_NAME;
     const rulesetFiles = getRulesetFiles(rootDir, args.ruleset, rulesetName);
     if (rulesetFiles.length === 0) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "compose-agentsmd",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "CLI tools for composing per-project AGENTS.md files from modular rule sets",
   "license": "MIT",
   "repository": {
@@ -18,17 +18,23 @@
     "cli",
     "markdown"
   ],
-  "type": "commonjs",
+  "type": "module",
   "bin": {
     "compose-agentsmd": "dist/compose-agents.js"
   },
   "files": [
     "dist",
-    "tools"
+    "tools",
+    "README.md",
+    "LICENSE"
   ],
+  "publishConfig": {
+    "access": "public"
+  },
   "scripts": {
     "build": "tsc -p tsconfig.json",
     "lint": "tsc -p tsconfig.json --noEmit",
+    "prepare": "npm run build",
     "prepack": "npm run build",
     "test": "npm run build && node --test",
     "compose": "npm run build && node dist/compose-agents.js"

package/tools/compose-agents.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import "../dist/compose-agents.js";

package/tools/compose-agents.cjs

@@ -1,2 +0,0 @@
-#!/usr/bin/env node
-require("../dist/compose-agents.js");