@abacus-ai/cli 2.0.0-canary.1 → 2.0.0-canary.11

package/src/lib/extension-connection.ts

@@ -1,181 +0,0 @@
-import type { ContractRouterClient } from "@orpc/contract";
-
-import { createSocketClient, ideContract } from "@codellm/comms";
-import { product } from "@codellm/product";
-import { createORPCClient } from "@orpc/client";
-import * as fs from "fs";
-import * as os from "os";
-import * as path from "path";
-
-import type { CliPushServer } from "./cli-push-server.js";
-
-type IdeClient = ContractRouterClient<typeof ideContract>;
-
-/**
- * Client to connect manual CLI to the VS Code extension via oRPC over Unix socket.
- * Uses push-based communication — no polling.
- */
-export class ExtensionConnection {
-  private client: IdeClient | null = null;
-  private disposeSocket: (() => void) | null = null;
-
-  private currentFile: string | undefined = undefined;
-  private selectionStartLine: number | undefined = undefined;
-  private selectionEndLine: number | undefined = undefined;
-
-  private onFileChangeCallback:
-    | ((file: string | undefined, startLine?: number, endLine?: number) => void)
-    | null = null;
-
-  constructor(private readonly pushServer: CliPushServer) {}
-
-  private findSocketPath(): string | null {
-    const envPath = process.env[product.socketEnvVar];
-    if (envPath && fs.existsSync(envPath)) {
-      return envPath;
-    }
-
-    // Fallback: scan the IDE socket dir for the most recently modified socket file
-    // This handles the case where the terminal was opened before the extension set the env var
-    try {
-      const socketDir = path.join(os.homedir(), product.configDirName, product.ideDirName);
-      const entries = fs.readdirSync(socketDir).filter((f) => f.endsWith(".sock"));
-      if (entries.length === 0) return null;
-
-      let best: { path: string; mtime: number } | null = null;
-      for (const entry of entries) {
-        const fullPath = path.join(socketDir, entry);
-        try {
-          const stat = fs.statSync(fullPath);
-          if (!best || stat.mtimeMs > best.mtime) {
-            best = { path: fullPath, mtime: stat.mtimeMs };
-          }
-        } catch {
-          // stale entry
-        }
-      }
-      if (best && fs.existsSync(best.path)) return best.path;
-    } catch {
-      // ignore
-    }
-    return null;
-  }
-
-  async connect(): Promise<boolean> {
-    try {
-      const socketPath = this.findSocketPath();
-      if (!socketPath) {
-        return false;
-      }
-
-      const handle = await createSocketClient(socketPath, { timeoutMs: 2000 });
-      this.client = createORPCClient<IdeClient>(handle.link);
-      this.disposeSocket = () => handle.dispose();
-
-      // Register our push server with the extension
-      await this.client.register({
-        cliSocketPath: this.pushServer.socketPath,
-        pid: process.pid,
-      });
-
-      // Seed state from push server (may already have state)
-      const state = this.pushServer.getEditorState();
-      this.currentFile = state.file;
-      this.selectionStartLine = state.startLine;
-      this.selectionEndLine = state.endLine;
-
-      // Wire push-based updates
-      this.pushServer.onEditorChange((s) => {
-        this.currentFile = s.file;
-        this.selectionStartLine = s.startLine;
-        this.selectionEndLine = s.endLine;
-        this.onFileChangeCallback?.(s.file, s.startLine, s.endLine);
-      });
-
-      return true;
-    } catch {
-      return false;
-    }
-  }
-
-  getCurrentFile(): string | undefined {
-    return this.currentFile;
-  }
-
-  getSelectionRange(): { startLine?: number; endLine?: number } {
-    return {
-      startLine: this.selectionStartLine,
-      endLine: this.selectionEndLine,
-    };
-  }
-
-  isConnected(): boolean {
-    return this.client !== null;
-  }
-
-  onFileChange(
-    callback: (file: string | undefined, startLine?: number, endLine?: number) => void,
-  ): void {
-    this.onFileChangeCallback = callback;
-  }
-
-  async showDiff(params: {
-    filePath: string;
-    originalContent: string;
-    modifiedContent: string;
-    toolId: string;
-  }): Promise<boolean> {
-    if (!this.client) return false;
-    try {
-      const result = await this.client.showDiff({
-        ...params,
-        cliSocketPath: this.pushServer.socketPath,
-      });
-      return result.success;
-    } catch {
-      return false;
-    }
-  }
-
-  async showToolView(params: { filePath: string; toolKey: string }): Promise<boolean> {
-    if (!this.client) return false;
-    try {
-      const result = await this.client.showToolView({
-        ...params,
-        cliSocketPath: this.pushServer.socketPath,
-      });
-      return result.success;
-    } catch {
-      return false;
-    }
-  }
-
-  async notifyDiffDecision(params: {
-    targetFile: string;
-    decision: "accept" | "reject";
-  }): Promise<void> {
-    if (!this.client) throw new Error("Not connected to extension");
-    await this.client.notifyDiffDecision(params);
-  }
-
-  async openPlanFile(planFilePath: string): Promise<{ opened: boolean }> {
-    if (!this.client) throw new Error("Not connected to extension");
-    const result = await this.client.openFile({ file: planFilePath });
-    return { opened: result.success };
-  }
-
-  async getDiagnostics(files?: string[]): Promise<unknown> {
-    if (!this.client) throw new Error("Not connected to extension");
-    return this.client.getDiagnostics({ ...(files && { files }) });
-  }
-
-  dispose(): void {
-    this.disposeSocket?.();
-    this.disposeSocket = null;
-    this.client = null;
-    this.currentFile = undefined;
-    this.selectionStartLine = undefined;
-    this.selectionEndLine = undefined;
-    this.onFileChangeCallback = null;
-  }
-}

package/src/lib/focusables.ts

@@ -1,7 +0,0 @@
-export enum Focusable {
-  Composer = "composer",
-  ModelSelector = "model-selector",
-  Messages = "messages",
-  Sidebar = "sidebar",
-  ToolPermission = "tool-permission",
-}

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;
-    }
-  }
-}