@aria-cli/tools 1.0.8 → 1.0.10

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

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

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

@@ -1,225 +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 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,
-];