@aria-cli/tools 1.0.0

package/src/definitions/process/pty-keys.ts

@@ -0,0 +1,298 @@
+// Originally from OpenClaw (MIT License, Copyright 2025 Peter Steinberger)
+// https://github.com/openclaw/openclaw
+// Modified for ARIA — stripped OpenClaw runtime, inlined escapeRegExp
+
+const ESC = "\x1b";
+const CR = "\r";
+const TAB = "\t";
+const BACKSPACE = "\x7f";
+
+export const BRACKETED_PASTE_START = `${ESC}[200~`;
+export const BRACKETED_PASTE_END = `${ESC}[201~`;
+
+type Modifiers = {
+  ctrl: boolean;
+  alt: boolean;
+  shift: boolean;
+};
+
+const namedKeyMap = new Map<string, string>([
+  ["enter", CR],
+  ["return", CR],
+  ["tab", TAB],
+  ["escape", ESC],
+  ["esc", ESC],
+  ["space", " "],
+  ["bspace", BACKSPACE],
+  ["backspace", BACKSPACE],
+  ["up", `${ESC}[A`],
+  ["down", `${ESC}[B`],
+  ["right", `${ESC}[C`],
+  ["left", `${ESC}[D`],
+  ["home", `${ESC}[1~`],
+  ["end", `${ESC}[4~`],
+  ["pageup", `${ESC}[5~`],
+  ["pgup", `${ESC}[5~`],
+  ["ppage", `${ESC}[5~`],
+  ["pagedown", `${ESC}[6~`],
+  ["pgdn", `${ESC}[6~`],
+  ["npage", `${ESC}[6~`],
+  ["insert", `${ESC}[2~`],
+  ["ic", `${ESC}[2~`],
+  ["delete", `${ESC}[3~`],
+  ["del", `${ESC}[3~`],
+  ["dc", `${ESC}[3~`],
+  ["btab", `${ESC}[Z`],
+  ["f1", `${ESC}OP`],
+  ["f2", `${ESC}OQ`],
+  ["f3", `${ESC}OR`],
+  ["f4", `${ESC}OS`],
+  ["f5", `${ESC}[15~`],
+  ["f6", `${ESC}[17~`],
+  ["f7", `${ESC}[18~`],
+  ["f8", `${ESC}[19~`],
+  ["f9", `${ESC}[20~`],
+  ["f10", `${ESC}[21~`],
+  ["f11", `${ESC}[23~`],
+  ["f12", `${ESC}[24~`],
+  ["kp/", `${ESC}Oo`],
+  ["kp*", `${ESC}Oj`],
+  ["kp-", `${ESC}Om`],
+  ["kp+", `${ESC}Ok`],
+  ["kp7", `${ESC}Ow`],
+  ["kp8", `${ESC}Ox`],
+  ["kp9", `${ESC}Oy`],
+  ["kp4", `${ESC}Ot`],
+  ["kp5", `${ESC}Ou`],
+  ["kp6", `${ESC}Ov`],
+  ["kp1", `${ESC}Oq`],
+  ["kp2", `${ESC}Or`],
+  ["kp3", `${ESC}Os`],
+  ["kp0", `${ESC}Op`],
+  ["kp.", `${ESC}On`],
+  ["kpenter", `${ESC}OM`],
+]);
+
+const modifiableNamedKeys = new Set([
+  "up",
+  "down",
+  "left",
+  "right",
+  "home",
+  "end",
+  "pageup",
+  "pgup",
+  "ppage",
+  "pagedown",
+  "pgdn",
+  "npage",
+  "insert",
+  "ic",
+  "delete",
+  "del",
+  "dc",
+]);
+
+export type KeyEncodingRequest = {
+  keys?: string[];
+  hex?: string[];
+  literal?: string;
+};
+
+export type KeyEncodingResult = {
+  data: string;
+  warnings: string[];
+};
+
+export function encodeKeySequence(request: KeyEncodingRequest): KeyEncodingResult {
+  const warnings: string[] = [];
+  let data = "";
+
+  if (request.literal) {
+    data += request.literal;
+  }
+
+  if (request.hex?.length) {
+    for (const raw of request.hex) {
+      const byte = parseHexByte(raw);
+      if (byte === null) {
+        warnings.push(`Invalid hex byte: ${raw}`);
+        continue;
+      }
+      data += String.fromCharCode(byte);
+    }
+  }
+
+  if (request.keys?.length) {
+    for (const token of request.keys) {
+      data += encodeKeyToken(token, warnings);
+    }
+  }
+
+  return { data, warnings };
+}
+
+export function encodePaste(text: string, bracketed = true): string {
+  if (!bracketed) {
+    return text;
+  }
+  return `${BRACKETED_PASTE_START}${text}${BRACKETED_PASTE_END}`;
+}
+
+function encodeKeyToken(raw: string, warnings: string[]): string {
+  const token = raw.trim();
+  if (!token) {
+    return "";
+  }
+
+  if (token.length === 2 && token.startsWith("^")) {
+    const ctrl = toCtrlChar(token[1]!);
+    if (ctrl) {
+      return ctrl;
+    }
+  }
+
+  const parsed = parseModifiers(token);
+  const base = parsed.base;
+  const baseLower = base.toLowerCase();
+
+  if (baseLower === "tab" && parsed.mods.shift) {
+    return `${ESC}[Z`;
+  }
+
+  const baseSeq = namedKeyMap.get(baseLower);
+  if (baseSeq) {
+    let seq = baseSeq;
+    if (modifiableNamedKeys.has(baseLower) && hasAnyModifier(parsed.mods)) {
+      const mod = xtermModifier(parsed.mods);
+      if (mod > 1) {
+        const modified = applyXtermModifier(seq, mod);
+        if (modified) {
+          seq = modified;
+          return seq;
+        }
+      }
+    }
+    if (parsed.mods.alt) {
+      return `${ESC}${seq}`;
+    }
+    return seq;
+  }
+
+  if (base.length === 1) {
+    return applyCharModifiers(base, parsed.mods);
+  }
+
+  if (parsed.hasModifiers) {
+    warnings.push(`Unknown key "${base}" for modifiers; sending literal.`);
+  }
+  return base;
+}
+
+function parseModifiers(token: string) {
+  const mods: Modifiers = { ctrl: false, alt: false, shift: false };
+  let rest = token;
+  let sawModifiers = false;
+
+  while (rest.length > 2 && rest[1] === "-") {
+    const mod = rest[0]!.toLowerCase();
+    if (mod === "c") {
+      mods.ctrl = true;
+    } else if (mod === "m") {
+      mods.alt = true;
+    } else if (mod === "s") {
+      mods.shift = true;
+    } else {
+      break;
+    }
+    sawModifiers = true;
+    rest = rest.slice(2);
+  }
+
+  return { mods, base: rest, hasModifiers: sawModifiers };
+}
+
+function applyCharModifiers(char: string, mods: Modifiers): string {
+  let value = char;
+  if (mods.shift && value.length === 1 && /[a-z]/.test(value)) {
+    value = value.toUpperCase();
+  }
+  if (mods.ctrl) {
+    const ctrl = toCtrlChar(value);
+    if (ctrl) {
+      value = ctrl;
+    }
+  }
+  if (mods.alt) {
+    value = `${ESC}${value}`;
+  }
+  return value;
+}
+
+function toCtrlChar(char: string): string | null {
+  if (char.length !== 1) {
+    return null;
+  }
+  if (char === "?") {
+    return "\x7f";
+  }
+  const code = char.toUpperCase().charCodeAt(0);
+  if (code >= 64 && code <= 95) {
+    return String.fromCharCode(code & 0x1f);
+  }
+  return null;
+}
+
+function xtermModifier(mods: Modifiers): number {
+  let mod = 1;
+  if (mods.shift) {
+    mod += 1;
+  }
+  if (mods.alt) {
+    mod += 2;
+  }
+  if (mods.ctrl) {
+    mod += 4;
+  }
+  return mod;
+}
+
+/** Inlined from OpenClaw src/utils.ts — escapes special regex characters */
+function escapeRegExp(value: string): string {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+function applyXtermModifier(sequence: string, modifier: number): string | null {
+  const escPattern = escapeRegExp(ESC);
+  const csiNumber = new RegExp(`^${escPattern}\\[(\\d+)([~A-Z])$`);
+  const csiArrow = new RegExp(`^${escPattern}\\[(A|B|C|D|H|F)$`);
+
+  const numberMatch = sequence.match(csiNumber);
+  if (numberMatch) {
+    return `${ESC}[${numberMatch[1]};${modifier}${numberMatch[2]}`;
+  }
+
+  const arrowMatch = sequence.match(csiArrow);
+  if (arrowMatch) {
+    return `${ESC}[1;${modifier}${arrowMatch[1]}`;
+  }
+
+  return null;
+}
+
+function hasAnyModifier(mods: Modifiers): boolean {
+  return mods.ctrl || mods.alt || mods.shift;
+}
+
+function parseHexByte(raw: string): number | null {
+  const trimmed = raw.trim().toLowerCase();
+  const normalized = trimmed.startsWith("0x") ? trimmed.slice(2) : trimmed;
+  if (!/^[0-9a-f]{1,2}$/.test(normalized)) {
+    return null;
+  }
+  const value = Number.parseInt(normalized, 16);
+  if (Number.isNaN(value) || value < 0 || value > 0xff) {
+    return null;
+  }
+  return value;
+}

package/src/definitions/process/session-slug.ts

@@ -0,0 +1,147 @@
+// 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
+
+const SLUG_ADJECTIVES = [
+  "amber",
+  "briny",
+  "brisk",
+  "calm",
+  "clear",
+  "cool",
+  "crisp",
+  "dawn",
+  "delta",
+  "ember",
+  "faint",
+  "fast",
+  "fresh",
+  "gentle",
+  "glow",
+  "good",
+  "grand",
+  "keen",
+  "kind",
+  "lucky",
+  "marine",
+  "mellow",
+  "mild",
+  "neat",
+  "nimble",
+  "nova",
+  "oceanic",
+  "plaid",
+  "quick",
+  "quiet",
+  "rapid",
+  "salty",
+  "sharp",
+  "swift",
+  "tender",
+  "tidal",
+  "tidy",
+  "tide",
+  "vivid",
+  "warm",
+  "wild",
+  "young",
+];
+
+const SLUG_NOUNS = [
+  "atlas",
+  "basil",
+  "bison",
+  "bloom",
+  "breeze",
+  "canyon",
+  "cedar",
+  "claw",
+  "cloud",
+  "comet",
+  "coral",
+  "cove",
+  "crest",
+  "crustacean",
+  "daisy",
+  "dune",
+  "ember",
+  "falcon",
+  "fjord",
+  "forest",
+  "glade",
+  "gulf",
+  "harbor",
+  "haven",
+  "kelp",
+  "lagoon",
+  "lobster",
+  "meadow",
+  "mist",
+  "nudibranch",
+  "nexus",
+  "ocean",
+  "orbit",
+  "otter",
+  "pine",
+  "prairie",
+  "reef",
+  "ridge",
+  "river",
+  "rook",
+  "sable",
+  "sage",
+  "seaslug",
+  "shell",
+  "shoal",
+  "shore",
+  "slug",
+  "summit",
+  "tidepool",
+  "trail",
+  "valley",
+  "wharf",
+  "willow",
+  "zephyr",
+];
+
+function randomChoice(values: string[], fallback: string) {
+  return values[Math.floor(Math.random() * values.length)] ?? fallback;
+}
+
+function createSlugBase(words = 2) {
+  const parts = [randomChoice(SLUG_ADJECTIVES, "steady"), randomChoice(SLUG_NOUNS, "harbor")];
+  if (words > 2) {
+    parts.push(randomChoice(SLUG_NOUNS, "reef"));
+  }
+  return parts.join("-");
+}
+
+export function createSessionSlug(isTaken?: (id: string) => boolean): string {
+  const isIdTaken = isTaken ?? (() => false);
+  for (let attempt = 0; attempt < 12; attempt += 1) {
+    const base = createSlugBase(2);
+    if (!isIdTaken(base)) {
+      return base;
+    }
+    for (let i = 2; i <= 12; i += 1) {
+      const candidate = `${base}-${i}`;
+      if (!isIdTaken(candidate)) {
+        return candidate;
+      }
+    }
+  }
+  for (let attempt = 0; attempt < 12; attempt += 1) {
+    const base = createSlugBase(3);
+    if (!isIdTaken(base)) {
+      return base;
+    }
+    for (let i = 2; i <= 12; i += 1) {
+      const candidate = `${base}-${i}`;
+      if (!isIdTaken(candidate)) {
+        return candidate;
+      }
+    }
+  }
+  const fallback = `${createSlugBase(3)}-${Math.random().toString(36).slice(2, 5)}`;
+  return isIdTaken(fallback) ? `${fallback}-${Date.now().toString(36)}` : fallback;
+}

package/src/definitions/quip.ts

@@ -0,0 +1,225 @@
+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 QUIP_PY = join(homedir(), ".aria", "tools", "quip.py");
+
+function runQuip(args: string[]): Promise<string> {
+  return new Promise((resolve, reject) => {
+    execFile(QUIP_PY, args, { timeout: 30_000 }, (err, stdout, stderr) => {
+      if (err) {
+        reject(new Error(stderr?.trim() || err.message));
+      } else {
+        resolve(stdout);
+      }
+    });
+  });
+}
+
+type CheckQuipDocumentsInput = {
+  action?: string;
+  query?: string;
+  threadId?: string;
+  limit?: number;
+};
+
+type SendQuipCommentInput = {
+  threadId?: string;
+  content?: string;
+};
+
+type CreateQuipDocumentInput = {
+  title?: string;
+  content?: string;
+  format?: string;
+  folderId?: string;
+};
+
+const check_quip_documents: Tool = {
+  name: "check_quip_documents",
+  description:
+    "Read, search, or list Quip documents and comments using the local Quip session on this machine. " +
+    "Actions: 'recent' lists recent docs, 'search' finds docs by query, 'read' gets full document content, 'comments' lists comments on a document.",
+  category: "messaging",
+  parameters: {
+    type: "object",
+    properties: {
+      action: {
+        type: "string",
+        enum: ["recent", "search", "read", "comments"],
+        description:
+          "What to do: 'recent' (list recent docs), 'search' (find docs), 'read' (get document content), 'comments' (list comments).",
+      },
+      query: {
+        type: "string",
+        description: "Search query (required for 'search' action).",
+      },
+      threadId: {
+        type: "string",
+        description: "Quip thread/document ID (required for 'read' and 'comments' actions).",
+      },
+      limit: {
+        type: "number",
+        description: "Maximum number of results to return (default 20, max 50).",
+        default: 20,
+      },
+    },
+    required: ["action"],
+  } as JSONSchema7,
+  riskLevel: "safe",
+  isReadOnly: true,
+  loadingTier: "always",
+  execute: async (input: unknown) => {
+    const typedInput = input as CheckQuipDocumentsInput;
+    try {
+      const action = String(typedInput.action ?? "recent");
+      const limit = String(typeof typedInput.limit === "number" ? typedInput.limit : 20);
+
+      if (action === "recent") {
+        const raw = await runQuip(["recent", limit]);
+        return { success: true, message: `Recent Quip documents.`, data: { output: raw } };
+      }
+
+      if (action === "search") {
+        const query = String(typedInput.query ?? "");
+        if (!query) return { success: false, message: "'search' requires a 'query' parameter." };
+        const raw = await runQuip(["search", query, "--limit", limit]);
+        return { success: true, message: `Search results for "${query}".`, data: { output: raw } };
+      }
+
+      if (action === "read") {
+        const threadId = String(typedInput.threadId ?? "");
+        if (!threadId)
+          return { success: false, message: "'read' requires a 'threadId' parameter." };
+        const raw = await runQuip(["read", threadId]);
+        return { success: true, message: `Read document ${threadId}.`, data: { output: raw } };
+      }
+
+      if (action === "comments") {
+        const threadId = String(typedInput.threadId ?? "");
+        if (!threadId)
+          return { success: false, message: "'comments' requires a 'threadId' parameter." };
+        const raw = await runQuip(["comments", threadId]);
+        return { success: true, message: `Comments on ${threadId}.`, data: { output: raw } };
+      }
+
+      return {
+        success: false,
+        message: `Unknown action: ${action}. Use recent, search, read, or comments.`,
+      };
+    } catch (error) {
+      return {
+        success: false,
+        message: error instanceof Error ? error.message : "Quip read failed.",
+      };
+    }
+  },
+};
+
+const send_quip_comment: Tool = {
+  name: "send_quip_comment",
+  description:
+    "Add a comment to a Quip document using the local Quip session on this machine. " +
+    "Requires confirmation because it posts externally.",
+  category: "messaging",
+  parameters: {
+    type: "object",
+    properties: {
+      threadId: {
+        type: "string",
+        description: "Quip thread/document ID to comment on.",
+      },
+      content: {
+        type: "string",
+        description: "Comment text to post.",
+      },
+    },
+    required: ["threadId", "content"],
+  } as JSONSchema7,
+  riskLevel: "dangerous",
+  requiresConfirmation: true,
+  isReadOnly: false,
+  loadingTier: "always",
+  execute: async (input: unknown) => {
+    const typedInput = input as SendQuipCommentInput;
+    try {
+      const raw = await runQuip([
+        "comment",
+        String(typedInput.threadId ?? ""),
+        String(typedInput.content ?? ""),
+      ]);
+      return { success: true, message: `Posted comment.`, data: { output: raw } };
+    } catch (error) {
+      return {
+        success: false,
+        message: error instanceof Error ? error.message : "Quip comment failed.",
+      };
+    }
+  },
+};
+
+const create_quip_document: Tool = {
+  name: "create_quip_document",
+  description:
+    "Create a new Quip document using the local Quip session on this machine. " +
+    "Requires confirmation because it creates external content.",
+  category: "messaging",
+  parameters: {
+    type: "object",
+    properties: {
+      title: {
+        type: "string",
+        description: "Document title.",
+      },
+      content: {
+        type: "string",
+        description: "Document body content.",
+      },
+      format: {
+        type: "string",
+        enum: ["markdown", "html"],
+        description: "Content format (default 'markdown').",
+        default: "markdown",
+      },
+      folderId: {
+        type: "string",
+        description: "Optional folder ID to place the document in.",
+      },
+    },
+    required: ["title", "content"],
+  } as JSONSchema7,
+  riskLevel: "dangerous",
+  requiresConfirmation: true,
+  isReadOnly: false,
+  loadingTier: "always",
+  execute: async (input: unknown) => {
+    const typedInput = input as CreateQuipDocumentInput;
+    try {
+      const args = [
+        "create",
+        "--title",
+        String(typedInput.title ?? ""),
+        "--body",
+        String(typedInput.content ?? ""),
+      ];
+      if (typedInput.format) args.push("--format", typedInput.format);
+      if (typedInput.folderId) args.push("--folder", typedInput.folderId);
+
+      const raw = await runQuip(args);
+      return { success: true, message: `Created document.`, data: { output: raw } };
+    } catch (error) {
+      return {
+        success: false,
+        message: error instanceof Error ? error.message : "Quip create failed.",
+      };
+    }
+  },
+};
+
+export const QUIP_TOOL_DEFINITIONS = [
+  check_quip_documents,
+  send_quip_comment,
+  create_quip_document,
+];