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

package/src/components/tools/filesystem/delete-file.tsx

@@ -0,0 +1,104 @@
+import type { ParsedToolResult } from "@codellm/agent";
+
+import { View, Text } from "@codellm/jar";
+import React from "react";
+import { z } from "zod";
+
+import type { ToolDef, ToolStatus } from "../types.js";
+
+import { ToolHeader, ToolResult, truncatePath, snakeToCamel } from "../shared/index.js";
+
+const DeleteFileToolParams = z.object({
+  targetFile: z.string(),
+  explanation: z.string().optional(),
+});
+
+export const deleteFileTool: ToolDef = {
+  displayName: "Delete",
+
+  getHeaderParams(input: Record<string, unknown>): string {
+    try {
+      const targetFile = (input?.targetFile || input?.target_file || "[unknown]") as string;
+      return truncatePath(targetFile);
+    } catch {
+      return "[unknown]";
+    }
+  },
+
+  renderUI(
+    rawInput: Record<string, unknown>,
+    status: ToolStatus,
+    parsedResult?: ParsedToolResult,
+  ): React.ReactElement {
+    const parseResult = DeleteFileToolParams.safeParse(snakeToCamel(rawInput));
+    if (!parseResult.success) {
+      return (
+        <View flexDirection="column">
+          <ToolHeader name="Delete" params="" status="error" />
+          <ToolResult color="red">Invalid params</ToolResult>
+        </View>
+      );
+    }
+    const params = parseResult.data;
+    const { targetFile } = params;
+    const displayParams = truncatePath(targetFile);
+
+    if (status === "interrupted") {
+      return (
+        <View flexDirection="column">
+          <ToolHeader name="Delete" params={displayParams} status="interrupted" />
+          <ToolResult color="yellow">Interrupted · What should I do instead?</ToolResult>
+        </View>
+      );
+    }
+
+    if (status === "rejected") {
+      if (parsedResult?.userNote) {
+        return (
+          <View flexDirection="column">
+            <ToolHeader name="Delete" params={displayParams} status="rejected" />
+            <ToolResult color="yellow">
+              Rejected · <Text italic>"{parsedResult.userNote}"</Text>
+            </ToolResult>
+          </View>
+        );
+      }
+      return (
+        <View flexDirection="column">
+          <ToolHeader name="Delete" params={displayParams} status="rejected" />
+          <ToolResult color="yellow">Rejected</ToolResult>
+        </View>
+      );
+    }
+
+    if (status === "error") {
+      return (
+        <View flexDirection="column">
+          <ToolHeader name="Delete" params={displayParams} status="error" />
+          <ToolResult color="red">Error deleting file</ToolResult>
+        </View>
+      );
+    }
+
+    const isExecuting = !parsedResult && (status === "executing" || status === "pending");
+
+    if (isExecuting) {
+      return <ToolHeader name="Delete" params={displayParams} status="pending" showSpinner />;
+    }
+
+    if (!parsedResult) {
+      return (
+        <View flexDirection="column">
+          <ToolHeader name="Delete" params={displayParams} status="pending" />
+        </View>
+      );
+    }
+
+    return (
+      <View flexDirection="column">
+        <ToolHeader name="Delete" params={displayParams} status="success" />
+        <ToolResult>Deleted</ToolResult>
+      </View>
+    );
+  },
+};

package/src/components/tools/filesystem/edit.tsx

@@ -0,0 +1,220 @@
+import type { EditParsedData, ParsedToolResult, ToolDisplayData } from "@codellm/agent";
+
+import { View, Text, useFocus, useInput } from "@codellm/jar";
+import React, { useState } from "react";
+import { z } from "zod";
+
+import type { ToolDef, ToolStatus } from "../types.js";
+
+import { DiffPreview } from "../../tool-permissions/diff-preview.js";
+import {
+  ToolHeader,
+  ToolResult,
+  PreviewContent,
+  truncatePath,
+  CodePreview,
+  snakeToCamel,
+} from "../shared/index.js";
+import { coerceOptionalBoolean } from "../shared/zod-coercion.js";
+
+const EditToolParams = z.object({
+  targetFile: z.string(),
+  codeEdit: z.string(),
+  overwriteFile: coerceOptionalBoolean,
+  instructions: z.string().optional(),
+  startLine: z
+    .union([z.number(), z.string(), z.null(), z.undefined()])
+    .optional()
+    .transform((val) => {
+      if (val === null || val === undefined) return undefined;
+      const num = Number(val);
+      return isNaN(num) ? undefined : num;
+    }),
+  endLine: z
+    .union([z.number(), z.string(), z.null(), z.undefined()])
+    .optional()
+    .transform((val) => {
+      if (val === null || val === undefined) return undefined;
+      const num = Number(val);
+      return isNaN(num) ? undefined : num;
+    }),
+  explanation: z.string().optional(),
+});
+
+const EDIT_MAX_LINES_COLLAPSED = 15;
+const EDIT_MAX_LINES_EXPANDED = 100;
+
+function EditToolUI({
+  rawInput,
+  status,
+  parsedResult,
+  toolDisplayData,
+}: {
+  rawInput: Record<string, unknown>;
+  status: ToolStatus;
+  parsedResult?: ParsedToolResult<EditParsedData>;
+  toolDisplayData?: ToolDisplayData;
+}) {
+  const [isExpanded, setIsExpanded] = useState(false);
+  const hasResult =
+    parsedResult != null && (status === "success" || parsedResult.phase === "skipped");
+
+  const { isFocused } = useFocus({
+    id: `edit-tool-${(rawInput?.targetFile || rawInput?.target_file || "unknown") as string}`,
+    isActive: hasResult,
+  });
+
+  useInput(
+    (input, key) => {
+      if (isFocused && key.ctrl && input === "o") {
+        setIsExpanded((prev) => !prev);
+      }
+    },
+    { isActive: isFocused && hasResult },
+  );
+
+  const parseResult = EditToolParams.safeParse(snakeToCamel(rawInput));
+  if (!parseResult.success) {
+    return (
+      <View flexDirection="column">
+        <ToolHeader name="Edit" params="" status="error" />
+        <ToolResult color="red">Invalid params</ToolResult>
+      </View>
+    );
+  }
+  const params = parseResult.data;
+
+  const targetFile = parsedResult?.data.targetFile ?? params.targetFile;
+
+  const isExecuting = !parsedResult && (status === "executing" || status === "pending");
+  const displayPath = truncatePath(targetFile);
+
+  // Resolve display data — prefer toolDisplayData side-channel
+  const isPlanFile = toolDisplayData?.isPlanFile ?? false;
+  const isNewFile = parsedResult?.data.isNewFile ?? toolDisplayData?.isNewFile ?? false;
+  const operation = isNewFile ? "Create" : "Update";
+
+  // Plan file edits: no diff shown
+  if (isPlanFile && status === "success") {
+    return (
+      <View flexDirection="column">
+        <ToolHeader name={operation} params={displayPath} status="success" />
+        <ToolResult>Updated plan</ToolResult>
+      </View>
+    );
+  }
+
+  if (status === "interrupted") {
+    return (
+      <View flexDirection="column">
+        <ToolHeader name={operation} params={displayPath} status="interrupted" />
+        <ToolResult color="yellow">Interrupted · What should I do instead?</ToolResult>
+      </View>
+    );
+  }
+
+  if (status === "rejected") {
+    const origContent = toolDisplayData?.originalContent ?? "";
+    const newCont = toolDisplayData?.newContent ?? "";
+    const interruptMessage = parsedResult?.userNote ? (
+      <ToolResult color="yellow">
+        Rejected · <Text italic>"{parsedResult.userNote}"</Text>
+      </ToolResult>
+    ) : (
+      <ToolResult color="yellow">Rejected</ToolResult>
+    );
+    return (
+      <View flexDirection="column">
+        <ToolHeader name={operation} params={displayPath} status="rejected" />
+        {!isPlanFile && origContent && newCont && (
+          <PreviewContent>
+            <DiffPreview
+              filePath={targetFile}
+              originalContent={origContent}
+              newContent={newCont}
+              dimmed
+            />
+          </PreviewContent>
+        )}
+        {interruptMessage}
+      </View>
+    );
+  }
+
+  if (isExecuting) {
+    return <ToolHeader name={operation} params={displayPath} status="pending" showSpinner />;
+  }
+
+  if (!parsedResult) {
+    return (
+      <View flexDirection="column">
+        <ToolHeader name={operation} params={displayPath} status="pending" />
+      </View>
+    );
+  }
+
+  const isNoChanges = parsedResult.phase === "skipped";
+  const resultText = parsedResult.summary ?? "Updated";
+
+  // Content for diff preview — ONLY from toolDisplayData (EditTool.format() strips it)
+  const originalContent = toolDisplayData?.originalContent;
+  const finalContent = toolDisplayData?.finalContent ?? toolDisplayData?.newContent;
+
+  return (
+    <View flexDirection="column">
+      <ToolHeader
+        name={operation}
+        params={displayPath}
+        status={isNoChanges ? "rejected" : "success"}
+      />
+      <ToolResult color={isNoChanges ? "yellow" : undefined}>{resultText}</ToolResult>
+
+      {!isNoChanges && originalContent !== undefined && finalContent !== undefined && (
+        <PreviewContent>
+          {isNewFile ? (
+            <CodePreview
+              filePath={targetFile}
+              content={finalContent}
+              maxLines={isExpanded ? EDIT_MAX_LINES_EXPANDED : EDIT_MAX_LINES_COLLAPSED}
+            />
+          ) : (
+            <DiffPreview
+              filePath={targetFile}
+              originalContent={originalContent}
+              newContent={finalContent}
+            />
+          )}
+        </PreviewContent>
+      )}
+    </View>
+  );
+}
+
+export const editTool: ToolDef<EditParsedData> = {
+  displayName: "Edit",
+
+  getHeaderParams(input: Record<string, unknown>): string {
+    try {
+      const targetFile = (input?.targetFile || input?.target_file || "[unknown]") as string;
+      return truncatePath(targetFile);
+    } catch {
+      return "[unknown]";
+    }
+  },
+
+  renderUI(
+    rawInput: Record<string, unknown>,
+    status: ToolStatus,
+    parsedResult,
+    displayData,
+  ): React.ReactElement {
+    return (
+      <EditToolUI
+        rawInput={rawInput}
+        status={status}
+        parsedResult={parsedResult}
+        toolDisplayData={displayData}
+      />
+    );
+  },
+};

package/src/components/tools/filesystem/list-dir.tsx

@@ -0,0 +1,78 @@
+import type { ParsedToolResult } from "@codellm/agent";
+
+import { View } from "@codellm/jar";
+import React from "react";
+import { z } from "zod";
+
+import type { ToolDef, ToolStatus } from "../types.js";
+
+import { ToolHeader, ToolResult, truncatePath, snakeToCamel } from "../shared/index.js";
+
+const ListDirToolParams = z.object({
+  relativeWorkspacePath: z.string().optional(),
+  explanation: z.string().optional(),
+});
+
+export const listDirTool: ToolDef = {
+  displayName: "ListDir",
+
+  getHeaderParams(input: Record<string, unknown>): string {
+    try {
+      const path = (input?.relativeWorkspacePath ||
+        input?.relative_workspace_path ||
+        ".") as string;
+      return truncatePath(path);
+    } catch {
+      return "[unknown]";
+    }
+  },
+
+  renderUI(
+    rawInput: Record<string, unknown>,
+    status: ToolStatus,
+    parsedResult?: ParsedToolResult,
+  ): React.ReactElement {
+    const parseResult = ListDirToolParams.safeParse(snakeToCamel(rawInput));
+    if (!parseResult.success) {
+      return (
+        <View flexDirection="column">
+          <ToolHeader name="LS" params="" status="error" />
+          <ToolResult color="red">Invalid params</ToolResult>
+        </View>
+      );
+    }
+    const params = parseResult.data;
+    const path = params.relativeWorkspacePath || ".";
+    const displayParams = truncatePath(path);
+
+    if (status === "error") {
+      return (
+        <View flexDirection="column">
+          <ToolHeader name="List" params={displayParams} status="error" />
+          <ToolResult color="red">Error listing directory</ToolResult>
+        </View>
+      );
+    }
+
+    const isExecuting = !parsedResult && (status === "executing" || status === "pending");
+
+    if (isExecuting) {
+      return <ToolHeader name="LS" params={displayParams} status="pending" showSpinner />;
+    }
+
+    if (!parsedResult) {
+      return (
+        <View flexDirection="column">
+          <ToolHeader name="LS" params={displayParams} status="pending" />
+        </View>
+      );
+    }
+
+    return (
+      <View flexDirection="column">
+        <ToolHeader name="LS" params={displayParams} status="success" />
+        <ToolResult>{parsedResult.summary}</ToolResult>
+      </View>
+    );
+  },
+};

package/src/components/tools/filesystem/read-file.tsx

@@ -0,0 +1,180 @@
+import type { ReadFileParsedData } from "@codellm/agent";
+
+import { View, useFocus, useInput } from "@codellm/jar";
+import React, { useState } from "react";
+import { z } from "zod";
+
+import type { ToolDef, ToolStatus } from "../types.js";
+
+import {
+  ToolHeader,
+  ToolResult,
+  PreviewContent,
+  CodePreview,
+  truncatePath,
+  snakeToCamel,
+} from "../shared/index.js";
+import { coerceOptionalBoolean, coerceOptionalNumber } from "../shared/zod-coercion.js";
+
+const MAX_LINES_COLLAPSED = 4;
+const MAX_LINES_EXPANDED = 100;
+
+const ReadFileToolParams = z.object({
+  targetFile: z.string(),
+  startLineOneIndexed: coerceOptionalNumber,
+  endLineOneIndexed: coerceOptionalNumber,
+  startLine: coerceOptionalNumber,
+  endLine: coerceOptionalNumber,
+  shouldReadEntireFile: coerceOptionalBoolean,
+  explanation: z.string().optional(),
+});
+
+export const readFileTool: ToolDef<ReadFileParsedData> = {
+  displayName: "Read",
+
+  getHeaderParams(input: Record<string, unknown>): string {
+    try {
+      const targetFile = (input?.targetFile || input?.target_file || "[unknown]") as string;
+      const displayPath = truncatePath(targetFile);
+
+      const startLine =
+        input?.startLineOneIndexed ||
+        input?.start_line_one_indexed ||
+        input?.startLine ||
+        input?.start_line;
+      const endLine =
+        input?.endLineOneIndexed ||
+        input?.end_line_one_indexed ||
+        input?.endLine ||
+        input?.end_line;
+
+      if (startLine !== undefined && endLine !== undefined) {
+        return `${displayPath}:${startLine}-${endLine}`;
+      }
+      return displayPath;
+    } catch {
+      return "[unknown]";
+    }
+  },
+
+  renderUI(
+    rawInput: Record<string, unknown>,
+    status: ToolStatus,
+    parsedResult,
+  ): React.ReactElement {
+    const parseResult = ReadFileToolParams.safeParse(snakeToCamel(rawInput));
+    if (!parseResult.success) {
+      return (
+        <View flexDirection="column">
+          <ToolHeader name="Read" params="" status="error" />
+          <ToolResult color="red">Invalid params</ToolResult>
+        </View>
+      );
+    }
+    const params = parseResult.data;
+    const { targetFile, startLineOneIndexed, endLineOneIndexed } = params;
+
+    if (!targetFile || typeof targetFile !== "string") {
+      return (
+        <View flexDirection="column">
+          <ToolHeader name="Read" params="[invalid file path]" status="error" />
+          <ToolResult color="red">Error: Invalid file path parameter</ToolResult>
+        </View>
+      );
+    }
+
+    const isExecuting = !parsedResult && (status === "executing" || status === "pending");
+    const filePath = truncatePath(targetFile);
+    const paramStartLine = startLineOneIndexed ?? params.startLine;
+    const endLine = endLineOneIndexed ?? params.endLine;
+
+    let displayParams = filePath;
+    if (paramStartLine !== undefined && endLine !== undefined) {
+      displayParams = `${filePath}:${paramStartLine}-${endLine}`;
+    }
+
+    if (isExecuting) {
+      return <ToolHeader name="Read" params={displayParams} status="pending" showSpinner />;
+    }
+
+    if (status === "error") {
+      return (
+        <View flexDirection="column">
+          <ToolHeader name="Read" params={displayParams} status="error" />
+          <ToolResult color="red">Error reading file</ToolResult>
+        </View>
+      );
+    }
+
+    if (!parsedResult) {
+      return (
+        <View flexDirection="column">
+          <ToolHeader name="Read" params={displayParams} status="pending" />
+        </View>
+      );
+    }
+
+    // Content comes clean from parsedResult.data (prefixes stripped by SDK parse())
+    const content = parsedResult.data.content ?? "";
+    const startLine = parsedResult.data.startLine ?? paramStartLine ?? 1;
+    const lineCount = parsedResult.data.lineCount ?? content.split("\n").length;
+
+    return (
+      <ReadFileResult
+        displayParams={displayParams}
+        content={content}
+        filePath={targetFile}
+        startLine={startLine}
+        lineCount={lineCount}
+      />
+    );
+  },
+};
+
+function ReadFileResult({
+  displayParams,
+  content,
+  filePath,
+  startLine,
+  lineCount,
+}: {
+  displayParams: string;
+  content: string;
+  filePath: string;
+  startLine: number;
+  lineCount: number;
+}) {
+  const [isExpanded, setIsExpanded] = useState(false);
+  const totalLines = content.split("\n").length;
+  const maxLines = isExpanded ? MAX_LINES_EXPANDED : MAX_LINES_COLLAPSED;
+  const canExpand = totalLines > MAX_LINES_COLLAPSED;
+
+  const { isFocused } = useFocus({
+    id: `read-file-${filePath}`,
+    isActive: canExpand,
+  });
+
+  useInput(
+    (input, key) => {
+      if (isFocused && key.ctrl && input === "o") {
+        setIsExpanded((prev) => !prev);
+      }
+    },
+    { isActive: isFocused && canExpand },
+  );
+
+  return (
+    <View flexDirection="column">
+      <ToolHeader name="Read" params={displayParams} status="success" />
+      <ToolResult>Read {lineCount} lines</ToolResult>
+      <PreviewContent>
+        <CodePreview
+          content={content}
+          filePath={filePath}
+          startLine={startLine}
+          maxLines={maxLines}
+        />
+      </PreviewContent>
+    </View>
+  );
+}

package/src/components/tools/filesystem/upload-image.tsx

@@ -0,0 +1,76 @@
+import type { ParsedToolResult } from "@codellm/agent";
+
+import { View } from "@codellm/jar";
+import React from "react";
+import { z } from "zod";
+
+import type { ToolDef, ToolStatus } from "../types.js";
+
+import { ToolHeader, ToolResult, truncatePath, snakeToCamel } from "../shared/index.js";
+
+const UploadImageToolParams = z.object({
+  targetFile: z.string(),
+  explanation: z.string().optional(),
+});
+
+export const uploadImageTool: ToolDef = {
+  displayName: "Upload",
+
+  getHeaderParams(input: Record<string, unknown>): string {
+    try {
+      const targetFile = (input?.targetFile || input?.target_file || "[unknown]") as string;
+      return truncatePath(targetFile);
+    } catch {
+      return "[unknown]";
+    }
+  },
+
+  renderUI(
+    rawInput: Record<string, unknown>,
+    status: ToolStatus,
+    parsedResult?: ParsedToolResult,
+  ): React.ReactElement {
+    const parseResult = UploadImageToolParams.safeParse(snakeToCamel(rawInput));
+    if (!parseResult.success) {
+      return (
+        <View flexDirection="column">
+          <ToolHeader name="Upload" params="" status="error" />
+          <ToolResult color="red">Invalid params</ToolResult>
+        </View>
+      );
+    }
+    const params = parseResult.data;
+    const { targetFile } = params;
+    const displayParams = truncatePath(targetFile);
+
+    const isExecuting = !parsedResult && (status === "executing" || status === "pending");
+
+    if (isExecuting) {
+      return <ToolHeader name="Upload" params={displayParams} status="pending" showSpinner />;
+    }
+
+    if (!parsedResult) {
+      return (
+        <View flexDirection="column">
+          <ToolHeader name="Upload" params={displayParams} status="pending" />
+        </View>
+      );
+    }
+
+    if (parsedResult.phase === "error") {
+      return (
+        <View flexDirection="column">
+          <ToolHeader name="Upload" params={displayParams} status="error" />
+          <ToolResult color="red">{parsedResult.errorMessage ?? "Error executing tool"}</ToolResult>
+        </View>
+      );
+    }
+
+    return (
+      <View flexDirection="column">
+        <ToolHeader name="Upload" params={displayParams} status="success" />
+        <ToolResult>{parsedResult.summary}</ToolResult>
+      </View>
+    );
+  },
+};