@aria-cli/tools 1.0.12 → 1.0.14

package/dist/definitions/outlook.js

@@ -1,277 +0,0 @@
-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) {
-    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) {
-    try {
-        return JSON.parse(raw);
-    }
-    catch {
-        return { raw };
-    }
-}
-// PascalCase → camelCase field mapper for Outlook REST v2 responses
-function normalizeMessage(msg) {
-    const from = msg.From;
-    const emailAddr = from?.EmailAddress;
-    const toRaw = msg.ToRecipients;
-    const ccRaw = msg.CcRecipients;
-    const body = msg.Body;
-    const mapRecipient = (r) => {
-        const ea = r.EmailAddress;
-        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",
-    };
-}
-const check_outlook_messages = {
-    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: [],
-    },
-    riskLevel: "safe",
-    isReadOnly: true,
-    loadingTier: "always",
-    execute: async (input) => {
-        const typedInput = input;
-        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 && 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 = {
-    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"],
-    },
-    riskLevel: "dangerous",
-    requiresConfirmation: true,
-    isReadOnly: false,
-    loadingTier: "always",
-    execute: async (input) => {
-        const typedInput = input;
-        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 = {
-    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"],
-    },
-    riskLevel: "dangerous",
-    requiresConfirmation: true,
-    isReadOnly: false,
-    loadingTier: "always",
-    execute: async (input) => {
-        const typedInput = input;
-        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/dist/definitions/patch/apply-patch.js

@@ -1,184 +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 { parsePatchText, normalizeUnicodeSpaces } from "./patch-parser.js";
-import { applyUpdateHunk } from "./fuzzy-match.js";
-import { assertSandboxPath } from "./sandbox-paths.js";
-// ── Path Helpers ───────────────────────────────────────────────────
-function expandPath(filePath) {
-    const normalized = normalizeUnicodeSpaces(filePath);
-    if (normalized === "~") {
-        return os.homedir();
-    }
-    if (normalized.startsWith("~/")) {
-        return os.homedir() + normalized.slice(1);
-    }
-    return normalized;
-}
-function resolvePathFromCwd(filePath, cwd) {
-    const expanded = expandPath(filePath);
-    if (path.isAbsolute(expanded)) {
-        return path.normalize(expanded);
-    }
-    return path.resolve(cwd, expanded);
-}
-function toDisplayPath(resolved, cwd) {
-    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, cwd, purpose = "readWrite") {
-    const resolved = (await assertSandboxPath({
-        filePath,
-        cwd,
-        root: cwd,
-        allowFinalSymlink: purpose === "unlink",
-    })).resolved;
-    return {
-        resolved,
-        display: toDisplayPath(resolved, cwd),
-    };
-}
-// ── Summary Helpers ────────────────────────────────────────────────
-function recordSummary(summary, seen, bucket, value) {
-    if (seen[bucket].has(value)) {
-        return;
-    }
-    seen[bucket].add(value);
-    summary[bucket].push(value);
-}
-function formatSummary(summary) {
-    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) {
-    const parent = path.dirname(filePath);
-    if (!parent || parent === ".") {
-        return;
-    }
-    await fs.mkdir(parent, { recursive: true });
-}
-export async function applyPatch(input, options) {
-    const parsed = parsePatchText(input);
-    if (parsed.hunks.length === 0) {
-        return {
-            success: false,
-            summary: { added: [], modified: [], deleted: [] },
-            text: "No files were modified.",
-        };
-    }
-    const summary = {
-        added: [],
-        modified: [],
-        deleted: [],
-    };
-    const seen = {
-        added: new Set(),
-        modified: new Set(),
-        deleted: new Set(),
-    };
-    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 = {
-    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"],
-    },
-    riskLevel: "dangerous",
-    requiresConfirmation: true,
-    isReadOnly: false,
-    loadingTier: "always",
-    async execute(input, _context) {
-        const { patch, cwd } = input;
-        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}`,
-            };
-        }
-    },
-};

package/dist/definitions/patch/fuzzy-match.js

@@ -1,166 +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";
-async function defaultReadFile(filePath) {
-    return fs.readFile(filePath, "utf8");
-}
-export async function applyUpdateHunk(filePath, chunks, options) {
-    const reader = options?.readFile ?? defaultReadFile;
-    const originalContents = await reader(filePath).catch((err) => {
-        throw new Error(`Failed to read file to update ${filePath}: ${err}`);
-    });
-    const originalLines = originalContents.split("\n");
-    if (originalLines.length > 0 && originalLines[originalLines.length - 1] === "") {
-        originalLines.pop();
-    }
-    const replacements = computeReplacements(originalLines, filePath, chunks);
-    let newLines = applyReplacements(originalLines, replacements);
-    if (newLines.length === 0 || newLines[newLines.length - 1] !== "") {
-        newLines = [...newLines, ""];
-    }
-    return newLines.join("\n");
-}
-function computeReplacements(originalLines, filePath, chunks) {
-    const replacements = [];
-    let lineIndex = 0;
-    for (const chunk of chunks) {
-        if (chunk.changeContext) {
-            const ctxIndex = seekSequence(originalLines, [chunk.changeContext], lineIndex, false);
-            if (ctxIndex === null) {
-                throw new Error(`Failed to find context '${chunk.changeContext}' in ${filePath}`);
-            }
-            lineIndex = ctxIndex + 1;
-        }
-        if (chunk.oldLines.length === 0) {
-            const insertionIndex = originalLines.length > 0 && originalLines[originalLines.length - 1] === ""
-                ? originalLines.length - 1
-                : originalLines.length;
-            replacements.push([insertionIndex, 0, chunk.newLines]);
-            continue;
-        }
-        let pattern = chunk.oldLines;
-        let newSlice = chunk.newLines;
-        let found = seekSequence(originalLines, pattern, lineIndex, chunk.isEndOfFile);
-        if (found === null && pattern[pattern.length - 1] === "") {
-            pattern = pattern.slice(0, -1);
-            if (newSlice.length > 0 && newSlice[newSlice.length - 1] === "") {
-                newSlice = newSlice.slice(0, -1);
-            }
-            found = seekSequence(originalLines, pattern, lineIndex, chunk.isEndOfFile);
-        }
-        if (found === null) {
-            throw new Error(`Failed to find expected lines in ${filePath}:\n${chunk.oldLines.join("\n")}`);
-        }
-        replacements.push([found, pattern.length, newSlice]);
-        lineIndex = found + pattern.length;
-    }
-    replacements.sort((a, b) => a[0] - b[0]);
-    return replacements;
-}
-function applyReplacements(lines, replacements) {
-    const result = [...lines];
-    for (let rIdx = replacements.length - 1; rIdx >= 0; rIdx -= 1) {
-        const entry = replacements[rIdx];
-        const startIndex = entry[0];
-        const oldLen = entry[1];
-        const newLines = entry[2];
-        for (let i = 0; i < oldLen; i += 1) {
-            if (startIndex < result.length) {
-                result.splice(startIndex, 1);
-            }
-        }
-        for (let i = 0; i < newLines.length; i += 1) {
-            result.splice(startIndex + i, 0, newLines[i]);
-        }
-    }
-    return result;
-}
-function seekSequence(lines, pattern, start, eof) {
-    if (pattern.length === 0) {
-        return start;
-    }
-    if (pattern.length > lines.length) {
-        return null;
-    }
-    const maxStart = lines.length - pattern.length;
-    const searchStart = eof && lines.length >= pattern.length ? maxStart : start;
-    if (searchStart > maxStart) {
-        return null;
-    }
-    // Pass 1: exact match
-    for (let i = searchStart; i <= maxStart; i += 1) {
-        if (linesMatch(lines, pattern, i, (value) => value)) {
-            return i;
-        }
-    }
-    // Pass 2: trim trailing whitespace
-    for (let i = searchStart; i <= maxStart; i += 1) {
-        if (linesMatch(lines, pattern, i, (value) => value.trimEnd())) {
-            return i;
-        }
-    }
-    // Pass 3: trim all whitespace
-    for (let i = searchStart; i <= maxStart; i += 1) {
-        if (linesMatch(lines, pattern, i, (value) => value.trim())) {
-            return i;
-        }
-    }
-    // Pass 4: normalize punctuation + trim
-    for (let i = searchStart; i <= maxStart; i += 1) {
-        if (linesMatch(lines, pattern, i, (value) => normalizePunctuation(value.trim()))) {
-            return i;
-        }
-    }
-    return null;
-}
-function linesMatch(lines, pattern, start, normalize) {
-    for (let idx = 0; idx < pattern.length; idx += 1) {
-        if (normalize(lines[start + idx]) !== normalize(pattern[idx])) {
-            return false;
-        }
-    }
-    return true;
-}
-function normalizePunctuation(value) {
-    return Array.from(value)
-        .map((char) => {
-        switch (char) {
-            case "\u2010":
-            case "\u2011":
-            case "\u2012":
-            case "\u2013":
-            case "\u2014":
-            case "\u2015":
-            case "\u2212":
-                return "-";
-            case "\u2018":
-            case "\u2019":
-            case "\u201A":
-            case "\u201B":
-                return "'";
-            case "\u201C":
-            case "\u201D":
-            case "\u201E":
-            case "\u201F":
-                return '"';
-            case "\u00A0":
-            case "\u2002":
-            case "\u2003":
-            case "\u2004":
-            case "\u2005":
-            case "\u2006":
-            case "\u2007":
-            case "\u2008":
-            case "\u2009":
-            case "\u200A":
-            case "\u202F":
-            case "\u205F":
-            case "\u3000":
-                return " ";
-            default:
-                return char;
-        }
-    })
-        .join("");
-}

package/dist/definitions/patch/index.js

@@ -1 +0,0 @@
-export { applyPatchTool } from "./apply-patch.js";