@aria-cli/tools 1.0.10 → 1.0.12

package/dist-cjs/definitions/session-history.js

@@ -0,0 +1,72 @@
+"use strict";
+/**
+ * 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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SESSION_HISTORY_TOOL_DEFINITIONS = void 0;
+const session_history_js_1 = require("../executors/session-history.js");
+const sessionHistory = {
+    name: "session_history",
+    description: "List, search, and manage conversation session history. Actions: " +
+        "'list' shows recent sessions, 'search' finds sessions by message content (full-text search), " +
+        "'get' retrieves a full session transcript, 'current' shows current session info, " +
+        "'stats' shows session statistics, 'delete' removes a session, " +
+        "'set_title' renames a session.",
+    category: "memory",
+    parameters: {
+        type: "object",
+        properties: {
+            action: {
+                type: "string",
+                enum: ["list", "search", "get", "current", "stats", "delete", "set_title"],
+                description: "Action to perform",
+            },
+            query: {
+                type: "string",
+                description: "Search query (required for 'search' action)",
+            },
+            sessionId: {
+                type: "string",
+                description: "Session ID or prefix — 8+ chars for prefix match, full UUID for exact match (required for 'get', 'delete', 'set_title')",
+            },
+            title: {
+                type: "string",
+                description: "New title (required for 'set_title' action)",
+            },
+            limit: {
+                type: "number",
+                description: "Maximum number of results to return (default 20)",
+                default: 20,
+            },
+            offset: {
+                type: "number",
+                description: "Pagination offset (default 0)",
+                default: 0,
+            },
+            messageLimit: {
+                type: "number",
+                description: "Maximum messages to return per session for 'get' action (default 50)",
+                default: 50,
+            },
+        },
+        required: ["action"],
+    },
+    riskLevel: "moderate",
+    isReadOnly: false,
+    loadingTier: "deferred",
+    // Only 'delete' needs confirmation — all other actions are safe
+    skipApprovalForInput: (input) => {
+        const i = input;
+        return i?.action !== "delete";
+    },
+    execute: (input, ctx) => {
+        return (0, session_history_js_1.executeSessionHistory)(input, ctx);
+    },
+};
+/** Session History tool definitions (1) */
+exports.SESSION_HISTORY_TOOL_DEFINITIONS = [sessionHistory];

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

@@ -0,0 +1,8 @@
+/**
+ * Shell tool definitions
+ *
+ * Tools: bash, exec, spawn, kill, write_stdin, list_processes, wait_process (7 tools)
+ */
+import type { Tool } from "../types.js";
+/** Shell tool definitions (7) */
+export declare const SHELL_TOOL_DEFINITIONS: Tool[];

package/dist-cjs/definitions/shell.js

@@ -0,0 +1,184 @@
+"use strict";
+/**
+ * Shell tool definitions
+ *
+ * Tools: bash, exec, spawn, kill, write_stdin, list_processes, wait_process (7 tools)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SHELL_TOOL_DEFINITIONS = void 0;
+const index_js_1 = require("../executors/index.js");
+const shell_js_1 = require("../executors/shell.js");
+const shell_safety_js_1 = require("../executors/shell-safety.js");
+const bash = {
+    name: "bash",
+    description: "Execute a shell command in a bash environment. Returns stdout and stderr.",
+    category: "shell",
+    parameters: {
+        type: "object",
+        properties: {
+            command: { type: "string", description: "Command to execute" },
+            cwd: { type: "string", description: "Working directory" },
+            env: { type: "object", description: "Environment variables" },
+            timeout: { type: "number", description: "Timeout in milliseconds" },
+        },
+        required: ["command"],
+    },
+    riskLevel: "dangerous",
+    requiresConfirmation: true,
+    isReadOnly: false,
+    loadingTier: "always",
+    skipApprovalForInput: (input) => {
+        const cmd = input?.command;
+        return typeof cmd === "string" && (0, shell_safety_js_1.classifyCommand)(cmd) === "safe";
+    },
+    execute: index_js_1.executeBash,
+};
+const exec = {
+    name: "exec",
+    description: "Execute a program directly without shell interpretation. Safer than bash for untrusted input.",
+    category: "shell",
+    parameters: {
+        type: "object",
+        properties: {
+            program: { type: "string", description: "Program to execute" },
+            args: {
+                type: "array",
+                items: { type: "string" },
+                description: "Command arguments",
+            },
+            cwd: { type: "string", description: "Working directory" },
+            env: { type: "object", description: "Environment variables" },
+            timeout: { type: "number", description: "Timeout in milliseconds" },
+        },
+        required: ["program"],
+    },
+    riskLevel: "dangerous",
+    isReadOnly: false,
+    loadingTier: "always",
+    execute: index_js_1.executeExec,
+};
+const spawn = {
+    name: "spawn",
+    description: "Start a long-running process in the background. Returns a process ID for management.",
+    category: "shell",
+    parameters: {
+        type: "object",
+        properties: {
+            program: { type: "string", description: "Program to spawn" },
+            args: {
+                type: "array",
+                items: { type: "string" },
+                description: "Command arguments",
+            },
+            cwd: { type: "string", description: "Working directory" },
+            env: { type: "object", description: "Environment variables" },
+            interactive: {
+                type: "boolean",
+                description: "Start as interactive PTY session (enables write_stdin). Default: false",
+                default: false,
+            },
+        },
+        required: ["program"],
+    },
+    riskLevel: "dangerous",
+    isReadOnly: false,
+    loadingTier: "always",
+    execute: index_js_1.executeSpawn,
+};
+const kill = {
+    name: "kill",
+    description: "Terminate a running process by its process ID.",
+    category: "shell",
+    parameters: {
+        type: "object",
+        properties: {
+            pid: { type: "number", description: "Process ID to kill" },
+            signal: {
+                type: "string",
+                description: "Signal to send",
+                default: "SIGTERM",
+            },
+        },
+        required: ["pid"],
+    },
+    riskLevel: "dangerous",
+    requiresConfirmation: true,
+    isReadOnly: false,
+    loadingTier: "always",
+    execute: index_js_1.executeKill,
+};
+const write_stdin = {
+    name: "write_stdin",
+    description: "Send input to an interactive PTY session by PID. Use after spawning a process with interactive=true. Returns recent output from the session.",
+    category: "shell",
+    parameters: {
+        type: "object",
+        properties: {
+            pid: { type: "number", description: "PID of the interactive process" },
+            input: { type: "string", description: "Input string to send to the process" },
+            timeout: {
+                type: "number",
+                description: "Milliseconds to wait for output after writing (max 30000)",
+            },
+        },
+        required: ["pid", "input"],
+    },
+    riskLevel: "moderate",
+    isReadOnly: false,
+    loadingTier: "always",
+    execute: index_js_1.executeWriteStdin,
+};
+const list_processes = {
+    name: "list_processes",
+    description: "List tracked shell processes started in this session with metadata and runtime status.",
+    category: "shell",
+    parameters: {
+        type: "object",
+        properties: {
+            includeExited: {
+                type: "boolean",
+                description: "Include recently exited processes from registry history (default: false).",
+                default: false,
+            },
+        },
+        required: [],
+    },
+    riskLevel: "safe",
+    isReadOnly: true,
+    loadingTier: "always",
+    execute: shell_js_1.executeListProcesses,
+};
+const wait_process = {
+    name: "wait_process",
+    description: "Wait for a tracked process to exit and return exit metadata. Fails on timeout.",
+    category: "shell",
+    parameters: {
+        type: "object",
+        properties: {
+            pid: { type: "number", description: "PID of the process to wait for" },
+            timeoutMs: {
+                type: "number",
+                description: "Maximum milliseconds to wait (max 300000, default 30000).",
+            },
+            timeout: {
+                type: "number",
+                description: "Deprecated alias for timeoutMs.",
+            },
+        },
+        required: ["pid"],
+    },
+    riskLevel: "safe",
+    isReadOnly: true,
+    loadingTier: "always",
+    execute: shell_js_1.executeWaitProcess,
+};
+/** Shell tool definitions (7) */
+exports.SHELL_TOOL_DEFINITIONS = [
+    bash,
+    exec,
+    spawn,
+    kill,
+    write_stdin,
+    list_processes,
+    wait_process,
+];

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

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

package/dist-cjs/definitions/slack.js

@@ -0,0 +1,183 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SLACK_TOOL_DEFINITIONS = void 0;
+const desktop_session_js_1 = require("../slack/desktop-session.js");
+const check_slack_messages = {
+    name: "check_slack_messages",
+    description: "Read recent Slack messages from a channel or DM using the local Slack Desktop session on this machine.",
+    category: "messaging",
+    parameters: {
+        type: "object",
+        properties: {
+            teamId: {
+                type: "string",
+                description: "Optional Slack team id to target when the local Slack Desktop app is signed into multiple workspaces.",
+            },
+            channel: {
+                type: "string",
+                description: "Slack conversation id (C/G/D...) or channel name.",
+            },
+            limit: {
+                type: "number",
+                description: "Maximum number of messages to return (default 20, max 100).",
+                default: 20,
+            },
+            threadTs: {
+                type: "string",
+                description: "Optional thread timestamp. When provided, reads thread replies instead of the root channel history.",
+            },
+        },
+        required: ["channel"],
+    },
+    riskLevel: "safe",
+    isReadOnly: true,
+    loadingTier: "always",
+    execute: async (input) => {
+        const typedInput = input;
+        const client = await (0, desktop_session_js_1.createSlackDesktopClient)({
+            teamId: typeof typedInput.teamId === "string" ? typedInput.teamId : undefined,
+        });
+        try {
+            const result = await client.listMessages({
+                channel: String(typedInput.channel ?? ""),
+                limit: typeof typedInput.limit === "number" ? typedInput.limit : 20,
+                threadTs: typeof typedInput.threadTs === "string" ? typedInput.threadTs : undefined,
+            });
+            return {
+                success: true,
+                message: `Fetched ${result.messages.length} Slack messages from ${result.channelId}.`,
+                data: result,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                message: error instanceof Error ? error.message : "Slack read failed.",
+            };
+        }
+        finally {
+            await client.close();
+        }
+    },
+};
+const send_slack_message = {
+    name: "send_slack_message",
+    description: "Send a Slack message through the local Slack Desktop session on this machine. Requires confirmation because it posts externally.",
+    category: "messaging",
+    parameters: {
+        type: "object",
+        properties: {
+            teamId: {
+                type: "string",
+                description: "Optional Slack team id to target when the local Slack Desktop app is signed into multiple workspaces.",
+            },
+            channel: {
+                type: "string",
+                description: "Slack conversation id (C/G/D...) or channel name.",
+            },
+            text: {
+                type: "string",
+                description: "Message text to send.",
+            },
+            threadTs: {
+                type: "string",
+                description: "Optional thread timestamp to reply inside an existing thread.",
+            },
+        },
+        required: ["channel", "text"],
+    },
+    riskLevel: "dangerous",
+    requiresConfirmation: true,
+    isReadOnly: false,
+    loadingTier: "always",
+    execute: async (input) => {
+        const typedInput = input;
+        const client = await (0, desktop_session_js_1.createSlackDesktopClient)({
+            teamId: typeof typedInput.teamId === "string" ? typedInput.teamId : undefined,
+        });
+        try {
+            const result = await client.sendMessage({
+                channel: String(typedInput.channel ?? ""),
+                text: String(typedInput.text ?? ""),
+                threadTs: typeof typedInput.threadTs === "string" ? typedInput.threadTs : undefined,
+            });
+            return {
+                success: true,
+                message: `Sent Slack message to ${result.channelId}.`,
+                data: result,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                message: error instanceof Error ? error.message : "Slack send failed.",
+            };
+        }
+        finally {
+            await client.close();
+        }
+    },
+};
+const react_slack_message = {
+    name: "react_slack_message",
+    description: "Add an emoji reaction to a Slack message using the local Slack Desktop session on this machine. Requires confirmation because it modifies external state.",
+    category: "messaging",
+    parameters: {
+        type: "object",
+        properties: {
+            teamId: {
+                type: "string",
+                description: "Optional Slack team id to target when the local Slack Desktop app is signed into multiple workspaces.",
+            },
+            channel: {
+                type: "string",
+                description: "Slack conversation id (C/G/D...) or channel name.",
+            },
+            timestamp: {
+                type: "string",
+                description: "Message timestamp to react to.",
+            },
+            name: {
+                type: "string",
+                description: "Emoji name without colons (e.g., thumbsup, eyes, white_check_mark).",
+            },
+        },
+        required: ["channel", "timestamp", "name"],
+    },
+    riskLevel: "dangerous",
+    requiresConfirmation: true,
+    isReadOnly: false,
+    loadingTier: "always",
+    execute: async (input) => {
+        const typedInput = input;
+        const client = await (0, desktop_session_js_1.createSlackDesktopClient)({
+            teamId: typeof typedInput.teamId === "string" ? typedInput.teamId : undefined,
+        });
+        try {
+            const result = await client.addReaction({
+                channel: String(typedInput.channel ?? ""),
+                timestamp: String(typedInput.timestamp ?? ""),
+                name: String(typedInput.name ?? ""),
+            });
+            return {
+                success: true,
+                message: `Added :${typedInput.name}: reaction in ${result.channelId}.`,
+                data: result,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                message: error instanceof Error ? error.message : "Slack reaction failed.",
+            };
+        }
+        finally {
+            await client.close();
+        }
+    },
+};
+exports.SLACK_TOOL_DEFINITIONS = [
+    check_slack_messages,
+    send_slack_message,
+    react_slack_message,
+];

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

@@ -0,0 +1,8 @@
+/**
+ * Web tool definitions
+ *
+ * Tools: web_search, web_fetch, browse (3 tools)
+ */
+import type { Tool } from "../types.js";
+/** Web tool definitions (3) */
+export declare const WEB_TOOL_DEFINITIONS: Tool[];

package/dist-cjs/definitions/web.js

@@ -0,0 +1,112 @@
+"use strict";
+/**
+ * Web tool definitions
+ *
+ * Tools: web_search, web_fetch, browse (3 tools)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WEB_TOOL_DEFINITIONS = void 0;
+const index_js_1 = require("../executors/index.js");
+// web_search uses SearchProviderRouter with automatic provider selection
+const web_search = {
+    name: "web_search",
+    description: "Search the web for information. Auto-selects the best available search provider (Brave, Firecrawl, Exa, Tavily, Jina, or DuckDuckGo). Works without any API key via Jina/DuckDuckGo fallback. Set ARIA_SEARCH_PROVIDER to override.",
+    category: "web",
+    parameters: {
+        type: "object",
+        properties: {
+            query: { type: "string", description: "Search query" },
+            limit: {
+                type: "number",
+                description: "Maximum number of results",
+                default: 10,
+            },
+            domains: {
+                type: "array",
+                items: { type: "string" },
+                description: "Only include results from these domains",
+            },
+            excludeDomains: {
+                type: "array",
+                items: { type: "string" },
+                description: "Exclude results from these domains",
+            },
+            topic: {
+                type: "string",
+                enum: ["general", "news"],
+                description: "Search topic classification",
+            },
+            timeRange: {
+                type: "string",
+                enum: ["day", "week", "month", "year"],
+                description: "Restrict results to a recent time window",
+            },
+        },
+        required: ["query"],
+    },
+    riskLevel: "moderate",
+    isReadOnly: true,
+    loadingTier: "always",
+    execute: index_js_1.executeWebSearch,
+};
+const web_fetch = {
+    name: "web_fetch",
+    description: "Fetch the content of a web page. Returns the page content as text or structured data.",
+    category: "web",
+    parameters: {
+        type: "object",
+        properties: {
+            url: { type: "string", description: "URL to fetch" },
+            format: {
+                type: "string",
+                enum: ["text", "html", "json"],
+                description: "Output format",
+                default: "text",
+            },
+            headers: {
+                type: "object",
+                description: "Custom request headers",
+                additionalProperties: { type: "string" },
+            },
+            timeoutMs: {
+                type: "number",
+                description: "Request timeout in milliseconds",
+                default: 30_000,
+            },
+            maxSizeBytes: {
+                type: "number",
+                description: "Maximum response body size in bytes",
+                default: 1 * 1024 * 1024,
+            },
+        },
+        required: ["url"],
+    },
+    riskLevel: "safe",
+    isReadOnly: true,
+    loadingTier: "always",
+    execute: index_js_1.executeWebFetch,
+};
+// browse uses Readability + Turndown for structured markdown extraction
+const browse = {
+    name: "browse",
+    description: "Browse a web page and extract structured markdown content using Readability + Turndown. Returns the page title and markdown (up to 50K chars). Handles GitHub URL normalization and retry with backoff.",
+    category: "web",
+    parameters: {
+        type: "object",
+        properties: {
+            url: { type: "string", description: "URL to browse" },
+            timeoutMs: {
+                type: "number",
+                description: "Request timeout in milliseconds",
+                default: 30_000,
+            },
+        },
+        required: ["url"],
+    },
+    riskLevel: "safe",
+    isReadOnly: true,
+    loadingTier: "always",
+    execute: index_js_1.executeBrowse,
+};
+/** Web tool definitions (3) */
+exports.WEB_TOOL_DEFINITIONS = [web_search, web_fetch, browse];

package/dist-cjs/executors/apply-patch.d.ts

@@ -0,0 +1,51 @@
+/**
+ * @aria/tools - Apply Patch executor
+ *
+ * Parses and applies unified diff patches with:
+ * - Path traversal protection (SECURITY-CRITICAL)
+ * - Atomic writes (all-or-nothing application)
+ * - Fuzzy hunk matching (offset tolerance)
+ * - CRLF normalization
+ */
+import type { ToolContext, ToolResult } from "../types.js";
+export interface ApplyPatchInput {
+    /** Unified diff format patch content */
+    patch: string;
+    /** Working directory for relative paths in the patch */
+    cwd?: string;
+}
+/** A single hunk within a file diff */
+interface Hunk {
+    /** Original file start line (1-based) */
+    oldStart: number;
+    /** Number of lines in original */
+    oldCount: number;
+    /** Modified file start line (1-based) */
+    newStart: number;
+    /** Number of lines in modified */
+    newCount: number;
+    /** Lines in the hunk: each prefixed with ' ', '+', or '-' */
+    lines: string[];
+}
+/** A diff for a single file */
+interface FileDiff {
+    /** Original file path (null for new files) */
+    oldPath: string | null;
+    /** Modified file path (null for deleted files) */
+    newPath: string | null;
+    /** Hunks to apply */
+    hunks: Hunk[];
+}
+/**
+ * Parse a unified diff string into an array of file diffs.
+ * Handles standard unified diff and git-style diffs.
+ */
+export declare function parseUnifiedDiff(patch: string): FileDiff[];
+/**
+ * Execute the apply_patch tool.
+ *
+ * Parses a unified diff, validates all paths for security,
+ * and applies changes atomically.
+ */
+export declare function executeApplyPatch(input: ApplyPatchInput, ctx: ToolContext): Promise<ToolResult>;
+export {};