@cmmd-center/forge 0.13.5 → 0.13.7

package/dist/node_modules/@ff-labs/fff-node/README.md

@@ -0,0 +1,126 @@
+# fff - Fast File Finder
+
+High-performance fuzzy file finder for Node.js, powered by Rust. Extremely fast live file, content, and directory search with a typo-resistant algorithm. As well as regex, plain-text, multi-occurrence and typo-resistant content search.
+
+Comes with built-in git status support, frecency access tracking, and a real-time file watcher, content indexing and many more! Designed for LLM agent tools that search through codebases or agentic RAG document search.
+
+Faster than ripgrep & fzf on any workflow that runs more than once per process.
+
+## Installation
+
+```bash
+npm install @ff-labs/fff-node
+```
+
+The correct native binary for your platform is installed automatically via platform-specific packages (e.g. `@ff-labs/fff-bin-darwin-arm64`, `@ff-labs/fff-bin-linux-x64-gnu`)
+
+### Supported Platforms
+
+| Platform | Architecture          | Package                             |
+| -------- | --------------------- | ----------------------------------- |
+| macOS    | ARM64 (Apple Silicon) | `@ff-labs/fff-bin-darwin-arm64`     |
+| macOS    | x64 (Intel)           | `@ff-labs/fff-bin-darwin-x64`       |
+| Linux    | x64 (glibc)           | `@ff-labs/fff-bin-linux-x64-gnu`    |
+| Linux    | ARM64 (glibc)         | `@ff-labs/fff-bin-linux-arm64-gnu`  |
+| Linux    | x64 (musl)            | `@ff-labs/fff-bin-linux-x64-musl`   |
+| Linux    | ARM64 (musl)          | `@ff-labs/fff-bin-linux-arm64-musl` |
+| Windows  | x64                   | `@ff-labs/fff-bin-win32-x64`        |
+| Windows  | ARM64                 | `@ff-labs/fff-bin-win32-arm64`      |
+
+If the platform package isn't available, the postinstall script will attempt to download from GitHub releases as a fallback.
+
+## Quick Start
+
+Each `FileFinder` instance owns an independent native index. Create one, wait
+for the initial scan, then run as many searches as you like.
+
+```typescript
+import { FileFinder } from "@ff-labs/fff-node";
+
+// Create an instance bound to a directory
+const created = FileFinder.create({ basePath: "/path/to/project" });
+if (!created.ok) throw new Error(created.error);
+
+const finder = created.value;
+
+// Wait for the initial scan (async, non-blocking)
+await finder.waitForScan(5000);
+
+// 1. Fuzzy file search (typo resistant)
+const files = finder.fileSearch("typescropt.ts", { pageSize: 10 });
+if (files.ok) {
+  for (const item of files.value.items) {
+    console.log(item.relativePath, item.gitStatus);
+  }
+}
+
+// 2. Glob filter — no fuzzy matching, 100% compatible with npm `glob`
+const globbed = finder.glob("src/**/*.ts");
+if (globbed.ok) console.log(`${globbed.value.totalMatched} TypeScript files`);
+
+// 3. Content search (live grep) with pagination
+const grep = finder.grep("TODO", { mode: "plain", pageSize: 20 });
+if (grep.ok) {
+  for (const m of grep.value.items) {
+    console.log(`${m.relativePath}:${m.lineNumber}: ${m.lineContent}`);
+  }
+}
+
+// 4. Directory search based on the query (typo resistant)
+const dirs = finder.directorySearch("components");
+if (dirs.ok) console.log(dirs.value.items.map((d) => d.relativePath));
+
+// Free the resources when you don't need a file picker anymore
+finder.destroy();
+```
+
+## API Reference
+
+Verify the latest API in the local interface at [`./src/fff-api.ts`](./src/fff-api.ts). Every field and type is documented.
+
+### Result Types
+
+All methods return a `Result<T>` type for explicit error handling:
+
+```typescript
+type Result<T> = { ok: true; value: T } | { ok: false; error: string };
+
+const result = finder.fileSearch("foo");
+
+if (result.ok) {
+  // result.value is SearchResult
+} else {
+  // result.error is string error message
+}
+```
+
+This SDK calls a native compiled library for your platform at runtime. This is generally safe — fff is battle-tested and stable, and written in a memory-safe language — but there is a class of errors that can't be caught at the Node.js level. If you hit one, please report an issue!
+
+## Building from Source
+
+If prebuilt binaries aren't available for your platform:
+
+```bash
+# Clone the repository
+git clone https://github.com/dmtrKovalenko/fff.nvim
+cd fff.nvim
+
+# Build the C library
+cargo build --release -p fff-c
+
+# The binary will be at target/release/libfff_c.{so,dylib,dll}
+```
+
+## CLI examples
+
+```bash
+# Download binary manually (fallback if npm package unavailable)
+npx @ff-labs/fff-node download [tag]
+
+# Show platform info and binary location
+npx @ff-labs/fff-node info
+```
+
+## License
+
+MIT

package/dist/node_modules/@ff-labs/fff-node/dist/src/binary.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Binary resolution utilities for fff-node
+ *
+ * Resolves the native library from:
+ * 1. Platform-specific npm package (e.g. @ff-labs/fff-bin-darwin-arm64)
+ * 2. Local dev build (target/release or target/debug)
+ */
+/**
+ * Check if the binary exists in any known location
+ */
+export declare function binaryExists(): boolean;
+/**
+ * Find the native library binary.
+ *
+ * Resolution order:
+ * - Dev workspace: local dev build first, then npm package
+ * - Production: npm package first, then dev build
+ *
+ * @returns Absolute path to the library, or null if not found
+ */
+export declare function findBinary(): string | null;
+//# sourceMappingURL=binary.d.ts.map

package/dist/node_modules/@ff-labs/fff-node/dist/src/binary.js

@@ -0,0 +1,144 @@
+/**
+ * Binary resolution utilities for fff-node
+ *
+ * Resolves the native library from:
+ * 1. Platform-specific npm package (e.g. @ff-labs/fff-bin-darwin-arm64)
+ * 2. Local dev build (target/release or target/debug)
+ */
+import { existsSync, readFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import { dirname, join, sep } from "node:path";
+import { fileURLToPath } from "node:url";
+import { getLibFilename, getNpmPackageName } from "./platform.js";
+/**
+ * Get the current file's directory
+ */
+function getCurrentDir() {
+    const url = import.meta.url;
+    if (url.startsWith("file://")) {
+        return dirname(fileURLToPath(url));
+    }
+    return dirname(url);
+}
+/**
+ * Get the package root directory
+ */
+function getPackageDir() {
+    const currentDir = getCurrentDir();
+    // In dev: src/ -> package root
+    // In dist: dist/src/ -> package root
+    // We look for package.json to find the actual root
+    let dir = currentDir;
+    for (let i = 0; i < 5; i++) {
+        if (existsSync(join(dir, "package.json"))) {
+            try {
+                const pkg = JSON.parse(readFileSync(join(dir, "package.json"), "utf-8"));
+                if (pkg.name === "@ff-labs/fff-node") {
+                    return dir;
+                }
+            }
+            catch {
+                // Not our package.json, keep going up
+            }
+        }
+        dir = dirname(dir);
+    }
+    // Fallback: assume we're one level deep in src/
+    return dirname(currentDir);
+}
+/**
+ * Check if the binary exists in any known location
+ */
+export function binaryExists() {
+    return findBinary() !== null;
+}
+/**
+ * Try to resolve the binary from the platform-specific npm package.
+ *
+ * When users install @ff-labs/fff-node, npm automatically installs the matching
+ * optionalDependency (e.g. @ff-labs/fff-bin-darwin-arm64). We resolve the binary
+ * path by requiring that package's package.json and looking for the binary
+ * in the same directory.
+ */
+function resolveUnpackedAsarPath(binaryPath) {
+    const pathSegments = binaryPath.split(sep);
+    const asarIndex = pathSegments.findLastIndex((segment) => segment.endsWith(".asar"));
+    if (asarIndex === -1) return binaryPath;
+    pathSegments[asarIndex] = `${pathSegments[asarIndex]}.unpacked`;
+    const unpackedPath = pathSegments.join(sep);
+    return existsSync(unpackedPath) ? unpackedPath : binaryPath;
+}
+
+function resolveFromNpmPackage() {
+    const packageName = getNpmPackageName();
+    try {
+        // Use createRequire to resolve the platform package's location
+        const require = createRequire(join(getPackageDir(), "package.json"));
+        const packageJsonPath = require.resolve(`${packageName}/package.json`);
+        const packageDir = dirname(packageJsonPath);
+        const binaryPath = join(packageDir, getLibFilename());
+        if (existsSync(binaryPath)) {
+            return resolveUnpackedAsarPath(binaryPath);
+        }
+    }
+    catch {
+        // Package not installed - this is expected on unsupported platforms
+        // or when installed without optional dependencies
+    }
+    return null;
+}
+/**
+ * Get the development binary path (for local development)
+ */
+function getDevBinaryPath() {
+    const packageDir = getPackageDir();
+    const workspaceRoot = join(packageDir, "..", "..");
+    const possiblePaths = [
+        join(workspaceRoot, "target", "release", getLibFilename()),
+        join(workspaceRoot, "target", "debug", getLibFilename()),
+    ];
+    for (const path of possiblePaths) {
+        if (existsSync(path)) {
+            return path;
+        }
+    }
+    return null;
+}
+function isDevWorkspace() {
+    const packageDir = getPackageDir();
+    const workspaceRoot = join(packageDir, "..", "..");
+    return existsSync(join(workspaceRoot, "Cargo.toml"));
+}
+/**
+ * Find the native library binary.
+ *
+ * Resolution order:
+ * - Dev workspace: local dev build first, then npm package
+ * - Production: npm package first, then dev build
+ *
+ * @returns Absolute path to the library, or null if not found
+ */
+export function findBinary() {
+    if (isDevWorkspace()) {
+        // 1. Local bin/ directory (populated by `make prepare-node`)
+        const binPath = join(getPackageDir(), "bin", getLibFilename());
+        if (existsSync(binPath))
+            return binPath;
+        // 2. Local dev build (target/release or target/debug)
+        const devPath = getDevBinaryPath();
+        if (devPath)
+            return devPath;
+        // 3. Fallback to npm package
+        const npmPath = resolveFromNpmPackage();
+        if (npmPath)
+            return npmPath;
+        return null;
+    }
+    // Production: npm package first
+    const npmPath = resolveFromNpmPackage();
+    if (npmPath)
+        return npmPath;
+    // Fallback: local dev build (e.g. user built from source)
+    return getDevBinaryPath();
+}
+//# sourceMappingURL=binary.js.map