@aria-cli/tools 1.0.8 → 1.0.10

package/src/definitions/patch/fuzzy-match.ts

@@ -1,217 +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";
-
-type UpdateFileChunk = {
-  changeContext?: string;
-  oldLines: string[];
-  newLines: string[];
-  isEndOfFile: boolean;
-};
-
-async function defaultReadFile(filePath: string): Promise<string> {
-  return fs.readFile(filePath, "utf8");
-}
-
-export async function applyUpdateHunk(
-  filePath: string,
-  chunks: UpdateFileChunk[],
-  options?: { readFile?: (filePath: string) => Promise<string> },
-): Promise<string> {
-  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: string[],
-  filePath: string,
-  chunks: UpdateFileChunk[],
-): Array<[number, number, string[]]> {
-  const replacements: Array<[number, number, string[]]> = [];
-  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: string[],
-  replacements: Array<[number, number, string[]]>,
-): string[] {
-  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: string[],
-  pattern: string[],
-  start: number,
-  eof: boolean,
-): number | null {
-  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: string[],
-  pattern: string[],
-  start: number,
-  normalize: (value: string) => string,
-): boolean {
-  for (let idx = 0; idx < pattern.length; idx += 1) {
-    if (normalize(lines[start + idx]!) !== normalize(pattern[idx]!)) {
-      return false;
-    }
-  }
-  return true;
-}
-
-function normalizePunctuation(value: string): string {
-  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/src/definitions/patch/index.ts

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

package/src/definitions/patch/patch-parser.ts

@@ -1,297 +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
-
-// ── Marker Constants ───────────────────────────────────────────────
-
-export const BEGIN_PATCH_MARKER = "*** Begin Patch";
-export const END_PATCH_MARKER = "*** End Patch";
-export const ADD_FILE_MARKER = "*** Add File: ";
-export const DELETE_FILE_MARKER = "*** Delete File: ";
-export const UPDATE_FILE_MARKER = "*** Update File: ";
-export const MOVE_TO_MARKER = "*** Move to: ";
-export const EOF_MARKER = "*** End of File";
-export const CHANGE_CONTEXT_MARKER = "@@ ";
-export const EMPTY_CHANGE_CONTEXT_MARKER = "@@";
-
-// ── Types ──────────────────────────────────────────────────────────
-
-export type AddFileHunk = {
-  kind: "add";
-  path: string;
-  contents: string;
-};
-
-export type DeleteFileHunk = {
-  kind: "delete";
-  path: string;
-};
-
-export type UpdateFileChunk = {
-  changeContext?: string;
-  oldLines: string[];
-  newLines: string[];
-  isEndOfFile: boolean;
-};
-
-export type UpdateFileHunk = {
-  kind: "update";
-  path: string;
-  movePath?: string;
-  chunks: UpdateFileChunk[];
-};
-
-export type Hunk = AddFileHunk | DeleteFileHunk | UpdateFileHunk;
-
-export type ApplyPatchSummary = {
-  added: string[];
-  modified: string[];
-  deleted: string[];
-};
-
-// ── Unicode Normalization ──────────────────────────────────────────
-
-const UNICODE_SPACES = /[\u00A0\u2000-\u200A\u202F\u205F\u3000]/g;
-
-export function normalizeUnicodeSpaces(value: string): string {
-  return value.replace(UNICODE_SPACES, " ");
-}
-
-// ── Parser ─────────────────────────────────────────────────────────
-
-export function parsePatchText(input: string): { hunks: Hunk[]; patch: string } {
-  const trimmed = input.trim();
-  if (!trimmed) {
-    throw new Error("Invalid patch: input is empty.");
-  }
-
-  const lines = trimmed.split(/\r?\n/);
-  const validated = checkPatchBoundariesLenient(lines);
-  const hunks: Hunk[] = [];
-
-  const lastLineIndex = validated.length - 1;
-  let remaining = validated.slice(1, lastLineIndex);
-  let lineNumber = 2;
-
-  while (remaining.length > 0) {
-    const { hunk, consumed } = parseOneHunk(remaining, lineNumber);
-    hunks.push(hunk);
-    lineNumber += consumed;
-    remaining = remaining.slice(consumed);
-  }
-
-  return { hunks, patch: validated.join("\n") };
-}
-
-export function checkPatchBoundariesLenient(lines: string[]): string[] {
-  const strictError = checkPatchBoundariesStrict(lines);
-  if (!strictError) {
-    return lines;
-  }
-
-  if (lines.length < 4) {
-    throw new Error(strictError);
-  }
-  const first = lines[0];
-  const last = lines[lines.length - 1];
-  if ((first === "<<EOF" || first === "<<'EOF'" || first === '<<"EOF"') && last?.endsWith("EOF")) {
-    const inner = lines.slice(1, lines.length - 1);
-    const innerError = checkPatchBoundariesStrict(inner);
-    if (!innerError) {
-      return inner;
-    }
-    throw new Error(innerError);
-  }
-
-  throw new Error(strictError);
-}
-
-function checkPatchBoundariesStrict(lines: string[]): string | null {
-  const firstLine = lines[0]?.trim();
-  const lastLine = lines[lines.length - 1]?.trim();
-
-  if (firstLine === BEGIN_PATCH_MARKER && lastLine === END_PATCH_MARKER) {
-    return null;
-  }
-  if (firstLine !== BEGIN_PATCH_MARKER) {
-    return "The first line of the patch must be '*** Begin Patch'";
-  }
-  return "The last line of the patch must be '*** End Patch'";
-}
-
-export function parseOneHunk(
-  lines: string[],
-  lineNumber: number,
-): { hunk: Hunk; consumed: number } {
-  if (lines.length === 0) {
-    throw new Error(`Invalid patch hunk at line ${lineNumber}: empty hunk`);
-  }
-  const firstLine = lines[0]!.trim();
-  if (firstLine.startsWith(ADD_FILE_MARKER)) {
-    const targetPath = firstLine.slice(ADD_FILE_MARKER.length);
-    let contents = "";
-    let consumed = 1;
-    for (const addLine of lines.slice(1)) {
-      if (addLine.startsWith("+")) {
-        contents += `${addLine.slice(1)}\n`;
-        consumed += 1;
-      } else {
-        break;
-      }
-    }
-    return {
-      hunk: { kind: "add", path: targetPath, contents },
-      consumed,
-    };
-  }
-
-  if (firstLine.startsWith(DELETE_FILE_MARKER)) {
-    const targetPath = firstLine.slice(DELETE_FILE_MARKER.length);
-    return {
-      hunk: { kind: "delete", path: targetPath },
-      consumed: 1,
-    };
-  }
-
-  if (firstLine.startsWith(UPDATE_FILE_MARKER)) {
-    const targetPath = firstLine.slice(UPDATE_FILE_MARKER.length);
-    let remaining = lines.slice(1);
-    let consumed = 1;
-    let movePath: string | undefined;
-
-    const moveCandidate = remaining[0]?.trim();
-    if (moveCandidate?.startsWith(MOVE_TO_MARKER)) {
-      movePath = moveCandidate.slice(MOVE_TO_MARKER.length);
-      remaining = remaining.slice(1);
-      consumed += 1;
-    }
-
-    const chunks: UpdateFileChunk[] = [];
-    while (remaining.length > 0) {
-      if (remaining[0]!.trim() === "") {
-        remaining = remaining.slice(1);
-        consumed += 1;
-        continue;
-      }
-      if (remaining[0]!.startsWith("***")) {
-        break;
-      }
-      const { chunk, consumed: chunkLines } = parseUpdateFileChunk(
-        remaining,
-        lineNumber + consumed,
-        chunks.length === 0,
-      );
-      chunks.push(chunk);
-      remaining = remaining.slice(chunkLines);
-      consumed += chunkLines;
-    }
-
-    if (chunks.length === 0) {
-      throw new Error(
-        `Invalid patch hunk at line ${lineNumber}: Update file hunk for path '${targetPath}' is empty`,
-      );
-    }
-
-    return {
-      hunk: {
-        kind: "update",
-        path: targetPath,
-        movePath,
-        chunks,
-      },
-      consumed,
-    };
-  }
-
-  throw new Error(
-    `Invalid patch hunk at line ${lineNumber}: '${lines[0]}' is not a valid hunk header. Valid hunk headers: '*** Add File: {path}', '*** Delete File: {path}', '*** Update File: {path}'`,
-  );
-}
-
-export function parseUpdateFileChunk(
-  lines: string[],
-  lineNumber: number,
-  allowMissingContext: boolean,
-): { chunk: UpdateFileChunk; consumed: number } {
-  if (lines.length === 0) {
-    throw new Error(
-      `Invalid patch hunk at line ${lineNumber}: Update hunk does not contain any lines`,
-    );
-  }
-
-  const firstLine = lines[0]!;
-  let changeContext: string | undefined;
-  let startIndex = 0;
-  if (firstLine === EMPTY_CHANGE_CONTEXT_MARKER) {
-    startIndex = 1;
-  } else if (firstLine.startsWith(CHANGE_CONTEXT_MARKER)) {
-    changeContext = firstLine.slice(CHANGE_CONTEXT_MARKER.length);
-    startIndex = 1;
-  } else if (!allowMissingContext) {
-    throw new Error(
-      `Invalid patch hunk at line ${lineNumber}: Expected update hunk to start with a @@ context marker, got: '${firstLine}'`,
-    );
-  }
-
-  if (startIndex >= lines.length) {
-    throw new Error(
-      `Invalid patch hunk at line ${lineNumber + 1}: Update hunk does not contain any lines`,
-    );
-  }
-
-  const chunk: UpdateFileChunk = {
-    changeContext,
-    oldLines: [],
-    newLines: [],
-    isEndOfFile: false,
-  };
-
-  let parsedLines = 0;
-  for (const line of lines.slice(startIndex)) {
-    if (line === EOF_MARKER) {
-      if (parsedLines === 0) {
-        throw new Error(
-          `Invalid patch hunk at line ${lineNumber + 1}: Update hunk does not contain any lines`,
-        );
-      }
-      chunk.isEndOfFile = true;
-      parsedLines += 1;
-      break;
-    }
-
-    const marker = line[0];
-    if (!marker) {
-      chunk.oldLines.push("");
-      chunk.newLines.push("");
-      parsedLines += 1;
-      continue;
-    }
-
-    if (marker === " ") {
-      const content = line.slice(1);
-      chunk.oldLines.push(content);
-      chunk.newLines.push(content);
-      parsedLines += 1;
-      continue;
-    }
-    if (marker === "+") {
-      chunk.newLines.push(line.slice(1));
-      parsedLines += 1;
-      continue;
-    }
-    if (marker === "-") {
-      chunk.oldLines.push(line.slice(1));
-      parsedLines += 1;
-      continue;
-    }
-
-    if (parsedLines === 0) {
-      throw new Error(
-        `Invalid patch hunk at line ${lineNumber + 1}: Unexpected line found in update hunk: '${line}'. Every line should start with ' ' (context line), '+' (added line), or '-' (removed line)`,
-      );
-    }
-    break;
-  }
-
-  return { chunk, consumed: parsedLines + startIndex };
-}

package/src/definitions/patch/sandbox-paths.ts

@@ -1,129 +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";
-
-const UNICODE_SPACES = /[\u00A0\u2000-\u200A\u202F\u205F\u3000]/g;
-
-function normalizeUnicodeSpaces(str: string): string {
-  return str.replace(UNICODE_SPACES, " ");
-}
-
-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 resolveToCwd(filePath: string, cwd: string): string {
-  const expanded = expandPath(filePath);
-  if (path.isAbsolute(expanded)) {
-    return expanded;
-  }
-  return path.resolve(cwd, expanded);
-}
-
-export function resolveSandboxInputPath(filePath: string, cwd: string): string {
-  return resolveToCwd(filePath, cwd);
-}
-
-export function resolveSandboxPath(params: { filePath: string; cwd: string; root: string }): {
-  resolved: string;
-  relative: string;
-} {
-  const resolved = resolveSandboxInputPath(params.filePath, params.cwd);
-  const rootResolved = path.resolve(params.root);
-  const relative = path.relative(rootResolved, resolved);
-  if (!relative || relative === "") {
-    return { resolved, relative: "" };
-  }
-  if (relative.startsWith("..") || path.isAbsolute(relative)) {
-    throw new Error(`Path escapes sandbox root (${shortPath(rootResolved)}): ${params.filePath}`);
-  }
-  return { resolved, relative };
-}
-
-export async function assertSandboxPath(params: {
-  filePath: string;
-  cwd: string;
-  root: string;
-  allowFinalSymlink?: boolean;
-}) {
-  const resolved = resolveSandboxPath(params);
-  await assertNoSymlinkEscape(resolved.relative, path.resolve(params.root), {
-    allowFinalSymlink: params.allowFinalSymlink,
-  });
-  return resolved;
-}
-
-async function assertNoSymlinkEscape(
-  relative: string,
-  root: string,
-  options?: { allowFinalSymlink?: boolean },
-) {
-  if (!relative) {
-    return;
-  }
-  const rootReal = await tryRealpath(root);
-  const parts = relative.split(path.sep).filter(Boolean);
-  let current = root;
-  for (let idx = 0; idx < parts.length; idx += 1) {
-    const part = parts[idx]!;
-    const isLast = idx === parts.length - 1;
-    current = path.join(current, part);
-    try {
-      const stat = await fs.lstat(current);
-      if (stat.isSymbolicLink()) {
-        // Unlinking a symlink itself is safe even if it points outside the root. What we
-        // must prevent is traversing through a symlink to reach targets outside root.
-        if (options?.allowFinalSymlink && isLast) {
-          return;
-        }
-        const target = await tryRealpath(current);
-        if (!isPathInside(rootReal, target)) {
-          throw new Error(
-            `Symlink escapes sandbox root (${shortPath(rootReal)}): ${shortPath(current)}`,
-          );
-        }
-        current = target;
-      }
-    } catch (err) {
-      const anyErr = err as { code?: string };
-      if (anyErr.code === "ENOENT") {
-        return;
-      }
-      throw err;
-    }
-  }
-}
-
-async function tryRealpath(value: string): Promise<string> {
-  try {
-    return await fs.realpath(value);
-  } catch {
-    return path.resolve(value);
-  }
-}
-
-function isPathInside(root: string, target: string): boolean {
-  const relative = path.relative(root, target);
-  if (!relative || relative === "") {
-    return true;
-  }
-  return !(relative.startsWith("..") || path.isAbsolute(relative));
-}
-
-function shortPath(value: string) {
-  if (value.startsWith(os.homedir())) {
-    return `~${value.slice(os.homedir().length)}`;
-  }
-  return value;
-}

package/src/definitions/process/index.ts

@@ -1,5 +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
-
-export { processTool } from "./process.js";