pi-neutrasearch 0.1.0 → 0.2.0

package/README.md

@@ -6,20 +6,29 @@ Token-efficient native indexed filename and path search for [Pi](https://pi.dev)
 
 ## Install
 
-Install Neutrasearch and build its index first, then install the Pi package:
+Install the Pi package:
 
 ```sh
 pi install npm:pi-neutrasearch
 ```
 
-Use `/neutrasearch` inside Pi to confirm executable discovery.
+npm automatically installs the matching Neutrasearch application for Linux x64/ARM64, Windows x64, or macOS x64/ARM64. No separate application download or compiler is required.
+
+Inside Pi, run:
+
+```text
+/neutrasearch-setup
+```
+
+This opens the bundled Neutrasearch app. Approve local indexing there, then return to Pi. Indexing remains an explicit user action; package installation never scans disks or requests privileges.
+
+Use `/neutrasearch` to inspect installation and index status.
 
 The package resolves, in order:
 
-1. `NEUTRASEARCH_QUERY`
-2. `neutrasearch-query` on `PATH`
-3. `NEUTRASEARCH_BIN`
-4. `neutrasearch` on `PATH`
+1. `NEUTRASEARCH_QUERY` or `NEUTRASEARCH_BIN` when explicitly configured
+2. the OS/architecture-specific binary package installed by npm
+3. `neutrasearch-query` or `neutrasearch` on `PATH`
 
 Set `NEUTRASEARCH_INDEX` to override Neutrasearch's platform-default index path.
 

package/index.js

@@ -1,4 +1,12 @@
-import { compactSearchResult, limits, queryArguments, resolveNeutrasearch, resolveScope } from "./lib.js";
+import { spawn } from "node:child_process";
+import {
+  compactSearchResult,
+  limits,
+  queryArguments,
+  resolveNeutrasearch,
+  resolveNeutrasearchApp,
+  resolveScope,
+} from "./lib.js";
 
 const TOOL_NAME = "neutrasearch";
 
@@ -17,7 +25,7 @@ function status(binary) {
       ok: false,
       tool: TOOL_NAME,
       error: "Neutrasearch executable not found",
-      setup: "Install Neutrasearch, or set NEUTRASEARCH_QUERY / NEUTRASEARCH_BIN.",
+      setup: "Reinstall pi-neutrasearch to fetch its matching native binary package, or set NEUTRASEARCH_QUERY / NEUTRASEARCH_BIN.",
       token_defaults: { limit: limits.defaultLimit, max_chars: limits.defaultMaxChars },
     };
   }
@@ -26,6 +34,8 @@ function status(binary) {
     tool: TOOL_NAME,
     executable: binary.command,
     executable_kind: binary.kind,
+    bundled_package: binary.packageName || null,
+    app: binary.app || resolveNeutrasearchApp() || null,
     index: process.env.NEUTRASEARCH_INDEX || "platform default",
     default_scope: "current Pi workspace",
     extra_scope_env: "NEUTRASEARCH_PI_ALLOWED_ROOTS",
@@ -50,11 +60,27 @@ async function search(pi, params, signal, ctx) {
   const { scope } = resolveScope(params.scope, ctx.cwd);
   const { args, limit } = queryArguments(params, scope);
   const timeout = Math.max(1000, Math.min(30000, Math.trunc(Number(params.timeout_ms) || 10000)));
-  const execution = await pi.exec(binary.command, [...binary.prefix, ...args], {
+  let transport = params.metadata ? "metadata-json" : "paths-only-json";
+  let execution = await pi.exec(binary.command, [...binary.prefix, ...args], {
     cwd: ctx.cwd,
     signal,
     timeout,
   });
+  if (
+    execution.code !== 0
+    && !params.metadata
+    && args.includes("--json-paths")
+    && /(?:unknown|unrecognized|unexpected).*(?:--json-paths)|--json-paths.*(?:unknown|unrecognized|unexpected)/i
+      .test(`${execution.stderr}\n${execution.stdout}`)
+  ) {
+    const compatibleArgs = args.map((argument) => argument === "--json-paths" ? "--json" : argument);
+    execution = await pi.exec(binary.command, [...binary.prefix, ...compatibleArgs], {
+      cwd: ctx.cwd,
+      signal,
+      timeout,
+    });
+    transport = "metadata-json-compat";
+  }
   if (execution.code !== 0) {
     throw new Error(`Neutrasearch exited ${execution.code}: ${shortError(execution.stderr || execution.stdout)}`);
   }
@@ -75,6 +101,7 @@ async function search(pi, params, signal, ctx) {
     query: params.query,
     limit,
     executable_kind: binary.kind,
+    transport,
     token_efficient: true,
   });
 }
@@ -142,6 +169,31 @@ export default function register(pi) {
     },
   });
 
+  pi.registerCommand("neutrasearch-setup", {
+    description: "Open the bundled Neutrasearch app to approve and build its index",
+    handler: async (_args, ctx) => {
+      const application = resolveNeutrasearchApp();
+      if (!application) {
+        ctx.ui.notify(
+          "Neutrasearch app is missing. Reinstall pi-neutrasearch or set NEUTRASEARCH_BIN.",
+          "error",
+        );
+        return;
+      }
+      try {
+        const child = spawn(application, [], {
+          detached: true,
+          stdio: "ignore",
+          windowsHide: false,
+        });
+        child.unref();
+        ctx.ui.notify("Neutrasearch opened. Approve local indexing in the app, then return to Pi.", "info");
+      } catch (error) {
+        ctx.ui.notify(`Could not open Neutrasearch: ${shortError(error)}`, "error");
+      }
+    },
+  });
+
   pi.registerCommand("neutrasearch", {
     description: "Show Neutrasearch Pi integration status",
     handler: async (_args, ctx) => {

package/lib.js

@@ -1,6 +1,9 @@
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
+import { createRequire } from "node:module";
+
+const require = createRequire(import.meta.url);
 
 const DEFAULT_LIMIT = 20;
 const MAX_LIMIT = 200;
@@ -46,25 +49,93 @@ function findOnPath(command, env = process.env, platform = process.platform) {
   return null;
 }
 
-export function resolveNeutrasearch(env = process.env, platform = process.platform) {
-  const candidates = [
+export function bundledPackageName(platform = process.platform, architecture = process.arch) {
+  return {
+    "linux:x64": "neutrasearch-linux-x64",
+    "linux:arm64": "neutrasearch-linux-arm64",
+    "win32:x64": "neutrasearch-windows-x64",
+    "darwin:x64": "neutrasearch-darwin-x64",
+    "darwin:arm64": "neutrasearch-darwin-arm64",
+  }[`${platform}:${architecture}`] || null;
+}
+
+export function resolveBundledInstallation(
+  platform = process.platform,
+  architecture = process.arch,
+  packageResolver = (specifier) => require.resolve(specifier),
+) {
+  const packageName = bundledPackageName(platform, architecture);
+  if (!packageName) return null;
+  try {
+    const packageJson = packageResolver(`${packageName}/package.json`);
+    const root = path.dirname(packageJson);
+    const suffix = platform === "win32" ? ".exe" : "";
+    const installation = {
+      packageName,
+      root,
+      query: path.join(root, "bin", `neutrasearch-query${suffix}`),
+      app: path.join(root, "bin", `neutrasearch${suffix}`),
+      helper: path.join(root, "bin", `neutrasearch-helper${suffix}`),
+      mcp: path.join(root, "bin", `neutrasearch-mcp${suffix}`),
+    };
+    return canExecute(installation.query, platform) && canExecute(installation.app, platform)
+      ? installation
+      : null;
+  } catch {
+    return null;
+  }
+}
+
+export function resolveNeutrasearch(
+  env = process.env,
+  platform = process.platform,
+  architecture = process.arch,
+) {
+  const explicit = [
     env.NEUTRASEARCH_QUERY
       ? { command: env.NEUTRASEARCH_QUERY, prefix: [], kind: "query" }
       : null,
-    { command: "neutrasearch-query", prefix: [], kind: "query" },
     env.NEUTRASEARCH_BIN
       ? { command: env.NEUTRASEARCH_BIN, prefix: ["search"], kind: "launcher" }
       : null,
-    { command: "neutrasearch", prefix: ["search"], kind: "launcher" },
   ].filter(Boolean);
+  for (const candidate of explicit) {
+    const resolved = findOnPath(candidate.command, env, platform);
+    if (resolved) return { ...candidate, command: resolved };
+  }
 
-  for (const candidate of candidates) {
+  const bundled = resolveBundledInstallation(platform, architecture);
+  if (bundled) {
+    return {
+      command: bundled.query,
+      prefix: [],
+      kind: "bundled-query",
+      app: bundled.app,
+      packageName: bundled.packageName,
+    };
+  }
+
+  const pathCandidates = [
+    { command: "neutrasearch-query", prefix: [], kind: "query" },
+    { command: "neutrasearch", prefix: ["search"], kind: "launcher" },
+  ];
+  for (const candidate of pathCandidates) {
     const resolved = findOnPath(candidate.command, env, platform);
     if (resolved) return { ...candidate, command: resolved };
   }
   return null;
 }
 
+export function resolveNeutrasearchApp(env = process.env, platform = process.platform) {
+  if (env.NEUTRASEARCH_BIN) {
+    const explicit = findOnPath(env.NEUTRASEARCH_BIN, env, platform);
+    if (explicit) return explicit;
+  }
+  const bundled = resolveBundledInstallation(platform, process.arch);
+  if (bundled) return bundled.app;
+  return findOnPath("neutrasearch", env, platform);
+}
+
 function canonicalDirectory(input) {
   const resolved = fs.realpathSync(path.resolve(input));
   if (!fs.statSync(resolved).isDirectory()) throw new Error(`scope is not a directory: ${input}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-neutrasearch",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Token-efficient native indexed filename and path search for Pi agents",
   "type": "module",
   "license": "MIT",
@@ -32,6 +32,13 @@
   "engines": {
     "node": ">=20"
   },
+  "optionalDependencies": {
+    "neutrasearch-darwin-arm64": "0.1.0",
+    "neutrasearch-darwin-x64": "0.1.0",
+    "neutrasearch-linux-arm64": "0.1.0",
+    "neutrasearch-linux-x64": "0.1.0",
+    "neutrasearch-windows-x64": "0.1.0"
+  },
   "scripts": {
     "test": "node --test",
     "prepublishOnly": "npm test"