@aria-cli/tools 1.0.10 → 1.0.12

package/dist-cjs/definitions/process/pty-keys.js

@@ -0,0 +1,259 @@
+"use strict";
+// Originally from OpenClaw (MIT License, Copyright 2025 Peter Steinberger)
+// https://github.com/openclaw/openclaw
+// Modified for ARIA — stripped OpenClaw runtime, inlined escapeRegExp
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BRACKETED_PASTE_END = exports.BRACKETED_PASTE_START = void 0;
+exports.encodeKeySequence = encodeKeySequence;
+exports.encodePaste = encodePaste;
+const ESC = "\x1b";
+const CR = "\r";
+const TAB = "\t";
+const BACKSPACE = "\x7f";
+exports.BRACKETED_PASTE_START = `${ESC}[200~`;
+exports.BRACKETED_PASTE_END = `${ESC}[201~`;
+const namedKeyMap = new Map([
+    ["enter", CR],
+    ["return", CR],
+    ["tab", TAB],
+    ["escape", ESC],
+    ["esc", ESC],
+    ["space", " "],
+    ["bspace", BACKSPACE],
+    ["backspace", BACKSPACE],
+    ["up", `${ESC}[A`],
+    ["down", `${ESC}[B`],
+    ["right", `${ESC}[C`],
+    ["left", `${ESC}[D`],
+    ["home", `${ESC}[1~`],
+    ["end", `${ESC}[4~`],
+    ["pageup", `${ESC}[5~`],
+    ["pgup", `${ESC}[5~`],
+    ["ppage", `${ESC}[5~`],
+    ["pagedown", `${ESC}[6~`],
+    ["pgdn", `${ESC}[6~`],
+    ["npage", `${ESC}[6~`],
+    ["insert", `${ESC}[2~`],
+    ["ic", `${ESC}[2~`],
+    ["delete", `${ESC}[3~`],
+    ["del", `${ESC}[3~`],
+    ["dc", `${ESC}[3~`],
+    ["btab", `${ESC}[Z`],
+    ["f1", `${ESC}OP`],
+    ["f2", `${ESC}OQ`],
+    ["f3", `${ESC}OR`],
+    ["f4", `${ESC}OS`],
+    ["f5", `${ESC}[15~`],
+    ["f6", `${ESC}[17~`],
+    ["f7", `${ESC}[18~`],
+    ["f8", `${ESC}[19~`],
+    ["f9", `${ESC}[20~`],
+    ["f10", `${ESC}[21~`],
+    ["f11", `${ESC}[23~`],
+    ["f12", `${ESC}[24~`],
+    ["kp/", `${ESC}Oo`],
+    ["kp*", `${ESC}Oj`],
+    ["kp-", `${ESC}Om`],
+    ["kp+", `${ESC}Ok`],
+    ["kp7", `${ESC}Ow`],
+    ["kp8", `${ESC}Ox`],
+    ["kp9", `${ESC}Oy`],
+    ["kp4", `${ESC}Ot`],
+    ["kp5", `${ESC}Ou`],
+    ["kp6", `${ESC}Ov`],
+    ["kp1", `${ESC}Oq`],
+    ["kp2", `${ESC}Or`],
+    ["kp3", `${ESC}Os`],
+    ["kp0", `${ESC}Op`],
+    ["kp.", `${ESC}On`],
+    ["kpenter", `${ESC}OM`],
+]);
+const modifiableNamedKeys = new Set([
+    "up",
+    "down",
+    "left",
+    "right",
+    "home",
+    "end",
+    "pageup",
+    "pgup",
+    "ppage",
+    "pagedown",
+    "pgdn",
+    "npage",
+    "insert",
+    "ic",
+    "delete",
+    "del",
+    "dc",
+]);
+function encodeKeySequence(request) {
+    const warnings = [];
+    let data = "";
+    if (request.literal) {
+        data += request.literal;
+    }
+    if (request.hex?.length) {
+        for (const raw of request.hex) {
+            const byte = parseHexByte(raw);
+            if (byte === null) {
+                warnings.push(`Invalid hex byte: ${raw}`);
+                continue;
+            }
+            data += String.fromCharCode(byte);
+        }
+    }
+    if (request.keys?.length) {
+        for (const token of request.keys) {
+            data += encodeKeyToken(token, warnings);
+        }
+    }
+    return { data, warnings };
+}
+function encodePaste(text, bracketed = true) {
+    if (!bracketed) {
+        return text;
+    }
+    return `${exports.BRACKETED_PASTE_START}${text}${exports.BRACKETED_PASTE_END}`;
+}
+function encodeKeyToken(raw, warnings) {
+    const token = raw.trim();
+    if (!token) {
+        return "";
+    }
+    if (token.length === 2 && token.startsWith("^")) {
+        const ctrl = toCtrlChar(token[1]);
+        if (ctrl) {
+            return ctrl;
+        }
+    }
+    const parsed = parseModifiers(token);
+    const base = parsed.base;
+    const baseLower = base.toLowerCase();
+    if (baseLower === "tab" && parsed.mods.shift) {
+        return `${ESC}[Z`;
+    }
+    const baseSeq = namedKeyMap.get(baseLower);
+    if (baseSeq) {
+        let seq = baseSeq;
+        if (modifiableNamedKeys.has(baseLower) && hasAnyModifier(parsed.mods)) {
+            const mod = xtermModifier(parsed.mods);
+            if (mod > 1) {
+                const modified = applyXtermModifier(seq, mod);
+                if (modified) {
+                    seq = modified;
+                    return seq;
+                }
+            }
+        }
+        if (parsed.mods.alt) {
+            return `${ESC}${seq}`;
+        }
+        return seq;
+    }
+    if (base.length === 1) {
+        return applyCharModifiers(base, parsed.mods);
+    }
+    if (parsed.hasModifiers) {
+        warnings.push(`Unknown key "${base}" for modifiers; sending literal.`);
+    }
+    return base;
+}
+function parseModifiers(token) {
+    const mods = { ctrl: false, alt: false, shift: false };
+    let rest = token;
+    let sawModifiers = false;
+    while (rest.length > 2 && rest[1] === "-") {
+        const mod = rest[0].toLowerCase();
+        if (mod === "c") {
+            mods.ctrl = true;
+        }
+        else if (mod === "m") {
+            mods.alt = true;
+        }
+        else if (mod === "s") {
+            mods.shift = true;
+        }
+        else {
+            break;
+        }
+        sawModifiers = true;
+        rest = rest.slice(2);
+    }
+    return { mods, base: rest, hasModifiers: sawModifiers };
+}
+function applyCharModifiers(char, mods) {
+    let value = char;
+    if (mods.shift && value.length === 1 && /[a-z]/.test(value)) {
+        value = value.toUpperCase();
+    }
+    if (mods.ctrl) {
+        const ctrl = toCtrlChar(value);
+        if (ctrl) {
+            value = ctrl;
+        }
+    }
+    if (mods.alt) {
+        value = `${ESC}${value}`;
+    }
+    return value;
+}
+function toCtrlChar(char) {
+    if (char.length !== 1) {
+        return null;
+    }
+    if (char === "?") {
+        return "\x7f";
+    }
+    const code = char.toUpperCase().charCodeAt(0);
+    if (code >= 64 && code <= 95) {
+        return String.fromCharCode(code & 0x1f);
+    }
+    return null;
+}
+function xtermModifier(mods) {
+    let mod = 1;
+    if (mods.shift) {
+        mod += 1;
+    }
+    if (mods.alt) {
+        mod += 2;
+    }
+    if (mods.ctrl) {
+        mod += 4;
+    }
+    return mod;
+}
+/** Inlined from OpenClaw src/utils.ts — escapes special regex characters */
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function applyXtermModifier(sequence, modifier) {
+    const escPattern = escapeRegExp(ESC);
+    const csiNumber = new RegExp(`^${escPattern}\\[(\\d+)([~A-Z])$`);
+    const csiArrow = new RegExp(`^${escPattern}\\[(A|B|C|D|H|F)$`);
+    const numberMatch = sequence.match(csiNumber);
+    if (numberMatch) {
+        return `${ESC}[${numberMatch[1]};${modifier}${numberMatch[2]}`;
+    }
+    const arrowMatch = sequence.match(csiArrow);
+    if (arrowMatch) {
+        return `${ESC}[1;${modifier}${arrowMatch[1]}`;
+    }
+    return null;
+}
+function hasAnyModifier(mods) {
+    return mods.ctrl || mods.alt || mods.shift;
+}
+function parseHexByte(raw) {
+    const trimmed = raw.trim().toLowerCase();
+    const normalized = trimmed.startsWith("0x") ? trimmed.slice(2) : trimmed;
+    if (!/^[0-9a-f]{1,2}$/.test(normalized)) {
+        return null;
+    }
+    const value = Number.parseInt(normalized, 16);
+    if (Number.isNaN(value) || value < 0 || value > 0xff) {
+        return null;
+    }
+    return value;
+}

package/dist-cjs/definitions/process/session-slug.d.ts

@@ -0,0 +1 @@
+export declare function createSessionSlug(isTaken?: (id: string) => boolean): string;

package/dist-cjs/definitions/process/session-slug.js

@@ -0,0 +1,145 @@
+"use strict";
+// Originally from OpenClaw (MIT License, Copyright 2025 Peter Steinberger)
+// https://github.com/openclaw/openclaw
+// Modified for ARIA — stripped OpenClaw runtime, rewired to ARIA Tool interface
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSessionSlug = createSessionSlug;
+const SLUG_ADJECTIVES = [
+    "amber",
+    "briny",
+    "brisk",
+    "calm",
+    "clear",
+    "cool",
+    "crisp",
+    "dawn",
+    "delta",
+    "ember",
+    "faint",
+    "fast",
+    "fresh",
+    "gentle",
+    "glow",
+    "good",
+    "grand",
+    "keen",
+    "kind",
+    "lucky",
+    "marine",
+    "mellow",
+    "mild",
+    "neat",
+    "nimble",
+    "nova",
+    "oceanic",
+    "plaid",
+    "quick",
+    "quiet",
+    "rapid",
+    "salty",
+    "sharp",
+    "swift",
+    "tender",
+    "tidal",
+    "tidy",
+    "tide",
+    "vivid",
+    "warm",
+    "wild",
+    "young",
+];
+const SLUG_NOUNS = [
+    "atlas",
+    "basil",
+    "bison",
+    "bloom",
+    "breeze",
+    "canyon",
+    "cedar",
+    "claw",
+    "cloud",
+    "comet",
+    "coral",
+    "cove",
+    "crest",
+    "crustacean",
+    "daisy",
+    "dune",
+    "ember",
+    "falcon",
+    "fjord",
+    "forest",
+    "glade",
+    "gulf",
+    "harbor",
+    "haven",
+    "kelp",
+    "lagoon",
+    "lobster",
+    "meadow",
+    "mist",
+    "nudibranch",
+    "nexus",
+    "ocean",
+    "orbit",
+    "otter",
+    "pine",
+    "prairie",
+    "reef",
+    "ridge",
+    "river",
+    "rook",
+    "sable",
+    "sage",
+    "seaslug",
+    "shell",
+    "shoal",
+    "shore",
+    "slug",
+    "summit",
+    "tidepool",
+    "trail",
+    "valley",
+    "wharf",
+    "willow",
+    "zephyr",
+];
+function randomChoice(values, fallback) {
+    return values[Math.floor(Math.random() * values.length)] ?? fallback;
+}
+function createSlugBase(words = 2) {
+    const parts = [randomChoice(SLUG_ADJECTIVES, "steady"), randomChoice(SLUG_NOUNS, "harbor")];
+    if (words > 2) {
+        parts.push(randomChoice(SLUG_NOUNS, "reef"));
+    }
+    return parts.join("-");
+}
+function createSessionSlug(isTaken) {
+    const isIdTaken = isTaken ?? (() => false);
+    for (let attempt = 0; attempt < 12; attempt += 1) {
+        const base = createSlugBase(2);
+        if (!isIdTaken(base)) {
+            return base;
+        }
+        for (let i = 2; i <= 12; i += 1) {
+            const candidate = `${base}-${i}`;
+            if (!isIdTaken(candidate)) {
+                return candidate;
+            }
+        }
+    }
+    for (let attempt = 0; attempt < 12; attempt += 1) {
+        const base = createSlugBase(3);
+        if (!isIdTaken(base)) {
+            return base;
+        }
+        for (let i = 2; i <= 12; i += 1) {
+            const candidate = `${base}-${i}`;
+            if (!isIdTaken(candidate)) {
+                return candidate;
+            }
+        }
+    }
+    const fallback = `${createSlugBase(3)}-${Math.random().toString(36).slice(2, 5)}`;
+    return isIdTaken(fallback) ? `${fallback}-${Date.now().toString(36)}` : fallback;
+}

package/dist-cjs/definitions/quip.d.ts

@@ -0,0 +1,2 @@
+import type { Tool } from "../types.js";
+export declare const QUIP_TOOL_DEFINITIONS: Tool[];

package/dist-cjs/definitions/quip.js

@@ -0,0 +1,198 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QUIP_TOOL_DEFINITIONS = void 0;
+const node_child_process_1 = require("node:child_process");
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+const QUIP_PY = (0, node_path_1.join)((0, node_os_1.homedir)(), ".aria", "tools", "quip.py");
+function runQuip(args) {
+    return new Promise((resolve, reject) => {
+        (0, node_child_process_1.execFile)(QUIP_PY, args, { timeout: 30_000 }, (err, stdout, stderr) => {
+            if (err) {
+                reject(new Error(stderr?.trim() || err.message));
+            }
+            else {
+                resolve(stdout);
+            }
+        });
+    });
+}
+const check_quip_documents = {
+    name: "check_quip_documents",
+    description: "Read, search, or list Quip documents and comments using the local Quip session on this machine. " +
+        "Actions: 'recent' lists recent docs, 'search' finds docs by query, 'read' gets full document content, 'comments' lists comments on a document.",
+    category: "messaging",
+    parameters: {
+        type: "object",
+        properties: {
+            action: {
+                type: "string",
+                enum: ["recent", "search", "read", "comments"],
+                description: "What to do: 'recent' (list recent docs), 'search' (find docs), 'read' (get document content), 'comments' (list comments).",
+            },
+            query: {
+                type: "string",
+                description: "Search query (required for 'search' action).",
+            },
+            threadId: {
+                type: "string",
+                description: "Quip thread/document ID (required for 'read' and 'comments' actions).",
+            },
+            limit: {
+                type: "number",
+                description: "Maximum number of results to return (default 20, max 50).",
+                default: 20,
+            },
+        },
+        required: ["action"],
+    },
+    riskLevel: "safe",
+    isReadOnly: true,
+    loadingTier: "always",
+    execute: async (input) => {
+        const typedInput = input;
+        try {
+            const action = String(typedInput.action ?? "recent");
+            const limit = String(typeof typedInput.limit === "number" ? typedInput.limit : 20);
+            if (action === "recent") {
+                const raw = await runQuip(["recent", limit]);
+                return { success: true, message: `Recent Quip documents.`, data: { output: raw } };
+            }
+            if (action === "search") {
+                const query = String(typedInput.query ?? "");
+                if (!query)
+                    return { success: false, message: "'search' requires a 'query' parameter." };
+                const raw = await runQuip(["search", query, "--limit", limit]);
+                return { success: true, message: `Search results for "${query}".`, data: { output: raw } };
+            }
+            if (action === "read") {
+                const threadId = String(typedInput.threadId ?? "");
+                if (!threadId)
+                    return { success: false, message: "'read' requires a 'threadId' parameter." };
+                const raw = await runQuip(["read", threadId]);
+                return { success: true, message: `Read document ${threadId}.`, data: { output: raw } };
+            }
+            if (action === "comments") {
+                const threadId = String(typedInput.threadId ?? "");
+                if (!threadId)
+                    return { success: false, message: "'comments' requires a 'threadId' parameter." };
+                const raw = await runQuip(["comments", threadId]);
+                return { success: true, message: `Comments on ${threadId}.`, data: { output: raw } };
+            }
+            return {
+                success: false,
+                message: `Unknown action: ${action}. Use recent, search, read, or comments.`,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                message: error instanceof Error ? error.message : "Quip read failed.",
+            };
+        }
+    },
+};
+const send_quip_comment = {
+    name: "send_quip_comment",
+    description: "Add a comment to a Quip document using the local Quip session on this machine. " +
+        "Requires confirmation because it posts externally.",
+    category: "messaging",
+    parameters: {
+        type: "object",
+        properties: {
+            threadId: {
+                type: "string",
+                description: "Quip thread/document ID to comment on.",
+            },
+            content: {
+                type: "string",
+                description: "Comment text to post.",
+            },
+        },
+        required: ["threadId", "content"],
+    },
+    riskLevel: "dangerous",
+    requiresConfirmation: true,
+    isReadOnly: false,
+    loadingTier: "always",
+    execute: async (input) => {
+        const typedInput = input;
+        try {
+            const raw = await runQuip([
+                "comment",
+                String(typedInput.threadId ?? ""),
+                String(typedInput.content ?? ""),
+            ]);
+            return { success: true, message: `Posted comment.`, data: { output: raw } };
+        }
+        catch (error) {
+            return {
+                success: false,
+                message: error instanceof Error ? error.message : "Quip comment failed.",
+            };
+        }
+    },
+};
+const create_quip_document = {
+    name: "create_quip_document",
+    description: "Create a new Quip document using the local Quip session on this machine. " +
+        "Requires confirmation because it creates external content.",
+    category: "messaging",
+    parameters: {
+        type: "object",
+        properties: {
+            title: {
+                type: "string",
+                description: "Document title.",
+            },
+            content: {
+                type: "string",
+                description: "Document body content.",
+            },
+            format: {
+                type: "string",
+                enum: ["markdown", "html"],
+                description: "Content format (default 'markdown').",
+                default: "markdown",
+            },
+            folderId: {
+                type: "string",
+                description: "Optional folder ID to place the document in.",
+            },
+        },
+        required: ["title", "content"],
+    },
+    riskLevel: "dangerous",
+    requiresConfirmation: true,
+    isReadOnly: false,
+    loadingTier: "always",
+    execute: async (input) => {
+        const typedInput = input;
+        try {
+            const args = [
+                "create",
+                "--title",
+                String(typedInput.title ?? ""),
+                "--body",
+                String(typedInput.content ?? ""),
+            ];
+            if (typedInput.format)
+                args.push("--format", typedInput.format);
+            if (typedInput.folderId)
+                args.push("--folder", typedInput.folderId);
+            const raw = await runQuip(args);
+            return { success: true, message: `Created document.`, data: { output: raw } };
+        }
+        catch (error) {
+            return {
+                success: false,
+                message: error instanceof Error ? error.message : "Quip create failed.",
+            };
+        }
+    },
+};
+exports.QUIP_TOOL_DEFINITIONS = [
+    check_quip_documents,
+    send_quip_comment,
+    create_quip_document,
+];

package/dist-cjs/definitions/search.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Native indexed regex search tool definition.
+ *
+ * Uses @aria-cli/search (Rust napi-rs addon) for sub-millisecond indexed search.
+ * Registered alongside (not replacing) the existing grep tool.
+ */
+import type { Tool } from "../types.js";
+export declare const searchTool: Tool;
+export declare const SEARCH_TOOL_DEFINITIONS: Tool[];

package/dist-cjs/definitions/search.js

@@ -0,0 +1,63 @@
+"use strict";
+/**
+ * Native indexed regex search tool definition.
+ *
+ * Uses @aria-cli/search (Rust napi-rs addon) for sub-millisecond indexed search.
+ * Registered alongside (not replacing) the existing grep tool.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SEARCH_TOOL_DEFINITIONS = exports.searchTool = void 0;
+const search_js_1 = require("../executors/search.js");
+exports.searchTool = {
+    name: "grep",
+    description: "Search for patterns in files using regular expressions. Indexed for sub-millisecond speed. Builds index automatically on first use. Supports regex, literal strings, file type filters, and glob patterns.",
+    category: "filesystem",
+    parameters: {
+        type: "object",
+        properties: {
+            pattern: {
+                type: "string",
+                description: "Regex pattern to search for. Use literal: true for exact string matching.",
+            },
+            directory: {
+                type: "string",
+                description: "Directory to search in (default: current working directory)",
+                default: ".",
+            },
+            fileGlob: {
+                type: "string",
+                description: "Glob pattern to filter files (e.g. '*.ts', 'src/**/*.rs')",
+            },
+            fileType: {
+                type: "string",
+                description: "File extension filter (e.g. 'ts', 'rs', 'py'). Simpler than glob for single types.",
+            },
+            caseSensitive: {
+                type: "boolean",
+                description: "Case-sensitive matching (default: true)",
+                default: true,
+            },
+            literal: {
+                type: "boolean",
+                description: "Treat pattern as a literal string, not regex (default: false)",
+                default: false,
+            },
+            maxResults: {
+                type: "number",
+                description: "Maximum number of matches to return (default: 1000)",
+                default: 1000,
+            },
+            context: {
+                type: "number",
+                description: "Number of context lines before and after each match (default: 0)",
+                default: 0,
+            },
+        },
+        required: ["pattern"],
+    },
+    riskLevel: "safe",
+    isReadOnly: true,
+    loadingTier: "always",
+    execute: search_js_1.executeSearch,
+};
+exports.SEARCH_TOOL_DEFINITIONS = [exports.searchTool];

package/dist-cjs/definitions/session-history.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Session History tool definitions
+ *
+ * Tools: session_history (1 tool with multi-action pattern)
+ *
+ * Provides list, search, get, current, stats, delete, and set_title
+ * actions against the SessionHistory SQLite database.
+ */
+import type { Tool } from "../types.js";
+/** Session History tool definitions (1) */
+export declare const SESSION_HISTORY_TOOL_DEFINITIONS: Tool[];