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

package/src/lib/fs.ts

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

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

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

@@ -1,19 +0,0 @@
-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";