@ridit/lens 0.3.7 → 0.3.9

package/src/commands/review.tsx

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

package/src/commands/run.tsx

@@ -1,56 +0,0 @@
-import React from "react";
-import { Box, Text } from "ink";
-import figures from "figures";
-import path from "path";
-import { existsSync } from "fs";
-import { RunRunner } from "../components/watch/RunRunner";
-import { RED } from "../colors";
-
-interface Props {
-  cmd: string;
-  path: string;
-  clean: boolean;
-  fixAll: boolean;
-  autoRestart: boolean;
-  prompt?: string;
-}
-
-export function RunCommand({
-  cmd,
-  path: inputPath,
-  clean,
-  fixAll,
-  autoRestart,
-  prompt,
-}: Props) {
-  const repoPath = path.resolve(inputPath);
-
-  if (!cmd.trim()) {
-    return (
-      <Box marginTop={1}>
-        <Text color={RED}>{figures.cross} Usage: lens watch "bun dev"</Text>
-      </Box>
-    );
-  }
-
-  if (!existsSync(repoPath)) {
-    return (
-      <Box marginTop={1}>
-        <Text color={RED}>
-          {figures.cross} Path not found: {repoPath}
-        </Text>
-      </Box>
-    );
-  }
-
-  return (
-    <RunRunner
-      cmd={cmd}
-      repoPath={repoPath}
-      clean={clean}
-      fixAll={fixAll}
-      autoRestart={autoRestart}
-      extraPrompt={prompt}
-    />
-  );
-}

package/src/commands/task.tsx

@@ -1,36 +0,0 @@
-import React from "react";
-import { Box, Text } from "ink";
-import figures from "figures";
-import { existsSync } from "fs";
-import path from "path";
-import { PromptRunner } from "../components/task/TaskRunner";
-
-export const TaskCommand = ({
-  prompt,
-  path: inputPath,
-}: {
-  prompt: string;
-  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>
-    );
-  }
-
-  if (!prompt.trim()) {
-    return (
-      <Box marginTop={1}>
-        <Text color="red">{figures.cross} Prompt cannot be empty.</Text>
-      </Box>
-    );
-  }
-
-  return <PromptRunner repoPath={resolvedPath} userPrompt={prompt} />;
-};

package/src/components/chat/ChatMessage.tsx

@@ -1,195 +0,0 @@
-import React from "react";
-import { Box, Text } from "ink";
-import { ACCENT, GREEN, RED } from "../../colors";
-import type { Message } from "../../types/chat";
-
-function InlineText({ text }: { text: string }) {
-  const parts = text.split(/(`[^`]+`|\*\*[^*]+\*\*)/g);
-  return (
-    <>
-      {parts.map((part, i) => {
-        if (part.startsWith("`") && part.endsWith("`")) {
-          return (
-            <Text key={i} color={ACCENT}>
-              {part.slice(1, -1)}
-            </Text>
-          );
-        }
-        if (part.startsWith("**") && part.endsWith("**")) {
-          return (
-            <Text key={i} bold color="white">
-              {part.slice(2, -2)}
-            </Text>
-          );
-        }
-        return (
-          <Text key={i} color="white">
-            {part}
-          </Text>
-        );
-      })}
-    </>
-  );
-}
-
-function CodeBlock({ lang, code }: { lang: string; code: string }) {
-  return (
-    <Box flexDirection="column">
-      {code.split("\n").map((line, i) => (
-        <Text key={i} color={ACCENT}>
-          {"  "}
-          {line}
-        </Text>
-      ))}
-    </Box>
-  );
-}
-
-function MessageBody({ content }: { content: string }) {
-  const segments = content.split(/(```[\s\S]*?```)/g);
-
-  return (
-    <Box flexDirection="column">
-      {segments.map((seg, si) => {
-        if (seg.startsWith("```")) {
-          const lines = seg.slice(3).split("\n");
-          const lang = lines[0]?.trim() ?? "";
-          const code = lines
-            .slice(1)
-            .join("\n")
-            .replace(/```\s*$/, "")
-            .trimEnd();
-          return <CodeBlock key={si} lang={lang} code={code} />;
-        }
-
-        const lines = seg.split("\n").filter((l) => l.trim() !== "");
-        return (
-          <Box key={si} flexDirection="column">
-            {lines.map((line, li) => {
-              if (line.match(/^[-*•]\s/)) {
-                return (
-                  <Box key={li} gap={1}>
-                    <Text color={ACCENT}>*</Text>
-                    <InlineText text={line.slice(2).trim()} />
-                  </Box>
-                );
-              }
-
-              if (line.match(/^\d+\.\s/)) {
-                const num = line.match(/^(\d+)\.\s/)![1];
-                return (
-                  <Box key={li} gap={1}>
-                    <Text color="gray">{num}.</Text>
-                    <InlineText text={line.replace(/^\d+\.\s/, "").trim()} />
-                  </Box>
-                );
-              }
-
-              return (
-                <Box key={li}>
-                  <InlineText text={line} />
-                </Box>
-              );
-            })}
-          </Box>
-        );
-      })}
-    </Box>
-  );
-}
-
-function summarizeToolContent(toolName: string, content: string): string {
-  // For write-file, extract just the path
-  if (toolName === "write-file" || toolName === "read-file") {
-    const pathMatch = content.match(/"path"\s*:\s*"([^"]+)"/);
-    if (pathMatch) return pathMatch[1]!;
-  }
-  // For changes blocks, just say what changed
-  if (content.includes('"summary"')) {
-    const summaryMatch = content.match(/"summary"\s*:\s*"([^"]+)"/);
-    if (summaryMatch) return summaryMatch[1]!;
-  }
-  return content.length > 120 ? content.slice(0, 120) + "…" : content;
-}
-
-export function StaticMessage({ msg }: { msg: Message }) {
-  if (msg.role === "user") {
-    return (
-      <Box
-        marginBottom={1}
-        gap={1}
-        backgroundColor={"#1a1a1a"}
-        paddingLeft={1}
-        paddingRight={2}
-      >
-        <Text color="gray">{">"}</Text>
-        <Text color="white" bold>
-          {msg.content}
-        </Text>
-      </Box>
-    );
-  }
-
-  if (msg.type === "tool") {
-    const icons: Record<string, string> = {
-      shell: "$",
-      fetch: "~>",
-      "read-file": "r",
-      "write-file": "w",
-      search: "?",
-    };
-    const icon = icons[msg.toolName] ?? "·";
-    const label =
-      msg.toolName === "shell"
-        ? msg.content
-        : msg.toolName === "search"
-          ? `"${msg.content}"`
-          : summarizeToolContent(msg.toolName, msg.content);
-
-    return (
-      <Box flexDirection="column" marginBottom={1}>
-        <Box gap={1}>
-          <Text color={msg.approved ? ACCENT : RED}>{icon}</Text>
-          <Text color={msg.approved ? "gray" : RED} dimColor={!msg.approved}>
-            {label}
-          </Text>
-          {!msg.approved && <Text color={RED}>denied</Text>}
-        </Box>
-        {msg.approved && msg.result && (
-          <Box marginLeft={2}>
-            <Text color="gray">
-              {msg.result.split("\n")[0]?.slice(0, 120)}
-              {(msg.result.split("\n")[0]?.length ?? 0) > 120 ? "…" : ""}
-            </Text>
-          </Box>
-        )}
-      </Box>
-    );
-  }
-
-  if (msg.type === "plan") {
-    return (
-      <Box flexDirection="column" marginBottom={1}>
-        <Box gap={1}>
-          <Text color={ACCENT}>*</Text>
-          <MessageBody content={msg.content} />
-        </Box>
-        <Box marginLeft={2} gap={1}>
-          <Text color={msg.applied ? GREEN : "gray"}>
-            {msg.applied ? "✓" : "·"}
-          </Text>
-          <Text color={msg.applied ? GREEN : "gray"} dimColor={!msg.applied}>
-            {msg.applied ? "changes applied" : "changes skipped"}
-          </Text>
-        </Box>
-      </Box>
-    );
-  }
-
-  return (
-    <Box marginBottom={1} gap={1}>
-      <Text color={ACCENT}>●</Text>
-      <MessageBody content={msg.content} />
-    </Box>
-  );
-}