@ff-labs/fff-bun 0.1.0-nightly.00750c2

package/examples/search.ts

@@ -0,0 +1,224 @@
+#!/usr/bin/env bun
+/**
+ * Interactive file finder demo
+ * 
+ * Usage: 
+ *   bunx fff-demo [directory]
+ *   bun examples/search.ts [directory]
+ * 
+ * Indexes the specified directory (or cwd) and provides an interactive
+ * search prompt with detailed metadata about results.
+ */
+
+import { FileFinder } from "../src/index";
+import * as readline from "readline";
+
+const RESET = "\x1b[0m";
+const BOLD = "\x1b[1m";
+const DIM = "\x1b[2m";
+const GREEN = "\x1b[32m";
+const YELLOW = "\x1b[33m";
+const BLUE = "\x1b[34m";
+const MAGENTA = "\x1b[35m";
+const CYAN = "\x1b[36m";
+const RED = "\x1b[31m";
+
+function formatGitStatus(status: string): string {
+  switch (status) {
+    case "modified":
+      return `${YELLOW}M${RESET}`;
+    case "untracked":
+      return `${GREEN}?${RESET}`;
+    case "added":
+      return `${GREEN}A${RESET}`;
+    case "deleted":
+      return `${RED}D${RESET}`;
+    case "renamed":
+      return `${BLUE}R${RESET}`;
+    case "clean":
+    case "current":
+      return `${DIM} ${RESET}`;
+    default:
+      return `${DIM}${status.charAt(0)}${RESET}`;
+  }
+}
+
+function formatScore(score: number): string {
+  if (score >= 100) return `${GREEN}${score}${RESET}`;
+  if (score >= 50) return `${YELLOW}${score}${RESET}`;
+  if (score > 0) return `${DIM}${score}${RESET}`;
+  return `${DIM}0${RESET}`;
+}
+
+function formatSize(bytes: number): string {
+  if (bytes < 1024) return `${bytes}B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)}K`;
+  return `${(bytes / 1024 / 1024).toFixed(1)}M`;
+}
+
+function formatTime(unixSeconds: number): string {
+  if (unixSeconds === 0) return "unknown";
+  const date = new Date(unixSeconds * 1000);
+  const now = new Date();
+  const diffMs = now.getTime() - date.getTime();
+  const diffMins = Math.floor(diffMs / 60000);
+  const diffHours = Math.floor(diffMs / 3600000);
+  const diffDays = Math.floor(diffMs / 86400000);
+
+  if (diffMins < 1) return "just now";
+  if (diffMins < 60) return `${diffMins}m ago`;
+  if (diffHours < 24) return `${diffHours}h ago`;
+  if (diffDays < 7) return `${diffDays}d ago`;
+  return date.toLocaleDateString();
+}
+
+async function main() {
+  const targetDir = process.argv[2] || process.cwd();
+  
+  console.log(`${BOLD}${CYAN}fff - Fast File Finder Demo${RESET}\n`);
+
+  // Check library availability
+  if (!FileFinder.isAvailable()) {
+    console.error(`${RED}Error: Native library not found.${RESET}`);
+    console.error("Build with: cargo build --release -p fff-c");
+    process.exit(1);
+  }
+
+  // Create instance
+  console.log(`${DIM}Initializing index for: ${targetDir}${RESET}`);
+  const createResult = FileFinder.create({
+    basePath: targetDir,
+  });
+
+  if (!createResult.ok) {
+    console.error(`${RED}Init failed: ${createResult.error}${RESET}`);
+    process.exit(1);
+  }
+
+  const finder = createResult.value;
+
+  // Wait for scan with progress
+  process.stdout.write(`${DIM}Scanning files...${RESET}`);
+  const startTime = Date.now();
+  let lastCount = 0;
+
+  while (finder.isScanning()) {
+    const progress = finder.getScanProgress();
+    if (progress.ok && progress.value.scannedFilesCount !== lastCount) {
+      lastCount = progress.value.scannedFilesCount;
+      process.stdout.write(`\r${DIM}Scanning files... ${lastCount}${RESET}   `);
+    }
+    await new Promise((r) => setTimeout(r, 50));
+  }
+
+  const scanTime = Date.now() - startTime;
+  const finalProgress = finder.getScanProgress();
+  const totalFiles = finalProgress.ok ? finalProgress.value.scannedFilesCount : 0;
+
+  console.log(`\r${GREEN}✓${RESET} Indexed ${BOLD}${totalFiles}${RESET} files in ${scanTime}ms\n`);
+
+  // Show index info
+  const health = finder.healthCheck();
+  if (health.ok) {
+    console.log(`${DIM}Version:${RESET}    ${health.value.version}`);
+    console.log(`${DIM}Base path:${RESET}  ${health.value.filePicker.basePath}`);
+    if (health.value.git.repositoryFound) {
+      console.log(`${DIM}Git root:${RESET}   ${health.value.git.workdir}`);
+    }
+  }
+
+  // Interactive search loop
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  console.log(`${BOLD}Enter a search query${RESET} (or 'q' to quit, empty for all files):\n`);
+
+  const prompt = () => {
+    rl.question(`${CYAN}search>${RESET} `, (query) => {
+      if (query.toLowerCase() === "q" || query.toLowerCase() === "quit") {
+        console.log(`\n${DIM}Goodbye!${RESET}`);
+        finder.destroy();
+        rl.close();
+        process.exit(0);
+      }
+
+      const searchStart = Date.now();
+      const result = finder.search(query, { pageSize: 15 });
+      const searchTime = Date.now() - searchStart;
+
+      if (!result.ok) {
+        console.log(`${RED}Search error: ${result.error}${RESET}\n`);
+        prompt();
+        return;
+      }
+
+      const { items, scores, totalMatched, totalFiles } = result.value;
+
+      console.log();
+      console.log(
+        `${DIM}Found ${BOLD}${totalMatched}${RESET}${DIM} matches in ${totalFiles} files (${searchTime}ms)${RESET}`
+      );
+      console.log();
+
+      if (items.length === 0) {
+        console.log(`${DIM}No matches found.${RESET}\n`);
+        prompt();
+        return;
+      }
+
+      // Header
+      console.log(
+        `${DIM}  Git │ Score │  Size  │  Modified  │ Path${RESET}`
+      );
+
+      // Results
+      for (let i = 0; i < items.length; i++) {
+        const item = items[i];
+        const score = scores[i];
+
+        const gitStatus = formatGitStatus(item.gitStatus);
+        const totalScore = formatScore(score.total);
+        const size = formatSize(item.size).padStart(6);
+        const modified = formatTime(item.modified).padEnd(10);
+        const path = item.relativePath;
+
+        console.log(
+          `   ${gitStatus}  │ ${totalScore.padStart(5)} │ ${size} │ ${modified} │ ${path}`
+        );
+
+        // Show score breakdown for top results
+        if (i < 3 && score.total > 0) {
+          const breakdown: string[] = [];
+          if (score.baseScore > 0) breakdown.push(`base:${score.baseScore}`);
+          if (score.filenameBonus > 0) breakdown.push(`filename:+${score.filenameBonus}`);
+          if (score.frecencyBoost > 0) breakdown.push(`frecency:+${score.frecencyBoost}`);
+          if (score.comboMatchBoost > 0) breakdown.push(`combo:+${score.comboMatchBoost}`);
+          if (score.distancePenalty < 0) breakdown.push(`distance:${score.distancePenalty}`);
+          if (score.exactMatch) breakdown.push(`${GREEN}exact${RESET}`);
+          
+          if (breakdown.length > 0) {
+            console.log(`${DIM}      │       │        │            │  └─ ${breakdown.join(", ")}${RESET}`);
+          }
+        }
+      }
+
+      if (totalMatched > items.length) {
+        console.log(
+          `${DIM}      │       │        │            │ ... and ${totalMatched - items.length} more${RESET}`
+        );
+      }
+
+      console.log();
+      prompt();
+    });
+  };
+
+  prompt();
+}
+
+main().catch((err) => {
+  console.error(`${RED}Fatal error: ${err.message}${RESET}`);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,86 @@
+{
+  "name": "@ff-labs/fff-bun",
+  "version": "0.1.0-nightly.00750c2",
+  "private": false,
+  "description": "High-performance fuzzy file finder for Bun - perfect for LLM agent tools",
+  "type": "module",
+  "main": "src/index.ts",
+  "types": "src/index.ts",
+  "exports": {
+    ".": {
+      "import": "./src/index.ts",
+      "types": "./src/index.ts"
+    }
+  },
+  "bin": {
+    "fff": "./scripts/cli.ts",
+    "fff-demo": "./examples/search.ts",
+    "fff-grep": "./examples/grep.ts"
+  },
+  "files": [
+    "src",
+    "bin",
+    "scripts",
+    "examples"
+  ],
+  "scripts": {
+    "postinstall": "bun ./scripts/postinstall.ts",
+    "download": "bun ./scripts/cli.ts download",
+    "test": "bun test src/",
+    "typecheck": "tsc --noEmit",
+    "demo": "bun ./examples/search.ts"
+  },
+  "engines": {
+    "bun": ">=1.0.0"
+  },
+  "os": [
+    "darwin",
+    "linux",
+    "win32"
+  ],
+  "cpu": [
+    "x64",
+    "arm64"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/dmtrKovalenko/fff.nvim.git",
+    "directory": "packages/fff"
+  },
+  "keywords": [
+    "file-finder",
+    "fuzzy-search",
+    "bun",
+    "ffi",
+    "llm-tools",
+    "agent-tools",
+    "fast",
+    "rust"
+  ],
+  "author": "Dmitry Kovalenko",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "bugs": {
+    "url": "https://github.com/dmtrKovalenko/fff.nvim/issues"
+  },
+  "homepage": "https://github.com/dmtrKovalenko/fff.nvim#readme",
+  "optionalDependencies": {
+    "@ff-labs/fff-bun-darwin-arm64": "0.1.0-nightly.00750c2",
+    "@ff-labs/fff-bun-darwin-x64": "0.1.0-nightly.00750c2",
+    "@ff-labs/fff-bun-linux-x64-gnu": "0.1.0-nightly.00750c2",
+    "@ff-labs/fff-bun-linux-arm64-gnu": "0.1.0-nightly.00750c2",
+    "@ff-labs/fff-bun-linux-x64-musl": "0.1.0-nightly.00750c2",
+    "@ff-labs/fff-bun-linux-arm64-musl": "0.1.0-nightly.00750c2",
+    "@ff-labs/fff-bun-win32-x64": "0.1.0-nightly.00750c2",
+    "@ff-labs/fff-bun-win32-arm64": "0.1.0-nightly.00750c2"
+  },
+  "devDependencies": {
+    "@types/bun": "^1.3.8",
+    "typescript": "^5.0.0"
+  },
+  "peerDependencies": {
+    "bun": ">=1.0.0"
+  }
+}

package/scripts/cli.ts

@@ -0,0 +1,114 @@
+#!/usr/bin/env bun
+/**
+ * CLI tool for fff package management
+ *
+ * Usage:
+ *   bunx fff download [tag]     - Download native binary from GitHub
+ *   bunx fff info               - Show platform and binary info
+ */
+
+import { 
+  downloadBinary, 
+  getBinaryPath, 
+  findBinary, 
+} from "../src/download";
+import { getTriple, getLibExtension, getLibFilename, getNpmPackageName } from "../src/platform";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const args = process.argv.slice(2);
+const command = args[0];
+
+interface PackageJson {
+  version: string;
+}
+
+async function getPackageInfo(): Promise<PackageJson> {
+  const currentDir = dirname(fileURLToPath(import.meta.url));
+  const packageJsonPath = join(currentDir, "..", "package.json");
+  
+  try {
+    return await Bun.file(packageJsonPath).json();
+  } catch {
+    return { version: "unknown" };
+  }
+}
+
+async function main() {
+  switch (command) {
+    case "download": {
+      const tag = args[1];
+      console.log("fff: Downloading native library from GitHub...");
+      try {
+        const resolvedTag = await downloadBinary(tag);
+        console.log(`fff: Download complete! (${resolvedTag})`);
+      } catch (error) {
+        console.error("fff: Download failed:", error);
+        process.exit(1);
+      }
+      break;
+    }
+
+    case "info": {
+      const pkg = await getPackageInfo();
+      let npmPackage: string;
+      try {
+        npmPackage = getNpmPackageName();
+      } catch {
+        npmPackage = "unsupported";
+      }
+      
+      console.log("fff - Fast File Finder");
+      console.log(`Package version: ${pkg.version}`);
+      console.log("");
+      console.log("Platform Information:");
+      console.log(`  Triple: ${getTriple()}`);
+      console.log(`  Extension: ${getLibExtension()}`);
+      console.log(`  Library name: ${getLibFilename()}`);
+      console.log(`  npm package: ${npmPackage}`);
+      console.log("");
+      console.log("Binary Status:");
+      const existing = findBinary();
+      if (existing) {
+        console.log(`  Found: ${existing}`);
+      } else {
+        console.log(`  Not found`);
+        console.log(`  Expected path: ${getBinaryPath()}`);
+        console.log(`  Try: bun add ${npmPackage}`);
+      }
+      break;
+    }
+
+    case "version":
+    case "--version":
+    case "-v": {
+      const pkg = await getPackageInfo();
+      console.log(pkg.version);
+      break;
+    }
+
+    case "help":
+    case "--help":
+    case "-h":
+    default: {
+      const pkg = await getPackageInfo();
+      console.log(`fff - Fast File Finder CLI v${pkg.version}`);
+      console.log("");
+      console.log("Usage:");
+      console.log("  bunx fff download [tag]    Download native binary from GitHub (fallback)");
+      console.log("  bunx fff info              Show platform and binary info");
+      console.log("  bunx fff version           Show version");
+      console.log("  bunx fff help              Show this help message");
+      console.log("");
+      console.log("Examples:");
+      console.log("  bunx fff download          Download latest binary from GitHub");
+      console.log("  bunx fff download abc1234  Download specific release tag");
+      console.log("");
+      console.log("Note: Binaries are normally provided via platform-specific npm packages.");
+      console.log("The download command is a fallback for when those aren't available.");
+      break;
+    }
+  }
+}
+
+main();

package/scripts/postinstall.ts

@@ -0,0 +1,51 @@
+#!/usr/bin/env bun
+/**
+ * Postinstall script - ensures the native binary is available
+ *
+ * Resolution order:
+ * 1. Platform-specific npm package (installed via optionalDependencies)
+ * 2. Local dev build (target/release or target/debug)
+ * 3. Fallback: download from GitHub releases
+ */
+
+import { findBinary, downloadBinary } from "../src/download";
+import { getNpmPackageName } from "../src/platform";
+
+async function main() {
+  // Check if binary is already available (npm package or dev build)
+  const existing = findBinary();
+  if (existing) {
+    console.log(`fff: Native library found at ${existing}`);
+    return;
+  }
+
+  // Binary not found via npm package - try downloading from GitHub as fallback
+  let packageName: string;
+  try {
+    packageName = getNpmPackageName();
+  } catch {
+    packageName = "unknown";
+  }
+
+  console.log(
+    `fff: Platform package ${packageName} not found, falling back to GitHub download...`
+  );
+
+  try {
+    const tag = await downloadBinary();
+    console.log(`fff: Native library installed successfully! (${tag})`);
+  } catch (error) {
+    console.error("fff: Failed to download native library:", error);
+    console.error("");
+    console.error("fff: You can build from source instead:");
+    console.error("  cargo build --release -p fff-c");
+    console.error("");
+    console.error(
+      "fff: Or run `bunx fff download` after fixing network issues."
+    );
+    // Don't exit with error - allow install to complete
+    // The error will surface when the user tries to use the library
+  }
+}
+
+main();