@narumitw/pi-cbmem 0.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 narumiruna
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,127 @@
+# 🧠 pi-cbmem — Codebase Memory Tools for Pi
+
+[![npm: private](https://img.shields.io/badge/npm-private-lightgrey)](#-install) [![Pi extension](https://img.shields.io/badge/Pi-extension-blue)](https://pi.dev) [![License: MIT](https://img.shields.io/badge/license-MIT-green.svg)](./LICENSE)
+
+pi-cbmem is a private package that bundles the local Codebase Memory extension and its knowledge-graph operating skill.
+
+## ✨ Features
+
+- Registers all 15 Codebase Memory graph, search, indexing, coverage, trace, and architecture tools.
+- Invokes the local `codebase-memory-mcp` CLI with cancellation, failure reporting, and bounded output.
+- Bundles the `codebase-memory` skill for evidence-tier and graph-first workflows.
+- Keeps the extension and skill available through one package declaration.
+
+## 📦 Install
+
+This package is private and is not published to npm.
+
+Install it from this repository checkout:
+
+```bash
+pi install ./packages/pi-cbmem
+```
+
+Build and try it without adding a persistent package setting:
+
+```bash
+npm --workspace @narumitw/pi-cbmem run build
+pi --no-extensions -e ./packages/pi-cbmem
+```
+
+The package declares `dist/index.ts`, so an unbuilt local checkout must run the build before Pi loads the package directory.
+
+Pi extensions run with your user permissions.
+
+Review the source before loading the package.
+
+## 🚀 Quick start
+
+Install `codebase-memory-mcp` at `~/.local/bin/codebase-memory-mcp`, load the package, and ask Pi a structural codebase question.
+
+The bundled skill tells Pi to check the active graph project before exploration and to verify material claims with graph snippets and index-coverage evidence.
+
+## 🛠️ Tools
+
+The extension registers these tools:
+
+- `index_repository`
+- `search_graph`
+- `query_graph`
+- `trace_path`
+- `get_code_snippet`
+- `get_graph_schema`
+- `get_architecture`
+- `search_code`
+- `list_projects`
+- `delete_project`
+- `index_status`
+- `check_index_coverage`
+- `detect_changes`
+- `manage_adr`
+- `ingest_traces`
+
+Each tool sends JSON arguments to `codebase-memory-mcp cli <tool>` over standard input and returns the last JSON response written to standard output.
+
+Validated JSON output over 2,000 lines is truncated with an explicit omission notice.
+
+Standard output over 50 KB fails safely because the complete JSON response cannot be validated within the bounded capture.
+
+Spawn failures, nonzero exits, oversized output, and missing JSON responses are reported as failed tool calls.
+
+## 🔒 Security and privacy
+
+The Codebase Memory binary runs with the Pi process environment and user permissions.
+
+Tool calls can read and index repositories, inspect source, persist graph data, manage architecture decisions and traces, or delete indexed projects.
+
+Deleting a project or replacing its Architecture Decision Records requires explicit confirmation in TUI or RPC mode and is rejected in non-interactive modes.
+
+Repository content returned by graph tools can be sent to the selected model provider as tool output.
+
+Terminal controls are removed only from the TUI rendering boundary; the validated raw result remains available to the model.
+
+The extension starts one local CLI child process per tool call in the active session directory and does not start background work during extension factory load.
+
+Cancelling a tool call terminates its child process.
+
+## 🚧 Limitations
+
+The package expects the binary at `~/.local/bin/codebase-memory-mcp` for the current user.
+
+It does not install or update the Codebase Memory binary.
+
+The extension exposes static tool schemas that match the bundled Codebase Memory skill and delegates final argument validation to the installed CLI.
+
+## 🗂️ Package layout
+
+```text
+packages/pi-cbmem/
+├── dist/                           # Generated source-mapped Jiti runtime
+├── scripts/
+│   └── build-runtime.mjs           # Deterministic runtime builder and validator
+├── src/
+│   ├── index.ts                    # Thin Pi entrypoint
+│   ├── cbmem.ts                    # Bounded Codebase Memory CLI runner
+│   ├── render-result.ts            # Terminal-safe result rendering
+│   └── tool-definitions.ts         # Pi tool metadata and TypeBox schemas
+├── skills/codebase-memory/
+│   └── SKILL.md                    # Graph-first operating guidance
+├── test/
+│   ├── build-runtime.test.ts       # Generated-runtime and Jiti loader coverage
+│   └── cbmem.test.ts               # Tool registration coverage
+├── package.json                    # Private Pi extension and skill declarations
+├── tsconfig.json
+├── README.md
+└── LICENSE
+```
+
+The generated runtime is built from the authoritative `src/index.ts` graph and does not import back into `src`.
+
+## 🔎 Keywords
+
+Pi, Codebase Memory, code knowledge graph, MCP, call graph, architecture, impact analysis, source indexing.
+
+## 📄 License
+
+MIT.
+See [`LICENSE`](./LICENSE).

package/dist/index.ts

@@ -0,0 +1,523 @@
+// @generated by scripts/build-runtime.mjs; do not edit.
+// @ts-nocheck -- generated JavaScript uses a .ts extension for Pi's Jiti loader.
+
+// src/cbmem.ts
+import { spawn } from "node:child_process";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { DEFAULT_MAX_BYTES as DEFAULT_MAX_BYTES2, DEFAULT_MAX_LINES as DEFAULT_MAX_LINES2, formatSize as formatSize2 } from "@earendil-works/pi-coding-agent";
+import { sanitizeTerminalText as sanitizeTerminalText2 } from "@narumitw/pi-tui-kit/terminal-text";
+
+// src/render-result.ts
+import { Text } from "@earendil-works/pi-tui";
+import { sanitizeTerminalText } from "@narumitw/pi-tui-kit/terminal-text";
+function renderCodebaseMemoryResult(result, options, theme) {
+  const rawText = result.content.flatMap((content) => content.type === "text" ? [content.text] : []).join("\n");
+  const displayText = sanitizeMultilineTerminalText(rawText);
+  const color = options.isPartial ? "warning" : "toolOutput";
+  return new Text(theme.fg(color, displayText), 0, 0);
+}
+function sanitizeMultilineTerminalText(value) {
+  return value.replace(/\r\n?/gu, "\n").split("\n").map((line) => sanitizeTerminalText(line)).join("\n");
+}
+
+// src/tool-definitions.ts
+import { StringEnum } from "@earendil-works/pi-ai";
+import { DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, formatSize } from "@earendil-works/pi-coding-agent";
+import { Type } from "typebox";
+var Project = Type.String({ description: "Indexed project name from list_projects." });
+var outputLimit = `Output is limited to ${DEFAULT_MAX_LINES} lines or ${formatSize(DEFAULT_MAX_BYTES)}; byte-oversized responses fail validation instead of returning partial JSON.`;
+var TOOL_DEFINITIONS = [
+  {
+    name: "index_repository",
+    label: "Index Repository",
+    description: `Index a repository in the Codebase Memory graph. ${outputLimit}`,
+    parameters: Type.Object({
+      repo_path: Type.String({ description: "Path to the repository." }),
+      mode: Type.Optional(
+        StringEnum(["full", "moderate", "fast", "cross-repo-intelligence"])
+      ),
+      target_projects: Type.Optional(Type.Array(Type.String())),
+      name: Type.Optional(Type.String({ description: "Override the derived project name." })),
+      persistence: Type.Optional(Type.Boolean())
+    })
+  },
+  {
+    name: "search_graph",
+    label: "Search Graph",
+    description: `Search indexed symbols by text, name, file, relationship, or degree. ${outputLimit}`,
+    parameters: Type.Object({
+      project: Project,
+      query: Type.Optional(Type.String({ description: "Natural-language or keyword search." })),
+      label: Type.Optional(Type.String()),
+      name_pattern: Type.Optional(Type.String()),
+      qn_pattern: Type.Optional(Type.String()),
+      file_pattern: Type.Optional(Type.String()),
+      relationship: Type.Optional(Type.String()),
+      min_degree: Type.Optional(Type.Integer()),
+      max_degree: Type.Optional(Type.Integer()),
+      exclude_entry_points: Type.Optional(Type.Boolean()),
+      include_connected: Type.Optional(Type.Boolean()),
+      semantic_query: Type.Optional(Type.Array(Type.String())),
+      limit: Type.Optional(Type.Integer()),
+      offset: Type.Optional(Type.Integer()),
+      format: Type.Optional(StringEnum(["tree", "json"])),
+      fields: Type.Optional(Type.Array(Type.String())),
+      detail: Type.Optional(StringEnum(["ids", "default"]))
+    })
+  },
+  {
+    name: "query_graph",
+    label: "Query Graph",
+    description: `Execute a Cypher query against the code or missed-coverage graph. ${outputLimit}`,
+    parameters: Type.Object({
+      query: Type.String({ description: "Cypher query." }),
+      project: Project,
+      graph: Type.Optional(StringEnum(["code", "missed"])),
+      max_rows: Type.Optional(Type.Integer())
+    })
+  },
+  {
+    name: "trace_path",
+    label: "Trace Path",
+    description: `Trace callers, callees, data flow, or cross-service paths. ${outputLimit}`,
+    parameters: Type.Object({
+      function_name: Type.String(),
+      project: Project,
+      direction: Type.Optional(StringEnum(["inbound", "outbound", "both"])),
+      depth: Type.Optional(Type.Integer()),
+      limit: Type.Optional(Type.Integer({ minimum: 1, maximum: 5e3 })),
+      cursor: Type.Optional(Type.String()),
+      mode: Type.Optional(StringEnum(["calls", "data_flow", "cross_service"])),
+      parameter_name: Type.Optional(Type.String()),
+      edge_types: Type.Optional(Type.Array(Type.String())),
+      risk_labels: Type.Optional(Type.Boolean()),
+      include_tests: Type.Optional(Type.Boolean()),
+      format: Type.Optional(StringEnum(["tree", "json"])),
+      include_evidence: Type.Optional(Type.Boolean())
+    })
+  },
+  {
+    name: "get_code_snippet",
+    label: "Get Code Snippet",
+    description: `Read source for an indexed symbol by qualified name. ${outputLimit}`,
+    parameters: Type.Object({
+      qualified_name: Type.String(),
+      project: Project,
+      include_neighbors: Type.Optional(Type.Boolean())
+    })
+  },
+  {
+    name: "get_graph_schema",
+    label: "Get Graph Schema",
+    description: `Get graph node labels and edge types. ${outputLimit}`,
+    parameters: Type.Object({ project: Project })
+  },
+  {
+    name: "get_architecture",
+    label: "Get Architecture",
+    description: `Summarize architecture, dependencies, boundaries, clusters, or hotspots. ${outputLimit}`,
+    parameters: Type.Object({
+      project: Project,
+      path: Type.Optional(Type.String()),
+      aspects: Type.Optional(
+        Type.Array(
+          StringEnum([
+            "all",
+            "overview",
+            "structure",
+            "dependencies",
+            "routes",
+            "languages",
+            "packages",
+            "entry_points",
+            "hotspots",
+            "boundaries",
+            "layers",
+            "file_tree",
+            "clusters",
+            "cycles"
+          ])
+        )
+      )
+    })
+  },
+  {
+    name: "search_code",
+    label: "Search Code",
+    description: `Search source text and enrich matches with graph context. ${outputLimit}`,
+    parameters: Type.Object({
+      pattern: Type.String(),
+      project: Project,
+      file_pattern: Type.Optional(Type.String()),
+      path_filter: Type.Optional(Type.String()),
+      mode: Type.Optional(StringEnum(["compact", "full", "files"])),
+      context: Type.Optional(Type.Integer()),
+      regex: Type.Optional(Type.Boolean()),
+      debug: Type.Optional(Type.Boolean()),
+      limit: Type.Optional(Type.Integer({ minimum: 1 }))
+    })
+  },
+  {
+    name: "list_projects",
+    label: "List Projects",
+    description: `List indexed Codebase Memory projects. ${outputLimit}`,
+    parameters: Type.Object({
+      offset: Type.Optional(Type.Integer({ minimum: 0 })),
+      limit: Type.Optional(Type.Integer({ minimum: 1, maximum: 100 })),
+      include_details: Type.Optional(Type.Boolean()),
+      metadata_only: Type.Optional(Type.Boolean())
+    })
+  },
+  {
+    name: "delete_project",
+    label: "Delete Project",
+    description: `Delete a project from the Codebase Memory index. ${outputLimit}`,
+    parameters: Type.Object({ project: Project })
+  },
+  {
+    name: "index_status",
+    label: "Index Status",
+    description: `Get project index health, Git context, and coverage gaps. ${outputLimit}`,
+    parameters: Type.Object({
+      project: Project,
+      verbose: Type.Optional(Type.Boolean())
+    })
+  },
+  {
+    name: "check_index_coverage",
+    label: "Check Index Coverage",
+    description: `Check best-effort index coverage for exact paths or bounded scopes. ${outputLimit}`,
+    parameters: Type.Object({
+      project: Project,
+      paths: Type.Optional(Type.Array(Type.String(), { maxItems: 128 })),
+      scopes: Type.Optional(Type.Array(Type.String(), { maxItems: 32 })),
+      scope_limit: Type.Optional(Type.Integer({ minimum: 1, maximum: 1e3 })),
+      scope_offset: Type.Optional(Type.Integer({ minimum: 0 }))
+    })
+  },
+  {
+    name: "detect_changes",
+    label: "Detect Changes",
+    description: `Map a Git diff to changed files and impacted graph symbols. ${outputLimit}`,
+    parameters: Type.Object({
+      project: Project,
+      scope: Type.Optional(StringEnum(["files", "impact"])),
+      direction: Type.Optional(StringEnum(["inbound", "outbound", "both"])),
+      depth: Type.Optional(Type.Integer()),
+      limit: Type.Optional(Type.Integer({ maximum: 5e3 })),
+      base_branch: Type.Optional(Type.String()),
+      since: Type.Optional(Type.String()),
+      format: Type.Optional(StringEnum(["tree", "json"]))
+    })
+  },
+  {
+    name: "manage_adr",
+    label: "Manage ADR",
+    description: `Read or replace Architecture Decision Records. ${outputLimit}`,
+    parameters: Type.Object(
+      {
+        project: Project,
+        mode: Type.Optional(StringEnum(["get", "update", "sections"])),
+        content: Type.Optional(Type.String())
+      },
+      { additionalProperties: false }
+    )
+  },
+  {
+    name: "ingest_traces",
+    label: "Ingest Traces",
+    description: `Ingest runtime caller-to-callee traces into the graph. ${outputLimit}`,
+    parameters: Type.Object({
+      traces: Type.Array(
+        Type.Object(
+          {
+            caller: Type.Optional(Type.String()),
+            callee: Type.Optional(Type.String()),
+            count: Type.Optional(Type.Integer())
+          },
+          { additionalProperties: false }
+        )
+      ),
+      project: Project
+    })
+  }
+];
+var TOOL_NAMES = TOOL_DEFINITIONS.map(({ name }) => name);
+
+// src/cbmem.ts
+var BIN = join(homedir(), ".local", "bin", "codebase-memory-mcp");
+var STDERR_MAX_BYTES = 8 * 1024;
+var FORCE_KILL_DELAY_MS = 250;
+var BoundedPrefixCollector = class {
+  maxBytes;
+  text = "";
+  totalBytes = 0;
+  newlines = 0;
+  endsWithNewline = false;
+  truncated = false;
+  constructor(maxBytes) {
+    this.maxBytes = maxBytes;
+  }
+  append(chunk) {
+    const chunkBytes = Buffer.byteLength(chunk, "utf8");
+    this.totalBytes += chunkBytes;
+    this.newlines += countOccurrences(chunk, "\n");
+    if (chunk.length > 0) this.endsWithNewline = chunk.endsWith("\n");
+    const remaining = this.maxBytes - Buffer.byteLength(this.text, "utf8");
+    if (remaining <= 0) {
+      if (chunkBytes > 0) this.truncated = true;
+      return;
+    }
+    const kept = takeUtf8Prefix(chunk, remaining, Number.POSITIVE_INFINITY);
+    this.text += kept;
+    if (kept.length !== chunk.length) this.truncated = true;
+  }
+  get totalLines() {
+    if (this.totalBytes === 0) return 0;
+    return this.newlines + (this.endsWithNewline ? 0 : 1);
+  }
+};
+var BoundedTailCollector = class {
+  maxBytes;
+  text = "";
+  truncated = false;
+  constructor(maxBytes) {
+    this.maxBytes = maxBytes;
+  }
+  append(chunk) {
+    this.text += chunk;
+    if (Buffer.byteLength(this.text, "utf8") <= this.maxBytes) return;
+    this.text = takeUtf8Suffix(this.text, this.maxBytes);
+    this.truncated = true;
+  }
+};
+async function callCodebaseMemory(tool, args, signal, cwd, binary = BIN) {
+  signal?.throwIfAborted();
+  const input = JSON.stringify(args);
+  return await new Promise((resolve, reject) => {
+    const stdout = new BoundedPrefixCollector(DEFAULT_MAX_BYTES2);
+    const stderr = new BoundedTailCollector(STDERR_MAX_BYTES);
+    const child = spawn(binary, ["cli", tool], {
+      cwd,
+      stdio: ["pipe", "pipe", "pipe"],
+      env: { ...process.env, CBM_LOG_LEVEL: "error" }
+    });
+    let settled = false;
+    let forceKillTimer;
+    const cleanup = () => {
+      signal?.removeEventListener("abort", onAbort);
+      if (forceKillTimer) clearTimeout(forceKillTimer);
+    };
+    const fail = (error) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      if (child.exitCode === null && child.signalCode === null) child.kill("SIGKILL");
+      reject(error);
+    };
+    const succeed = (result) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      resolve(result);
+    };
+    const onAbort = () => {
+      if (child.exitCode !== null || child.signalCode !== null) return;
+      child.kill("SIGTERM");
+      forceKillTimer = setTimeout(() => {
+        if (child.exitCode === null && child.signalCode === null) child.kill("SIGKILL");
+      }, FORCE_KILL_DELAY_MS);
+      forceKillTimer.unref();
+    };
+    signal?.addEventListener("abort", onAbort, { once: true });
+    if (signal?.aborted) onAbort();
+    child.stdout.setEncoding("utf8");
+    child.stderr.setEncoding("utf8");
+    child.stdout.on("data", (chunk) => stdout.append(chunk));
+    child.stderr.on("data", (chunk) => stderr.append(chunk));
+    child.stdout.on("error", fail);
+    child.stderr.on("error", fail);
+    child.stdin.on("error", () => {
+    });
+    child.on("error", fail);
+    child.on("close", (code) => {
+      if (settled) return;
+      if (signal?.aborted) {
+        fail(abortReason(signal));
+        return;
+      }
+      if (code !== 0) {
+        fail(cliFailure(tool, code, stderr));
+        return;
+      }
+      if (stdout.truncated) {
+        fail(
+          new Error(
+            `codebase-memory-mcp ${tool} exceeded ${formatSize2(DEFAULT_MAX_BYTES2)} before a complete JSON response could be validated`
+          )
+        );
+        return;
+      }
+      try {
+        const response = extractLastJson(stdout.text);
+        const bounded = boundOutput(response, stdout);
+        succeed({
+          content: [{ type: "text", text: bounded.text }],
+          details: {
+            truncated: bounded.truncated,
+            totalBytes: stdout.totalBytes,
+            totalLines: stdout.totalLines
+          }
+        });
+      } catch (error) {
+        const diagnostic = stderr.text.trim();
+        const suffix = diagnostic ? `: ${diagnostic}` : "";
+        fail(
+          new Error(`codebase-memory-mcp ${tool} returned no JSON response${suffix}`, {
+            cause: error
+          })
+        );
+      }
+    });
+    child.stdin.end(input);
+  });
+}
+function cbmem(pi, binary = BIN) {
+  for (const definition of TOOL_DEFINITIONS) registerBridgeTool(pi, definition, binary);
+}
+function registerBridgeTool(pi, definition, binary) {
+  pi.registerTool({
+    ...definition,
+    renderResult: renderCodebaseMemoryResult,
+    async execute(_toolCallId, params, signal, _onUpdate, ctx) {
+      const tool = definition.name;
+      const args = params;
+      await confirmDestructiveCall(tool, args, signal, ctx);
+      return await callCodebaseMemory(tool, args, signal, ctx.cwd, binary);
+    }
+  });
+}
+async function confirmDestructiveCall(tool, args, signal, ctx) {
+  const prompt = destructivePrompt(tool, args);
+  if (!prompt) return;
+  signal?.throwIfAborted();
+  if (!ctx.hasUI || ctx.mode !== "tui" && ctx.mode !== "rpc") {
+    throw new Error(
+      `Codebase Memory ${tool} requires user confirmation in TUI or RPC mode before it can run.`
+    );
+  }
+  const confirmed = await ctx.ui.confirm(prompt.title, prompt.message, { signal });
+  signal?.throwIfAborted();
+  if (!confirmed) {
+    throw new DOMException(`Codebase Memory ${tool} was cancelled by the user.`, "AbortError");
+  }
+}
+function destructivePrompt(tool, args) {
+  const project = safeArgument(args.project, "unknown project");
+  if (tool === "delete_project") {
+    return {
+      title: "Delete Codebase Memory project?",
+      message: `Project: ${project}
+This permanently removes the project's Codebase Memory index.`
+    };
+  }
+  if (tool === "manage_adr" && args.mode === "update") {
+    const contentBytes = typeof args.content === "string" ? Buffer.byteLength(args.content, "utf8") : 0;
+    return {
+      title: "Replace Codebase Memory ADRs?",
+      message: `Project: ${project}
+Replace the complete ADR document with ${contentBytes} bytes of content.`
+    };
+  }
+  return void 0;
+}
+function safeArgument(value, fallback) {
+  if (typeof value !== "string") return fallback;
+  return sanitizeTerminalText2(value) || fallback;
+}
+function extractLastJson(output) {
+  const trimmed = output.trim();
+  if (!trimmed) throw new Error("empty stdout");
+  try {
+    JSON.parse(trimmed);
+    return trimmed;
+  } catch {
+    const lines = trimmed.split("\n");
+    for (let index = lines.length - 1; index >= 0; index--) {
+      const line = lines[index].trim();
+      if (!line) continue;
+      try {
+        JSON.parse(line);
+        return line;
+      } catch {
+      }
+    }
+    throw new Error("stdout did not contain JSON");
+  }
+}
+function boundOutput(text, collector) {
+  const textBytes = Buffer.byteLength(text, "utf8");
+  const textLines = countLines(text);
+  const truncated = collector.truncated || textBytes > DEFAULT_MAX_BYTES2 || textLines > DEFAULT_MAX_LINES2;
+  if (!truncated) return { text, truncated: false };
+  const notice = `[Output truncated: Codebase Memory produced ${collector.totalLines} lines (${formatSize2(collector.totalBytes)}); additional output was omitted.]`;
+  const separator = "\n";
+  const body = takeUtf8Prefix(
+    text,
+    Math.max(0, DEFAULT_MAX_BYTES2 - Buffer.byteLength(notice + separator, "utf8")),
+    Math.max(0, DEFAULT_MAX_LINES2 - 1)
+  );
+  return {
+    text: body ? `${body}${body.endsWith("\n") ? "" : separator}${notice}` : notice,
+    truncated: true
+  };
+}
+function cliFailure(tool, code, stderr) {
+  const diagnostic = stderr.text.trim();
+  const truncation = stderr.truncated ? "[earlier stderr omitted] " : "";
+  const suffix = diagnostic ? `: ${truncation}${diagnostic}` : "";
+  return new Error(`codebase-memory-mcp ${tool} exited with code ${code ?? "unknown"}${suffix}`);
+}
+function abortReason(signal) {
+  return signal.reason instanceof Error ? signal.reason : new DOMException("Codebase Memory tool call was aborted", "AbortError");
+}
+function takeUtf8Prefix(text, maxBytes, maxLines) {
+  let bytes = 0;
+  let lines = text ? 1 : 0;
+  let result = "";
+  for (const character of text) {
+    const nextLines = character === "\n" ? lines + 1 : lines;
+    const characterBytes = Buffer.byteLength(character, "utf8");
+    if (bytes + characterBytes > maxBytes || nextLines > maxLines) break;
+    result += character;
+    bytes += characterBytes;
+    lines = nextLines;
+  }
+  return result;
+}
+function takeUtf8Suffix(text, maxBytes) {
+  let bytes = 0;
+  const characters = Array.from(text);
+  let start = characters.length;
+  while (start > 0) {
+    const characterBytes = Buffer.byteLength(characters[start - 1], "utf8");
+    if (bytes + characterBytes > maxBytes) break;
+    bytes += characterBytes;
+    start--;
+  }
+  return characters.slice(start).join("");
+}
+function countOccurrences(text, character) {
+  let count = 0;
+  for (const value of text) if (value === character) count++;
+  return count;
+}
+function countLines(text) {
+  if (!text) return 0;
+  return countOccurrences(text, "\n") + (text.endsWith("\n") ? 0 : 1);
+}
+export {
+  cbmem as default
+};
+//# sourceMappingURL=index.ts.map