@abacus-ai/cli 1.106.25007 → 2.0.0-canary.0

package/src/lib/fs.ts

@@ -0,0 +1,533 @@
+import {
+  getFileRecency,
+  prepareQuery,
+  scoreItemFuzzy,
+  compareItemsByFuzzyScore,
+  type IPreparedQuery,
+  type IItemAccessor,
+  type FuzzyScorerCache,
+  LABEL_SCORE_THRESHOLD,
+} from "@codellm/agent/utils";
+import { rgPath } from "@vscode/ripgrep";
+import { spawn } from "node:child_process";
+import { promises as fs } from "node:fs";
+import path from "node:path";
+import { createInterface } from "node:readline";
+
+import { unescapePath } from "./path.js";
+
+class TtlCache<K, V> {
+  private cache = new Map<K, { value: V; expiresAt: number }>();
+  private ttlMs: number;
+
+  constructor(ttlMs: number) {
+    this.ttlMs = ttlMs;
+  }
+
+  get(key: K): V | undefined {
+    const entry = this.cache.get(key);
+    if (!entry) {
+      return undefined;
+    }
+    if (Date.now() > entry.expiresAt) {
+      this.cache.delete(key);
+      return undefined;
+    }
+    return entry.value;
+  }
+
+  set(key: K, value: V): void {
+    this.cache.set(key, { value, expiresAt: Date.now() + this.ttlMs });
+  }
+
+  clear(): void {
+    this.cache.clear();
+  }
+
+  delete(key: K): void {
+    this.cache.delete(key);
+  }
+}
+
+type SearchOptions = {
+  root: string;
+  maxResults?: number;
+  includeHidden?: boolean;
+  globs?: string[];
+  ignoreGlobs?: string[];
+  useRipgrep?: boolean;
+  useGitignore?: boolean;
+};
+
+type FileDoc = {
+  path: string;
+  name: string;
+  dir: string;
+  ext: string;
+  isDirectory?: boolean;
+};
+
+type FileIndex = {
+  docs: FileDoc[];
+  building: boolean;
+  builtAt?: number;
+  buildError?: Error;
+};
+
+type SearchResult = {
+  paths: string[];
+  isDirectory: boolean[];
+};
+
+const SEARCH_RESULT_CACHE_TTL = 5 * 1000;
+const FILE_INDEX_CACHE_TTL = 60 * 1000;
+
+const searchResultCache = new TtlCache<string, SearchResult>(SEARCH_RESULT_CACHE_TTL);
+const fileIndexCache = new TtlCache<string, FileIndex>(FILE_INDEX_CACHE_TTL);
+
+const RECENCY_BOOST_SCORE = LABEL_SCORE_THRESHOLD / 4;
+
+function toDoc(filePath: string, isDirectory = false): FileDoc {
+  const normalized = filePath.replace(/\\/g, "/");
+  const name = path.posix.basename(normalized);
+  const dir = path.posix.dirname(normalized);
+  const ext = path.posix.extname(normalized);
+  return { path: normalized, name, dir, ext, isDirectory };
+}
+
+function getIndexKey(root: string): string {
+  return path.resolve(root).replace(/\\/g, "/");
+}
+
+function getResultCacheKey(
+  query: string,
+  options: Required<Pick<SearchOptions, "root" | "maxResults">>,
+): string {
+  return `${getIndexKey(options.root)}::${query}::${options.maxResults}`;
+}
+
+const fileDocAccessor: IItemAccessor<FileDoc> = {
+  getItemLabel(item: FileDoc): string {
+    return item.name;
+  },
+  getItemDescription(item: FileDoc): string {
+    return item.dir;
+  },
+  getItemPath(item: FileDoc): string {
+    return item.path;
+  },
+};
+
+function searchAndRank(
+  docs: ReadonlyArray<FileDoc>,
+  query: IPreparedQuery,
+  maxResults: number,
+): SearchResult {
+  if (docs.length === 0) {
+    return { paths: [], isDirectory: [] };
+  }
+
+  const scorerCache: FuzzyScorerCache = {};
+  const queryLower = query.normalizedLowercase;
+  const queryLength = query.normalized.length;
+
+  if (queryLength === 0) {
+    return { paths: [], isDirectory: [] };
+  }
+
+  const scoredDocs: Array<{ doc: FileDoc; score: number; recencyBoost: number }> = [];
+  const candidateLimit = Math.min(docs.length, maxResults * 15);
+
+  const candidates: Array<{ doc: FileDoc; recency: number }> = [];
+
+  for (const doc of docs) {
+    const nameLower = doc.name.toLowerCase();
+    const pathLower = doc.path.toLowerCase();
+
+    const nameStarts = nameLower.startsWith(queryLower);
+    const nameIncludes = nameLower.includes(queryLower);
+    const pathIncludes = pathLower.includes(queryLower);
+
+    if (nameStarts || nameIncludes || pathIncludes) {
+      const recency = getFileRecency(doc.path);
+      candidates.push({ doc, recency });
+    }
+  }
+
+  candidates.sort((a, b) => b.recency - a.recency);
+
+  let candidatesChecked = 0;
+  for (const { doc, recency } of candidates) {
+    if (candidatesChecked >= candidateLimit && scoredDocs.length >= maxResults * 2) {
+      break;
+    }
+
+    candidatesChecked++;
+
+    const recencyBoost = recency > 0 ? RECENCY_BOOST_SCORE : 0;
+
+    const itemScore = scoreItemFuzzy(doc, query, true, fileDocAccessor, scorerCache);
+    if (itemScore.score > 0) {
+      scoredDocs.push({
+        doc,
+        score: itemScore.score + recencyBoost,
+        recencyBoost,
+      });
+    }
+  }
+
+  scoredDocs.sort((a, b) => {
+    if (a.score !== b.score) {
+      return b.score - a.score;
+    }
+    if (a.recencyBoost !== b.recencyBoost) {
+      return b.recencyBoost - a.recencyBoost;
+    }
+    return compareItemsByFuzzyScore(a.doc, b.doc, query, true, fileDocAccessor, scorerCache);
+  });
+
+  const topResults = scoredDocs.slice(0, maxResults);
+  return {
+    paths: topResults.map((item) => item.doc.path),
+    isDirectory: topResults.map((item) => item.doc.isDirectory ?? false),
+  };
+}
+
+function getBaselineResults(docs: ReadonlyArray<FileDoc>, maxResults: number): SearchResult {
+  const withRecency = docs.map((doc) => ({
+    doc,
+    recency: getFileRecency(doc.path),
+  }));
+
+  const sorted = withRecency
+    .sort((a, b) => {
+      if (a.recency !== b.recency) {
+        return b.recency - a.recency;
+      }
+      const aDepth = a.doc.path.split("/").length;
+      const bDepth = b.doc.path.split("/").length;
+      return aDepth - bDepth || a.doc.name.localeCompare(b.doc.name);
+    })
+    .slice(0, maxResults);
+
+  return {
+    paths: sorted.map((item) => item.doc.path),
+    isDirectory: sorted.map((item) => item.doc.isDirectory ?? false),
+  };
+}
+
+async function ensureIndex(
+  options: Required<
+    Pick<SearchOptions, "root" | "includeHidden" | "globs" | "ignoreGlobs" | "useRipgrep">
+  > &
+    Pick<SearchOptions, "useGitignore">,
+): Promise<FileIndex> {
+  const key = getIndexKey(options.root);
+  const cached = fileIndexCache.get(key);
+  if (cached) {
+    if (cached.docs.length === 0 && !cached.building && !cached.buildError) {
+      fileIndexCache.delete(key);
+    } else {
+      return cached;
+    }
+  }
+
+  const index: FileIndex = { docs: [], building: true };
+  fileIndexCache.set(key, index);
+
+  const seenPaths = new Set<string>();
+
+  const addDoc = (doc: FileDoc) => {
+    if (seenPaths.has(doc.path)) {
+      return;
+    }
+    seenPaths.add(doc.path);
+    index.docs.push(doc);
+  };
+
+  if (options.useRipgrep !== false) {
+    const args: string[] = ["--files", "--no-messages", "--max-depth", "100"];
+
+    if (options.includeHidden) {
+      args.push("--hidden");
+    }
+
+    if (options.useGitignore === false) {
+      args.push("--no-ignore");
+    }
+
+    const include = options.globs ?? [];
+    const ignore = options.ignoreGlobs ?? [];
+
+    for (const g of include) {
+      args.push("-g", g);
+    }
+    for (const g of ignore) {
+      args.push("-g", g);
+    }
+
+    const child = spawn(rgPath, args, { cwd: options.root, stdio: ["ignore", "pipe", "pipe"] });
+    const rl = createInterface({ input: child.stdout });
+
+    rl.on("line", (line: string) => {
+      const raw = unescapePath(line.trim());
+      if (!raw) {
+        return;
+      }
+      const absolute = path.resolve(options.root, raw);
+      const doc = toDoc(absolute, false);
+      if (!options.includeHidden) {
+        if (
+          doc.name.startsWith(".") ||
+          doc.path.split("/").some((seg) => seg.startsWith(".") && seg !== ".")
+        ) {
+          return;
+        }
+      }
+      addDoc(doc);
+    });
+
+    const performFallbackWalk = async () => {
+      const MAX_DEPTH = 12;
+      const MAX_FILES = 15000;
+      const SKIP_DIRS = /^(node_modules|\.git|dist|build|out|coverage|\.vscode|\.idea|\.DS_Store)$/;
+
+      const walk = async (dir: string, depth: number): Promise<void> => {
+        if (depth > MAX_DEPTH || index.docs.length >= MAX_FILES) {
+          return;
+        }
+
+        try {
+          const entries = await fs.readdir(dir, { withFileTypes: true });
+          const dirs: string[] = [];
+
+          for (const entry of entries) {
+            if (!options.includeHidden && entry.name.startsWith(".")) {
+              continue;
+            }
+
+            const full = path.join(dir, entry.name);
+
+            if (entry.isDirectory()) {
+              if (SKIP_DIRS.test(entry.name)) {
+                continue;
+              }
+              addDoc(toDoc(full, true));
+              dirs.push(full);
+            } else if (entry.isFile()) {
+              addDoc(toDoc(full));
+              if (index.docs.length >= MAX_FILES) {
+                return;
+              }
+            }
+          }
+
+          await Promise.all(dirs.map((d) => walk(d, depth + 1)));
+        } catch {
+          // Skip directories we can't read
+        }
+      };
+
+      await walk(options.root, 0);
+    };
+
+    const done = new Promise<void>((resolve) => {
+      child.on("close", (code) => {
+        if (code !== 0 && code !== null) {
+          void performFallbackWalk()
+            .then(() => {
+              index.building = false;
+              index.builtAt = Date.now();
+              resolve();
+            })
+            .catch((err: unknown) => {
+              index.building = false;
+              index.buildError = err instanceof Error ? err : new Error("Indexing failed");
+              resolve();
+            });
+        } else {
+          // Collect directories after ripgrep finishes successfully
+          void (async () => {
+            const MAX_DEPTH = 12;
+            const SKIP_DIRS =
+              /^(node_modules|\.git|dist|build|out|coverage|\.vscode|\.idea|\.DS_Store)$/;
+            const walk = async (dir: string, depth: number): Promise<void> => {
+              if (depth > MAX_DEPTH) {
+                return;
+              }
+              try {
+                const entries = await fs.readdir(dir, { withFileTypes: true });
+                await Promise.all(
+                  entries
+                    .filter(
+                      (e) =>
+                        e.isDirectory() &&
+                        (options.includeHidden || !e.name.startsWith(".")) &&
+                        !SKIP_DIRS.test(e.name),
+                    )
+                    .map(async (e) => {
+                      const full = path.join(dir, e.name);
+                      addDoc(toDoc(full, true));
+                      await walk(full, depth + 1);
+                    }),
+                );
+              } catch {}
+            };
+            await walk(options.root, 0);
+          })().finally(() => {
+            index.building = false;
+            index.builtAt = Date.now();
+            resolve();
+          });
+        }
+      });
+      child.on("error", () => {
+        void performFallbackWalk()
+          .then(() => {
+            index.building = false;
+            index.builtAt = Date.now();
+            resolve();
+          })
+          .catch((err: unknown) => {
+            index.building = false;
+            index.buildError = err instanceof Error ? err : new Error("Indexing failed");
+            resolve();
+          });
+      });
+    });
+
+    void done.then(() => {
+      if (index.building) {
+        index.building = false;
+        index.builtAt = Date.now();
+      }
+    });
+  } else {
+    const MAX_DEPTH = 12;
+    const MAX_FILES = 15000;
+    const SKIP_DIRS = /^(node_modules|\.git|dist|build|out|coverage|\.vscode|\.idea|\.DS_Store)$/;
+
+    const walk = async (dir: string, depth: number): Promise<void> => {
+      if (depth > MAX_DEPTH || index.docs.length >= MAX_FILES) {
+        return;
+      }
+
+      try {
+        const entries = await fs.readdir(dir, { withFileTypes: true });
+        const dirs: string[] = [];
+
+        for (const entry of entries) {
+          if (!options.includeHidden && entry.name.startsWith(".")) {
+            continue;
+          }
+
+          const full = path.join(dir, entry.name);
+
+          if (entry.isDirectory()) {
+            if (SKIP_DIRS.test(entry.name)) {
+              continue;
+            }
+            addDoc(toDoc(full, true));
+            dirs.push(full);
+          } else if (entry.isFile()) {
+            addDoc(toDoc(full));
+            if (index.docs.length >= MAX_FILES) {
+              return;
+            }
+          }
+        }
+
+        await Promise.all(dirs.map((d) => walk(d, depth + 1)));
+      } catch {}
+    };
+
+    void walk(options.root, 0)
+      .then(() => {
+        index.building = false;
+        index.builtAt = Date.now();
+      })
+      .catch((err: unknown) => {
+        index.building = false;
+        index.buildError = err instanceof Error ? err : new Error("Indexing failed");
+      });
+  }
+
+  return index;
+}
+
+export async function* searchFiles(
+  query: string,
+  options: SearchOptions,
+): AsyncGenerator<SearchResult, void, void> {
+  const root = options.root;
+  const maxResults = options.maxResults ?? 100;
+  const includeHidden = options.includeHidden ?? false;
+  const globs = options.globs ?? [];
+  const ignoreGlobs = options.ignoreGlobs ?? [];
+  const useRipgrep = options.useRipgrep ?? true;
+  const useGitignore = options.useGitignore ?? true;
+
+  const stat = await fs.stat(root).catch(() => null);
+  if (!stat || !stat.isDirectory()) {
+    return;
+  }
+
+  const index = await ensureIndex({
+    root,
+    includeHidden,
+    globs,
+    ignoreGlobs,
+    useRipgrep,
+    useGitignore,
+  });
+
+  const trimmedQuery = query.trim();
+  const cachedKey = getResultCacheKey(trimmedQuery, { root, maxResults });
+  const cached = searchResultCache.get(cachedKey);
+  if (cached && cached.paths.length > 0) {
+    yield cached;
+    if (!index.building) {
+      return;
+    }
+  }
+
+  if (trimmedQuery.length === 0) {
+    const baseline = getBaselineResults(index.docs, maxResults);
+    if (baseline.paths.length > 0) {
+      searchResultCache.set(cachedKey, baseline);
+      yield baseline;
+    }
+    return;
+  }
+
+  const preparedQuery = prepareQuery(trimmedQuery);
+  const results = searchAndRank(index.docs, preparedQuery, maxResults);
+
+  if (results.paths.length > 0) {
+    searchResultCache.set(cachedKey, results);
+    yield results;
+  }
+
+  if (index.building) {
+    await new Promise<void>((resolve) => {
+      const checkInterval = setInterval(() => {
+        if (!index.building) {
+          clearTimeout(timeout);
+          clearInterval(checkInterval);
+          resolve();
+        }
+      }, 50);
+      const timeout = setTimeout(() => {
+        clearInterval(checkInterval);
+        resolve();
+      }, 5000);
+    });
+
+    const finalResults = searchAndRank(index.docs, preparedQuery, maxResults);
+    if (finalResults.paths.length > 0) {
+      const finalKey = getResultCacheKey(trimmedQuery, { root, maxResults });
+      searchResultCache.set(finalKey, finalResults);
+      yield finalResults;
+    }
+  }
+}

package/src/lib/markdown/code-block.tsx

@@ -0,0 +1,63 @@
+import { View, Text } from "@codellm/jar";
+import { renderMermaidAscii } from "beautiful-mermaid";
+import { highlight, supportsLanguage } from "cli-highlight";
+
+import type { CodeBlockProps } from "./types.js";
+
+/**
+ * Check if the language is mermaid
+ */
+function isMermaidLanguage(language: string | undefined): boolean {
+  if (!language) return false;
+  const normalizedLang = language.toLowerCase().trim();
+  return normalizedLang === "mermaid" || normalizedLang === "mmd";
+}
+
+/**
+ * Try to render mermaid diagram as ASCII art
+ * Returns null if parsing fails
+ */
+function tryRenderMermaid(content: string): string | null {
+  try {
+    return renderMermaidAscii(content);
+  } catch {
+    // Fallback to regular code block rendering
+    return null;
+  }
+}
+
+export function CodeBlock({ children, language }: CodeBlockProps) {
+  // Try to render mermaid diagrams as ASCII art
+  if (isMermaidLanguage(language)) {
+    const mermaidOutput = tryRenderMermaid(children || "");
+    if (mermaidOutput !== null) {
+      return (
+        <View paddingX={1} flexDirection="row" alignSelf="flex-start">
+          <Text>{mermaidOutput}</Text>
+        </View>
+      );
+    }
+    // If mermaid parsing fails, fall through to regular code block rendering
+  }
+
+  let highlighted = children;
+
+  if (language && supportsLanguage(language)) {
+    try {
+      // Use cli-highlight's default theme which works well with terminal colors
+      highlighted = highlight(children || "", {
+        language,
+      });
+    } catch {
+      // Fallback to plain text if highlighting fails
+    }
+  }
+
+  return (
+    <View paddingX={1} flexDirection="row" alignSelf="flex-start">
+      <Text>{highlighted}</Text>
+    </View>
+  );
+}
+
+CodeBlock.displayName = "CodeBlock";

package/src/lib/markdown/index.ts

@@ -0,0 +1,4 @@
+export { Markdown } from "./markdown.js";
+export { CodeBlock } from "./code-block.js";
+export { Link } from "./link.js";
+export type { MarkdownProps, CodeBlockProps, LinkProps } from "./types.js";

package/src/lib/markdown/link.tsx

@@ -0,0 +1,19 @@
+import { Text } from "@codellm/jar";
+
+import type { LinkProps } from "./types.js";
+
+import { useTheme } from "../../theme/index.js";
+
+export function Link({ href, children }: LinkProps) {
+  const { colors } = useTheme();
+  // ANSI hyperlink: ESC]8;;url ST text ESC]8;; ST
+  const open = `\x1b]8;;${href}\x07`;
+  const close = `\x1b]8;;\x07`;
+  return (
+    <Text color={colors.link} underline transform={(s) => `${open}${s}${close}`}>
+      {children}
+    </Text>
+  );
+}
+
+Link.displayName = "Link";