@y0shua1ee/dsh-auto-memory 0.3.2 → 0.4.0

package/lib/rule-glob.js

@@ -5,159 +5,184 @@
  * (`[abc]`). Patterns are relative to the rule's base directory and use `/`
  * separators on every platform.
  */
-
 const EXPANSION_BUDGET = 1000;
 const COMPILED_CACHE = new Map();
 const COMPILED_CACHE_LIMIT = 2000;
-
+const NEVER = /^(?!)$/u;
 function findBrace(pattern, from) {
-  let depth = 0;
-  let start = -1;
-  for (let index = from; index < pattern.length; index += 1) {
-    const character = pattern[index];
-    if (character === "\\") {
-      index += 1;
-      continue;
-    }
-    if (character === "{") {
-      if (depth === 0) start = index;
-      depth += 1;
-    } else if (character === "}") {
-      if (depth > 0) {
-        depth -= 1;
-        if (depth === 0 && start !== -1) return { start, end: index };
-      }
+    let depth = 0;
+    let start = -1;
+    for (let index = from; index < pattern.length; index += 1) {
+        const character = pattern[index];
+        if (character === "\\") {
+            index += 1;
+            continue;
+        }
+        if (character === "{") {
+            if (depth === 0)
+                start = index;
+            depth += 1;
+        }
+        else if (character === "}") {
+            if (depth > 0) {
+                depth -= 1;
+                if (depth === 0 && start !== -1)
+                    return { start, end: index };
+            }
+        }
     }
-  }
-  return undefined;
+    return undefined;
 }
-
 function splitAlternatives(inner) {
-  const parts = [];
-  let current = "";
-  let depth = 0;
-  for (const character of inner) {
-    if (character === "{") depth += 1;
-    if (character === "}") depth -= 1;
-    if (character === "," && depth === 0) {
-      parts.push(current);
-      current = "";
-    } else {
-      current += character;
+    const parts = [];
+    let current = "";
+    let depth = 0;
+    for (const character of inner) {
+        if (character === "{")
+            depth += 1;
+        if (character === "}")
+            depth -= 1;
+        if (character === "," && depth === 0) {
+            parts.push(current);
+            current = "";
+        }
+        else {
+            current += character;
+        }
     }
-  }
-  parts.push(current);
-  return parts;
+    parts.push(current);
+    return parts;
 }
-
 function expandInto(pattern, from, output) {
-  if (output.length >= EXPANSION_BUDGET) return;
-  const brace = findBrace(pattern, from);
-  if (brace === undefined) {
-    output.push(pattern);
-    return;
-  }
-  const alternatives = splitAlternatives(pattern.slice(brace.start + 1, brace.end));
-  if (alternatives.length < 2) {
-    expandInto(pattern, brace.end + 1, output);
-    return;
-  }
-  const prefix = pattern.slice(0, brace.start);
-  const suffix = pattern.slice(brace.end + 1);
-  for (const alternative of alternatives) {
-    if (output.length >= EXPANSION_BUDGET) break;
-    expandInto(`${prefix}${alternative}${suffix}`, brace.start, output);
-  }
+    if (output.length >= EXPANSION_BUDGET)
+        return;
+    const brace = findBrace(pattern, from);
+    if (brace === undefined) {
+        output.push(pattern);
+        return;
+    }
+    const alternatives = splitAlternatives(pattern.slice(brace.start + 1, brace.end));
+    if (alternatives.length < 2) {
+        expandInto(pattern, brace.end + 1, output);
+        return;
+    }
+    const prefix = pattern.slice(0, brace.start);
+    const suffix = pattern.slice(brace.end + 1);
+    for (const alternative of alternatives) {
+        if (output.length >= EXPANSION_BUDGET)
+            break;
+        expandInto(`${prefix}${alternative}${suffix}`, brace.start, output);
+    }
 }
-
 /**
  * Expand brace alternatives with a hard budget. A pattern over budget is
  * returned unexpanded, so its literal braces match nothing rather than
  * consuming unbounded memory.
- *
- * @param {string} pattern - glob pattern.
- * @returns {string[]} expanded patterns.
  */
 export function expandBraces(pattern) {
-  const output = [];
-  expandInto(pattern, 0, output);
-  return output.length > 0 ? output : [pattern];
+    const output = [];
+    expandInto(pattern, 0, output);
+    return output.length > 0 ? output : [pattern];
 }
-
 function normalizePattern(pattern) {
-  return pattern.replaceAll("\\", "/").replace(/^\.\//u, "").replace(/^\/+/u, "");
+    let value = pattern.replace(/^\.\//u, "");
+    if (value.startsWith("/")) {
+        return { pattern: value.replace(/^\/+/, ""), anchored: true };
+    }
+    return { pattern: value, anchored: value.includes("/") };
+}
+function escapeRegex(character) {
+    return /[.*+?^${}()|[\]\\]/u.test(character) ? `\\${character}` : character;
 }
-
 /**
  * Compile one glob pattern into an anchored regular expression.
- *
- * @param {string} pattern - glob pattern.
- * @returns {RegExp} matcher for `/`-separated relative paths.
  */
 export function compileGlob(pattern) {
-  const cached = COMPILED_CACHE.get(pattern);
-  if (cached !== undefined) return cached;
-  const source = normalizePattern(pattern);
-  let expression = "^";
-  for (let index = 0; index < source.length; index += 1) {
-    const character = source[index];
-    if (character === "*") {
-      let end = index;
-      while (source[end + 1] === "*") end += 1;
-      if (end > index) {
-        if (source[end + 1] === "/") {
-          expression += "(?:.*/)?";
-          index = end + 1;
-        } else {
-          expression += ".*";
-          index = end;
+    const cached = COMPILED_CACHE.get(pattern);
+    if (cached !== undefined)
+        return cached;
+    const normalized = normalizePattern(pattern);
+    const source = normalized.pattern;
+    let expression = normalized.anchored ? "^" : "^(?:.*/)?";
+    for (let index = 0; index < source.length; index += 1) {
+        const character = source[index];
+        if (character === "\\") {
+            const next = source[index + 1];
+            if (next !== undefined) {
+                expression += escapeRegex(next);
+                index += 1;
+            }
+            else {
+                expression += "\\\\";
+            }
+            continue;
         }
-      } else {
-        expression += "[^/]*";
-      }
-      continue;
-    }
-    if (character === "?") {
-      expression += "[^/]";
-      continue;
-    }
-    if (character === "[") {
-      const close = source.indexOf("]", index + 1);
-      if (close === -1) {
-        expression += "\\[";
-        continue;
-      }
-      let characterClass = source.slice(index + 1, close);
-      if (characterClass.startsWith("!")) characterClass = `^${characterClass.slice(1)}`;
-      expression += `[${characterClass}]`;
-      index = close;
-      continue;
-    }
-    if (character === "{" || character === "}") {
-      expression += `\\${character}`;
-      continue;
-    }
-    if ("\\.+^$()|".includes(character)) {
-      expression += `\\${character}`;
-      continue;
+        if (character === "*") {
+            let end = index;
+            while (source[end + 1] === "*")
+                end += 1;
+            if (end > index) {
+                if (source[end + 1] === "/") {
+                    expression += "(?:.*/)?";
+                    index = end + 1;
+                }
+                else {
+                    expression += ".*";
+                    index = end;
+                }
+            }
+            else {
+                expression += "[^/]*";
+            }
+            continue;
+        }
+        if (character === "?") {
+            expression += "[^/]";
+            continue;
+        }
+        if (character === "[") {
+            let close = -1;
+            for (let cursor = index + 1; cursor < source.length; cursor += 1) {
+                if (source[cursor] === "\\") {
+                    cursor += 1;
+                    continue;
+                }
+                if (source[cursor] === "]") {
+                    close = cursor;
+                    break;
+                }
+            }
+            if (close === -1) {
+                return NEVER;
+            }
+            let characterClass = source.slice(index + 1, close);
+            if (characterClass.startsWith("!"))
+                characterClass = `^${characterClass.slice(1)}`;
+            expression += `[${characterClass}]`;
+            index = close;
+            continue;
+        }
+        if (character === "{" || character === "}") {
+            expression += `\\${character}`;
+            continue;
+        }
+        if ("\\.+^$()|".includes(character)) {
+            expression += `\\${character}`;
+            continue;
+        }
+        expression += character;
     }
-    expression += character;
-  }
-  expression += "$";
-  const compiled = new RegExp(expression);
-  if (COMPILED_CACHE.size >= COMPILED_CACHE_LIMIT) COMPILED_CACHE.clear();
-  COMPILED_CACHE.set(pattern, compiled);
-  return compiled;
+    expression += "$";
+    const compiled = new RegExp(expression);
+    if (COMPILED_CACHE.size >= COMPILED_CACHE_LIMIT)
+        COMPILED_CACHE.clear();
+    COMPILED_CACHE.set(pattern, compiled);
+    return compiled;
 }
-
 /**
  * Test one `/`-separated relative path against a glob.
- *
- * @param {string} path - relative path.
- * @param {string} pattern - glob pattern.
- * @returns {boolean} whether the path matches.
  */
 export function matchGlob(path, pattern) {
-  const normalized = path.replaceAll("\\", "/").replace(/^\.\//u, "");
-  return expandBraces(pattern).some((expanded) => compileGlob(expanded).test(normalized));
+    const normalized = path.replaceAll("\\", "/").replace(/^\.\//u, "");
+    return expandBraces(pattern).some((expanded) => compileGlob(expanded).test(normalized));
 }

package/lib/rules-inject.d.ts

@@ -0,0 +1,14 @@
+import type { ProjectFor } from "./inject.js";
+import type { ResolvedConfig } from "./config.js";
+import type { Logger, PreStepHandler, ToolExecEvent, ToolResultEvent } from "./types.js";
+/**
+ * Register rule injection and file-touch tracking.
+ */
+export declare function createRulesFeature({ projectFor, config, logger }: {
+    projectFor: ProjectFor;
+    config: ResolvedConfig;
+    logger?: Logger;
+}): {
+    preStep: PreStepHandler;
+    toolResult: (exec: ToolExecEvent, result: ToolResultEvent) => void;
+};

package/lib/rules-inject.js

@@ -2,129 +2,137 @@ import { createUserMessage } from "@deepseek-ai/dsh-llm";
 import { isAbsolute, relative, resolve } from "node:path";
 import { enterWithMessage, isSubagent } from "./inject.js";
 import { RULE_MESSAGE_KIND, RuleIndex, renderRules } from "./rules.js";
-
 const FILE_TOOLS = new Set(["read", "write", "edit"]);
-
 function toPosix(value) {
-  return value.replaceAll("\\", "/");
+    return value.replaceAll("\\", "/");
 }
-
-function ruleMatches(rule, touched, cwd, projectRoot) {
-  if (rule.matchers.length === 0) return true;
-  const base = rule.scope === "user" ? cwd : projectRoot;
-  for (const raw of touched) {
-    const absolute = isAbsolute(raw) ? resolve(raw) : resolve(cwd, raw);
-    const rel = relative(base, absolute);
-    if (rel.length === 0 || rel.startsWith("..") || isAbsolute(rel)) continue;
-    const posix = toPosix(rel);
-    if (rule.matchers.some((matcher) => matcher.test(posix))) return true;
-  }
-  return false;
+function ruleMatches(rule, touched, cwd, ruleRoot) {
+    if (rule.matchers.length === 0)
+        return true;
+    const base = rule.scope === "user" ? cwd : ruleRoot;
+    for (const raw of touched) {
+        const absolute = isAbsolute(raw) ? resolve(raw) : resolve(cwd, raw);
+        const rel = relative(base, absolute);
+        if (rel.length === 0 || rel.startsWith("..") || isAbsolute(rel))
+            continue;
+        const posix = toPosix(rel);
+        if (rule.matchers.some((matcher) => matcher.test(posix)))
+            return true;
+    }
+    return false;
 }
-
 function visibleRuleDigests(agent, decision) {
-  const visible = new Map();
-  const collect = (message) => {
-    if (message?.source?.kind !== RULE_MESSAGE_KIND) return;
-    const entries = message.source.rules;
-    if (!Array.isArray(entries)) return;
-    for (const entry of entries) {
-      if (typeof entry?.key === "string" && typeof entry.digest === "string") {
-        visible.set(entry.key, entry.digest);
-      }
+    const visible = new Map();
+    const collect = (message) => {
+        if (message?.source?.kind !== RULE_MESSAGE_KIND)
+            return;
+        const entries = message.source.rules;
+        if (!Array.isArray(entries))
+            return;
+        for (const entry of entries) {
+            if (typeof entry !== "object" || entry === null)
+                continue;
+            const candidate = entry;
+            if (typeof candidate.key === "string" && typeof candidate.digest === "string") {
+                visible.set(candidate.key, candidate.digest);
+            }
+        }
+    };
+    for (const message of decision.messages)
+        collect(message);
+    for (const seq of agent.session.surface.nodes) {
+        const event = agent.session.eventAt(seq);
+        if (event?.type === "user/message")
+            collect(event.data);
     }
-  };
-  for (const message of decision.messages) collect(message);
-  for (const seq of agent.session.surface.nodes) {
-    const event = agent.session.eventAt(seq);
-    if (event?.type === "user/message") collect(event.data);
-  }
-  for (const message of agent.inbox.nextStep) collect(message);
-  return visible;
+    for (const message of agent.inbox.nextStep)
+        collect(message);
+    return visible;
 }
-
 function isRulesMessage(message) {
-  return message?.source?.kind === RULE_MESSAGE_KIND;
+    return message?.source?.kind === RULE_MESSAGE_KIND;
 }
-
 /**
  * Register rule injection and file-touch tracking.
- *
- * @param {object} input - feature wiring.
- * @param {(agent: object, signal: AbortSignal) => Promise<object>} input.projectFor - resolve the session project.
- * @param {object} input.config - normalized plugin configuration.
- * @param {object} [input.logger] - host logger.
- * @returns {{preStep: Function, toolResult: Function}} event listeners.
  */
 export function createRulesFeature({ projectFor, config, logger }) {
-  const index = new RuleIndex({
-    userRuleDirs: config.userRuleDirs,
-    projectRuleDirs: config.projectRuleDirs,
-    maxRuleBytes: config.maxRuleBytes,
-    maxRules: config.maxRules,
-    maxRulesBytes: config.maxRulesBytes
-  });
-  const touched = new WeakMap();
-
-  const toolResult = (exec, result) => {
-    if (result?.isError) return;
-    if (!FILE_TOOLS.has(exec?.name)) return;
-    const agent = exec.agent;
-    if (agent === undefined) return;
-    if (!config.injectInSubagents && isSubagent(agent)) return;
-    const raw = exec.arguments?.file_path;
-    if (typeof raw !== "string" || raw.trim().length === 0) return;
-    let paths = touched.get(agent.session);
-    if (paths === undefined) {
-      paths = new Set();
-      touched.set(agent.session, paths);
-    }
-    paths.add(raw.trim());
-  };
-
-  const preStep = async ({ agent, messages, signal }, next) => {
-    const decision = await next();
-    if (decision.kind === "reject") return decision;
-    if (!config.rules) return decision;
-    if (!config.injectInSubagents && isSubagent(agent)) return decision;
-    try {
-      const project = await projectFor(agent, signal);
-      const { rules } = await index.collect({
-        cwd: project.cwd,
-        projectRoot: project.projectRoot
-      });
-      if (rules.length === 0) return decision;
-      const sessionTouches = touched.get(agent.session) ?? new Set();
-      const eligible = rules.filter((rule) =>
-        ruleMatches(rule, sessionTouches, project.cwd, project.projectRoot)
-      );
-      if (eligible.length === 0) return decision;
-      const visible = visibleRuleDigests(agent, decision);
-      const fresh = eligible.filter((rule) => visible.get(rule.key) !== rule.digest);
-      if (fresh.length === 0) return decision;
-      const rendered = renderRules(fresh, config.maxRulesBytes);
-      if (rendered === undefined) return decision;
-      const message = createUserMessage({
-        content: [{ type: "text", text: rendered.text }],
-        source: {
-          kind: RULE_MESSAGE_KIND,
-          form: "instructions",
-          digest: rendered.digest,
-          rules: rendered.rules.map((rule) => ({
-            key: rule.key,
-            path: rule.path,
-            scope: rule.scope,
-            digest: rule.digest
-          }))
+    const index = new RuleIndex({
+        userRuleDirs: config.userRuleDirs,
+        projectRuleDirs: config.projectRuleDirs,
+        maxRuleBytes: config.maxRuleBytes,
+        maxRules: config.maxRules,
+        maxRulesBytes: config.maxRulesBytes
+    });
+    const touched = new WeakMap();
+    const toolResult = (exec, result) => {
+        if (result?.isError)
+            return;
+        if (!FILE_TOOLS.has(exec?.name ?? ""))
+            return;
+        const agent = exec.agent;
+        if (agent === undefined)
+            return;
+        if (!config.injectInSubagents && isSubagent(agent))
+            return;
+        const raw = exec.arguments?.file_path;
+        if (typeof raw !== "string" || raw.trim().length === 0)
+            return;
+        let paths = touched.get(agent.session);
+        if (paths === undefined) {
+            paths = new Set();
+            touched.set(agent.session, paths);
         }
-      });
-      return enterWithMessage(agent, messages, decision, message, isRulesMessage);
-    } catch (error) {
-      if (signal?.aborted) return decision;
-      logger?.warn?.("auto-memory: could not load rules for this step: %o", error);
-      return decision;
-    }
-  };
-
-  return { preStep, toolResult };
+        paths.add(raw.trim());
+    };
+    const preStep = async ({ agent, messages, signal }, next) => {
+        const decision = await next();
+        if (decision.kind === "reject")
+            return decision;
+        if (!config.rules)
+            return decision;
+        if (!config.injectInSubagents && isSubagent(agent))
+            return decision;
+        try {
+            const project = await projectFor(agent, signal);
+            const { rules, warnings } = await index.collect({
+                cwd: project.cwd,
+                projectRoot: project.ruleRoot
+            });
+            if (rules.length === 0)
+                return decision;
+            const sessionTouches = touched.get(agent.session) ?? new Set();
+            const eligible = rules.filter((rule) => ruleMatches(rule, sessionTouches, project.cwd, project.ruleRoot));
+            if (eligible.length === 0)
+                return decision;
+            const visible = visibleRuleDigests(agent, decision);
+            const fresh = eligible.filter((rule) => visible.get(rule.key) !== rule.digest);
+            if (fresh.length === 0)
+                return decision;
+            const rendered = renderRules(fresh, config.maxRulesBytes, warnings);
+            if (rendered === undefined)
+                return decision;
+            const message = createUserMessage({
+                content: [{ type: "text", text: rendered.text }],
+                source: {
+                    kind: RULE_MESSAGE_KIND,
+                    form: "instructions",
+                    digest: rendered.digest,
+                    rules: rendered.rules.map((rule) => ({
+                        key: rule.key,
+                        path: rule.path,
+                        scope: rule.scope,
+                        digest: rule.digest
+                    }))
+                }
+            });
+            return enterWithMessage(agent, messages, decision, message, isRulesMessage);
+        }
+        catch (error) {
+            if (signal?.aborted)
+                return decision;
+            logger?.warn?.("auto-memory: could not load rules for this step: %o", error);
+            return decision;
+        }
+    };
+    return { preStep, toolResult };
 }

package/lib/rules.d.ts

@@ -0,0 +1,62 @@
+import type { RuleScope } from "./types.js";
+/** Message source kind used to recognize injected rule batches. */
+export declare const RULE_MESSAGE_KIND = "auto-rules";
+export interface Rule {
+    key: string;
+    path: string;
+    scope: RuleScope;
+    body: string;
+    paths?: string[];
+    matchers: RegExp[];
+    digest: string;
+    bytes: number;
+}
+export interface RuleIndexOptions {
+    userRuleDirs: string[];
+    projectRuleDirs: string[];
+    maxRuleBytes: number;
+    maxRules: number;
+    maxRulesBytes: number;
+}
+export interface CollectInput {
+    cwd: string;
+    projectRoot: string;
+}
+export interface CollectResult {
+    rules: Rule[];
+    warnings: string[];
+}
+/** The subset of a rule that rendering needs. */
+export interface RenderableRule {
+    key: string;
+    path: string;
+    scope: RuleScope;
+    body: string;
+    digest: string;
+}
+export interface RenderedRules {
+    text: string;
+    digest: string;
+    rules: RenderableRule[];
+}
+/**
+ * Discover and cache rule files from user and project roots.
+ *
+ * Files are re-stat'ed on every collection; content is read again only when
+ * size or mtime changes. Symlinks are followed, which is required for the
+ * Home Manager-managed rules under `~/.claude/rules/`.
+ */
+export declare class RuleIndex {
+    #private;
+    readonly userRuleDirs: string[];
+    readonly projectRuleDirs: string[];
+    readonly maxRuleBytes: number;
+    readonly maxRules: number;
+    readonly maxRulesBytes: number;
+    constructor({ userRuleDirs, projectRuleDirs, maxRuleBytes, maxRules, maxRulesBytes }: RuleIndexOptions);
+    /**
+     * Collect the rules visible to one session.
+     */
+    collect({ cwd, projectRoot }: CollectInput): Promise<CollectResult>;
+}
+export declare function renderRules(rules: RenderableRule[], maxBytes: number, warnings?: string[]): RenderedRules | undefined;