codesesh 0.7.2 → 0.9.0

package/dist/{chunk-XANARSZG.js → chunk-LXHUIQZI.js}

@@ -31,18 +31,20 @@ import {
 import { join as join7, basename as basename5 } from "path";
 import { existsSync as existsSync8, readdirSync as readdirSync4, readFileSync as readFileSync6, statSync as statSync5 } from "fs";
 import { join as join8, normalize } from "path";
+import { existsSync as existsSync9, readFileSync as readFileSync7, readdirSync as readdirSync5, statSync as statSync6 } from "fs";
+import { basename as basename6, join as join9 } from "path";
 import { availableParallelism } from "os";
 import { Worker } from "worker_threads";
-import { existsSync as existsSync9, readFileSync as readFileSync7 } from "fs";
+import { existsSync as existsSync10, readFileSync as readFileSync8 } from "fs";
 import { spawnSync } from "child_process";
 import * as os from "os";
 import * as path from "path";
 import { resolve, sep } from "path";
-import { existsSync as existsSync10, rmSync, unlinkSync } from "fs";
-import { join as join9 } from "path";
+import { existsSync as existsSync11, rmSync, unlinkSync } from "fs";
+import { join as join10 } from "path";
 import { homedir as homedir4 } from "os";
 import { homedir as homedir5, platform as platform2 } from "os";
-import { join as join10 } from "path";
+import { join as join11 } from "path";
 var registrations = [];
 function registerAgent(reg) {
   registrations.push(reg);
@@ -112,7 +114,8 @@ function resolveProviderRoots() {
     codexRoot: envPath("CODEX_HOME") ?? join(home, ".codex"),
     claudeRoot: envPath("CLAUDE_CONFIG_DIR") ?? join(home, ".claude"),
     kimiRoot: envPath("KIMI_SHARE_DIR") ?? join(home, ".kimi"),
-    opencodeRoot: join(getDataHome(), "opencode")
+    opencodeRoot: join(getDataHome(), "opencode"),
+    piRoot: envPath("PI_HOME") ?? join(home, ".pi")
   };
 }
 function getCursorDataPath() {
@@ -4664,6 +4667,589 @@ var CursorAgent = class extends BaseAgent {
     }
   }
 };
+var HEAD_INDEX_VERSION3 = "pi-head-v1";
+var PARSER_VERSION2 = "pi-parser-v1";
+function parseTimestampMs3(value) {
+  if (typeof value === "number") return Number.isFinite(value) ? value : 0;
+  const text = String(value ?? "").trim();
+  if (!text) return 0;
+  const ts = Date.parse(text);
+  return Number.isNaN(ts) ? 0 : ts;
+}
+function extractSessionIdFromFilename(filePath) {
+  const stem = basename6(filePath, ".jsonl");
+  const underscore = stem.indexOf("_");
+  return underscore >= 0 ? stem.slice(underscore + 1) || stem : stem;
+}
+function isObject(value) {
+  return typeof value === "object" && value !== null;
+}
+function contentToText(content) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  return content.map((item) => {
+    if (!isObject(item)) return "";
+    if (item["type"] === "text") return String(item["text"] ?? "");
+    if (item["type"] === "image") return "[image]";
+    return "";
+  }).filter(Boolean).join("\n");
+}
+function normalizeTextParts(content, timestampMs) {
+  const text = cleanInternalText(contentToText(content));
+  return text ? [{ type: "text", text, time_created: timestampMs }] : [];
+}
+function buildMessage(params) {
+  return {
+    id: params.id,
+    role: params.role,
+    agent: params.agent,
+    time_created: params.timestampMs,
+    provider: params.provider,
+    model: params.model,
+    tokens: params.tokens,
+    cost: params.cost,
+    cost_source: params.costSource,
+    parts: params.parts
+  };
+}
+function getEntryTimestamp(entry) {
+  return parseTimestampMs3(entry["timestamp"]);
+}
+function chooseLeafEntry(entries) {
+  for (let index = entries.length - 1; index >= 0; index -= 1) {
+    if (typeof entries[index]?.["id"] === "string") return entries[index];
+  }
+  return null;
+}
+function buildCurrentPathEntries(entries) {
+  const byId = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const id = entry["id"];
+    if (typeof id === "string" && id) byId.set(id, entry);
+  }
+  const leaf = chooseLeafEntry(entries);
+  if (!leaf) return [];
+  const path2 = [];
+  const seen = /* @__PURE__ */ new Set();
+  let current = leaf;
+  while (current) {
+    const id = String(current["id"] ?? "");
+    if (!id || seen.has(id)) break;
+    seen.add(id);
+    path2.push(current);
+    const parentId = current["parentId"];
+    current = typeof parentId === "string" ? byId.get(parentId) : void 0;
+  }
+  return path2.reverse();
+}
+var PiAgent = class extends BaseAgent {
+  name = "pi";
+  displayName = "Pi";
+  basePath = null;
+  sessionMetaMap = /* @__PURE__ */ new Map();
+  findBasePath() {
+    const roots = resolveProviderRoots();
+    return firstExisting(join9(roots.piRoot, "agent", "sessions"), "data/pi");
+  }
+  isAvailable() {
+    this.basePath = this.findBasePath();
+    if (!this.basePath) return false;
+    return this.listSessionFiles().length > 0;
+  }
+  scan(options) {
+    if (!this.basePath) return [];
+    const scanMarker = perf.start("pi:scan");
+    const files = this.listSessionFiles(options);
+    options?.onProgress?.({ total: files.length, processed: 0, sessions: 0 });
+    const heads = [];
+    let processed = 0;
+    for (const file of files) {
+      try {
+        const head = getParsedSession(this.parseSessionHeadResult(file));
+        if (head) {
+          heads.push(head);
+          this.sessionMetaMap.set(head.id, this.buildSessionMeta(head, file));
+        }
+      } catch {
+      } finally {
+        processed += 1;
+        options?.onProgress?.({ total: files.length, processed, sessions: heads.length });
+      }
+    }
+    perf.end(scanMarker);
+    return heads;
+  }
+  listSessionSources() {
+    if (!this.basePath) return [];
+    return this.listSessionFiles().map((file) => ({
+      sessionId: extractSessionIdFromFilename(file),
+      sourcePath: file,
+      fingerprint: this.sourceFingerprint(file)
+    }));
+  }
+  scanSessionSource(sourcePath) {
+    const head = getParsedSession(this.parseSessionHeadResult(sourcePath));
+    if (head) {
+      this.sessionMetaMap.set(head.id, this.buildSessionMeta(head, sourcePath));
+    }
+    return head;
+  }
+  getSessionMetaMap() {
+    return this.sessionMetaMap;
+  }
+  setSessionMetaMap(meta) {
+    this.sessionMetaMap = meta;
+  }
+  checkForChanges(_sinceTimestamp, cachedSessions) {
+    if (!this.basePath) return { hasChanges: false, timestamp: Date.now() };
+    const currentFiles = this.listSessionFiles();
+    const currentIds = new Set(currentFiles.map((file) => extractSessionIdFromFilename(file)));
+    const cachedIds = new Set(cachedSessions.map((session) => session.id));
+    const changedIds = /* @__PURE__ */ new Set();
+    for (const session of cachedSessions) {
+      if (!currentIds.has(session.id)) {
+        changedIds.add(session.id);
+        continue;
+      }
+      const meta = this.sessionMetaMap.get(session.id);
+      if (!meta) {
+        changedIds.add(session.id);
+        continue;
+      }
+      try {
+        if (this.hasMetaChanged(meta)) changedIds.add(session.id);
+      } catch {
+        changedIds.add(session.id);
+      }
+    }
+    const hasAddedSessions = currentFiles.some(
+      (file) => !cachedIds.has(extractSessionIdFromFilename(file))
+    );
+    return {
+      hasChanges: changedIds.size > 0 || hasAddedSessions,
+      changedIds: [...changedIds],
+      timestamp: Date.now()
+    };
+  }
+  incrementalScan(cachedSessions, changedIds) {
+    if (!this.basePath) return cachedSessions;
+    const sessionMap = new Map(cachedSessions.map((session) => [session.id, session]));
+    const changedSet = new Set(changedIds);
+    const currentFiles = this.listSessionFiles();
+    const currentIds = new Set(currentFiles.map((file) => extractSessionIdFromFilename(file)));
+    for (const session of cachedSessions) {
+      if (!currentIds.has(session.id)) {
+        sessionMap.delete(session.id);
+        this.sessionMetaMap.delete(session.id);
+      }
+    }
+    for (const file of currentFiles) {
+      try {
+        const sessionId = extractSessionIdFromFilename(file);
+        if (!changedSet.has(sessionId) && sessionMap.has(sessionId)) continue;
+        const head = getParsedSession(this.parseSessionHeadResult(file));
+        if (head) {
+          sessionMap.set(head.id, head);
+          this.sessionMetaMap.set(head.id, this.buildSessionMeta(head, file));
+        }
+      } catch {
+      }
+    }
+    return [...sessionMap.values()];
+  }
+  getSessionData(sessionId) {
+    const meta = this.sessionMetaMap.get(sessionId);
+    if (!meta) throw new Error(`Session not found: ${sessionId}`);
+    if (!existsSync9(meta.sourcePath)) throw new Error(`Session file missing: ${meta.sourcePath}`);
+    const parsed2 = this.parsePiFile(meta.sourcePath);
+    const state = this.convertEntries(parsed2.pathEntries);
+    const cleanedMessages = cleanParsedMessages(state.messages);
+    return {
+      id: meta.id,
+      title: meta.title,
+      slug: `pi/${meta.id}`,
+      directory: meta.directory,
+      time_created: meta.createdAt,
+      time_updated: meta.updatedAt,
+      stats: {
+        message_count: cleanedMessages.length,
+        total_input_tokens: state.totalInputTokens,
+        total_output_tokens: state.totalOutputTokens,
+        total_cache_read_tokens: state.totalCacheReadTokens || void 0,
+        total_cache_create_tokens: state.totalCacheCreateTokens || void 0,
+        total_cost: state.totalCost,
+        cost_source: state.totalCost > 0 ? "recorded" : void 0
+      },
+      messages: cleanedMessages
+    };
+  }
+  listSessionFiles(options) {
+    if (!this.basePath) return [];
+    return this.walkJsonlFiles(this.basePath, options);
+  }
+  walkJsonlFiles(dir, options) {
+    const files = [];
+    try {
+      for (const entry of readdirSync5(dir, { withFileTypes: true })) {
+        const fullPath = join9(dir, entry.name);
+        if (entry.isDirectory()) {
+          files.push(...this.walkJsonlFiles(fullPath, options));
+          continue;
+        }
+        if (!entry.isFile() || !entry.name.endsWith(".jsonl")) continue;
+        if (!matchesScanWindow(statSync6(fullPath).mtimeMs, options)) continue;
+        files.push(fullPath);
+      }
+    } catch {
+    }
+    return files;
+  }
+  buildSessionMeta(head, file) {
+    return {
+      id: head.id,
+      title: head.title,
+      sourcePath: file,
+      sourceFingerprint: this.sourceFingerprint(file),
+      sourceMtimeMs: statSync6(file).mtimeMs,
+      headIndexVersion: HEAD_INDEX_VERSION3,
+      parserVersion: PARSER_VERSION2,
+      directory: head.directory,
+      messageCount: head.stats.message_count,
+      createdAt: head.time_created,
+      updatedAt: head.time_updated ?? head.time_created
+    };
+  }
+  hasMetaChanged(meta) {
+    if (meta.headIndexVersion !== HEAD_INDEX_VERSION3) return true;
+    if (meta.parserVersion !== PARSER_VERSION2) return true;
+    return statSync6(meta.sourcePath).mtimeMs !== meta.sourceMtimeMs;
+  }
+  sourceFingerprint(file) {
+    const stat = statSync6(file);
+    return JSON.stringify([HEAD_INDEX_VERSION3, PARSER_VERSION2, stat.mtimeMs, stat.size]);
+  }
+  parseSessionHeadResult(filePath) {
+    const parsed2 = this.parsePiFile(filePath);
+    const state = this.convertEntries(parsed2.pathEntries);
+    const messageCount = state.messages.length;
+    if (messageCount === 0) return filteredSession("no visible messages");
+    const modelUsage = Object.keys(state.modelUsage).length > 0 ? state.modelUsage : void 0;
+    return parsedSession({
+      id: parsed2.sessionId,
+      slug: `pi/${parsed2.sessionId}`,
+      title: parsed2.title,
+      directory: parsed2.directory,
+      time_created: parsed2.createdAt,
+      time_updated: parsed2.updatedAt,
+      stats: {
+        message_count: messageCount,
+        total_input_tokens: state.totalInputTokens,
+        total_output_tokens: state.totalOutputTokens,
+        total_cache_read_tokens: state.totalCacheReadTokens || void 0,
+        total_cache_create_tokens: state.totalCacheCreateTokens || void 0,
+        total_cost: state.totalCost,
+        cost_source: state.totalCost > 0 ? "recorded" : void 0
+      },
+      model_usage: modelUsage
+    });
+  }
+  parsePiFile(filePath) {
+    const records = Array.from(parseJsonlLines(readFileSync7(filePath, "utf-8")));
+    if (records.length === 0) throw new Error("empty file");
+    const header = records.find((record) => record["type"] === "session");
+    if (!header) throw new Error("missing session header");
+    const entries = records.filter((record) => record["type"] !== "session");
+    const pathEntries = buildCurrentPathEntries(entries);
+    if (pathEntries.length === 0) throw new Error("empty session tree");
+    const sessionId = String(header["id"] ?? extractSessionIdFromFilename(filePath)).trim();
+    if (!sessionId) throw new Error("missing session id");
+    const stat = statSync6(filePath);
+    const directory = String(header["cwd"] ?? "").trim() || basename6(filePath, ".jsonl");
+    const createdAt = parseTimestampMs3(header["timestamp"]) || stat.mtimeMs;
+    const updatedAt = pathEntries.reduce(
+      (max, entry) => Math.max(max, getEntryTimestamp(entry)),
+      createdAt
+    );
+    const explicitTitle = this.extractSessionName(pathEntries);
+    const messageTitle = this.extractTitle(pathEntries);
+    const directoryTitle = basenameTitle(directory);
+    return {
+      sessionId,
+      directory,
+      createdAt,
+      updatedAt,
+      title: resolveSessionTitle(explicitTitle, messageTitle, directoryTitle),
+      pathEntries
+    };
+  }
+  extractSessionName(entries) {
+    for (let index = entries.length - 1; index >= 0; index -= 1) {
+      const entry = entries[index];
+      if (entry["type"] !== "session_info") continue;
+      const name = normalizeTitleText(String(entry["name"] ?? ""));
+      if (name) return name;
+    }
+    return null;
+  }
+  extractTitle(entries) {
+    for (const entry of entries) {
+      if (entry["type"] !== "message") continue;
+      const message = entry["message"];
+      if (!isObject(message) || message["role"] !== "user") continue;
+      const title = normalizeTitleText(contentToText(message["content"]));
+      if (title) return title;
+    }
+    return null;
+  }
+  convertEntries(entries) {
+    const messages = [];
+    const pendingToolCalls = /* @__PURE__ */ new Map();
+    const modelUsage = {};
+    let totalInputTokens = 0;
+    let totalOutputTokens = 0;
+    let totalCacheReadTokens = 0;
+    let totalCacheCreateTokens = 0;
+    let totalCost = 0;
+    for (const entry of entries) {
+      const timestampMs = getEntryTimestamp(entry);
+      const type = String(entry["type"] ?? "");
+      if (type === "message") {
+        const message = entry["message"];
+        if (!isObject(message)) continue;
+        const result = this.convertAgentMessage(
+          entry,
+          message,
+          timestampMs,
+          pendingToolCalls,
+          messages.length,
+          messages
+        );
+        if (!result) continue;
+        if (result.message) messages.push(result.message);
+        totalInputTokens += result.inputTokens;
+        totalOutputTokens += result.outputTokens;
+        totalCacheReadTokens += result.cacheReadTokens;
+        totalCacheCreateTokens += result.cacheCreateTokens;
+        totalCost += result.cost;
+        if (result.model && result.totalTokens > 0) {
+          modelUsage[result.model] = (modelUsage[result.model] ?? 0) + result.totalTokens;
+        }
+        continue;
+      }
+      const summary = this.convertSummaryEntry(entry, timestampMs);
+      if (summary) messages.push(summary);
+    }
+    return {
+      messages,
+      totalInputTokens,
+      totalOutputTokens,
+      totalCacheReadTokens,
+      totalCacheCreateTokens,
+      totalCost,
+      modelUsage
+    };
+  }
+  convertAgentMessage(entry, message, timestampMs, pendingToolCalls, nextMessageIndex, messages) {
+    const id = String(entry["id"] ?? "");
+    const role = String(message["role"] ?? "");
+    if (role === "user") {
+      const parts = normalizeTextParts(message["content"], timestampMs);
+      if (parts.length === 0) return null;
+      return this.emptyUsageResult(buildMessage({ id, role: "user", timestampMs, parts }));
+    }
+    if (role === "assistant") {
+      const parts = this.normalizeAssistantParts(
+        message["content"],
+        timestampMs,
+        pendingToolCalls,
+        nextMessageIndex
+      );
+      if (parts.length === 0) return null;
+      const usage = this.normalizeUsage(message["usage"]);
+      const model = typeof message["model"] === "string" ? message["model"].trim() : null;
+      const cost = usage.cost ?? estimateTokenCost(model, usage.tokens) ?? 0;
+      return {
+        message: buildMessage({
+          id,
+          role: "assistant",
+          agent: "pi",
+          timestampMs,
+          parts,
+          provider: typeof message["provider"] === "string" ? message["provider"] : null,
+          model,
+          tokens: usage.tokens,
+          cost: cost || void 0,
+          costSource: cost > 0 ? "recorded" : void 0
+        }),
+        inputTokens: usage.inputTokens,
+        outputTokens: usage.outputTokens,
+        cacheReadTokens: usage.cacheReadTokens,
+        cacheCreateTokens: usage.cacheCreateTokens,
+        totalTokens: usage.totalTokens,
+        cost,
+        model
+      };
+    }
+    if (role === "toolResult") {
+      this.attachToolResult(message, timestampMs, pendingToolCalls, messages);
+      return this.emptyUsageResult();
+    }
+    if (role === "bashExecution") {
+      return this.emptyUsageResult(this.convertBashExecution(id, message, timestampMs));
+    }
+    if (role === "custom" && message["display"] === true) {
+      const parts = normalizeTextParts(message["content"], timestampMs);
+      if (parts.length === 0) return null;
+      return this.emptyUsageResult(buildMessage({ id, role: "user", timestampMs, parts }));
+    }
+    if (role === "branchSummary" || role === "compactionSummary") {
+      const summary = String(message["summary"] ?? "").trim();
+      if (!summary) return null;
+      return this.emptyUsageResult(
+        buildMessage({
+          id,
+          role: "assistant",
+          agent: "pi",
+          timestampMs,
+          parts: [{ type: "text", text: summary, time_created: timestampMs }]
+        })
+      );
+    }
+    return null;
+  }
+  normalizeAssistantParts(content, timestampMs, pendingToolCalls, messageIndex) {
+    if (!Array.isArray(content)) return [];
+    const parts = [];
+    for (const item of content) {
+      if (!isObject(item)) continue;
+      const type = item["type"];
+      if (type === "text") {
+        const text = cleanInternalText(String(item["text"] ?? ""));
+        if (text) parts.push({ type: "text", text, time_created: timestampMs });
+        continue;
+      }
+      if (type === "thinking") {
+        const text = cleanInternalText(String(item["thinking"] ?? ""));
+        if (text) parts.push({ type: "reasoning", text, time_created: timestampMs });
+        continue;
+      }
+      if (type === "toolCall") {
+        const callId = String(item["id"] ?? "").trim();
+        const toolName = String(item["name"] ?? "").trim() || "tool";
+        const toolPart = {
+          type: "tool",
+          tool: toolName,
+          title: `Tool: ${toolName}`,
+          callID: callId || void 0,
+          time_created: timestampMs,
+          state: {
+            status: "running",
+            input: item["arguments"] ?? {}
+          }
+        };
+        parts.push(toolPart);
+        if (callId) pendingToolCalls.set(callId, [messageIndex, parts.length - 1]);
+      }
+    }
+    return parts;
+  }
+  attachToolResult(message, timestampMs, pendingToolCalls, messages) {
+    const callId = String(message["toolCallId"] ?? "").trim();
+    const output = normalizeTextParts(message["content"], timestampMs);
+    const location = callId ? pendingToolCalls.get(callId) : void 0;
+    if (!location) return;
+    const [messageIndex, partIndex] = location;
+    const target = messages[messageIndex]?.parts[partIndex];
+    if (!target?.state) return;
+    target.state.output = output;
+    target.state.status = message["isError"] === true ? "error" : "completed";
+    target.state.metadata = message["details"];
+    pendingToolCalls.delete(callId);
+  }
+  convertBashExecution(id, message, timestampMs) {
+    const command = String(message["command"] ?? "");
+    const output = String(message["output"] ?? "");
+    const isError = Number(message["exitCode"] ?? 0) !== 0 || message["cancelled"] === true;
+    return buildMessage({
+      id,
+      role: "tool",
+      timestampMs,
+      parts: [
+        {
+          type: "tool",
+          tool: "bash",
+          title: "Tool: bash",
+          time_created: timestampMs,
+          state: {
+            status: isError ? "error" : "completed",
+            input: { command },
+            output: output ? [{ type: "text", text: output, time_created: timestampMs }] : [],
+            metadata: {
+              exitCode: message["exitCode"],
+              cancelled: message["cancelled"],
+              truncated: message["truncated"],
+              fullOutputPath: message["fullOutputPath"]
+            }
+          }
+        }
+      ]
+    });
+  }
+  convertSummaryEntry(entry, timestampMs) {
+    const type = entry["type"];
+    if (type !== "compaction" && type !== "branch_summary" && type !== "custom_message") {
+      return null;
+    }
+    if (type === "custom_message" && entry["display"] !== true) return null;
+    const rawText = type === "custom_message" ? contentToText(entry["content"]) : String(entry["summary"] ?? "");
+    const text = cleanInternalText(rawText);
+    if (!text) return null;
+    return buildMessage({
+      id: String(entry["id"] ?? ""),
+      role: type === "custom_message" ? "user" : "assistant",
+      agent: type === "custom_message" ? void 0 : "pi",
+      timestampMs,
+      parts: [{ type: "text", text, time_created: timestampMs }]
+    });
+  }
+  normalizeUsage(raw) {
+    const usage = isObject(raw) ? raw : {};
+    const inputTokens = Number(usage["input"] ?? 0);
+    const outputTokens = Number(usage["output"] ?? 0);
+    const cacheReadTokens = Number(usage["cacheRead"] ?? 0);
+    const cacheCreateTokens = Number(usage["cacheWrite"] ?? 0);
+    const totalTokens = Number(
+      usage["totalTokens"] ?? inputTokens + outputTokens + cacheReadTokens + cacheCreateTokens
+    );
+    const cost = isObject(usage["cost"]) ? Number(usage["cost"]["total"] ?? 0) : null;
+    return {
+      inputTokens: inputTokens + cacheReadTokens + cacheCreateTokens,
+      outputTokens,
+      cacheReadTokens,
+      cacheCreateTokens,
+      totalTokens,
+      cost: cost && Number.isFinite(cost) ? cost : null,
+      tokens: {
+        input: inputTokens + cacheReadTokens + cacheCreateTokens,
+        output: outputTokens,
+        cache_read: cacheReadTokens || void 0,
+        cache_create: cacheCreateTokens || void 0
+      }
+    };
+  }
+  emptyUsageResult(message) {
+    return {
+      message,
+      inputTokens: 0,
+      outputTokens: 0,
+      cacheReadTokens: 0,
+      cacheCreateTokens: 0,
+      totalTokens: 0,
+      cost: 0,
+      model: null
+    };
+  }
+};
 registerAgent({
   name: "claudecode",
   displayName: "Claude Code",
@@ -4688,6 +5274,12 @@ registerAgent({
   icon: "/icon/agent/codex.svg",
   create: () => new CodexAgent()
 });
+registerAgent({
+  name: "pi",
+  displayName: "Pi",
+  icon: "/icon/agent/pi.svg",
+  create: () => new PiAgent()
+});
 registerAgent({
   name: "cursor",
   displayName: "Cursor",
@@ -4702,11 +5294,11 @@ function fallbackDisplayName(input) {
 }
 var realFs = {
   exists(path2) {
-    return existsSync9(path2);
+    return existsSync10(path2);
   },
   readText(path2) {
     try {
-      return readFileSync7(path2, "utf8");
+      return readFileSync8(path2, "utf8");
     } catch {
       return null;
     }
@@ -5196,16 +5788,16 @@ var LEGACY_CACHE_FILENAME = "scan-cache.json";
 var SEARCH_INDEX_BULK_SYNC_THRESHOLD = 100;
 var ftsIntegrityCheckedPath = null;
 function getCacheDir2() {
-  return join9(homedir4(), ".cache", "codesesh");
+  return join10(homedir4(), ".cache", "codesesh");
 }
 function getCachePath2() {
-  return join9(getCacheDir2(), CACHE_FILENAME);
+  return join10(getCacheDir2(), CACHE_FILENAME);
 }
 function getLegacyCachePath() {
-  return join9(getCacheDir2(), LEGACY_CACHE_FILENAME);
+  return join10(getCacheDir2(), LEGACY_CACHE_FILENAME);
 }
 function hasCacheStorage() {
-  return existsSync10(getCachePath2());
+  return existsSync11(getCachePath2());
 }
 function withCacheDb(fn) {
   const cachePath = getCachePath2();
@@ -6644,7 +7236,7 @@ function buildSessionContentFromMessages(title, messages) {
 }
 function deleteLegacyCacheFile() {
   const legacyPath = getLegacyCachePath();
-  if (!existsSync10(legacyPath)) {
+  if (!existsSync11(legacyPath)) {
     return;
   }
   try {
@@ -6971,7 +7563,7 @@ function clearCache() {
   const walPath = `${cachePath}-wal`;
   const shmPath = `${cachePath}-shm`;
   for (const filePath of [walPath, shmPath]) {
-    if (!existsSync10(filePath)) {
+    if (!existsSync11(filePath)) {
       continue;
     }
     try {
@@ -8179,16 +8771,16 @@ function getStateDir() {
   }
   const p = platform2();
   if (p === "darwin") {
-    return join10(homedir5(), "Library", "Application Support", "codesesh");
+    return join11(homedir5(), "Library", "Application Support", "codesesh");
   }
   if (p === "win32") {
     const appData = process.env.APPDATA ?? process.env.LOCALAPPDATA;
-    return join10(appData ?? join10(homedir5(), "AppData", "Roaming"), "codesesh");
+    return join11(appData ?? join11(homedir5(), "AppData", "Roaming"), "codesesh");
   }
-  return join10(process.env.XDG_DATA_HOME ?? join10(homedir5(), ".local", "share"), "codesesh");
+  return join11(process.env.XDG_DATA_HOME ?? join11(homedir5(), ".local", "share"), "codesesh");
 }
 function getStateDbPath() {
-  return join10(getStateDir(), BOOKMARK_DB_FILENAME);
+  return join11(getStateDir(), BOOKMARK_DB_FILENAME);
 }
 function useMemoryStateStore() {
   return process.env.CODESESH_STATE_STORE === MEMORY_STATE_STORE;
@@ -8556,4 +9148,4 @@ export {
   importBookmarks,
   deleteBookmark
 };
-//# sourceMappingURL=chunk-XANARSZG.js.map
+//# sourceMappingURL=chunk-LXHUIQZI.js.map