chainlesschain 0.162.71 → 0.162.73

package/src/lib/permission-rules.cjs

@@ -13,6 +13,11 @@
  *   Read(./src/**)        → read_file/list_dir on a path under <cwd>/src
  *   Edit(//etc/**)        → edit_file on an absolute path under /etc
  *   WebFetch(domain:example.com) → web_fetch of https://example.com/…
+ *   Bash(command:rm*)     → run_shell whose `command` arg matches `rm*` (CC
+ *                           2.1.178 `Tool(param:value)` — matches any named
+ *                           input parameter, incl. arbitrary MCP tool args;
+ *                           `*` crosses `/` here, unlike path globs)
+ *   mcp__db__query(table:users) → that MCP tool whose `table` arg is "users"
  *   Bash                  → every run_shell call
  *   *                     → every tool call (Claude-Code deny-all idiom)
  *   Bash(*)               → every run_shell call (lone-`*` pattern = match-all)
@@ -197,6 +202,30 @@ function matchUrl(pattern, url) {
   return globToRegExp(pattern).test(u);
 }
 
+/** Match a single named-parameter value — `Tool(param:value)`. `prefix:*` →
+ *  starts-with; otherwise glob/exact. Unlike path globs, `*` here crosses `/`
+ *  because param values are arbitrary strings (commands often embed paths),
+ *  not filesystem path segments. */
+function matchParamValue(pattern, value) {
+  const v = value == null ? "" : String(value);
+  if (pattern === "*" || pattern === "**") return true;
+  if (pattern.endsWith(":*")) {
+    const prefix = pattern.slice(0, -2).trim();
+    return v === prefix || v.startsWith(prefix);
+  }
+  if (pattern.includes("*") || pattern.includes("?")) {
+    const re =
+      "^" +
+      pattern
+        .replace(/[.+^${}()|[\]\\]/g, "\\$&")
+        .replace(/\*/g, ".*")
+        .replace(/\?/g, ".") +
+      "$";
+    return new RegExp(re).test(v);
+  }
+  return v === pattern;
+}
+
 /**
  * Does `pattern` (the inside of `Tool(...)`, or null for a bare rule) match the
  * given tool call? `null` pattern always matches.
@@ -208,6 +237,15 @@ function matchPattern(pattern, actualTool, args, cwd) {
   // command/url/path containing `/` can't slip past a deny-all (globToRegExp's
   // `*` → `[^/]*` otherwise excludes slashes).
   if (pattern === "*" || pattern === "**") return true;
+  // Claude-Code 2.1.178: `Tool(param:value)` matches a NAMED input parameter,
+  // generalizing the positional command/path/url targets below. Treated as a
+  // param rule only when `param` is a bare identifier AND an actual key in the
+  // tool's args — so command idioms (`git push:*`) and `domain:host` (whose
+  // prefix is not an arg key) correctly fall through to the matching below.
+  const pv = pattern.match(/^([A-Za-z_]\w*):([\s\S]*)$/);
+  if (pv && Object.prototype.hasOwnProperty.call(args || {}, pv[1])) {
+    return matchParamValue(pv[2].trim(), (args || {})[pv[1]]);
+  }
   const target = extractTarget(actualTool, args, cwd);
   if (target.kind === "command") {
     return target.value ? matchCommand(pattern, target.value) : false;
@@ -328,6 +366,7 @@ module.exports = {
   extractTarget,
   matchCommand,
   matchUrl,
+  matchParamValue,
   matchPattern,
   evaluatePermissionRules,
   suggestAllowRule,

package/src/lib/project-root.cjs

@@ -0,0 +1,87 @@
+/**
+ * project-root — locate the nearest ancestor project root by walking up from a
+ * starting directory until a `.git` marker is found.
+ *
+ * Shared by the `.claude` / `.chainlesschain` discovery layers (settings.json
+ * permission rules, output-styles, slash-commands, sub-agents) so that running
+ * `cc` from a project SUBDIRECTORY still picks up the project-root config —
+ * Claude-Code 2.1.178 "closest `.claude` directory wins" parity. This mirrors
+ * the git-root resolution already used by skill-loader + project-instructions,
+ * which previously left these four layers as the only cwd-only stragglers (so a
+ * subdir run silently dropped the project's permission rules — a safety gap).
+ *
+ * A single `.cjs` module so the CJS `settings-loader` can `require` it and the
+ * ESM loaders can `import` it — one source of truth for the walk.
+ *
+ * DEFENSIVE BY DESIGN: callers thread their own (often mocked) `fs` / `path`
+ * through `deps`. If `.git` is not found via that `fs`, or the injected `path`
+ * lacks `dirname` / `resolve`, the walk bails to `null` and the caller keeps its
+ * existing cwd-only behavior unchanged — keeping the heavily-mocked unit tests
+ * green while real runs (real `node:path`) walk up correctly.
+ */
+
+const fsDefault = require("node:fs");
+const pathDefault = require("node:path");
+
+const _deps = { fs: fsDefault, path: pathDefault };
+
+/**
+ * Walk up from `cwd` to the nearest directory containing `.git`. Returns the
+ * resolved root path, or `null` when none is found (or deps are unusable).
+ * @param {string} cwd
+ * @param {{ fs?: object, path?: object }} [deps]
+ */
+function findGitProjectRoot(cwd, deps = {}) {
+  const fs = deps.fs || _deps.fs;
+  const path = deps.path || _deps.path;
+  if (!fs || typeof fs.existsSync !== "function") return null;
+  if (!path || typeof path.dirname !== "function" || typeof path.join !== "function") {
+    return null;
+  }
+  let dir;
+  try {
+    dir = typeof path.resolve === "function" ? path.resolve(cwd || ".") : String(cwd || ".");
+  } catch {
+    return null;
+  }
+  // Bounded walk (64 levels) so a malformed `dirname` can never spin forever.
+  for (let i = 0; i < 64 && dir; i++) {
+    try {
+      if (fs.existsSync(path.join(dir, ".git"))) return dir;
+    } catch {
+      /* unreadable dir → keep walking up */
+    }
+    let parent;
+    try {
+      parent = path.dirname(dir);
+    } catch {
+      return null;
+    }
+    if (!parent || parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}
+
+/**
+ * The extra project-root base directory to ADD to a cwd-based discovery list
+ * when running from a subdirectory. Returns the git root when it exists AND is a
+ * strict ancestor of `cwd`; returns `null` when `cwd` is itself the root (its
+ * own dirs already cover it) or no root is found.
+ * @param {string} cwd
+ * @param {{ fs?: object, path?: object }} [deps]
+ */
+function projectRootBase(cwd, deps = {}) {
+  const root = findGitProjectRoot(cwd, deps);
+  if (!root) return null;
+  const path = deps.path || _deps.path;
+  let resolvedCwd = cwd;
+  try {
+    if (path && typeof path.resolve === "function") resolvedCwd = path.resolve(cwd || ".");
+  } catch {
+    /* fall through with raw cwd */
+  }
+  return root === resolvedCwd ? null : root;
+}
+
+module.exports = { findGitProjectRoot, projectRootBase, _deps };

package/src/lib/settings-hooks.cjs

@@ -28,6 +28,7 @@ const path = require("node:path");
 const os = require("node:os");
 const fsDefault = require("node:fs");
 const { SUGGEST_UMBRELLA } = require("./permission-rules.cjs");
+const { projectRootBase } = require("./project-root.cjs");
 
 const _deps = { fs: fsDefault, homedir: () => os.homedir() };
 
@@ -44,14 +45,25 @@ const HOOK_EVENTS = Object.freeze([
   "Notification",
 ]);
 
-/** Same hierarchy as settings-loader (user < project < .local < --settings). */
+/**
+ * Same hierarchy as settings-loader (user < project-root < cwd < --settings).
+ * When run from a SUBDIRECTORY, the project-root `.claude` hooks apply (below
+ * cwd's, above the user layer) — same walk-up as settings-loader's settingsPaths
+ * (shared `projectRootBase`, threaded through this loader's own `_deps.fs` to
+ * keep test injection intact). Hooks RUN SHELL COMMANDS, so a guard hook in the
+ * project-root settings must NOT silently vanish when `cc` is invoked from a
+ * subdirectory. `projectRootBase` returns null when cwd IS the root.
+ */
 function settingsFiles(cwd, explicitFile) {
   const home = _deps.homedir();
-  const list = [
-    path.join(home, ".claude", "settings.json"),
-    path.join(cwd, ".claude", "settings.json"),
-    path.join(cwd, ".claude", "settings.local.json"),
-  ];
+  const list = [path.join(home, ".claude", "settings.json")];
+  const root = projectRootBase(cwd, { fs: _deps.fs, path });
+  if (root) {
+    list.push(path.join(root, ".claude", "settings.json"));
+    list.push(path.join(root, ".claude", "settings.local.json"));
+  }
+  list.push(path.join(cwd, ".claude", "settings.json"));
+  list.push(path.join(cwd, ".claude", "settings.local.json"));
   if (explicitFile) list.push(path.resolve(cwd, explicitFile));
   return list;
 }

package/src/lib/settings-loader.cjs

@@ -27,6 +27,7 @@
 const fsDefault = require("node:fs");
 const path = require("node:path");
 const os = require("node:os");
+const { projectRootBase } = require("./project-root.cjs");
 
 const _deps = { fs: fsDefault, homedir: () => os.homedir() };
 
@@ -72,11 +73,17 @@ function accrete(target, sources, arr, file, kind) {
 /** The ordered list of candidate settings files for a cwd. */
 function settingsPaths(cwd, explicitFile) {
   const home = _deps.homedir();
-  const list = [
-    path.join(home, ".claude", "settings.json"),
-    path.join(cwd, ".claude", "settings.json"),
-    path.join(cwd, ".claude", "settings.local.json"),
-  ];
+  const list = [path.join(home, ".claude", "settings.json")];
+  // When run from a subdirectory, the project-root `.claude` sits BELOW cwd's
+  // own (closest wins) but ABOVE the user layer — so its rules apply yet a
+  // cwd-local settings file still overrides them. Null when cwd IS the root.
+  const root = projectRootBase(cwd, { fs: _deps.fs, path });
+  if (root) {
+    list.push(path.join(root, ".claude", "settings.json"));
+    list.push(path.join(root, ".claude", "settings.local.json"));
+  }
+  list.push(path.join(cwd, ".claude", "settings.json"));
+  list.push(path.join(cwd, ".claude", "settings.local.json"));
   if (explicitFile) list.push(path.resolve(cwd, explicitFile));
   return list;
 }

package/src/lib/skill-loader.js

@@ -78,6 +78,10 @@ export const LAYER_NAMES = [
   "workspace",
 ];
 
+/** Max directory depth to descend when scanning a skill layer for nested
+ *  `<group>/<skill>/SKILL.md` layouts (infinite-recursion / deep-tree guard). */
+export const MAX_SKILL_NEST_DEPTH = 5;
+
 /**
  * Simple YAML frontmatter parser (no dependencies)
  * Shared utility extracted from skill.js
@@ -348,54 +352,69 @@ export class CLISkillLoader {
    */
   _loadFromDir(dir, layer) {
     const skills = [];
-    if (!dir || !fs.existsSync(dir)) return skills;
+    this._collectSkills(dir, layer, skills, 0);
+    return skills;
+  }
 
+  /**
+   * Recursively collect skills under `dir`. A directory containing a SKILL.md
+   * is a skill (a leaf — we do NOT descend into its asset/script subdirs); a
+   * directory WITHOUT one is treated as a grouping/category folder and is
+   * descended into, so nested layouts like `.claude/skills/<group>/<skill>/`
+   * load too (Claude-Code 2.1.178 nested-skills parity). Depth-capped.
+   */
+  _collectSkills(dir, layer, out, depth) {
+    if (!dir || !fs.existsSync(dir)) return;
+    let entries;
     try {
-      const dirs = fs.readdirSync(dir, { withFileTypes: true });
-      for (const entry of dirs) {
-        if (!entry.isDirectory()) continue;
-
-        const skillMd = path.join(dir, entry.name, "SKILL.md");
-        if (!fs.existsSync(skillMd)) continue;
-
-        try {
-          const content = fs.readFileSync(skillMd, "utf-8");
-          const { data, body } = parseSkillMd(content);
-
-          skills.push({
-            id: data.name || entry.name,
-            displayName: data.displayName || entry.name,
-            description: data.description || "",
-            version: data.version || "1.0.0",
-            category: data.category || "uncategorized",
-            activation: data.activation || "manual",
-            tags: data.tags || [],
-            userInvocable: data.userInvocable !== false,
-            handler: data.handler || null,
-            capabilities: data.capabilities || [],
-            os: data.os || [],
-            // CLI pack extended fields
-            executionMode: data.executionMode || null,
-            cliDomain: data.cliDomain || null,
-            cliVersionHash: data.cliVersionHash || null,
-            dirName: entry.name,
-            hasHandler: fs.existsSync(path.join(dir, entry.name, "handler.js")),
-            body,
-            // Skill-Embedded MCP: inline server declarations in a
-            // ```mcp-servers fenced code block. Empty array if absent.
-            mcpServers: parseSkillMcpServers(body),
-            source: layer,
-            skillDir: path.join(dir, entry.name),
-          });
-        } catch {
-          // Skip malformed skill files
+      entries = fs.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return; // Directory unreadable
+    }
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      const skillDir = path.join(dir, entry.name);
+      const skillMd = path.join(skillDir, "SKILL.md");
+      if (!fs.existsSync(skillMd)) {
+        // Grouping folder → descend (bounded) to find nested skills.
+        if (depth < MAX_SKILL_NEST_DEPTH) {
+          this._collectSkills(skillDir, layer, out, depth + 1);
         }
+        continue;
+      }
+      try {
+        const content = fs.readFileSync(skillMd, "utf-8");
+        const { data, body } = parseSkillMd(content);
+
+        out.push({
+          id: data.name || entry.name,
+          displayName: data.displayName || entry.name,
+          description: data.description || "",
+          version: data.version || "1.0.0",
+          category: data.category || "uncategorized",
+          activation: data.activation || "manual",
+          tags: data.tags || [],
+          userInvocable: data.userInvocable !== false,
+          handler: data.handler || null,
+          capabilities: data.capabilities || [],
+          os: data.os || [],
+          // CLI pack extended fields
+          executionMode: data.executionMode || null,
+          cliDomain: data.cliDomain || null,
+          cliVersionHash: data.cliVersionHash || null,
+          dirName: entry.name,
+          hasHandler: fs.existsSync(path.join(skillDir, "handler.js")),
+          body,
+          // Skill-Embedded MCP: inline server declarations in a
+          // ```mcp-servers fenced code block. Empty array if absent.
+          mcpServers: parseSkillMcpServers(body),
+          source: layer,
+          skillDir,
+        });
+      } catch {
+        // Skip malformed skill files
       }
-    } catch {
-      // Directory unreadable
     }
-
-    return skills;
   }
 
   /**

package/src/lib/slash-commands.js

@@ -23,6 +23,7 @@ import pathDefault from "node:path";
 import { homedir } from "node:os";
 import { execSync as execSyncDefault } from "node:child_process";
 import { expandFileRefs } from "../runtime/file-ref-expander.js";
+import { projectRootBase } from "./project-root.cjs";
 
 const _deps = { fs: fsDefault, path: pathDefault, execSync: execSyncDefault };
 
@@ -62,16 +63,31 @@ export const BANG_TIMEOUT_MS = 10_000;
  * on a name clash). `opts.home` overrides the personal root for tests.
  */
 export function commandDirs(cwd = process.cwd(), opts = {}) {
+  const fs = opts.deps?.fs || _deps.fs;
   const path = opts.deps?.path || _deps.path;
   const home = opts.home || homedir();
   // Project-native `.chainlesschain/commands/` takes precedence, then the
   // Claude-Code-portable `.claude/commands/` (so existing definitions work
   // unchanged), then personal. Both project dirs share the "project" scope.
-  return [
+  const dirs = [
     { dir: path.join(cwd, ".chainlesschain", "commands"), scope: "project" },
     { dir: path.join(cwd, ".claude", "commands"), scope: "project" },
-    { dir: path.join(home, ".claude", "commands"), scope: "personal" },
   ];
+  // Subdirectory run: also scan the project-root `.claude` (cwd stays closest
+  // and wins on a name clash via discoverCommands' reverse + last-write-wins).
+  const root = projectRootBase(cwd, { fs, path });
+  if (root) {
+    dirs.push({
+      dir: path.join(root, ".chainlesschain", "commands"),
+      scope: "project",
+    });
+    dirs.push({
+      dir: path.join(root, ".claude", "commands"),
+      scope: "project",
+    });
+  }
+  dirs.push({ dir: path.join(home, ".claude", "commands"), scope: "personal" });
+  return dirs;
 }
 
 /** Recursively collect `*.md` files under `dir` as `{file, rel}` (rel uses /). */