@aria-cli/tools 1.0.0

package/src/definitions/outlook.ts

@@ -0,0 +1,318 @@
+import type { JSONSchema7 } from "json-schema";
+import type { Tool } from "../types.js";
+import { execFile } from "node:child_process";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+const OUTLOOK_PY = join(homedir(), ".aria", "tools", "outlook.py");
+
+function runOutlook(args: string[]): Promise<string> {
+  return new Promise((resolve, reject) => {
+    execFile(OUTLOOK_PY, args, { timeout: 30_000 }, (err, stdout, stderr) => {
+      if (err) {
+        reject(new Error(stderr?.trim() || err.message));
+      } else {
+        resolve(stdout);
+      }
+    });
+  });
+}
+
+function parseJson(raw: string): Record<string, unknown> {
+  try {
+    return JSON.parse(raw) as Record<string, unknown>;
+  } catch {
+    return { raw };
+  }
+}
+
+// PascalCase → camelCase field mapper for Outlook REST v2 responses
+function normalizeMessage(msg: Record<string, unknown>): Record<string, unknown> {
+  const from = msg.From as Record<string, unknown> | undefined;
+  const emailAddr = from?.EmailAddress as Record<string, unknown> | undefined;
+  const toRaw = msg.ToRecipients as Array<Record<string, unknown>> | undefined;
+  const ccRaw = msg.CcRecipients as Array<Record<string, unknown>> | undefined;
+  const body = msg.Body as Record<string, unknown> | undefined;
+
+  const mapRecipient = (r: Record<string, unknown>) => {
+    const ea = r.EmailAddress as Record<string, unknown> | undefined;
+    return { name: ea?.Name ?? "", email: ea?.Address ?? "" };
+  };
+
+  return {
+    id: msg.Id ?? msg.id ?? "",
+    subject: msg.Subject ?? msg.subject ?? "",
+    from: emailAddr
+      ? { name: emailAddr.Name ?? "", email: emailAddr.Address ?? "" }
+      : { name: "", email: "" },
+    toRecipients: toRaw?.map(mapRecipient) ?? [],
+    receivedDateTime: msg.ReceivedDateTime ?? msg.receivedDateTime ?? "",
+    isRead: msg.IsRead ?? msg.isRead ?? false,
+    hasAttachments: msg.HasAttachments ?? msg.hasAttachments ?? false,
+    bodyPreview: msg.BodyPreview ?? msg.bodyPreview ?? "",
+    conversationId: msg.ConversationId ?? msg.conversationId ?? "",
+    ...(body
+      ? {
+          body: {
+            contentType: body.ContentType ?? body.contentType ?? "text",
+            content: body.Content ?? body.content ?? "",
+          },
+        }
+      : {}),
+    ...(ccRaw ? { ccRecipients: ccRaw.map(mapRecipient) } : {}),
+    importance: msg.Importance ?? msg.importance ?? "normal",
+  };
+}
+
+type CheckOutlookMessagesInput = {
+  folder?: string;
+  limit?: number;
+  filter?: string;
+  search?: string;
+  messageId?: string;
+};
+
+type SendOutlookMessageInput = {
+  to?: string | string[];
+  cc?: string | string[];
+  subject?: string;
+  body?: string;
+  bodyType?: "text" | "html";
+};
+
+type ReplyOutlookMessageInput = {
+  messageId?: string;
+  body?: string;
+  bodyType?: "text" | "html";
+  replyAll?: boolean;
+};
+
+const check_outlook_messages: Tool = {
+  name: "check_outlook_messages",
+  description:
+    "Read or search Outlook emails using the local Microsoft Office desktop session on this machine. " +
+    "Can list inbox messages, filter by read status, search by keyword, or retrieve a specific message by ID.",
+  category: "messaging",
+  parameters: {
+    type: "object",
+    properties: {
+      folder: {
+        type: "string",
+        description:
+          'Mail folder to read from (default "inbox"). Common values: inbox, drafts, sentitems, deleteditems.',
+        default: "inbox",
+      },
+      limit: {
+        type: "number",
+        description: "Maximum number of messages to return (default 20, max 50).",
+        default: 20,
+      },
+      filter: {
+        type: "string",
+        description:
+          'OData filter expression, e.g. "isRead eq false" or "from/emailAddress/address eq \'alice@example.com\'".',
+      },
+      search: {
+        type: "string",
+        description:
+          "KQL search query to find messages by keyword across subject, body, and participants.",
+      },
+      messageId: {
+        type: "string",
+        description:
+          "Optional message ID. When provided, returns the full message detail instead of a list.",
+      },
+    },
+    required: [],
+  } as JSONSchema7,
+  riskLevel: "safe",
+  isReadOnly: true,
+  loadingTier: "always",
+  execute: async (input: unknown) => {
+    const typedInput = input as CheckOutlookMessagesInput;
+    try {
+      if (typeof typedInput.messageId === "string" && typedInput.messageId) {
+        const raw = await runOutlook(["read", typedInput.messageId]);
+        const msg = normalizeMessage(parseJson(raw));
+        return {
+          success: true,
+          message: `Fetched Outlook message: ${msg.subject}`,
+          data: msg,
+        };
+      }
+
+      const args = ["check"];
+      const folder = typeof typedInput.folder === "string" ? typedInput.folder : "inbox";
+      args.push("--folder", folder);
+      args.push("--limit", String(typeof typedInput.limit === "number" ? typedInput.limit : 20));
+      if (typeof typedInput.filter === "string") args.push("--filter", typedInput.filter);
+      if (typeof typedInput.search === "string") args.push("--search", typedInput.search);
+
+      const raw = await runOutlook(args);
+      const json = parseJson(raw);
+      const rawMessages = Array.isArray(json.value) ? json.value : [];
+      const messages = rawMessages
+        .filter((m): m is Record<string, unknown> => !!m && typeof m === "object")
+        .map(normalizeMessage);
+
+      return {
+        success: true,
+        message: `Fetched ${messages.length} Outlook messages from ${folder}.`,
+        data: { accountEmail: "hole@axon.com", folder, messages, totalCount: messages.length },
+      };
+    } catch (error) {
+      return {
+        success: false,
+        message: error instanceof Error ? error.message : "Outlook read failed.",
+      };
+    }
+  },
+};
+
+const send_outlook_message: Tool = {
+  name: "send_outlook_message",
+  description:
+    "Send an email through the local Microsoft Office desktop session on this machine. " +
+    "Requires confirmation because it sends externally.",
+  category: "messaging",
+  parameters: {
+    type: "object",
+    properties: {
+      to: {
+        oneOf: [{ type: "string" }, { type: "array", items: { type: "string" } }],
+        description: "Recipient email address(es).",
+      },
+      cc: {
+        oneOf: [{ type: "string" }, { type: "array", items: { type: "string" } }],
+        description: "CC email address(es).",
+      },
+      subject: {
+        type: "string",
+        description: "Email subject line.",
+      },
+      body: {
+        type: "string",
+        description: "Email body content.",
+      },
+      bodyType: {
+        type: "string",
+        enum: ["text", "html"],
+        description: 'Body content type (default "text").',
+        default: "text",
+      },
+    },
+    required: ["to", "subject", "body"],
+  } as JSONSchema7,
+  riskLevel: "dangerous",
+  requiresConfirmation: true,
+  isReadOnly: false,
+  loadingTier: "always",
+  execute: async (input: unknown) => {
+    const typedInput = input as SendOutlookMessageInput;
+    try {
+      const toArray = Array.isArray(typedInput.to)
+        ? typedInput.to
+        : typeof typedInput.to === "string"
+          ? [typedInput.to]
+          : [];
+
+      const args = [
+        "send",
+        "--to",
+        toArray.join(","),
+        "--subject",
+        String(typedInput.subject ?? ""),
+        "--body",
+        String(typedInput.body ?? ""),
+      ];
+
+      if (typedInput.cc) {
+        const ccArray = Array.isArray(typedInput.cc) ? typedInput.cc : [typedInput.cc];
+        args.push("--cc", ccArray.join(","));
+      }
+      if (typedInput.bodyType === "html") args.push("--html");
+
+      await runOutlook(args);
+
+      return {
+        success: true,
+        message: `Sent email to ${toArray.join(", ")}.`,
+        data: { status: "sent" },
+      };
+    } catch (error) {
+      return {
+        success: false,
+        message: error instanceof Error ? error.message : "Outlook send failed.",
+      };
+    }
+  },
+};
+
+const reply_outlook_message: Tool = {
+  name: "reply_outlook_message",
+  description:
+    "Reply to an Outlook email thread using the local Microsoft Office desktop session on this machine. " +
+    "Requires confirmation because it sends externally.",
+  category: "messaging",
+  parameters: {
+    type: "object",
+    properties: {
+      messageId: {
+        type: "string",
+        description: "The ID of the message to reply to.",
+      },
+      body: {
+        type: "string",
+        description: "Reply body content.",
+      },
+      bodyType: {
+        type: "string",
+        enum: ["text", "html"],
+        description: 'Body content type (default "text").',
+        default: "text",
+      },
+      replyAll: {
+        type: "boolean",
+        description: "Whether to reply to all recipients (default false — reply to sender only).",
+        default: false,
+      },
+    },
+    required: ["messageId", "body"],
+  } as JSONSchema7,
+  riskLevel: "dangerous",
+  requiresConfirmation: true,
+  isReadOnly: false,
+  loadingTier: "always",
+  execute: async (input: unknown) => {
+    const typedInput = input as ReplyOutlookMessageInput;
+    try {
+      const args = [
+        "reply",
+        String(typedInput.messageId ?? ""),
+        "--body",
+        String(typedInput.body ?? ""),
+      ];
+      if (typedInput.replyAll) args.push("--reply-all");
+      if (typedInput.bodyType === "html") args.push("--html");
+
+      await runOutlook(args);
+
+      return {
+        success: true,
+        message: "Replied to message.",
+        data: { status: "sent" },
+      };
+    } catch (error) {
+      return {
+        success: false,
+        message: error instanceof Error ? error.message : "Outlook reply failed.",
+      };
+    }
+  },
+};
+
+export const OUTLOOK_TOOL_DEFINITIONS = [
+  check_outlook_messages,
+  send_outlook_message,
+  reply_outlook_message,
+];

package/src/definitions/patch/apply-patch.ts

@@ -0,0 +1,235 @@
+// 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
+
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import type { JSONSchema7 } from "json-schema";
+import type { Tool } from "../../types.js";
+import { parsePatchText, normalizeUnicodeSpaces } from "./patch-parser.js";
+import type { Hunk, ApplyPatchSummary } from "./patch-parser.js";
+import { applyUpdateHunk } from "./fuzzy-match.js";
+import { assertSandboxPath } from "./sandbox-paths.js";
+
+// ── Path Helpers ───────────────────────────────────────────────────
+
+function expandPath(filePath: string): string {
+  const normalized = normalizeUnicodeSpaces(filePath);
+  if (normalized === "~") {
+    return os.homedir();
+  }
+  if (normalized.startsWith("~/")) {
+    return os.homedir() + normalized.slice(1);
+  }
+  return normalized;
+}
+
+function resolvePathFromCwd(filePath: string, cwd: string): string {
+  const expanded = expandPath(filePath);
+  if (path.isAbsolute(expanded)) {
+    return path.normalize(expanded);
+  }
+  return path.resolve(cwd, expanded);
+}
+
+function toDisplayPath(resolved: string, cwd: string): string {
+  const relative = path.relative(cwd, resolved);
+  if (!relative || relative === "") {
+    return path.basename(resolved);
+  }
+  if (relative.startsWith("..") || path.isAbsolute(relative)) {
+    return resolved;
+  }
+  return relative;
+}
+
+// ── Path Resolution with Sandbox Validation ────────────────────────
+
+async function resolvePatchPath(
+  filePath: string,
+  cwd: string,
+  purpose: "readWrite" | "unlink" = "readWrite",
+): Promise<{ resolved: string; display: string }> {
+  const resolved = (
+    await assertSandboxPath({
+      filePath,
+      cwd,
+      root: cwd,
+      allowFinalSymlink: purpose === "unlink",
+    })
+  ).resolved;
+  return {
+    resolved,
+    display: toDisplayPath(resolved, cwd),
+  };
+}
+
+// ── Summary Helpers ────────────────────────────────────────────────
+
+function recordSummary(
+  summary: ApplyPatchSummary,
+  seen: {
+    added: Set<string>;
+    modified: Set<string>;
+    deleted: Set<string>;
+  },
+  bucket: keyof ApplyPatchSummary,
+  value: string,
+) {
+  if (seen[bucket].has(value)) {
+    return;
+  }
+  seen[bucket].add(value);
+  summary[bucket].push(value);
+}
+
+function formatSummary(summary: ApplyPatchSummary): string {
+  const lines = ["Success. Updated the following files:"];
+  for (const file of summary.added) {
+    lines.push(`A ${file}`);
+  }
+  for (const file of summary.modified) {
+    lines.push(`M ${file}`);
+  }
+  for (const file of summary.deleted) {
+    lines.push(`D ${file}`);
+  }
+  return lines.join("\n");
+}
+
+// ── Directory Helper ───────────────────────────────────────────────
+
+async function ensureDir(filePath: string) {
+  const parent = path.dirname(filePath);
+  if (!parent || parent === ".") {
+    return;
+  }
+  await fs.mkdir(parent, { recursive: true });
+}
+
+// ── Core Orchestrator ──────────────────────────────────────────────
+
+export type ApplyPatchResult = {
+  success: boolean;
+  summary: ApplyPatchSummary;
+  text: string;
+};
+
+export async function applyPatch(
+  input: string,
+  options: { cwd: string },
+): Promise<ApplyPatchResult> {
+  const parsed = parsePatchText(input);
+  if (parsed.hunks.length === 0) {
+    return {
+      success: false,
+      summary: { added: [], modified: [], deleted: [] },
+      text: "No files were modified.",
+    };
+  }
+
+  const summary: ApplyPatchSummary = {
+    added: [],
+    modified: [],
+    deleted: [],
+  };
+  const seen = {
+    added: new Set<string>(),
+    modified: new Set<string>(),
+    deleted: new Set<string>(),
+  };
+
+  for (const hunk of parsed.hunks) {
+    if (hunk.kind === "add") {
+      const target = await resolvePatchPath(hunk.path, options.cwd);
+      await ensureDir(target.resolved);
+      await fs.writeFile(target.resolved, hunk.contents, "utf8");
+      recordSummary(summary, seen, "added", target.display);
+      continue;
+    }
+
+    if (hunk.kind === "delete") {
+      const target = await resolvePatchPath(hunk.path, options.cwd, "unlink");
+      await fs.rm(target.resolved);
+      recordSummary(summary, seen, "deleted", target.display);
+      continue;
+    }
+
+    // hunk.kind === "update"
+    const target = await resolvePatchPath(hunk.path, options.cwd);
+    const applied = await applyUpdateHunk(target.resolved, hunk.chunks, {
+      readFile: (p) => fs.readFile(p, "utf8"),
+    });
+
+    if (hunk.movePath) {
+      const moveTarget = await resolvePatchPath(hunk.movePath, options.cwd);
+      await ensureDir(moveTarget.resolved);
+      await fs.writeFile(moveTarget.resolved, applied, "utf8");
+      await fs.rm(target.resolved);
+      recordSummary(summary, seen, "modified", moveTarget.display);
+    } else {
+      await fs.writeFile(target.resolved, applied, "utf8");
+      recordSummary(summary, seen, "modified", target.display);
+    }
+  }
+
+  return {
+    success: true,
+    summary,
+    text: formatSummary(summary),
+  };
+}
+
+// ── ARIA Tool Definition ───────────────────────────────────────────
+
+export const applyPatchTool: Tool = {
+  name: "apply_patch",
+  description:
+    "Apply a patch to files using a structured format. Supports adding, deleting, updating, and renaming files with fuzzy line matching for resilient text replacement.",
+  category: "filesystem",
+  parameters: {
+    type: "object",
+    properties: {
+      patch: {
+        type: "string",
+        description: "The patch text in *** Begin Patch / *** End Patch format",
+      },
+      cwd: {
+        type: "string",
+        description: "Working directory for relative paths (defaults to process.cwd())",
+      },
+    },
+    required: ["patch"],
+  } as JSONSchema7,
+  riskLevel: "dangerous",
+  requiresConfirmation: true,
+  isReadOnly: false,
+  loadingTier: "always",
+  async execute(input, _context) {
+    const { patch, cwd } = input as { patch: string; cwd?: string };
+
+    if (!patch || patch.trim() === "") {
+      return {
+        success: false,
+        message: "Patch content is empty.",
+      };
+    }
+
+    try {
+      const result = await applyPatch(patch, {
+        cwd: cwd ?? process.cwd(),
+      });
+      return {
+        success: result.success,
+        message: result.text,
+      };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return {
+        success: false,
+        message: `apply_patch failed: ${message}`,
+      };
+    }
+  },
+};