autohand-cli 0.8.3 → 0.9.1

package/dist/feedback-D4437VE4.js

@@ -0,0 +1,18 @@
+import {
+  feedback,
+  metadata
+} from "./chunk-YQDI753V.js";
+import "./chunk-MMKZSJUN.js";
+import "./chunk-JB3JCYBJ.js";
+import "./chunk-NZ3ZWLUW.js";
+import "./chunk-HZWU6IO3.js";
+import "./chunk-CSTUTDTH.js";
+import "./chunk-NBGOIFKP.js";
+import "./chunk-JAQO6XDB.js";
+import "./chunk-SHRLFX6F.js";
+import "./chunk-LEZEWKPA.js";
+import "./chunk-QGM4M3NI.js";
+export {
+  feedback,
+  metadata
+};

package/dist/feedback-VZPEHGFY.cjs

@@ -0,0 +1,18 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+var _chunkRBXBH6EBcjs = require('./chunk-RBXBH6EB.cjs');
+require('./chunk-S5JNQIGL.cjs');
+require('./chunk-AQ5PVHOC.cjs');
+require('./chunk-CK4HAHVY.cjs');
+require('./chunk-YWH55BWK.cjs');
+require('./chunk-NHWHEW7M.cjs');
+require('./chunk-YWTIXHU6.cjs');
+require('./chunk-2VHB43IX.cjs');
+require('./chunk-KASXKDF2.cjs');
+require('./chunk-SY2P3Z5W.cjs');
+require('./chunk-3HT76LNN.cjs');
+
+
+
+exports.feedback = _chunkRBXBH6EBcjs.feedback; exports.metadata = _chunkRBXBH6EBcjs.metadata;

package/dist/fffSearchProvider-2YCNKOYD.js

@@ -0,0 +1,412 @@
+import {
+  resolveRipgrepCommand
+} from "./chunk-UOQECODR.js";
+import "./chunk-QGM4M3NI.js";
+
+// src/search/fffSearchProvider.ts
+import { execFile } from "child_process";
+import fs from "fs/promises";
+import { createRequire } from "module";
+import path from "path";
+import { pathToFileURL } from "url";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+var FILE_WALK_IGNORED_DIRECTORIES = /* @__PURE__ */ new Set([
+  ".git",
+  ".hg",
+  ".svn",
+  "node_modules",
+  "dist",
+  "build",
+  "coverage"
+]);
+var FFFSearchProvider = class _FFFSearchProvider {
+  backend;
+  constructor(backend) {
+    this.backend = backend;
+  }
+  static async create(workspaceRoot) {
+    const backend = await createNativeClassBackend(workspaceRoot) ?? await createLowLevelFfiBackend(workspaceRoot) ?? new RipgrepSearchBackend(workspaceRoot);
+    return new _FFFSearchProvider(backend);
+  }
+  async grep(params) {
+    return this.backend.grep(params);
+  }
+  async fileSearch(params) {
+    return this.backend.fileSearch(params);
+  }
+  destroy() {
+    this.backend.destroy();
+  }
+};
+async function createNativeClassBackend(workspaceRoot) {
+  try {
+    const fffPackage = await import("@ff-labs/fff-bun");
+    const create = fffPackage.FileFinder?.create;
+    if (typeof create !== "function") {
+      return null;
+    }
+    const result = create({
+      basePath: workspaceRoot,
+      aiMode: true
+    });
+    if (!result.ok) {
+      throw new Error(`Failed to initialize FFF: ${result.error}`);
+    }
+    const finder = result.value;
+    if (typeof finder.waitForScan !== "function" || typeof finder.grep !== "function" || typeof finder.fileSearch !== "function" || typeof finder.destroy !== "function") {
+      finder.destroy?.();
+      return null;
+    }
+    const scanResult = finder.waitForScan(1e4);
+    if (!scanResult.ok) {
+      throw new Error(`Failed to scan workspace with FFF: ${scanResult.error}`);
+    }
+    return new NativeClassSearchBackend(finder);
+  } catch {
+    return null;
+  }
+}
+async function createLowLevelFfiBackend(workspaceRoot) {
+  try {
+    const ffi = await importLowLevelFfiModule();
+    if (!ffi) {
+      return null;
+    }
+    const result = ffi.ffiCreate(
+      workspaceRoot,
+      "",
+      "",
+      false,
+      true,
+      true,
+      true,
+      true,
+      "",
+      "",
+      0n,
+      0n,
+      0n
+    );
+    if (!result.ok) {
+      throw new Error(`Failed to initialize FFF: ${result.error}`);
+    }
+    const scanResult = ffi.ffiWaitForScan(result.value, 1e4);
+    if (!scanResult.ok) {
+      ffi.ffiDestroy(result.value);
+      throw new Error(`Failed to scan workspace with FFF: ${scanResult.error}`);
+    }
+    return new LowLevelFfiSearchBackend(ffi, result.value);
+  } catch {
+    return null;
+  }
+}
+async function importLowLevelFfiModule() {
+  try {
+    const require2 = createRequire(import.meta.url);
+    const packageJsonPath = require2.resolve("@ff-labs/fff-bun/package.json");
+    const ffiPath = path.join(path.dirname(packageJsonPath), "src", "ffi.ts");
+    return await import(pathToFileURL(ffiPath).href);
+  } catch {
+    return null;
+  }
+}
+var NativeClassSearchBackend = class {
+  constructor(finder) {
+    this.finder = finder;
+  }
+  finder;
+  async grep(params) {
+    const query = buildConstrainedQuery(params);
+    const mode = inferGrepMode(params.query);
+    const result = unwrap(this.finder.grep(query, {
+      mode,
+      smartCase: !params.caseSensitive,
+      beforeContext: params.beforeContext ?? 2,
+      afterContext: params.afterContext ?? 2,
+      maxMatchesPerFile: params.limit
+    }));
+    if (!result.items.length && mode !== "fuzzy") {
+      return formatGrepResult(unwrap(this.finder.grep(query, {
+        mode: "fuzzy",
+        smartCase: !params.caseSensitive,
+        beforeContext: params.beforeContext ?? 2,
+        afterContext: params.afterContext ?? 2,
+        maxMatchesPerFile: params.limit
+      })), params.limit);
+    }
+    return formatGrepResult(result, params.limit);
+  }
+  async fileSearch(params) {
+    return formatSearchResult(unwrap(this.finder.fileSearch(params.query, {
+      pageSize: params.limit ?? 50
+    })));
+  }
+  destroy() {
+    this.finder.destroy();
+  }
+};
+var LowLevelFfiSearchBackend = class {
+  constructor(ffi, handle) {
+    this.ffi = ffi;
+    this.handle = handle;
+  }
+  ffi;
+  handle;
+  async grep(params) {
+    const query = buildConstrainedQuery(params);
+    const mode = inferGrepMode(params.query);
+    const result = this.grepWithMode(query, mode, params);
+    if (!result.items.length && mode !== "fuzzy") {
+      return formatGrepResult(this.grepWithMode(query, "fuzzy", params), params.limit);
+    }
+    return formatGrepResult(result, params.limit);
+  }
+  async fileSearch(params) {
+    const result = this.ffi.ffiSearch(
+      this.handle,
+      params.query,
+      "",
+      0,
+      0,
+      params.limit ?? 50,
+      0,
+      0
+    );
+    return formatSearchResult(unwrap(result));
+  }
+  destroy() {
+    this.ffi.ffiDestroy(this.handle);
+  }
+  grepWithMode(query, mode, params) {
+    return unwrap(this.ffi.ffiLiveGrep(
+      this.handle,
+      query,
+      mode,
+      0,
+      0,
+      !params.caseSensitive,
+      0,
+      params.limit ?? 50,
+      0,
+      params.beforeContext ?? 2,
+      params.afterContext ?? 2,
+      params.classifyDefinitions ?? true
+    ));
+  }
+};
+var RipgrepSearchBackend = class {
+  constructor(workspaceRoot) {
+    this.workspaceRoot = workspaceRoot;
+  }
+  workspaceRoot;
+  async grep(params) {
+    const target = normalizeSearchTarget(params.path);
+    const args = [
+      "--line-number",
+      "--color",
+      "never",
+      "--no-heading",
+      "--with-filename",
+      "--no-binary",
+      params.caseSensitive ? "--case-sensitive" : "--smart-case"
+    ];
+    const mode = inferGrepMode(params.query);
+    if (mode === "plain") {
+      args.push("--fixed-strings");
+    }
+    if (params.beforeContext !== void 0) {
+      args.push("--before-context", String(params.beforeContext));
+    }
+    if (params.afterContext !== void 0) {
+      args.push("--after-context", String(params.afterContext));
+    }
+    for (const pattern of splitExcludePatterns(params.exclude)) {
+      args.push("--glob", `!${pattern}`);
+    }
+    args.push(params.query, target);
+    try {
+      const result = await execFileAsync(resolveRipgrepCommand(), args, {
+        cwd: this.workspaceRoot,
+        encoding: "utf8",
+        maxBuffer: 10 * 1024 * 1024
+      });
+      const lines = result.stdout.trim().split("\n").filter(Boolean);
+      if (!lines.length) {
+        return "No matches found.";
+      }
+      return formatPlainLines(lines, params.limit ?? 50, "match", "matches");
+    } catch (error) {
+      if (isNoMatchError(error)) {
+        return "No matches found.";
+      }
+      throw error;
+    }
+  }
+  async fileSearch(params) {
+    try {
+      const result = await execFileAsync(resolveRipgrepCommand(), ["--files", "."], {
+        cwd: this.workspaceRoot,
+        encoding: "utf8",
+        maxBuffer: 10 * 1024 * 1024
+      });
+      const files = result.stdout.trim().split("\n").filter(Boolean);
+      const ranked = rankPaths(files, params.query).slice(0, params.limit ?? 50);
+      if (!ranked.length) {
+        return "No files found.";
+      }
+      return ranked.join("\n");
+    } catch (error) {
+      if (isNoMatchError(error)) {
+        return "No files found.";
+      }
+      if (isMissingExecutableError(error)) {
+        return this.fileSearchWithFilesystemWalk(params);
+      }
+      throw error;
+    }
+  }
+  destroy() {
+  }
+  async fileSearchWithFilesystemWalk(params) {
+    const files = await collectWorkspaceFiles(this.workspaceRoot);
+    const ranked = rankPaths(files, params.query).slice(0, params.limit ?? 50);
+    if (!ranked.length) {
+      return "No files found.";
+    }
+    return ranked.join("\n");
+  }
+};
+function unwrap(result) {
+  if (!result.ok) {
+    throw new Error(result.error);
+  }
+  return result.value;
+}
+function formatGrepResult(searchResult, limit = 50) {
+  const hits = searchResult.items;
+  if (!hits.length) {
+    return "No matches found.";
+  }
+  const limited = hits.slice(0, limit);
+  const formattedHits = limited.map((hit) => {
+    const before = hit.contextBefore?.join("\n") ?? "";
+    const line = `${hit.relativePath}:${hit.lineNumber}: ${hit.lineContent}`;
+    const after = hit.contextAfter?.join("\n") ?? "";
+    return [before, line, after].filter(Boolean).join("\n");
+  }).join("\n\n");
+  const header = hits.length > limit ? `Found ${hits.length} matches (showing first ${limit}):
+
+` : `Found ${hits.length} match${hits.length === 1 ? "" : "es"}:
+
+`;
+  return header + formattedHits;
+}
+function formatSearchResult(result) {
+  const files = result.items;
+  if (!files.length) {
+    return "No files found.";
+  }
+  return files.map((file) => {
+    const gitStatus = file.gitStatus && file.gitStatus !== "clean" ? `[${file.gitStatus}] ` : "";
+    return `${gitStatus}${file.relativePath}`;
+  }).join("\n");
+}
+function inferGrepMode(query) {
+  return /(^|[^\\])[\\^$.*+?()[\]{}|]/.test(query) ? "regex" : "plain";
+}
+function buildConstrainedQuery(params) {
+  if (!params.path?.trim()) {
+    return params.query;
+  }
+  const normalizedPath = params.path.trim().replace(/\\/g, "/").replace(/^\.\//, "");
+  if (!normalizedPath) {
+    return params.query;
+  }
+  const constraint = normalizedPath.endsWith("/") || normalizedPath.includes("*") || /\.[^/]+$/.test(normalizedPath) ? normalizedPath : `${normalizedPath}/`;
+  return `${constraint} ${params.query}`;
+}
+function splitExcludePatterns(exclude) {
+  return exclude?.split(/[,\s]+/).map((entry) => entry.trim()).filter(Boolean) ?? [];
+}
+function normalizeSearchTarget(target) {
+  const trimmed = target?.trim();
+  if (!trimmed || trimmed === ".") {
+    return ".";
+  }
+  return trimmed.replace(/\\/g, "/").replace(/^\.\//, "");
+}
+function isNoMatchError(error) {
+  const exitCode = error?.code;
+  return exitCode === 1 || exitCode === "1";
+}
+function isMissingExecutableError(error) {
+  return error?.code === "ENOENT";
+}
+function formatPlainLines(lines, limit, singular, plural) {
+  const limited = lines.slice(0, limit);
+  const header = lines.length > limit ? `Found ${lines.length} ${plural} (showing first ${limit}):
+
+` : `Found ${lines.length} ${lines.length === 1 ? singular : plural}:
+
+`;
+  return header + limited.join("\n");
+}
+function rankPaths(files, query) {
+  const terms = query.toLowerCase().split(/\s+/).filter(Boolean);
+  return files.map((file) => ({ file, score: scorePath(file, terms) })).filter((entry) => entry.score > 0).sort((a, b) => b.score - a.score || a.file.localeCompare(b.file)).map((entry) => entry.file);
+}
+function scorePath(file, terms) {
+  if (!terms.length) {
+    return 1;
+  }
+  const normalized = file.toLowerCase();
+  const basename = path.basename(normalized);
+  let score = 0;
+  for (const term of terms) {
+    if (basename === term) {
+      score += 20;
+    } else if (basename.includes(term)) {
+      score += 10;
+    } else if (normalized.includes(term)) {
+      score += 4;
+    } else {
+      return 0;
+    }
+  }
+  return score;
+}
+async function collectWorkspaceFiles(workspaceRoot) {
+  const files = [];
+  await walkWorkspaceFiles(workspaceRoot, workspaceRoot, files);
+  return files;
+}
+async function walkWorkspaceFiles(workspaceRoot, currentDirectory, files) {
+  let entries;
+  try {
+    entries = await fs.readdir(currentDirectory, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (entry.isDirectory()) {
+      if (FILE_WALK_IGNORED_DIRECTORIES.has(entry.name)) {
+        continue;
+      }
+      await walkWorkspaceFiles(workspaceRoot, path.join(currentDirectory, entry.name), files);
+      continue;
+    }
+    if (!entry.isFile()) {
+      continue;
+    }
+    files.push(path.relative(workspaceRoot, path.join(currentDirectory, entry.name)).replace(/\\/g, "/"));
+  }
+}
+export {
+  FFFSearchProvider
+};
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */