context-mode 1.0.161 → 1.0.163

package/build/session/project-attribution.js

@@ -194,14 +194,28 @@ export function resolveProjectAttribution(event, context) {
 export function resolveProjectAttributions(events, context) {
     const out = [];
     let lastKnown = context.lastKnownProjectDir ? normalizePath(context.lastKnownProjectDir) : "";
+    // v1.0.162 Bug 8 — track whether an in-batch CWD-level event has explicitly
+    // re-scoped the project. When extract.ts emits a cwd event for `cd /projB`
+    // or `git -C /projB ...`, subsequent path-less events in the same batch
+    // (e.g. the git operation event itself) currently fall back to the hook's
+    // inputProjectDir, which still points at the session startup cwd. The
+    // user's INTENTIONAL scoping should win over the hook's startup cwd —
+    // shadow inputProjectDir with the carried-forward lastKnown once a high-
+    // confidence cwd event has fired in this batch.
+    let inBatchCwdScope = false;
     for (const ev of events) {
+        const effectiveInputCwd = inBatchCwdScope ? lastKnown : context.inputProjectDir;
         const attribution = resolveProjectAttribution(ev, {
             ...context,
+            inputProjectDir: effectiveInputCwd,
             lastKnownProjectDir: lastKnown || context.lastKnownProjectDir || null,
         });
         out.push(attribution);
         if (attribution.projectDir && attribution.confidence >= ATTRIBUTION_CONFIDENCE.CARRY_FORWARD_THRESHOLD) {
             lastKnown = attribution.projectDir;
+            if (attribution.confidence >= ATTRIBUTION_CONFIDENCE.CWD_EVENT) {
+                inBatchCwdScope = true;
+            }
         }
     }
     return out;

package/build/store.d.ts

@@ -88,7 +88,7 @@ export declare class ContentStore {
     indexPlainText(content: string, source: string, linesPerChunk?: number, attribution?: {
         sessionId?: string;
         eventId?: string;
-    }): IndexResult;
+    }, maxChunkBytes?: number): IndexResult;
     /**
      * Index JSON content by walking the object tree and using key paths
      * as chunk titles (analogous to heading hierarchy in markdown). Objects

package/build/store.js

@@ -108,6 +108,20 @@ function maxEditDistance(wordLength) {
 // length normalization and produce unwieldy search results. Split at paragraph
 // boundaries when a chunk exceeds this cap.
 const MAX_CHUNK_BYTES = 4096;
+// Blank-line sectioning is used only for output that is *naturally* sectioned:
+// at least a few sections, not an unbounded explosion, and no single section so
+// large that the split is clearly not the real structure (those fall back to
+// line-grouping). Sections that pass the heuristic but still exceed
+// MAX_CHUNK_BYTES are sub-split so no persisted chunk breaks the cap.
+const MIN_BLANK_LINE_SECTIONS = 3;
+const MAX_BLANK_LINE_SECTIONS = 200;
+const BLANK_SECTION_STRATEGY_MAX_BYTES = 5000;
+// Number of leading characters of a chunk's first line used as its title.
+const CHUNK_TITLE_MAX_CHARS = 80;
+// When byte-splitting an oversized single line, prefer to break at a whitespace
+// boundary for readability — but only if that boundary is past this fraction of
+// the slice, otherwise we'd waste too much of the byte budget.
+const WHITESPACE_BREAK_RATIO = 0.5;
 // ─────────────────────────────────────────────────────────
 // ContentStore
 // ─────────────────────────────────────────────────────────
@@ -820,11 +834,11 @@ export class ContentStore {
      * into fixed-size line groups. Unlike markdown indexing, this does not
      * look for headings — it chunks by line count with overlap.
      */
-    indexPlainText(content, source, linesPerChunk = 20, attribution) {
+    indexPlainText(content, source, linesPerChunk = 20, attribution, maxChunkBytes = MAX_CHUNK_BYTES) {
         if (!content || content.trim().length === 0) {
             return this.#insertChunks([], source, "", undefined, undefined, attribution);
         }
-        const chunks = this.#chunkPlainText(content, linesPerChunk);
+        const chunks = this.#chunkPlainText(content, linesPerChunk, maxChunkBytes);
         return withRetry(() => this.#insertChunks(chunks.map((c) => ({ ...c, hasCode: false })), source, content, undefined, undefined, attribution));
     }
     // ── Index JSON ──
@@ -837,19 +851,19 @@ export class ContentStore {
      */
     indexJSON(content, source, maxChunkBytes = MAX_CHUNK_BYTES, attribution) {
         if (!content || content.trim().length === 0) {
-            return this.indexPlainText("", source, undefined, attribution);
+            return this.indexPlainText("", source, undefined, attribution, maxChunkBytes);
         }
         let parsed;
         try {
             parsed = JSON.parse(content);
         }
         catch {
-            return this.indexPlainText(content, source, undefined, attribution);
+            return this.indexPlainText(content, source, undefined, attribution, maxChunkBytes);
         }
         const chunks = [];
         this.#walkJSON(parsed, [], chunks, maxChunkBytes);
         if (chunks.length === 0) {
-            return this.indexPlainText(content, source, undefined, attribution);
+            return this.indexPlainText(content, source, undefined, attribution, maxChunkBytes);
         }
         return withRetry(() => this.#insertChunks(chunks, source, content, undefined, undefined, attribution));
     }
@@ -1448,27 +1462,119 @@ export class ContentStore {
         flush();
         return chunks;
     }
-    #chunkPlainText(text, linesPerChunk) {
+    /**
+     * Return the largest prefix of `str` whose UTF-8 byte length does not exceed
+     * `maxBytes`, walking by Unicode code point so multibyte sequences (CJK) and
+     * surrogate pairs (emoji) are never cut mid-character. Guarantees forward
+     * progress: if even the first code point exceeds `maxBytes`, it is still
+     * returned whole (a 1-4 byte overshoot beats an infinite loop).
+     */
+    #byteCappedPrefix(str, maxBytes) {
+        if (Buffer.byteLength(str) <= maxBytes)
+            return str;
+        let prefix = "";
+        let bytes = 0;
+        for (const char of str) {
+            const charBytes = Buffer.byteLength(char);
+            if (bytes + charBytes > maxBytes)
+                break;
+            prefix += char;
+            bytes += charBytes;
+        }
+        // Defensive: a single code point wider than the cap (only possible with a
+        // pathologically small maxBytes) still advances by one character.
+        if (prefix.length === 0)
+            return [...str][0] ?? "";
+        return prefix;
+    }
+    /**
+     * Split a single oversized plain-text chunk into byte-capped sub-chunks
+     * by accumulating lines until the byte count would exceed maxChunkBytes.
+     * Falls back to byte-accurate splitting for extremely long single lines.
+     */
+    #splitOversizedPlainChunk(lines, titlePrefix, maxChunkBytes) {
+        const subChunks = [];
+        let accumulator = [];
+        let partIndex = 1;
+        const flushAccumulator = () => {
+            if (accumulator.length === 0)
+                return;
+            const content = accumulator.join("\n");
+            const partTitle = partIndex === 1 ? titlePrefix : `${titlePrefix} (${partIndex})`;
+            subChunks.push({ title: partTitle, content });
+            partIndex++;
+            accumulator = [];
+        };
+        for (const line of lines) {
+            // If a single line itself exceeds the cap (even as first line),
+            // split it by character before accumulating
+            if (Buffer.byteLength(line) > maxChunkBytes) {
+                flushAccumulator();
+                // Split the long line into byte-capped pieces
+                let remaining = line;
+                let linePart = 1;
+                while (remaining.length > 0) {
+                    // Byte-accurate slice: never exceeds the cap, never cuts a multibyte
+                    // character (CJK) or surrogate pair (emoji) in half.
+                    let slice = this.#byteCappedPrefix(remaining, maxChunkBytes);
+                    // Try to break at a whitespace boundary near the end for readability,
+                    // but only when text remains after this slice.
+                    if (slice.length < remaining.length) {
+                        const lastSpace = slice.lastIndexOf(" ");
+                        const lastNewline = slice.lastIndexOf("\n");
+                        const breakPoint = Math.max(lastSpace, lastNewline);
+                        if (breakPoint > slice.length * WHITESPACE_BREAK_RATIO) {
+                            slice = slice.slice(0, breakPoint);
+                        }
+                    }
+                    const linePartTitle = partIndex === 1 && linePart === 1
+                        ? titlePrefix
+                        : `${titlePrefix} (${partIndex}.${linePart})`;
+                    subChunks.push({ title: linePartTitle, content: slice });
+                    remaining = remaining.slice(slice.length);
+                    linePart++;
+                    partIndex++;
+                }
+                continue;
+            }
+            const candidate = accumulator.length > 0
+                ? accumulator.join("\n") + "\n" + line
+                : line;
+            // If adding this line would exceed the cap, flush accumulator first
+            if (Buffer.byteLength(candidate) > maxChunkBytes && accumulator.length > 0) {
+                flushAccumulator();
+            }
+            accumulator.push(line);
+        }
+        flushAccumulator();
+        return subChunks;
+    }
+    #chunkPlainText(text, linesPerChunk, maxChunkBytes = MAX_CHUNK_BYTES) {
         // Try blank-line splitting first for naturally-sectioned output
         const sections = text.split(/\n\s*\n/);
-        if (sections.length >= 3 &&
-            sections.length <= 200 &&
-            sections.every((s) => Buffer.byteLength(s) < 5000)) {
-            return sections
-                .map((section, i) => {
+        if (sections.length >= MIN_BLANK_LINE_SECTIONS &&
+            sections.length <= MAX_BLANK_LINE_SECTIONS &&
+            sections.every((s) => Buffer.byteLength(s) < BLANK_SECTION_STRATEGY_MAX_BYTES)) {
+            return sections.flatMap((section, i) => {
                 const trimmed = section.trim();
-                const firstLine = trimmed.split("\n")[0].slice(0, 80);
-                return {
-                    title: firstLine || `Section ${i + 1}`,
-                    content: trimmed,
-                };
-            })
-                .filter((s) => s.content.length > 0);
+                if (trimmed.length === 0)
+                    return [];
+                const title = trimmed.split("\n")[0].slice(0, CHUNK_TITLE_MAX_CHARS) || `Section ${i + 1}`;
+                // A section may pass the strategy guard yet still exceed the byte cap
+                // (4097–4999B band): sub-split it so no stored chunk breaks the cap.
+                if (Buffer.byteLength(trimmed) <= maxChunkBytes) {
+                    return [{ title, content: trimmed }];
+                }
+                return this.#splitOversizedPlainChunk(trimmed.split("\n"), title, maxChunkBytes);
+            });
         }
         const lines = text.split("\n");
-        // Small enough for a single chunk
+        // Small enough for a single chunk — but still enforce byte cap
         if (lines.length <= linesPerChunk) {
-            return [{ title: "Output", content: text }];
+            if (Buffer.byteLength(text) <= maxChunkBytes) {
+                return [{ title: "Output", content: text }];
+            }
+            return this.#splitOversizedPlainChunk(lines, "Output", maxChunkBytes);
         }
         // Fixed-size line groups with 2-line overlap
         const chunks = [];
@@ -1480,11 +1586,19 @@ export class ContentStore {
                 break;
             const startLine = i + 1;
             const endLine = Math.min(i + slice.length, lines.length);
-            const firstLine = slice[0]?.trim().slice(0, 80);
-            chunks.push({
-                title: firstLine || `Lines ${startLine}-${endLine}`,
-                content: slice.join("\n"),
-            });
+            const firstLine = slice[0]?.trim().slice(0, CHUNK_TITLE_MAX_CHARS);
+            const joined = slice.join("\n");
+            // Enforce byte cap: sub-split oversized line-group chunks
+            if (Buffer.byteLength(joined) <= maxChunkBytes) {
+                chunks.push({
+                    title: firstLine || `Lines ${startLine}-${endLine}`,
+                    content: joined,
+                });
+            }
+            else {
+                const subChunks = this.#splitOversizedPlainChunk(slice, firstLine || `Lines ${startLine}-${endLine}`, maxChunkBytes);
+                chunks.push(...subChunks);
+            }
         }
         return chunks;
     }

package/build/tool-naming.d.ts

@@ -0,0 +1,4 @@
+export declare function getToolName(platform: string, bareTool: string): string;
+export type ToolNamer = (bareTool: string) => string;
+export declare function createToolNamer(platform: string): ToolNamer;
+export declare const KNOWN_PLATFORMS: string[];

package/build/tool-naming.js

@@ -0,0 +1,24 @@
+const TOOL_PREFIXES = {
+    "claude-code": (tool) => `mcp__plugin_context-mode_context-mode__${tool}`,
+    "gemini-cli": (tool) => `mcp__context-mode__${tool}`,
+    "antigravity": (tool) => `mcp__context-mode__${tool}`,
+    "opencode": (tool) => `context-mode_${tool}`,
+    "kilo": (tool) => `context-mode_${tool}`,
+    "vscode-copilot": (tool) => `context-mode_${tool}`,
+    "jetbrains-copilot": (tool) => `context-mode_${tool}`,
+    "kiro": (tool) => `@context-mode/${tool}`,
+    "zed": (tool) => `mcp:context-mode:${tool}`,
+    "cursor": (tool) => tool,
+    "codex": (tool) => tool,
+    "openclaw": (tool) => tool,
+    "pi": (tool) => tool,
+    "qwen-code": (tool) => `mcp__context-mode__${tool}`,
+};
+export function getToolName(platform, bareTool) {
+    const fn = TOOL_PREFIXES[platform] || TOOL_PREFIXES["claude-code"];
+    return fn(bareTool);
+}
+export function createToolNamer(platform) {
+    return (bareTool) => getToolName(platform, bareTool);
+}
+export const KNOWN_PLATFORMS = Object.keys(TOOL_PREFIXES);

package/build/util/jsonc.d.ts

@@ -0,0 +1,14 @@
+/**
+ * util/jsonc — string-aware JSONC comment + trailing-comma stripping and a
+ * tolerant parse. Several agent CLIs ship config files as JSONC (VS Code
+ * `mcp.json`, Zed `settings.json`), so a strict `JSON.parse` false-fails on a
+ * perfectly valid commented file. Use `parseJsonc` whenever reading a
+ * platform config we did not write ourselves.
+ */
+/** Strip `//` line + `/* *​/` block comments and trailing commas, string-aware. */
+export declare function stripJsonComments(str: string): string;
+/**
+ * Parse JSON or JSONC. Tries strict `JSON.parse` first (fast, exact), then a
+ * comment/trailing-comma-stripped parse. Returns `undefined` when both fail.
+ */
+export declare function parseJsonc<T = unknown>(raw: string): T | undefined;

package/build/util/jsonc.js

@@ -0,0 +1,104 @@
+/**
+ * util/jsonc — string-aware JSONC comment + trailing-comma stripping and a
+ * tolerant parse. Several agent CLIs ship config files as JSONC (VS Code
+ * `mcp.json`, Zed `settings.json`), so a strict `JSON.parse` false-fails on a
+ * perfectly valid commented file. Use `parseJsonc` whenever reading a
+ * platform config we did not write ourselves.
+ */
+/** Strip `//` line + `/* *​/` block comments and trailing commas, string-aware. */
+export function stripJsonComments(str) {
+    let out = "";
+    let inString = false;
+    let escaped = false;
+    let inBlockComment = false;
+    for (let i = 0; i < str.length; i++) {
+        const c = str[i];
+        const next = str[i + 1];
+        if (inBlockComment) {
+            if (c === "*" && next === "/") {
+                inBlockComment = false;
+                i++;
+            }
+            continue;
+        }
+        if (escaped) {
+            out += c;
+            escaped = false;
+            continue;
+        }
+        if (c === "\\") {
+            out += c;
+            escaped = inString;
+            continue;
+        }
+        if (c === '"') {
+            inString = !inString;
+            out += c;
+            continue;
+        }
+        if (!inString && c === "/" && next === "/") {
+            while (i < str.length && str[i] !== "\n")
+                i++;
+            if (i < str.length)
+                out += "\n";
+            continue;
+        }
+        if (!inString && c === "/" && next === "*") {
+            inBlockComment = true;
+            i++;
+            continue;
+        }
+        out += c;
+    }
+    // Trailing-comma removal, string-aware. The scan above already removed
+    // comments, so this second pass over `out` only needs to track string state:
+    // a comma is "trailing" when the next significant char is `}` or `]`. Doing
+    // it here — instead of a post-hoc trailing-comma regex over the whole string —
+    // preserves commas inside string literals (e.g. "[1, ]"), which that regex
+    // silently corrupted to "[1 ]". See #787 review.
+    let result = "";
+    let inStr = false;
+    let esc = false;
+    for (let i = 0; i < out.length; i++) {
+        const c = out[i];
+        if (esc) {
+            result += c;
+            esc = false;
+            continue;
+        }
+        if (c === "\\") {
+            result += c;
+            esc = inStr;
+            continue;
+        }
+        if (c === '"') {
+            inStr = !inStr;
+            result += c;
+            continue;
+        }
+        if (!inStr && c === ",") {
+            let j = i + 1;
+            while (j < out.length && (out[j] === " " || out[j] === "\t" || out[j] === "\r" || out[j] === "\n"))
+                j++;
+            if (out[j] === "}" || out[j] === "]")
+                continue;
+        }
+        result += c;
+    }
+    return result;
+}
+/**
+ * Parse JSON or JSONC. Tries strict `JSON.parse` first (fast, exact), then a
+ * comment/trailing-comma-stripped parse. Returns `undefined` when both fail.
+ */
+export function parseJsonc(raw) {
+    for (const candidate of [raw, stripJsonComments(raw)]) {
+        try {
+            return JSON.parse(candidate);
+        }
+        catch {
+            /* try next */
+        }
+    }
+    return undefined;
+}