@travisennis/acai 0.0.5 → 0.0.6

package/dist/agent/manual-loop.js

@@ -0,0 +1,278 @@
+import { NoOutputGeneratedError, streamText, } from "ai";
+import { logger } from "../logger.js";
+import { AiConfig } from "../models/ai-config.js";
+import { displayToolMessages } from "../repl/display-tool-messages.js";
+import style from "../terminal/style.js";
+import { isToolMessage } from "../tools/types.js";
+import { isAsyncIterable } from "../utils/iterables.js";
+export async function runManualLoop(opts) {
+    const { modelManager, messageHistory, systemPrompt, input, toolDefs, executors, maxIterations = 90, maxRetries = 2, abortSignal, toolCallRepair, } = opts;
+    const terminal = opts.terminal;
+    const langModel = modelManager.getModel("repl");
+    const modelConfig = modelManager.getModelMetadata("repl");
+    const aiConfig = new AiConfig({
+        modelMetadata: modelConfig,
+        prompt: input,
+    });
+    const loopResult = {
+        usage: {
+            inputTokens: 0,
+            outputTokens: 0,
+            totalTokens: 0,
+            reasoningTokens: 0,
+            cachedInputTokens: 0,
+        },
+        totalUsage: {
+            inputTokens: 0,
+            outputTokens: 0,
+            totalTokens: 0,
+            reasoningTokens: 0,
+            cachedInputTokens: 0,
+        },
+        steps: [],
+    };
+    let iter = 0;
+    let consecutiveErrors = 0;
+    while (iter < maxIterations) {
+        if (abortSignal?.aborted) {
+            logger.warn("The agent loop was aborted by the user.");
+            terminal.warn("Operation aborted by user.");
+            break;
+        }
+        try {
+            const result = streamText({
+                model: langModel,
+                maxOutputTokens: aiConfig.maxOutputTokens(),
+                system: systemPrompt,
+                messages: messageHistory.get(),
+                temperature: aiConfig.temperature(),
+                topP: aiConfig.topP(),
+                maxRetries: 2,
+                providerOptions: aiConfig.providerOptions(),
+                tools: toolDefs,
+                // biome-ignore lint/style/useNamingConvention: third-party code
+                experimental_repairToolCall: toolCallRepair,
+                abortSignal,
+            });
+            let accumulatedText = "";
+            let lastType = null;
+            for await (const chunk of result.fullStream) {
+                if (chunk.type === "reasoning-delta" || chunk.type === "text-delta") {
+                    if (chunk.type === "reasoning-delta") {
+                        if (lastType !== "reasoning") {
+                            terminal.writeln(style.dim("<think>"));
+                        }
+                        terminal.write(style.dim(chunk.text));
+                        lastType = "reasoning";
+                    }
+                    else {
+                        terminal.stopProgress();
+                        if (lastType === "reasoning") {
+                            terminal.writeln(style.dim("\n</think>\n"));
+                        }
+                        accumulatedText += chunk.text;
+                        lastType = "text";
+                    }
+                }
+                else {
+                    // finish off this step
+                    if (lastType === "reasoning") {
+                        terminal.write(style.dim("\n</think>\n\n"));
+                    }
+                    terminal.stopProgress();
+                    if (accumulatedText.trim()) {
+                        terminal.writeln(`${style.blue.bold("● Response:")}`);
+                        terminal.display(accumulatedText, true);
+                        terminal.lineBreak();
+                    }
+                    accumulatedText = "";
+                    lastType = null;
+                }
+            }
+            // Get response and tool calls
+            const response = await result.response;
+            const responseMessages = response.messages;
+            messageHistory.appendResponseMessages(responseMessages);
+            const toolCalls = await result.toolCalls;
+            const thisStepToolCalls = [];
+            const thisStepToolResults = [];
+            loopResult.steps.push({
+                toolCalls: thisStepToolCalls,
+                toolResults: thisStepToolResults,
+            });
+            // If finishReason is not tool-calls, break
+            const finishReason = await result.finishReason;
+            if (finishReason !== "tool-calls") {
+                const lastStepUsage = await result.usage;
+                loopResult.usage.inputTokens = lastStepUsage.inputTokens ?? 0;
+                loopResult.usage.outputTokens = lastStepUsage.outputTokens ?? 0;
+                loopResult.usage.totalTokens = lastStepUsage.totalTokens ?? 0;
+                loopResult.usage.cachedInputTokens =
+                    lastStepUsage.cachedInputTokens ?? 0;
+                loopResult.usage.reasoningTokens = lastStepUsage.reasoningTokens ?? 0;
+                loopResult.totalUsage.inputTokens += lastStepUsage.inputTokens ?? 0;
+                loopResult.totalUsage.outputTokens += lastStepUsage.outputTokens ?? 0;
+                loopResult.totalUsage.totalTokens += lastStepUsage.totalTokens ?? 0;
+                loopResult.totalUsage.cachedInputTokens +=
+                    lastStepUsage.cachedInputTokens ?? 0;
+                loopResult.totalUsage.reasoningTokens +=
+                    lastStepUsage.reasoningTokens ?? 0;
+                break;
+            }
+            // Execute tools in parallel (order not guaranteed)
+            // Check response.messages for already-processed tool results
+            const alreadyProcessedToolCallIds = new Set();
+            // Look for tool results and tool errors in the response messages
+            for (const message of responseMessages) {
+                if (message.role === "tool" && Array.isArray(message.content)) {
+                    for (const content of message.content) {
+                        if ((content.type === "tool-result" ||
+                            content.type === "tool-error") &&
+                            content.toolCallId) {
+                            alreadyProcessedToolCallIds.add(content.toolCallId);
+                        }
+                    }
+                }
+            }
+            // Filter out tool calls that have already been processed or are invalid
+            const validToolCalls = toolCalls.filter((call) => !alreadyProcessedToolCallIds.has(call.toolCallId) &&
+                // Also check if the tool call is marked as invalid by the AI SDK
+                !call.invalid);
+            if (validToolCalls.length === 0) {
+                // All tool calls were already processed by the AI SDK
+                logger.debug(`All ${toolCalls.length} tool calls were already processed by AI SDK, skipping manual execution`);
+                continue;
+            }
+            if (validToolCalls.length < toolCalls.length) {
+                logger.debug(`Filtered out ${toolCalls.length - validToolCalls.length} already-processed tool calls, executing ${validToolCalls.length} remaining`);
+            }
+            // Process all tools concurrently
+            const toolMessagesPromise = Promise.allSettled(validToolCalls.map(async (call) => {
+                const toolName = call.toolName;
+                let resultOutput = "Unknown result.";
+                try {
+                    thisStepToolCalls.push({ toolName });
+                    thisStepToolResults.push({ toolName });
+                    const exec = executors.get(toolName);
+                    if (!exec) {
+                        resultOutput = `No executor for tool ${toolName}`;
+                    }
+                    else {
+                        try {
+                            const output = await exec(call.input, {
+                                toolCallId: call.toolCallId,
+                                messages: messageHistory.get(),
+                                abortSignal,
+                            });
+                            if (isAsyncIterable(output)) {
+                                const { finalValue } = await consumeToolAsyncIterable(output, terminal);
+                                resultOutput = formatToolResult(finalValue);
+                            }
+                            else {
+                                resultOutput = formatToolResult(output);
+                            }
+                        }
+                        catch (err) {
+                            resultOutput = `Tool error: ${err instanceof Error ? err.message : String(err)}`;
+                        }
+                    }
+                }
+                catch (error) {
+                    resultOutput = `Tool error: ${error instanceof Error ? error.message : String(error)}`;
+                }
+                return {
+                    role: "tool",
+                    content: [
+                        {
+                            type: "tool-result",
+                            toolName,
+                            toolCallId: call.toolCallId,
+                            output: {
+                                type: "text",
+                                value: resultOutput,
+                            },
+                        },
+                    ],
+                };
+            }));
+            const toolMessages = (await toolMessagesPromise)
+                .filter((result) => result.status === "fulfilled")
+                .map((result) => result.value);
+            messageHistory.appendToolMessages(toolMessages);
+            // Calculate usage for the current step/iteration
+            const stepUsage = await result.usage;
+            loopResult.totalUsage.inputTokens += stepUsage.inputTokens ?? 0;
+            loopResult.totalUsage.outputTokens += stepUsage.outputTokens ?? 0;
+            loopResult.totalUsage.totalTokens += stepUsage.totalTokens ?? 0;
+            loopResult.totalUsage.cachedInputTokens +=
+                stepUsage.cachedInputTokens ?? 0;
+            loopResult.totalUsage.reasoningTokens += stepUsage.reasoningTokens ?? 0;
+            // Consume the rest of the team if necessary
+            // await result.consumeStream();
+            // continue iterations
+            iter += 1;
+        }
+        catch (error) {
+            consecutiveErrors += 1;
+            logger.error(error, // Log the full error object
+            `Error on manual agent loop streamText (attempt ${consecutiveErrors}/${maxRetries + 1})`);
+            terminal.error("Error in manual agent loop.");
+            terminal.error(error.message.length > 100
+                ? `${error.message.slice(0, 100)}...`
+                : error.message);
+            if (NoOutputGeneratedError.isInstance(error)) {
+                break;
+            }
+            // Break loop if we exceed max retries
+            if (consecutiveErrors > maxRetries) {
+                terminal.error(`Exceeded maximum retry attempts (${maxRetries}). Stopping manual loop.`);
+                break;
+            }
+        }
+    }
+    return loopResult;
+}
+export async function consumeToolAsyncIterable(iterable, terminal) {
+    const iterator = iterable[Symbol.asyncIterator]();
+    const toolResultValues = [];
+    let next = await iterator.next();
+    while (!next.done) {
+        const value = next.value;
+        if (isToolMessage(value)) {
+            if (terminal) {
+                displayToolMessages(value, terminal);
+            }
+        }
+        else {
+            toolResultValues.push(value);
+        }
+        next = await iterator.next();
+    }
+    const finalValue = next.value ??
+        (toolResultValues.length > 0 ? toolResultValues.at(-1) : undefined);
+    return { finalValue };
+}
+function formatToolResult(value) {
+    if (typeof value === "string") {
+        return value;
+    }
+    if (value === undefined) {
+        return "";
+    }
+    if (value === null) {
+        return "null";
+    }
+    if (typeof value === "number" || typeof value === "boolean") {
+        return String(value);
+    }
+    try {
+        const serialized = JSON.stringify(value);
+        if (typeof serialized === "string") {
+            return serialized;
+        }
+    }
+    catch {
+        // noop - fallback below
+    }
+    return String(value);
+}

package/dist/cli.d.ts

@@ -1,3 +1,4 @@
+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";
@@ -10,6 +11,7 @@ interface CliOptions {
     tokenTracker: TokenTracker;
     config: Record<PropertyKey, unknown>;
     tokenCounter: TokenCounter;
+    workspace: WorkspaceContext;
 }
 export declare class Cli {
     private options;

package/dist/cli.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../source/cli.ts"],"names":[],"mappings":"AAUA,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;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,MAAM,EAAE,MAAM,CAAC,WAAW,EAAE,OAAO,CAAC,CAAC;IACrC,YAAY,EAAE,YAAY,CAAC;CAC5B;AAID,qBAAa,GAAG;IACd,OAAO,CAAC,OAAO,CAAa;gBAChB,OAAO,EAAE,UAAU;IAIzB,GAAG;CAgGV"}
+{"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,MAAM,EAAE,MAAM,CAAC,WAAW,EAAE,OAAO,CAAC,CAAC;IACrC,YAAY,EAAE,YAAY,CAAC;IAC3B,SAAS,EAAE,gBAAgB,CAAC;CAC7B;AAWD,qBAAa,GAAG;IACd,OAAO,CAAC,OAAO,CAAa;gBAChB,OAAO,EAAE,UAAU;IAIzB,GAAG;CAkFV"}

package/dist/cli.js

@@ -2,12 +2,21 @@ import { generateObject, generateText, NoSuchToolError, stepCountIs, } from "ai"
 import { logger } from "./logger.js";
 import { AiConfig } from "./models/ai-config.js";
 import { minSystemPrompt } from "./prompts.js";
-import { DeleteFileTool } from "./tools/delete-file.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 { MoveFileTool } from "./tools/move-file.js";
-import { SaveFileTool } from "./tools/save-file.js";
-import { ThinkTool } from "./tools/think.js";
+import { ReadFileTool } from "./tools/read-file.js";
+const activeTools = [
+    EditFileTool.name,
+    ReadFileTool.name,
+    BashTool.name,
+    GrepTool.name,
+    GlobTool.name,
+    CodeInterpreterTool.name,
+];
 export class Cli {
     options;
     constructor(options) {
@@ -33,41 +42,25 @@ export class Cli {
             modelMetadata: modelConfig,
             prompt: userPrompt,
         });
-        const maxTokens = aiConfig.getMaxTokens();
-        const tools = modelConfig.supportsToolCalling
-            ? await initCliTools({ tokenCounter })
-            : undefined;
+        const tools = await initCliTools({
+            tokenCounter,
+            workspace: this.options.workspace,
+        });
         try {
             const result = await generateText({
                 model: langModel,
-                maxOutputTokens: maxTokens,
-                messages: [
-                    {
-                        role: "system",
-                        content: finalSystemPrompt,
-                        providerOptions: {
-                            anthropic: { cacheControl: { type: "ephemeral" } },
-                        },
-                    },
-                    ...messageHistory.get(),
-                ],
-                temperature: modelConfig.defaultTemperature,
+                maxOutputTokens: aiConfig.maxOutputTokens(),
+                system: finalSystemPrompt,
+                messages: messageHistory.get(),
+                temperature: aiConfig.temperature(),
+                topP: aiConfig.topP(),
                 stopWhen: stepCountIs(60),
                 maxRetries: 2,
-                providerOptions: aiConfig.getProviderOptions(),
-                tools,
-                // biome-ignore lint/style/useNamingConvention: third-party controlled
-                experimental_activeTools: [
-                    EditFileTool.name,
-                    SaveFileTool.name,
-                    MoveFileTool.name,
-                    DeleteFileTool.name,
-                    ThinkTool.name,
-                ],
+                providerOptions: aiConfig.providerOptions(),
+                tools: tools.toolDefs,
+                activeTools,
                 // biome-ignore lint/style/useNamingConvention: third-party controlled
-                experimental_repairToolCall: modelConfig.supportsToolCalling
-                    ? toolCallRepair(modelManager)
-                    : undefined,
+                experimental_repairToolCall: toolCallRepair(modelManager),
                 abortSignal: signal,
             });
             if (result.response.messages.length > 0) {
@@ -75,6 +68,7 @@ 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();
             process.stdout.end(result.text.endsWith("\n") ? result.text : `${result.text}\n`);
         }
         catch (e) {

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"add-directory-command.d.ts","sourceRoot":"","sources":["../../source/commands/add-directory-command.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAE9D,eAAO,MAAM,mBAAmB,GAAI,0BAGjC,cAAc,KAAG,WAkInB,CAAC"}

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

@@ -0,0 +1,85 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import style from "../terminal/style.js";
+import { Text } from "../tui/index.js";
+export const addDirectoryCommand = ({ terminal, workspace, }) => {
+    return {
+        command: "/add-directory",
+        description: "Add a directory to the list of allowed working directories",
+        getSubCommands: async () => {
+            return [];
+        },
+        execute: async (args) => {
+            const directoryPath = args?.[0];
+            if (!directoryPath) {
+                terminal.error("Usage: /add-directory <path>");
+                return "continue";
+            }
+            try {
+                // Resolve and validate the directory
+                const resolvedPath = path.resolve(directoryPath);
+                const stats = await fs.stat(resolvedPath);
+                if (!stats.isDirectory()) {
+                    terminal.error(`Path is not a directory: ${resolvedPath}`);
+                    return "continue";
+                }
+                // Check if directory is already in the list
+                if (workspace.allowedDirs.includes(resolvedPath)) {
+                    terminal.warn(`Directory already in allowed list: ${resolvedPath}`);
+                    return "continue";
+                }
+                // Add the directory to the workspace
+                workspace.allowedDirs.push(resolvedPath);
+                terminal.writeln(`Added directory to allowed list: ${style.blue(resolvedPath)}`);
+                terminal.writeln(`Current allowed directories: ${style.blue(workspace.allowedDirs.join(", "))}`);
+                return "continue";
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                terminal.error(`Failed to add directory: ${errorMessage}`);
+                return "continue";
+            }
+        },
+        async handle(args, { tui, container, editor, }) {
+            const directoryPath = args?.[0];
+            if (!directoryPath) {
+                container.addChild(new Text(style.red("Usage: /add-directory <path>"), 0, 1));
+                tui.requestRender();
+                editor.setText("");
+                return "continue";
+            }
+            try {
+                // Resolve and validate the directory
+                const resolvedPath = path.resolve(directoryPath);
+                const stats = await fs.stat(resolvedPath);
+                if (!stats.isDirectory()) {
+                    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));
+                tui.requestRender();
+                editor.setText("");
+                return "continue";
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                container.addChild(new Text(style.red(`Failed to add directory: ${errorMessage}`), 0, 1));
+                tui.requestRender();
+                editor.setText("");
+                return "continue";
+            }
+        },
+    };
+};

package/dist/commands/application-log-command.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"application-log-command.d.ts","sourceRoot":"","sources":["../../source/commands/application-log-command.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAE9D,eAAO,MAAM,qBAAqB,GAAI,eAEnC,cAAc,KAAG,WAgDnB,CAAC"}
+{"version":3,"file":"application-log-command.d.ts","sourceRoot":"","sources":["../../source/commands/application-log-command.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAE9D,eAAO,MAAM,qBAAqB,GAAI,eAEnC,cAAc,KAAG,WAwHnB,CAAC"}

package/dist/commands/application-log-command.js

@@ -1,6 +1,8 @@
 import { readFile } from "node:fs/promises";
 import { config } from "../config.js";
 import { editor } from "../terminal/editor-prompt.js";
+import style from "../terminal/style.js";
+import { Text } from "../tui/index.js";
 export const applicationLogCommand = ({ terminal, }) => {
     return {
         command: "/application-logs",
@@ -41,5 +43,37 @@ export const applicationLogCommand = ({ terminal, }) => {
                 return "continue";
             }
         },
+        async handle(_args, { tui, container, editor, }) {
+            let logFilePath;
+            try {
+                const projectConfig = await config.readProjectConfig();
+                logFilePath = projectConfig.logs?.path;
+                if (!logFilePath) {
+                    container.addChild(new Text(style.red("Application log path is not defined in .acai/acai.json under the 'logs.path' key."), 1, 0));
+                    tui.requestRender();
+                    editor.setText("");
+                    return "continue";
+                }
+                const content = await readFile(logFilePath, { encoding: "utf8" });
+                // For TUI mode, we'll just display a message since we can't use the editor prompt
+                container.addChild(new Text(`Viewing application log: ${style.blue(logFilePath)}`, 0, 1));
+                container.addChild(new Text(`Content length: ${content.length} characters`, 2, 0));
+                container.addChild(new Text(style.dim("Note: Full log viewing not available in TUI mode"), 3, 0));
+                tui.requestRender();
+                editor.setText("");
+                return "continue";
+            }
+            catch (error) {
+                if (logFilePath && error.code === "ENOENT") {
+                    container.addChild(new Text(style.red(`Application log file not found at: ${logFilePath}`), 1, 0));
+                }
+                else {
+                    container.addChild(new Text(style.red(`Error reading log file ${logFilePath ?? "specified in config"}: ${error}`), 1, 0));
+                }
+                tui.requestRender();
+                editor.setText("");
+                return "continue";
+            }
+        },
     };
 };

package/dist/commands/clear-command.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"clear-command.d.ts","sourceRoot":"","sources":["../../source/commands/clear-command.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAE9D,eAAO,MAAM,YAAY,GAAI,cAAc,cAAc,KAAG,WAU3D,CAAC"}
+{"version":3,"file":"clear-command.d.ts","sourceRoot":"","sources":["../../source/commands/clear-command.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAE9D,eAAO,MAAM,YAAY,GAAI,cAAc,cAAc,KAAG,WAyB3D,CAAC"}

package/dist/commands/clear-command.js

@@ -7,5 +7,13 @@ export const clearCommand = ({ terminal }) => {
             terminal.clear();
             return "continue";
         },
+        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("");
+            return "continue";
+        },
     };
 };

package/dist/commands/compact-command.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"compact-command.d.ts","sourceRoot":"","sources":["../../source/commands/compact-command.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAE9D,eAAO,MAAM,cAAc,GAAI,SAAS,cAAc,KAAG,WAiBxD,CAAC"}
+{"version":3,"file":"compact-command.d.ts","sourceRoot":"","sources":["../../source/commands/compact-command.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAE9D,eAAO,MAAM,cAAc,GAAI,SAAS,cAAc,KAAG,WAqCxD,CAAC"}

package/dist/commands/compact-command.js

@@ -1,5 +1,7 @@
 import { generateText } from "ai";
 import { createUserMessage } from "../messages.js";
+import style from "../terminal/style.js";
+import { Text } from "../tui/index.js";
 export const compactCommand = (options) => {
     return {
         command: "/compact",
@@ -14,6 +16,17 @@ export const compactCommand = (options) => {
             terminal.info("Message history summarized and reset.");
             return "continue";
         },
+        async handle(args, { tui, container, editor, }) {
+            const { messageHistory } = options;
+            if (!messageHistory.isEmpty()) {
+                const additionalInstructions = args.join(" ");
+                await summarizeAndReset(options, additionalInstructions);
+            }
+            container.addChild(new Text(style.green("Message history summarized and reset."), 0, 1));
+            tui.requestRender();
+            editor.setText("");
+            return "continue";
+        },
     };
 };
 async function summarizeAndReset({ messageHistory, modelManager, tokenTracker }, additionalInstructions) {
@@ -45,7 +58,7 @@ Your summary should include the following sections:
         messages: messageHistory.get(),
     });
     tokenTracker.trackUsage(app, usage);
-    //clear messages
-    messageHistory.clear();
+    //create new session
+    messageHistory.create(modelManager.getModel("repl").modelId);
     messageHistory.appendUserMessage(createUserMessage([text]));
 }

package/dist/commands/context-command.d.ts

@@ -0,0 +1,3 @@
+import type { CommandOptions, ReplCommand } from "./types.ts";
+export declare function contextCommand({ terminal, tokenCounter, modelManager, messageHistory, workspace, }: CommandOptions): ReplCommand;
+//# sourceMappingURL=context-command.d.ts.map

package/dist/commands/context-command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context-command.d.ts","sourceRoot":"","sources":["../../source/commands/context-command.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AA4C9D,wBAAgB,cAAc,CAAC,EAC7B,QAAQ,EACR,YAAY,EACZ,YAAY,EACZ,cAAc,EACd,SAAS,GACV,EAAE,cAAc,GAAG,WAAW,CA4L9B"}