@travisennis/acai 0.0.7 → 0.0.9

package/dist/agent/index.js

@@ -1,9 +1,7 @@
-import { NoOutputGeneratedError, streamText, } from "ai";
+import { generateText, InvalidToolInputError, NoOutputGeneratedError, NoSuchToolError, Output, streamText, tool, } from "ai";
 import { config } from "../config.js";
 import { logger } from "../logger.js";
 import { AiConfig } from "../models/ai-config.js";
-import { isToolMessage } from "../tools/types.js";
-import { isAsyncIterable } from "../utils/iterables.js";
 export class Agent {
     opts;
     _state;
@@ -20,10 +18,10 @@ export class Agent {
         return this.abortController.signal;
     }
     async *run(args) {
-        const { modelManager, messageHistory, tokenTracker, maxIterations = (await config.getConfig()).loop.maxIterations, maxRetries = 2, toolCallRepair, } = this.opts;
+        const { modelManager, sessionManager, tokenTracker, maxIterations = (await config.getConfig()).loop.maxIterations, maxRetries = 2, } = this.opts;
         this.resetState();
         this._state.timestamps.start = performance.now();
-        const { systemPrompt, input, toolDefs, activeTools = undefined, executors, abortSignal, } = args;
+        const { systemPrompt, input, tools, activeTools, abortSignal } = args;
         const langModel = modelManager.getModel("repl");
         const modelConfig = modelManager.getModelMetadata("repl");
         const aiConfig = new AiConfig({
@@ -63,22 +61,34 @@ export class Agent {
                     model: langModel,
                     maxOutputTokens: aiConfig.maxOutputTokens(),
                     system: systemPrompt,
-                    messages: messageHistory.get(),
+                    messages: sessionManager.get(),
                     temperature: aiConfig.temperature(),
                     topP: aiConfig.topP(),
                     maxRetries: 2,
                     providerOptions: aiConfig.providerOptions(),
-                    tools: toolDefs,
+                    tools: Object.fromEntries(
+                    // biome-ignore lint/suspicious/noExplicitAny: temporary
+                    Object.entries(tools).map((t) => [t[0], tool(t[1].toolDef)])),
                     activeTools,
-                    // biome-ignore lint/style/useNamingConvention: third-party code
-                    experimental_repairToolCall: toolCallRepair,
+                    // biome-ignore lint/style/useNamingConvention: third-party controlled
+                    experimental_repairToolCall: toolCallRepair(modelManager),
                     abortSignal,
                     onAbort: ({ steps }) => {
                         logger.debug(`Aborting and processing ${steps.length} steps`);
                         steps.forEach((step) => {
-                            messageHistory.appendResponseMessages(step.response.messages);
+                            sessionManager.appendResponseMessages(step.response.messages);
                         });
                     },
+                    onError({ error }) {
+                        if (typeof error === "object" &&
+                            error != null &&
+                            "message" in error) {
+                            logger.error(error.message);
+                        }
+                        else {
+                            logger.error(error);
+                        }
+                    },
                 });
                 let accumulatedText = "";
                 let accumulatedReasoning = "";
@@ -134,11 +144,13 @@ export class Agent {
                     else if (chunk.type === "tool-call") {
                         const call = chunk;
                         const toolName = call.toolName;
+                        const iTool = tools[toolName];
                         yield this.processToolEvent(toolsCalled, {
                             type: "tool-call-start",
                             name: toolName,
                             toolCallId: call.toolCallId,
-                            msg: "",
+                            // biome-ignore lint/suspicious/noExplicitAny: unknown
+                            msg: iTool ? iTool.display(call.input) : "",
                             args: call.input,
                         });
                         if (call.invalid) {
@@ -155,88 +167,58 @@ export class Agent {
                         try {
                             thisStepToolCalls.push({ toolName });
                             thisStepToolResults.push({ toolName });
-                            const toolExec = executors.get(toolName);
-                            if (!toolExec) {
+                            const iTool = tools[toolName];
+                            if (!iTool) {
                                 resultOutput = `No executor for tool ${toolName}`;
                             }
                             else {
-                                try {
-                                    const output = await toolExec(call.input, {
-                                        toolCallId: call.toolCallId,
-                                        messages: messageHistory.get(),
-                                        abortSignal,
-                                    });
-                                    if (isAsyncIterable(output)) {
-                                        const toolResultValues = [];
-                                        for await (const value of output) {
-                                            if (isToolMessage(value)) {
-                                                if (call.toolCallId !== value.id) {
-                                                    logger.debug(`Tool ${call.toolName} ids don't match: ${call.toolCallId} != ${value.id}`);
-                                                }
-                                                const event = value.event;
-                                                switch (event) {
-                                                    case "tool-completion":
-                                                        yield this.processToolEvent(toolsCalled, {
-                                                            type: "tool-call-end",
-                                                            name: value.name,
-                                                            toolCallId: call.toolCallId,
-                                                            msg: value.data,
-                                                            args: call.input,
-                                                        });
-                                                        break;
-                                                    case "tool-error":
-                                                        yield this.processToolEvent(toolsCalled, {
-                                                            type: "tool-call-error",
-                                                            name: value.name,
-                                                            toolCallId: call.toolCallId,
-                                                            msg: value.data,
-                                                            args: call.input,
-                                                        });
-                                                        break;
-                                                    case "tool-update":
-                                                        yield this.processToolEvent(toolsCalled, {
-                                                            type: "tool-call-update",
-                                                            name: value.name,
-                                                            toolCallId: call.toolCallId,
-                                                            msg: value.data,
-                                                            args: call.input,
-                                                        });
-                                                        break;
-                                                    case "tool-init":
-                                                        yield this.processToolEvent(toolsCalled, {
-                                                            type: "tool-call-init",
-                                                            name: value.name,
-                                                            toolCallId: call.toolCallId,
-                                                            msg: value.data,
-                                                            args: call.input,
-                                                        });
-                                                        break;
-                                                    default:
-                                                        event;
-                                                        logger.debug(`Unhandled tool message event: ${event}`);
-                                                        break;
-                                                }
-                                            }
-                                            else {
-                                                toolResultValues.push(value);
-                                            }
-                                        }
-                                        const finalValue = toolResultValues.length > 0
-                                            ? toolResultValues.at(-1)
-                                            : undefined;
-                                        resultOutput = formatToolResult(finalValue);
+                                // Pre-validate tool input to catch malformed JSON early
+                                if (typeof call.input === "string") {
+                                    // If input is a string, try to validate it's proper JSON
+                                    try {
+                                        JSON.parse(call.input);
                                     }
-                                    else {
-                                        resultOutput = formatToolResult(output);
+                                    catch {
+                                        // Malformed JSON detected - emit error and skip execution
+                                        const errorMsg = `Invalid tool input: malformed JSON. Received: "${call.input.slice(0, 50)}${call.input.length > 50 ? "..." : ""}". Expected a JSON object.`;
                                         yield this.processToolEvent(toolsCalled, {
-                                            type: "tool-call-end",
-                                            name: call.toolName,
+                                            type: "tool-call-error",
+                                            name: toolName,
                                             toolCallId: call.toolCallId,
-                                            msg: "success",
+                                            msg: errorMsg,
                                             args: null,
                                         });
+                                        continue;
                                     }
                                 }
+                                else if (call.input === null || call.input === undefined) {
+                                    // Null/undefined input
+                                    const errorMsg = "Invalid tool input: received null/undefined. Expected a JSON object matching the schema.";
+                                    yield this.processToolEvent(toolsCalled, {
+                                        type: "tool-call-error",
+                                        name: toolName,
+                                        toolCallId: call.toolCallId,
+                                        msg: errorMsg,
+                                        args: null,
+                                    });
+                                    continue;
+                                }
+                                const toolExec = iTool.execute;
+                                try {
+                                    const output = await toolExec(call.input, {
+                                        toolCallId: call.toolCallId,
+                                        messages: sessionManager.get(),
+                                        abortSignal,
+                                    });
+                                    resultOutput = formatToolResult(output);
+                                    yield this.processToolEvent(toolsCalled, {
+                                        type: "tool-call-end",
+                                        name: call.toolName,
+                                        toolCallId: call.toolCallId,
+                                        msg: resultOutput,
+                                        args: call.input,
+                                    });
+                                }
                                 catch (err) {
                                     resultOutput = `Tool error: ${err instanceof Error ? err.message : String(err)}`;
                                     yield this.processToolEvent(toolsCalled, {
@@ -278,21 +260,23 @@ export class Agent {
                 // Get response and tool calls
                 const response = await result.response;
                 const responseMessages = response.messages;
-                messageHistory.appendResponseMessages(responseMessages);
+                sessionManager.appendResponseMessages(responseMessages);
                 const stepUsage = await result.usage;
                 this._state.usage.inputTokens = stepUsage.inputTokens ?? 0;
                 this._state.usage.outputTokens = stepUsage.outputTokens ?? 0;
                 this._state.usage.totalTokens = stepUsage.totalTokens ?? 0;
-                this._state.usage.cachedInputTokens = stepUsage.cachedInputTokens ?? 0;
-                this._state.usage.reasoningTokens = stepUsage.reasoningTokens ?? 0;
-                messageHistory.setContextWindow(stepUsage.totalTokens ?? 0);
+                this._state.usage.cachedInputTokens =
+                    stepUsage.inputTokenDetails.cacheReadTokens ?? 0;
+                this._state.usage.reasoningTokens =
+                    stepUsage.outputTokenDetails.reasoningTokens ?? 0;
+                sessionManager.setContextWindow(stepUsage.totalTokens ?? 0);
                 this._state.totalUsage.inputTokens += stepUsage.inputTokens ?? 0;
                 this._state.totalUsage.outputTokens += stepUsage.outputTokens ?? 0;
                 this._state.totalUsage.totalTokens += stepUsage.totalTokens ?? 0;
                 this._state.totalUsage.cachedInputTokens +=
-                    stepUsage.cachedInputTokens ?? 0;
+                    stepUsage.inputTokenDetails.cacheReadTokens ?? 0;
                 this._state.totalUsage.reasoningTokens +=
-                    stepUsage.reasoningTokens ?? 0;
+                    stepUsage.outputTokenDetails.reasoningTokens ?? 0;
                 // If finishReason is not tool-calls, break
                 const finishReason = await result.finishReason;
                 if (finishReason !== "tool-calls") {
@@ -302,7 +286,7 @@ export class Agent {
                     hasEmittedTerminalEvent = true;
                     break;
                 }
-                messageHistory.appendToolMessages(toolMessages);
+                sessionManager.appendToolMessages(toolMessages);
                 // Consume the rest of the team if necessary
                 // await result.consumeStream();
                 yield {
@@ -313,18 +297,29 @@ export class Agent {
             }
             catch (error) {
                 consecutiveErrors += 1;
-                logger.error(error, // Log the full error object
-                `Error on manual agent loop streamText (attempt ${consecutiveErrors}/${maxRetries + 1})`);
-                const errorMsg = error.message.length > 100
-                    ? `${error.message.slice(0, 100)}...`
-                    : error.message;
-                yield {
-                    type: "agent-error",
-                    message: errorMsg,
-                };
-                if (NoOutputGeneratedError.isInstance(error)) {
-                    hasEmittedTerminalEvent = true;
-                    break;
+                // Handle AI SDK invalid tool input errors gracefully
+                if (InvalidToolInputError.isInstance(error)) {
+                    logger.warn(error, `Invalid tool input detected - returning error to allow recovery (attempt ${consecutiveErrors}/${maxRetries + 1})`);
+                    yield {
+                        type: "agent-error",
+                        message: `Tool input validation failed: ${error.message}. Try again with valid arguments.`,
+                    };
+                    // Continue loop to allow user to provide corrected input
+                }
+                else {
+                    logger.error(error, // Log the full error object
+                    `Error on manual agent loop streamText (attempt ${consecutiveErrors}/${maxRetries + 1})`);
+                    const errorMsg = error.message.length > 100
+                        ? `${error.message.slice(0, 100)}...`
+                        : error.message;
+                    yield {
+                        type: "agent-error",
+                        message: errorMsg,
+                    };
+                    if (NoOutputGeneratedError.isInstance(error)) {
+                        hasEmittedTerminalEvent = true;
+                        break;
+                    }
                 }
                 // Break loop if we exceed max retries
                 if (consecutiveErrors > maxRetries) {
@@ -356,7 +351,7 @@ export class Agent {
     }
     resetState() {
         const { modelManager,
-        // messageHistory,
+        // sessionManager,
          } = this.opts;
         this._state = {
             modelId: modelManager.getModel("repl").modelId,
@@ -367,6 +362,15 @@ export class Agent {
                 totalTokens: 0,
                 reasoningTokens: 0,
                 cachedInputTokens: 0,
+                inputTokenDetails: {
+                    noCacheTokens: 0,
+                    cacheReadTokens: 0,
+                    cacheWriteTokens: 0,
+                },
+                outputTokenDetails: {
+                    textTokens: 0,
+                    reasoningTokens: 0,
+                },
             },
             totalUsage: {
                 inputTokens: 0,
@@ -374,6 +378,15 @@ export class Agent {
                 totalTokens: 0,
                 reasoningTokens: 0,
                 cachedInputTokens: 0,
+                inputTokenDetails: {
+                    noCacheTokens: 0,
+                    cacheReadTokens: 0,
+                    cacheWriteTokens: 0,
+                },
+                outputTokenDetails: {
+                    textTokens: 0,
+                    reasoningTokens: 0,
+                },
             },
             steps: [],
             timestamps: {
@@ -432,3 +445,32 @@ function formatToolResult(value) {
     }
     return String(value);
 }
+const toolCallRepair = (modelManager) => {
+    const fn = async ({ toolCall, tools, inputSchema, error, }) => {
+        if (NoSuchToolError.isInstance(error)) {
+            return null; // do not attempt to fix invalid tool names
+        }
+        const tool = tools[toolCall.toolName];
+        try {
+            const { output: repairedArgs } = await generateText({
+                model: modelManager.getModel("tool-repair"),
+                output: Output.object({
+                    schema: tool.inputSchema,
+                }),
+                prompt: [
+                    `The model tried to call the tool "${toolCall.toolName}" with the following arguments:`,
+                    JSON.stringify(toolCall.input),
+                    "The tool accepts the following schema:",
+                    JSON.stringify(inputSchema(toolCall)),
+                    "Please fix the arguments.",
+                ].join("\n"),
+            });
+            return { ...toolCall, args: JSON.stringify(repairedArgs) };
+        }
+        catch (err) {
+            logger.error(err, `Failed to repair tool call: ${toolCall.toolName}.`);
+            return null;
+        }
+    };
+    return fn;
+};

package/dist/cli.d.ts

@@ -1,11 +1,11 @@
 import type { WorkspaceContext } from "./index.ts";
-import type { MessageHistory } from "./messages.ts";
 import type { ModelManager } from "./models/manager.js";
 import type { PromptManager } from "./prompts/manager.ts";
+import type { SessionManager } from "./sessions/manager.ts";
 import type { TokenCounter } from "./tokens/counter.ts";
 import type { TokenTracker } from "./tokens/tracker.ts";
 interface CliOptions {
-    messageHistory: MessageHistory;
+    messageHistory: SessionManager;
     promptManager: PromptManager;
     modelManager: ModelManager;
     tokenTracker: TokenTracker;

package/dist/cli.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../source/cli.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAEnD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAEpD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACxD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAE1D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACxD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AASxD,UAAU,UAAU;IAClB,cAAc,EAAE,cAAc,CAAC;IAC/B,aAAa,EAAE,aAAa,CAAC;IAC7B,YAAY,EAAE,YAAY,CAAC;IAC3B,YAAY,EAAE,YAAY,CAAC;IAC3B,YAAY,EAAE,YAAY,CAAC;IAC3B,SAAS,EAAE,gBAAgB,CAAC;IAC5B,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB;AAWD,qBAAa,GAAG;IACd,OAAO,CAAC,OAAO,CAAa;IAC5B,OAAO,CAAC,aAAa,CAAU;gBACnB,OAAO,EAAE,UAAU;IAKzB,GAAG;CAiHV"}
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../source/cli.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAGnD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACxD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAE1D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAC5D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACxD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAQxD,UAAU,UAAU;IAClB,cAAc,EAAE,cAAc,CAAC;IAC/B,aAAa,EAAE,aAAa,CAAC;IAC7B,YAAY,EAAE,YAAY,CAAC;IAC3B,YAAY,EAAE,YAAY,CAAC;IAC3B,YAAY,EAAE,YAAY,CAAC;IAC3B,SAAS,EAAE,gBAAgB,CAAC;IAC5B,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB;AAUD,qBAAa,GAAG;IACd,OAAO,CAAC,OAAO,CAAa;IAC5B,OAAO,CAAC,aAAa,CAAU;gBACnB,OAAO,EAAE,UAAU;IAKzB,GAAG;CAuHV"}

package/dist/cli.js

@@ -1,13 +1,12 @@
-import { generateObject, generateText, NoSuchToolError, stepCountIs, } from "ai";
+import { generateText, NoSuchToolError, Output, stepCountIs, tool, } from "ai";
 import { logger } from "./logger.js";
 import { AiConfig } from "./models/ai-config.js";
 import { systemPrompt } from "./prompts.js";
 import { BashTool } from "./tools/bash.js";
-import { CodeInterpreterTool } from "./tools/code-interpreter.js";
 import { EditFileTool } from "./tools/edit-file.js";
 import { GlobTool } from "./tools/glob.js";
 import { GrepTool } from "./tools/grep.js";
-import { initCliTools } from "./tools/index.js";
+import { initTools } from "./tools/index.js";
 import { ReadFileTool } from "./tools/read-file.js";
 const activeTools = [
     EditFileTool.name,
@@ -15,7 +14,6 @@ const activeTools = [
     BashTool.name,
     GrepTool.name,
     GlobTool.name,
-    CodeInterpreterTool.name,
 ];
 export class Cli {
     options;
@@ -25,7 +23,7 @@ export class Cli {
         this.skillsEnabled = options.skillsEnabled ?? true;
     }
     async run() {
-        const { promptManager, modelManager, tokenTracker, messageHistory, tokenCounter, } = this.options;
+        const { promptManager, modelManager, tokenTracker, messageHistory } = this.options;
         const abortController = new AbortController();
         const { signal } = abortController;
         const cb = () => {
@@ -38,18 +36,17 @@ export class Cli {
         const userPrompt = promptManager.get();
         const userMsg = promptManager.getUserMessage();
         messageHistory.appendUserMessage(userMsg);
-        const finalSystemPrompt = await systemPrompt({
-            type: "cli",
+        const finalSystemPromptResult = await systemPrompt({
             activeTools,
             allowedDirs: this.options.workspace.allowedDirs,
             skillsEnabled: this.skillsEnabled,
         });
+        const finalSystemPrompt = finalSystemPromptResult.prompt;
         const aiConfig = new AiConfig({
             modelMetadata: modelConfig,
             prompt: userPrompt,
         });
-        const tools = await initCliTools({
-            tokenCounter,
+        const tools = await initTools({
             workspace: this.options.workspace,
         });
         // Cleanup function to remove signal handler
@@ -64,10 +61,16 @@ export class Cli {
                 messages: messageHistory.get(),
                 temperature: aiConfig.temperature(),
                 topP: aiConfig.topP(),
-                stopWhen: stepCountIs(60),
+                stopWhen: stepCountIs(200),
                 maxRetries: 2,
                 providerOptions: aiConfig.providerOptions(),
-                tools: tools.toolDefs,
+                tools: Object.fromEntries(Object.entries(tools).map((t) => [
+                    t[0],
+                    tool({
+                        ...t[1]["toolDef"],
+                        execute: t[1]["execute"],
+                    }),
+                ])),
                 activeTools,
                 // biome-ignore lint/style/useNamingConvention: third-party controlled
                 experimental_repairToolCall: toolCallRepair(modelManager),
@@ -78,18 +81,19 @@ export class Cli {
             }
             // this tracks the usage of every step in the call to streamText. it's a cumulative usage.
             tokenTracker.trackUsage("cli", result.usage);
-            messageHistory.save();
+            await messageHistory.save();
             process.stdout.end(result.text.endsWith("\n") ? result.text : `${result.text}\n`);
             cleanup();
         }
         catch (e) {
             // Always cleanup signal handler
             cleanup();
-            // Check if it's an abort error
-            const isAbortError = e instanceof Error &&
+            // Check if it's an abort error or if the signal was aborted
+            const isAbortError = (e instanceof Error &&
                 (e.name === "AbortError" ||
                     e.message.includes("aborted") ||
-                    e.message.includes("No output generated"));
+                    e.message.includes("No output generated"))) ||
+                signal.aborted;
             if (isAbortError) {
                 logger.info("CLI execution interrupted by user");
                 // Try to save message history before exiting
@@ -121,9 +125,11 @@ const toolCallRepair = (modelManager) => {
         }
         const tool = tools[toolCall.toolName];
         try {
-            const { object: repairedArgs } = await generateObject({
+            const { output: repairedArgs } = await generateText({
                 model: modelManager.getModel("tool-repair"),
-                schema: tool.inputSchema,
+                output: Output.object({
+                    schema: tool.inputSchema,
+                }),
                 prompt: [
                     `The model tried to call the tool "${toolCall.toolName}" with the following arguments:`,
                     JSON.stringify(toolCall.input),

package/dist/commands/add-directory/index.d.ts

@@ -0,0 +1,3 @@
+import type { CommandOptions, ReplCommand } from "../types.ts";
+export declare const addDirectoryCommand: ({ workspace, }: CommandOptions) => ReplCommand;
+//# sourceMappingURL=index.d.ts.map

package/dist/commands/add-directory/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../source/commands/add-directory/index.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAG/D,eAAO,MAAM,mBAAmB,GAAI,gBAEjC,cAAc,KAAG,WAwFnB,CAAC"}

package/dist/commands/{add-directory-command.js → add-directory/index.js}

@@ -1,7 +1,6 @@
-import fs from "node:fs/promises";
-import path from "node:path";
-import style from "../terminal/style.js";
-import { Text } from "../tui/index.js";
+import style from "../../terminal/style.js";
+import { Text } from "../../tui/index.js";
+import { resolveDirectoryPath, validateDirectory } from "./utils.js";
 export const addDirectoryCommand = ({ workspace, }) => {
     return {
         command: "/add-directory",
@@ -18,23 +17,20 @@ export const addDirectoryCommand = ({ workspace, }) => {
                 return "continue";
             }
             try {
-                // Resolve and validate the directory
-                const resolvedPath = path.resolve(directoryPath);
-                const stats = await fs.stat(resolvedPath);
-                if (!stats.isDirectory()) {
+                const resolvedPath = resolveDirectoryPath(directoryPath);
+                const isValid = await validateDirectory(resolvedPath);
+                if (!isValid) {
                     container.addChild(new Text(style.red(`Path is not a directory: ${resolvedPath}`), 1, 0));
                     tui.requestRender();
                     editor.setText("");
                     return "continue";
                 }
-                // Check if directory is already in the list
                 if (workspace.allowedDirs.includes(resolvedPath)) {
                     container.addChild(new Text(style.yellow(`Directory already in allowed list: ${resolvedPath}`), 1, 0));
                     tui.requestRender();
                     editor.setText("");
                     return "continue";
                 }
-                // Add the directory to the workspace
                 workspace.allowedDirs.push(resolvedPath);
                 container.addChild(new Text(`Added directory to allowed list: ${style.blue(resolvedPath)}`, 1, 0));
                 container.addChild(new Text(`Current allowed directories: ${style.blue(workspace.allowedDirs.join(", "))}`, 2, 0));

package/dist/commands/add-directory/types.d.ts

@@ -0,0 +1,6 @@
+import type { WorkspaceContext } from "../../index.ts";
+export interface AddDirectoryOptions {
+    workspace: WorkspaceContext;
+}
+export type { WorkspaceContext };
+//# sourceMappingURL=types.d.ts.map

package/dist/commands/add-directory/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../source/commands/add-directory/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAEvD,MAAM,WAAW,mBAAmB;IAClC,SAAS,EAAE,gBAAgB,CAAC;CAC7B;AAED,YAAY,EAAE,gBAAgB,EAAE,CAAC"}

package/dist/commands/add-directory/types.js

@@ -0,0 +1 @@
+export {};

package/dist/commands/add-directory/utils.d.ts

@@ -0,0 +1,3 @@
+export declare function validateDirectory(dirPath: string): Promise<boolean>;
+export declare function resolveDirectoryPath(dirPath: string): string;
+//# sourceMappingURL=utils.d.ts.map

package/dist/commands/add-directory/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../source/commands/add-directory/utils.ts"],"names":[],"mappings":"AAGA,wBAAsB,iBAAiB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAQzE;AAED,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAE5D"}

package/dist/commands/add-directory/utils.js

@@ -0,0 +1,15 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+export async function validateDirectory(dirPath) {
+    try {
+        const resolvedPath = path.resolve(dirPath);
+        const stats = await fs.stat(resolvedPath);
+        return stats.isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+export function resolveDirectoryPath(dirPath) {
+    return path.resolve(dirPath);
+}

package/dist/commands/clear/index.d.ts

@@ -0,0 +1,3 @@
+import type { CommandOptions, ReplCommand } from "../types.ts";
+export declare const clearCommand: (_options: CommandOptions) => ReplCommand;
+//# sourceMappingURL=index.d.ts.map

package/dist/commands/clear/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../source/commands/clear/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAE/D,eAAO,MAAM,YAAY,GAAI,UAAU,cAAc,KAAG,WAmBvD,CAAC"}

package/dist/commands/{clear-command.js → clear/index.js}

@@ -4,8 +4,6 @@ export const clearCommand = (_options) => {
         description: "Clears the terminal screen.",
         getSubCommands: () => Promise.resolve([]),
         async handle(_args, { tui, container, editor, }) {
-            // In TUI mode, we can't clear the screen like terminal.clear()
-            // Instead, we'll just clear the input and show a message
             container.clear();
             tui.requestRender();
             editor.setText("");

package/dist/commands/copy/index.d.ts

@@ -0,0 +1,3 @@
+import type { CommandOptions, ReplCommand } from "../types.ts";
+export declare function copyCommand(options: CommandOptions): ReplCommand;
+//# sourceMappingURL=index.d.ts.map

package/dist/commands/copy/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../source/commands/copy/index.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAG/D,wBAAgB,WAAW,CAAC,OAAO,EAAE,cAAc,GAAG,WAAW,CAmDhE"}