@aria-cli/tools 1.0.9 → 1.0.10

package/src/executors/search-freshness.ts

@@ -1,249 +0,0 @@
-/**
- * Freshness tracker for aria-search (code_search tool).
- *
- * Mirrors frg-freshness.ts patterns to close the freshness gaps:
- * 1. Tracks file mutations from ARIA tool writes (session overlay)
- * 2. Reconciles git-dirty files on each search
- * 3. Generates session overlay for the napi search() call
- *
- * The session overlay gives 0ms visibility for pending mutations —
- * files written by agents/users appear in search results immediately
- * without waiting for an index rebuild or hot.log sync.
- */
-
-import * as fsSync from "node:fs";
-import * as nodePath from "node:path";
-import { execFileSync } from "node:child_process";
-
-export type SearchMutationOperation = "write" | "delete";
-
-export interface SearchMutationRecord {
-  path: string;
-  operation: SearchMutationOperation;
-  content?: string;
-  sequence: number;
-}
-
-export interface SearchSessionOverlay {
-  sessionWrites: Array<{ path: string; content: string }>;
-  sessionDeletes: string[];
-}
-
-// ---------------------------------------------------------------------------
-// In-memory state (per repo root)
-// ---------------------------------------------------------------------------
-
-interface RepoState {
-  sequence: number;
-  pending: Map<string, SearchMutationRecord>;
-  lastGitReconcileMs: number;
-}
-
-const repoStates = new Map<string, RepoState>();
-
-/** Minimum interval between git-dirty reconciliations (avoid hammering git). */
-const GIT_RECONCILE_INTERVAL_MS = 2_000;
-
-/** Max content size to cache in memory per file. */
-const MAX_CACHED_CONTENT_BYTES = 256 * 1024;
-
-function norm(p: string): string {
-  return nodePath.resolve(p);
-}
-
-function getState(root: string): RepoState {
-  const key = norm(root);
-  let state = repoStates.get(key);
-  if (!state) {
-    state = { sequence: 0, pending: new Map(), lastGitReconcileMs: 0 };
-    repoStates.set(key, state);
-  }
-  return state;
-}
-
-// ---------------------------------------------------------------------------
-// Public API — called from filesystem/patch executors
-// ---------------------------------------------------------------------------
-
-/**
- * Record a file mutation from an ARIA tool write/edit/delete.
- * Called alongside recordFrgMutation in filesystem.ts and apply-patch.ts.
- */
-export function recordSearchMutation(
-  filePath: string,
-  operation: SearchMutationOperation,
-  content?: string,
-): void {
-  // Find the git repo root to scope mutations correctly
-  const repoRoot = findGitRepoRoot(filePath);
-  if (!repoRoot) return;
-
-  const state = getState(repoRoot);
-  state.sequence += 1;
-  const normalizedPath = norm(filePath);
-
-  state.pending.set(normalizedPath, {
-    path: normalizedPath,
-    operation,
-    content:
-      typeof content === "string" && Buffer.byteLength(content, "utf8") <= MAX_CACHED_CONTENT_BYTES
-        ? content
-        : undefined,
-    sequence: state.sequence,
-  });
-}
-
-// ---------------------------------------------------------------------------
-// Public API — called from search executor
-// ---------------------------------------------------------------------------
-
-/**
- * Reconcile git-dirty files into the pending mutations map.
- * Runs `git diff --name-status -z HEAD` and `git ls-files -o --exclude-standard -z`
- * to detect files modified/created/deleted by external agents or the user.
- *
- * Throttled to at most once per GIT_RECONCILE_INTERVAL_MS to avoid
- * hammering git on rapid sequential searches.
- */
-export function reconcileSearchGitDirty(root: string): void {
-  const state = getState(root);
-  const now = Date.now();
-  if (now - state.lastGitReconcileMs < GIT_RECONCILE_INTERVAL_MS) {
-    return; // Throttled — recent reconciliation is still fresh enough
-  }
-  state.lastGitReconcileMs = now;
-
-  const normalizedRoot = norm(root);
-
-  // Tracked modified/deleted files
-  const trackedOutput = runGit(normalizedRoot, ["diff", "--name-status", "-z", "HEAD", "--"]);
-  if (trackedOutput) {
-    const tokens = trackedOutput.split("\0").filter(Boolean);
-    for (let i = 0; i < tokens.length; i++) {
-      const status = tokens[i] ?? "";
-      if (status.startsWith("R")) {
-        // Rename: old path deleted, new path written
-        const oldPath = tokens[++i];
-        const newPath = tokens[++i];
-        if (oldPath) addGitDirtyMutation(state, normalizedRoot, oldPath, "delete");
-        if (newPath) addGitDirtyMutation(state, normalizedRoot, newPath, "write");
-        continue;
-      }
-      const filePath = tokens[++i];
-      if (!filePath) continue;
-      addGitDirtyMutation(
-        state,
-        normalizedRoot,
-        filePath,
-        status.startsWith("D") ? "delete" : "write",
-      );
-    }
-  }
-
-  // Untracked new files
-  const untrackedOutput = runGit(normalizedRoot, ["ls-files", "-o", "--exclude-standard", "-z"]);
-  if (untrackedOutput) {
-    for (const token of untrackedOutput.split("\0").filter(Boolean)) {
-      addGitDirtyMutation(state, normalizedRoot, token, "write");
-    }
-  }
-}
-
-function addGitDirtyMutation(
-  state: RepoState,
-  root: string,
-  relativePath: string,
-  operation: SearchMutationOperation,
-): void {
-  const absPath = norm(nodePath.join(root, relativePath));
-  const existing = state.pending.get(absPath);
-  // Don't overwrite ARIA-sourced mutations (which have cached content)
-  if (existing?.content) return;
-  if (existing?.operation === operation) return;
-
-  state.sequence += 1;
-  state.pending.set(absPath, {
-    path: absPath,
-    operation,
-    content: undefined, // Will be read from disk in getSearchSessionOverlay
-    sequence: state.sequence,
-  });
-}
-
-/**
- * Generate the session overlay for the napi search() call.
- * Reads content from disk for mutations without cached content.
- */
-export function getSearchSessionOverlay(root: string): SearchSessionOverlay {
-  const state = getState(root);
-  const sessionWrites: Array<{ path: string; content: string }> = [];
-  const sessionDeletes: string[] = [];
-
-  for (const mutation of state.pending.values()) {
-    if (mutation.operation === "delete") {
-      sessionDeletes.push(mutation.path);
-      continue;
-    }
-
-    let content = mutation.content;
-    if (typeof content !== "string") {
-      // Read from disk — closes the gap where git-dirty files have no cached content
-      try {
-        const buf = fsSync.readFileSync(mutation.path);
-        if (!buf.subarray(0, Math.min(buf.length, 8192)).includes(0)) {
-          content = buf.toString("utf8");
-        }
-      } catch {
-        continue; // Unreadable — skip
-      }
-    }
-
-    if (typeof content === "string") {
-      sessionWrites.push({ path: mutation.path, content });
-    }
-  }
-
-  return { sessionWrites, sessionDeletes };
-}
-
-/**
- * Clear all pending mutations for a repo root.
- * Called after a full index rebuild (all mutations are now in the base index).
- */
-export function clearSearchMutations(root: string): void {
-  const key = norm(root);
-  repoStates.delete(key);
-}
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-function findGitRepoRoot(startPath: string): string | null {
-  let current = norm(startPath);
-  try {
-    if (!fsSync.statSync(current).isDirectory()) {
-      current = nodePath.dirname(current);
-    }
-  } catch {
-    current = nodePath.dirname(current);
-  }
-  while (true) {
-    if (fsSync.existsSync(nodePath.join(current, ".git"))) return current;
-    const parent = nodePath.dirname(current);
-    if (parent === current) return null;
-    current = parent;
-  }
-}
-
-function runGit(cwd: string, args: string[]): string | null {
-  try {
-    return execFileSync("git", args, {
-      cwd,
-      encoding: "utf8",
-      stdio: ["ignore", "pipe", "ignore"],
-    }).trim();
-  } catch {
-    return null;
-  }
-}

package/src/executors/search-types.ts

@@ -1,98 +0,0 @@
-/**
- * Shared types and utilities for the unified search tool.
- *
- * Used by:
- * - Base executor in @aria/tools (learning-meta.ts)
- * - Runner wrapper in @aria/aria (search-wrapper.ts)
- * - Tests
- */
-
-/** Tagged search result — every result carries runnability info. */
-export interface SearchResult {
-  kind: "tool" | "skill" | "memory";
-  name: string;
-  description: string;
-  source:
-    | "memoria"
-    | "local"
-    | "local_cli"
-    | "builtin"
-    | "skills.sh"
-    | "clawhub"
-    | "npm"
-    | "brew"
-    | "web";
-  runnable: boolean;
-  action: "call" | "bash" | "read_skill" | "install" | "recall";
-  id?: string;
-  path?: string;
-  url?: string;
-  installCmd?: string;
-  installs?: number;
-  version?: string;
-  usageHint?: string;
-  /** Schema for injection (builtin source only, consumed by runner wrapper). */
-  _schema?: { name: string; description: string; parameters?: unknown };
-}
-
-/** OS context for platform-aware search and result metadata. */
-export interface OSContext {
-  os: "macos" | "linux" | "windows";
-  arch: string;
-  distro?: string;
-}
-
-/** Input for the unified search tool. */
-export interface SearchInput {
-  query: string;
-  sources?: Array<"memoria" | "local" | "local_cli" | "builtin" | "registry" | "web">;
-  limit?: number;
-  learn?: boolean;
-  adopt?: boolean;
-  rebuild_index?: boolean;
-}
-
-// ---------------------------------------------------------------------------
-// Shared dedup logic — single source of truth for both base executor and wrapper
-// ---------------------------------------------------------------------------
-
-/** Source priority for dedup (lower = higher priority). */
-export const SOURCE_PRIORITY: Record<SearchResult["source"], number> = {
-  builtin: 0,
-  local_cli: 1,
-  memoria: 2,
-  local: 3,
-  "skills.sh": 4,
-  clawhub: 5,
-  npm: 6,
-  brew: 7,
-  web: 8,
-};
-
-/**
- * Dedup search results by name with source priority.
- * When the same name appears from multiple sources, keep the higher-priority one.
- */
-export function dedupSearchResults(results: SearchResult[], limit: number): SearchResult[] {
-  const deduped = new Map<string, SearchResult>();
-  for (const item of results) {
-    const normalizedName = item.name.trim().toLowerCase();
-    const existing = deduped.get(normalizedName);
-    if (!existing) {
-      deduped.set(normalizedName, item);
-    } else {
-      const existingPriority = SOURCE_PRIORITY[existing.source] ?? 99;
-      const newPriority = SOURCE_PRIORITY[item.source] ?? 99;
-      if (newPriority < existingPriority) {
-        deduped.set(normalizedName, item);
-      }
-    }
-  }
-  const sorted = [...deduped.values()].sort((a, b) => {
-    const aPriority = SOURCE_PRIORITY[a.source] ?? 99;
-    const bPriority = SOURCE_PRIORITY[b.source] ?? 99;
-    if (aPriority !== bPriority) return aPriority - bPriority;
-    return a.name.localeCompare(b.name);
-  });
-  return sorted.slice(0, limit);
-}

package/src/executors/search.ts

@@ -1,89 +0,0 @@
-/**
- * Executor for the native indexed regex search tool.
- *
- * Freshness architecture (frg parity):
- * 1. ARIA tool writes → recordSearchMutation → session overlay (0ms visibility)
- * 2. External edits → reconcileSearchGitDirty → session overlay (0ms visibility)
- * 3. Commit/version change → syncIndex or buildIndex (incremental/full)
- * 4. Session overlay passed to napi search() — no index rebuild needed
- */
-
-import * as nodePath from "node:path";
-import { buildIndex, syncIndex, indexStatus, search } from "@aria-cli/search";
-import { success, fail } from "./utils.js";
-import type { ToolContext, ToolResult } from "../types.js";
-import {
-  reconcileSearchGitDirty,
-  getSearchSessionOverlay,
-  clearSearchMutations,
-} from "./search-freshness.js";
-
-interface SearchInput {
-  pattern: string;
-  directory?: string;
-  fileGlob?: string;
-  fileType?: string;
-  caseSensitive?: boolean;
-  literal?: boolean;
-  maxResults?: number;
-  context?: number;
-}
-
-export async function executeSearch(input: unknown, ctx: ToolContext): Promise<ToolResult> {
-  const opts = input as SearchInput;
-  const dir = nodePath.resolve(ctx.workingDir, opts.directory || ".");
-
-  try {
-    // Step 1: Index management — build or sync base index if needed.
-    const status = indexStatus(dir);
-    if (status.state === "none") {
-      buildIndex(dir);
-      clearSearchMutations(dir); // fresh index includes everything
-    } else if (status.state === "stale") {
-      // Commit or binary version changed — incremental sync is sufficient
-      // (syncIndex rebuilds hot.log from git diff, much cheaper than full build).
-      // Only fall back to full build if sync fails.
-      try {
-        syncIndex(dir);
-      } catch {
-        buildIndex(dir);
-      }
-      clearSearchMutations(dir);
-    }
-    // "ready" — base index is fresh, session overlay handles uncommitted changes
-
-    // Step 2: Reconcile git-dirty files into pending mutations.
-    // Detects files modified/created/deleted by external agents or the user.
-    // Throttled to avoid hammering git on rapid sequential searches.
-    reconcileSearchGitDirty(dir);
-
-    // Step 3: Generate session overlay from pending mutations.
-    // This gives 0ms visibility for ARIA tool writes and external edits —
-    // no index rebuild needed. The overlay is applied in-memory by the
-    // Rust search engine on top of the base index + hot.log.
-    const overlay = getSearchSessionOverlay(dir);
-
-    // Step 4: Search with overlay.
-    const results = search({
-      pattern: opts.pattern,
-      directory: dir,
-      maxResults: opts.maxResults ?? 1000,
-      fileGlob: opts.fileGlob,
-      fileType: opts.fileType,
-      caseSensitive: opts.caseSensitive ?? true,
-      literal: opts.literal ?? false,
-      context: opts.context ?? 0,
-      sessionWrites: overlay.sessionWrites,
-      sessionDeletes: overlay.sessionDeletes,
-    });
-
-    const truncated = results.length >= (opts.maxResults ?? 1000);
-    return success(
-      `Found ${results.length} matches for "${opts.pattern}"${truncated ? " (truncated)" : ""}`,
-      { matches: results, truncated },
-    );
-  } catch (err) {
-    const reason = err instanceof Error ? err.message : String(err);
-    return fail(`Search failed: ${reason}`);
-  }
-}