@ridit/lens 0.3.5 → 0.3.7

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

@@ -1,4 +1,5 @@
 import type { Tool, ToolContext } from "@ridit/lens-sdk";
+import { TOOL_TAGS } from "@ridit/lens-sdk";
 import {
   fetchUrl,
   searchWeb,
@@ -23,6 +24,7 @@ export const fetchTool: Tool<string> = {
   name: "fetch",
   description: "load a URL",
   safe: true,
+  tag: TOOL_TAGS.net,
   permissionLabel: "fetch",
   systemPromptEntry: (i) =>
     `### ${i}. fetch — load a URL\n<fetch>https://example.com</fetch>`,
@@ -45,6 +47,7 @@ export const shellTool: Tool<string> = {
   name: "shell",
   description: "run a terminal command",
   safe: false,
+  tag: TOOL_TAGS.shell,
   permissionLabel: "run",
   systemPromptEntry: (i) =>
     `### ${i}. shell — run a terminal command\n<shell>node -v</shell>`,
@@ -60,6 +63,7 @@ export const readFileTool: Tool<string> = {
   name: "read-file",
   description: "read a file from the repo",
   safe: true,
+  tag: TOOL_TAGS.read,
   permissionLabel: "read",
   systemPromptEntry: (i) =>
     `### ${i}. read-file — read a file from the repo\n<read-file>src/foo.ts</read-file>`,
@@ -74,6 +78,7 @@ export const readFileTool: Tool<string> = {
 export const readFolderTool: Tool<string> = {
   name: "read-folder",
   description: "list contents of a folder (files + subfolders, one level deep)",
+  tag: TOOL_TAGS.read,
   safe: true,
   permissionLabel: "folder",
   systemPromptEntry: (i) =>
@@ -94,6 +99,7 @@ interface GrepInput {
 export const grepTool: Tool<GrepInput> = {
   name: "grep",
   description: "search for a pattern across files in the repo",
+  tag: TOOL_TAGS.find,
   safe: true,
   permissionLabel: "grep",
   systemPromptEntry: (i) =>
@@ -124,18 +130,45 @@ interface WriteFileInput {
 export const writeFileTool: Tool<WriteFileInput> = {
   name: "write-file",
   description: "create or overwrite a file",
+  tag: TOOL_TAGS.write,
   safe: false,
   permissionLabel: "write",
   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) => ({
@@ -147,6 +180,7 @@ export const writeFileTool: Tool<WriteFileInput> = {
 export const deleteFileTool: Tool<string> = {
   name: "delete-file",
   description: "permanently delete a single file",
+  tag: TOOL_TAGS.delete,
   safe: false,
   permissionLabel: "delete",
   systemPromptEntry: (i) =>
@@ -162,6 +196,7 @@ export const deleteFileTool: Tool<string> = {
 export const deleteFolderTool: Tool<string> = {
   name: "delete-folder",
   description: "permanently delete a folder and all its contents",
+  tag: TOOL_TAGS.delete,
   safe: false,
   permissionLabel: "delete folder",
   systemPromptEntry: (i) =>
@@ -177,6 +212,7 @@ export const deleteFolderTool: Tool<string> = {
 export const openUrlTool: Tool<string> = {
   name: "open-url",
   description: "open a URL in the user's default browser",
+  tag: TOOL_TAGS.net,
   safe: true,
   permissionLabel: "open",
   systemPromptEntry: (i) =>
@@ -194,6 +230,7 @@ interface GeneratePdfInput {
 export const generatePdfTool: Tool<GeneratePdfInput> = {
   name: "generate-pdf",
   description: "generate a PDF file from markdown-style content",
+  tag: TOOL_TAGS.write,
   safe: false,
   permissionLabel: "pdf",
   systemPromptEntry: (i) =>
@@ -222,6 +259,7 @@ export const generatePdfTool: Tool<GeneratePdfInput> = {
 
 export const searchTool: Tool<string> = {
   name: "search",
+  tag: TOOL_TAGS.net,
   description: "search the internet for anything you are unsure about",
   safe: true,
   permissionLabel: "search",
@@ -245,6 +283,7 @@ export const searchTool: Tool<string> = {
 export const cloneTool: Tool<string> = {
   name: "clone",
   description: "clone a GitHub repo so you can explore and discuss it",
+  tag: TOOL_TAGS.write,
   safe: false,
   permissionLabel: "clone",
   systemPromptEntry: (i) =>
@@ -265,6 +304,7 @@ export interface ChangesInput {
 export const changesTool: Tool<ChangesInput> = {
   name: "changes",
   description: "propose code edits (shown as a diff for user approval)",
+  tag: TOOL_TAGS.write,
   safe: false,
   permissionLabel: "changes",
   systemPromptEntry: (i) =>
@@ -290,6 +330,7 @@ interface ReadFilesInput {
 export const readFilesTool: Tool<ReadFilesInput> = {
   name: "read-files",
   description: "read multiple files from the repo at once",
+  tag: TOOL_TAGS.read,
   safe: true,
   permissionLabel: "read",
   systemPromptEntry: (i) =>

package/src/utils/tools/registry.ts

@@ -1,4 +1,23 @@
-import type { Tool } from "@ridit/lens-sdk";
+import type { Tool, ToolTag } from "@ridit/lens-sdk";
+import type { Intent } from "../intentClassifier";
+
+/**
+ * Broad capability category for a tool.
+ * Used to filter the system prompt based on classified user intent.
+ *
+ * "read"   — safe, purely observational (read-file, read-folder, grep, etc.)
+ * "net"    — outbound network (fetch, search, clone, open-url)
+ * "write"  — creates or overwrites file content (write-file, changes, generate-pdf)
+ * "delete" — destructive removal (delete-file, delete-folder)
+ * "shell"  — arbitrary shell execution
+ */
+
+/** Tools allowed for each intent level */
+const INTENT_ALLOWED: Record<Intent, ToolTag[]> = {
+  readonly: ["read", "net"],
+  mutating: ["read", "net", "write", "delete", "shell"],
+  any: ["read", "net", "write", "delete", "shell"],
+};
 
 class ToolRegistry {
   private tools = new Map<string, Tool<unknown>>();
@@ -27,17 +46,54 @@ class ToolRegistry {
   }
 
   /**
-   * Build the TOOLS section of the system prompt from all registered tools.
+   * Returns tool names that are allowed for the given intent.
+   * Falls back to all names when a tool has no tag (legacy / addons).
+   */
+  namesForIntent(intent: Intent): string[] {
+    const allowed = new Set(INTENT_ALLOWED[intent]);
+    return Array.from(this.tools.values())
+      .filter((t) => {
+        const tag = (t as any).tag as ToolTag | undefined;
+        // No tag = addon / unknown → always allow (conservative)
+        if (!tag) return true;
+        return allowed.has(tag);
+      })
+      .map((t) => t.name);
+  }
+
+  /**
+   * Build the TOOLS section of the system prompt from all registered tools,
+   * optionally scoped to a specific intent.
+   *
+   * When intent is "readonly", write/delete/shell tools are omitted entirely
+   * so the LLM never sees them and can't hallucinate calls to them.
    */
-  buildSystemPromptSection(): string {
+  buildSystemPromptSection(intent: Intent = "any"): string {
+    const allowed = new Set(INTENT_ALLOWED[intent]);
+
+    const visible = Array.from(this.tools.values()).filter((t) => {
+      const tag = (t as any).tag as ToolTag | undefined;
+      if (!tag) return true; // addon without tag → always show
+      return allowed.has(tag);
+    });
+
     const lines: string[] = ["## TOOLS\n"];
-    lines.push(
-      "You have exactly " +
-        this.tools.size +
-        " tools. To use a tool you MUST wrap it in the exact XML tags shown below — no other format will work.\n",
-    );
+
+    if (intent === "readonly") {
+      lines.push(
+        `You have ${visible.length} tools available for this read-only request. ` +
+          `Do NOT attempt to write, delete, or run shell commands — ` +
+          `those tools are not available right now.\n`,
+      );
+    } else {
+      lines.push(
+        `You have exactly ${visible.length} tools. To use a tool you MUST wrap it ` +
+          `in the exact XML tags shown below — no other format will work.\n`,
+      );
+    }
+
     let i = 1;
-    for (const tool of this.tools.values()) {
+    for (const tool of visible) {
       lines.push(tool.systemPromptEntry(i++));
     }
     return lines.join("\n");