compose-agentsmd 2.0.2 → 3.1.0

package/README.md

@@ -30,7 +30,7 @@ From each project root, run:
 compose-agentsmd
 ```
 
-The tool searches for `agent-ruleset.json` under the given root directory (default: current working directory), and writes output files as specified by each ruleset. If `output` is omitted, it defaults to `AGENTS.md`.
+The tool reads `agent-ruleset.json` from the given root directory (default: current working directory), and writes the output file specified by the ruleset. If `output` is omitted, it defaults to `AGENTS.md`.
 
 The tool prepends a small "Tool Rules" block to every generated `AGENTS.md` so agents know how to regenerate or update rules.
 
@@ -85,6 +85,8 @@ Remote sources are cached under `~/.agentsmd/cache/<owner>/<repo>/<ref>/`. Use `
 - `--ruleset-name <name>`: override the ruleset filename (default: `agent-ruleset.json`)
 - `--refresh`: refresh cached remote rules
 - `--clear-cache`: remove cached remote rules and exit
+- `--version` / `-V`: show version and exit
+- `--verbose` / `-v`: show verbose diagnostics
 - `edit-rules`: prepare or locate a writable rules workspace
 - `apply-rules`: push workspace changes (if GitHub source) and regenerate rules with refresh
 

package/dist/compose-agents.js

@@ -9,21 +9,7 @@ const DEFAULT_OUTPUT = "AGENTS.md";
 const DEFAULT_CACHE_ROOT = path.join(os.homedir(), ".agentsmd", "cache");
 const DEFAULT_WORKSPACE_ROOT = path.join(os.homedir(), ".agentsmd", "workspace");
 const RULESET_SCHEMA_PATH = new URL("../agent-ruleset.schema.json", import.meta.url);
-const DEFAULT_IGNORE_DIRS = new Set([
-    ".git",
-    "agent-rules",
-    "agent-rules-private",
-    "agent-rules-local",
-    "agent-rules-tools",
-    "compose-agentsmd",
-    "node_modules",
-    "dist",
-    "build",
-    "out",
-    ".next",
-    ".turbo",
-    "coverage"
-]);
+const PACKAGE_JSON_PATH = new URL("../package.json", import.meta.url);
 const TOOL_RULES_PATH = new URL("../tools/tool-rules.md", import.meta.url);
 const USAGE_PATH = new URL("../tools/usage.txt", import.meta.url);
 const parseArgs = (argv) => {
@@ -39,6 +25,14 @@ const parseArgs = (argv) => {
             args.help = true;
             continue;
         }
+        if (arg === "--version" || arg === "-V") {
+            args.version = true;
+            continue;
+        }
+        if (arg === "--verbose" || arg === "-v") {
+            args.verbose = true;
+            continue;
+        }
         if (arg === "--root") {
             const value = remaining[i + 1];
             if (!value) {
@@ -82,6 +76,8 @@ const normalizeTrailingWhitespace = (content) => content.replace(/\s+$/u, "");
 const normalizePath = (filePath) => filePath.replace(/\\/g, "/");
 const isNonEmptyString = (value) => typeof value === "string" && value.trim() !== "";
 const usage = normalizeTrailingWhitespace(fs.readFileSync(USAGE_PATH, "utf8"));
+const packageJson = JSON.parse(fs.readFileSync(PACKAGE_JSON_PATH, "utf8"));
+const getVersion = () => packageJson.version ?? "unknown";
 const rulesetSchema = JSON.parse(fs.readFileSync(RULESET_SCHEMA_PATH, "utf8"));
 const TOOL_RULES = normalizeTrailingWhitespace(fs.readFileSync(TOOL_RULES_PATH, "utf8"));
 const ajv = new Ajv({ allErrors: true, strict: false });
@@ -394,51 +390,31 @@ const composeRuleset = (rulesetPath, rootDir, options) => {
     fs.writeFileSync(outputPath, output, "utf8");
     return normalizePath(path.relative(rootDir, outputPath));
 };
-const findRulesetFiles = (rootDir, rulesetName) => {
-    const results = [];
-    const pending = [rootDir];
-    while (pending.length > 0) {
-        const currentDir = pending.pop();
-        if (!currentDir) {
-            continue;
-        }
-        const entries = fs.readdirSync(currentDir, { withFileTypes: true });
-        for (const entry of entries) {
-            const entryPath = path.join(currentDir, entry.name);
-            if (entry.isDirectory()) {
-                if (DEFAULT_IGNORE_DIRS.has(entry.name)) {
-                    continue;
-                }
-                pending.push(entryPath);
-                continue;
-            }
-            if (entry.isFile() && entry.name === rulesetName) {
-                results.push(entryPath);
-            }
-        }
-    }
-    return results;
-};
 const getRulesetFiles = (rootDir, specificRuleset, rulesetName) => {
     if (specificRuleset) {
         const resolved = resolveFrom(rootDir, specificRuleset);
         ensureFileExists(resolved);
         return [resolved];
     }
-    return findRulesetFiles(rootDir, rulesetName);
+    const defaultRuleset = path.join(rootDir, rulesetName);
+    if (!fs.existsSync(defaultRuleset)) {
+        return [];
+    }
+    return [defaultRuleset];
 };
 const ensureSingleRuleset = (rulesetFiles, rootDir, rulesetName) => {
     if (rulesetFiles.length === 0) {
-        throw new Error(`No ruleset files named ${rulesetName} found under ${rootDir}`);
-    }
-    if (rulesetFiles.length > 1) {
-        const list = rulesetFiles.map((file) => `- ${normalizePath(path.relative(rootDir, file))}`).join("\n");
-        throw new Error(`Multiple ruleset files found. Specify one with --ruleset:\n${list}`);
+        const expectedPath = normalizePath(path.join(rootDir, rulesetName));
+        throw new Error(`Missing ruleset file: ${expectedPath}`);
     }
     return rulesetFiles[0];
 };
 const main = () => {
     const args = parseArgs(process.argv.slice(2));
+    if (args.version) {
+        process.stdout.write(`${getVersion()}\n`);
+        return;
+    }
     if (args.help) {
         process.stdout.write(`${usage}\n`);
         return;
@@ -452,6 +428,15 @@ const main = () => {
     const rulesetName = args.rulesetName || DEFAULT_RULESET_NAME;
     const rulesetFiles = getRulesetFiles(rootDir, args.ruleset, rulesetName);
     const command = args.command ?? "compose";
+    const logVerbose = (message) => {
+        if (args.verbose) {
+            process.stdout.write(`${message}\n`);
+        }
+    };
+    logVerbose("Verbose:");
+    logVerbose(`- Root: ${rootDir}`);
+    logVerbose(`- Ruleset name: ${rulesetName}`);
+    logVerbose(`- Ruleset files:\n${rulesetFiles.map((file) => `  - ${normalizePath(path.relative(rootDir, file))}`).join("\n")}`);
     if (command === "edit-rules") {
         const rulesetPath = ensureSingleRuleset(rulesetFiles, rootDir, rulesetName);
         const rulesetDir = path.dirname(rulesetPath);
@@ -473,7 +458,8 @@ const main = () => {
         return;
     }
     if (rulesetFiles.length === 0) {
-        throw new Error(`No ruleset files named ${rulesetName} found under ${rootDir}`);
+        const expectedPath = normalizePath(path.join(rootDir, rulesetName));
+        throw new Error(`Missing ruleset file: ${expectedPath}`);
     }
     const outputs = rulesetFiles
         .sort()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "compose-agentsmd",
-  "version": "2.0.2",
+  "version": "3.1.0",
   "description": "CLI tools for composing per-project AGENTS.md files from modular rule sets",
   "license": "MIT",
   "repository": {

package/tools/tool-rules.md

@@ -1,4 +1,5 @@
 # Tool Rules (compose-agentsmd)
 - Before starting any work, run `compose-agentsmd` from the project root.
 - To update shared rules, run `compose-agentsmd edit-rules`, edit the workspace rules, then run `compose-agentsmd apply-rules`.
-- Do not edit `AGENTS.md` directly; update the source rules and regenerate.
+- Do not edit `AGENTS.md` directly; update the source rules and regenerate.
+- When updating rules, include a detailed summary of what changed (added/removed/modified items) in the final response.

package/tools/usage.txt

@@ -1,8 +1,11 @@
-Usage: compose-agentsmd [edit-rules|apply-rules] [--root <path>] [--ruleset <path>] [--ruleset-name <name>] [--refresh] [--clear-cache]
+Usage: compose-agentsmd [edit-rules|apply-rules] [--root <path>] [--ruleset <path>] [--ruleset-name <name>] [--refresh] [--clear-cache] [--version|-V] [--verbose|-v] [--help|-h]
 
 Options:
+  --help, -h           Show help and exit
+  --version, -V        Show version and exit
+  --verbose, -v        Show verbose diagnostics
   --root <path>         Project root directory (default: current working directory)
   --ruleset <path>      Only compose a single ruleset file
-  --ruleset-name <name> Ruleset filename to search for (default: agent-ruleset.json)
+  --ruleset-name <name> Ruleset filename in the project root (default: agent-ruleset.json)
   --refresh             Refresh cached remote rules
-  --clear-cache         Remove cached remote rules and exit
+  --clear-cache         Remove cached remote rules and exit