@ridit/lens 0.2.0 → 0.2.2

package/src/utils/chatHistory.ts

@@ -0,0 +1,121 @@
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  readdirSync,
+  writeFileSync,
+  unlinkSync,
+} from "fs";
+import path from "path";
+import os from "os";
+import type { Message } from "../types/chat";
+
+const LENS_DIR = path.join(os.homedir(), ".lens");
+const CHATS_DIR = path.join(LENS_DIR, "chats");
+
+export type SavedChat = {
+  name: string;
+  repoPath: string;
+  messages: Message[];
+  savedAt: string;
+  userMessageCount: number;
+};
+
+function ensureChatsDir(): void {
+  if (!existsSync(CHATS_DIR)) mkdirSync(CHATS_DIR, { recursive: true });
+}
+
+function chatFilePath(name: string): string {
+  const safe = name.replace(/[^a-z0-9_-]/gi, "-").toLowerCase();
+  return path.join(CHATS_DIR, `${safe}.json`);
+}
+
+export function saveChat(
+  name: string,
+  repoPath: string,
+  messages: Message[],
+): void {
+  ensureChatsDir();
+  const data: SavedChat = {
+    name,
+    repoPath,
+    messages,
+    savedAt: new Date().toISOString(),
+    userMessageCount: messages.filter((m) => m.role === "user").length,
+  };
+  writeFileSync(chatFilePath(name), JSON.stringify(data, null, 2), "utf-8");
+}
+
+export function loadChat(name: string): SavedChat | null {
+  const filePath = chatFilePath(name);
+  if (!existsSync(filePath)) return null;
+  try {
+    return JSON.parse(readFileSync(filePath, "utf-8")) as SavedChat;
+  } catch {
+    return null;
+  }
+}
+
+export function listChats(repoPath?: string): SavedChat[] {
+  ensureChatsDir();
+  const files = readdirSync(CHATS_DIR).filter((f) => f.endsWith(".json"));
+  const chats: SavedChat[] = [];
+  for (const file of files) {
+    try {
+      const data = JSON.parse(
+        readFileSync(path.join(CHATS_DIR, file), "utf-8"),
+      ) as SavedChat;
+      if (!repoPath || data.repoPath === repoPath) chats.push(data);
+    } catch {
+      // skip corrupt files
+    }
+  }
+  return chats.sort(
+    (a, b) => new Date(b.savedAt).getTime() - new Date(a.savedAt).getTime(),
+  );
+}
+
+export function deleteChat(name: string): boolean {
+  const filePath = chatFilePath(name);
+  if (!existsSync(filePath)) return false;
+  try {
+    unlinkSync(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export function getChatNameSuggestions(messages: Message[]): string[] {
+  const userMsgs = messages
+    .filter((m) => m.role === "user")
+    .map((m) => m.content.toLowerCase().trim());
+
+  const date = new Date().toISOString().slice(0, 10);
+
+  if (userMsgs.length === 0) {
+    return [`chat-${date}`, `session-${date}`, `new-chat`];
+  }
+
+  const suggestions: string[] = [];
+
+  const toSlug = (s: string) =>
+    s
+      .replace(/[^a-z0-9\s]/g, "")
+      .split(/\s+/)
+      .filter(Boolean)
+      .slice(0, 4)
+      .join("-");
+
+  const firstSlug = toSlug(userMsgs[0]!);
+  if (firstSlug) suggestions.push(firstSlug);
+
+  if (userMsgs.length > 1) {
+    const lastSlug = toSlug(userMsgs[userMsgs.length - 1]!);
+    if (lastSlug && lastSlug !== firstSlug) suggestions.push(lastSlug);
+  }
+
+  suggestions.push(`session-${date}`);
+
+  return suggestions.slice(0, 3);
+}

package/src/utils/files.ts

@@ -71,6 +71,7 @@ export function readImportantFiles(
   repoPath: string,
   files: string[],
 ): ImportantFile[] {
+  if (files.length > 100) return [];
   return files.filter(isImportantFile).flatMap((filePath) => {
     try {
       const content = readFileSync(path.join(repoPath, filePath), "utf-8");

package/src/utils/memory.ts

@@ -0,0 +1,137 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import path from "path";
+import os from "os";
+
+export type MemoryEntryKind =
+  | "file-written"
+  | "file-read"
+  | "url-fetched"
+  | "shell-run"
+  | "code-applied"
+  | "code-skipped";
+
+export type MemoryEntry = {
+  kind: MemoryEntryKind;
+  detail: string;
+  summary: string;
+  timestamp: string;
+  repoPath: string;
+};
+
+export type Memory = {
+  id: string;
+  content: string;
+  timestamp: string;
+  repoPath: string;
+};
+
+export type MemoryFile = {
+  entries: MemoryEntry[];
+  memories: Memory[];
+};
+
+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: [] };
+  try {
+    const data = JSON.parse(
+      readFileSync(MEMORY_PATH, "utf-8"),
+    ) as Partial<MemoryFile>;
+    return {
+      entries: data.entries ?? [],
+      memories: data.memories ?? [],
+    };
+  } catch {
+    return { entries: [], memories: [] };
+  }
+}
+
+function saveMemoryFile(m: MemoryFile): void {
+  if (!existsSync(LENS_DIR)) mkdirSync(LENS_DIR, { recursive: true });
+  writeFileSync(MEMORY_PATH, JSON.stringify(m, null, 2), "utf-8");
+}
+
+// ── Action entries (what the model has done) ──────────────────────────────────
+
+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);
+}
+
+export function buildMemorySummary(repoPath: string): string {
+  const m = loadMemoryFile();
+  const relevant = m.entries.filter((e) => e.repoPath === repoPath).slice(-50);
+
+  const memories = m.memories.filter((mem) => mem.repoPath === repoPath);
+
+  const parts: string[] = [];
+
+  if (memories.length > 0) {
+    parts.push(
+      `## MEMORIES ABOUT THIS REPO\n\n${memories
+        .map((mem) => `- [${mem.id}] ${mem.content}`)
+        .join("\n")}`,
+    );
+  }
+
+  if (relevant.length > 0) {
+    const lines = relevant.map((e) => {
+      const ts = new Date(e.timestamp).toLocaleString();
+      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")}`,
+    );
+  }
+
+  return parts.join("\n\n");
+}
+
+export function getRepoMemory(repoPath: string): MemoryEntry[] {
+  return loadMemoryFile().entries.filter((e) => e.repoPath === repoPath);
+}
+
+export function clearRepoMemory(repoPath: string): void {
+  const m = loadMemoryFile();
+  m.entries = m.entries.filter((e) => e.repoPath !== repoPath);
+  m.memories = m.memories.filter((mem) => 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 memory: Memory = {
+    id: generateId(),
+    content,
+    timestamp: new Date().toISOString(),
+    repoPath,
+  };
+  m.memories.push(memory);
+  saveMemoryFile(m);
+  return 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 && mem.repoPath === repoPath),
+  );
+  if (m.memories.length === before) return false;
+  saveMemoryFile(m);
+  return true;
+}
+
+export function listMemories(repoPath: string): Memory[] {
+  return loadMemoryFile().memories.filter((mem) => mem.repoPath === repoPath);
+}

package/src/utils/tools/builtins.ts

@@ -0,0 +1,324 @@
+import type { Tool, ToolContext, ToolResult } from "./registry";
+import {
+  fetchUrl,
+  searchWeb,
+  runShell,
+  openUrl,
+  readFile,
+  readFolder,
+  grepFiles,
+  writeFile,
+  deleteFile,
+  deleteFolder,
+  generatePdf,
+} from "../../tools";
+
+// ── fetch ─────────────────────────────────────────────────────────────────────
+
+export const fetchTool: Tool<string> = {
+  name: "fetch",
+  description: "load a URL",
+  safe: true,
+  permissionLabel: "fetch",
+  systemPromptEntry: (i) =>
+    `### ${i}. fetch — load a URL\n<fetch>https://example.com</fetch>`,
+  parseInput: (body) => body.replace(/^<|>$/g, "").trim() || null,
+  summariseInput: (url) => url,
+  execute: async (url) => {
+    try {
+      const value = await fetchUrl(url);
+      return { kind: "text", value };
+    } catch (err) {
+      return {
+        kind: "error",
+        value: `Fetch failed: ${err instanceof Error ? err.message : String(err)}`,
+      };
+    }
+  },
+};
+
+// ── shell ─────────────────────────────────────────────────────────────────────
+
+export const shellTool: Tool<string> = {
+  name: "shell",
+  description: "run a terminal command",
+  safe: false,
+  permissionLabel: "run",
+  systemPromptEntry: (i) =>
+    `### ${i}. shell — run a terminal command\n<shell>node -v</shell>`,
+  parseInput: (body) => body || null,
+  summariseInput: (cmd) => cmd,
+  execute: async (cmd, ctx) => {
+    const value = await runShell(cmd, ctx.repoPath);
+    return { kind: "text", value };
+  },
+};
+
+// ── read-file ─────────────────────────────────────────────────────────────────
+
+export const readFileTool: Tool<string> = {
+  name: "read-file",
+  description: "read a file from the repo",
+  safe: true,
+  permissionLabel: "read",
+  systemPromptEntry: (i) =>
+    `### ${i}. read-file — read a file from the repo\n<read-file>src/foo.ts</read-file>`,
+  parseInput: (body) => body || null,
+  summariseInput: (p) => p,
+  execute: (filePath, ctx) => ({
+    kind: "text",
+    value: readFile(filePath, ctx.repoPath),
+  }),
+};
+
+// ── read-folder ───────────────────────────────────────────────────────────────
+
+export const readFolderTool: Tool<string> = {
+  name: "read-folder",
+  description: "list contents of a folder (files + subfolders, one level deep)",
+  safe: true,
+  permissionLabel: "folder",
+  systemPromptEntry: (i) =>
+    `### ${i}. read-folder — list contents of a folder (files + subfolders, one level deep)\n<read-folder>src/components</read-folder>`,
+  parseInput: (body) => body || null,
+  summariseInput: (p) => p,
+  execute: (folderPath, ctx) => ({
+    kind: "text",
+    value: readFolder(folderPath, ctx.repoPath),
+  }),
+};
+
+// ── grep ──────────────────────────────────────────────────────────────────────
+
+interface GrepInput {
+  pattern: string;
+  glob: string;
+}
+
+export const grepTool: Tool<GrepInput> = {
+  name: "grep",
+  description: "search for a pattern across files in the repo",
+  safe: true,
+  permissionLabel: "grep",
+  systemPromptEntry: (i) =>
+    `### ${i}. grep — search for a pattern across files in the repo (cross-platform, no shell needed)\n<grep>\n{"pattern": "ChatRunner", "glob": "src/**/*.tsx"}\n</grep>`,
+  parseInput: (body) => {
+    try {
+      const parsed = JSON.parse(body) as { pattern: string; glob?: string };
+      return { pattern: parsed.pattern, glob: parsed.glob ?? "**/*" };
+    } catch {
+      return { pattern: body, glob: "**/*" };
+    }
+  },
+  summariseInput: ({ pattern, glob }) => `${pattern} — ${glob}`,
+  execute: ({ pattern, glob }, ctx) => ({
+    kind: "text",
+    value: grepFiles(pattern, glob, ctx.repoPath),
+  }),
+};
+
+// ── write-file ────────────────────────────────────────────────────────────────
+
+interface WriteFileInput {
+  path: string;
+  content: string;
+}
+
+export const writeFileTool: Tool<WriteFileInput> = {
+  name: "write-file",
+  description: "create or overwrite a file",
+  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) => {
+    try {
+      const parsed = JSON.parse(body) as { path: string; content: string };
+      if (!parsed.path) return null;
+      return parsed;
+    } catch {
+      return null;
+    }
+  },
+  summariseInput: ({ path, content }) => `${path} (${content.length} bytes)`,
+  execute: ({ path: filePath, content }, ctx) => ({
+    kind: "text",
+    value: writeFile(filePath, content, ctx.repoPath),
+  }),
+};
+
+// ── delete-file ───────────────────────────────────────────────────────────────
+
+export const deleteFileTool: Tool<string> = {
+  name: "delete-file",
+  description: "permanently delete a single file",
+  safe: false,
+  permissionLabel: "delete",
+  systemPromptEntry: (i) =>
+    `### ${i}. delete-file — permanently delete a single file\n<delete-file>src/old-component.tsx</delete-file>`,
+  parseInput: (body) => body || null,
+  summariseInput: (p) => p,
+  execute: (filePath, ctx) => ({
+    kind: "text",
+    value: deleteFile(filePath, ctx.repoPath),
+  }),
+};
+
+// ── delete-folder ─────────────────────────────────────────────────────────────
+
+export const deleteFolderTool: Tool<string> = {
+  name: "delete-folder",
+  description: "permanently delete a folder and all its contents",
+  safe: false,
+  permissionLabel: "delete folder",
+  systemPromptEntry: (i) =>
+    `### ${i}. delete-folder — permanently delete a folder and all its contents\n<delete-folder>src/legacy</delete-folder>`,
+  parseInput: (body) => body || null,
+  summariseInput: (p) => p,
+  execute: (folderPath, ctx) => ({
+    kind: "text",
+    value: deleteFolder(folderPath, ctx.repoPath),
+  }),
+};
+
+// ── open-url ──────────────────────────────────────────────────────────────────
+
+export const openUrlTool: Tool<string> = {
+  name: "open-url",
+  description: "open a URL in the user's default browser",
+  safe: true,
+  permissionLabel: "open",
+  systemPromptEntry: (i) =>
+    `### ${i}. open-url — open a URL in the user's default browser\n<open-url>https://github.com/owner/repo</open-url>`,
+  parseInput: (body) => body.replace(/^<|>$/g, "").trim() || null,
+  summariseInput: (url) => url,
+  execute: (url) => ({ kind: "text", value: openUrl(url) }),
+};
+
+// ── generate-pdf ──────────────────────────────────────────────────────────────
+
+interface GeneratePdfInput {
+  filePath: string;
+  content: string;
+}
+
+export const generatePdfTool: Tool<GeneratePdfInput> = {
+  name: "generate-pdf",
+  description: "generate a PDF file from markdown-style content",
+  safe: false,
+  permissionLabel: "pdf",
+  systemPromptEntry: (i) =>
+    `### ${i}. generate-pdf — generate a PDF file from markdown-style content\n<generate-pdf>\n{"path": "output/report.pdf", "content": "# Title\\n\\nSome body text."}\n</generate-pdf>`,
+  parseInput: (body) => {
+    try {
+      const parsed = JSON.parse(body) as {
+        path?: string;
+        filePath?: string;
+        content?: string;
+      };
+      return {
+        filePath: parsed.path ?? parsed.filePath ?? "output.pdf",
+        content: parsed.content ?? "",
+      };
+    } catch {
+      return null;
+    }
+  },
+  summariseInput: ({ filePath }) => filePath,
+  execute: ({ filePath, content }, ctx) => ({
+    kind: "text",
+    value: generatePdf(filePath, content, ctx.repoPath),
+  }),
+};
+
+// ── search ────────────────────────────────────────────────────────────────────
+
+export const searchTool: Tool<string> = {
+  name: "search",
+  description: "search the internet for anything you are unsure about",
+  safe: true,
+  permissionLabel: "search",
+  systemPromptEntry: (i) =>
+    `### ${i}. search — search the internet for anything you are unsure about\n<search>how to use React useEffect cleanup function</search>`,
+  parseInput: (body) => body || null,
+  summariseInput: (q) => `"${q}"`,
+  execute: async (query) => {
+    try {
+      const value = await searchWeb(query);
+      return { kind: "text", value };
+    } catch (err) {
+      return {
+        kind: "error",
+        value: `Search failed: ${err instanceof Error ? err.message : String(err)}`,
+      };
+    }
+  },
+};
+
+// ── clone ─────────────────────────────────────────────────────────────────────
+
+export const cloneTool: Tool<string> = {
+  name: "clone",
+  description: "clone a GitHub repo so you can explore and discuss it",
+  safe: false,
+  permissionLabel: "clone",
+  systemPromptEntry: (i) =>
+    `### ${i}. clone — clone a GitHub repo so you can explore and discuss it\n<clone>https://github.com/owner/repo</clone>`,
+  parseInput: (body) => body.replace(/^<|>$/g, "").trim() || null,
+  summariseInput: (url) => url,
+  // Clone is handled specially by ChatRunner (it triggers a UI flow),
+  // so execute here is just a fallback that should never run.
+  execute: (repoUrl) => ({
+    kind: "text",
+    value: `Clone of ${repoUrl} was handled by the UI.`,
+  }),
+};
+
+// ── changes ───────────────────────────────────────────────────────────────────
+
+export interface ChangesInput {
+  summary: string;
+  patches: { path: string; content: string; isNew: boolean }[];
+}
+
+export const changesTool: Tool<ChangesInput> = {
+  name: "changes",
+  description: "propose code edits (shown as a diff for user approval)",
+  safe: false,
+  permissionLabel: "changes",
+  systemPromptEntry: (i) =>
+    `### ${i}. changes — propose code edits (shown as a diff for user approval)\n<changes>\n{"summary": "what changed and why", "patches": [{"path": "src/foo.ts", "content": "COMPLETE file content", "isNew": false}]}\n</changes>`,
+  parseInput: (body) => {
+    try {
+      return JSON.parse(body) as ChangesInput;
+    } catch {
+      return null;
+    }
+  },
+  summariseInput: ({ summary }) => summary,
+  // changes is handled specially by ChatRunner (diff preview UI).
+  execute: ({ summary }) => ({
+    kind: "text",
+    value: `Changes proposed: ${summary}`,
+  }),
+};
+
+// ── registerBuiltins ──────────────────────────────────────────────────────────
+
+import { registry } from "./registry";
+
+export function registerBuiltins(): void {
+  registry.register(fetchTool);
+  registry.register(shellTool);
+  registry.register(readFileTool);
+  registry.register(readFolderTool);
+  registry.register(grepTool);
+  registry.register(writeFileTool);
+  registry.register(deleteFileTool);
+  registry.register(deleteFolderTool);
+  registry.register(openUrlTool);
+  registry.register(generatePdfTool);
+  registry.register(searchTool);
+  registry.register(cloneTool);
+  registry.register(changesTool);
+}