@ridit/lens 0.1.0

package/src/utils/repo.ts

@@ -0,0 +1,69 @@
+import fs from "fs";
+import os from "os";
+import path from "path";
+import { exec } from "child_process";
+
+type CloneResult =
+  | { done: true }
+  | { done: false; folderExists: true; repoPath: string }
+  | { done: false; folderExists?: false; error: string };
+
+export function cloneRepo(
+  url: string,
+  repoPath: string,
+): Promise<{ done: boolean; error?: string }> {
+  return new Promise((resolve) => {
+    exec(`git clone "${url}" "${repoPath}"`, (err) => {
+      if (err) {
+        resolve({ done: false, error: err.message });
+      } else {
+        resolve({ done: true });
+      }
+    });
+  });
+}
+
+export function deleteRepoFolder(repoPath: string): void {
+  fs.rmSync(repoPath, { recursive: true, force: true });
+}
+
+export async function startCloneRepo(
+  url: string,
+  opts: { forceReclone?: boolean } = {},
+): Promise<CloneResult> {
+  let parsedUrl: URL;
+  try {
+    parsedUrl = new URL(url);
+  } catch {
+    return { done: false, error: `Invalid URL: ${url}` };
+  }
+
+  const repoName = path.basename(parsedUrl.pathname).replace(/\.git$/, "");
+  if (!repoName) {
+    return {
+      done: false,
+      error: "Could not determine repository name from URL.",
+    };
+  }
+
+  const repoPath = path.join(os.tmpdir(), repoName);
+
+  const firstTry = await cloneRepo(url, repoPath);
+  if (!firstTry.error) {
+    return { done: true };
+  }
+
+  if (firstTry.error.includes("already exists")) {
+    if (!opts.forceReclone) {
+      return { done: false, folderExists: true, repoPath };
+    }
+
+    deleteRepoFolder(repoPath);
+    const secondTry = await cloneRepo(url, repoPath);
+    return secondTry.error
+      ? { done: false, error: secondTry.error }
+      : { done: true };
+  }
+
+  return { done: false, error: firstTry.error };
+}

package/src/utils/stats.ts

@@ -0,0 +1,174 @@
+import { readFileSync, statSync } from "fs";
+import path from "path";
+
+export type CodeStats = {
+  totalFiles: number;
+  totalLines: number;
+  languages: Record<string, number>;
+  functions: number;
+  classes: number;
+  blankLines: number;
+  commentLines: number;
+  codeLines: number;
+};
+
+const LANG_MAP: Record<string, string> = {
+  ".ts": "TS",
+  ".tsx": "TSX",
+  ".js": "JS",
+  ".jsx": "JSX",
+  ".css": "CSS",
+  ".scss": "SCSS",
+  ".json": "JSON",
+  ".md": "MD",
+  ".py": "PY",
+  ".go": "GO",
+  ".rs": "RS",
+  ".java": "Java",
+  ".cpp": "C++",
+  ".c": "C",
+  ".html": "HTML",
+  ".yaml": "YAML",
+  ".yml": "YAML",
+  ".sh": "SH",
+  ".env": "ENV",
+};
+
+const SKIP_DIRS = new Set([
+  "node_modules",
+  ".git",
+  "dist",
+  "build",
+  ".next",
+  "out",
+  "coverage",
+  "__pycache__",
+  ".cache",
+  "vendor",
+  ".venv",
+  "venv",
+]);
+
+function isBinary(filePath: string): boolean {
+  const binaryExts = new Set([
+    ".png",
+    ".jpg",
+    ".jpeg",
+    ".gif",
+    ".webp",
+    ".ico",
+    ".svg",
+    ".woff",
+    ".woff2",
+    ".ttf",
+    ".eot",
+    ".mp4",
+    ".mp3",
+    ".wav",
+    ".zip",
+    ".tar",
+    ".gz",
+    ".pdf",
+    ".lock",
+  ]);
+  return binaryExts.has(path.extname(filePath).toLowerCase());
+}
+
+function countFunctionsAndClasses(
+  content: string,
+  ext: string,
+): { functions: number; classes: number } {
+  let functions = 0;
+  let classes = 0;
+
+  if ([".ts", ".tsx", ".js", ".jsx"].includes(ext)) {
+    const fnMatches = content.match(
+      /(?:^|\s)(?:function\s+\w+|const\s+\w+\s*=\s*(?:async\s*)?\(|(?:async\s+)?\w+\s*\([^)]*\)\s*(?::\s*\w+)?\s*\{|\w+\s*=\s*(?:async\s*)?\([^)]*\)\s*=>)/gm,
+    );
+    functions = fnMatches?.length ?? 0;
+
+    const classMatches = content.match(/(?:^|\s)class\s+\w+/gm);
+    classes = classMatches?.length ?? 0;
+  } else if (ext === ".py") {
+    const fnMatches = content.match(/^\s*def\s+\w+/gm);
+    functions = fnMatches?.length ?? 0;
+    const classMatches = content.match(/^\s*class\s+\w+/gm);
+    classes = classMatches?.length ?? 0;
+  } else if ([".go", ".rs"].includes(ext)) {
+    const fnMatches = content.match(/^\s*(?:func|fn)\s+\w+/gm);
+    functions = fnMatches?.length ?? 0;
+  }
+
+  return { functions, classes };
+}
+
+export function computeStats(repoPath: string, files: string[]): CodeStats {
+  const stats: CodeStats = {
+    totalFiles: 0,
+    totalLines: 0,
+    languages: {},
+    functions: 0,
+    classes: 0,
+    blankLines: 0,
+    commentLines: 0,
+    codeLines: 0,
+  };
+
+  for (const filePath of files) {
+    const parts = filePath.split(/[/\\]/);
+    if (parts.some((p) => SKIP_DIRS.has(p))) continue;
+    if (isBinary(filePath)) continue;
+
+    const ext = path.extname(filePath).toLowerCase();
+    const lang = LANG_MAP[ext];
+    if (!lang) continue;
+
+    stats.totalFiles++;
+    stats.languages[lang] = (stats.languages[lang] ?? 0) + 1;
+
+    try {
+      const content = readFileSync(path.join(repoPath, filePath), "utf-8");
+      const lines = content.split("\n");
+      stats.totalLines += lines.length;
+
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (trimmed === "") {
+          stats.blankLines++;
+        } else if (
+          trimmed.startsWith("//") ||
+          trimmed.startsWith("#") ||
+          trimmed.startsWith("*") ||
+          trimmed.startsWith("/*") ||
+          trimmed.startsWith("<!--")
+        ) {
+          stats.commentLines++;
+        } else {
+          stats.codeLines++;
+        }
+      }
+
+      const { functions, classes } = countFunctionsAndClasses(content, ext);
+      stats.functions += functions;
+      stats.classes += classes;
+    } catch {}
+  }
+
+  return stats;
+}
+
+export function formatNumber(n: number): string {
+  if (n >= 1000) return `${(n / 1000).toFixed(1)}k`;
+  return n.toString();
+}
+
+export function topLanguages(
+  languages: Record<string, number>,
+  limit = 5,
+): string {
+  return Object.entries(languages)
+    .sort((a, b) => b[1] - a[1])
+    .slice(0, limit)
+    .map(([lang]) => lang)
+    .join(", ");
+}

package/src/utils/thinking.tsx

@@ -0,0 +1,191 @@
+import { useEffect, useState } from "react";
+
+const PHRASES: Record<string, string[]> = {
+  general: [
+    // ── cooking ──────────────────────────────────────────────────
+    "marinating on that...",
+    "letting it simmer...",
+    "preheating the brain...",
+    "seasoning the response...",
+    "slow cooking an answer...",
+    "whisking it together...",
+    "folding in the context...",
+    "reducing the codebase...",
+    "deglazing with tokens...",
+    "plating the thoughts...",
+
+    // ── dev ──────────────────────────────────────────────────────
+    "shipping neurons...",
+    "diffing the vibes...",
+    "grepping the matrix...",
+    "pushing to brainstem...",
+    "rebasing thoughts...",
+    "compiling feelings...",
+    "hot reloading ideas...",
+    "touching grass mentally...",
+    "npm install wisdom...",
+    "resolving merge conflicts in head...",
+    "squashing dumb thoughts...",
+    "git blame on myself...",
+    "yarn linking synapses...",
+    "type checking the universe...",
+    "tree shaking nonsense...",
+
+    // ── gen z ────────────────────────────────────────────────────
+    "no cap, thinking hard...",
+    "lowkey computing...",
+    "in my bag rn...",
+    "it's giving... processing...",
+    "understood the assignment...",
+    "era of thinking...",
+    "main character moment...",
+    "this is the way...",
+    "based response incoming...",
+    "big brain time...",
+    "galaxy brained...",
+    "cooked something up...",
+    "chefkiss incoming...",
+    "slay mode: on...",
+    "rizzing up an answer...",
+
+    // ── existential ──────────────────────────────────────────────
+    "consulting the void...",
+    "asking my other personalities...",
+    "reading the codebase tea leaves...",
+    "vibing with your files...",
+    "channeling senior engineer energy...",
+    "pretending i know what i'm doing...",
+    "staring at the wall (productively)...",
+    "definitely not making this up...",
+  ],
+
+  cloning: [
+    "cloning at the speed of git...",
+    "negotiating with github...",
+    "untangling the object graph...",
+    "counting commits like sheep...",
+    "shallow clone, deep thoughts...",
+    "fetching the whole iceberg...",
+    "packing objects...",
+    "resolving deltas...",
+    "checking out the vibes...",
+    "recursing into submodules...",
+    "buffering the bits...",
+    "git is being git...",
+    "praying to the network gods...",
+    "downloading the internet (just your repo)...",
+  ],
+
+  analyzing: [
+    "reading every file (skimming)...",
+    "building a mental model...",
+    "reverse engineering intent...",
+    "parsing the chaos...",
+    "connecting the dots...",
+    "finding the load-bearing files...",
+    "mapping the dependency graph...",
+    "absorbing the architecture...",
+    "noticing things...",
+    "judging your folder structure...",
+    "appreciating the tech debt...",
+    "counting your TODOs...",
+    "reading between the lines...",
+    "anthropic-ifying your codebase...",
+    "following the import trail...",
+    "speed-reading your life's work...",
+    "pretending to understand your monorepo...",
+  ],
+
+  model: [
+    "deciding which files matter...",
+    "picking the important ones...",
+    "triaging your codebase...",
+    "figuring out where to look...",
+    "consulting the file oracle...",
+    "narrowing it down...",
+    "skimming the directory...",
+    "choosing wisely...",
+    "not reading everything (smart)...",
+    "filtering the noise...",
+    "asking the oracle...",
+    "pinging the motherbrain...",
+    "waiting on the neurons...",
+    "tokens incoming...",
+    "model is cooking...",
+    "inference in progress...",
+    "the GPU is thinking...",
+    "attention is all we need...",
+    "cross-attending to your vibes...",
+    "softmaxing the options...",
+    "sampling from the distribution...",
+    "temperature: just right...",
+    "context window: not full yet...",
+    "next token any second now...",
+    "beaming thoughts from the datacenter...",
+    "anthropic servers sweating...",
+    "matrix multiply in progress...",
+  ],
+  summary: [
+    "synthesizing the chaos...",
+    "forming an opinion...",
+    "writing the verdict...",
+    "digesting everything...",
+    "putting it all together...",
+    "crafting the overview...",
+    "making sense of it all...",
+    "distilling the essence...",
+    "summarizing your life's work...",
+    "turning files into feelings...",
+    "extracting signal from noise...",
+    "generating hot takes...",
+    "cooking up the analysis...",
+    "almost done judging your code...",
+    "writing the report card...",
+  ],
+
+  task: [
+    "thinking about your ask...",
+    "processing the request...",
+    "on it...",
+    "got it, working...",
+    "considering the angles...",
+    "thinking this through...",
+    "working on it...",
+    "cooking up a plan...",
+    "breaking it down...",
+    "figuring out the approach...",
+    "strategizing...",
+    "mapping out the steps...",
+    "scoping the work...",
+    "locking in...",
+    "challenge accepted...",
+  ],
+};
+
+function pick(list: string[], lastIndex: number): number {
+  let next = Math.floor(Math.random() * list.length);
+  if (next === lastIndex) next = (next + 1) % list.length;
+  return next;
+}
+
+export type ThinkingKind = keyof typeof PHRASES;
+
+export function useThinkingPhrase(
+  active: boolean,
+  kind: ThinkingKind = "general",
+  intervalMs = 4321,
+): string {
+  const list = PHRASES[kind]!;
+  const [index, setIndex] = useState(() =>
+    Math.floor(Math.random() * list.length),
+  );
+
+  useEffect(() => {
+    if (!active) return;
+    setIndex((i) => pick(list, i));
+    const id = setInterval(() => setIndex((i) => pick(list, i)), intervalMs);
+    return () => clearInterval(id);
+  }, [active, kind, intervalMs]);
+
+  return list[index]!;
+}

package/tsconfig.json

@@ -0,0 +1,24 @@
+{
+  "compilerOptions": {
+    "lib": ["ESNext"],
+    "target": "ESNext",
+    "module": "ESNext",
+    "moduleResolution": "node",
+    "jsx": "react-jsx",
+    "allowJs": true,
+    "outDir": "dist",
+    // "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+
+    "strict": true,
+    "skipLibCheck": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedIndexedAccess": true,
+    "noImplicitOverride": true,
+
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "noPropertyAccessFromIndexSignature": false
+  },
+  "include": ["src"]
+}