@ff-labs/fff-bun 0.5.2 → 0.5.3-nightly.205f9d6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ff-labs/fff-bun",
-  "version": "0.5.2",
+  "version": "0.5.3-nightly.205f9d6",
   "private": false,
   "description": "High-performance fuzzy file finder for Bun - perfect for LLM agent tools",
   "type": "module",
@@ -62,14 +62,14 @@
   },
   "homepage": "https://github.com/dmtrKovalenko/fff.nvim#readme",
   "optionalDependencies": {
-    "@ff-labs/fff-bin-darwin-arm64": "0.5.2",
-    "@ff-labs/fff-bin-darwin-x64": "0.5.2",
-    "@ff-labs/fff-bin-linux-x64-gnu": "0.5.2",
-    "@ff-labs/fff-bin-linux-arm64-gnu": "0.5.2",
-    "@ff-labs/fff-bin-linux-x64-musl": "0.5.2",
-    "@ff-labs/fff-bin-linux-arm64-musl": "0.5.2",
-    "@ff-labs/fff-bin-win32-x64": "0.5.2",
-    "@ff-labs/fff-bin-win32-arm64": "0.5.2"
+    "@ff-labs/fff-bin-darwin-arm64": "0.5.3-nightly.205f9d6",
+    "@ff-labs/fff-bin-darwin-x64": "0.5.3-nightly.205f9d6",
+    "@ff-labs/fff-bin-linux-x64-gnu": "0.5.3-nightly.205f9d6",
+    "@ff-labs/fff-bin-linux-arm64-gnu": "0.5.3-nightly.205f9d6",
+    "@ff-labs/fff-bin-linux-x64-musl": "0.5.3-nightly.205f9d6",
+    "@ff-labs/fff-bin-linux-arm64-musl": "0.5.3-nightly.205f9d6",
+    "@ff-labs/fff-bin-win32-x64": "0.5.3-nightly.205f9d6",
+    "@ff-labs/fff-bin-win32-arm64": "0.5.3-nightly.205f9d6"
   },
   "devDependencies": {
     "@types/bun": "^1.3.8",

package/src/git-lifecycle.test.ts

@@ -86,7 +86,10 @@ async function waitForFileStatus(
 }
 
 /** Poll until a file is gone from the index, or the timeout is exceeded. */
-async function waitForFileGone(finder: FileFinder, name: string): Promise<boolean> {
+async function waitForFileGone(
+  finder: FileFinder,
+  name: string,
+): Promise<boolean> {
   const start = Date.now();
   while (Date.now() - start < WATCHER_TIMEOUT_MS) {
     if (findFile(finder, name) === undefined) return true;
@@ -96,7 +99,10 @@ async function waitForFileGone(finder: FileFinder, name: string): Promise<boolea
 }
 
 /** Poll until the total file count reaches the expected value, or the timeout is exceeded. */
-async function waitForFileCount(finder: FileFinder, count: number): Promise<number> {
+async function waitForFileCount(
+  finder: FileFinder,
+  count: number,
+): Promise<number> {
   const start = Date.now();
   while (Date.now() - start < WATCHER_TIMEOUT_MS) {
     const result = finder.fileSearch("", { pageSize: 200 });
@@ -123,203 +129,269 @@ async function waitForGrep(
   return finder.grep(pattern, options);
 }
 
-describe.skipIf(process.platform === "win32")("Git lifecycle integration", () => {
-  let tmpDir: string;
-  let finder: FileFinder;
-
-  beforeAll(async () => {
-    // Create temp directory and initialise a git repo with two committed files.
-    // Use realpathSync to resolve symlinks (macOS /var -> /private/var) so
-    // that git2's resolved workdir paths match the file picker's base_path.
-    tmpDir = realpathSync(mkdtempSync(join(tmpdir(), "fff-git-test-")));
-
-    git(tmpDir, "init", "-b", "main");
-    // Need at least one commit for status to work properly
-    writeFileSync(join(tmpDir, "hello.txt"), "hello world\n");
-    writeFileSync(join(tmpDir, "readme.md"), "# Test Project\n");
-    mkdirSync(join(tmpDir, "src"));
-    writeFileSync(join(tmpDir, "src", "main.rs"), 'fn main() { println?."hi"); }\n');
-    git(tmpDir, "add", "-A");
-    git(tmpDir, "commit", "-m", "initial commit");
-
-    // Create the FileFinder instance
-    const result = FileFinder.create({ basePath: tmpDir });
-    expect(result.ok).toBe(true);
-    if (!result.ok) throw new Error(result.error);
-    finder = result.value;
-
-    // Wait for the initial scan to finish
-    const scanResult = finder.waitForScan(10_000);
-    expect(scanResult.ok).toBe(true);
-
-    // Poll getScanProgress until the watcher is ready so that
-    // filesystem events (file creates, deletes) are detected.
-    const start = Date.now();
-    while (Date.now() - start < WATCHER_TIMEOUT_MS) {
+describe.skipIf(process.platform === "win32")(
+  "Git lifecycle integration",
+  () => {
+    let tmpDir: string;
+    let finder: FileFinder;
+
+    beforeAll(async () => {
+      // Create temp directory and initialise a git repo with two committed files.
+      // Use realpathSync to resolve symlinks (macOS /var -> /private/var) so
+      // that git2's resolved workdir paths match the file picker's base_path.
+      tmpDir = realpathSync(mkdtempSync(join(tmpdir(), "fff-git-test-")));
+
+      git(tmpDir, "init", "-b", "main");
+      // Need at least one commit for status to work properly
+      writeFileSync(join(tmpDir, "hello.txt"), "hello world\n");
+      writeFileSync(join(tmpDir, "readme.md"), "# Test Project\n");
+      mkdirSync(join(tmpDir, "src"));
+      writeFileSync(
+        join(tmpDir, "src", "main.rs"),
+        'fn main() { println?."hi"); }\n',
+      );
+      git(tmpDir, "add", "-A");
+      git(tmpDir, "commit", "-m", "initial commit");
+
+      // Create the FileFinder instance
+      const result = FileFinder.create({ basePath: tmpDir });
+      expect(result.ok).toBe(true);
+      if (!result.ok) throw new Error(result.error);
+      finder = result.value;
+
+      // Wait for the initial scan to finish
+      const scanResult = finder.waitForScan(10_000);
+      expect(scanResult.ok).toBe(true);
+
+      // Poll getScanProgress until the watcher is ready so that
+      // filesystem events (file creates, deletes) are detected.
+      const start = Date.now();
+      while (Date.now() - start < WATCHER_TIMEOUT_MS) {
+        const progress = finder.getScanProgress();
+        if (progress.ok && progress.value.isWatcherReady) break;
+        await sleep(POLL_INTERVAL_MS);
+      }
       const progress = finder.getScanProgress();
-      if (progress.ok && progress.value.isWatcherReady) break;
-      await sleep(POLL_INTERVAL_MS);
-    }
-    const progress = finder.getScanProgress();
-    expect(progress.ok).toBe(true);
-    if (progress.ok) {
-      expect(progress.value.isWatcherReady).toBe(true);
-    }
-  });
-
-  afterAll(() => {
-    finder?.destroy();
-    if (tmpDir) {
-      rmSync(tmpDir, { recursive: true, force: true });
-    }
-  });
-
-  test("initial scan indexes all committed files", () => {
-    const result = finder.fileSearch("", { pageSize: 200 });
-    expect(result.ok).toBe(true);
-    if (!result.ok) return;
-
-    const names = result.value.items.map((i) => i.relativePath).sort();
-    expect(names).toContain("hello.txt");
-    expect(names).toContain("readme.md");
-    expect(names).toContain("src/main.rs");
-    expect(result.value.totalFiles).toBe(3);
-  });
-
-  test("committed files have clean git status", async () => {
-    const hello = await waitForFileStatus(finder, "hello.txt", "clean");
-    expect(hello).toBeDefined();
-    expect(hello?.gitStatus).toBe("clean");
-
-    const main = await waitForFileStatus(finder, "main.rs", "clean");
-    expect(main).toBeDefined();
-    expect(main?.gitStatus).toBe("clean");
-  });
-
-  test("new untracked file appears with 'untracked' status", async () => {
-    writeFileSync(join(tmpDir, "new_file.ts"), "export const x = 1;\n");
-
-    const newFile = await waitForFileStatus(finder, "new_file.ts", "untracked");
-    expect(newFile).toBeDefined();
-    expect(newFile?.gitStatus).toBe("untracked");
-
-    // Total should now be 4
-    const total = await waitForFileCount(finder, 4);
-    expect(total).toBe(4);
-  });
-
-  test("staging a new file changes status to 'staged_new'", async () => {
-    git(tmpDir, "add", "new_file.ts");
-
-    const newFile = await waitForFileStatus(finder, "new_file.ts", "staged_new");
-    expect(newFile).toBeDefined();
-    expect(newFile?.gitStatus).toBe("staged_new");
-  });
-
-  test("committing makes the file 'clean'", async () => {
-    git(tmpDir, "commit", "-m", "add new_file");
-
-    const newFile = await waitForFileStatus(finder, "new_file.ts", "clean");
-    expect(newFile).toBeDefined();
-    expect(newFile?.gitStatus).toBe("clean");
-  });
-
-  test("modifying a tracked file changes status to 'modified'", async () => {
-    writeFileSync(join(tmpDir, "hello.txt"), "hello world\nupdated content\n");
-
-    const hello = await waitForFileStatus(finder, "hello.txt", "modified");
-    expect(hello).toBeDefined();
-    expect(hello?.gitStatus).toBe("modified");
-  });
-
-  test("staging a modification changes status to 'staged_modified'", async () => {
-    git(tmpDir, "add", "hello.txt");
-
-    const hello = await waitForFileStatus(finder, "hello.txt", "staged_modified");
-    expect(hello).toBeDefined();
-    expect(hello?.gitStatus).toBe("staged_modified");
-  });
-
-  test("committing the modification returns to 'clean'", async () => {
-    git(tmpDir, "commit", "-m", "update hello");
-
-    const hello = await waitForFileStatus(finder, "hello.txt", "clean");
-    expect(hello).toBeDefined();
-    expect(hello?.gitStatus).toBe("clean");
-  });
-
-  test("deleting a file removes it from the index", async () => {
-    unlinkSync(join(tmpDir, "new_file.ts"));
-
-    const gone = await waitForFileGone(finder, "new_file.ts");
-    expect(gone).toBe(true);
-
-    // Total should be back to 3
-    const total = await waitForFileCount(finder, 3);
-    expect(total).toBe(3);
-  });
-
-  test("adding a file in a subdirectory works", async () => {
-    writeFileSync(join(tmpDir, "src", "utils.rs"), "pub fn helper() {}\n");
-
-    const utils = await waitForFileStatus(finder, "utils.rs", "untracked");
-    expect(utils).toBeDefined();
-    expect(utils?.relativePath).toBe("src/utils.rs");
-    expect(utils?.gitStatus).toBe("untracked");
-  });
-
-  test("live grep finds content in a newly added file", async () => {
-    writeFileSync(
-      join(tmpDir, "src", "searchtarget.rs"),
-      'const UNIQUE_NEEDLE: &str = "xylophone_waterfall_97";\n',
-    );
-
-    await waitForFile(finder, "searchtarget.rs");
-
-    const result = await waitForGrep(
-      finder,
-      "xylophone_waterfall_97",
-      { mode: "plain" },
-      (n) => n > 0,
-    );
-    expect(result?.ok).toBe(true);
-    if (!result?.ok) return;
-
-    expect(result.value.totalMatched).toBeGreaterThan(0);
-    const match = result.value.items.find(
-      (m) => m.relativePath === "src/searchtarget.rs",
-    );
-    expect(match).toBeDefined();
-    expect(match!.lineContent).toContain("xylophone_waterfall_97");
-  });
-
-  test("live grep no longer finds content after file is deleted", async () => {
-    unlinkSync(join(tmpDir, "src", "searchtarget.rs"));
-
-    const result = await waitForGrep(
-      finder,
-      "xylophone_waterfall_97",
-      { mode: "plain" },
-      (n) => n === 0,
-    );
-    expect(result?.ok).toBe(true);
-    if (!result?.ok) return;
-
-    expect(result.value.totalMatched).toBe(0);
-    expect(result.value.items.length).toBe(0);
-  });
-
-  test("full add-commit cycle for subdirectory file", async () => {
-    git(tmpDir, "add", "src/utils.rs");
-
-    let utils = await waitForFileStatus(finder, "utils.rs", "staged_new");
-    expect(utils).toBeDefined();
-    expect(utils?.gitStatus).toBe("staged_new");
-
-    git(tmpDir, "commit", "-m", "add utils");
-
-    utils = await waitForFileStatus(finder, "utils.rs", "clean");
-    expect(utils).toBeDefined();
-    expect(utils?.gitStatus).toBe("clean");
-  });
-});
+      expect(progress.ok).toBe(true);
+      if (progress.ok) {
+        expect(progress.value.isWatcherReady).toBe(true);
+      }
+    });
+
+    afterAll(() => {
+      finder?.destroy();
+      if (tmpDir) {
+        rmSync(tmpDir, { recursive: true, force: true });
+      }
+    });
+
+    test("initial scan indexes all committed files", () => {
+      const result = finder.fileSearch("", { pageSize: 200 });
+      expect(result.ok).toBe(true);
+      if (!result.ok) return;
+
+      const names = result.value.items.map((i) => i.relativePath).sort();
+      expect(names).toContain("hello.txt");
+      expect(names).toContain("readme.md");
+      expect(names).toContain("src/main.rs");
+      expect(result.value.totalFiles).toBe(3);
+    });
+
+    test("committed files have clean git status", async () => {
+      const hello = await waitForFileStatus(finder, "hello.txt", "clean");
+      expect(hello).toBeDefined();
+      expect(hello?.gitStatus).toBe("clean");
+
+      const main = await waitForFileStatus(finder, "main.rs", "clean");
+      expect(main).toBeDefined();
+      expect(main?.gitStatus).toBe("clean");
+    });
+
+    test("new untracked file appears with 'untracked' status", async () => {
+      writeFileSync(join(tmpDir, "new_file.ts"), "export const x = 1;\n");
+
+      const newFile = await waitForFileStatus(
+        finder,
+        "new_file.ts",
+        "untracked",
+      );
+      expect(newFile).toBeDefined();
+      expect(newFile?.gitStatus).toBe("untracked");
+
+      // Total should now be 4
+      const total = await waitForFileCount(finder, 4);
+      expect(total).toBe(4);
+    });
+
+    test("staging a new file changes status to 'staged_new'", async () => {
+      git(tmpDir, "add", "new_file.ts");
+
+      const newFile = await waitForFileStatus(
+        finder,
+        "new_file.ts",
+        "staged_new",
+      );
+      expect(newFile).toBeDefined();
+      expect(newFile?.gitStatus).toBe("staged_new");
+    });
+
+    test("committing makes the file 'clean'", async () => {
+      git(tmpDir, "commit", "-m", "add new_file");
+
+      const newFile = await waitForFileStatus(finder, "new_file.ts", "clean");
+      expect(newFile).toBeDefined();
+      expect(newFile?.gitStatus).toBe("clean");
+    });
+
+    test("modifying a tracked file changes status to 'modified'", async () => {
+      writeFileSync(
+        join(tmpDir, "hello.txt"),
+        "hello world\nupdated content\n",
+      );
+
+      const hello = await waitForFileStatus(finder, "hello.txt", "modified");
+      expect(hello).toBeDefined();
+      expect(hello?.gitStatus).toBe("modified");
+    });
+
+    test("staging a modification changes status to 'staged_modified'", async () => {
+      git(tmpDir, "add", "hello.txt");
+
+      const hello = await waitForFileStatus(
+        finder,
+        "hello.txt",
+        "staged_modified",
+      );
+      expect(hello).toBeDefined();
+      expect(hello?.gitStatus).toBe("staged_modified");
+    });
+
+    test("committing the modification returns to 'clean'", async () => {
+      git(tmpDir, "commit", "-m", "update hello");
+
+      const hello = await waitForFileStatus(finder, "hello.txt", "clean");
+      expect(hello).toBeDefined();
+      expect(hello?.gitStatus).toBe("clean");
+    });
+
+    test("deleting a file removes it from the index", async () => {
+      unlinkSync(join(tmpDir, "new_file.ts"));
+
+      const gone = await waitForFileGone(finder, "new_file.ts");
+      expect(gone).toBe(true);
+
+      // Total should be back to 3
+      const total = await waitForFileCount(finder, 3);
+      expect(total).toBe(3);
+    });
+
+    test("adding a file in a subdirectory works", async () => {
+      writeFileSync(join(tmpDir, "src", "utils.rs"), "pub fn helper() {}\n");
+
+      const utils = await waitForFileStatus(finder, "utils.rs", "untracked");
+      expect(utils).toBeDefined();
+      expect(utils?.relativePath).toBe("src/utils.rs");
+      expect(utils?.gitStatus).toBe("untracked");
+    });
+
+    test("live grep finds content in a newly added file", async () => {
+      writeFileSync(
+        join(tmpDir, "src", "searchtarget.rs"),
+        'const UNIQUE_NEEDLE: &str = "xylophone_waterfall_97";\n',
+      );
+
+      await waitForFile(finder, "searchtarget.rs");
+
+      const result = await waitForGrep(
+        finder,
+        "xylophone_waterfall_97",
+        { mode: "plain" },
+        (n) => n > 0,
+      );
+      expect(result?.ok).toBe(true);
+      if (!result?.ok) return;
+
+      expect(result.value.totalMatched).toBeGreaterThan(0);
+      const match = result.value.items.find(
+        (m) => m.relativePath === "src/searchtarget.rs",
+      );
+      expect(match).toBeDefined();
+      expect(match!.lineContent).toContain("xylophone_waterfall_97");
+    });
+
+    test("live grep no longer finds content after file is deleted", async () => {
+      unlinkSync(join(tmpDir, "src", "searchtarget.rs"));
+
+      const result = await waitForGrep(
+        finder,
+        "xylophone_waterfall_97",
+        { mode: "plain" },
+        (n) => n === 0,
+      );
+      expect(result?.ok).toBe(true);
+      if (!result?.ok) return;
+
+      expect(result.value.totalMatched).toBe(0);
+      expect(result.value.items.length).toBe(0);
+    });
+
+    test("file in a newly created directory is discoverable", async () => {
+      // Create a brand-new directory that didn't exist during the initial scan,
+      // then add a file inside it. The watcher must dynamically pick up the new
+      // directory and index the file.
+      mkdirSync(join(tmpDir, "lib"));
+      writeFileSync(
+        join(tmpDir, "lib", "helpers.ts"),
+        "export function add(a: number, b: number) { return a + b; }\n",
+      );
+
+      const helpers = await waitForFile(finder, "helpers.ts");
+      expect(helpers).toBeDefined();
+      expect(helpers?.relativePath).toBe("lib/helpers.ts");
+    });
+
+    test("files in gitignored directories are not indexed", async () => {
+      // Commit a .gitignore rule first so it's established repo state before
+      // the ignored directory is created. This tests the watch-level filtering
+      // (is_path_ignored in the debouncer callback), not a rescan triggered
+      // by a .gitignore change.
+      writeFileSync(join(tmpDir, ".gitignore"), "build_output/\n");
+      git(tmpDir, "add", ".gitignore");
+      git(tmpDir, "commit", "-m", "add gitignore");
+
+      // Wait for the watcher to settle after the commit.
+      await waitForFile(finder, ".gitignore");
+
+      // Now create the ignored directory and add a file inside it.
+      mkdirSync(join(tmpDir, "build_output"));
+      writeFileSync(
+        join(tmpDir, "build_output", "artifact.bin"),
+        "should not appear\n",
+      );
+
+      // Create a non-ignored file as a synchronisation barrier — once it's
+      // indexed, the watcher has processed the same batch of events.
+      writeFileSync(join(tmpDir, "canary.txt"), "visible\n");
+      const canary = await waitForFile(finder, "canary.txt");
+      expect(canary).toBeDefined();
+
+      // The ignored file must NOT appear in the index.
+      const artifact = findFile(finder, "artifact.bin");
+      expect(artifact).toBeUndefined();
+    });
+
+    test("full add-commit cycle for subdirectory file", async () => {
+      git(tmpDir, "add", "src/utils.rs");
+
+      let utils = await waitForFileStatus(finder, "utils.rs", "staged_new");
+      expect(utils).toBeDefined();
+      expect(utils?.gitStatus).toBe("staged_new");
+
+      git(tmpDir, "commit", "-m", "add utils");
+
+      utils = await waitForFileStatus(finder, "utils.rs", "clean");
+      expect(utils).toBeDefined();
+      expect(utils?.gitStatus).toBe("clean");
+    });
+  },
+);