@ridit/lens 0.1.0

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@ridit/lens",
+  "version": "0.1.0",
+  "description": "Know Your Codebase.",
+  "author": "Ridit Jangra <riditjangra09@gmail.com> (https://ridit.space)",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ridit-jangra/Lens"
+  },
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "lens": "./dist/index.js"
+  },
+  "scripts": {
+    "build": "bun build src/index.tsx --target bun --outfile dist/index.js",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "chalk": "^5.6.2",
+    "commander": "^14.0.3",
+    "figures": "^6.1.0",
+    "ink": "^6.8.0",
+    "ink-spinner": "^5.0.0",
+    "ink-text-input": "^6.0.0",
+    "nanoid": "^5.1.6",
+    "react": "^19.2.4",
+    "react-devtools-core": "^7.0.1"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "@types/react": "^19.2.14"
+  },
+  "peerDependencies": {
+    "typescript": "^5"
+  }
+}

package/src/colors.ts

@@ -0,0 +1 @@
+export const ACCENT = "#DA7758";

package/src/commands/chat.tsx

@@ -0,0 +1,23 @@
+import React from "react";
+import { Box, Text } from "ink";
+import figures from "figures";
+import { existsSync } from "fs";
+import path from "path";
+import { ChatRunner } from "../components/chat/ChatRunner";
+import { ACCENT } from "../colors";
+
+export const ChatCommand = ({ path: inputPath }: { path: string }) => {
+  const resolvedPath = path.resolve(inputPath);
+
+  if (!existsSync(resolvedPath)) {
+    return (
+      <Box marginTop={1}>
+        <Text color="red">
+          {figures.cross} Path not found: {resolvedPath}
+        </Text>
+      </Box>
+    );
+  }
+
+  return <ChatRunner repoPath={resolvedPath} />;
+};

package/src/commands/provider.tsx

@@ -0,0 +1,224 @@
+import { Box, Text, useInput } from "ink";
+import figures from "figures";
+import { useState } from "react";
+import { nanoid } from "nanoid";
+import { addProvider, loadConfig } from "../utils/config";
+import { ProviderTypeStep } from "../components/provider/ProviderTypeStep";
+import { ApiKeyStep } from "../components/provider/ApiKeyStep";
+import { ModelStep } from "../components/provider/ModelStep";
+import { RemoveProviderStep } from "../components/provider/RemoveProviderStep";
+import type { Provider, ProviderType } from "../types/config";
+
+type InitStage =
+  | { type: "menu" }
+  | { type: "provider-type" }
+  | { type: "api-key"; providerType: ProviderType }
+  | { type: "base-url"; providerType: ProviderType; apiKey: string }
+  | {
+      type: "model";
+      providerType: ProviderType;
+      apiKey: string;
+      baseUrl?: string;
+    }
+  | { type: "remove" }
+  | { type: "done"; provider: Provider };
+
+const MENU_OPTIONS = [
+  { label: "Add a provider", action: "provider-type" },
+  { label: "Remove a provider", action: "remove" },
+] as const;
+
+export const InitCommand = () => {
+  const [stage, setStage] = useState<InitStage>({ type: "menu" });
+  const [completedSteps, setCompletedSteps] = useState<string[]>([]);
+  const [menuIndex, setMenuIndex] = useState(0);
+
+  const pushStep = (label: string) => setCompletedSteps((s) => [...s, label]);
+
+  useInput((input, key) => {
+    if (stage.type !== "menu") return;
+    if (key.upArrow) setMenuIndex((i) => Math.max(0, i - 1));
+    if (key.downArrow)
+      setMenuIndex((i) => Math.min(MENU_OPTIONS.length - 1, i + 1));
+    if (key.return) {
+      const action = MENU_OPTIONS[menuIndex]?.action;
+      if (action === "provider-type") setStage({ type: "provider-type" });
+      if (action === "remove") setStage({ type: "remove" });
+    }
+  });
+
+  if (stage.type === "menu") {
+    const config = loadConfig();
+    return (
+      <Box flexDirection="column" gap={1}>
+        {completedSteps.map((s, i) => (
+          <Text key={i} color="green">
+            {figures.tick} {s}
+          </Text>
+        ))}
+        <Text bold color="cyan">
+          Lens — provider setup
+        </Text>
+        {config.providers.length > 0 && (
+          <Text color="gray">
+            {figures.info} {config.providers.length} provider(s) configured
+          </Text>
+        )}
+        {MENU_OPTIONS.map((opt, i) => (
+          <Box key={opt.action} marginLeft={1}>
+            <Text color={i === menuIndex ? "cyan" : "white"}>
+              {i === menuIndex ? figures.arrowRight : " "}
+              {"  "}
+              {opt.label}
+            </Text>
+          </Box>
+        ))}
+        <Text color="gray">↑↓ navigate · enter to select</Text>
+      </Box>
+    );
+  }
+
+  if (stage.type === "remove") {
+    return (
+      <Box flexDirection="column" gap={1}>
+        {completedSteps.map((s, i) => (
+          <Text key={i} color="green">
+            {figures.tick} {s}
+          </Text>
+        ))}
+        <RemoveProviderStep onDone={() => setStage({ type: "menu" })} />
+      </Box>
+    );
+  }
+
+  if (stage.type === "provider-type") {
+    return (
+      <Box flexDirection="column" gap={1}>
+        {completedSteps.map((s, i) => (
+          <Text key={i} color="green">
+            {figures.tick} {s}
+          </Text>
+        ))}
+        <ProviderTypeStep
+          onSelect={(providerType) => {
+            pushStep(`Provider: ${providerType}`);
+            setStage({ type: "api-key", providerType });
+          }}
+        />
+      </Box>
+    );
+  }
+
+  if (stage.type === "api-key") {
+    return (
+      <Box flexDirection="column" gap={1}>
+        {completedSteps.map((s, i) => (
+          <Text key={i} color="green">
+            {figures.tick} {s}
+          </Text>
+        ))}
+        <ApiKeyStep
+          providerType={stage.providerType}
+          onSubmit={(value) => {
+            if (stage.providerType === "custom") {
+              const { apiKey, baseUrl } = value as {
+                apiKey: string;
+                baseUrl?: string;
+              };
+              pushStep("API key saved");
+              if (baseUrl) pushStep(`Base URL: ${baseUrl}`);
+              setStage({
+                type: "model",
+                providerType: stage.providerType,
+                apiKey,
+                baseUrl,
+              });
+            } else if (stage.providerType === "ollama") {
+              pushStep(`Base URL: ${value}`);
+              setStage({
+                type: "model",
+                providerType: stage.providerType,
+                apiKey: "",
+                baseUrl: value as string,
+              });
+            } else {
+              pushStep("API key saved");
+              setStage({
+                type: "model",
+                providerType: stage.providerType,
+                apiKey: value as string,
+              });
+            }
+          }}
+        />
+      </Box>
+    );
+  }
+
+  if (stage.type === "base-url") {
+    return (
+      <Box flexDirection="column" gap={1}>
+        {completedSteps.map((s, i) => (
+          <Text key={i} color="green">
+            {figures.tick} {s}
+          </Text>
+        ))}
+        <ApiKeyStep
+          providerType="ollama"
+          onSubmit={(baseUrl) => {
+            pushStep(`Base URL: ${baseUrl}`);
+            setStage({
+              type: "model",
+              providerType: stage.providerType,
+              apiKey: stage.apiKey,
+              baseUrl: baseUrl as string,
+            });
+          }}
+        />
+      </Box>
+    );
+  }
+
+  if (stage.type === "model") {
+    return (
+      <Box flexDirection="column" gap={1}>
+        {completedSteps.map((s, i) => (
+          <Text key={i} color="green">
+            {figures.tick} {s}
+          </Text>
+        ))}
+        <ModelStep
+          providerType={stage.providerType}
+          onSelect={(model) => {
+            const provider: Provider = {
+              id: nanoid(8),
+              type: stage.providerType,
+              name: `${stage.providerType}-${model}`,
+              apiKey: stage.apiKey || undefined,
+              baseUrl: stage.baseUrl,
+              model,
+            };
+            addProvider(provider);
+            pushStep(`Model: ${model}`);
+            setStage({ type: "done", provider });
+          }}
+        />
+      </Box>
+    );
+  }
+
+  return (
+    <Box flexDirection="column" gap={1}>
+      {completedSteps.map((s, i) => (
+        <Text key={i} color="green">
+          {figures.tick} {s}
+        </Text>
+      ))}
+      <Text color="green">{figures.tick} Provider configured successfully</Text>
+      <Text color="gray">
+        {figures.info} Run <Text color="cyan">lens init</Text> again to manage
+        providers.
+      </Text>
+    </Box>
+  );
+};

package/src/commands/repo.tsx

@@ -0,0 +1,120 @@
+import { Box, Text, useInput } from "ink";
+import figures from "figures";
+import { useEffect, useState } from "react";
+import path from "path";
+import os from "os";
+import { startCloneRepo } from "../utils/repo";
+import { fetchFileTree, readImportantFiles } from "../utils/files";
+import { StepRow } from "../components/repo/StepRow";
+import { FileReviewer } from "../components/repo/FileReviewer";
+import { RepoAnalysis } from "../components/repo/RepoAnalysis";
+import type { Step, ImportantFile } from "../types/repo";
+
+export const RepoCommand = ({ url }: { url: string }) => {
+  const [steps, setSteps] = useState<Step[]>([
+    { type: "cloning", status: "pending" },
+  ]);
+  const [importantFiles, setImportantFiles] = useState<ImportantFile[]>([]);
+  const [fileTree, setFileTree] = useState<string[]>([]);
+  const [repoPath, setRepoPath] = useState<string>("");
+  const [reviewDone, setReviewDone] = useState(false);
+
+  const updateLastStep = (updated: Step) =>
+    setSteps((prev) => [...prev.slice(0, -1), updated]);
+
+  const pushStep = (step: Step) => setSteps((prev) => [...prev, step]);
+
+  const handleCloneSuccess = (rPath: string) => {
+    setRepoPath(rPath);
+    updateLastStep({ type: "cloning", status: "done" });
+    pushStep({ type: "fetching-tree", status: "pending" });
+
+    fetchFileTree(rPath)
+      .then((files) => {
+        updateLastStep({ type: "fetching-tree", status: "done" });
+        pushStep({ type: "reading-files", status: "pending" });
+        setFileTree(files);
+        const found = readImportantFiles(rPath, files);
+        setImportantFiles(found);
+        updateLastStep({ type: "reading-files", status: "done" });
+      })
+      .catch(() => updateLastStep({ type: "fetching-tree", status: "done" }));
+  };
+
+  useEffect(() => {
+    startCloneRepo(url).then((result) => {
+      if (result.done) {
+        const repoName = path
+          .basename(new URL(url).pathname)
+          .replace(/\.git$/, "");
+        handleCloneSuccess(path.join(os.tmpdir(), repoName));
+      } else if (result.folderExists) {
+        updateLastStep({
+          type: "folder-exists",
+          status: "pending",
+          repoPath: result.repoPath,
+        });
+      } else {
+        updateLastStep({
+          type: "error",
+          message: result.error ?? "Unknown error",
+        });
+      }
+    });
+  }, [url]);
+
+  useInput((input) => {
+    const last = steps[steps.length - 1];
+    if (last?.type !== "folder-exists") return;
+    const rPath = last.repoPath;
+
+    if (input === "y" || input === "Y") {
+      updateLastStep({ type: "cloning", status: "pending" });
+      startCloneRepo(url, { forceReclone: true }).then((result) => {
+        if (result.done) {
+          handleCloneSuccess(rPath);
+        } else if (!result.folderExists) {
+          updateLastStep({
+            type: "error",
+            message: result.error ?? "Unknown error",
+          });
+        }
+      });
+    }
+
+    if (input === "n" || input === "N") handleCloneSuccess(rPath);
+  });
+
+  const allDone =
+    steps[steps.length - 1]?.type === "reading-files" &&
+    (steps[steps.length - 1] as Extract<Step, { type: "reading-files" }>)
+      .status === "done";
+
+  return (
+    <Box flexDirection="column">
+      {steps.map((step, i) => (
+        <StepRow key={i} step={step} />
+      ))}
+
+      {allDone && !reviewDone && importantFiles.length > 0 && (
+        <FileReviewer
+          files={importantFiles}
+          onDone={() => setReviewDone(true)}
+        />
+      )}
+
+      {allDone && importantFiles.length === 0 && !reviewDone && (
+        <Text color="gray">{figures.info} No important files found</Text>
+      )}
+
+      {(reviewDone || (allDone && importantFiles.length === 0)) && (
+        <RepoAnalysis
+          repoUrl={url}
+          repoPath={repoPath}
+          fileTree={fileTree}
+          files={importantFiles}
+        />
+      )}
+    </Box>
+  );
+};

package/src/commands/review.tsx

@@ -0,0 +1,294 @@
+import React from "react";
+import { Box, Text } from "ink";
+import figures from "figures";
+import { useEffect, useState } from "react";
+import path from "path";
+import { existsSync, readdirSync, readFileSync, statSync } from "fs";
+import { fetchFileTree, readImportantFiles } from "../utils/files";
+import { computeStats, formatNumber, topLanguages } from "../utils/stats";
+import { RepoAnalysis } from "../components/repo/RepoAnalysis";
+import { LensFileMenu } from "../components/repo/LensFileMenu";
+import {
+  lensFileExists,
+  readLensFile,
+  lensFileToAnalysisResult,
+} from "../utils/lensfile";
+import type { ImportantFile } from "../types/repo";
+import type { CodeStats } from "../utils/stats";
+import type { LensMenuChoice } from "../components/repo/LensFileMenu";
+
+type ReviewStage =
+  | { type: "scanning" }
+  | {
+      type: "lens-menu";
+      fileTree: string[];
+      files: ImportantFile[];
+      stats: CodeStats;
+    }
+  | {
+      type: "stats";
+      stats: CodeStats;
+      files: ImportantFile[];
+      fileTree: string[];
+    }
+  | { type: "error"; message: string };
+
+function StatRow({ label, value }: { label: string; value: string }) {
+  const PAD = 20;
+  return (
+    <Box>
+      <Text color="gray">{label.padEnd(PAD, " ")}</Text>
+      <Text color="white" bold>
+        {value}
+      </Text>
+    </Box>
+  );
+}
+
+function Divider() {
+  return <Text color="gray">{"─".repeat(36)}</Text>;
+}
+
+const SKIP_DIRS = new Set([
+  "node_modules",
+  ".git",
+  "dist",
+  "build",
+  ".next",
+  "out",
+  "coverage",
+  "__pycache__",
+  ".venv",
+  "venv",
+]);
+
+function parseGitignore(dir: string): string[] {
+  const p = path.join(dir, ".gitignore");
+  if (!existsSync(p)) return [];
+  try {
+    return readFileSync(p, "utf-8")
+      .split("\n")
+      .map((l) => l.trim())
+      .filter((l) => l && !l.startsWith("#"));
+  } catch {
+    return [];
+  }
+}
+
+function matchesGitignore(
+  patterns: string[],
+  relPath: string,
+  isDir: boolean,
+): boolean {
+  const name = path.basename(relPath);
+  for (const pattern of patterns) {
+    if (pattern.endsWith("/")) {
+      if (isDir && name === pattern.slice(0, -1)) return true;
+      continue;
+    }
+    if (pattern.startsWith("!")) continue;
+    if (pattern.includes("*")) {
+      const regex = new RegExp(
+        "^" +
+          pattern
+            .replace(/\./g, "\\.")
+            .replace(/\*\*/g, ".*")
+            .replace(/\*/g, "[^/]*") +
+          "$",
+      );
+      if (regex.test(name) || regex.test(relPath)) return true;
+      continue;
+    }
+    if (
+      name === pattern ||
+      relPath === pattern ||
+      relPath.startsWith(pattern + "/")
+    )
+      return true;
+  }
+  return false;
+}
+
+function walkDir(dir: string, base = dir, patterns?: string[]): string[] {
+  const p = patterns ?? parseGitignore(base);
+  const results: string[] = [];
+  let entries: string[];
+  try {
+    entries = readdirSync(dir, { encoding: "utf-8" });
+  } catch {
+    return results;
+  }
+  for (const entry of entries) {
+    if (SKIP_DIRS.has(entry)) continue;
+    const full = path.join(dir, entry);
+    const rel = path.relative(base, full).replace(/\\/g, "/");
+    let isDir = false;
+    try {
+      isDir = statSync(full).isDirectory();
+    } catch {
+      continue;
+    }
+    if (matchesGitignore(p, rel, isDir)) continue;
+    if (isDir) results.push(...walkDir(full, base, p));
+    else results.push(rel);
+  }
+  return results;
+}
+
+function StatsPanel({
+  resolvedPath,
+  stats,
+}: {
+  resolvedPath: string;
+  stats: CodeStats;
+}) {
+  const langs = topLanguages(stats.languages);
+  return (
+    <Box flexDirection="column" marginTop={1} gap={0}>
+      <Text bold color="cyan">
+        {figures.hamburger} {path.basename(resolvedPath)}
+      </Text>
+      <Divider />
+      <StatRow label="Lines of Code" value={formatNumber(stats.codeLines)} />
+      <StatRow label="Total Lines" value={formatNumber(stats.totalLines)} />
+      <StatRow label="Files" value={formatNumber(stats.totalFiles)} />
+      <StatRow label="Languages" value={langs || "—"} />
+      <StatRow label="Functions" value={formatNumber(stats.functions)} />
+      <StatRow label="Classes" value={formatNumber(stats.classes)} />
+      <StatRow label="Comment Lines" value={formatNumber(stats.commentLines)} />
+      <StatRow label="Blank Lines" value={formatNumber(stats.blankLines)} />
+      <Divider />
+    </Box>
+  );
+}
+
+export const ReviewCommand = ({
+  path: inputPath,
+  onExit,
+}: {
+  path: string;
+  onExit?: () => void;
+}) => {
+  const [stage, setStage] = useState<ReviewStage>({ type: "scanning" });
+
+  const [preloadedResult, setPreloadedResult] = useState<
+    import("../types/repo").AnalysisResult | null
+  >(null);
+  const resolvedPath = path.resolve(inputPath);
+
+  useEffect(() => {
+    if (!existsSync(resolvedPath)) {
+      setStage({ type: "error", message: `Path not found: ${resolvedPath}` });
+      return;
+    }
+
+    fetchFileTree(resolvedPath)
+      .catch(() => walkDir(resolvedPath))
+      .then((fileTree) => {
+        const stats = computeStats(resolvedPath, fileTree);
+        const files = readImportantFiles(resolvedPath, fileTree);
+
+        if (lensFileExists(resolvedPath)) {
+          setStage({ type: "lens-menu", fileTree, files, stats });
+        } else {
+          setStage({ type: "stats", stats, files, fileTree });
+        }
+      })
+      .catch((err: unknown) =>
+        setStage({
+          type: "error",
+          message: err instanceof Error ? err.message : "Failed to scan",
+        }),
+      );
+  }, [resolvedPath]);
+
+  const handleLensChoice = (
+    choice: LensMenuChoice,
+    fileTree: string[],
+    files: ImportantFile[],
+    stats: CodeStats,
+  ) => {
+    const lf = readLensFile(resolvedPath);
+
+    if (choice === "use-cached" && lf) {
+      setPreloadedResult(lensFileToAnalysisResult(lf));
+      setStage({ type: "stats", stats, files, fileTree });
+      return;
+    }
+
+    if (choice === "fix-issues" && lf) {
+      setPreloadedResult(lensFileToAnalysisResult(lf));
+      setStage({ type: "stats", stats, files, fileTree });
+      return;
+    }
+
+    if (choice === "security" && lf) {
+      setPreloadedResult(lensFileToAnalysisResult(lf));
+      setStage({ type: "stats", stats, files, fileTree });
+      return;
+    }
+
+    setStage({ type: "stats", stats, files, fileTree });
+  };
+
+  if (stage.type === "scanning") {
+    return (
+      <Box marginTop={1} gap={1}>
+        <Text color="cyan">{figures.pointer}</Text>
+        <Text>Scanning codebase...</Text>
+      </Box>
+    );
+  }
+
+  if (stage.type === "error") {
+    return (
+      <Box marginTop={1}>
+        <Text color="red">
+          {figures.cross} {stage.message}
+        </Text>
+      </Box>
+    );
+  }
+
+  if (stage.type === "lens-menu") {
+    const lf = readLensFile(resolvedPath);
+    if (!lf) {
+      setStage({
+        type: "stats",
+        stats: stage.stats,
+        files: stage.files,
+        fileTree: stage.fileTree,
+      });
+      return null;
+    }
+    const { fileTree, files, stats } = stage;
+    return (
+      <Box flexDirection="column" gap={1}>
+        <StatsPanel resolvedPath={resolvedPath} stats={stats} />
+        <LensFileMenu
+          repoPath={resolvedPath}
+          lensFile={lf}
+          onChoice={(choice) =>
+            handleLensChoice(choice, fileTree, files, stats)
+          }
+        />
+      </Box>
+    );
+  }
+
+  const { stats, files, fileTree } = stage;
+
+  return (
+    <Box flexDirection="column" gap={1}>
+      <StatsPanel resolvedPath={resolvedPath} stats={stats} />
+      <RepoAnalysis
+        repoUrl={resolvedPath}
+        repoPath={resolvedPath}
+        fileTree={fileTree}
+        files={files}
+        preloadedResult={preloadedResult ?? undefined}
+        onExit={onExit}
+      />
+    </Box>
+  );
+};