@abacus-ai/cli 1.106.25007 → 2.0.0-canary.0

package/src/lib/path-paste.ts

@@ -0,0 +1,185 @@
+import { existsSync } from "node:fs";
+import path from "node:path";
+
+import { stripFileProtocol } from "./clipboard.js";
+import { expandHome, abbreviatePath } from "./path.js";
+
+export const IMAGE_EXTENSIONS = [".png", ".jpg", ".jpeg", ".webp", ".heic", ".heif", ".gif"];
+
+export function isImagePath(p: string): boolean {
+  return IMAGE_EXTENSIONS.includes(path.extname(p).toLowerCase());
+}
+
+/**
+ * Escapes a path for use in an @mention.
+ * Paths containing spaces are wrapped in single quotes (shell-safe).
+ */
+export function escapePathForMention(p: string): string {
+  if (p.includes(" ")) return `'${p.replace(/'/g, "'\\''")}'`;
+  return p;
+}
+
+/**
+ * Abbreviates an absolute path for display, picking the shorter of
+ * CWD-relative (./src/foo.ts) or home-relative (~/work/bar.ts).
+ */
+export function prettifyMentionPath(absolutePath: string): string {
+  return abbreviatePath(absolutePath);
+}
+
+// ── State-machine path splitter ───────────────────────────────────────────
+
+type SplitMode = "NORMAL" | "SINGLE" | "DOUBLE";
+
+function looksLikePathStart(text: string): boolean {
+  const unquoted = text.startsWith("'") || text.startsWith('"') ? text.slice(1) : text;
+  return (
+    unquoted.startsWith("/") ||
+    unquoted.startsWith("~") ||
+    unquoted.startsWith("./") ||
+    unquoted.startsWith("../") ||
+    /^file:\/\//i.test(unquoted) ||
+    /^[A-Za-z]:[/\\]/.test(unquoted) ||
+    unquoted.startsWith("\\\\") || // Windows UNC
+    text.startsWith("& '") // PowerShell & 'path'
+  );
+}
+
+/**
+ * Generator that splits a drag-and-drop input string into resolved absolute paths.
+ *
+ * Handles all major terminal/OS path encodings:
+ *   - Bare POSIX:              /path/to/file.txt
+ *   - Backslash-escaped:       /path/to/my\ file.txt
+ *   - Single-quoted:           '/path/to/my file.txt'
+ *   - Double-quoted (Windows): "C:\path\to\file.txt"
+ *   - file:// URI:             file:///path/to/my%20file.txt
+ *   - Windows bare C::         c:\path\to\file.txt
+ *   - Windows UNC:             \\Mac\Home\file.txt
+ *   - PowerShell & '...':      & 'c:\New Text Document.txt'
+ */
+export function* splitDragAndDropPaths(text: string): Generator<string> {
+  const trimmed = text.trim();
+
+  if (!looksLikePathStart(trimmed)) return;
+
+  // Strip PowerShell & prefix (e.g. & 'path')
+  const input = trimmed.replace(/^& /, "");
+
+  function resolveSeg(raw: string): string {
+    let s = raw.trim();
+    // Decode file:// URI
+    if (/^file:\/\//i.test(s)) {
+      s = stripFileProtocol(s);
+    }
+    // Unescape backslash-escaped spaces
+    s = s.replace(/\\ /g, " ");
+    // Expand ~ to home
+    s = expandHome(s);
+    return path.resolve(s);
+  }
+
+  let mode: SplitMode = "NORMAL";
+  let current = "";
+
+  let i = 0;
+  while (i < input.length) {
+    const ch = input[i];
+
+    if (mode === "SINGLE") {
+      // Check for '\'' (escaped single quote within single-quoted string)
+      if (ch === "'" && input.slice(i, i + 4) === "'\\''") {
+        current += "'";
+        i += 4;
+        continue;
+      }
+      if (ch === "'") {
+        // End of single-quoted segment
+        const resolved = resolveSeg(current);
+        if (resolved) yield resolved;
+        current = "";
+        mode = "NORMAL";
+        i++;
+        continue;
+      }
+      current += ch;
+      i++;
+      continue;
+    }
+
+    if (mode === "DOUBLE") {
+      if (ch === '"') {
+        const resolved = resolveSeg(current);
+        if (resolved) yield resolved;
+        current = "";
+        mode = "NORMAL";
+        i++;
+        continue;
+      }
+      current += ch;
+      i++;
+      continue;
+    }
+
+    // NORMAL mode
+    if (ch === "'") {
+      mode = "SINGLE";
+      i++;
+      continue;
+    }
+    if (ch === '"') {
+      mode = "DOUBLE";
+      i++;
+      continue;
+    }
+    // Backslash-escaped space
+    if (ch === "\\" && i + 1 < input.length && input[i + 1] === " ") {
+      current += "\\ ";
+      i += 2;
+      continue;
+    }
+    // Unescaped separator between paths
+    if (ch === " " || ch === "\n" || ch === "\t") {
+      if (current.trim()) {
+        const resolved = resolveSeg(current);
+        if (resolved) yield resolved;
+        current = "";
+      }
+      i++;
+      continue;
+    }
+    current += ch;
+    i++;
+  }
+
+  // Flush remaining segment
+  if (current.trim()) {
+    const resolved = resolveSeg(current);
+    if (resolved) yield resolved;
+  }
+}
+
+/**
+ * Validates pasted text as file paths and formats them as @mention strings.
+ *
+ * All-or-nothing: returns null if any segment doesn't exist on disk,
+ * or if no path segments are found.
+ *
+ * @returns "@path1 @path2 " (trailing space) or null
+ */
+export function parsePastedPaths(text: string): string | null {
+  const segments: string[] = [];
+
+  for (const resolved of splitDragAndDropPaths(text)) {
+    if (!existsSync(resolved)) {
+      return null; // all-or-nothing: bail if any path is missing
+    }
+    const pretty = prettifyMentionPath(resolved);
+    const escaped = escapePathForMention(pretty);
+    segments.push(`@${escaped}`);
+  }
+
+  if (segments.length === 0) return null;
+
+  return segments.join(" ") + " ";
+}

package/src/lib/path.ts

@@ -0,0 +1,179 @@
+import { realpathSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+/**
+ * Special characters that need to be escaped in file paths for shell compatibility.
+ * Includes: spaces, parentheses, brackets, braces, semicolons, ampersands, pipes,
+ * asterisks, question marks, dollar signs, backticks, quotes, hash, and other shell metacharacters.
+ */
+export const SHELL_SPECIAL_CHARS = /[ \t()[\]{};|*?$`'"#&<>!~]/;
+
+/**
+ * Unescapes special characters in a file path.
+ * Removes backslash escaping from shell metacharacters.
+ */
+export function unescapePath(filePath: string): string {
+  return filePath.replace(
+    new RegExp(`\\\\([${SHELL_SPECIAL_CHARS.source.slice(1, -1)}])`, "g"),
+    "$1",
+  );
+}
+
+const home = os.homedir();
+
+export function expandHome(filePath: string): string {
+  if (filePath === "~") {
+    return home;
+  }
+  if (filePath.startsWith("~/")) {
+    return path.join(home, filePath.slice(2));
+  }
+  return filePath;
+}
+
+/**
+ * Abbreviates the home directory in a file path
+ * @param filePath - The file path to abbreviate.
+ * @param cwd - The current working directory (defaults to process.cwd())
+ *
+ * @example
+ * ```ts
+ * abbreviateHome('/home/user/documents/file.txt') // ~/documents/file.txt
+ * abbreviateHome('./documents/file.txt', '/home/user') // ~/documents/file.txt
+ * ```
+ */
+export function abbreviateHome(filePath: string, cwd: string = process.cwd()): string {
+  const resolved = path.resolve(cwd, filePath);
+  if (resolved === home || resolved.startsWith(`${home}${path.sep}`)) {
+    const suffix = resolved.slice(home.length);
+    const posix = suffix.split(path.sep).join("/");
+    return `~${posix}`;
+  }
+  return resolved;
+}
+
+export function abbreviateCwd(filePath: string): string {
+  const resolved = path.resolve(filePath);
+  const rel = path.relative(process.cwd(), resolved);
+  if (!rel) {
+    return ".";
+  }
+  const posixRel = rel.split(path.sep).join("/");
+  if (posixRel.startsWith(".")) {
+    return posixRel;
+  }
+  return `./${posixRel}`;
+}
+
+export function abbreviatePath(filePath: string): string {
+  const resolved = path.resolve(filePath);
+  const cwd = process.cwd();
+  const rel = path.relative(cwd, resolved);
+
+  if (!rel) {
+    return ".";
+  }
+
+  if (!rel.startsWith("..")) {
+    const posixRel = rel.split(path.sep).join("/");
+    return posixRel.startsWith(".") ? posixRel : `./${posixRel}`;
+  }
+
+  if (resolved === home || resolved.startsWith(`${home}${path.sep}`)) {
+    const suffix = resolved.slice(home.length);
+    const posix = suffix.split(path.sep).join("/");
+    return `~${posix}`;
+  }
+
+  return resolved;
+}
+
+export function resolvePath(filePath: string): string {
+  return path.resolve(expandHome(filePath));
+}
+
+/**
+ * Attempts to convert an absolute path to a relative path within a workspace,
+ * handling symlinks correctly. This is useful for SSH environments where workspace
+ * directories may be symlinked (e.g., /home/user/code -> /shared/home/user/code).
+ *
+ * @param absolutePath - The absolute path to convert
+ * @param workspacePath - The workspace base path
+ * @returns An object with:
+ *   - success: true if conversion succeeded
+ *   - relativePath: the relative path (only if success is true)
+ *   - reason: explanation if conversion failed
+ *
+ * @example
+ * ```ts
+ * // Direct path match
+ * convertAbsoluteToRelativePath('/home/user/code/file.py', '/home/user/code')
+ * // => { success: true, relativePath: 'file.py' }
+ *
+ * // With symlinks: /home/user/code -> /shared/home/user/code
+ * convertAbsoluteToRelativePath('/home/user/code/file.py', '/shared/home/user/code')
+ * // => { success: true, relativePath: 'file.py' }
+ *
+ * // Outside workspace
+ * convertAbsoluteToRelativePath('/other/path/file.py', '/home/user/code')
+ * // => { success: false, reason: 'outside_workspace' }
+ * ```
+ */
+export function convertAbsoluteToRelativePath(
+  absolutePath: string,
+  workspacePath: string,
+): { success: true; relativePath: string } | { success: false; reason: string } {
+  const normalizedTarget = path.resolve(absolutePath);
+  const normalizedWorkspace = path.resolve(workspacePath);
+
+  // Step 1: Try direct conversion (without symlink resolution)
+  let relativeToWorkspace = path.relative(normalizedWorkspace, normalizedTarget);
+  const canConvertDirect =
+    relativeToWorkspace &&
+    !relativeToWorkspace.startsWith("..") &&
+    !path.isAbsolute(relativeToWorkspace);
+
+  if (canConvertDirect) {
+    return { success: true, relativePath: relativeToWorkspace };
+  }
+
+  // Step 2: Try with symlink resolution
+  // This handles cases like /home/user/code vs /shared/home/user/code
+  let realTarget = normalizedTarget;
+  let realWorkspace = normalizedWorkspace;
+
+  try {
+    realTarget = realpathSync(normalizedTarget);
+  } catch {
+    // If realpath fails (file doesn't exist yet), try resolving parent directory
+    try {
+      const parentDir = path.resolve(normalizedTarget, "..");
+      const fileName = normalizedTarget.split(path.sep).pop() || "";
+      const realParent = realpathSync(parentDir);
+      realTarget = path.resolve(realParent, fileName);
+    } catch {
+      // If that also fails, use normalized path
+    }
+  }
+
+  try {
+    realWorkspace = realpathSync(normalizedWorkspace);
+  } catch {
+    // If realpath fails, use normalized path
+  }
+
+  // Try relative path calculation with resolved symlinks
+  relativeToWorkspace = path.relative(realWorkspace, realTarget);
+  const canConvertWithSymlinks =
+    relativeToWorkspace &&
+    !relativeToWorkspace.startsWith("..") &&
+    !path.isAbsolute(relativeToWorkspace);
+
+  if (canConvertWithSymlinks) {
+    return { success: true, relativePath: relativeToWorkspace };
+  }
+
+  // Could not convert - path is outside workspace
+  return { success: false, reason: "outside_workspace" };
+}

package/src/lib/queries.ts

@@ -0,0 +1,15 @@
+export enum QueryKey {
+  Models = "models",
+  CreateConversation = "create-conversation",
+  GetConversation = "get-conversation",
+
+  Grep = "grep",
+  FileSearch = "file-search",
+  ListDir = "list-dir",
+  ReadFile = "read-file",
+  DeleteFile = "delete-file",
+  EditFile = "edit-file",
+  RunTerminal = "run-terminal",
+  GetTerminalOutput = "get-terminal-output",
+  MCPTool = "mcp-tool",
+}