@travisennis/acai 0.0.3 → 0.0.5

package/dist/repl/tool-call-repair.js

@@ -0,0 +1,50 @@
+import { generateObject, NoSuchToolError, } from "ai";
+import { jsonrepair } from "jsonrepair";
+import { logger } from "../logger.js";
+async function remoteToolCallRepair(modelManager, toolCall, tool, inputSchema) {
+    const { object: repairedArgs } = await generateObject({
+        model: modelManager.getModel("tool-repair"),
+        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, input: JSON.stringify(repairedArgs) };
+}
+const localToolCallRepair = async (toolCall, tool) => {
+    const schema = tool.inputSchema;
+    const repairedArgs = jsonrepair(toolCall.input);
+    schema.parse(repairedArgs);
+    return { ...toolCall, input: JSON.stringify(repairedArgs) };
+};
+export const toolCallRepair = (modelManager) => {
+    const fn = async ({ toolCall, tools, inputSchema, error, }) => {
+        if (NoSuchToolError.isInstance(error)) {
+            return null;
+        }
+        logger.warn(`Attempting to repair tool call: ${toolCall.toolName}.`);
+        const tool = tools[toolCall.toolName];
+        if (typeof tool === "undefined") {
+            logger.error(new Error("Tool not found"), `Failed to repair tool call: ${toolCall.toolName}.`);
+            return null;
+        }
+        try {
+            return localToolCallRepair(toolCall, tool);
+        }
+        catch (err) {
+            logger.error(err, `Failed to repair tool call locally: ${toolCall.toolName}.`);
+            try {
+                return remoteToolCallRepair(modelManager, toolCall, tool, inputSchema);
+            }
+            catch (err2) {
+                logger.error(err2, `Failed to repair tool call remotely: ${toolCall.toolName}.`);
+                return null;
+            }
+        }
+    };
+    return fn;
+};

package/dist/repl-prompt.d.ts

@@ -12,3 +12,4 @@ export declare class ReplPrompt {
     close(): void;
     [Symbol.dispose](): void;
 }
+//# sourceMappingURL=repl-prompt.d.ts.map

package/dist/repl-prompt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"repl-prompt.d.ts","sourceRoot":"","sources":["../source/repl-prompt.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAyD5D,qBAAa,UAAU;IAErB,OAAO,CAAC,gBAAgB,CAAC,CAAkC;IAC3D,OAAO,CAAC,EAAE,CAAY;IACtB,OAAO,CAAC,OAAO,CAAW;IAC1B,OAAO,CAAC,UAAU,CAAM;gBAEZ,EACV,QAAQ,EACR,OAAO,GACR,EAAE;QAAE,QAAQ,EAAE,cAAc,CAAC;QAAC,OAAO,EAAE,MAAM,EAAE,CAAA;KAAE;IA4F5C,KAAK;IAoBX,KAAK;IAQL,CAAC,MAAM,CAAC,OAAO,CAAC;CAGjB"}

package/dist/repl.d.ts

@@ -3,8 +3,9 @@ import type { MessageHistory } from "./messages.ts";
 import type { ModelManager } from "./models/manager.js";
 import type { PromptManager } from "./prompts/manager.ts";
 import type { Terminal } from "./terminal/index.ts";
-import type { TokenTracker } from "./token-tracker.ts";
-import type { TokenCounter } from "./token-utils.ts";
+import type { TokenCounter } from "./tokens/counter.ts";
+import type { TokenTracker } from "./tokens/tracker.ts";
+import type { ToolExecutor } from "./tool-executor.ts";
 import type { Message } from "./tools/types.ts";
 interface ReplOptions {
     messageHistory: MessageHistory;
@@ -16,12 +17,15 @@ interface ReplOptions {
     config: Record<PropertyKey, unknown>;
     tokenCounter: TokenCounter;
     toolEvents: Map<string, Message[]>;
-    autoAcceptAll: boolean;
+    showLastMessage: boolean;
+    toolExecutor?: ToolExecutor;
+    promptHistory: string[];
 }
 export declare class Repl {
     private options;
+    private showLastMessage;
     constructor(options: ReplOptions);
     run(): Promise<void>;
-    private displayToolUse;
 }
 export {};
+//# sourceMappingURL=repl.d.ts.map

package/dist/repl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"repl.d.ts","sourceRoot":"","sources":["../source/repl.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAI5D,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;AAO1D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAEpD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACxD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACxD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAEvD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAC;AAEhD,UAAU,WAAW;IACnB,cAAc,EAAE,cAAc,CAAC;IAC/B,aAAa,EAAE,aAAa,CAAC;IAC7B,YAAY,EAAE,YAAY,CAAC;IAC3B,YAAY,EAAE,YAAY,CAAC;IAC3B,QAAQ,EAAE,QAAQ,CAAC;IACnB,QAAQ,EAAE,cAAc,CAAC;IACzB,MAAM,EAAE,MAAM,CAAC,WAAW,EAAE,OAAO,CAAC,CAAC;IACrC,YAAY,EAAE,YAAY,CAAC;IAC3B,UAAU,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,EAAE,CAAC,CAAC;IACnC,eAAe,EAAE,OAAO,CAAC;IACzB,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B,aAAa,EAAE,MAAM,EAAE,CAAC;CACzB;AAED,qBAAa,IAAI;IACf,OAAO,CAAC,OAAO,CAAc;IAC7B,OAAO,CAAC,eAAe,CAAU;gBAErB,OAAO,EAAE,WAAW;IAK1B,GAAG;CAwVV"}

package/dist/repl.js

@@ -1,78 +1,133 @@
 import { isNumber, isRecord } from "@travisennis/stdlib/typeguards";
-import { generateObject, NoSuchToolError, stepCountIs, streamText, } from "ai";
-import chalk from "chalk";
+import { stepCountIs, streamText } from "ai";
 import { config as configManager } from "./config.js";
 import { logger } from "./logger.js";
-import { processPrompt } from "./mentions.js";
+import { PromptError, processPrompt } from "./mentions.js";
 import { AiConfig } from "./models/ai-config.js";
 import { systemPrompt } from "./prompts.js";
+import { displayToolMessages } from "./repl/display-tool-messages.js";
+import { displayToolUse } from "./repl/display-tool-use.js";
+import { getPromptHeader } from "./repl/get-prompt-header.js";
+import { toolCallRepair } from "./repl/tool-call-repair.js";
 import { ReplPrompt } from "./repl-prompt.js";
-import { isMarkdown } from "./terminal/markdown-utils.js";
-import { getCurrentBranch, getDiffStat, getGitStatus, hasUncommittedChanges, inGitDirectory, } from "./tools/git-utils.js"; // Modified import
+import style from "./terminal/style.js";
 import { initAgents, initTools } from "./tools/index.js";
 export class Repl {
     options;
+    showLastMessage;
     constructor(options) {
         this.options = options;
+        this.showLastMessage = options.showLastMessage;
     }
     async run() {
-        const { config, promptManager, terminal, modelManager, tokenTracker, messageHistory, commands, tokenCounter, toolEvents, autoAcceptAll, } = this.options;
+        const { config, promptManager, terminal, modelManager, tokenTracker, messageHistory, commands, tokenCounter, toolEvents, toolExecutor, promptHistory, } = this.options;
         logger.info(config, "Config:");
         terminal.displayWelcome();
-        const promptHistory = [];
         let currentContextWindow = 0;
         messageHistory.on("clear-history", () => {
             currentContextWindow = 0;
         });
-        let prevCb = null;
+        const finalSystemPrompt = await systemPrompt();
+        // Initialize tools once outside the loop - all models support tool calling
+        const tools = {
+            ...(await initTools({
+                terminal,
+                tokenCounter,
+                events: toolEvents,
+                toolExecutor,
+            })),
+            ...(await initAgents({
+                terminal,
+                modelManager,
+                tokenTracker,
+                tokenCounter,
+                events: toolEvents,
+            })),
+        };
+        let currentAbortController = null;
+        // Handle Ctrl+C (SIGINT) as a fallback when not in raw mode
+        process.on("SIGINT", () => {
+            currentAbortController?.abort();
+        });
         while (true) {
-            const abortController = new AbortController();
-            const { signal } = abortController;
-            const cb = () => {
-                abortController.abort();
-            };
-            if (prevCb) {
-                process.removeListener("SIGINT", prevCb);
-            }
-            // Handle Ctrl+C (SIGINT)
-            process.on("SIGINT", cb);
-            prevCb = cb;
+            currentAbortController = new AbortController();
+            const { signal } = currentAbortController;
             const langModel = modelManager.getModel("repl");
             const modelConfig = modelManager.getModelMetadata("repl");
-            terminal.hr();
-            terminal.writeln(await getProjectStatusLine());
-            terminal.writeln(chalk.dim(langModel.modelId));
-            terminal.displayProgressBar(currentContextWindow, modelConfig.contextWindow);
+            // agent header/status line
+            await getPromptHeader({
+                terminal,
+                modelId: langModel.modelId,
+                contextWindow: modelConfig.contextWindow,
+                currentContextWindow,
+            });
+            // Display last message when continuing/resuming a conversation
+            if (this.showLastMessage) {
+                const lastMessage = messageHistory.getLastMessage();
+                if (lastMessage) {
+                    terminal.lineBreak();
+                    terminal.writeln(style.dim("Continuing conversation:"));
+                    terminal.display(lastMessage);
+                    terminal.lineBreak();
+                    terminal.hr();
+                }
+                // don't show the last message after showing it once
+                this.showLastMessage = false;
+            }
             if (!promptManager.isPending()) {
                 // For interactive input
                 const prompt = new ReplPrompt({ commands, history: promptHistory });
                 const userInput = await prompt.input();
                 prompt.close();
+                terminal.startProgress();
                 // see if the userInput contains a command
                 const commandResult = await commands.handle({ userInput });
                 if (commandResult.break) {
+                    terminal.stopProgress();
                     break;
                 }
                 if (commandResult.continue) {
+                    terminal.stopProgress();
                     terminal.lineBreak();
                     continue;
                 }
                 if (!userInput.trim()) {
+                    terminal.stopProgress();
                     continue;
                 }
                 // if there is no pending prompt then use the user's input. otherwise, the prompt was loaded from a command
                 if (!promptManager.isPending()) {
-                    const processedPrompt = await processPrompt(userInput, {
-                        baseDir: process.cwd(),
-                        model: modelConfig,
-                    });
-                    for (const context of processedPrompt.context) {
-                        promptManager.addContext(context);
+                    try {
+                        const processedPrompt = await processPrompt(userInput, {
+                            baseDir: process.cwd(),
+                            model: modelConfig,
+                        });
+                        for (const context of processedPrompt.context) {
+                            promptManager.addContext(context);
+                        }
+                        promptManager.set(processedPrompt.message);
+                    }
+                    catch (error) {
+                        if (error instanceof PromptError) {
+                            terminal.error(`Prompt processing failed: ${error.message}`);
+                            if (error.cause &&
+                                typeof error.cause === "object" &&
+                                "command" in error.cause &&
+                                typeof error.cause.command === "string") {
+                                terminal.error(`Command: ${error.cause.command}`);
+                            }
+                            terminal.lineBreak();
+                            terminal.stopProgress();
+                            continue; // Continue the REPL loop
+                        }
+                        throw error; // Re-throw other errors
                     }
-                    promptManager.set(processedPrompt.message);
                 }
                 terminal.lineBreak();
             }
+            else {
+                terminal.startProgress();
+            }
             // flag to see if the user prompt has added context
             const hasAddedContext = promptManager.hasContext();
             if (hasAddedContext) {
@@ -83,31 +138,11 @@ export class Repl {
             const userPrompt = promptManager.get();
             const userMsg = promptManager.getUserMessage();
             messageHistory.appendUserMessage(userMsg);
-            const finalSystemPrompt = await systemPrompt({
-                supportsToolCalling: modelConfig.supportsToolCalling,
-            });
             const aiConfig = new AiConfig({
                 modelMetadata: modelConfig,
                 prompt: userPrompt,
             });
             const maxTokens = aiConfig.getMaxTokens();
-            const tools = modelConfig.supportsToolCalling
-                ? {
-                    ...(await initTools({
-                        terminal,
-                        tokenCounter,
-                        autoAcceptAll,
-                        events: toolEvents,
-                    })),
-                    ...(await initAgents({
-                        terminal,
-                        modelManager,
-                        tokenTracker,
-                        tokenCounter,
-                        events: toolEvents,
-                    })),
-                }
-                : undefined;
             try {
                 const result = streamText({
                     model: langModel,
@@ -122,16 +157,20 @@ export class Repl {
                         },
                         ...messageHistory.get(),
                     ],
-                    temperature: modelConfig.defaultTemperature,
-                    stopWhen: stepCountIs(60),
+                    temperature: modelConfig.defaultTemperature > -1
+                        ? modelConfig.defaultTemperature
+                        : undefined,
+                    stopWhen: stepCountIs(90),
                     maxRetries: 2,
                     providerOptions: aiConfig.getProviderOptions(),
                     tools,
                     // biome-ignore lint/style/useNamingConvention: third-party controlled
-                    experimental_repairToolCall: modelConfig.supportsToolCalling
-                        ? toolCallRepair(modelManager, terminal)
-                        : undefined,
+                    experimental_repairToolCall: toolCallRepair(modelManager),
                     abortSignal: signal,
+                    onAbort(_event) {
+                        logger.warn("The agent loop was aborted by the user.");
+                        terminal.warn("Operation aborted by user.");
+                    },
                     onFinish: async (result) => {
                         logger.debug("onFinish called");
                         if (result.response.messages.length > 0) {
@@ -144,7 +183,7 @@ export class Repl {
                             terminal.alert();
                         }
                         // Create a more visual representation of steps/tool usage
-                        this.displayToolUse(result, terminal);
+                        displayToolUse(result, terminal);
                         const total = result.totalUsage ??
                             result.usage;
                         const inputTokens = isNumber(total.inputTokens)
@@ -154,10 +193,10 @@ export class Repl {
                             ? total.outputTokens
                             : 0;
                         const tokenSummary = `Tokens: ↑ ${inputTokens} ↓ ${outputTokens}`;
-                        terminal.writeln(chalk.dim(tokenSummary));
+                        terminal.writeln(style.dim(tokenSummary));
                         const inputCost = modelConfig.costPerInputToken * inputTokens;
                         const outputCost = modelConfig.costPerOutputToken * outputTokens;
-                        terminal.writeln(chalk.dim(`Cost: $${(inputCost + outputCost).toFixed(2)}`));
+                        terminal.writeln(style.dim(`Cost: $${(inputCost + outputCost).toFixed(2)}`));
                         // Track aggregate usage across all steps when available
                         tokenTracker.trackUsage("repl", total);
                         // Derive current context window from final step usage
@@ -176,13 +215,6 @@ export class Repl {
                                 }
                             }
                         }
-                        // comment out auto-summarization for now. it's been causing issues.
-                        // if (currentContextWindow > 70000) {
-                        //   logger.info(
-                        //     `Condensing history from ${currentContextWindow} to 0`,
-                        //   );
-                        //   await messageHistory.summarizeAndReset();
-                        // }
                         terminal.hr();
                     },
                     onError: ({ error }) => {
@@ -200,20 +232,23 @@ export class Repl {
                     if (chunk.type === "reasoning-delta" || chunk.type === "text-delta") {
                         if (chunk.type === "reasoning-delta") {
                             if (lastType !== "reasoning") {
-                                terminal.writeln(chalk.dim("<think>"));
+                                terminal.writeln(style.dim("<think>"));
                             }
-                            terminal.write(chalk.dim(chunk.text)); // Stream reasoning directly
+                            terminal.write(style.dim(chunk.text)); // Stream reasoning directly
                             lastType = "reasoning";
                         }
                         else if (chunk.type === "text-delta") {
                             if (lastType === "reasoning") {
                                 // Finishing reasoning: Print </think>
-                                terminal.writeln(chalk.dim("\n</think>\n"));
+                                terminal.writeln(style.dim("\n</think>\n"));
                             }
                             accumulatedText += chunk.text;
                             lastType = "text";
                         }
                     }
+                    else if (chunk.type === "tool-call") {
+                        terminal.stopProgress();
+                    }
                     else if (chunk.type === "tool-result") {
                         const messages = toolEvents.get(chunk.toolCallId);
                         if (messages) {
@@ -227,11 +262,12 @@ export class Repl {
                     else {
                         // Close thinking tags when moving from reasoning to any other chunk type
                         if (lastType === "reasoning") {
-                            terminal.write(chalk.dim("\n</think>\n\n"));
+                            terminal.write(style.dim("\n</think>\n\n"));
                         }
+                        terminal.stopProgress();
                         // if there is accumulatedText, display it
                         if (accumulatedText.trim()) {
-                            terminal.writeln(`${chalk.blue.bold("● Response:")}`);
+                            terminal.writeln(`${style.blue.bold("● Response:")}`);
                             terminal.display(accumulatedText, true);
                             terminal.lineBreak();
                         }
@@ -241,11 +277,11 @@ export class Repl {
                 }
                 // Ensure the final closing tag for reasoning is written if it was the last type
                 if (lastType === "reasoning") {
-                    terminal.write(chalk.gray("\n</think>\n\n"));
+                    terminal.write(style.gray("\n</think>\n\n"));
                 }
                 // if there is accumulatedText, display it
                 if (accumulatedText.trim()) {
-                    terminal.writeln(`${chalk.green.bold("● Response:")}`);
+                    terminal.writeln(`${style.green.bold("● Response:")}`);
                     terminal.display(accumulatedText, true);
                     terminal.lineBreak();
                 }
@@ -271,184 +307,4 @@ export class Repl {
             }
         }
     }
-    displayToolUse(result, terminal) {
-        const toolsCalled = [];
-        const toolColors = new Map();
-        const chalkColors = [
-            "red",
-            "green",
-            "yellow",
-            "blue",
-            "magenta",
-            "cyan",
-            "white",
-            "gray",
-            "redBright",
-            "greenBright",
-            "yellowBright",
-            "blueBright",
-            "magentaBright",
-            "cyanBright",
-            "whiteBright",
-            "blackBright",
-        ];
-        terminal.writeln(chalk.dim(`Steps: ${result.steps.length}`));
-        for (const step of result.steps) {
-            let currentToolCalls = [];
-            if (step.toolResults.length > 0) {
-                currentToolCalls = step.toolResults;
-            }
-            else if (step.toolCalls.length > 0) {
-                currentToolCalls = step.toolCalls;
-            }
-            for (const toolCallOrResult of currentToolCalls) {
-                const toolName = toolCallOrResult.toolName;
-                if (!toolColors.has(toolName)) {
-                    const availableColors = chalkColors.filter((color) => !Array.from(toolColors.values()).some((c) => c === chalk[color]));
-                    const color = availableColors.length > 0
-                        ? (availableColors[Math.floor(Math.random() * availableColors.length)] ?? "white")
-                        : "white";
-                    toolColors.set(toolName, chalk[color]);
-                }
-                toolsCalled.push(toolName);
-            }
-        }
-        if (toolsCalled.length > 0) {
-            terminal.lineBreak();
-            terminal.writeln(chalk.dim("Tools:"));
-            for (const toolCalled of toolsCalled) {
-                const colorFn = toolColors.get(toolCalled) ?? chalk.white;
-                terminal.write(`${colorFn("██")} `);
-            }
-            terminal.lineBreak();
-            const uniqueTools = new Set(toolsCalled);
-            for (const [index, toolCalled] of Array.from(uniqueTools).entries()) {
-                const colorFn = toolColors.get(toolCalled) ?? chalk.white;
-                terminal.write(colorFn(toolCalled));
-                if (index < new Set(toolsCalled).size - 1) {
-                    terminal.write(" - ");
-                }
-            }
-            terminal.lineBreak();
-            terminal.lineBreak();
-        }
-    }
-}
-function displayToolMessages(messages, terminal) {
-    const isError = messages[messages.length - 1]?.event === "tool-error";
-    const indicator = isError ? chalk.red.bold("●") : chalk.blue.bold("●");
-    const initMessage = messages.find((m) => m.event === "tool-init")?.data ?? "Tool Execution";
-    terminal.write(`${indicator} `); // Write indicator without newline (sync)
-    terminal.display(initMessage); // Display initial message (async)
-    for (const msg of messages) {
-        switch (msg.event) {
-            case "tool-update":
-                _handleToolUpdateMessage(msg.data, terminal);
-                break;
-            case "tool-completion":
-                _handleToolCompletionMessage(msg.data, terminal);
-                break;
-            case "tool-error":
-                _handleToolErrorMessage(msg.data, terminal);
-                break;
-            case "tool-init":
-                // 'tool-init' is handled before the loop, so nothing to do here.
-                break;
-            default:
-                // Optional: Log an unexpected event type for debugging, or do nothing.
-                logger.debug(`Unhandled tool message event: ${msg.event}`);
-                break;
-        }
-    }
-    terminal.lineBreak();
-}
-// Helper function to handle tool update messages
-function _handleToolUpdateMessage(data, terminal) {
-    if (data.secondary && data.secondary.length > 0) {
-        const content = data.secondary.join("\n");
-        if (content.trim().length !== 0) {
-            terminal.display(`└── ${data.primary}`);
-            terminal.hr();
-            if (isMarkdown(content)) {
-                terminal.display(content, true);
-            }
-            else {
-                terminal.write(chalk.green(content));
-                terminal.lineBreak();
-            }
-            terminal.hr();
-        }
-    }
-    else {
-        terminal.display(`└── ${data.primary}`);
-    }
-}
-// Helper function to handle tool completion messages
-function _handleToolCompletionMessage(data, terminal) {
-    terminal.display(`└── ${data}`);
-}
-// Helper function to handle tool error messages
-function _handleToolErrorMessage(data, terminal) {
-    terminal.write("└── ");
-    terminal.error(data);
-}
-const toolCallRepair = (modelManager, terminal) => {
-    const fn = async ({ toolCall, tools, inputSchema, error, }) => {
-        if (NoSuchToolError.isInstance(error)) {
-            return null; // do not attempt to fix invalid tool names
-        }
-        terminal.warn(`Attempting to repair tool call: ${toolCall.toolName}.`);
-        terminal.lineBreak();
-        const tool = tools[toolCall.toolName];
-        try {
-            const { object: repairedArgs } = await generateObject({
-                model: modelManager.getModel("tool-repair"),
-                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;
-};
-async function getProjectStatusLine() {
-    //
-    const currentDir = process.cwd().split("/").pop() || process.cwd();
-    const branch = await getCurrentBranch();
-    let gitStatus = "";
-    if (branch) {
-        const hasChanges = await hasUncommittedChanges();
-        const asterisk = hasChanges ? "*" : "";
-        gitStatus = ` ${chalk.gray(branch + asterisk)}`;
-    }
-    if (await inGitDirectory()) {
-        // Added check
-        const stats = await getDiffStat();
-        const fileChanges = await getGitStatus();
-        let fileStatus = "";
-        if (fileChanges.added)
-            fileStatus += ` +${fileChanges.added}`;
-        if (fileChanges.modified)
-            fileStatus += ` ~${fileChanges.modified}`;
-        if (fileChanges.deleted)
-            fileStatus += ` -${fileChanges.deleted}`;
-        if (fileChanges.untracked)
-            fileStatus += ` ?${fileChanges.untracked}`;
-        gitStatus +=
-            " " +
-                `${chalk.dim("[")}${chalk.yellow(fileStatus.trim())} ` +
-                `${chalk.green(`+${stats.insertions}`)} ` + // Insertions first (green)
-                `${chalk.red(`-${stats.deletions}`)}${chalk.dim("]")}`; // Deletions last (red)
-    }
-    return `${chalk.blue(currentDir)}${gitStatus}`;
 }

package/dist/terminal/ansi-styles.d.ts

@@ -0,0 +1,77 @@
+export interface AnsiStyle {
+    open: string;
+    close: string;
+}
+interface ColorStyle extends AnsiStyle {
+    ansi: (code: number) => string;
+    ansi256: (code: number) => string;
+    ansi16m: (red: number, green: number, blue: number) => string;
+}
+interface Styles {
+    modifier: typeof styles.modifier;
+    color: typeof styles.color & ColorStyle;
+    bgColor: typeof styles.bgColor & ColorStyle;
+    [key: string]: any;
+    rgbToAnsi256: (red: number, green: number, blue: number) => number;
+    hexToRgb: (hex: string) => [number, number, number];
+    hexToAnsi256: (hex: string) => number;
+    ansi256ToAnsi: (code: number) => number;
+    rgbToAnsi: (red: number, green: number, blue: number) => number;
+    hexToAnsi: (hex: string) => number;
+}
+declare const styles: {
+    readonly modifier: {
+        readonly reset: readonly [0, 0];
+        readonly bold: readonly [1, 22];
+        readonly dim: readonly [2, 22];
+        readonly italic: readonly [3, 23];
+        readonly underline: readonly [4, 24];
+        readonly overline: readonly [53, 55];
+        readonly inverse: readonly [7, 27];
+        readonly hidden: readonly [8, 28];
+        readonly strikethrough: readonly [9, 29];
+    };
+    readonly color: {
+        readonly black: readonly [30, 39];
+        readonly red: readonly [31, 39];
+        readonly green: readonly [32, 39];
+        readonly yellow: readonly [33, 39];
+        readonly blue: readonly [34, 39];
+        readonly magenta: readonly [35, 39];
+        readonly cyan: readonly [36, 39];
+        readonly white: readonly [37, 39];
+        readonly blackBright: readonly [90, 39];
+        readonly gray: readonly [90, 39];
+        readonly grey: readonly [90, 39];
+        readonly redBright: readonly [91, 39];
+        readonly greenBright: readonly [92, 39];
+        readonly yellowBright: readonly [93, 39];
+        readonly blueBright: readonly [94, 39];
+        readonly magentaBright: readonly [95, 39];
+        readonly cyanBright: readonly [96, 39];
+        readonly whiteBright: readonly [97, 39];
+    };
+    readonly bgColor: {
+        readonly bgBlack: readonly [40, 49];
+        readonly bgRed: readonly [41, 49];
+        readonly bgGreen: readonly [42, 49];
+        readonly bgYellow: readonly [43, 49];
+        readonly bgBlue: readonly [44, 49];
+        readonly bgMagenta: readonly [45, 49];
+        readonly bgCyan: readonly [46, 49];
+        readonly bgWhite: readonly [47, 49];
+        readonly bgBlackBright: readonly [100, 49];
+        readonly bgGray: readonly [100, 49];
+        readonly bgGrey: readonly [100, 49];
+        readonly bgRedBright: readonly [101, 49];
+        readonly bgGreenBright: readonly [102, 49];
+        readonly bgYellowBright: readonly [103, 49];
+        readonly bgBlueBright: readonly [104, 49];
+        readonly bgMagentaBright: readonly [105, 49];
+        readonly bgCyanBright: readonly [106, 49];
+        readonly bgWhiteBright: readonly [107, 49];
+    };
+};
+export declare const ansiStyles: Styles;
+export {};
+//# sourceMappingURL=ansi-styles.d.ts.map

package/dist/terminal/ansi-styles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ansi-styles.d.ts","sourceRoot":"","sources":["../../source/terminal/ansi-styles.ts"],"names":[],"mappings":"AA2BA,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;CACf;AAED,UAAU,UAAW,SAAQ,SAAS;IACpC,IAAI,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,CAAC;IAC/B,OAAO,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,CAAC;IAClC,OAAO,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,KAAK,MAAM,CAAC;CAC/D;AAED,UAAU,MAAM;IACd,QAAQ,EAAE,OAAO,MAAM,CAAC,QAAQ,CAAC;IACjC,KAAK,EAAE,OAAO,MAAM,CAAC,KAAK,GAAG,UAAU,CAAC;IACxC,OAAO,EAAE,OAAO,MAAM,CAAC,OAAO,GAAG,UAAU,CAAC;IAE5C,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;IACnB,YAAY,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,KAAK,MAAM,CAAC;IACnE,QAAQ,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IACpD,YAAY,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,MAAM,CAAC;IACtC,aAAa,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,CAAC;IACxC,SAAS,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,KAAK,MAAM,CAAC;IAChE,SAAS,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,MAAM,CAAC;CACpC;AAED,QAAA,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuDF,CAAC;AAuLX,eAAO,MAAM,UAAU,QAAmB,CAAC"}