more cleanup

Author: pelikhan

packages/core/src/cache.ts

@@ -4,6 +4,8 @@ import { MemoryCache } from "./memcache"
 import { host } from "./host"
 import { NotSupportedError } from "./error"
 import { CancellationOptions } from "./cancellation"
+import debug from "debug"
+const dbg = debug("genaiscript:cache")
 
 /**
  * Represents a cache entry with a hashed identifier (`sha`), `key`, and `val`.
@@ -30,14 +32,18 @@ export function createCache<K, V>(
     options?: CacheOptions & CancellationOptions
 ): WorkspaceFileCache<K, V> {
     name = cacheNormalizeName(name) // Sanitize name
-    if (!name) throw new NotSupportedError("missing cache name")
+    if (!name) {
+        dbg(`empty cache name`)
+        throw new NotSupportedError("missing cache name")
+    }
 
     const type = options?.type || "fs"
     const key = `cache:${type}:${name}`
     const userState = options?.userState || host.userState
     if (userState[key]) return userState[key] // Return if exists
     if (options?.lookupOnly) return undefined
 
+    dbg(`creating ${name} ${type}`)
     let r: WorkspaceFileCache<K, V>
     switch (type) {
         case "memory":

packages/core/src/fscache.ts

@@ -34,6 +34,7 @@ export class FsCache<K, V> implements WorkspaceFileCache<any, any> {
     }
 
     async get(key: any): Promise<any> {
+        if (key === undefined) return undefined // Handle undefined key
         const sha = await this.getSha(key)
         const fn = this.cacheFilename(sha)
         const res = await tryReadJSON(fn)

packages/core/src/memcache.ts

@@ -42,25 +42,6 @@ export class MemoryCache<K, V>
         return Object.values(this._entries).map((kv) => kv.val)
     }
 
-    /**
-     * Retrieve all entries from the cache.
-     * @returns A promise resolving to an array of cache entries
-     */
-    async entries(): Promise<CacheEntry<V>[]> {
-        await this.initialize()
-        return Object.values(this._entries).map((e) => ({ ...e }))
-    }
-
-    /**
-     * Retrieve a specific entry by its SHA identifier.
-     * @param sha - The SHA identifier of the entry
-     * @returns A promise resolving to the cache entry
-     */
-    async getEntryBySha(sha: string) {
-        await this.initialize()
-        return this._entries[sha]
-    }
-
     /**
      * Get the value associated with a specific key.
      * @param key - The key of the entry

packages/core/src/workspace.ts

@@ -146,11 +146,6 @@ export function createWorkspaceFileSystem(): Omit<
             return data
         },
         cache: async (name: string) => {
-            if (!name) {
-                dbg(`cache name is missing`)
-                throw new NotSupportedError("missing cache name")
-            }
-            dbg(`cache name: ${name}`)
             const res = createCache<any, any>(name)
             return res
         },

packages/vscode/src/state.ts

@@ -97,10 +97,6 @@ export class ExtensionState extends EventTarget {
     private _project: Project = undefined
     private _aiRequest: AIRequest = undefined
     private _diagColl: vscode.DiagnosticCollection
-    private _aiRequestCache: WorkspaceFileCache<
-        AIRequestSnapshotKey,
-        AIRequestSnapshot
-    > = undefined
     readonly output: vscode.LogOutputChannel
     readonly sessionApiKey: string
     private panel: vscode.WebviewPanel
@@ -122,11 +118,6 @@ export class ExtensionState extends EventTarget {
         this._diagColl = vscode.languages.createDiagnosticCollection(TOOL_NAME)
         subscriptions.push(this._diagColl)
 
-        this._aiRequestCache = createCache<
-            AIRequestSnapshotKey,
-            AIRequestSnapshot
-        >(AI_REQUESTS_CACHE)
-
         // clear errors when file edited (remove me?)
         subscriptions.push(
             vscode.workspace.onDidChangeTextDocument(
@@ -169,10 +160,6 @@ export class ExtensionState extends EventTarget {
         return res
     }
 
-    aiRequestCache() {
-        return this._aiRequestCache
-    }
-
     async applyEdits() {
         const req = this.aiRequest
         if (!req) return
@@ -193,7 +180,7 @@ export class ExtensionState extends EventTarget {
 
     async requestAI(
         options: AIRequestOptions
-    ): Promise<Partial<GenerationResult> & { requestSha: string }> {
+    ): Promise<Partial<GenerationResult>> {
         try {
             const req = await this.startAIRequest(options)
             if (!req) {
@@ -208,42 +195,17 @@ export class ExtensionState extends EventTarget {
                 else if (text) this.showWebview({ reveal: false })
             }
 
-            const { key, sha } = await this.snapshotAIRequestKey(req)
-            const snapshot = snapshotAIRequest(req)
-            await this._aiRequestCache.set(key, snapshot)
             this.setDiagnostics()
             this.dispatchChange()
 
             if (edits?.length && options.mode != "notebook") this.applyEdits()
-            return { ...res, requestSha: sha }
+            return res
         } catch (e) {
             if (isCancelError(e)) return undefined
             throw e
         }
     }
 
-    private async snapshotAIRequestKey(r: AIRequest) {
-        const { options } = r
-        const key: AIRequestSnapshotKey = {
-            template: {
-                id: options.template.id,
-                title: options.template.title,
-                hash: await hash(
-                    {
-                        template: options.template,
-                        parameters: options.parameters,
-                        mode: options.mode,
-                        runOptions: options.runOptions,
-                    },
-                    { version: true }
-                ),
-            },
-            fragment: options.fragment,
-            version: CORE_VERSION,
-        }
-        return { key, sha: await this._aiRequestCache.getSha(key) }
-    }
-
     dispatchAIRequestChange() {
         this.dispatchEvent(new Event(AI_REQUEST_CHANGE))
     }