@aria-cli/tools 1.0.19 → 1.0.31

package/dist/executors/pty-session-store.js

@@ -0,0 +1,31 @@
+export class PTYSessionStore {
+    sessions = new Map();
+    add(pid, session) {
+        this.sessions.set(pid, session);
+    }
+    get(pid) {
+        return this.sessions.get(pid);
+    }
+    has(pid) {
+        return this.sessions.has(pid);
+    }
+    remove(pid) {
+        this.sessions.delete(pid);
+    }
+    async closeAll() {
+        const sessions = Array.from(this.sessions.values());
+        this.sessions.clear();
+        await Promise.allSettled(sessions.map((s) => {
+            try {
+                return Promise.resolve(s.close());
+            }
+            catch {
+                return Promise.resolve();
+            }
+        }));
+    }
+    get size() {
+        return this.sessions.size;
+    }
+}
+//# sourceMappingURL=pty-session-store.js.map

package/dist/executors/pty.js

@@ -0,0 +1,281 @@
+/**
+ * @aria/tools - PTY executor for interactive terminal programs
+ *
+ * Provides PTY (pseudo-terminal) support for running interactive programs
+ * that require a terminal environment (like vim, less, etc.)
+ */
+function loadNodePty() {
+    try {
+        return require("node-pty"); // eslint-disable-line
+    }
+    catch {
+        throw new Error("Interactive PTY sessions require node-pty (optional dependency).\n" +
+            "Install it with: npm install node-pty\n" +
+            "Or use non-interactive mode: spawn(interactive=false)");
+    }
+}
+import { sanitizeEnv } from "./shell.js";
+/**
+ * Error thrown when a PTY operation times out.
+ */
+export class PTYTimeoutError extends Error {
+    output;
+    constructor(message, output) {
+        super(message);
+        this.output = output;
+        this.name = "PTYTimeoutError";
+    }
+}
+/**
+ * Error thrown when a PTY operation fails.
+ */
+export class PTYError extends Error {
+    output;
+    constructor(message, output) {
+        super(message);
+        this.output = output;
+        this.name = "PTYError";
+    }
+}
+/**
+ * A session wrapping a PTY process.
+ * Provides methods for interacting with the process and collecting output.
+ */
+export class PTYSession {
+    static MAX_OUTPUT = 10 * 1024 * 1024; // 10MB
+    _output = "";
+    _isRunning = true;
+    _exitCode;
+    _exitPromise;
+    _exitResolve;
+    _pty;
+    _dataDisposable;
+    _exitDisposable;
+    constructor(pty) {
+        this._pty = pty;
+        // Set up exit promise
+        this._exitPromise = new Promise((resolve) => {
+            this._exitResolve = resolve;
+        });
+        // Collect output with buffer cap
+        this._dataDisposable = pty.onData((data) => {
+            this._output += data;
+            if (this._output.length > PTYSession.MAX_OUTPUT) {
+                this._output = this._output.slice(-PTYSession.MAX_OUTPUT);
+            }
+        });
+        // Handle exit
+        this._exitDisposable = pty.onExit(({ exitCode }) => {
+            this._isRunning = false;
+            this._exitCode = exitCode;
+            this._exitResolve(exitCode);
+        });
+    }
+    /**
+     * Write data to the terminal input.
+     */
+    write(data) {
+        if (!this._isRunning) {
+            throw new PTYError("Cannot write to a closed PTY session");
+        }
+        this._pty.write(data);
+    }
+    /**
+     * Resize the terminal.
+     */
+    resize(cols, rows) {
+        if (!this._isRunning) {
+            throw new PTYError("Cannot resize a closed PTY session");
+        }
+        this._pty.resize(cols, rows);
+    }
+    /**
+     * Wait for a pattern to appear in the output.
+     * @param pattern String or RegExp to match
+     * @param timeoutMs Timeout in milliseconds (default: 5000)
+     * @returns The output accumulated up to and including the match
+     */
+    async waitFor(pattern, timeoutMs = 5000) {
+        const startTime = Date.now();
+        const regex = typeof pattern === "string" ? new RegExp(escapeRegExp(pattern)) : pattern;
+        // Check if pattern already matches
+        if (regex.test(this._output)) {
+            return this._output;
+        }
+        return new Promise((resolve, reject) => {
+            let checkInterval;
+            let timeoutHandle;
+            const cleanup = () => {
+                if (checkInterval)
+                    clearInterval(checkInterval);
+                if (timeoutHandle)
+                    clearTimeout(timeoutHandle);
+            };
+            const check = () => {
+                if (regex.test(this._output)) {
+                    cleanup();
+                    resolve(this._output);
+                    return true;
+                }
+                if (!this._isRunning) {
+                    cleanup();
+                    reject(new PTYError(`Process exited before pattern was found: ${pattern}`, this._output));
+                    return true;
+                }
+                return false;
+            };
+            // Initial check
+            if (check())
+                return;
+            // Set up polling
+            checkInterval = setInterval(() => {
+                check();
+            }, 10);
+            // Set up timeout
+            timeoutHandle = setTimeout(() => {
+                cleanup();
+                const elapsed = Date.now() - startTime;
+                reject(new PTYTimeoutError(`Timeout (${elapsed}ms) waiting for pattern: ${pattern}`, this._output));
+            }, timeoutMs);
+        });
+    }
+    /**
+     * Wait for the process to exit.
+     * @param timeoutMs Timeout in milliseconds (default: 30000)
+     * @returns The complete output
+     */
+    async waitForExit(timeoutMs = 30000) {
+        if (!this._isRunning) {
+            return this._output;
+        }
+        return new Promise((resolve, reject) => {
+            let timeoutHandle;
+            timeoutHandle = setTimeout(() => {
+                reject(new PTYTimeoutError(`Timeout (${timeoutMs}ms) waiting for process to exit`, this._output));
+            }, timeoutMs);
+            this._exitPromise
+                .then(() => {
+                if (timeoutHandle)
+                    clearTimeout(timeoutHandle);
+                resolve(this._output);
+            })
+                .catch(reject);
+        });
+    }
+    /**
+     * Kill the process.
+     * @param signal Signal to send (default: SIGHUP on Unix)
+     */
+    kill(signal) {
+        if (!this._isRunning) {
+            return;
+        }
+        try {
+            this._pty.kill(signal);
+        }
+        catch {
+            // Process may already be dead
+        }
+    }
+    /**
+     * Close the session and clean up resources.
+     */
+    close() {
+        // Kill the process first before disposing handlers
+        if (this._isRunning) {
+            this.kill("SIGKILL");
+            // Mark as not running since we won't receive the exit event
+            // after disposing the handlers
+            this._isRunning = false;
+            // Resolve the exit promise to unblock any waiters
+            // Use -1 to indicate forced termination
+            this._exitResolve(-1);
+        }
+        this._dataDisposable.dispose();
+        this._exitDisposable.dispose();
+    }
+    /**
+     * Get the current output buffer.
+     */
+    get output() {
+        return this._output;
+    }
+    /**
+     * Check if the process is still running.
+     */
+    get isRunning() {
+        return this._isRunning;
+    }
+    /**
+     * Get the process ID.
+     */
+    get pid() {
+        return this._pty.pid;
+    }
+    /**
+     * Get the exit code (undefined if still running).
+     */
+    get exitCode() {
+        return this._exitCode;
+    }
+    /**
+     * Get the current terminal columns.
+     */
+    get cols() {
+        return this._pty.cols;
+    }
+    /**
+     * Get the current terminal rows.
+     */
+    get rows() {
+        return this._pty.rows;
+    }
+}
+/**
+ * Create a new PTY session.
+ * @param options Options for the PTY
+ * @returns A PTYSession wrapping the process
+ */
+export async function createPTYSession(options) {
+    const defaultCols = 80;
+    const defaultRows = 24;
+    const pty = loadNodePty().spawn(options.command, options.args ?? [], {
+        name: "xterm-256color",
+        cols: options.cols ?? defaultCols,
+        rows: options.rows ?? defaultRows,
+        cwd: options.cwd ?? process.cwd(),
+        env: {
+            ...sanitizeEnv(options.env),
+            TERM: "xterm-256color",
+        },
+    });
+    return new PTYSession(pty);
+}
+/**
+ * Run a command in a PTY and wait for it to complete.
+ * This is a convenience function for commands that don't require interaction.
+ *
+ * @param options Options for the PTY, with optional timeout
+ * @returns The output and exit code
+ */
+export async function runInPTY(options) {
+    const { timeoutMs = 30000, ...ptyOptions } = options;
+    const session = await createPTYSession(ptyOptions);
+    try {
+        const output = await session.waitForExit(timeoutMs);
+        return {
+            output,
+            exitCode: session.exitCode ?? 0,
+        };
+    }
+    finally {
+        session.close();
+    }
+}
+/**
+ * Escape special regex characters in a string.
+ */
+function escapeRegExp(string) {
+    return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+//# sourceMappingURL=pty.js.map

package/dist/executors/restart.js

@@ -0,0 +1,120 @@
+/**
+ * @aria/tools - Restart executor
+ *
+ * Single restart path for both TUI and daemon:
+ * Register an 'exit' handler to spawn a replacement process, then SIGINT
+ * the current process for graceful shutdown. The replacement starts fresh
+ * and goes through normal startup (heap check, createCliContext, REPL/daemon).
+ */
+import { success, fail } from "./utils.js";
+import { spawn } from "node:child_process";
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import * as os from "node:os";
+import { RESUME_ARION_ENV, RESUME_SESSION_ENV, writeRelaunchMarker } from "@aria-cli/types";
+function findBunWorkspaceRoot(startDir) {
+    let dir = resolve(startDir);
+    while (true) {
+        if (existsSync(join(dir, "bunfig.toml")) || existsSync(join(dir, "bun.lock")))
+            return dir;
+        const parent = dirname(dir);
+        if (parent === dir)
+            return null;
+        dir = parent;
+    }
+}
+function getBunCommand() {
+    return process.platform === "win32" ? "bun.exe" : "bun";
+}
+async function rebuildWorkspaceIfPresent(startDir) {
+    const root = findBunWorkspaceRoot(startDir);
+    if (!root)
+        return { attempted: false };
+    const bun = getBunCommand();
+    await new Promise((resolvePromise, rejectPromise) => {
+        const child = spawn(bun, ["run", "build"], {
+            cwd: root,
+            env: process.env,
+            stdio: "inherit",
+        });
+        child.on("error", rejectPromise);
+        child.on("close", (code) => {
+            if (code === 0)
+                resolvePromise();
+            else
+                rejectPromise(new Error(`bun run build failed with exit code ${code ?? "unknown"}`));
+        });
+    });
+    return { attempted: true };
+}
+/**
+ * Find the daemon PID for the current ARIA_HOME by scanning owner records.
+ * Owner records live at $RUNTIME_ROOT/owners/*.json where RUNTIME_ROOT is
+ * XDG_RUNTIME_DIR/aria or ~/.aria/run.
+ */
+function findDaemonPid() {
+    const ariaHome = process.env.ARIA_HOME?.trim() || join(os.homedir(), ".aria");
+    const runtimeDir = process.env.XDG_RUNTIME_DIR?.trim();
+    const runtimeRoot = runtimeDir ? join(runtimeDir, "aria") : join(ariaHome, "run");
+    const ownersDir = join(runtimeRoot, "owners");
+    if (!existsSync(ownersDir))
+        return null;
+    const canonicalHome = resolve(ariaHome);
+    for (const file of readdirSync(ownersDir).filter((f) => f.endsWith(".json"))) {
+        try {
+            const record = JSON.parse(readFileSync(join(ownersDir, file), "utf8"));
+            if (record.ariaHome && resolve(record.ariaHome) === canonicalHome) {
+                return typeof record.runtimePid === "number" ? record.runtimePid : null;
+            }
+        }
+        catch {
+            // Skip malformed records
+        }
+    }
+    return null;
+}
+export async function executeRestart(input, ctx) {
+    if (ctx.abortSignal?.aborted)
+        return fail("Operation cancelled");
+    const reason = (input.reason ?? "").trim() || "Restart requested";
+    // Note: tool definition has requiresConfirmation: true, so the framework
+    // already prompts the user before execute() is called. No need to confirm again.
+    process.stderr.write(`[aria] Rebuilding workspace before restart...\n`);
+    try {
+        const rebuilt = await rebuildWorkspaceIfPresent(ctx.workingDir || process.cwd());
+        if (!rebuilt.attempted) {
+            process.stderr.write(`[aria] No bun workspace detected; skipping build\n`);
+        }
+    }
+    catch (error) {
+        process.stderr.write(`[aria] Build failed; continuing restart: ${error.message}\n`);
+    }
+    process.stderr.write(`[aria] Restarting: ${reason}\n`);
+    const sessionId = process.env[RESUME_SESSION_ENV] ?? null;
+    const arionName = process.env[RESUME_ARION_ENV] || "ARIA";
+    // Write disk-backed marker so the replacement process can resume the session.
+    writeRelaunchMarker({
+        sessionId,
+        arionName,
+        pid: process.ppid || process.pid,
+        timestamp: new Date().toISOString(),
+    });
+    // Spawn replacement on exit, then SIGINT for graceful shutdown.
+    // Works for both TUI and daemon — no supervisor needed.
+    const targetPid = findDaemonPid() ?? process.pid;
+    process.once("exit", () => {
+        spawn(process.execPath, [...process.execArgv, ...process.argv.slice(1)], {
+            detached: true,
+            stdio: "ignore",
+        }).unref();
+    });
+    process.stderr.write(`[aria] Sending SIGINT to pid ${targetPid} for graceful restart\n`);
+    try {
+        process.kill(targetPid, "SIGINT");
+    }
+    catch {
+        process.kill(process.pid, "SIGINT");
+    }
+    return success("Restarting...");
+}
+//# sourceMappingURL=restart.js.map

package/dist/executors/search-freshness.js

@@ -0,0 +1,196 @@
+/**
+ * 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";
+const repoStates = new Map();
+/** 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) {
+    return nodePath.resolve(p);
+}
+function getState(root) {
+    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, operation, content) {
+    // 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) {
+    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, root, relativePath, operation) {
+    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) {
+    const state = getState(root);
+    const sessionWrites = [];
+    const sessionDeletes = [];
+    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) {
+    const key = norm(root);
+    repoStates.delete(key);
+}
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function findGitRepoRoot(startPath) {
+    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, args) {
+    try {
+        return execFileSync("git", args, {
+            cwd,
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "ignore"],
+        }).trim();
+    }
+    catch {
+        return null;
+    }
+}
+//# sourceMappingURL=search-freshness.js.map

package/dist/executors/search-types.js

@@ -0,0 +1,53 @@
+/**
+ * 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
+ */
+// ---------------------------------------------------------------------------
+// Shared dedup logic — single source of truth for both base executor and wrapper
+// ---------------------------------------------------------------------------
+/** Source priority for dedup (lower = higher priority). */
+export const SOURCE_PRIORITY = {
+    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, limit) {
+    const deduped = new Map();
+    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);
+}
+//# sourceMappingURL=search-types.js.map