@remnic/plugin-pi 1.0.0

package/dist/index.js

@@ -0,0 +1,849 @@
+// openclaw-engram: Local-first memory plugin
+import {
+  REMNIC_PI_EXTENSION_DIR_NAME,
+  resolvePiAgentHome
+} from "./chunk-VGPUF4JQ.js";
+
+// src/index.ts
+import { Type } from "@sinclair/typebox";
+
+// src/config.ts
+import { existsSync, readFileSync } from "fs";
+import path from "path";
+import { expandTildePath } from "@remnic/core";
+var DEFAULT_CONFIG = {
+  remnicDaemonUrl: "http://127.0.0.1:4318",
+  recallMode: "auto",
+  recallTopK: 8,
+  recallBudgetChars: 12e3,
+  recallEnabled: true,
+  observeEnabled: true,
+  observeSkipExtraction: false,
+  compactionEnabled: true,
+  mcpToolsEnabled: true,
+  statusEnabled: true,
+  requestTimeoutMs: 5e3
+};
+function defaultConfigPath(env) {
+  return path.join(resolvePiAgentHome(env), "extensions", REMNIC_PI_EXTENSION_DIR_NAME, "remnic.config.json");
+}
+function coerceBoolean(value, fallback, fieldName) {
+  if (value === void 0 || value === null) return fallback;
+  if (typeof value === "boolean") return value;
+  if (typeof value === "string") {
+    const normalized = value.trim().toLowerCase();
+    if (["true", "1", "yes", "on"].includes(normalized)) return true;
+    if (["false", "0", "no", "off"].includes(normalized)) return false;
+  }
+  throw new Error(`Invalid boolean value for Remnic Pi config field ${fieldName}`);
+}
+function coercePositiveInt(value, fallback, max, fieldName) {
+  if (value === void 0 || value === null || value === "") return fallback;
+  let parsed;
+  if (typeof value === "number") {
+    parsed = value;
+  } else if (typeof value === "string") {
+    const trimmed = value.trim();
+    if (trimmed.length === 0) return fallback;
+    if (!/^[+-]?\d+$/.test(trimmed)) {
+      throw new Error(`Invalid numeric value for Remnic Pi config field ${fieldName}: expected an integer from 1 to ${max}`);
+    }
+    parsed = Number(trimmed);
+  } else {
+    throw new Error(`Invalid numeric value for Remnic Pi config field ${fieldName}: expected an integer from 1 to ${max}`);
+  }
+  if (!Number.isInteger(parsed) || parsed <= 0 || parsed > max) {
+    throw new Error(`Invalid numeric value for Remnic Pi config field ${fieldName}: expected an integer from 1 to ${max}`);
+  }
+  return parsed;
+}
+function coerceOptionalNonEmptyString(value, fieldName) {
+  if (value === void 0 || value === null) return void 0;
+  if (typeof value === "string" && value.trim().length > 0) return value.trim();
+  throw new Error(`Invalid string value for Remnic Pi config field ${fieldName}`);
+}
+function coerceOptionalString(value, fieldName) {
+  if (value === void 0 || value === null) return void 0;
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : void 0;
+  }
+  throw new Error(`Invalid string value for Remnic Pi config field ${fieldName}`);
+}
+function coerceOptionalHttpUrl(value, fieldName) {
+  if (value === void 0 || value === null) return void 0;
+  if (typeof value !== "string") {
+    throw new Error(`Invalid URL value for Remnic Pi config field ${fieldName}: expected an http or https URL`);
+  }
+  const trimmed = value.trim();
+  if (trimmed.length === 0) return void 0;
+  try {
+    const parsed = new URL(trimmed);
+    if (parsed.protocol === "http:" || parsed.protocol === "https:") return trimTrailingSlashes(trimmed);
+  } catch {
+  }
+  throw new Error(`Invalid URL value for Remnic Pi config field ${fieldName}: expected an http or https URL`);
+}
+function coerceRecallMode(value) {
+  if (value === void 0 || value === null || value === "") return DEFAULT_CONFIG.recallMode;
+  if (value === "minimal" || value === "full" || value === "graph_mode" || value === "no_recall" || value === "auto") {
+    return value;
+  }
+  throw new Error(`Invalid recallMode value for Remnic Pi config: ${JSON.stringify(value)}`);
+}
+function readConfigFile(configPath) {
+  if (!existsSync(configPath)) return {};
+  try {
+    const raw = readFileSync(configPath, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+      return parsed;
+    }
+    throw new Error("expected a JSON object");
+  } catch (err) {
+    const reason = err instanceof Error ? err.message : String(err);
+    throw new Error(`Failed to load Remnic Pi config at ${configPath}: ${reason}`);
+  }
+}
+function trimTrailingSlashes(value) {
+  let end = value.length;
+  while (end > 0 && value.charCodeAt(end - 1) === 47) end -= 1;
+  return value.slice(0, end);
+}
+function resolveConfigPath(options = {}) {
+  const env = options.env ?? process.env;
+  return expandTildePath(options.configPath || env.REMNIC_PI_CONFIG || defaultConfigPath(env));
+}
+function loadConfig(options = {}) {
+  const env = options.env ?? process.env;
+  const fileConfig = readConfigFile(resolveConfigPath(options));
+  const daemonUrl = coerceOptionalHttpUrl(fileConfig.remnicDaemonUrl, "remnicDaemonUrl") ?? coerceOptionalHttpUrl(env.REMNIC_DAEMON_URL, "REMNIC_DAEMON_URL") ?? DEFAULT_CONFIG.remnicDaemonUrl;
+  const authToken = coerceOptionalString(fileConfig.authToken, "authToken") ?? coerceOptionalString(env.REMNIC_PI_AUTH_TOKEN, "REMNIC_PI_AUTH_TOKEN");
+  const namespace = coerceOptionalNonEmptyString(fileConfig.namespace, "namespace");
+  return {
+    remnicDaemonUrl: daemonUrl,
+    authToken,
+    namespace,
+    recallMode: coerceRecallMode(fileConfig.recallMode),
+    recallTopK: coercePositiveInt(fileConfig.recallTopK, DEFAULT_CONFIG.recallTopK, 50, "recallTopK"),
+    recallBudgetChars: coercePositiveInt(fileConfig.recallBudgetChars, DEFAULT_CONFIG.recallBudgetChars, 64e3, "recallBudgetChars"),
+    recallEnabled: coerceBoolean(fileConfig.recallEnabled, DEFAULT_CONFIG.recallEnabled, "recallEnabled"),
+    observeEnabled: coerceBoolean(fileConfig.observeEnabled, DEFAULT_CONFIG.observeEnabled, "observeEnabled"),
+    observeSkipExtraction: coerceBoolean(fileConfig.observeSkipExtraction, DEFAULT_CONFIG.observeSkipExtraction, "observeSkipExtraction"),
+    compactionEnabled: coerceBoolean(fileConfig.compactionEnabled, DEFAULT_CONFIG.compactionEnabled, "compactionEnabled"),
+    mcpToolsEnabled: coerceBoolean(fileConfig.mcpToolsEnabled, DEFAULT_CONFIG.mcpToolsEnabled, "mcpToolsEnabled"),
+    statusEnabled: coerceBoolean(fileConfig.statusEnabled, DEFAULT_CONFIG.statusEnabled, "statusEnabled"),
+    requestTimeoutMs: coercePositiveInt(fileConfig.requestTimeoutMs, DEFAULT_CONFIG.requestTimeoutMs, 6e4, "requestTimeoutMs")
+  };
+}
+
+// src/client.ts
+var RemnicHttpError = class extends Error {
+  constructor(status, message) {
+    super(message);
+    this.status = status;
+  }
+  status;
+};
+var RemnicClient = class {
+  constructor(config) {
+    this.config = config;
+  }
+  config;
+  requestId = 0;
+  async health() {
+    return this.request("GET", "/engram/v1/health");
+  }
+  async recall(query, sessionKey, cwd) {
+    return this.request("POST", "/engram/v1/recall", {
+      query,
+      sessionKey,
+      cwd,
+      namespace: this.config.namespace,
+      topK: this.config.recallTopK,
+      mode: this.config.recallMode
+    });
+  }
+  async recallExplain(sessionKey) {
+    return this.request("POST", "/engram/v1/recall/explain", {
+      sessionKey,
+      namespace: this.config.namespace
+    });
+  }
+  async observe(sessionKey, cwd, messages) {
+    return this.request("POST", "/engram/v1/observe", {
+      sessionKey,
+      cwd,
+      namespace: this.config.namespace,
+      skipExtraction: this.config.observeSkipExtraction,
+      messages
+    });
+  }
+  async storeMemory(content, sessionKey) {
+    return this.request("POST", "/engram/v1/memories", {
+      content,
+      category: "fact",
+      sourceReason: "Captured from Pi via Remnic extension",
+      sessionKey,
+      namespace: this.config.namespace
+    });
+  }
+  async lcmSearch(query, sessionKey, limit = 10) {
+    return this.request("POST", "/engram/v1/lcm/search", {
+      query,
+      sessionKey,
+      namespace: this.config.namespace,
+      limit
+    });
+  }
+  async lcmCompactionFlush(sessionKey) {
+    return this.request("POST", "/engram/v1/lcm/compaction/flush", {
+      sessionKey,
+      namespace: this.config.namespace
+    });
+  }
+  async lcmCompactionRecord(sessionKey, tokensBefore, tokensAfter) {
+    return this.request("POST", "/engram/v1/lcm/compaction/record", {
+      sessionKey,
+      namespace: this.config.namespace,
+      tokensBefore,
+      tokensAfter
+    });
+  }
+  async contextCheckpoint(sessionKey, context) {
+    return this.mcpTool("remnic.context_checkpoint", {
+      sessionKey,
+      context,
+      namespace: this.config.namespace
+    });
+  }
+  async mcpListTools() {
+    const result = await this.mcpRequest("tools/list", {});
+    const tools = result.tools;
+    return Array.isArray(tools) ? tools.filter(isMcpTool) : [];
+  }
+  async mcpTool(name, args) {
+    return this.mcpRequest("tools/call", {
+      name,
+      arguments: args
+    });
+  }
+  async request(method, pathname, body) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), this.config.requestTimeoutMs);
+    try {
+      const response = await fetch(`${this.config.remnicDaemonUrl}${pathname}`, {
+        method,
+        headers: {
+          ...body === void 0 ? {} : { "Content-Type": "application/json" },
+          ...this.config.authToken ? { Authorization: `Bearer ${this.config.authToken}` } : {},
+          "X-Engram-Client-Id": "pi"
+        },
+        body: body === void 0 ? void 0 : JSON.stringify(body),
+        signal: controller.signal
+      });
+      const text = await response.text();
+      const payload = text ? JSON.parse(text) : {};
+      if (!response.ok) {
+        throw new RemnicHttpError(response.status, typeof payload?.error === "string" ? payload.error : response.statusText);
+      }
+      return payload;
+    } finally {
+      clearTimeout(timeout);
+    }
+  }
+  async mcpRequest(method, params) {
+    this.requestId += 1;
+    const payload = await this.request("POST", "/mcp", {
+      jsonrpc: "2.0",
+      id: this.requestId,
+      method,
+      params
+    });
+    if (payload.error) {
+      throw new Error(JSON.stringify(payload.error));
+    }
+    return payload.result && typeof payload.result === "object" ? payload.result : payload;
+  }
+};
+function isMcpTool(value) {
+  return !!value && typeof value === "object" && typeof value.name === "string";
+}
+
+// src/messages.ts
+import { createHash } from "crypto";
+import { parsePiMessageParts } from "@remnic/core";
+function sessionKeyFromContext(ctx) {
+  const id = ctx.sessionManager?.getSessionId?.();
+  return id && id.trim().length > 0 ? `pi:${id}` : "pi:default";
+}
+function textFromMessage(message) {
+  if (!message || typeof message !== "object") return "";
+  const obj = message;
+  const role = typeof obj.role === "string" ? obj.role : "message";
+  if (role === "bashExecution") {
+    const command = typeof obj.command === "string" ? obj.command : "";
+    const output = typeof obj.output === "string" ? obj.output : "";
+    return [`Ran ${command}`, output].filter(Boolean).join("\n");
+  }
+  return textFromContent(obj.content).trim();
+}
+function latestUserQuery(messages) {
+  for (let index = messages.length - 1; index >= 0; index--) {
+    const message = messages[index];
+    if (isExcludedFromContext(message)) continue;
+    if (message?.role === "user") {
+      const text = textFromMessage(message);
+      if (text.length > 0) return text;
+    }
+  }
+  return "";
+}
+function toObserveMessage(message) {
+  if (!message || typeof message !== "object") return null;
+  const obj = message;
+  if (isExcludedFromContext(obj)) return null;
+  const role = obj.role === "user" || obj.role === "bashExecution" ? "user" : "assistant";
+  const content = textFromMessage(obj);
+  if (content.length === 0) return null;
+  return {
+    role,
+    content,
+    sourceFormat: "pi",
+    rawContent: obj,
+    parts: partsFromMessage(obj, content)
+  };
+}
+function hashObservedMessage(message, sessionKey = "", identity = "content") {
+  return createHash("sha256").update(sessionKey).update("\0").update(message.role).update("\0").update(identity).update("\0").update(message.content).digest("hex");
+}
+function observedMessageDedupeKey(message, sessionKey = "") {
+  const identity = stableObservedMessageIdentity(message.rawContent);
+  return identity ? hashObservedMessage(message, sessionKey, identity) : null;
+}
+function summarizeMessages(messages, maxChars) {
+  const chunks = [];
+  let used = 0;
+  for (const message of messages) {
+    if (isExcludedFromContext(message)) continue;
+    const text = textFromMessage(message);
+    if (!text) continue;
+    const role = typeof message?.role === "string" ? message.role : "message";
+    const line = `[${role}] ${text}`;
+    const separatorLength = chunks.length > 0 ? 2 : 0;
+    const remaining = maxChars - used - separatorLength;
+    if (remaining <= 0) break;
+    const clipped = line.length > remaining ? line.slice(0, remaining) : line;
+    if (clipped.length > 0) chunks.push(clipped);
+    used += separatorLength + clipped.length;
+    if (used >= maxChars) break;
+  }
+  return chunks.join("\n\n");
+}
+function isExcludedFromContext(message) {
+  return !!message && typeof message === "object" && message.excludeFromContext === true;
+}
+function textFromContent(content) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  const chunks = [];
+  for (const block of content) {
+    if (!block || typeof block !== "object") continue;
+    const obj = block;
+    if (obj.type === "text" && typeof obj.text === "string") chunks.push(obj.text);
+    if (obj.type === "toolCall" && typeof obj.name === "string") {
+      chunks.push(`Tool ${obj.name} called with ${JSON.stringify(obj.arguments ?? {})}`);
+    }
+  }
+  return chunks.join("\n");
+}
+function partsFromMessage(message, renderedContent) {
+  return parsePiMessageParts(message, {
+    renderedContent,
+    allowRenderedFallback: true
+  }).map(toObserveMessagePart);
+}
+function toObserveMessagePart(part) {
+  return {
+    ordinal: part.ordinal ?? void 0,
+    kind: part.kind,
+    payload: part.payload,
+    toolName: part.toolName ?? part.tool_name ?? void 0,
+    filePath: part.filePath ?? part.file_path ?? void 0,
+    createdAt: part.createdAt ?? part.created_at ?? void 0
+  };
+}
+function stableObservedMessageIdentity(rawContent) {
+  if (rawContent && typeof rawContent === "object") {
+    const obj = rawContent;
+    const fields = [
+      "id",
+      "entryId",
+      "entry_id",
+      "messageId",
+      "message_id",
+      "turnId",
+      "turn_id",
+      "timestamp",
+      "createdAt",
+      "created_at"
+    ];
+    for (const field of fields) {
+      const value = obj[field];
+      if (typeof value === "string" && value.length > 0) return `${field}:${value}`;
+      if (typeof value === "number" && Number.isFinite(value)) return `${field}:${value}`;
+    }
+  }
+  return null;
+}
+
+// src/index.ts
+var STATE_CUSTOM_TYPE = "remnic_state";
+var MAX_OBSERVED_HASHES = 2e3;
+var MAX_SESSION_STATES = 50;
+var MAX_CONTEXT_CHARS = 12e3;
+var TRUNCATION_NOTICE = "\n\n[Remnic context truncated]";
+function createRemnicPiExtension(options = {}) {
+  const config = options.config ?? loadConfig(options);
+  const client = new RemnicClient(config);
+  const sessionStates = /* @__PURE__ */ new Map();
+  return async function remnicPiExtension2(pi) {
+    pi.on("session_start", async (_event, ctx) => {
+      const { state } = getSessionState(ctx, sessionStates);
+      restoreObservedState(ctx, state.observedHashes);
+      if (!config.statusEnabled) return;
+      await setStatus(ctx, client, config);
+    });
+    pi.on("context", async (event, ctx) => {
+      if (!config.recallEnabled || !config.authToken) return;
+      const query = latestUserQuery(Array.isArray(event.messages) ? event.messages : []);
+      if (!query) return;
+      const sessionKey = sessionKeyFromContext(ctx);
+      const { state } = getSessionState(ctx, sessionStates);
+      if (query === state.lastInjectedQuery) return;
+      try {
+        const recalled = await client.recall(query, sessionKey, ctx.cwd);
+        const context = trimContext(recalled.context ?? "", config.recallBudgetChars);
+        if (!context) return;
+        state.lastInjectedQuery = query;
+        return {
+          messages: [
+            {
+              role: "user",
+              content: [{ type: "text", text: `Remnic recalled context for this turn:
+
+${context}` }],
+              timestamp: Date.now()
+            },
+            ...event.messages
+          ]
+        };
+      } catch (err) {
+        notify(ctx, `Remnic recall unavailable: ${errorMessage(err)}`, "warning");
+      }
+    });
+    pi.on("message_end", async (event, ctx) => {
+      if (!config.observeEnabled || !isUserMessage(event.message)) return;
+      const { state } = getSessionState(ctx, sessionStates);
+      await observeMessages(ctx, client, [event.message], state.observedHashes, state.liveObservedReplayKeys);
+    });
+    pi.on("turn_end", async (event, ctx) => {
+      if (!config.observeEnabled) return;
+      const messages = [event.message, ...Array.isArray(event.toolResults) ? event.toolResults : []];
+      const { state } = getSessionState(ctx, sessionStates);
+      await observeMessages(ctx, client, messages, state.observedHashes, state.liveObservedReplayKeys);
+    });
+    pi.on("session_shutdown", async (_event, ctx) => {
+      const { sessionKey, state } = getSessionState(ctx, sessionStates);
+      if (config.observeEnabled) {
+        const branch = safeBranch(ctx);
+        const branchMessages = branchMessagesWithEntryIdentity(branch);
+        const unobservedBranchMessages = skipLiveObservedReplayMessages(ctx, branchMessages, state.liveObservedReplayKeys);
+        if (unobservedBranchMessages.length > 0) await observeMessages(ctx, client, unobservedBranchMessages, state.observedHashes);
+      }
+      persistObservedState(pi, state.observedHashes);
+      sessionStates.delete(sessionKey);
+    });
+    pi.on("session_before_compact", async (event, ctx) => {
+      if (!config.compactionEnabled || !config.authToken) return;
+      const sessionKey = sessionKeyFromContext(ctx);
+      const preparation = event.preparation ?? {};
+      try {
+        await client.lcmCompactionFlush(sessionKey);
+      } catch (err) {
+        notify(ctx, `Remnic LCM flush failed: ${errorMessage(err)}`, "warning");
+        return;
+      }
+      const summary = buildCompactionSummary(preparation);
+      if (!summary.trim()) return;
+      void client.contextCheckpoint(sessionKey, summary).catch(() => void 0);
+      const tokensBefore = finiteTokenCount(preparation.tokensBefore);
+      const tokensAfter = finiteTokenCount(preparation.tokensAfter);
+      if (tokensBefore !== null && tokensAfter !== null) {
+        void client.lcmCompactionRecord(sessionKey, tokensBefore, tokensAfter).catch(() => void 0);
+      }
+      const details = fileDetailsFromPreparation(preparation);
+      return {
+        compaction: {
+          summary,
+          firstKeptEntryId: preparation.firstKeptEntryId,
+          tokensBefore: preparation.tokensBefore,
+          details: {
+            ...details,
+            remnic: { version: 1, source: "pi" }
+          }
+        }
+      };
+    });
+    registerCommands(pi, client, config);
+    if (config.mcpToolsEnabled && config.authToken) {
+      await registerMcpTools(pi, client, config);
+    }
+  };
+}
+async function remnicPiExtension(pi) {
+  await createRemnicPiExtension()(pi);
+}
+function registerCommands(pi, client, config) {
+  pi.registerCommand("remnic-status", {
+    description: "Check Remnic daemon status",
+    handler: commandHandler(async (_args, ctx) => {
+      const health = await client.health();
+      notify(ctx, `Remnic ${health.ok ? "healthy" : "unhealthy"} at ${config.remnicDaemonUrl}`, health.ok ? "success" : "warning");
+    })
+  });
+  pi.registerCommand("remnic-recall", {
+    description: "Recall Remnic context for a query",
+    handler: commandHandler(async (args, ctx) => {
+      const query = args.trim();
+      if (!query) {
+        notify(ctx, "Usage: /remnic-recall <query>", "warning");
+        return;
+      }
+      const result = await client.recall(query, sessionKeyFromContext(ctx), ctx.cwd);
+      notify(ctx, trimContext(result.context ?? "(no Remnic context)", MAX_CONTEXT_CHARS), "info");
+    })
+  });
+  pi.registerCommand("remnic-remember", {
+    description: "Store a Remnic memory",
+    handler: commandHandler(async (args, ctx) => {
+      const content = args.trim();
+      if (!content) {
+        notify(ctx, "Usage: /remnic-remember <memory>", "warning");
+        return;
+      }
+      await client.storeMemory(content, sessionKeyFromContext(ctx));
+      notify(ctx, "Stored Remnic memory", "success");
+    })
+  });
+  pi.registerCommand("remnic-lcm-search", {
+    description: "Search Remnic LCM archived Pi context",
+    handler: commandHandler(async (args, ctx) => {
+      const query = args.trim();
+      if (!query) {
+        notify(ctx, "Usage: /remnic-lcm-search <query>", "warning");
+        return;
+      }
+      const result = await client.lcmSearch(query, sessionKeyFromContext(ctx));
+      notify(ctx, JSON.stringify(result, null, 2), "info");
+    })
+  });
+  pi.registerCommand("remnic-why", {
+    description: "Explain the last Remnic recall",
+    handler: commandHandler(async (_args, ctx) => {
+      const result = await client.recallExplain(sessionKeyFromContext(ctx));
+      notify(ctx, JSON.stringify(result, null, 2), "info");
+    })
+  });
+  pi.registerCommand("remnic-compact", {
+    description: "Trigger Pi compaction with Remnic LCM coordination",
+    handler: commandHandler(async (_args, ctx) => {
+      ctx.compact?.();
+      notify(ctx, "Compaction requested", "info");
+    })
+  });
+}
+function commandHandler(handler) {
+  return async (args, ctx) => {
+    try {
+      await handler(args, ctx);
+    } catch (err) {
+      notify(ctx, `Remnic command failed: ${errorMessage(err)}`, "warning");
+    }
+  };
+}
+async function registerMcpTools(pi, client, config) {
+  let tools = [];
+  try {
+    tools = await client.mcpListTools();
+  } catch {
+    return;
+  }
+  for (const tool of tools) {
+    if (!tool.name.startsWith("remnic.")) continue;
+    const piToolName = tool.name.replace(/^remnic\./, "remnic_").replace(/[^a-zA-Z0-9_]/g, "_");
+    pi.registerTool({
+      name: piToolName,
+      label: tool.name,
+      description: tool.description ?? `Call ${tool.name}`,
+      parameters: toPiToolParametersSchema(tool.inputSchema),
+      async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+        const sessionKey = sessionKeyFromContext(ctx);
+        const {
+          sessionKey: _ignoredSessionKey,
+          namespace: _ignoredNamespace,
+          cwd: _ignoredCwd,
+          ...safeParams
+        } = params ?? {};
+        const result = await client.mcpTool(tool.name, {
+          ...safeParams,
+          sessionKey,
+          namespace: config.namespace,
+          cwd: ctx.cwd
+        });
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+          details: result
+        };
+      }
+    });
+  }
+}
+function toPiToolParametersSchema(inputSchema) {
+  return Type.Unsafe(stripSessionOwnedSchemaFields(inputSchema));
+}
+function stripSessionOwnedSchemaFields(inputSchema) {
+  if (!isRecord(inputSchema)) {
+    return { type: "object", properties: {}, additionalProperties: true };
+  }
+  const schema = { ...inputSchema };
+  const properties = isRecord(inputSchema.properties) ? { ...inputSchema.properties } : {};
+  delete properties.sessionKey;
+  delete properties.namespace;
+  delete properties.cwd;
+  schema.properties = properties;
+  if (Array.isArray(inputSchema.required)) {
+    schema.required = inputSchema.required.filter(
+      (field) => field !== "sessionKey" && field !== "namespace" && field !== "cwd"
+    );
+  }
+  return schema;
+}
+function isRecord(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function isUserMessage(message) {
+  return isRecord(message) && message.role === "user";
+}
+function getSessionState(ctx, states) {
+  const sessionKey = sessionKeyFromContext(ctx);
+  let state = states.get(sessionKey);
+  if (!state) {
+    state = {
+      observedHashes: /* @__PURE__ */ new Set(),
+      liveObservedReplayKeys: /* @__PURE__ */ new Map(),
+      lastInjectedQuery: ""
+    };
+    states.set(sessionKey, state);
+    pruneSessionStates(states);
+  }
+  return { sessionKey, state };
+}
+function pruneSessionStates(states) {
+  while (states.size > MAX_SESSION_STATES) {
+    const oldest = states.keys().next().value;
+    if (typeof oldest !== "string") return;
+    states.delete(oldest);
+  }
+}
+async function observeMessages(ctx, client, rawMessages, observedHashes, liveObservedReplayKeys) {
+  const sessionKey = sessionKeyFromContext(ctx);
+  const messages = [];
+  const pendingHashes = /* @__PURE__ */ new Set();
+  for (const raw of rawMessages) {
+    const message = toObserveMessage(raw);
+    if (!message) continue;
+    const hash = observedMessageDedupeKey(message, sessionKey);
+    if (hash && (observedHashes.has(hash) || pendingHashes.has(hash))) continue;
+    if (hash) pendingHashes.add(hash);
+    messages.push(message);
+  }
+  if (messages.length === 0) return;
+  try {
+    await client.observe(sessionKey, ctx.cwd, messages);
+    for (const hash of pendingHashes) rememberObservedHash(observedHashes, hash);
+    if (liveObservedReplayKeys) {
+      for (const message of messages) {
+        rememberLiveObservedReplayKey(liveObservedReplayKeys, liveReplayKey(message, sessionKey));
+      }
+    }
+  } catch (err) {
+    notify(ctx, `Remnic observe failed: ${errorMessage(err)}`, "warning");
+  }
+}
+function buildCompactionSummary(preparation) {
+  const previousSummary = typeof preparation.previousSummary === "string" ? preparation.previousSummary.trim() : "";
+  const messages = [
+    ...Array.isArray(preparation.messagesToSummarize) ? preparation.messagesToSummarize : [],
+    ...Array.isArray(preparation.turnPrefixMessages) ? preparation.turnPrefixMessages : []
+  ];
+  const transcript = summarizeMessages(messages, 24e3);
+  const details = fileDetailsFromPreparation(preparation);
+  if (!previousSummary && !transcript && details.readFiles.length === 0 && details.modifiedFiles.length === 0) {
+    return "";
+  }
+  const sections = [
+    "## Remnic Pi Context Checkpoint",
+    "",
+    "This checkpoint was created by Remnic during Pi context compaction."
+  ];
+  if (previousSummary) sections.push("", "## Previous Summary", previousSummary);
+  if (transcript) sections.push("", "## Conversation Excerpt", transcript);
+  if (details.readFiles.length > 0) sections.push("", "<read-files>", ...details.readFiles, "</read-files>");
+  if (details.modifiedFiles.length > 0) sections.push("", "<modified-files>", ...details.modifiedFiles, "</modified-files>");
+  return sections.join("\n");
+}
+function fileDetailsFromPreparation(preparation) {
+  const fileOps = preparation?.fileOps;
+  const read = fileOps?.read instanceof Set ? Array.from(fileOps.read).filter(isString) : [];
+  const edited = fileOps?.edited instanceof Set ? Array.from(fileOps.edited).filter(isString) : [];
+  const written = fileOps?.written instanceof Set ? Array.from(fileOps.written).filter(isString) : [];
+  const modified = /* @__PURE__ */ new Set([...edited, ...written]);
+  return {
+    readFiles: read.filter((file) => !modified.has(file)).sort(),
+    modifiedFiles: Array.from(modified).sort()
+  };
+}
+function restoreObservedState(ctx, observedHashes) {
+  for (const entry of safeEntries(ctx)) {
+    if (entry?.type !== "custom" || entry.customType !== STATE_CUSTOM_TYPE) continue;
+    const hashes = entry.data?.observedHashes;
+    if (Array.isArray(hashes)) {
+      for (const hash of hashes) {
+        if (typeof hash === "string") rememberObservedHash(observedHashes, hash);
+      }
+    }
+  }
+}
+function rememberObservedHash(observedHashes, hash) {
+  if (observedHashes.has(hash)) return;
+  while (observedHashes.size >= MAX_OBSERVED_HASHES) {
+    const oldest = observedHashes.keys().next().value;
+    if (typeof oldest !== "string") break;
+    observedHashes.delete(oldest);
+  }
+  observedHashes.add(hash);
+}
+function rememberLiveObservedReplayKey(liveObservedReplayKeys, key) {
+  liveObservedReplayKeys.set(key, (liveObservedReplayKeys.get(key) ?? 0) + 1);
+}
+function consumeLiveObservedReplayKey(liveObservedReplayKeys, key) {
+  const count = liveObservedReplayKeys.get(key) ?? 0;
+  if (count <= 0) return false;
+  if (count === 1) liveObservedReplayKeys.delete(key);
+  else liveObservedReplayKeys.set(key, count - 1);
+  return true;
+}
+function skipLiveObservedReplayMessages(ctx, rawMessages, liveObservedReplayKeys) {
+  if (liveObservedReplayKeys.size === 0) return rawMessages;
+  const sessionKey = sessionKeyFromContext(ctx);
+  const unobserved = [];
+  for (const raw of rawMessages) {
+    const message = toObserveMessage(raw);
+    if (message && consumeLiveObservedReplayKey(liveObservedReplayKeys, liveReplayKey(message, sessionKey))) {
+      continue;
+    }
+    unobserved.push(raw);
+  }
+  return unobserved;
+}
+function liveReplayKey(message, sessionKey) {
+  return hashObservedMessage(message, sessionKey, "live-replay");
+}
+function persistObservedState(pi, observedHashes) {
+  const observed = Array.from(observedHashes).slice(-MAX_OBSERVED_HASHES);
+  pi.appendEntry(STATE_CUSTOM_TYPE, {
+    observedHashes: observed,
+    recordedAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+}
+async function setStatus(ctx, client, config) {
+  try {
+    await client.health();
+    ctx.ui?.setStatus?.("remnic", `Remnic ${config.namespace ? `(${config.namespace})` : "ready"}`);
+  } catch {
+    ctx.ui?.setStatus?.("remnic", "Remnic offline");
+  }
+}
+function safeEntries(ctx) {
+  try {
+    const entries = ctx.sessionManager?.getEntries?.();
+    return Array.isArray(entries) ? entries : [];
+  } catch {
+    return [];
+  }
+}
+function safeBranch(ctx) {
+  try {
+    const branch = ctx.sessionManager?.getBranch?.();
+    return Array.isArray(branch) ? branch : [];
+  } catch {
+    return [];
+  }
+}
+function branchMessagesWithEntryIdentity(branch) {
+  const messages = [];
+  for (const entry of branch) {
+    const message = messageWithEntryIdentity(entry);
+    if (message) messages.push(message);
+  }
+  return messages;
+}
+function messageWithEntryIdentity(entry) {
+  const message = entry?.message;
+  if (!message || typeof message !== "object" || Array.isArray(message)) return message ?? null;
+  const source = isRecord(entry) ? entry : {};
+  const enriched = { ...message };
+  assignMissingIdentity(enriched, "entryId", source.id ?? source.entryId ?? source.entry_id);
+  assignMissingIdentity(enriched, "timestamp", source.timestamp);
+  assignMissingIdentity(enriched, "createdAt", source.createdAt ?? source.created_at);
+  return enriched;
+}
+function assignMissingIdentity(target, field, value) {
+  if (target[field] !== void 0) return;
+  if (typeof value === "string" && value.length > 0) {
+    target[field] = value;
+    return;
+  }
+  if (typeof value === "number" && Number.isFinite(value)) {
+    target[field] = value;
+  }
+}
+function trimContext(value, budget) {
+  if (value.length <= budget) return value;
+  if (budget <= TRUNCATION_NOTICE.length) return TRUNCATION_NOTICE.slice(0, budget);
+  return `${value.slice(0, budget - TRUNCATION_NOTICE.length)}${TRUNCATION_NOTICE}`;
+}
+function notify(ctx, message, level) {
+  if (ctx?.hasUI === false) return;
+  ctx?.ui?.notify?.(message, level);
+}
+function errorMessage(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+function finiteTokenCount(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : null;
+}
+function isString(value) {
+  return typeof value === "string";
+}
+export {
+  buildCompactionSummary,
+  createRemnicPiExtension,
+  remnicPiExtension as default,
+  observeMessages,
+  stripSessionOwnedSchemaFields,
+  textFromMessage,
+  toPiToolParametersSchema
+};
+//# sourceMappingURL=index.js.map