@ridit/lens 0.1.9 → 0.2.1

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/history.ts

@@ -1,86 +0,0 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
-import path from "path";
-import os from "os";
-
-export type HistoryEntryKind =
-  | "file-written"
-  | "file-read"
-  | "url-fetched"
-  | "shell-run"
-  | "code-applied"
-  | "code-skipped";
-
-export type HistoryEntry = {
-  kind: HistoryEntryKind;
-  detail: string;
-  summary: string;
-  timestamp: string;
-  repoPath: string;
-};
-
-export type HistoryFile = {
-  entries: HistoryEntry[];
-};
-
-const LENS_DIR = path.join(os.homedir(), ".lens");
-const HISTORY_PATH = path.join(LENS_DIR, "history.json");
-
-function loadHistory(): HistoryFile {
-  if (!existsSync(HISTORY_PATH)) return { entries: [] };
-  try {
-    return JSON.parse(readFileSync(HISTORY_PATH, "utf-8")) as HistoryFile;
-  } catch {
-    return { entries: [] };
-  }
-}
-
-function saveHistory(h: HistoryFile): void {
-  if (!existsSync(LENS_DIR)) mkdirSync(LENS_DIR, { recursive: true });
-  writeFileSync(HISTORY_PATH, JSON.stringify(h, null, 2), "utf-8");
-}
-
-export function appendHistory(entry: Omit<HistoryEntry, "timestamp">): void {
-  const h = loadHistory();
-  h.entries.push({ ...entry, timestamp: new Date().toISOString() });
-
-  if (h.entries.length > 500) h.entries = h.entries.slice(-500);
-  saveHistory(h);
-}
-
-/**
- * Returns a compact summary string to inject into the system prompt.
- * Only includes entries for the current repo, most recent 50.
- */
-export function buildHistorySummary(repoPath: string): string {
-  const h = loadHistory();
-  const relevant = h.entries.filter((e) => e.repoPath === repoPath).slice(-50);
-
-  if (relevant.length === 0) return "";
-
-  const lines = relevant.map((e) => {
-    const ts = new Date(e.timestamp).toLocaleString();
-    return `[${ts}] ${e.kind}: ${e.detail} — ${e.summary}`;
-  });
-
-  return `## WHAT YOU HAVE ALREADY DONE IN THIS REPO
-
-The following actions have already been completed. Do NOT repeat them unless the user explicitly asks you to redo something:
-
-${lines.join("\n")}`;
-}
-
-/**
- * Returns all entries for a repo, for display purposes.
- */
-export function getRepoHistory(repoPath: string): HistoryEntry[] {
-  return loadHistory().entries.filter((e) => e.repoPath === repoPath);
-}
-
-/**
- * Clears all history for a repo.
- */
-export function clearRepoHistory(repoPath: string): void {
-  const h = loadHistory();
-  h.entries = h.entries.filter((e) => e.repoPath !== repoPath);
-  saveHistory(h);
-}