@aria-cli/tools 1.0.1 → 1.0.3

package/src/executors/frg.ts

@@ -0,0 +1,394 @@
+import * as fsSync from "node:fs";
+import * as nodePath from "node:path";
+import { frg, type FrgToolInput, type FrgToolOutput } from "@aria-cli/fastripgrep";
+import { getErrorMessage, fail, isPathWithinBase, success } from "./utils.js";
+import type { ToolContext, ToolResult } from "../types.js";
+import { executeSpawn } from "./shell.js";
+import {
+  clearPendingFrgMutations,
+  ensureFrgRepoStateLoaded,
+  flushPendingFrgMutations,
+  getFrgFreshnessSnapshot,
+  getPendingFrgMutations,
+  maybeBuildFrgIndexForRepo,
+  reconcileGitDirtyMutations,
+  scheduleBackgroundFrgFlush,
+  shouldForceSynchronousFrgFlush,
+} from "./frg-freshness.js";
+
+function resolveSearchRoot(inputPath: string | undefined, ctx: ToolContext): string {
+  const requested = inputPath ?? ".";
+  return nodePath.isAbsolute(requested)
+    ? nodePath.resolve(requested)
+    : nodePath.resolve(ctx.workingDir, requested);
+}
+
+function assertAllowedPath(resolvedPath: string, ctx: ToolContext): void {
+  let realBase = nodePath.resolve(ctx.workingDir);
+  try {
+    realBase = fsSync.realpathSync(ctx.workingDir);
+  } catch {
+    // ignore
+  }
+
+  let candidate = resolvedPath;
+  try {
+    candidate = fsSync.realpathSync(resolvedPath);
+  } catch {
+    candidate = nodePath.resolve(resolvedPath);
+  }
+
+  if (isPathWithinBase(candidate, realBase)) {
+    return;
+  }
+
+  const home = process.env.HOME;
+  if (home) {
+    try {
+      const realHome = fsSync.realpathSync(home);
+      if (isPathWithinBase(candidate, realHome)) {
+        return;
+      }
+    } catch {
+      // ignore
+    }
+  }
+
+  throw new Error(
+    "Path traversal not allowed: resolved path is outside working directory and home directory",
+  );
+}
+
+export interface FrgInput {
+  command:
+    | "index"
+    | "search"
+    | "update"
+    | "status"
+    | "replace"
+    | "init"
+    | "watch"
+    | "man"
+    | "completions"
+    | "upgrade";
+  pattern?: string;
+  replacement?: string;
+  path?: string;
+  noIndex?: boolean;
+  literal?: boolean;
+  caseInsensitive?: boolean;
+  smartCase?: boolean;
+  filesOnly?: boolean;
+  count?: boolean;
+  maxCount?: number;
+  quiet?: boolean;
+  context?: number;
+  json?: boolean;
+  glob?: string;
+  fileType?: string;
+  follow?: boolean;
+  extraPatterns?: string[];
+  maxFilesize?: number;
+  force?: boolean;
+  write?: boolean;
+  hook?: boolean;
+  shell?: "bash" | "elvish" | "fish" | "powershell" | "zsh";
+}
+
+function toNativeInput(input: FrgInput, root: string): FrgToolInput {
+  return {
+    command: input.command,
+    pattern: input.pattern,
+    replacement: input.replacement,
+    path: root,
+    noIndex: input.noIndex,
+    literal: input.literal,
+    caseInsensitive: input.caseInsensitive,
+    smartCase: input.smartCase,
+    filesOnly: input.filesOnly,
+    count: input.count,
+    maxCount: input.maxCount,
+    quiet: input.quiet,
+    context: input.context,
+    json: input.json,
+    glob: input.glob,
+    fileType: input.fileType,
+    follow: input.follow,
+    extraPatterns: input.extraPatterns,
+    maxFilesize: input.maxFilesize,
+    force: input.force,
+    write: input.write,
+    hook: input.hook,
+    shell: input.shell,
+  };
+}
+
+function getNativeSessionOverlay(root: string): {
+  sessionWrites: Array<{ path: string; content: string }>;
+  sessionDeletes: string[];
+} {
+  const sessionWrites: Array<{ path: string; content: string }> = [];
+  const sessionDeletes: string[] = [];
+  for (const mutation of getPendingFrgMutations(root)) {
+    if (mutation.operation === "delete") {
+      sessionDeletes.push(nodePath.resolve(mutation.path));
+      continue;
+    }
+    // Read content from disk if not cached. This closes the gap where
+    // reconcileGitDirtyMutations detects git-dirty files but sets
+    // content=undefined (no cache). Without this read, the session overlay
+    // would skip these mutations entirely — making agent-written files
+    // invisible until the 750ms background flush completes.
+    let content = mutation.content;
+    if (typeof content !== "string") {
+      try {
+        const resolved = nodePath.resolve(mutation.path);
+        const buf = fsSync.readFileSync(resolved);
+        // Skip binary files
+        if (!buf.subarray(0, Math.min(buf.length, 8192)).includes(0)) {
+          content = buf.toString("utf8");
+        }
+      } catch {
+        // File unreadable (deleted, permission, etc.) — skip
+      }
+    }
+    if (typeof content === "string") {
+      sessionWrites.push({
+        path: nodePath.resolve(mutation.path),
+        content,
+      });
+    }
+  }
+  return { sessionWrites, sessionDeletes };
+}
+
+async function executeFrgWatch(
+  _input: FrgInput,
+  ctx: ToolContext,
+  root: string,
+): Promise<ToolResult> {
+  const resolvedWorkingDir = nodePath.resolve(ctx.workingDir);
+  const repoRoot = resolvedWorkingDir.includes(`${nodePath.sep}packages${nodePath.sep}`)
+    ? (resolvedWorkingDir.split(`${nodePath.sep}packages${nodePath.sep}`)[0] ?? process.cwd())
+    : process.cwd();
+  const binaryPath = nodePath.join(
+    repoRoot,
+    "vendor",
+    "fastripgrep",
+    "target",
+    "release",
+    process.platform === "win32" ? "frg.exe" : "frg",
+  );
+
+  if (!fsSync.existsSync(binaryPath)) {
+    return fail(
+      `frg watch failed: binary not found at ${binaryPath}. Build @aria-cli/fastripgrep first.`,
+    );
+  }
+
+  const spawnResult = await executeSpawn(
+    {
+      program: binaryPath,
+      args: ["watch", root],
+      cwd: root,
+    },
+    ctx,
+  );
+
+  if (!spawnResult.success) {
+    return spawnResult;
+  }
+
+  const data = (spawnResult.data ?? {}) as { pid?: number };
+  return success(`Started frg watch process for ${root}`, {
+    command: "watch",
+    path: root,
+    watched: true,
+    pid: data.pid,
+  });
+}
+
+function maybeReindexOnHeadChange(root: string, currentOutput: FrgToolOutput): FrgToolOutput {
+  if (currentOutput.command !== "status") {
+    return currentOutput;
+  }
+
+  try {
+    const indexedTree = currentOutput.status?.tree_hash ?? null;
+    const indexedHead = currentOutput.status?.commit_hash ?? null;
+    const freshness = getFrgFreshnessSnapshot(root, currentOutput.status);
+
+    if (freshness.headTree && indexedTree && freshness.headTree !== indexedTree) {
+      if (
+        freshness.sessionPendingCount === 0 &&
+        freshness.dirtyTrackedCount === 0 &&
+        freshness.dirtyUntrackedCount === 0
+      ) {
+        const updated = frg({ command: "update", path: root });
+        return {
+          ...updated,
+          content: `HEAD tree changed from indexed ${indexedTree} to ${freshness.headTree}; triggered incremental update`,
+        };
+      }
+
+      return {
+        ...currentOutput,
+        content: `HEAD tree differs from indexed tree (${indexedTree} -> ${freshness.headTree}); local dirty state deferred update`,
+      };
+    }
+
+    if (indexedHead && freshness.headCommit && indexedHead !== freshness.headCommit) {
+      return {
+        ...currentOutput,
+        content: `HEAD commit differs from indexed commit (${indexedHead} -> ${freshness.headCommit})`,
+      };
+    }
+  } catch {
+    // ignore and keep status output stable
+  }
+
+  return currentOutput;
+}
+
+function enrichStatusOutput(root: string, output: FrgToolOutput): FrgToolOutput {
+  if (output.command !== "status") {
+    return output;
+  }
+
+  const freshness = getFrgFreshnessSnapshot(root, output.status);
+  return {
+    ...output,
+    status: output.status
+      ? {
+          ...output.status,
+          head_commit: freshness.headCommit,
+          head_tree: freshness.headTree,
+          tree_match:
+            freshness.headTree && output.status.tree_hash
+              ? freshness.headTree === output.status.tree_hash
+              : undefined,
+          dirty_tracked_count: freshness.dirtyTrackedCount,
+          dirty_untracked_count: freshness.dirtyUntrackedCount,
+          session_pending_count: freshness.sessionPendingCount,
+          session_pending_bytes: freshness.sessionPendingBytes,
+          background_flush_scheduled: freshness.flush.scheduled,
+          flush_in_flight: freshness.flush.inFlight,
+          last_flush_at: freshness.flush.lastFlushAt,
+          last_flush_error: freshness.flush.lastError,
+          freshness_state: freshness.freshnessState,
+        }
+      : output.status,
+  };
+}
+
+function messageFor(output: FrgToolOutput, input: FrgInput): string {
+  if (output.command === "search") {
+    if (output.mode === "quiet") {
+      return output.matched
+        ? `Match found for ${input.pattern}`
+        : `No matches found for ${input.pattern}`;
+    }
+    if (output.mode === "files") {
+      return `Found ${(output.files ?? []).length} files for ${input.pattern}`;
+    }
+    if (output.mode === "counts") {
+      return `Counted matches in ${(output.counts ?? []).length} files for ${input.pattern}`;
+    }
+    return `Found ${(output.matches ?? []).length} matches for ${input.pattern}`;
+  }
+  if (output.command === "replace") {
+    return input.write
+      ? `Applied ${output.replacements ?? 0} replacements in ${output.files_changed ?? 0} files`
+      : `Previewed ${output.replacements ?? 0} replacements in ${output.files_changed ?? 0} files`;
+  }
+  if (output.command === "init") {
+    return output.hook_installed
+      ? `Initialized frg for ${output.path} and installed git hook`
+      : `Initialized frg for ${output.path}`;
+  }
+  if (output.command === "completions") {
+    return `Generated ${output.shell ?? input.shell ?? "shell"} completions for frg`;
+  }
+  if (output.command === "man") {
+    return "Generated frg man page content";
+  }
+  if (output.command === "upgrade") {
+    return output.content ?? "Provided frg upgrade metadata";
+  }
+  return `frg ${output.command} completed for ${output.path}`;
+}
+
+export async function executeFrg(input: unknown, ctx: ToolContext): Promise<ToolResult> {
+  try {
+    const args = input as FrgInput;
+    const root = resolveSearchRoot(args.path, ctx);
+    assertAllowedPath(root, ctx);
+
+    if (args.command === "watch") {
+      return executeFrgWatch(args, ctx, root);
+    }
+
+    ensureFrgRepoStateLoaded(root);
+    reconcileGitDirtyMutations(root);
+
+    if (args.command === "search") {
+      maybeBuildFrgIndexForRepo(root);
+
+      // Detect HEAD tree change (e.g., after a commit or branch switch).
+      // Without this, the index stays on the old tree until `frg status` is
+      // explicitly called. This is the same gap that aria-search had —
+      // the index was "ready" because .frg/ exists, but stale because
+      // the tree changed. Run incremental update to pick up the new tree.
+      try {
+        const statusOutput = frg({ command: "status", path: root });
+        if (statusOutput.status?.tree_hash && statusOutput.status?.commit_hash) {
+          const snapshot = getFrgFreshnessSnapshot(root, statusOutput.status);
+          if (
+            snapshot.headTree &&
+            statusOutput.status.tree_hash !== snapshot.headTree &&
+            snapshot.sessionPendingCount === 0 &&
+            snapshot.dirtyTrackedCount === 0 &&
+            snapshot.dirtyUntrackedCount === 0
+          ) {
+            // Clean working tree but HEAD moved — incremental update
+            frg({ command: "update", path: root });
+            clearPendingFrgMutations(root);
+          }
+        }
+      } catch {
+        // Best effort — search will still work with session overlay
+      }
+
+      const pending = getPendingFrgMutations(root);
+      if (pending.length > 0) {
+        if (!args.noIndex) {
+          if (shouldForceSynchronousFrgFlush(root)) {
+            flushPendingFrgMutations(root);
+          } else {
+            scheduleBackgroundFrgFlush(root);
+          }
+        }
+      }
+    }
+
+    const nativeInput = toNativeInput(args, root);
+    if (args.command === "search") {
+      const sessionOverlay = getNativeSessionOverlay(root);
+      nativeInput.sessionWrites = sessionOverlay.sessionWrites;
+      nativeInput.sessionDeletes = sessionOverlay.sessionDeletes;
+    }
+
+    let output = frg(nativeInput);
+    if (args.command === "status") {
+      output = maybeReindexOnHeadChange(root, output);
+      output = enrichStatusOutput(root, output);
+      if (output.content?.includes("triggered incremental update")) {
+        clearPendingFrgMutations(root);
+      }
+    }
+
+    return success(messageFor(output, args), output);
+  } catch (error) {
+    return fail(`frg failed: ${getErrorMessage(error)}`);
+  }
+}

package/src/executors/index.ts

@@ -29,6 +29,39 @@ export type {
   GrepMatch,
 } from "./filesystem.js";
 
+// fastripgrep executors
+export { executeFrg } from "./frg.js";
+export {
+  recordFrgMutation,
+  getPendingFrgMutations,
+  getPendingFrgMutationBytes,
+  clearPendingFrgMutations,
+  flushPendingFrgMutations,
+  maybeBuildFrgIndexForRepo,
+  ensureFrgRepoStateLoaded,
+  reconcileGitDirtyMutations,
+  getGitDirtyStatus,
+  getFrgFlushStatus,
+  getFrgFreshnessSnapshot,
+  scheduleBackgroundFrgFlush,
+  shouldForceSynchronousFrgFlush,
+  DEFAULT_BACKGROUND_FRG_FLUSH_DELAY_MS,
+  BACKGROUND_FRG_MAX_FLUSH_DELAY_MS,
+  MAX_PENDING_MUTATIONS_BEFORE_SYNC_FLUSH,
+  MAX_PENDING_MUTATION_BYTES_BEFORE_SYNC_FLUSH,
+  MAX_CACHED_MUTATION_CONTENT_BYTES,
+} from "./frg-freshness.js";
+
+// fastripgrep executor types
+export type { FrgInput } from "./frg.js";
+export type {
+  FrgMutationOperation,
+  FrgMutationRecord,
+  FrgGitDirtyStatus,
+  FrgFlushStatus,
+  FrgFreshnessSnapshot,
+} from "./frg-freshness.js";
+
 // Apply Patch executor
 export { executeApplyPatch } from "./apply-patch.js";
 
@@ -218,5 +251,30 @@ export type { RestartInput } from "./restart.js";
 export { executeDeploy } from "./deploy.js";
 export type { DeployInput, DeployOutput } from "./deploy.js";
 
+// Code Intelligence executors
+export {
+  executeRg,
+  executeUg,
+  executeProbe,
+  executeSg,
+  executeCbm,
+  executeLsp,
+  executeSerena,
+  executeFff,
+} from "./code-intelligence.js";
+
+// Code Intelligence executor types
+export type {
+  RgInput,
+  UgInput,
+  ProbeInput,
+  SgInput,
+  CbmInput,
+  LspInput,
+  SerenaInput,
+  FffInput,
+  RgMatch,
+} from "./code-intelligence.js";
+
 // Shared executor utilities
 export { success, fail, getErrorMessage } from "./utils.js";