Refactor code for consistency: standardize import formatting, enhance error handling, and improve component rendering logic

Author: habedi

src/agent/autofix.ts

@@ -0,0 +1,47 @@
+// src/agent/autofix.ts
+// CORRECTED: Adjusted the function signature to resolve the complex generic type error with streamObject.
+
+import {createOpenAI} from "@ai-sdk/openai";
+import {streamObject} from "ai";
+import {z} from "zod";
+import logger from "@/logger.js";
+
+const getFixerClient = () => {
+    const apiKey = process.env.OPENAI_API_KEY;
+    if (!apiKey) {
+        logger.warn("Autofix requires OPENAI_API_KEY to be set for a fixer model.");
+        return null;
+    }
+    return createOpenAI({apiKey})("gpt-4.1-mini");
+};
+
+const fixJsonPrompt = (badJson: string) => `
+The following string is invalid JSON produced by an AI. Your task is to fix it.
+Respond ONLY with the corrected JSON object. Do not add any commentary, just the JSON.
+
+Invalid JSON:
+${badJson}
+`;
+
+// The schema is now constrained to `z.ZodObject<any>`, which is more compatible with the AI SDK.
+export async function autofixJson(
+    schema: z.ZodObject<any>,
+    brokenJson: string,
+): Promise<z.infer<typeof schema> | null> {
+    const fixer = getFixerClient();
+    if (!fixer) return null;
+
+    try {
+        // The call to streamObject now works with the simplified type.
+        const {object} = await streamObject({
+            model: fixer,
+            prompt: fixJsonPrompt(brokenJson),
+            schema: schema,
+        });
+        // We still parse here to ensure the final object conforms to the specific schema passed in.
+        return schema.parse(object);
+    } catch (e) {
+        logger.error("JSON autofixing failed.", e);
+        return null;
+    }
+}

src/agent/errors.ts

@@ -1,4 +1,5 @@
 // src/agent/errors.ts
+// REFACTORED: Centralized all custom agent errors in one place.
 
 /**
  * A base class for all custom errors in the application.
@@ -12,18 +13,39 @@ export class AppError extends Error {
 
 /**
  * Represents an error that is fatal and should stop the agent's execution.
- * Examples: Invalid API key, configuration errors.
  */
-export class FatalError extends AppError {}
+export class FatalError extends AppError {
+}
 
 /**
  * Represents a transient error that might be resolved by retrying.
- * Examples: Temporary network issues, rate limiting.
  */
-export class TransientError extends AppError {}
+export class TransientError extends AppError {
+}
 
 /**
  * Represents an error related to tool execution.
- * Examples: Tool not found, invalid arguments, tool failed to run.
  */
-export class ToolError extends AppError {}
+export class ToolError extends AppError {
+}
+
+/**
+ * Thrown when an edit is attempted on a file that has been modified
+ * since it was last read by the agent.
+ */
+export class FileOutdatedError extends ToolError {
+    constructor(message: string) {
+        super(message);
+        this.name = this.constructor.name;
+    }
+}
+
+/**
+ * Thrown when a 'create' operation is attempted on a file that already exists.
+ */
+export class FileExistsError extends ToolError {
+    constructor(message: string) {
+        super(message);
+        this.name = this.constructor.name;
+    }
+}

src/agent/file-tracker.ts

@@ -1,30 +1,13 @@
 // src/agent/file-tracker.ts
+// REFACTORED: Imports errors from the new centralized `errors.ts`.
+
 import fs from "fs/promises";
 import path from "path";
-
-// --- Custom Error Types ---
-export class FileOutdatedError extends Error {
-    constructor(message: string) {
-        super(message);
-        this.name = this.constructor.name;
-    }
-}
-
-export class FileExistsError extends Error {
-    constructor(message: string) {
-        super(message);
-        this.name = this.constructor.name;
-    }
-}
+import {FileExistsError, FileOutdatedError} from "./errors.js";
 
 export class FileTracker {
-    // A map to store the last known modification time of a file
     private readTimestamps = new Map<string, number>();
 
-    /**
-     * Reads a file, records its modification time, and returns the content.
-     * All tool reads should use this method.
-     */
     async read(filePath: string): Promise<string> {
         const absolutePath = path.resolve(filePath);
         const content = await fs.readFile(absolutePath, "utf8");
@@ -33,44 +16,27 @@ export class FileTracker {
         return content;
     }
 
-    /**
-     * Writes to a file, and updates its modification time in the tracker.
-     * All tool writes should use this method.
-     */
     async write(filePath: string, content: string): Promise<void> {
         const absolutePath = path.resolve(filePath);
         const dir = path.dirname(absolutePath);
-        await fs.mkdir(dir, { recursive: true });
+        await fs.mkdir(dir, {recursive: true});
         await fs.writeFile(absolutePath, content, "utf8");
         const modified = await this.getModifiedTime(absolutePath);
         this.readTimestamps.set(absolutePath, modified);
     }
 
-    /**
-     * Throws an error if a file exists. Used by the 'create' tool.
-     */
     async assertCanCreate(filePath: string): Promise<void> {
         try {
             await fs.access(filePath);
-            // If fs.access doesn't throw, the file exists.
             throw new FileExistsError(
                 `File already exists at ${filePath}. Use the 'edit' tool to modify it.`,
             );
         } catch (error) {
-            if (error instanceof FileExistsError) {
-                throw error;
-            }
-            if ((error as NodeJS.ErrnoException).code !== "ENOENT") {
-                throw error;
-            }
-            // Any other error (like ENOENT) means the file doesn't exist, which is good.
+            if (error instanceof FileExistsError) throw error;
+            if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
         }
     }
 
-    /**
-     * Throws an error if a file has been modified since it was last read/written by the tracker.
-     * This is the core safety check for the 'edit' tool.
-     */
     async assertCanEdit(filePath: string): Promise<void> {
         const absolutePath = path.resolve(filePath);
         if (!this.readTimestamps.has(absolutePath)) {
@@ -81,12 +47,10 @@ export class FileTracker {
 
         const lastReadTime = this.readTimestamps.get(absolutePath)!;
         let currentModifiedTime;
-
         try {
             currentModifiedTime = await this.getModifiedTime(absolutePath);
         } catch (error) {
             if ((error as NodeJS.ErrnoException).code === "ENOENT") {
-                // If the file was deleted after being read
                 throw new FileOutdatedError(
                     "File seems to have been deleted after it was last read.",
                 );
@@ -95,7 +59,6 @@ export class FileTracker {
         }
 
         if (currentModifiedTime > lastReadTime) {
-            // Invalidate the timestamp and throw
             this.readTimestamps.delete(absolutePath);
             throw new FileOutdatedError(
                 "File was modified since it was last read. Please read the file again to get the latest version.",
@@ -109,5 +72,4 @@ export class FileTracker {
     }
 }
 
-// Export a single instance for the entire application to use
 export const fileTracker = new FileTracker();

src/agent/history.ts

@@ -1,4 +1,47 @@
 // src/agent/history.ts
-import type { AssistantToolCall, Message, ToolCall } from "./types.js";
+// REFACTORED: This file now defines the rich, structured history for the agent.
+// This is a core concept from Octofriend that enables more intelligent UI and logic.
 
-export type { Message, AssistantToolCall, ToolCall };
+import type {AssistantContent} from "ai";
+import type {ToolCall} from "./types.js";
+
+export type UserMessageItem = {
+    id: string;
+    role: "user";
+    content: string;
+};
+
+export type AssistantMessageItem = {
+    id: string;
+    role: "assistant";
+    content: AssistantContent | string;
+};
+
+export type ToolRequestItem = {
+    id: string;
+    role: "tool-request";
+    calls: ToolCall[];
+};
+
+export type ToolResultItem = {
+    id: string;
+    role: "tool-result";
+    toolCallId: string;
+    toolName: string;
+    output: unknown;
+};
+
+export type ToolFailureItem = {
+    id: string;
+    role: "tool-failure";
+    toolCallId: string;
+    toolName: string;
+    error: string;
+};
+
+export type HistoryItem =
+    | UserMessageItem
+    | AssistantMessageItem
+    | ToolRequestItem
+    | ToolResultItem
+    | ToolFailureItem;