@cjhyy/code-shell 0.1.0-alpha.1 → 0.1.0-alpha.2

package/dist/{chunk-4PKZPFCD.js → chunk-I57ZD5IQ.js}

@@ -7,16 +7,30 @@ init_esm_shims();
 import { mkdirSync, existsSync, readFileSync, writeFileSync, readdirSync, unlinkSync } from "fs";
 import { join } from "path";
 import { homedir } from "os";
+function resolveMemoryBaseDir(override) {
+  if (override) return override;
+  const fromEnv = process.env.CODE_SHELL_HOME;
+  if (fromEnv && fromEnv.length > 0) return fromEnv;
+  return join(homedir(), ".code-shell");
+}
 var MemoryManager = class {
+  baseDir;
   memoryDir;
   indexPath;
-  constructor(projectDir) {
-    const baseDir = join(homedir(), ".code-shell");
-    if (projectDir) {
-      const projectHash = projectDir.replace(/[/\\:]/g, "-").replace(/^-/, "");
-      this.memoryDir = join(baseDir, "projects", projectHash, "memory");
+  // Per-instance cache of {fileName -> {name, description}} so the
+  // index can be rewritten without re-reading every memory file
+  // every time a single entry is saved/deleted (the previous code
+  // path called loadAll() on every save, giving O(N²) total I/O).
+  // null = "not initialized yet, fall back to disk on next access."
+  indexCache = null;
+  constructor(options) {
+    const opts = typeof options === "string" ? { projectDir: options } : options ?? {};
+    this.baseDir = resolveMemoryBaseDir(opts.baseDir);
+    if (opts.projectDir) {
+      const projectHash = opts.projectDir.replace(/[/\\:]/g, "-").replace(/^-/, "");
+      this.memoryDir = join(this.baseDir, "projects", projectHash, "memory");
     } else {
-      this.memoryDir = join(baseDir, "memory");
+      this.memoryDir = join(this.baseDir, "memory");
     }
     this.indexPath = join(this.memoryDir, "MEMORY.md");
     mkdirSync(this.memoryDir, { recursive: true });
@@ -39,7 +53,9 @@ type: ${entry.type}
 ${entry.content}
 `;
     writeFileSync(filePath, content, "utf-8");
-    this.updateIndex();
+    const cache = this.ensureIndexCache();
+    cache.set(fileName, { name: entry.name, description: entry.description });
+    this.writeIndex(cache);
     return fileName;
   }
   /**
@@ -88,7 +104,9 @@ ${entry.content}
     if (!entry) return false;
     try {
       unlinkSync(join(this.memoryDir, entry.fileName));
-      this.updateIndex();
+      const cache = this.ensureIndexCache();
+      cache.delete(entry.fileName);
+      this.writeIndex(cache);
       return true;
     } catch {
       return false;
@@ -116,13 +134,27 @@ The following memories from previous sessions may be relevant:
 
 ` + lines.join("\n") + `
 
-To read a specific memory, check ~/.code-shell/memory/`;
+To read a specific memory, check ${this.memoryDir}/`;
   }
-  updateIndex() {
-    const entries = this.loadAll();
-    const lines = entries.map(
-      (e) => `- [${e.name}](${e.fileName}) \u2014 ${e.description}`
-    );
+  /**
+   * Lazy-build the in-memory index from disk on first use, then
+   * keep it in sync incrementally via save/delete. Avoids the
+   * O(N²) re-read of every memory file on every save.
+   */
+  ensureIndexCache() {
+    if (this.indexCache !== null) return this.indexCache;
+    const cache = /* @__PURE__ */ new Map();
+    for (const entry of this.loadAll()) {
+      cache.set(entry.fileName, { name: entry.name, description: entry.description });
+    }
+    this.indexCache = cache;
+    return cache;
+  }
+  writeIndex(cache) {
+    const lines = [];
+    for (const [fileName, meta] of cache) {
+      lines.push(`- [${meta.name}](${fileName}) \u2014 ${meta.description}`);
+    }
     const content = lines.length > 0 ? lines.join("\n") + "\n" : "(no memories stored)\n";
     writeFileSync(this.indexPath, content, "utf-8");
   }
@@ -132,5 +164,6 @@ To read a specific memory, check ~/.code-shell/memory/`;
 };
 
 export {
+  resolveMemoryBaseDir,
   MemoryManager
 };