@aria-cli/tools 1.0.18 → 1.0.31

package/dist/definitions/filesystem.js

@@ -0,0 +1,197 @@
+/**
+ * Filesystem tool definitions
+ *
+ * Tools: read_file, write_file, edit_file, glob, ls, apply_patch (6 tools)
+ * Note: grep replaced by native indexed search in SEARCH_TOOL_DEFINITIONS
+ */
+import { executeReadFile, executeWriteFile, executeEditFile, executeLs, executeGlob, } from "../executors/index.js";
+const read_file = {
+    name: "read_file",
+    description: "Read the contents of a file from the filesystem.",
+    category: "filesystem",
+    parameters: {
+        type: "object",
+        properties: {
+            path: { type: "string", description: "Path to the file to read" },
+            encoding: {
+                type: "string",
+                enum: [
+                    "utf-8",
+                    "utf8",
+                    "latin1",
+                    "ascii",
+                    "base64",
+                    "base64url",
+                    "utf16le",
+                    "ucs2",
+                    "hex",
+                    "binary",
+                ],
+                description: "File encoding",
+                default: "utf-8",
+            },
+            offset: { type: "number", description: "Starting line offset (0-based)" },
+            limit: { type: "number", description: "Maximum number of lines to read" },
+        },
+        required: ["path"],
+    },
+    riskLevel: "safe",
+    isReadOnly: true,
+    loadingTier: "always",
+    execute: executeReadFile,
+};
+const write_file = {
+    name: "write_file",
+    description: "Write content to a file on the filesystem. Creates the file if it does not exist.",
+    category: "filesystem",
+    parameters: {
+        type: "object",
+        properties: {
+            path: { type: "string", description: "Path to the file to write" },
+            content: { type: "string", description: "Content to write" },
+            encoding: {
+                type: "string",
+                enum: [
+                    "utf-8",
+                    "utf8",
+                    "latin1",
+                    "ascii",
+                    "base64",
+                    "base64url",
+                    "utf16le",
+                    "ucs2",
+                    "hex",
+                    "binary",
+                ],
+                description: "File encoding",
+                default: "utf-8",
+            },
+            append: {
+                type: "boolean",
+                description: "Append to existing file",
+                default: false,
+            },
+            expectedHash: {
+                type: "string",
+                description: "Optional SHA-256 hash of the current file content. When provided, write fails if the file has changed.",
+            },
+        },
+        required: ["path", "content"],
+    },
+    riskLevel: "dangerous",
+    isReadOnly: false,
+    loadingTier: "always",
+    execute: executeWriteFile,
+};
+const edit_file = {
+    name: "edit_file",
+    description: "Edit a file by replacing text. Uses exact match first, then resilient matching strategies for whitespace and indentation drift.",
+    category: "filesystem",
+    parameters: {
+        type: "object",
+        properties: {
+            path: { type: "string", description: "Path to the file to edit" },
+            oldText: { type: "string", description: "Text to find and replace" },
+            newText: { type: "string", description: "Replacement text" },
+            replaceAll: {
+                type: "boolean",
+                description: "Replace all occurrences instead of just the first",
+                default: false,
+            },
+            expectedReplacements: {
+                type: "number",
+                description: "Optional safety check. If provided, the tool will fail unless exactly this many replacements are applied.",
+            },
+            expectedHash: {
+                type: "string",
+                description: "Optional SHA-256 hash of the current file content. Edit fails if the file changed since it was read.",
+            },
+        },
+        required: ["path", "oldText", "newText"],
+    },
+    riskLevel: "dangerous",
+    isReadOnly: false,
+    loadingTier: "always",
+    execute: executeEditFile,
+};
+const glob = {
+    name: "glob",
+    description: "Find files matching a glob pattern.",
+    category: "filesystem",
+    parameters: {
+        type: "object",
+        properties: {
+            pattern: {
+                type: "string",
+                description: 'Glob pattern to match (e.g., "**/*.ts")',
+            },
+            cwd: { type: "string", description: "Working directory for the pattern" },
+            ignore: {
+                type: "array",
+                items: { type: "string" },
+                description: "Patterns to ignore",
+            },
+        },
+        required: ["pattern"],
+    },
+    riskLevel: "safe",
+    isReadOnly: true,
+    loadingTier: "always",
+    execute: executeGlob,
+};
+const ls = {
+    name: "ls",
+    description: "List files and directories with a structured response including entries, depth/limit/offset/ignore, and truncated metadata.",
+    category: "filesystem",
+    parameters: {
+        type: "object",
+        properties: {
+            path: { type: "string", description: "Path to list", default: "." },
+            all: {
+                type: "boolean",
+                description: "Include hidden files",
+                default: false,
+            },
+            long: {
+                type: "boolean",
+                description: "Include detailed metadata when available (size, mode, mtimeMs, modifiedAt)",
+                default: false,
+            },
+            depth: {
+                type: "number",
+                description: "Recursion depth where 1 lists immediate children",
+            },
+            limit: {
+                type: "number",
+                description: "Maximum number of entries to return",
+            },
+            offset: {
+                type: "number",
+                description: "Number of entries to skip before returning results",
+            },
+            ignore: {
+                type: "array",
+                items: { type: "string" },
+                description: "Glob patterns to ignore while listing",
+            },
+        },
+        required: [],
+    },
+    riskLevel: "safe",
+    isReadOnly: true,
+    loadingTier: "always",
+    execute: executeLs,
+};
+// apply_patch: forked from OpenClaw (MIT) — includes fuzzy matching for robust patching.
+// Replaces the simple inline version with the full implementation from ./patch/.
+import { applyPatchTool } from "./patch/index.js";
+/** Filesystem tool definitions (6) — grep replaced by native indexed search in SEARCH_TOOL_DEFINITIONS */
+export const FILESYSTEM_TOOL_DEFINITIONS = [
+    read_file,
+    write_file,
+    edit_file,
+    glob,
+    ls,
+    applyPatchTool,
+];
+//# sourceMappingURL=filesystem.js.map

package/dist/definitions/frg.js

@@ -0,0 +1,64 @@
+import { z } from "zod";
+import { tool } from "../tool-factory.js";
+import { executeFrg } from "../executors/frg.js";
+export const frgTool = tool({
+    name: "frg",
+    description: "Native fastripgrep tool via napi-rs. Wraps the original frg commands in one tool: init, index, search, update, status, replace, man, completions, watch, and upgrade-safe metadata.",
+    category: "code",
+    riskLevel: "safe",
+    isReadOnly: false,
+    loadingTier: "always",
+    parameters: z.object({
+        command: z
+            .enum([
+            "init",
+            "index",
+            "search",
+            "update",
+            "status",
+            "replace",
+            "man",
+            "completions",
+            "watch",
+            "upgrade",
+        ])
+            .describe("Original frg command to run"),
+        pattern: z.string().optional().describe("Regex pattern for search/replace"),
+        replacement: z.string().optional().describe("Replacement string for replace"),
+        path: z
+            .string()
+            .optional()
+            .describe("Repository or directory to operate on (defaults to current working directory)"),
+        noIndex: z.boolean().optional().describe("Skip the index and do a brute-force scan for search"),
+        literal: z.boolean().optional().describe("Treat pattern as a fixed string"),
+        caseInsensitive: z.boolean().optional().describe("Enable case-insensitive matching"),
+        smartCase: z.boolean().optional().describe("Use smart-case matching"),
+        filesOnly: z.boolean().optional().describe("Return only file paths with matches"),
+        count: z.boolean().optional().describe("Return match counts per file"),
+        maxCount: z.number().optional().describe("Maximum matches per file"),
+        quiet: z.boolean().optional().describe("Only report whether a match exists"),
+        context: z.number().optional().describe("Context lines for search matches"),
+        json: z.boolean().optional().describe("Compatibility flag matching upstream JSON mode"),
+        glob: z.string().optional().describe("Glob filter for candidate files"),
+        fileType: z.string().optional().describe("File extension/type filter"),
+        follow: z.boolean().optional().describe("Follow symbolic links"),
+        extraPatterns: z
+            .array(z.string())
+            .optional()
+            .describe("Additional regex patterns combined with OR"),
+        maxFilesize: z
+            .number()
+            .optional()
+            .describe("Maximum file size in bytes while indexing/updating/init"),
+        force: z.boolean().optional().describe("Compatibility flag for forced rebuilds"),
+        write: z.boolean().optional().describe("Actually apply replace changes instead of previewing"),
+        hook: z.boolean().optional().describe("Install a post-commit git hook when using init"),
+        shell: z
+            .enum(["bash", "elvish", "fish", "powershell", "zsh"])
+            .optional()
+            .describe("Shell target when using completions"),
+    }),
+    execute: executeFrg,
+});
+export const FRG_TOOL_DEFINITIONS = [frgTool];
+//# sourceMappingURL=frg.js.map

package/{dist-cjs/definitions/index.d.ts → dist/definitions/index.js}

@@ -2,6 +2,7 @@
  * Tool definitions exports
  */
 export { CORE_TOOL_DEFINITIONS, getCoreTools, getCoreTool, getCoreToolsByCategory, getCoreToolsByRiskLevel, } from "./core.js";
+// Category-specific definition arrays
 export { MEMORY_TOOL_DEFINITIONS } from "./memory.js";
 export { WEB_TOOL_DEFINITIONS } from "./web.js";
 export { FILESYSTEM_TOOL_DEFINITIONS } from "./filesystem.js";
@@ -17,3 +18,4 @@ export { SESSION_HISTORY_TOOL_DEFINITIONS } from "./session-history.js";
 export { FRG_TOOL_DEFINITIONS } from "./frg.js";
 export { CODE_INTELLIGENCE_TOOL_DEFINITIONS } from "./code-intelligence.js";
 export { SEARCH_TOOL_DEFINITIONS } from "./search.js";
+//# sourceMappingURL=index.js.map

package/dist/definitions/memory.js

@@ -0,0 +1,124 @@
+/**
+ * Memory tool definitions
+ *
+ * Tools: remember, recall, forget, recall_knowledge, reflect (5 tools)
+ */
+import { executeRecall, executeForget, executeReflect, executeLearnLegacy, executeSearchKnowledge, } from "../executors/index.js";
+const remember = {
+    name: "remember",
+    description: "Store information in memory for later recall. Use this to save important facts, decisions, or context. (Deprecated — use learn instead)",
+    category: "memory",
+    parameters: {
+        type: "object",
+        properties: {
+            content: { type: "string", description: "The content to remember" },
+            importance: { type: "number", description: "Importance score from 0-1" },
+        },
+        required: ["content"],
+    },
+    riskLevel: "moderate",
+    isReadOnly: false,
+    loadingTier: "always",
+    execute: (input, ctx) => {
+        // Delegate to learn with content-only input
+        return executeLearnLegacy({ content: String(input.content ?? "") }, ctx);
+    },
+};
+const recall = {
+    name: "recall",
+    description: "Retrieve information from memory based on a query. Supports temporal queries to see what was known at a specific date.",
+    category: "memory",
+    parameters: {
+        type: "object",
+        properties: {
+            query: {
+                type: "string",
+                description: "The query to search for in memory",
+            },
+            limit: {
+                type: "number",
+                description: "Maximum number of results to return",
+                default: 10,
+            },
+            date: {
+                type: "string",
+                description: "ISO 8601 date string for temporal query — returns memories valid at this date. Example: '2026-01-15'",
+            },
+        },
+        required: ["query"],
+    },
+    riskLevel: "safe",
+    isReadOnly: true,
+    loadingTier: "always",
+    execute: executeRecall,
+};
+const forget = {
+    name: "forget",
+    description: "Remove information from memory. Use sparingly to clean up outdated or incorrect information.",
+    category: "memory",
+    parameters: {
+        type: "object",
+        properties: {
+            id: { type: "string", description: "ID of the memory to forget" },
+        },
+        required: ["id"],
+    },
+    riskLevel: "dangerous",
+    requiresConfirmation: true,
+    isReadOnly: false,
+    loadingTier: "always",
+    execute: executeForget,
+};
+const recallKnowledge = {
+    name: "recall_knowledge",
+    description: "Search for tools, skills, or both in memory, local skill files, and the web. (Deprecated — use search instead)",
+    category: "memory",
+    parameters: {
+        type: "object",
+        properties: {
+            topic: { type: "string", description: "Topic to search knowledge for" },
+            limit: {
+                type: "number",
+                description: "Maximum number of knowledge items to retrieve",
+                default: 10,
+            },
+            kind: {
+                type: "string",
+                enum: ["tool", "skill"],
+                description: "Kind of knowledge to filter by",
+            },
+        },
+        required: ["topic"],
+    },
+    riskLevel: "safe",
+    isReadOnly: true,
+    loadingTier: "always",
+    execute: (input, ctx) => {
+        // Delegate to search with query mapped from topic
+        return executeSearchKnowledge({ query: String(input.topic ?? ""), limit: input.limit }, ctx);
+    },
+};
+const reflect = {
+    name: "reflect",
+    description: "Reflect on the current conversation to identify genuine learnings about yourself — " +
+        "limitations, non-obvious strategies, user preferences, or blind spots. " +
+        "Use sparingly: most conversations teach nothing new.",
+    category: "memory",
+    parameters: {
+        type: "object",
+        properties: {
+            summary: {
+                type: "string",
+                description: "Summary of what happened in the conversation — what you did, what worked, what didn't",
+            },
+        },
+        required: ["summary"],
+    },
+    riskLevel: "moderate",
+    isReadOnly: false,
+    loadingTier: "always",
+    execute: executeReflect,
+};
+/** Memory tool definitions (5) */
+export const MEMORY_TOOL_DEFINITIONS = [remember, recall, forget, recallKnowledge, reflect];
+//# sourceMappingURL=memory.js.map