ccsniff 1.1.16 → 1.1.18

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ccsniff",
-  "version": "1.1.16",
+  "version": "1.1.18",
   "description": "Watch Claude Code JSONL output files and emit structured events as a Node.js EventEmitter",
   "type": "module",
   "main": "./src/index.js",

package/src/cli.js

@@ -383,6 +383,23 @@ if (opts['search-discipline']) {
   // A search-tool token inside a quoted string (echo/printf/node -e payloads) is text, not a shell
   // invocation; blank quoted bodies before matching, like git-discipline strips commit-message bodies.
   const stripQuoted = (s) => s.replace(/"(?:\\.|[^"\\])*"/g, '""').replace(/'(?:\\.|[^'\\])*'/g, "''");
+  // codesearch indexes ONLY the conversation's own cwd (the gm repo). A search whose target is a
+  // sibling repo outside cwd has NO codesearch index to route through, so the agent is forced to
+  // native search and flagging it is a false positive. Exempt a line that targets an absolute path
+  // or cd's into a directory that is not under the conversation cwd.
+  const normPath = (p) => String(p || '').replace(/\\/g, '/').replace(/\/+$/, '').toLowerCase();
+  const targetsOutsideCwd = (line, cwd) => {
+    const cwdN = normPath(cwd);
+    if (!cwdN) return false;
+    const stripped = stripQuoted(line);
+    // explicit `cd <dir>` to a path outside cwd
+    const cdM = stripped.match(/(?:^|[|&;]\s*)cd\s+([^\s|&;]+)/i);
+    if (cdM) { const d = normPath(cdM[1]); if (d.startsWith('/') || /^[a-z]:/.test(d)) { if (!d.startsWith(cwdN)) return true; } }
+    // absolute path argument to the search tool that is outside cwd
+    const absArgs = stripped.match(/(?:^|\s)((?:[a-z]:)?\/[^\s|&;"']+)/gi) || [];
+    for (const a of absArgs) { const d = normPath(a.trim()); if ((d.startsWith('/') || /^[a-z]:/.test(d)) && !d.startsWith(cwdN)) return true; }
+    return false;
+  };
   const violations = [];
   for (const ev of all) {
     if (!filter(ev)) continue;
@@ -393,8 +410,14 @@ if (opts['search-discipline']) {
     const ts = ev.timestamp, sid = ev.conversation?.id || '';
     let kind = null, detail = '';
     if (name === 'Grep' || name === 'Glob') {
-      kind = `native-search-${name.toLowerCase()}`;
-      detail = (ev.block?.input?.pattern || ev.block?.input?.query || '').slice(0, 120);
+      // A Grep/Glob whose path points outside the cwd targets a sibling repo with no codesearch
+      // index — exempt it, same as a cross-repo bash search.
+      const gp = ev.block?.input?.path;
+      if (gp && targetsOutsideCwd(gp, ev.conversation?.cwd)) { /* cross-repo, exempt */ }
+      else {
+        kind = `native-search-${name.toLowerCase()}`;
+        detail = (ev.block?.input?.pattern || ev.block?.input?.query || '').slice(0, 120);
+      }
     } else if (name === 'Task' || name === 'Agent') {
       const sub = (ev.block?.input?.subagent_type || ev.block?.input?.description || '').toLowerCase();
       if (/explore|search|general-purpose/.test(sub)) {
@@ -409,7 +432,9 @@ if (opts['search-discipline']) {
       // tree directly), never one immediately downstream of a pipe.
       const isTreeSearchLine = (line) => BASH_SEARCH.test(stripQuoted(line).split('|')[0]);
       const hitLine = cmd.split('\n').find(isTreeSearchLine);
-      if (hitLine) {
+      // Exempt a tree-search line that targets a sibling repo outside cwd (no codesearch index exists
+      // for it). Each command may `cd` first, so evaluate the cd context on the same line.
+      if (hitLine && !targetsOutsideCwd(hitLine, ev.conversation?.cwd)) {
         kind = 'native-search-bash';
         detail = (hitLine.split('|')[0]).trim().slice(0, 120);
       }

package/src/store.js

@@ -7,13 +7,20 @@ import { buildIndex, search, snippet, tokenize } from './bm25.js';
 export const DEFAULT_PROJECTS_DIR =
   process.env.CLAUDE_PROJECTS_DIR || path.join(os.homedir(), '.claude', 'projects');
 
+// Per-event retained-text ceiling. Tool outputs (file reads, command stdout) can
+// be many KB each; held in full across tens of thousands of events they dominate
+// the in-memory footprint. A generous cap preserves search tokens and snippet
+// windows while bounding the heap. Override via CCSNIFF_MAX_TEXT.
+const MAX_TEXT = parseInt(process.env.CCSNIFF_MAX_TEXT || '', 10) || 8192;
+
 export function blockText(b) {
   if (!b) return '';
-  if (typeof b.text === 'string') return b.text;
-  if (typeof b.content === 'string') return b.content;
-  if (Array.isArray(b.content)) return b.content.map(c => c?.text || '').join('');
-  if (b.input) { try { return JSON.stringify(b.input); } catch { return ''; } }
-  return '';
+  let t = '';
+  if (typeof b.text === 'string') t = b.text;
+  else if (typeof b.content === 'string') t = b.content;
+  else if (Array.isArray(b.content)) t = b.content.map(c => c?.text || '').join('');
+  else if (b.input) { try { t = JSON.stringify(b.input); } catch { t = ''; } }
+  return t.length > MAX_TEXT ? t.slice(0, MAX_TEXT) : t;
 }
 
 export function flattenEvent(ev, idx) {
@@ -40,8 +47,16 @@ export function flattenEvent(ev, idx) {
   };
 }
 
+// Cap retained in-memory events so a long-lived server watching an active
+// ~/.claude/projects tree does not grow without bound. The live watcher appends
+// every new event for the life of the process; without a ceiling the heap climbs
+// until OOM. Oldest events are evicted in batches (front-splice is O(n), so we
+// drop a slab at once and rebuild the search index lazily on next search).
+const DEFAULT_MAX_EVENTS = parseInt(process.env.CCSNIFF_MAX_EVENTS || '', 10) || 15000;
+const EVICT_BATCH_FRACTION = 0.1;
+
 export class Store {
-  constructor(projectsDir) {
+  constructor(projectsDir, { maxEvents } = {}) {
     this.projectsDir = projectsDir || DEFAULT_PROJECTS_DIR;
     this.events = [];
     this.errors = [];
@@ -52,16 +67,39 @@ export class Store {
     this.watcher = null;
     this.sseClients = new Set();
     this.convs = new Map();
+    this.maxEvents = maxEvents || DEFAULT_MAX_EVENTS;
+  }
+
+  // Drop oldest events once the cap is exceeded. Evicting shifts array indices,
+  // so the BM25 index (which maps by position) is invalidated and rebuilt lazily.
+  trimEvents() {
+    if (this.events.length > this.maxEvents) {
+      const drop = Math.max(this.events.length - this.maxEvents, Math.floor(this.maxEvents * EVICT_BATCH_FRACTION));
+      this.events.splice(0, drop);
+      this.index = null;
+    }
+    // errors are capped independently of events (a burst of errors must not be
+    // gated behind the events ceiling).
+    if (this.errors.length > this.maxEvents) this.errors.splice(0, this.errors.length - this.maxEvents);
   }
 
   loadOnce() {
     const r = new JsonlReplayer(this.projectsDir);
     let i = 0;
     r.on('conversation_created', ev => this.convs.set(ev.conversation.id, ev.conversation));
-    r.on('streaming_progress', ev => { this.events.push(flattenEvent(ev, i++)); });
+    // Trim during replay (not only after) so the full backlog never materializes
+    // at once — that one-shot peak, not steady-state, is what spikes RSS on a
+    // large ~/.claude/projects tree. A soft headroom above maxEvents keeps the
+    // trim from running on every push.
+    const softCap = Math.floor(this.maxEvents * 1.25);
+    r.on('streaming_progress', ev => {
+      this.events.push(flattenEvent(ev, i++));
+      if (this.events.length > softCap) this.events.splice(0, this.events.length - this.maxEvents);
+    });
     r.on('streaming_error', ev => { this.errors.push({ ts: ev.timestamp, sid: ev.conversationId, error: ev.error, recoverable: ev.recoverable }); });
     const stats = r.replay({});
     this.fileCount = stats.files;
+    this.trimEvents();
     this.rebuildIndex();
     return stats;
   }
@@ -82,6 +120,7 @@ export class Store {
       const fl = flattenEvent(ev, this.events.length);
       this.events.push(fl);
       this.broadcast('event', { sid: fl.sid, payload: fl });
+      this.trimEvents();
     });
     this.watcher.on('streaming_error', ev => {
       const e = { ts: ev.timestamp, sid: ev.conversationId, error: ev.error, recoverable: ev.recoverable };