@aria-cli/tools 1.0.19 → 1.0.31

package/dist-cjs/definitions/outlook.js

@@ -0,0 +1,281 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OUTLOOK_TOOL_DEFINITIONS = void 0;
+const node_child_process_1 = require("node:child_process");
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+const OUTLOOK_PY = (0, node_path_1.join)((0, node_os_1.homedir)(), ".aria", "tools", "outlook.py");
+function runOutlook(args) {
+    return new Promise((resolve, reject) => {
+        (0, node_child_process_1.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.",
+            };
+        }
+    },
+};
+exports.OUTLOOK_TOOL_DEFINITIONS = [
+    check_outlook_messages,
+    send_outlook_message,
+    reply_outlook_message,
+];
+//# sourceMappingURL=outlook.js.map

package/dist-cjs/definitions/patch/apply-patch.js

@@ -0,0 +1,192 @@
+"use strict";
+// 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
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyPatchTool = void 0;
+exports.applyPatch = applyPatch;
+const promises_1 = __importDefault(require("node:fs/promises"));
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const patch_parser_js_1 = require("./patch-parser.js");
+const fuzzy_match_js_1 = require("./fuzzy-match.js");
+const sandbox_paths_js_1 = require("./sandbox-paths.js");
+// ── Path Helpers ───────────────────────────────────────────────────
+function expandPath(filePath) {
+    const normalized = (0, patch_parser_js_1.normalizeUnicodeSpaces)(filePath);
+    if (normalized === "~") {
+        return node_os_1.default.homedir();
+    }
+    if (normalized.startsWith("~/")) {
+        return node_os_1.default.homedir() + normalized.slice(1);
+    }
+    return normalized;
+}
+function resolvePathFromCwd(filePath, cwd) {
+    const expanded = expandPath(filePath);
+    if (node_path_1.default.isAbsolute(expanded)) {
+        return node_path_1.default.normalize(expanded);
+    }
+    return node_path_1.default.resolve(cwd, expanded);
+}
+function toDisplayPath(resolved, cwd) {
+    const relative = node_path_1.default.relative(cwd, resolved);
+    if (!relative || relative === "") {
+        return node_path_1.default.basename(resolved);
+    }
+    if (relative.startsWith("..") || node_path_1.default.isAbsolute(relative)) {
+        return resolved;
+    }
+    return relative;
+}
+// ── Path Resolution with Sandbox Validation ────────────────────────
+async function resolvePatchPath(filePath, cwd, purpose = "readWrite") {
+    const resolved = (await (0, sandbox_paths_js_1.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 = node_path_1.default.dirname(filePath);
+    if (!parent || parent === ".") {
+        return;
+    }
+    await promises_1.default.mkdir(parent, { recursive: true });
+}
+async function applyPatch(input, options) {
+    const parsed = (0, patch_parser_js_1.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 promises_1.default.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 promises_1.default.rm(target.resolved);
+            recordSummary(summary, seen, "deleted", target.display);
+            continue;
+        }
+        // hunk.kind === "update"
+        const target = await resolvePatchPath(hunk.path, options.cwd);
+        const applied = await (0, fuzzy_match_js_1.applyUpdateHunk)(target.resolved, hunk.chunks, {
+            readFile: (p) => promises_1.default.readFile(p, "utf8"),
+        });
+        if (hunk.movePath) {
+            const moveTarget = await resolvePatchPath(hunk.movePath, options.cwd);
+            await ensureDir(moveTarget.resolved);
+            await promises_1.default.writeFile(moveTarget.resolved, applied, "utf8");
+            await promises_1.default.rm(target.resolved);
+            recordSummary(summary, seen, "modified", moveTarget.display);
+        }
+        else {
+            await promises_1.default.writeFile(target.resolved, applied, "utf8");
+            recordSummary(summary, seen, "modified", target.display);
+        }
+    }
+    return {
+        success: true,
+        summary,
+        text: formatSummary(summary),
+    };
+}
+// ── ARIA Tool Definition ───────────────────────────────────────────
+exports.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}`,
+            };
+        }
+    },
+};
+//# sourceMappingURL=apply-patch.js.map

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

@@ -0,0 +1,173 @@
+"use strict";
+// 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
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyUpdateHunk = applyUpdateHunk;
+const promises_1 = __importDefault(require("node:fs/promises"));
+async function defaultReadFile(filePath) {
+    return promises_1.default.readFile(filePath, "utf8");
+}
+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("");
+}
+//# sourceMappingURL=fuzzy-match.js.map

package/dist-cjs/definitions/patch/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyPatchTool = void 0;
+var apply_patch_js_1 = require("./apply-patch.js");
+Object.defineProperty(exports, "applyPatchTool", { enumerable: true, get: function () { return apply_patch_js_1.applyPatchTool; } });
+//# sourceMappingURL=index.js.map