@ridit/lens 0.1.0

package/src/utils/config.ts

@@ -0,0 +1,61 @@
+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

@@ -0,0 +1,104 @@
+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[] {
+  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/git.ts

@@ -0,0 +1,155 @@
+import { execSync } from "child_process";
+
+export type Commit = {
+  hash: string;
+  shortHash: string;
+  author: string;
+  email: string;
+  date: string;
+  relativeDate: string;
+  message: string;
+  body: string;
+  refs: string;
+  parents: string[];
+  filesChanged: number;
+  insertions: number;
+  deletions: number;
+};
+
+export type DiffFile = {
+  path: string;
+  status: "added" | "modified" | "deleted" | "renamed";
+  insertions: number;
+  deletions: number;
+  lines: { type: "add" | "remove" | "context" | "header"; content: string }[];
+};
+
+function run(cmd: string, cwd: string): string {
+  try {
+    return execSync(cmd, {
+      cwd,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"],
+    }).trim();
+  } catch {
+    return "";
+  }
+}
+
+export function isGitRepo(p: string): boolean {
+  return run("git rev-parse --is-inside-work-tree", p) === "true";
+}
+
+export function fetchCommits(repoPath: string, limit = 200): Commit[] {
+  const SEP = "|||";
+  const RS = "^^^";
+  const raw = run(
+    `git log --max-count=${limit} --format="${RS}%H${SEP}%h${SEP}%an${SEP}%ae${SEP}%ci${SEP}%cr${SEP}%s${SEP}%b${SEP}%D${SEP}%P" --shortstat`,
+    repoPath,
+  );
+  if (!raw) return [];
+
+  return raw
+    .split(RS)
+    .filter(Boolean)
+    .flatMap((block) => {
+      const lines = block.split("\n");
+      const parts = lines[0]!.split(SEP);
+      if (parts.length < 10) return [];
+      const [
+        hash,
+        shortHash,
+        author,
+        email,
+        date,
+        relativeDate,
+        message,
+        body,
+        refs,
+        parentsRaw,
+      ] = parts;
+      const statLine = lines.find((l) => l.includes("changed")) ?? "";
+      return [
+        {
+          hash: hash!.trim(),
+          shortHash: shortHash!.trim(),
+          author: author!.trim(),
+          email: email!.trim(),
+          date: date!.trim(),
+          relativeDate: relativeDate!.trim(),
+          message: message!.trim(),
+          body: body!.trim(),
+          refs: refs!.trim(),
+          parents: parentsRaw!.trim().split(" ").filter(Boolean),
+          filesChanged: parseInt(statLine.match(/(\d+) file/)?.[1] ?? "0"),
+          insertions: parseInt(statLine.match(/(\d+) insertion/)?.[1] ?? "0"),
+          deletions: parseInt(statLine.match(/(\d+) deletion/)?.[1] ?? "0"),
+        },
+      ];
+    });
+}
+
+export function fetchDiff(repoPath: string, hash: string): DiffFile[] {
+  const raw = run(
+    `git show --unified=3 --diff-filter=ACDMR "${hash}"`,
+    repoPath,
+  );
+  if (!raw) return [];
+
+  const files: DiffFile[] = [];
+  let cur: DiffFile | null = null;
+
+  for (const line of raw.split("\n")) {
+    if (line.startsWith("diff --git")) {
+      if (cur) files.push(cur);
+      cur = {
+        path: "",
+        status: "modified",
+        insertions: 0,
+        deletions: 0,
+        lines: [],
+      };
+    } else if (line.startsWith("+++ b/") && cur) {
+      cur.path = line.slice(6);
+    } else if (line.startsWith("new file") && cur) {
+      cur.status = "added";
+    } else if (line.startsWith("deleted file") && cur) {
+      cur.status = "deleted";
+    } else if (line.startsWith("rename") && cur) {
+      cur.status = "renamed";
+    } else if (line.startsWith("@@") && cur) {
+      cur.lines.push({ type: "header", content: line });
+    } else if (line.startsWith("+") && cur && !line.startsWith("+++")) {
+      cur.insertions++;
+      cur.lines.push({ type: "add", content: line.slice(1) });
+    } else if (line.startsWith("-") && cur && !line.startsWith("---")) {
+      cur.deletions++;
+      cur.lines.push({ type: "remove", content: line.slice(1) });
+    } else if (cur && line !== "\") {
+      cur.lines.push({ type: "context", content: line.slice(1) });
+    }
+  }
+  if (cur) files.push(cur);
+  return files.filter((f) => f.path);
+}
+
+export function summarizeTimeline(commits: Commit[]): string {
+  if (!commits.length) return "No commits.";
+  const authors = [...new Set(commits.map((c) => c.author))];
+  const biggest = [...commits].sort(
+    (a, b) => b.insertions + b.deletions - (a.insertions + a.deletions),
+  )[0]!;
+  return [
+    `Total commits: ${commits.length}`,
+    `Authors: ${authors.join(", ")}`,
+    `Newest: "${commits[0]!.message}" (${commits[0]!.shortHash}) — ${commits[0]!.relativeDate}`,
+    `Oldest: "${commits[commits.length - 1]!.message}" (${commits[commits.length - 1]!.shortHash}) — ${commits[commits.length - 1]!.relativeDate}`,
+    `Biggest change: "${biggest.message}" (${biggest.shortHash}) +${biggest.insertions}/-${biggest.deletions}`,
+    ``,
+    `Full log (hash | date | author | message | +ins/-del):`,
+    ...commits.map(
+      (c) =>
+        `${c.shortHash} | ${c.date.slice(0, 10)} | ${c.author} | ${c.message} | +${c.insertions}/-${c.deletions}`,
+    ),
+  ].join("\n");
+}

package/src/utils/history.ts

@@ -0,0 +1,86 @@
+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);
+}

package/src/utils/lensfile.ts

@@ -0,0 +1,77 @@
+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[];
+  missingConfigs: string[];
+  securityIssues: string[];
+  suggestions: string[];
+  generatedAt: string;
+};
+
+export function lensFilePath(repoPath: string): string {
+  return path.join(repoPath, LENS_FILENAME);
+}
+
+export function lensFileExists(repoPath: string): boolean {
+  return existsSync(lensFilePath(repoPath));
+}
+
+export function writeLensFile(repoPath: string, result: AnalysisResult): void {
+  const data: LensFile = {
+    ...result,
+    generatedAt: new Date().toISOString(),
+  };
+
+  const content = `# Lens Analysis
+> Generated: ${data.generatedAt}
+
+## Overview
+${data.overview}
+
+## Important Folders
+${data.importantFolders.map((f) => `- ${f}`).join("\n")}
+
+## Missing Configs
+${data.missingConfigs.length > 0 ? data.missingConfigs.map((f) => `- ${f}`).join("\n") : "- None detected"}
+
+## Security Issues
+${data.securityIssues.length > 0 ? data.securityIssues.map((s) => `- ${s}`).join("\n") : "- None detected"}
+
+## Suggestions
+${data.suggestions.map((s) => `- ${s}`).join("\n")}
+
+<!--lens-json
+${JSON.stringify(data)}
+lens-json-->
+`;
+
+  writeFileSync(lensFilePath(repoPath), content, "utf-8");
+}
+
+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,
+    missingConfigs: lf.missingConfigs,
+    securityIssues: lf.securityIssues,
+    suggestions: lf.suggestions,
+  };
+}

package/src/utils/llm.ts

@@ -0,0 +1,81 @@
+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 ?? "";
+}

package/src/utils/preview.ts

@@ -0,0 +1,119 @@
+import { existsSync, readFileSync } from "fs";
+import path from "path";
+import { spawn, type ChildProcess } from "child_process";
+import type { PackageManager, PreviewInfo } from "../types/repo";
+
+export function detectPreview(repoPath: string): PreviewInfo | null {
+  
+  const pkgPath = path.join(repoPath, "package.json");
+  if (existsSync(pkgPath)) {
+    try {
+      const pkg = JSON.parse(readFileSync(pkgPath, "utf-8")) as {
+        scripts?: Record<string, string>;
+      };
+      const scripts = pkg.scripts ?? {};
+
+      const pm: PackageManager = existsSync(
+        path.join(repoPath, "pnpm-lock.yaml"),
+      )
+        ? "pnpm"
+        : existsSync(path.join(repoPath, "yarn.lock"))
+          ? "yarn"
+          : "npm";
+
+      const devScript =
+        scripts["dev"] ?? scripts["start"] ?? scripts["serve"] ?? null;
+      if (!devScript) return null;
+
+      const devCmd =
+        pm === "npm" ? "npm run dev" : pm === "yarn" ? "yarn dev" : "pnpm dev";
+
+      
+      const portMatch = devScript.match(/--port[= ](\d+)/);
+      const port = portMatch ? parseInt(portMatch[1]!, 10) : 5173;
+
+      return {
+        packageManager: pm,
+        installCmd:
+          pm === "npm"
+            ? "npm install"
+            : pm === "yarn"
+              ? "yarn install"
+              : "pnpm install",
+        devCmd,
+        port,
+      };
+    } catch {
+      return null;
+    }
+  }
+
+  
+  if (
+    existsSync(path.join(repoPath, "requirements.txt")) ||
+    existsSync(path.join(repoPath, "pyproject.toml"))
+  ) {
+    return {
+      packageManager: "pip",
+      installCmd: "pip install -r requirements.txt",
+      devCmd: existsSync(path.join(repoPath, "manage.py"))
+        ? "python manage.py runserver"
+        : "python main.py",
+      port: 8000,
+    };
+  }
+
+  return null;
+}
+
+export type PreviewProcess = {
+  kill: () => void;
+  onLog: (cb: (line: string) => void) => void;
+  onError: (cb: (line: string) => void) => void;
+  onExit: (cb: (code: number | null) => void) => void;
+};
+
+export function runInstall(
+  repoPath: string,
+  installCmd: string,
+): PreviewProcess {
+  return spawnProcess(repoPath, installCmd);
+}
+
+export function runDev(repoPath: string, devCmd: string): PreviewProcess {
+  return spawnProcess(repoPath, devCmd);
+}
+
+function spawnProcess(cwd: string, cmd: string): PreviewProcess {
+  const [bin, ...args] = cmd.split(" ") as [string, ...string[]];
+  const child: ChildProcess = spawn(bin, args, {
+    cwd,
+    shell: true,
+    env: { ...process.env },
+  });
+
+  const logCallbacks: ((line: string) => void)[] = [];
+  const errorCallbacks: ((line: string) => void)[] = [];
+  const exitCallbacks: ((code: number | null) => void)[] = [];
+
+  child.stdout?.on("data", (data: Buffer) => {
+    const lines = data.toString().split("\n").filter(Boolean);
+    lines.forEach((line) => logCallbacks.forEach((cb) => cb(line)));
+  });
+
+  child.stderr?.on("data", (data: Buffer) => {
+    const lines = data.toString().split("\n").filter(Boolean);
+    lines.forEach((line) => errorCallbacks.forEach((cb) => cb(line)));
+  });
+
+  child.on("exit", (code) => {
+    exitCallbacks.forEach((cb) => cb(code));
+  });
+
+  return {
+    kill: () => child.kill(),
+    onLog: (cb) => logCallbacks.push(cb),
+    onError: (cb) => errorCallbacks.push(cb),
+    onExit: (cb) => exitCallbacks.push(cb),
+  };
+}