@aria-cli/tools 1.0.12 → 1.0.14

package/dist/executors/frg.js

@@ -1,298 +0,0 @@
-import * as fsSync from "node:fs";
-import * as nodePath from "node:path";
-import { frg } from "@aria-cli/fastripgrep";
-import { getErrorMessage, fail, isPathWithinBase, success } from "./utils.js";
-import { executeSpawn } from "./shell.js";
-import { clearPendingFrgMutations, ensureFrgRepoStateLoaded, flushPendingFrgMutations, getFrgFreshnessSnapshot, getPendingFrgMutations, maybeBuildFrgIndexForRepo, reconcileGitDirtyMutations, scheduleBackgroundFrgFlush, shouldForceSynchronousFrgFlush, } from "./frg-freshness.js";
-function resolveSearchRoot(inputPath, ctx) {
-    const requested = inputPath ?? ".";
-    return nodePath.isAbsolute(requested)
-        ? nodePath.resolve(requested)
-        : nodePath.resolve(ctx.workingDir, requested);
-}
-function assertAllowedPath(resolvedPath, ctx) {
-    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");
-}
-function toNativeInput(input, root) {
-    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) {
-    const sessionWrites = [];
-    const sessionDeletes = [];
-    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, ctx, root) {
-    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 ?? {});
-    return success(`Started frg watch process for ${root}`, {
-        command: "watch",
-        path: root,
-        watched: true,
-        pid: data.pid,
-    });
-}
-function maybeReindexOnHeadChange(root, currentOutput) {
-    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, output) {
-    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, input) {
-    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, ctx) {
-    try {
-        const args = input;
-        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/dist/executors/index.js

@@ -1,46 +0,0 @@
-/**
- * @aria/tools - Tool executors
- *
- * Executor functions that implement actual tool functionality.
- */
-// Filesystem executors
-export { executeReadFile, executeWriteFile, executeEditFile, executeLs, executeGlob, executeGrep, } 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";
-// Apply Patch executor
-export { executeApplyPatch } from "./apply-patch.js";
-// Shell executors
-export { executeBash, executeExec, executeSpawn, executeKill, executeListProcesses, executeWaitProcess, executeWriteStdin, sanitizeGitEnv, sanitizeEnv, } from "./shell.js";
-export { classifyCommand, BLOCKED_PATTERNS as SHELL_BLOCKED_PATTERNS } from "./shell-safety.js";
-// Memory executors
-export { executeRemember, executeRecall, executeForget, executeDiscover, executeReflect, getConversationContext, getSessionTranscript, getSelfContext, } from "./memory.js";
-// Web executors
-export { executeWebSearch, executeWebFetch, executeBrowse } from "./web.js";
-// PTY executors
-export { PTYSession, PTYTimeoutError, PTYError, createPTYSession, runInPTY } from "./pty.js";
-// PTY session store
-export { PTYSessionStore } from "./pty-session-store.js";
-// Arion executors
-export { executeHatchArion, executeRestArion, executeWakeArion, executeRetireArion, } from "./arion.js";
-// Process registry
-export { SpawnedProcessRegistry } from "./process-registry.js";
-// Meta executors
-export { executeAskUser, executeQuestUpdate, executeQuestList, resetAskUserCounter, } from "./meta.js";
-// Learning/meta capability executors
-export { executeSearchKnowledge, executeLearnTool, executeLearnSkill, executeLearnLegacy, executeCreateTool, executeCreateSkill, executeUseSkill, 
-// Search source helpers — used by runner wrapper (search-wrapper.ts)
-searchMemoria, searchLocalSkills, searchSkillRegistries, searchWeb, getOSContext, settleWithDeadline, fetchJson, } from "./learning-meta.js";
-export { SOURCE_PRIORITY, dedupSearchResults } from "./search-types.js";
-// Session History executors
-export { executeSessionHistory } from "./session-history.js";
-// Self-diagnose executor
-export { executeSelfDiagnose } from "./self-diagnose.js";
-// Restart executor
-export { executeRestart } from "./restart.js";
-// Deploy executor
-export { executeDeploy } from "./deploy.js";
-// Code Intelligence executors
-export { executeRg, executeUg, executeProbe, executeSg, executeCbm, executeLsp, executeSerena, executeFff, } from "./code-intelligence.js";
-// Shared executor utilities
-export { success, fail, getErrorMessage } from "./utils.js";