@travisennis/acai 0.0.7 → 0.0.9

package/dist/formatting.js

@@ -243,3 +243,43 @@ export const formatNumber = (num) => {
     // For values 100+, round to nearest whole number
     return `${Math.round(scaled)}${unit}`;
 };
+/**
+ * Formats a date into a human-readable string.
+ *
+ * @param date - The date to format
+ * @returns A formatted date string in the format "MMM DD, YYYY HH:MM:SS AM/PM"
+ *
+ * @example
+ * ```typescript
+ * formatDate(new Date("2023-12-25T14:30:00")) // Returns: "Dec 25, 2023, 02:30:00 PM"
+ * ```
+ */
+export const formatDate = (date) => {
+    return date.toLocaleString("en-US", {
+        month: "short",
+        day: "numeric",
+        year: "numeric",
+        hour: "2-digit",
+        minute: "2-digit",
+        second: "2-digit",
+    });
+};
+/**
+ * Formats a number as a percentage with one decimal place.
+ *
+ * @param n - The numerator
+ * @param d - The denominator
+ * @returns A formatted percentage string (e.g., "12.5%")
+ *
+ * @example
+ * ```typescript
+ * formatPercentage(25, 100) // Returns: "25.0%"
+ * formatPercentage(1, 3) // Returns: "33.3%"
+ * formatPercentage(0, 0) // Returns: "0.0%"
+ * ```
+ */
+export const formatPercentage = (n, d) => {
+    if (d <= 0)
+        return "0.0%";
+    return `${((n / d) * 100).toFixed(1)}%`;
+};

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../source/index.ts"],"names":[],"mappings":";AAkCA,MAAM,WAAW,gBAAgB;IAC/B,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,EAAE,CAAC;CACvB;AAGD,wBAAgB,sBAAsB,CACpC,UAAU,GAAE,MAAM,EAAO,GACxB,gBAAgB,CAmBlB;AAuCD,QAAA,MAAM,KAAK;;;;;;;;;CAAgB,CAAC;AAM5B;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,CAE9C;AAED,MAAM,MAAM,KAAK,GAAG,OAAO,KAAK,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../source/index.ts"],"names":[],"mappings":";AAgCA,MAAM,WAAW,gBAAgB;IAC/B,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,EAAE,CAAC;CACvB;AAGD,wBAAgB,sBAAsB,CACpC,UAAU,GAAE,MAAM,EAAO,GACxB,gBAAgB,CAmBlB;AAmDD,QAAA,MAAM,KAAK;;;;;;;;;CAAyB,CAAC;AAMrC;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,CAE9C;AAED,MAAM,MAAM,KAAK,GAAG,OAAO,KAAK,CAAC"}

package/dist/index.js

@@ -1,34 +1,36 @@
 #!/usr/bin/env node
+import { mkdirSync } from "node:fs";
 import os from "node:os";
 import path from "node:path";
-import { text } from "node:stream/consumers";
 import { parseArgs } from "node:util";
-import { asyncTry } from "@travisennis/stdlib/try";
+import { asyncTry, isFailure, syncTry } from "@travisennis/stdlib/try";
 import { isDefined } from "@travisennis/stdlib/typeguards";
 import { Agent } from "./agent/index.js";
 import { Cli } from "./cli.js";
 import { CommandManager } from "./commands/manager.js";
 import { config, } from "./config.js";
 import { logger } from "./logger.js";
-import { MessageHistory } from "./messages.js";
+import { PromptError, processPrompt } from "./mentions.js";
 import { ModelManager } from "./models/manager.js";
 import { isSupportedModel } from "./models/providers.js";
 import { PromptManager } from "./prompts/manager.js";
 import { systemPrompt } from "./prompts.js";
 import { NewRepl } from "./repl-new.js";
-import { setTerminalTitle } from "./terminal/formatting.js";
+import { SessionManager } from "./sessions/manager.js";
+import { readStdinWithLimits } from "./stdin.js";
+import { setTerminalTitle } from "./terminal/control.js";
 import { select } from "./terminal/select-prompt.js";
 import { TokenCounter } from "./tokens/counter.js";
 import { TokenTracker } from "./tokens/tracker.js";
-import { initAgents, initTools, } from "./tools/index.js";
+import { initTools } from "./tools/index.js";
 import { getPackageVersion } from "./version.js";
 // Create workspace context from CLI arguments
 export function createWorkspaceContext(addDirArgs = []) {
     const primaryDir = process.cwd();
+    mkdirSync("/tmp/acai", { recursive: true });
     const allowedDirs = [
         primaryDir,
-        "/tmp",
-        config.getAccessibleLogDir(),
+        "/tmp/acai",
         path.join(os.homedir(), ".acai"),
         ...addDirArgs,
     ];
@@ -46,20 +48,24 @@ Usage
 Options
   --model, -m        Sets the model to use
   --prompt, -p       Sets the prompt (runs in CLI mode)
-  --continue         Load the most recent conversation
-  --resume           Select a recent conversation to resume
+  --continue         Select a conversation to resume from a list
+  --resume           Resume a specific session by ID, or most recent if no ID given
   --add-dir          Add additional working directory (can be used multiple times)
   --no-skills        Disable skills discovery and loading
 
+
   --help, -h         Show help
   --version, -v      Show version
 
 Examples
-  $ acai --model anthopric:sonnet
+  $ acai --model anthropic:sonnet
   $ acai -p "initial prompt"
   $ acai --add-dir /path/to/project1 --add-dir /path/to/project2
+  $ acai --continue
+  $ acai --resume
+  $ acai --resume a1b2c3d4-e5f6-7890-1234-567890abcdef
 `;
-const parsed = parseArgs({
+const parsed = syncTry(() => parseArgs({
     options: {
         model: { type: "string", short: "m" },
         prompt: { type: "string", short: "p" },
@@ -71,9 +77,14 @@ const parsed = parseArgs({
         version: { type: "boolean", short: "v" },
     },
     allowPositionals: true,
-});
-const flags = parsed.values;
-const input = parsed.positionals;
+}));
+if (isFailure(parsed)) {
+    console.error(parsed.error.message);
+    console.info(helpText);
+    process.exit(0);
+}
+const flags = parsed.unwrap().values;
+const input = parsed.unwrap().positionals;
 // Create workspace context from CLI arguments
 const workspace = createWorkspaceContext(flags["add-dir"]);
 /**
@@ -88,7 +99,7 @@ export function handleError(error) {
 const DEFAULT_HISTORY_LIMIT = 10;
 const CONTINUE_HISTORY_LIMIT = 1;
 // Helper functions for main()
-async function initializeAppState(appConfig, initialPromptInput, stdInPrompt, hasContinueOrResume) {
+async function initializeAppState(appConfig, initialPromptInput, stdinContent, hasContinueOrResume, resumeSessionId) {
     const appDir = config.app;
     // Parallelize independent async operations
     const [messageHistoryDir, modelManager] = await Promise.all([
@@ -99,22 +110,46 @@ async function initializeAppState(appConfig, initialPromptInput, stdInPrompt, ha
     const tokenTracker = new TokenTracker();
     const tokenCounter = new TokenCounter();
     // Initialize dependent components
-    const messageHistory = await initializeMessageHistory(messageHistoryDir, modelManager, tokenTracker);
+    const sessionManager = await initializeSessionManager(messageHistoryDir, modelManager, tokenTracker);
     // Handle conversation history loading
-    await handleConversationHistory(messageHistory, messageHistoryDir, hasContinueOrResume);
+    await handleConversationHistory(sessionManager, messageHistoryDir, hasContinueOrResume, resumeSessionId);
     // Setup prompt manager
     const promptManager = new PromptManager(tokenCounter);
     if (!hasContinueOrResume && isDefined(initialPromptInput)) {
-        promptManager.set(initialPromptInput);
+        try {
+            const modelConfig = modelManager.getModelMetadata("repl");
+            const processedPrompt = await processPrompt(initialPromptInput, {
+                baseDir: process.cwd(),
+                model: modelConfig,
+            });
+            for (const context of processedPrompt.context) {
+                promptManager.addContext(context);
+            }
+            promptManager.set(processedPrompt.message);
+        }
+        catch (error) {
+            if (error instanceof PromptError) {
+                logger.error(`Prompt mention error: ${error.message}`);
+                promptManager.set(initialPromptInput);
+            }
+            else {
+                throw new Error("Failed to process prompt.", { cause: error });
+            }
+        }
     }
-    if (stdInPrompt) {
-        promptManager.addContext(stdInPrompt);
+    if (stdinContent && stdinContent.trim().length > 0) {
+        if (isDefined(initialPromptInput)) {
+            promptManager.addContext(stdinContent);
+        }
+        else {
+            promptManager.set(stdinContent);
+        }
     }
     const promptHistory = [];
     const commands = new CommandManager({
         promptManager,
         modelManager,
-        messageHistory,
+        sessionManager,
         tokenTracker,
         config,
         tokenCounter,
@@ -127,7 +162,7 @@ async function initializeAppState(appConfig, initialPromptInput, stdInPrompt, ha
         modelManager,
         tokenTracker,
         tokenCounter,
-        messageHistory,
+        sessionManager,
         promptManager,
         promptHistory,
         commands,
@@ -144,40 +179,56 @@ async function handleEarlyExits() {
     }
     return false;
 }
+function validateSessionId(id) {
+    const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+    return id.length === 36 && uuidRegex.test(id);
+}
 function validateCliArguments() {
     if (flags.continue === true && flags.resume === true) {
         console.error("Cannot use --continue and --resume flags together.");
         process.exit(1);
     }
+    if (flags.resume === true && input.length > 0) {
+        const sessionId = input[0];
+        if (!validateSessionId(sessionId)) {
+            console.error(`Invalid session ID: ${sessionId}`);
+            console.error("Session ID must be a valid UUID (xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx)");
+            process.exit(1);
+        }
+    }
 }
 async function determineInitialPrompt() {
     const hasContinueOrResume = flags.continue === true || flags.resume === true;
     const positionalPrompt = input.at(0);
-    let stdInPrompt;
-    // Check if there's data available on stdin
-    if (!process.stdin.isTTY) {
-        try {
-            stdInPrompt = await text(process.stdin);
-        }
-        catch (error) {
-            console.error(`Error reading stdin: ${error.message}`);
-        }
+    const { content: stdinContent, wasPiped } = await readStdinWithLimits();
+    if (wasPiped &&
+        (!stdinContent || stdinContent.trim().length === 0) &&
+        !flags.prompt &&
+        !positionalPrompt) {
+        console.error("No input provided via stdin.");
+        process.exit(0);
     }
+    const resumeSessionId = flags.resume === true && input.length > 0 ? input[0] : undefined;
     const initialPromptInput = typeof flags.prompt === "string" && flags.prompt.length > 0
         ? flags.prompt
-        : positionalPrompt && positionalPrompt.length > 0
+        : positionalPrompt && positionalPrompt.length > 0 && !resumeSessionId
             ? positionalPrompt
             : undefined;
     if (hasContinueOrResume && isDefined(initialPromptInput)) {
         console.error("Cannot use --continue or --resume with an initial prompt.");
         process.exit(1);
     }
-    return { initialPromptInput, stdInPrompt, hasContinueOrResume };
+    return {
+        initialPromptInput,
+        stdinContent,
+        hasContinueOrResume,
+        resumeSessionId,
+    };
 }
 async function initializeModelManager(appDir) {
     const chosenModel = isSupportedModel(flags.model)
         ? flags.model
-        : "openrouter:glm-4.6";
+        : "opencode:minimax-m2-1";
     const modelManager = new ModelManager({
         stateDir: await appDir.ensurePath("audit"),
     });
@@ -193,36 +244,31 @@ async function initializeModelManager(appDir) {
     modelManager.setModel("edit-fix", chosenModel);
     return modelManager;
 }
-async function initializeMessageHistory(messageHistoryDir, modelManager, tokenTracker) {
-    const messageHistory = new MessageHistory({
+async function initializeSessionManager(messageHistoryDir, modelManager, tokenTracker) {
+    const messageHistory = new SessionManager({
         stateDir: messageHistoryDir,
         modelManager,
         tokenTracker,
     });
     messageHistory.on("update-title", (title) => setTerminalTitle(title));
+    // Listen for model changes and update session manager when repl model changes
+    modelManager.on("set-model", (app, _model) => {
+        if (app === "repl") {
+            const modelId = modelManager.getModel("repl").modelId;
+            messageHistory.setModelId(modelId);
+        }
+    });
     return messageHistory;
 }
-async function handleConversationHistory(messageHistory, messageHistoryDir, _hasContinueOrResume) {
+async function handleConversationHistory(messageHistory, messageHistoryDir, _hasContinueOrResume, resumeSessionId) {
     if (flags.continue === true) {
-        const histories = await MessageHistory.load(messageHistoryDir, CONTINUE_HISTORY_LIMIT);
-        const latestHistory = histories.at(0);
-        if (latestHistory) {
-            messageHistory.restore(latestHistory);
-            console.info(`Resuming conversation: ${latestHistory.title}`);
-            setTerminalTitle(latestHistory.title || `acai: ${process.cwd()}`);
-        }
-        else {
-            logger.info("No previous conversation found to continue.");
-        }
-    }
-    else if (flags.resume === true) {
-        const histories = await MessageHistory.load(messageHistoryDir, DEFAULT_HISTORY_LIMIT);
+        const histories = await SessionManager.load(messageHistoryDir, DEFAULT_HISTORY_LIMIT);
         if (histories.length > 0) {
             try {
                 const choice = await select({
                     message: "Select a conversation to resume:",
                     choices: histories.map((h, index) => ({
-                        name: `${index + 1}: ${h.title} (${h.updatedAt.toLocaleString()})`,
+                        name: `${index + 1}: ${h.title} [${h.sessionId}] (${h.updatedAt.toLocaleString()})`,
                         value: index,
                         description: `${h.messages.length} messages`,
                     })),
@@ -249,7 +295,34 @@ async function handleConversationHistory(messageHistory, messageHistoryDir, _has
             }
         }
         else {
-            logger.info("No previous conversations found to resume.");
+            logger.info("No previous conversations found to continue.");
+        }
+    }
+    else if (flags.resume === true) {
+        if (resumeSessionId) {
+            const histories = await SessionManager.load(messageHistoryDir, DEFAULT_HISTORY_LIMIT);
+            const targetHistory = histories.find((h) => h.sessionId === resumeSessionId);
+            if (targetHistory) {
+                messageHistory.restore(targetHistory);
+                logger.info(`Resuming conversation: ${targetHistory.title}`);
+                setTerminalTitle(targetHistory.title || `acai: ${process.cwd()}`);
+            }
+            else {
+                console.error(`Session not found: ${resumeSessionId}`);
+                process.exit(1);
+            }
+        }
+        else {
+            const histories = await SessionManager.load(messageHistoryDir, CONTINUE_HISTORY_LIMIT);
+            const latestHistory = histories.at(0);
+            if (latestHistory) {
+                messageHistory.restore(latestHistory);
+                console.info(`Resuming conversation: ${latestHistory.title}`);
+                setTerminalTitle(latestHistory.title || `acai: ${process.cwd()}`);
+            }
+            else {
+                logger.info("No previous conversation found to resume.");
+            }
         }
     }
 }
@@ -257,7 +330,7 @@ async function runCliMode(state) {
     const skillsEnabled = !flags["no-skills"] && (await config.getSkillsEnabled());
     const cliProcess = new Cli({
         promptManager: state.promptManager,
-        messageHistory: state.messageHistory,
+        messageHistory: state.sessionManager,
         modelManager: state.modelManager,
         tokenTracker: state.tokenTracker,
         tokenCounter: state.tokenCounter,
@@ -266,35 +339,45 @@ async function runCliMode(state) {
     });
     (await asyncTry(cliProcess.run())).recover(handleError);
 }
-async function runReplMode(state) {
+async function runReplMode(state, stdinWasPiped) {
+    // Initialize tools before creating REPL (needed for session reload reconstruction)
+    const tools = await initTools({
+        workspace,
+    });
     const agent = new Agent({
-        messageHistory: state.messageHistory,
+        sessionManager: state.sessionManager,
         modelManager: state.modelManager,
         tokenTracker: state.tokenTracker,
     });
+    // When stdin was piped, use /dev/tty for interactive input instead of process.stdin
     const repl = new NewRepl({
         agent,
         promptManager: state.promptManager,
         config: state.appConfig,
-        messageHistory: state.messageHistory,
+        messageHistory: state.sessionManager,
         modelManager: state.modelManager,
         tokenTracker: state.tokenTracker,
         commands: state.commands,
         tokenCounter: state.tokenCounter,
         promptHistory: state.promptHistory,
         workspace,
+        tools,
+        terminalOptions: { useTty: stdinWasPiped },
     });
-    // Initialize TUI
     await repl.init();
-    state.messageHistory.on("clear-history", () => {
+    // Reconstruct session display if there are existing messages
+    if (!state.sessionManager.isEmpty()) {
+        await repl.rerender();
+    }
+    state.sessionManager.on("clear-history", () => {
         logger.info("Resetting agent state.");
         agent.resetState();
-        repl.rerender();
+        void repl.rerender();
     });
     // Set interrupt callback
-    repl.setInterruptCallback(() => {
+    repl.setInterruptCallback(async () => {
         try {
-            state.messageHistory.save();
+            await state.sessionManager.save();
         }
         catch (error) {
             // Log but don't throw - we still want to abort the agent
@@ -302,27 +385,44 @@ async function runReplMode(state) {
         }
         agent.abort();
     });
-    // Initialize tools
-    const coreTools = await initTools({
-        tokenCounter: state.tokenCounter,
-        workspace,
-        modelManager: state.modelManager,
-        tokenTracker: state.tokenTracker,
-    });
-    const agentTools = await initAgents({
-        modelManager: state.modelManager,
-        tokenTracker: state.tokenTracker,
-        tokenCounter: state.tokenCounter,
-        workspace,
+    // Set exit callback
+    repl.setExitCallback((sessionId) => {
+        if (!state.sessionManager.isEmpty()) {
+            console.info(`\nTo resume this session call acai --resume ${sessionId}`);
+        }
     });
-    const completeToolDefs = {
-        ...coreTools.toolDefs,
-        ...agentTools.toolDefs,
-    };
-    const tools = {
-        toolDefs: completeToolDefs,
-        executors: new Map([...coreTools.executors, ...agentTools.executors]),
-    };
+    // Auto-process pending prompt from stdin
+    if (state.promptManager.isPending()) {
+        const projectConfig = await config.getConfig();
+        const activeTools = projectConfig.tools.activeTools;
+        const skillsEnabled = !flags["no-skills"] && (projectConfig.skills?.enabled ?? true);
+        try {
+            // Get the prompt text before it gets cleared by getUserMessage()
+            const promptText = state.promptManager.get();
+            // Get the user message (includes context if any) and add to history
+            const userMessage = state.promptManager.getUserMessage();
+            state.sessionManager.appendUserMessage(userMessage);
+            const systemPromptResult = await systemPrompt({
+                activeTools,
+                allowedDirs: workspace.allowedDirs,
+                skillsEnabled,
+            });
+            const results = agent.run({
+                systemPrompt: systemPromptResult.prompt,
+                input: promptText,
+                tools,
+                activeTools,
+                abortSignal: agent.abortSignal,
+            });
+            for await (const result of results) {
+                await repl.handle(result, agent.state);
+            }
+            await state.sessionManager.save();
+        }
+        catch (_error) {
+            // Error displayed in the TUI
+        }
+    }
     // Interactive loop
     while (true) {
         const userInput = await repl.getUserInput();
@@ -330,23 +430,22 @@ async function runReplMode(state) {
         const activeTools = projectConfig.tools.activeTools;
         const skillsEnabled = !flags["no-skills"] && (projectConfig.skills?.enabled ?? true);
         try {
+            const systemPromptResult = await systemPrompt({
+                activeTools,
+                allowedDirs: workspace.allowedDirs,
+                skillsEnabled,
+            });
             const results = agent.run({
-                systemPrompt: await systemPrompt({
-                    type: projectConfig.systemPromptType,
-                    activeTools,
-                    allowedDirs: workspace.allowedDirs,
-                    skillsEnabled,
-                }),
+                systemPrompt: systemPromptResult.prompt,
                 input: userInput,
-                toolDefs: tools.toolDefs,
+                tools,
                 activeTools,
-                executors: tools.executors,
                 abortSignal: agent.abortSignal,
             });
             for await (const result of results) {
-                repl.handle(result, agent.state);
+                await repl.handle(result, agent.state);
             }
-            state.messageHistory.save();
+            await state.sessionManager.save();
         }
         catch (_error) {
             // Display error in the TUI by adding an error message to the chat
@@ -365,9 +464,9 @@ async function main() {
         // Validate CLI arguments
         validateCliArguments();
         // Determine initial prompt
-        const { initialPromptInput, stdInPrompt, hasContinueOrResume } = await determineInitialPrompt();
+        const { initialPromptInput, stdinContent, hasContinueOrResume, resumeSessionId, } = await determineInitialPrompt();
         // Initialize application state
-        const state = await initializeAppState(appConfig, initialPromptInput, stdInPrompt, hasContinueOrResume);
+        const state = await initializeAppState(appConfig, initialPromptInput, stdinContent, hasContinueOrResume, resumeSessionId);
         // Set terminal title after all validation is complete
         setTerminalTitle(`acai: ${workspace.primaryDir}`);
         // Handle CLI mode if initial prompt provided
@@ -375,11 +474,11 @@ async function main() {
             return await runCliMode(state);
         }
         // Setup REPL mode
-        return await runReplMode(state);
+        return await runReplMode(state, stdinContent !== null);
     }
     catch (error) {
         handleError(error);
         process.exit(1);
     }
 }
-main();
+void main();

package/dist/logger.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../source/logger.ts"],"names":[],"mappings":"AACA,OAAO,IAAI,MAAM,MAAM,CAAC;AAwDxB,eAAO,MAAM,MAAM,6BAIjB,CAAC"}
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../source/logger.ts"],"names":[],"mappings":"AACA,OAAO,IAAI,MAAM,MAAM,CAAC;AAgDxB,eAAO,MAAM,MAAM,6BAIjB,CAAC"}

package/dist/logger.js

@@ -4,18 +4,11 @@ import { config } from "./config.js";
 // Create a lazy logger factory that only initializes when first used
 let loggerInstance = null;
 function createLogger() {
-    // Check if we're running in code interpreter context
-    // Try multiple detection methods:
-    // 1. Environment variable (primary method)
-    // 2. Check if we're running with Node.js permissions (fallback)
-    const isCodeInterpreter = process.env["ACAI_CODE_INTERPRETER"] === "true" ||
-        (typeof process.permission !== "undefined" &&
-            process.permission.has !== undefined);
-    if (isCodeInterpreter) {
-        // In code interpreter context, use a no-op logger to avoid noise in script output
+    const isTest = process.env["NODE_ENV"] === "test";
+    if (isTest) {
         return pino({
-            level: "silent", // Completely disable logging
-            enabled: false, // Disable the logger entirely
+            level: "silent",
+            enabled: false,
         });
     }
     // Normal file-based logging

package/dist/mentions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mentions.d.ts","sourceRoot":"","sources":["../source/mentions.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAC3D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAsBxD,qBAAa,WAAY,SAAQ,KAAK;gBACxB,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,KAAK;CAI3C;AA+JD,wBAAsB,aAAa,CACjC,OAAO,EAAE,MAAM,EACf,EACE,OAAO,EACP,KAAK,EACL,UAAU,GACX,EAAE;IACD,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,aAAa,CAAC;IACrB,UAAU,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAClC,GACA,OAAO,CAAC;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,WAAW,EAAE,CAAA;CAAE,CAAC,CA8GtD"}
+{"version":3,"file":"mentions.d.ts","sourceRoot":"","sources":["../source/mentions.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAC3D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAqBxD,qBAAa,WAAY,SAAQ,KAAK;gBACxB,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,KAAK;CAI3C;AAwID,wBAAsB,aAAa,CACjC,OAAO,EAAE,MAAM,EACf,EACE,OAAO,EACP,KAAK,EACL,UAAU,GACX,EAAE;IACD,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,aAAa,CAAC;IACrB,UAAU,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAClC,GACA,OAAO,CAAC;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,WAAW,EAAE,CAAA;CAAE,CAAC,CAkFtD"}

package/dist/mentions.js

@@ -1,9 +1,7 @@
 import fs from "node:fs/promises";
 import path from "node:path";
-import { isString } from "@travisennis/stdlib/typeguards";
 import { initExecutionEnvironment } from "./execution/index.js";
-import { formatFile, formatUrl } from "./formatting.js";
-import { readUrl } from "./tools/web-fetch.js";
+import { formatFile } from "./formatting.js";
 class ShellCommandError extends Error {
     command;
     exitCode;
@@ -115,35 +113,11 @@ async function processShellCommand(command) {
     }
 }
 // Returns the formatted string or an error message string
-async function processUrlCommand(context) {
-    const { match } = context;
-    const urlPath = match;
-    try {
-        return Object.assign(await readUrl(urlPath), { source: urlPath });
-    }
-    catch (error) {
-        if (error instanceof Error) {
-            return {
-                contentType: "text/plain",
-                data: `Url: ${urlPath} Status: Error fetching URL: ${error.message}`,
-                source: urlPath,
-            };
-        }
-        // Fallback for unknown error types
-        return {
-            contentType: "text/plain",
-            data: `Url: ${urlPath} Status: Error fetching URL: An unknown error occurred.`,
-            source: urlPath,
-        };
-    }
-}
 export async function processPrompt(message, { baseDir, model, pasteStore, }) {
     const fileRegex = /@([^\s@]+(?:\.[\w\d]+))/g;
-    const urlRegex = /@(https?:\/\/[^\s]+)/g;
     const shellRegex = /!`([^`]+)`/g;
-    // Collect all matches for files and urls
+    // Collect all matches for files
     const fileMatches = Array.from(message.matchAll(fileRegex));
-    const urlMatches = Array.from(message.matchAll(urlRegex));
     const shellMatches = Array.from(message.matchAll(shellRegex));
     const mentionProcessingPromises = [];
     // Process file references - collect promises
@@ -158,18 +132,6 @@ export async function processPrompt(message, { baseDir, model, pasteStore, }) {
             mentionProcessingPromises.push(processFileCommand(context));
         }
     }
-    // Process url references - collect promises
-    for (const match of urlMatches) {
-        const firstMatch = match[1];
-        if (firstMatch) {
-            const context = {
-                model,
-                baseDir, // baseDir is not used by processUrlCommand but kept for consistency
-                match: firstMatch,
-            };
-            mentionProcessingPromises.push(processUrlCommand(context));
-        }
-    }
     let processedMessage = message;
     // Process paste placeholders
     if (pasteStore && pasteStore.size > 0) {
@@ -208,19 +170,7 @@ export async function processPrompt(message, { baseDir, model, pasteStore, }) {
     const mentionResults = await Promise.all(mentionProcessingPromises);
     const context = [];
     for (const mention of mentionResults) {
-        if (isString(mention)) {
-            context.push(mention);
-        }
-        else if (mention.data.startsWith("data")) {
-            context.push({
-                type: "image",
-                mediaType: mention.contentType,
-                image: mention.data,
-            });
-        }
-        else {
-            context.push(formatUrl(mention.source, mention.data.trim(), model.promptFormat));
-        }
+        context.push(mention);
     }
     return {
         message: processedMessage,