@ridit/lens 0.3.7 → 0.3.9

package/src/utils/chatHistory.ts

@@ -1,121 +0,0 @@
-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/config.ts

@@ -1,61 +0,0 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
-import path from "path";
-import os from "os";
-import type { Config, Provider } from "../types/config";
-
-const CONFIG_DIR = path.join(os.homedir(), ".lens");
-const CONFIG_PATH = path.join(CONFIG_DIR, "config.json");
-
-export function configExists(): boolean {
-  return existsSync(CONFIG_PATH);
-}
-
-export function loadConfig(): Config {
-  if (!configExists()) return { providers: [] };
-  try {
-    return JSON.parse(readFileSync(CONFIG_PATH, "utf-8")) as Config;
-  } catch {
-    return { providers: [] };
-  }
-}
-
-export function saveConfig(config: Config): void {
-  if (!existsSync(CONFIG_DIR)) mkdirSync(CONFIG_DIR, { recursive: true });
-  writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2), "utf-8");
-}
-
-export function addProvider(provider: Provider): void {
-  const config = loadConfig();
-  const existing = config.providers.findIndex((p) => p.id === provider.id);
-  if (existing >= 0) {
-    config.providers[existing] = provider;
-  } else {
-    config.providers.push(provider);
-  }
-  if (!config.defaultProviderId) config.defaultProviderId = provider.id;
-  saveConfig(config);
-}
-
-export function setDefaultProvider(id: string): void {
-  const config = loadConfig();
-  config.defaultProviderId = id;
-  saveConfig(config);
-}
-
-export function getDefaultProvider(): Provider | undefined {
-  const config = loadConfig();
-  return config.providers.find((p) => p.id === config.defaultProviderId);
-}
-
-export const DEFAULT_MODELS: Record<string, string[]> = {
-  anthropic: [
-    "claude-sonnet-4-20250514",
-    "claude-opus-4-20250514",
-    "claude-haiku-4-5-20251001",
-  ],
-  openai: ["gpt-4o", "gpt-4o-mini", "gpt-4-turbo"],
-  ollama: ["llama3", "mistral", "codellama", "phi3"],
-  custom: [],
-};
-
-export type CustomResult = { apiKey: string; baseUrl: string };

package/src/utils/files.ts

@@ -1,105 +0,0 @@
-import { readFileSync } from "fs";
-import path from "path";
-import { exec } from "child_process";
-import figures from "figures";
-import type { FileTree, ImportantFile } from "../types/repo";
-
-export const IMPORTANT_PATTERNS = [
-  /^\.gitignore$/,
-  /^\.env(\..+)?$/,
-  /^\.env\.example$/,
-  /^package\.json$/,
-  /^tsconfig(\..+)?\.json$/,
-  /^jsconfig\.json$/,
-  /^vite\.config\.(ts|js)$/,
-  /^webpack\.config\.(ts|js)$/,
-  /^rollup\.config\.(ts|js)$/,
-  /^babel\.config\.(ts|js|json)$/,
-  /^\.babelrc$/,
-  /^eslint\.config\.(ts|js|json)$/,
-  /^\.eslintrc(\..+)?$/,
-  /^\.prettierrc(\..+)?$/,
-  /^prettier\.config\.(ts|js)$/,
-  /^docker-compose(\..+)?\.yml$/,
-  /^Dockerfile(\..+)?$/,
-  /^README(\..+)?\.md$/,
-  /^LICENSE(\..+)?$/,
-  /^Makefile$/,
-  /^\.github\/workflows\/.+\.yml$/,
-];
-
-export function isImportantFile(filePath: string): boolean {
-  const fileName = path.basename(filePath);
-  return IMPORTANT_PATTERNS.some(
-    (pattern) => pattern.test(fileName) || pattern.test(filePath),
-  );
-}
-
-export function buildTree(files: string[]): FileTree[] {
-  const root: FileTree[] = [];
-  for (const file of files) {
-    const parts = file.split("/");
-    let current = root;
-    for (let i = 0; i < parts.length; i++) {
-      const part = parts[i] ?? "";
-      const isFile = i === parts.length - 1;
-      const existing = current.find((n) => n.name === part);
-      if (existing) {
-        if (!isFile && existing.children) current = existing.children;
-      } else {
-        const node: FileTree = isFile
-          ? { name: part }
-          : { name: part, children: [] };
-        current.push(node);
-        if (!isFile && node.children) current = node.children;
-      }
-    }
-  }
-  return root;
-}
-
-export function fetchFileTree(repoPath: string): Promise<string[]> {
-  return new Promise((resolve, reject) => {
-    exec("git ls-files", { cwd: repoPath }, (err, stdout) => {
-      if (err) return reject(err);
-      resolve(stdout.trim().split("\n").filter(Boolean));
-    });
-  });
-}
-
-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");
-      return [{ path: filePath, content }];
-    } catch {
-      return [];
-    }
-  });
-}
-
-const FILE_ICON: Record<string, string> = {
-  ".gitignore": figures.pointer,
-  "package.json": figures.nodejs,
-  Dockerfile: figures.square,
-  Makefile: figures.play,
-  "README.md": figures.info,
-  LICENSE: figures.star,
-  ".env": figures.warning,
-  ".env.example": figures.warning,
-};
-
-export function iconForFile(filePath: string): string {
-  const name = path.basename(filePath);
-  for (const [key, icon] of Object.entries(FILE_ICON)) {
-    if (name === key || name.startsWith(key)) return icon;
-  }
-  if (name.endsWith(".json")) return figures.arrowRight;
-  if (name.endsWith(".yml") || name.endsWith(".yaml")) return figures.bullet;
-  if (name.startsWith(".")) return figures.dot;
-  return figures.pointerSmall;
-}

package/src/utils/intentClassifier.ts

@@ -1,58 +0,0 @@
-/**
- * Classifies user message intent to scope which tools the LLM is allowed to use.
- *
- * readonly  → only read/search/fetch tools exposed (no write, delete, shell)
- * mutating  → all tools exposed
- * any       → all tools exposed (ambiguous / can't tell)
- */
-export type Intent = "readonly" | "mutating" | "any";
-
-const READONLY_PATTERNS: RegExp[] = [
-  // listing / exploring
-  /\b(list|ls|dir|show|display|print|dump)\b/i,
-  /\bwhat(('?s| is| are| does)\b| files| folder)/i,
-  /\b(folder|directory|file) (structure|tree|layout|contents?)\b/i,
-  /\bexplore\b/i,
-
-  // reading / explaining
-  /\b(read|open|view|look at|check out|inspect|peek)\b/i,
-  /\b(explain|describe|summarize|summarise|tell me about|walk me through)\b/i,
-  /\bhow does\b/i,
-  /\bwhat('?s| is) (in|inside|this|that|the)\b/i,
-
-  // searching
-  /\b(find|search|grep|locate|where is|where are)\b/i,
-  /\b(look for|scan|trace)\b/i,
-
-  // understanding
-  /\bunderstand\b/i,
-  /\bshow me (how|what|where|why)\b/i,
-];
-
-const MUTATING_PATTERNS: RegExp[] = [
-  // writing
-  /\b(write|create|make|generate|add|build|scaffold|init|initialize|setup|set up)\b/i,
-  /\b(new file|new folder|new component|new page|new route)\b/i,
-
-  // editing
-  /\b(edit|modify|update|change|refactor|rename|move|migrate)\b/i,
-  /\b(fix|patch|resolve|correct|debug|repair)\b/i,
-  /\b(implement|add .+ to|insert|inject|append|prepend)\b/i,
-
-  // deleting
-  /\b(delete|remove|drop|clean ?up|purge|wipe)\b/i,
-
-  // running
-  /\b(run|execute|install|deploy|build|test|start|launch|compile|lint|format)\b/i,
-];
-
-export function classifyIntent(userMessage: string): Intent {
-  const text = userMessage.trim();
-
-  const mutatingScore = MUTATING_PATTERNS.filter((p) => p.test(text)).length;
-  const readonlyScore = READONLY_PATTERNS.filter((p) => p.test(text)).length;
-
-  if (mutatingScore === 0 && readonlyScore > 0) return "readonly";
-  if (mutatingScore > 0) return "mutating";
-  return "any";
-}

package/src/utils/lensfile.ts

@@ -1,142 +0,0 @@
-import { existsSync, readFileSync, writeFileSync } from "fs";
-import path from "path";
-import type { AnalysisResult } from "../types/repo";
-
-export const LENS_FILENAME = "LENS.md";
-
-export type LensFile = {
-  overview: string;
-  importantFolders: string[];
-  tooling: Record<string, string>;
-  keyFiles: string[];
-  patterns: string[];
-  architecture: string;
-  suggestions: string[];
-  generatedAt: string;
-  lastUpdated: string;
-};
-
-export function lensFilePath(repoPath: string): string {
-  return path.join(repoPath, LENS_FILENAME);
-}
-
-export function lensFileExists(repoPath: string): boolean {
-  return existsSync(lensFilePath(repoPath));
-}
-
-function renderLensFile(data: LensFile): string {
-  const toolingLines = Object.entries(data.tooling)
-    .map(([k, v]) => `- **${k}**: ${v}`)
-    .join("\n");
-
-  return `# Lens
-> Generated: ${data.generatedAt}${data.lastUpdated !== data.generatedAt ? `  |  Updated: ${data.lastUpdated}` : ""}
-
-## Overview
-${data.overview}
-
-## Architecture
-${data.architecture}
-
-## Tooling & Conventions
-${toolingLines || "- Not yet determined"}
-
-## Important Folders
-${data.importantFolders.map((f) => `- ${f}`).join("\n") || "- None"}
-
-## Key Files
-${data.keyFiles.map((f) => `- ${f}`).join("\n") || "- None"}
-
-## Patterns & Idioms
-${data.patterns.map((p) => `- ${p}`).join("\n") || "- None"}
-
-## Suggestions
-${data.suggestions.map((s) => `- ${s}`).join("\n") || "- None"}
-
-<!--lens-json
-${JSON.stringify(data)}
-lens-json-->
-`;
-}
-
-export function writeLensFile(repoPath: string, result: AnalysisResult): void {
-  const now = new Date().toISOString();
-  const data: LensFile = {
-    overview: result.overview,
-    importantFolders: result.importantFolders,
-    tooling: result.tooling ?? {},
-    keyFiles: result.keyFiles ?? [],
-    patterns: result.patterns ?? [],
-    architecture: result.architecture ?? "",
-    suggestions: result.suggestions,
-    generatedAt: now,
-    lastUpdated: now,
-  };
-  writeFileSync(lensFilePath(repoPath), renderLensFile(data), "utf-8");
-}
-
-export function patchLensFile(
-  repoPath: string,
-  patch: Partial<AnalysisResult>,
-): void {
-  const existing = readLensFile(repoPath);
-  const now = new Date().toISOString();
-
-  const base: LensFile = existing ?? {
-    overview: "",
-    importantFolders: [],
-    tooling: {},
-    keyFiles: [],
-    patterns: [],
-    architecture: "",
-    suggestions: [],
-    generatedAt: now,
-    lastUpdated: now,
-  };
-
-  const merged: LensFile = {
-    ...base,
-    lastUpdated: now,
-    overview: patch.overview ?? base.overview,
-    architecture: patch.architecture ?? base.architecture,
-    tooling: { ...base.tooling, ...(patch.tooling ?? {}) },
-    importantFolders: dedup([
-      ...base.importantFolders,
-      ...(patch.importantFolders ?? []),
-    ]),
-    keyFiles: dedup([...base.keyFiles, ...(patch.keyFiles ?? [])]),
-    patterns: dedup([...base.patterns, ...(patch.patterns ?? [])]),
-    suggestions: dedup([...base.suggestions, ...(patch.suggestions ?? [])]),
-  };
-
-  writeFileSync(lensFilePath(repoPath), renderLensFile(merged), "utf-8");
-}
-
-function dedup(arr: string[]): string[] {
-  return [...new Map(arr.map((s) => [s.trim().toLowerCase(), s])).values()];
-}
-
-export function readLensFile(repoPath: string): LensFile | null {
-  const filePath = lensFilePath(repoPath);
-  if (!existsSync(filePath)) return null;
-  try {
-    const content = readFileSync(filePath, "utf-8");
-    const match = content.match(/<!--lens-json\n([\s\S]*?)\nlens-json-->/);
-    if (!match) return null;
-    return JSON.parse(match[1]!) as LensFile;
-  } catch {
-    return null;
-  }
-}
-
-export function lensFileToAnalysisResult(lf: LensFile): AnalysisResult {
-  return {
-    overview: lf.overview,
-    importantFolders: lf.importantFolders,
-    tooling: lf.tooling,
-    keyFiles: lf.keyFiles,
-    patterns: lf.patterns,
-    architecture: lf.architecture,
-    suggestions: lf.suggestions,
-  };
-}

package/src/utils/llm.ts

@@ -1,81 +0,0 @@
-import type { Provider } from "../types/config";
-
-type Message = { role: "user" | "assistant"; content: string };
-
-export async function runPrompt(
-  provider: Provider,
-  prompt: string,
-): Promise<string> {
-  if (provider.type === "anthropic") {
-    return runAnthropic(provider, prompt);
-  }
-  if (provider.type === "openai" || provider.type === "custom") {
-    return runOpenAICompat(provider, prompt);
-  }
-  if (provider.type === "ollama") {
-    return runOllama(provider, prompt);
-  }
-  throw new Error(`Unknown provider type: ${provider.type}`);
-}
-
-async function runAnthropic(
-  provider: Provider,
-  prompt: string,
-): Promise<string> {
-  const res = await fetch("https://api.anthropic.com/v1/messages", {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-      "x-api-key": provider.apiKey ?? "",
-      "anthropic-version": "2023-06-01",
-    },
-    body: JSON.stringify({
-      model: provider.model,
-      max_tokens: 2000,
-      messages: [{ role: "user", content: prompt }],
-    }),
-  });
-  if (!res.ok) throw new Error(`Anthropic error: ${res.statusText}`);
-  const data = (await res.json()) as any;
-  return data.content
-    .filter((b: { type: string }) => b.type === "text")
-    .map((b: { text: string }) => b.text)
-    .join("");
-}
-
-async function runOpenAICompat(
-  provider: Provider,
-  prompt: string,
-): Promise<string> {
-  const baseUrl = provider.baseUrl ?? "https://api.openai.com/v1";
-  const res = await fetch(`${baseUrl}/chat/completions`, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-      Authorization: `Bearer ${provider.apiKey ?? ""}`,
-    },
-    body: JSON.stringify({
-      model: provider.model,
-      messages: [{ role: "user", content: prompt }],
-    }),
-  });
-  if (!res.ok) throw new Error(`OpenAI error: ${res.statusText}`);
-  const data = (await res.json()) as any;
-  return data.choices?.[0]?.message?.content ?? "";
-}
-
-async function runOllama(provider: Provider, prompt: string): Promise<string> {
-  const baseUrl = provider.baseUrl ?? "http://localhost:11434";
-  const res = await fetch(`${baseUrl}/api/chat`, {
-    method: "POST",
-    headers: { "Content-Type": "application/json" },
-    body: JSON.stringify({
-      model: provider.model,
-      stream: false,
-      messages: [{ role: "user", content: prompt }],
-    }),
-  });
-  if (!res.ok) throw new Error(`Ollama error: ${res.statusText}`);
-  const data = (await res.json()) as any;
-  return data.message?.content ?? "";
-}