@aria-cli/tools 1.0.9 → 1.0.11

package/src/definitions/filesystem.ts

@@ -1,217 +0,0 @@
-/**
- * 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 type { JSONSchema7 } from "json-schema";
-import type { Tool } from "../types.js";
-import {
-  executeReadFile,
-  executeWriteFile,
-  executeEditFile,
-  executeLs,
-  executeGlob,
-} from "../executors/index.js";
-
-const read_file: Tool = {
-  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"],
-  } as JSONSchema7,
-  riskLevel: "safe",
-  isReadOnly: true,
-  loadingTier: "always",
-  execute: executeReadFile,
-};
-
-const write_file: Tool = {
-  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"],
-  } as JSONSchema7,
-  riskLevel: "dangerous",
-  isReadOnly: false,
-  loadingTier: "always",
-  execute: executeWriteFile,
-};
-
-const edit_file: Tool = {
-  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"],
-  } as JSONSchema7,
-  riskLevel: "dangerous",
-  isReadOnly: false,
-  loadingTier: "always",
-  execute: executeEditFile,
-};
-
-const glob: Tool = {
-  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"],
-  } as JSONSchema7,
-  riskLevel: "safe",
-  isReadOnly: true,
-  loadingTier: "always",
-  execute: executeGlob,
-};
-
-const ls: Tool = {
-  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: [],
-  } as JSONSchema7,
-  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: Tool[] = [
-  read_file,
-  write_file,
-  edit_file,
-  glob,
-  ls,
-  applyPatchTool,
-];

package/src/definitions/frg.ts

@@ -1,67 +0,0 @@
-import { z } from "zod";
-import type { Tool } from "../types.js";
-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: Tool[] = [frgTool];

package/src/definitions/index.ts

@@ -1,28 +0,0 @@
-/**
- * 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";
-export { SHELL_TOOL_DEFINITIONS } from "./shell.js";
-export { ARION_TOOL_DEFINITIONS } from "./arion.js";
-export { DELEGATION_TOOL_DEFINITIONS } from "./delegation.js";
-export { MESSAGING_TOOL_DEFINITIONS } from "./messaging.js";
-export { SLACK_TOOL_DEFINITIONS } from "./slack.js";
-export { QUIP_TOOL_DEFINITIONS } from "./quip.js";
-export { NETWORK_TOOL_DEFINITIONS } from "./network.js";
-export { META_TOOL_DEFINITIONS } from "./meta.js";
-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";

package/src/definitions/memory.ts

@@ -1,150 +0,0 @@
-/**
- * Memory tool definitions
- *
- * Tools: remember, recall, forget, recall_knowledge, reflect (5 tools)
- */
-
-import type { JSONSchema7 } from "json-schema";
-import type { Tool, ToolContext, ToolResult } from "../types.js";
-import {
-  executeRemember,
-  executeRecall,
-  executeForget,
-  executeDiscover,
-  executeReflect,
-  executeLearnLegacy,
-  executeSearchKnowledge,
-} from "../executors/index.js";
-
-const remember: Tool = {
-  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"],
-  } as JSONSchema7,
-  riskLevel: "moderate",
-  isReadOnly: false,
-  loadingTier: "always",
-  execute: (input: Record<string, unknown>, ctx: ToolContext): Promise<ToolResult> => {
-    // Delegate to learn with content-only input
-    return executeLearnLegacy({ content: String(input.content ?? "") }, ctx);
-  },
-};
-
-const recall: Tool = {
-  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"],
-  } as JSONSchema7,
-  riskLevel: "safe",
-  isReadOnly: true,
-  loadingTier: "always",
-  execute: executeRecall,
-};
-
-const forget: Tool = {
-  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"],
-  } as JSONSchema7,
-  riskLevel: "dangerous",
-  requiresConfirmation: true,
-  isReadOnly: false,
-  loadingTier: "always",
-  execute: executeForget,
-};
-
-const recallKnowledge: Tool = {
-  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"],
-  } as JSONSchema7,
-  riskLevel: "safe",
-  isReadOnly: true,
-  loadingTier: "always",
-  execute: (input: Record<string, unknown>, ctx: ToolContext): Promise<ToolResult> => {
-    // Delegate to search with query mapped from topic
-    return executeSearchKnowledge(
-      { query: String(input.topic ?? ""), limit: input.limit as number | undefined },
-      ctx,
-    );
-  },
-};
-
-const reflect: Tool = {
-  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"],
-  } as JSONSchema7,
-  riskLevel: "moderate",
-  isReadOnly: false,
-  loadingTier: "always",
-  execute: executeReflect,
-};
-
-/** Memory tool definitions (5) */
-export const MEMORY_TOOL_DEFINITIONS: Tool[] = [remember, recall, forget, recallKnowledge, reflect];