@aria-cli/tools 1.0.8 → 1.0.10

package/src/definitions/outlook.ts

@@ -1,318 +0,0 @@
-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

@@ -1,235 +0,0 @@
-// 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}`,
-      };
-    }
-  },
-};