@ridit/lens 0.3.6 → 0.3.7

package/src/utils/chat.ts

@@ -19,6 +19,11 @@ import { FEW_SHOT_MESSAGES } from "../prompts";
 import { registry } from "../utils/tools/registry";
 import type { FilePatch } from "../components/repo/DiffViewer";
 
+export type ChatResult = {
+  text: string;
+  truncated: boolean;
+};
+
 export type ParsedResponse =
   | { kind: "text"; content: string; remainder?: string }
   | {
@@ -219,7 +224,7 @@ export async function callChat(
   messages: Message[],
   abortSignal?: AbortSignal,
   retries = 2,
-): Promise<string> {
+): Promise<ChatResult> {
   const apiMessages = [
     ...buildFewShotMessages(),
     ...buildApiMessages(messages),
@@ -288,13 +293,20 @@ export async function callChat(
 
     if (provider.type === "anthropic") {
       const content = data.content as { type: string; text: string }[];
-      return content
+      const text = content
         .filter((b) => b.type === "text")
         .map((b) => b.text)
         .join("");
+      const truncated = (data as any).stop_reason === "max_tokens";
+      return { text, truncated };
     } else {
-      const choices = data.choices as { message: { content: string } }[];
-      return choices[0]?.message.content ?? "";
+      const choices = data.choices as {
+        message: { content: string };
+        finish_reason?: string;
+      }[];
+      const text = choices[0]?.message.content ?? "";
+      const truncated = choices[0]?.finish_reason === "length";
+      return { text, truncated };
     }
   } catch (err) {
     clearTimeout(timer);

package/src/utils/memory.ts

@@ -15,16 +15,18 @@ export type MemoryEntry = {
   detail: string;
   summary: string;
   timestamp: string;
+  repoPath?: string;
 };
 
 export type Memory = {
   id: string;
   content: string;
   timestamp: string;
+  repoPath?: string;
+  scope: "repo" | "global";
 };
 
 export type MemoryFile = {
-  entries: MemoryEntry[];
   memories: Memory[];
 };
 
@@ -32,17 +34,14 @@ const LENS_DIR = path.join(os.homedir(), ".lens");
 const MEMORY_PATH = path.join(LENS_DIR, "memory.json");
 
 function loadMemoryFile(): MemoryFile {
-  if (!existsSync(MEMORY_PATH)) return { entries: [], memories: [] };
+  if (!existsSync(MEMORY_PATH)) return { memories: [] };
   try {
     const data = JSON.parse(
       readFileSync(MEMORY_PATH, "utf-8"),
     ) as Partial<MemoryFile>;
-    return {
-      entries: data.entries ?? [],
-      memories: data.memories ?? [],
-    };
+    return { memories: data.memories ?? [] };
   } catch {
-    return { entries: [], memories: [] };
+    return { memories: [] };
   }
 }
 
@@ -51,26 +50,48 @@ function saveMemoryFile(m: MemoryFile): void {
   writeFileSync(MEMORY_PATH, JSON.stringify(m, null, 2), "utf-8");
 }
 
-// ── Action entries (what the model has done) ──────────────────────────────────
+// ── Session-only action entries (in-memory, never written to disk) ────────────
 
-export function appendMemory(entry: Omit<MemoryEntry, "timestamp">): void {
-  const m = loadMemoryFile();
-  m.entries.push({ ...entry, timestamp: new Date().toISOString() });
-  if (m.entries.length > 500) m.entries = m.entries.slice(-500);
-  saveMemoryFile(m);
+const sessionEntries: MemoryEntry[] = [];
+
+export function appendMemory(
+  entry: Omit<MemoryEntry, "timestamp">,
+  repoPath?: string,
+): void {
+  sessionEntries.push({
+    ...entry,
+    repoPath,
+    timestamp: new Date().toISOString(),
+  });
+  if (sessionEntries.length > 200)
+    sessionEntries.splice(0, sessionEntries.length - 200);
 }
 
 export function buildMemorySummary(repoPath: string): string {
   const m = loadMemoryFile();
-  const relevant = m.entries.slice(-50);
 
-  const memories = m.memories;
+  const globalMemories = m.memories.filter((mem) => mem.scope === "global");
+  const repoMemories = m.memories.filter(
+    (mem) => mem.scope === "repo" && mem.repoPath === repoPath,
+  );
+
+  const relevant = sessionEntries
+    .filter((e) => !e.repoPath || e.repoPath === repoPath)
+    .slice(-50);
 
   const parts: string[] = [];
 
-  if (memories.length > 0) {
+  if (globalMemories.length > 0) {
+    parts.push(
+      `## GLOBAL MEMORIES (apply to all repos)\n\n${globalMemories
+        .map((mem) => `- [${mem.id}] ${mem.content}`)
+        .join("\n")}`,
+    );
+  }
+
+  if (repoMemories.length > 0) {
     parts.push(
-      `## MEMORIES ABOUT THIS REPO\n\n${memories
+      `## MEMORIES ABOUT THIS REPO\n\n${repoMemories
         .map((mem) => `- [${mem.id}] ${mem.content}`)
         .join("\n")}`,
     );
@@ -82,7 +103,7 @@ export function buildMemorySummary(repoPath: string): string {
       return `[${ts}] ${e.kind}: ${e.detail} — ${e.summary}`;
     });
     parts.push(
-      `## WHAT YOU HAVE ALREADY DONE IN THIS REPO\n\nThe following actions have already been completed. Do NOT repeat them unless the user explicitly asks you to redo something:\n\n${lines.join("\n")}`,
+      `## WHAT YOU HAVE ALREADY DONE THIS SESSION\n\nThe following actions have already been completed. Do NOT repeat them unless the user explicitly asks:\n\n${lines.join("\n")}`,
     );
   }
 
@@ -90,27 +111,42 @@ export function buildMemorySummary(repoPath: string): string {
 }
 
 export function getRepoMemory(repoPath: string): MemoryEntry[] {
-  return loadMemoryFile().entries;
+  return sessionEntries.filter((e) => !e.repoPath || e.repoPath === repoPath);
 }
 
 export function clearRepoMemory(repoPath: string): void {
+  // clear session entries for this repo
+  const toRemove = sessionEntries
+    .map((e, i) => (e.repoPath === repoPath ? i : -1))
+    .filter((i) => i >= 0)
+    .reverse();
+  for (const i of toRemove) sessionEntries.splice(i, 1);
+
+  // clear persisted memories for this repo (keep global)
   const m = loadMemoryFile();
-  m.entries = m.entries = [];
-  m.memories = m.memories = [];
+  m.memories = m.memories.filter(
+    (mem) => mem.scope === "global" || mem.repoPath !== repoPath,
+  );
   saveMemoryFile(m);
 }
 
-// ── User/model memories ───────────────────────────────────────────────────────
-
 function generateId(): string {
   return Math.random().toString(36).slice(2, 8);
 }
 
 export function addMemory(content: string, repoPath: string): Memory {
   const m = loadMemoryFile();
+
+  const isGlobal = content.startsWith("[global]");
+  const cleanContent = isGlobal
+    ? content.replace("[global]", "").trim()
+    : content;
+
   const memory: Memory = {
     id: generateId(),
-    content,
+    content: cleanContent,
+    repoPath: isGlobal ? undefined : repoPath,
+    scope: isGlobal ? "global" : "repo",
     timestamp: new Date().toISOString(),
   };
   m.memories.push(memory);
@@ -121,12 +157,53 @@ export function addMemory(content: string, repoPath: string): Memory {
 export function deleteMemory(id: string, repoPath: string): boolean {
   const m = loadMemoryFile();
   const before = m.memories.length;
-  m.memories = m.memories.filter((mem) => !(mem.id === id));
+  m.memories = m.memories.filter((mem) => mem.id !== id);
   if (m.memories.length === before) return false;
   saveMemoryFile(m);
   return true;
 }
 
 export function listMemories(repoPath: string): Memory[] {
-  return loadMemoryFile().memories;
+  return loadMemoryFile().memories.filter(
+    (mem) => mem.scope === "global" || mem.repoPath === repoPath,
+  );
+}
+
+type SessionToolLog = {
+  toolName: string;
+  input: string;
+  resultPreview: string;
+  timestamp: string;
+};
+
+const sessionToolLog: SessionToolLog[] = [];
+
+export function logToolCall(
+  toolName: string,
+  input: string,
+  result: string,
+  repoPath?: string,
+): void {
+  sessionToolLog.push({
+    toolName,
+    input,
+    resultPreview: result.slice(0, 120),
+    timestamp: new Date().toISOString(),
+  });
+  if (sessionToolLog.length > 100)
+    sessionToolLog.splice(0, sessionToolLog.length - 100);
+}
+
+export function getSessionToolSummary(repoPath: string): string {
+  if (sessionToolLog.length === 0) return "";
+  const recent = sessionToolLog.slice(-30);
+  const lines = recent.map((e) => {
+    const input = e.input.length > 60 ? e.input.slice(0, 60) + "…" : e.input;
+    return `- ${e.toolName}: ${input}`;
+  });
+  return `## TOOLS ALREADY USED THIS SESSION\n\nDo NOT call these again unless the user explicitly asks:\n\n${lines.join("\n")}`;
+}
+
+export function clearSessionLog(): void {
+  sessionToolLog.splice(0, sessionToolLog.length);
 }

package/src/utils/tools/builtins.ts

@@ -136,13 +136,39 @@ export const writeFileTool: Tool<WriteFileInput> = {
   systemPromptEntry: (i) =>
     `### ${i}. write-file — create or overwrite a file\n<write-file>\n{"path": "data/output.csv", "content": "col1,col2\\nval1,val2"}\n</write-file>`,
   parseInput: (body) => {
+    const tryParse = (s: string) => {
+      try {
+        const parsed = JSON.parse(s) as { path: string; content: string };
+        if (!parsed.path || parsed.content === undefined) return null;
+        return { ...parsed, path: parsed.path.replace(/\\/g, "/") };
+      } catch {
+        return null;
+      }
+    };
+
+    const first = tryParse(body.trim());
+    if (first) return first;
+
     try {
-      const parsed = JSON.parse(body) as { path: string; content: string };
-      if (!parsed.path) return null;
-      return { ...parsed, path: parsed.path.replace(/\\/g, "/") };
-    } catch {
-      return null;
+      const sanitized = body
+        .replace(/[\x00-\x08\x0b\x0c\x0e-\x1f]/g, "")
+        .replace(/\n/g, "\\n")
+        .replace(/\r/g, "\\r")
+        .replace(/\t/g, "\\t");
+      const second = tryParse(sanitized);
+      if (second) return second;
+    } catch {}
+
+    const pathMatch = body.match(/"path"\s*:\s*"([^"]+)"/);
+    const contentMatch = body.match(/"content"\s*:\s*"([\s\S]*)"\s*}?\s*$/);
+    if (pathMatch && contentMatch && contentMatch[1] !== undefined) {
+      return {
+        path: pathMatch[1]!.replace(/\\/g, "/"),
+        content: contentMatch[1]!.replace(/\\n/g, "\n").replace(/\\t/g, "\t"),
+      };
     }
+
+    return null;
   },
   summariseInput: ({ path, content }) => `${path} (${content.length} bytes)`,
   execute: ({ path: filePath, content }, ctx) => ({