@aria-cli/tools 1.0.0

package/src/definitions/deploy.ts

@@ -0,0 +1,73 @@
+/**
+ * Deploy tool definition.
+ *
+ * Tools: deploy (1 tool)
+ *
+ * Deploys ARIA to a remote machine via SSH. Detects OS, installs Node.js + pnpm,
+ * clones/syncs repo, builds, sets up TLS certs, configures firewall, writes config,
+ * and starts the daemon.
+ *
+ * Safety: requires explicit user confirmation (dangerous risk level).
+ * Auto-denied in daemon autorun mode.
+ */
+
+import type { JSONSchema7 } from "json-schema";
+import type { Tool } from "../types.js";
+import { executeDeploy } from "../executors/index.js";
+
+const deploy: Tool = {
+  name: "deploy",
+  description:
+    "Deploy ARIA to a remote machine via SSH. Detects OS, installs Node.js + pnpm, " +
+    "clones/syncs repo, builds, discovers/provisions TLS certs, opens firewall ports, " +
+    "configures ~/.aria, and starts the daemon. Returns host, port, fingerprint, and TLS type.",
+  category: "arion",
+  parameters: {
+    type: "object",
+    properties: {
+      target: {
+        type: "string",
+        description: "SSH target (e.g. 'claude@10.0.0.1' or 'hostname')",
+      },
+      repo_url: {
+        type: "string",
+        description: "Git repo URL (default: current repo origin)",
+      },
+      branch: {
+        type: "string",
+        description: "Branch to deploy (default: main)",
+      },
+      arion_name: {
+        type: "string",
+        description: "Arion identity name (default: hostname of target)",
+      },
+      coordination_url: {
+        type: "string",
+        description: "Coordination server URL for mesh registration",
+      },
+      ssh_key_path: {
+        type: "string",
+        description: "Path to SSH private key (default: ~/.ssh/id_ed25519)",
+      },
+      commit_hash: {
+        type: "string",
+        description:
+          "Git commit hash to checkout after clone (pins exact code version, prevents MITM on branch refs)",
+      },
+      verify_signatures: {
+        type: "boolean",
+        description:
+          "Verify GPG signature on HEAD commit after checkout. Fails deploy if signature is invalid or missing.",
+      },
+    },
+    required: ["target"],
+  } as JSONSchema7,
+  riskLevel: "dangerous",
+  requiresConfirmation: true,
+  isReadOnly: false,
+  loadingTier: "always",
+  execute: executeDeploy,
+};
+
+/** Deploy tool definitions (1) */
+export const DEPLOY_TOOL_DEFINITIONS = [deploy];

package/src/definitions/filesystem.ts

@@ -0,0 +1,253 @@
+/**
+ * Filesystem tool definitions
+ *
+ * Tools: read_file, write_file, edit_file, glob, grep, ls, apply_patch (7 tools)
+ */
+
+import type { JSONSchema7 } from "json-schema";
+import type { Tool } from "../types.js";
+import {
+  executeReadFile,
+  executeWriteFile,
+  executeEditFile,
+  executeLs,
+  executeGlob,
+  executeGrep,
+} 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 grep: Tool = {
+  name: "grep",
+  description: "Search for patterns in files using regular expressions.",
+  category: "filesystem",
+  parameters: {
+    type: "object",
+    properties: {
+      pattern: {
+        type: "string",
+        description: "Regular expression pattern to search for",
+      },
+      path: {
+        type: "string",
+        description: "File or directory to search in",
+        default: ".",
+      },
+      glob: {
+        type: "string",
+        description: "Glob pattern to filter files when searching a directory",
+        default: "**/*",
+      },
+      ignoreCase: {
+        type: "boolean",
+        description: "Case-insensitive matching",
+        default: false,
+      },
+    },
+    required: ["pattern"],
+  } as JSONSchema7,
+  riskLevel: "safe",
+  isReadOnly: true,
+  loadingTier: "always",
+  execute: executeGrep,
+};
+
+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 (7) */
+export const FILESYSTEM_TOOL_DEFINITIONS: Tool[] = [
+  read_file,
+  write_file,
+  edit_file,
+  glob,
+  grep,
+  ls,
+  applyPatchTool,
+];

package/src/definitions/index.ts

@@ -0,0 +1,25 @@
+/**
+ * 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";

package/src/definitions/memory.ts

@@ -0,0 +1,150 @@
+/**
+ * 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];