codesesh 0.7.1 → 0.8.0

package/dist/{dist-L4XKQDGX.js → dist-WJUBVCLN.js}

@@ -79,7 +79,7 @@ import {
   syncSessionSearchIndexChanges,
   upsertBookmark,
   withEstimatedSessionCost
-} from "./chunk-7GQEIPVK.js";
+} from "./chunk-XANARSZG.js";
 export {
   BaseAgent,
   BookmarkStorageUnavailableError,
@@ -161,4 +161,4 @@ export {
   upsertBookmark,
   withEstimatedSessionCost
 };
-//# sourceMappingURL=dist-L4XKQDGX.js.map
+//# sourceMappingURL=dist-WJUBVCLN.js.map

package/dist/index.js

@@ -29,7 +29,7 @@ import {
   searchFileActivitySessions,
   searchSessions,
   upsertBookmark
-} from "./chunk-7GQEIPVK.js";
+} from "./chunk-XANARSZG.js";
 
 // src/index.ts
 import { defineCommand, runMain } from "citty";
@@ -1184,12 +1184,6 @@ function buildRefreshDiff(agentName, previousSessions, nextSessions, candidateCh
 function restoreAgentCacheMeta(agent, meta) {
   agent.setSessionMetaMap?.(new Map(Object.entries(meta)));
 }
-function sourceFingerprintFromMeta(meta) {
-  return typeof meta?.sourceFingerprint === "string" ? meta.sourceFingerprint : null;
-}
-function sourcePathFromMeta(meta) {
-  return typeof meta?.sourcePath === "string" ? meta.sourcePath : null;
-}
 function toAbsolutePath(path) {
   return isAbsolute(path) ? path : resolve2(path);
 }
@@ -1688,23 +1682,19 @@ var LiveScanStore = class {
     return workerUrl;
   }
   getScanRefreshWorkerUrl() {
-    const workerUrl = new URL("./scan-refresh-worker.js", import.meta.url);
-    if (workerUrl.protocol === "file:" && !existsSync3(fileURLToPath2(workerUrl))) {
-      return null;
-    }
-    return workerUrl;
+    return new URL("./scan-refresh-worker.js", import.meta.url);
   }
-  scanAgentInWorker(agent, previousSessions, changedIds, scanOptions) {
+  scanAgentInWorker(agent, previousSessions, changedIds, scanOptions, workerOptions = {}) {
     const workerUrl = this.getScanRefreshWorkerUrl();
-    if (!workerUrl) return null;
     return new Promise((resolve4, reject) => {
       const worker = new Worker(workerUrl, {
         workerData: {
           agentName: agent.name,
           previousSessions,
           changedIds,
+          sourceSync: workerOptions.sourceSync,
           scanOptions,
-          meta: buildAgentCacheMeta(agent)
+          meta: workerOptions.meta ?? buildAgentCacheMeta(agent)
         }
       });
       worker.unref();
@@ -1721,7 +1711,13 @@ var LiveScanStore = class {
           return;
         }
         if (message.type === "done") {
-          finish(() => resolve4({ sessions: message.sessions, meta: message.meta }));
+          finish(
+            () => resolve4({
+              sessions: message.sessions,
+              meta: message.meta,
+              changedIds: message.changedIds
+            })
+          );
           return;
         }
         finish(() => reject(new Error(message.error)));
@@ -1738,7 +1734,7 @@ var LiveScanStore = class {
   }
   buildFullSearchIndexJobs(context) {
     return this.agents.map((agent) => {
-      const cached = loadCachedSessions(agent.name, { ignoreTtl: true });
+      const cached = loadCachedSessions(agent.name);
       if (cached) {
         return {
           kind: "full",
@@ -1863,39 +1859,6 @@ var LiveScanStore = class {
   canSyncSources(agent) {
     return Boolean(agent.listSessionSources && agent.scanSessionSource);
   }
-  syncAgentSources(agent, cachedSessions, cachedMeta) {
-    const sessionMap = new Map(cachedSessions.map((session) => [session.id, session]));
-    const sourceRefs = agent.listSessionSources();
-    const currentIds = new Set(sourceRefs.map((source) => source.sessionId));
-    const changedIds = /* @__PURE__ */ new Set();
-    for (const source of sourceRefs) {
-      const cachedSession = sessionMap.get(source.sessionId);
-      const cached = cachedMeta[source.sessionId];
-      const sameSource = sourcePathFromMeta(cached) === source.sourcePath;
-      const sameFingerprint = sourceFingerprintFromMeta(cached) === source.fingerprint;
-      if (cachedSession && sameSource && sameFingerprint) continue;
-      const next = agent.scanSessionSource(source.sourcePath);
-      changedIds.add(source.sessionId);
-      if (next) {
-        sessionMap.set(next.id, next);
-      } else {
-        sessionMap.delete(source.sessionId);
-      }
-    }
-    for (const session of cachedSessions) {
-      if (!currentIds.has(session.id)) {
-        sessionMap.delete(session.id);
-        changedIds.add(session.id);
-      }
-    }
-    const sessions = attachMissingProjectIdentities([...sessionMap.values()]);
-    const persistenceDiff = buildRefreshDiff(agent.name, cachedSessions, sessions, [...changedIds]);
-    return {
-      sessions,
-      changedIds: [...changedIds],
-      persistenceDiff
-    };
-  }
   async refreshInitialIndex() {
     const startedAt = performance.now();
     const context = "scan.initial.background";
@@ -2145,7 +2108,7 @@ var LiveScanStore = class {
       return;
     }
     const previousSessions = this.byAgent[agentName] ?? [];
-    const cached = loadCachedSessions(agentName, { ignoreTtl: true });
+    const cached = loadCachedSessions(agentName);
     const refreshBaseline = cached?.sessions ?? previousSessions;
     const cacheTimestamp = cached?.timestamp ?? this.refreshTimestamps.get(agentName) ?? 0;
     if (cached) {
@@ -2174,32 +2137,38 @@ var LiveScanStore = class {
     } else if (!isInitialized) {
       this.setScanPhase("initializing");
       const scanStartedAt = performance.now();
-      const workerResult = this.scanAgentInWorker(agent, previousSessions, null, {});
-      if (workerResult) {
-        const result = await workerResult;
-        nextSessions = result.sessions;
-        agent.setSessionMetaMap?.(new Map(Object.entries(result.meta)));
-      } else {
-        nextSessions = await Promise.resolve(
-          agent.scan({
-            onProgress: (progress) => this.updateAgentScanProgress(agentName, progress)
-          })
-        );
-      }
+      const result = await this.scanAgentInWorker(agent, previousSessions, null, {});
+      nextSessions = result.sessions;
+      agent.setSessionMetaMap?.(new Map(Object.entries(result.meta)));
       fullScanSessions = attachMissingProjectIdentities(nextSessions);
       nextSessions = fullScanSessions;
       scanDuration = performance.now() - scanStartedAt;
       this.refreshTimestamps.set(agentName, Date.now());
     } else if (cached && this.canSyncSources(agent)) {
       const scanStartedAt = performance.now();
-      const result = this.syncAgentSources(agent, cached.sessions, cached.meta);
+      const result = await this.scanAgentInWorker(
+        agent,
+        cached.sessions,
+        null,
+        {},
+        {
+          sourceSync: true,
+          meta: cached.meta
+        }
+      );
       nextSessions = result.sessions;
-      preciseChangedIds = result.changedIds;
+      agent.setSessionMetaMap?.(new Map(Object.entries(result.meta)));
+      preciseChangedIds = result.changedIds ?? [];
       usedIncrementalScan = true;
-      persistenceDiff = result.persistenceDiff;
+      persistenceDiff = buildRefreshDiff(
+        agentName,
+        cached.sessions,
+        attachMissingProjectIdentities(nextSessions),
+        preciseChangedIds
+      );
       scanDuration = performance.now() - scanStartedAt;
       this.refreshTimestamps.set(agentName, Date.now());
-      if (result.changedIds.length === 0) {
+      if (preciseChangedIds.length === 0) {
         appLogger.debug("scan.refresh.unchanged", {
           agent: agentName,
           duration_ms: Math.round(performance.now() - startedAt)
@@ -2236,18 +2205,9 @@ var LiveScanStore = class {
       scanDuration = performance.now() - scanStartedAt;
     } else {
       const scanStartedAt = performance.now();
-      const workerResult = this.scanAgentInWorker(agent, previousSessions, null, {});
-      if (workerResult) {
-        const result = await workerResult;
-        nextSessions = result.sessions;
-        agent.setSessionMetaMap?.(new Map(Object.entries(result.meta)));
-      } else {
-        nextSessions = await Promise.resolve(
-          agent.scan({
-            onProgress: (progress) => this.updateAgentScanProgress(agentName, progress)
-          })
-        );
-      }
+      const result = await this.scanAgentInWorker(agent, previousSessions, null, {});
+      nextSessions = result.sessions;
+      agent.setSessionMetaMap?.(new Map(Object.entries(result.meta)));
       fullScanSessions = attachMissingProjectIdentities(nextSessions);
       nextSessions = fullScanSessions;
       scanDuration = performance.now() - scanStartedAt;
@@ -2480,7 +2440,7 @@ var main = defineCommand({
       log_path: appLogger.getLogPath()
     });
     if (clearCache) {
-      const { clearCache: clear } = await import("./dist-L4XKQDGX.js");
+      const { clearCache: clear } = await import("./dist-WJUBVCLN.js");
       clear();
       appLogger.info("cache.clear");
       console.log("Cache cleared.");