@travisennis/acai 0.0.3 → 0.0.5

package/dist/api/exa/index.js

@@ -0,0 +1,439 @@
+import { isZodSchema, zodToJsonSchema } from "../../utils/zod-utils.js";
+// Prefer global fetch/Headers from Node >= 18
+const fetchImpl = globalThis.fetch;
+const HeadersImpl = globalThis.Headers;
+/**
+ * HTTP status codes
+ */
+const HttpStatusCode = {
+    badRequest: 400,
+    notFound: 404,
+    unauthorized: 401,
+    forbidden: 403,
+    tooManyRequests: 429,
+    requestTimeout: 408,
+    internalServerError: 500,
+    serviceUnavailable: 503,
+};
+/**
+ * Base error class for all Exa API errors
+ */
+class ExaError extends Error {
+    statusCode;
+    timestamp;
+    path;
+    constructor(message, statusCode, timestamp, path) {
+        super(message);
+        this.name = "ExaError";
+        this.statusCode = statusCode;
+        this.timestamp = timestamp ?? new Date().toISOString();
+        this.path = path;
+    }
+}
+export default class Exa {
+    baseUrl;
+    headers;
+    constructor(apiKey, baseUrl = "https://api.exa.ai") {
+        this.baseUrl = baseUrl;
+        let resolvedKey = apiKey;
+        if (!resolvedKey) {
+            resolvedKey = process.env["EXA_API_KEY"];
+            if (!resolvedKey) {
+                throw new ExaError("API key must be provided as an argument or as an environment variable (EXA_API_KEY)", HttpStatusCode.unauthorized);
+            }
+        }
+        // Build base headers
+        const headers = new HeadersImpl();
+        headers.set("x-api-key", resolvedKey);
+        headers.set("Content-Type", "application/json");
+        headers.set("User-Agent", "acai-exa");
+        // Store as a simple record for easier merging and type safety in this codebase
+        const headerRecord = {};
+        headers.forEach((value, key) => {
+            headerRecord[key] = value;
+        });
+        this.headers = headerRecord;
+    }
+    extractContentsOptions(options) {
+        const { text, highlights, summary, subpages, subpageTarget, extras, livecrawl, livecrawlTimeout, context, ...rest } = options;
+        const contentsOptions = {};
+        if (text === undefined &&
+            summary === undefined &&
+            highlights === undefined &&
+            extras === undefined) {
+            contentsOptions.text = true;
+        }
+        if (text !== undefined)
+            contentsOptions.text = text;
+        if (summary !== undefined) {
+            if (typeof summary === "object" &&
+                summary !== null &&
+                "schema" in summary &&
+                summary.schema &&
+                isZodSchema(summary.schema)) {
+                const { schema, ...restSummary } = summary;
+                contentsOptions.summary = {
+                    ...restSummary,
+                    schema: zodToJsonSchema(schema),
+                };
+            }
+            else {
+                contentsOptions.summary = summary;
+            }
+        }
+        if (highlights !== undefined)
+            contentsOptions.highlights = highlights;
+        if (subpages !== undefined)
+            contentsOptions.subpages = subpages;
+        if (subpageTarget !== undefined)
+            contentsOptions.subpageTarget = subpageTarget;
+        if (extras !== undefined)
+            contentsOptions.extras = extras;
+        if (livecrawl !== undefined)
+            contentsOptions.livecrawl = livecrawl;
+        if (livecrawlTimeout !== undefined)
+            contentsOptions.livecrawlTimeout = livecrawlTimeout;
+        if (context !== undefined)
+            contentsOptions.context = context;
+        return {
+            contentsOptions,
+            restOptions: rest,
+        };
+    }
+    async request(endpoint, method, body, params, headers) {
+        if (!fetchImpl) {
+            throw new ExaError("Global fetch is not available in this environment.", HttpStatusCode.internalServerError);
+        }
+        let url = this.baseUrl + endpoint;
+        if (params && Object.keys(params).length > 0) {
+            const searchParams = new URLSearchParams();
+            for (const [key, value] of Object.entries(params)) {
+                if (Array.isArray(value)) {
+                    for (const item of value) {
+                        searchParams.append(key, String(item));
+                    }
+                }
+                else if (value !== undefined && value !== null) {
+                    searchParams.append(key, String(value));
+                }
+            }
+            url += `?${searchParams.toString()}`;
+        }
+        const combinedHeaders = {
+            ...this.headers,
+            ...(headers ?? {}),
+        };
+        const response = await fetchImpl(url, {
+            method,
+            headers: combinedHeaders,
+            body: body !== undefined ? JSON.stringify(body) : undefined,
+        });
+        if (!response.ok) {
+            let errorMessage = `HTTP ${response.status}`;
+            let errorTimestamp;
+            let errorPath = endpoint;
+            try {
+                const errorData = await response.json();
+                const message = (errorData &&
+                    (errorData.error || errorData.message));
+                if (typeof message === "string" && message.length > 0) {
+                    errorMessage = message;
+                }
+                errorTimestamp =
+                    (errorData && errorData.timestamp) ??
+                        new Date().toISOString();
+                errorPath =
+                    (errorData && errorData.path) ?? endpoint;
+            }
+            catch {
+                // ignore body parse errors
+            }
+            throw new ExaError(errorMessage, response.status, errorTimestamp, errorPath);
+        }
+        const contentType = response.headers.get("content-type") || "";
+        if (contentType.includes("text/event-stream")) {
+            return (await this.parseSseStream(response));
+        }
+        return (await response.json());
+    }
+    async rawRequest(endpoint, method = "POST", body, queryParams) {
+        if (!fetchImpl) {
+            throw new ExaError("Global fetch is not available in this environment.", HttpStatusCode.internalServerError);
+        }
+        let url = this.baseUrl + endpoint;
+        if (queryParams) {
+            const searchParams = new URLSearchParams();
+            for (const [key, value] of Object.entries(queryParams)) {
+                if (Array.isArray(value)) {
+                    for (const item of value) {
+                        searchParams.append(key, String(item));
+                    }
+                }
+                else if (value !== undefined && value !== null) {
+                    searchParams.append(key, String(value));
+                }
+            }
+            url += `?${searchParams.toString()}`;
+        }
+        const response = await fetchImpl(url, {
+            method,
+            headers: this.headers,
+            body: body ? JSON.stringify(body) : undefined,
+        });
+        return response;
+    }
+    async search(query, options) {
+        return await this.request("/search", "POST", { query, ...options });
+    }
+    async searchAndContents(query, options) {
+        const { contentsOptions, restOptions } = options === undefined
+            ? {
+                contentsOptions: { text: true },
+                restOptions: {},
+            }
+            : this.extractContentsOptions(options);
+        return await this.request("/search", "POST", {
+            query,
+            contents: contentsOptions,
+            ...restOptions,
+        });
+    }
+    async findSimilar(url, options) {
+        return await this.request("/findSimilar", "POST", { url, ...options });
+    }
+    async findSimilarAndContents(url, options) {
+        const { contentsOptions, restOptions } = options === undefined
+            ? {
+                contentsOptions: { text: true },
+                restOptions: {},
+            }
+            : this.extractContentsOptions(options);
+        return await this.request("/findSimilar", "POST", {
+            url,
+            contents: contentsOptions,
+            ...restOptions,
+        });
+    }
+    async getContents(urls, options) {
+        if (!urls || (Array.isArray(urls) && urls.length === 0)) {
+            throw new ExaError("Must provide at least one URL", HttpStatusCode.badRequest);
+        }
+        let requestUrls;
+        if (typeof urls === "string") {
+            requestUrls = [urls];
+        }
+        else if (Array.isArray(urls) && typeof urls[0] === "string") {
+            requestUrls = urls;
+        }
+        else {
+            requestUrls = urls.map((result) => result.url);
+        }
+        const payload = {
+            urls: requestUrls,
+            ...(options ?? {}),
+        };
+        return await this.request("/contents", "POST", payload);
+    }
+    async answer(query, options) {
+        if (options?.stream) {
+            throw new ExaError("For streaming responses, please use streamAnswer() instead:\n\n" +
+                "for await (const chunk of exa.streamAnswer(query)) {\n" +
+                "  // Handle chunks\n" +
+                "}", HttpStatusCode.badRequest);
+        }
+        let outputSchema = options
+            ?.outputSchema;
+        if (outputSchema && isZodSchema(outputSchema)) {
+            outputSchema = zodToJsonSchema(outputSchema);
+        }
+        const requestBody = {
+            query,
+            stream: false,
+            text: options?.text ?? false,
+            model: options?.model ?? "exa",
+            systemPrompt: options
+                ?.systemPrompt,
+            outputSchema,
+            userLocation: options
+                ?.userLocation,
+        };
+        return await this.request("/answer", "POST", requestBody);
+    }
+    async *streamAnswer(query, options) {
+        if (!fetchImpl) {
+            throw new ExaError("Global fetch is not available in this environment.", HttpStatusCode.internalServerError);
+        }
+        let outputSchema = options?.outputSchema;
+        if (outputSchema && isZodSchema(outputSchema)) {
+            outputSchema = zodToJsonSchema(outputSchema);
+        }
+        const body = {
+            query,
+            text: options?.text ?? false,
+            stream: true,
+            model: options?.model ?? "exa",
+            systemPrompt: options?.systemPrompt,
+            outputSchema,
+        };
+        const response = await fetchImpl(`${this.baseUrl}/answer`, {
+            method: "POST",
+            headers: this.headers,
+            body: JSON.stringify(body),
+        });
+        if (!response.ok) {
+            const message = await response.text();
+            throw new ExaError(message, response.status, new Date().toISOString());
+        }
+        const reader = response.body?.getReader();
+        if (!reader) {
+            throw new ExaError("No response body available for streaming.", 500, new Date().toISOString());
+        }
+        const decoder = new TextDecoder();
+        let buffer = "";
+        try {
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                buffer += decoder.decode(value, { stream: true });
+                const lines = buffer.split("\n");
+                buffer = lines.pop() ?? "";
+                for (const line of lines) {
+                    if (!line.startsWith("data: "))
+                        continue;
+                    const jsonStr = line.replace(/^data:\s*/, "").trim();
+                    if (!jsonStr || jsonStr === "[DONE]") {
+                        continue;
+                    }
+                    let chunkData;
+                    try {
+                        chunkData = JSON.parse(jsonStr);
+                    }
+                    catch {
+                        continue;
+                    }
+                    const chunk = this.processChunk(chunkData);
+                    if (chunk.content || chunk.citations) {
+                        yield chunk;
+                    }
+                }
+            }
+            if (buffer.startsWith("data: ")) {
+                const leftover = buffer.replace(/^data:\s*/, "").trim();
+                if (leftover && leftover !== "[DONE]") {
+                    try {
+                        const chunkData = JSON.parse(leftover);
+                        const chunk = this.processChunk(chunkData);
+                        if (chunk.content || chunk.citations) {
+                            yield chunk;
+                        }
+                    }
+                    catch {
+                        // ignore
+                    }
+                }
+            }
+        }
+        finally {
+            reader.releaseLock();
+        }
+    }
+    processChunk(chunkData) {
+        let content;
+        let citations;
+        const data = chunkData;
+        const choices = data?.["choices"] ?? undefined;
+        if (choices?.[0]?.delta) {
+            const c = choices[0].delta.content;
+            if (typeof c === "string") {
+                content = c;
+            }
+        }
+        const rawCitations = data?.["citations"];
+        if (rawCitations &&
+            rawCitations !== "null" &&
+            Array.isArray(rawCitations)) {
+            citations = rawCitations.map((c) => ({
+                id: String(c["id"] ?? ""),
+                url: String(c["url"] ?? ""),
+                title: typeof c["title"] === "string"
+                    ? c["title"]
+                    : undefined,
+                publishedDate: typeof c["publishedDate"] === "string"
+                    ? c["publishedDate"]
+                    : undefined,
+                author: typeof c["author"] === "string"
+                    ? c["author"]
+                    : undefined,
+                text: typeof c["text"] === "string"
+                    ? c["text"]
+                    : undefined,
+            }));
+        }
+        return { content, citations };
+    }
+    async parseSseStream(response) {
+        const reader = response.body?.getReader();
+        if (!reader) {
+            throw new ExaError("No response body available for streaming.", 500, new Date().toISOString());
+        }
+        const decoder = new TextDecoder();
+        let buffer = "";
+        return await new Promise((resolve, reject) => {
+            (async () => {
+                try {
+                    while (true) {
+                        const { done, value } = await reader.read();
+                        if (done)
+                            break;
+                        buffer += decoder.decode(value, { stream: true });
+                        const lines = buffer.split("\n");
+                        buffer = lines.pop() ?? "";
+                        for (const line of lines) {
+                            if (!line.startsWith("data: "))
+                                continue;
+                            const jsonStr = line.replace(/^data:\s*/, "").trim();
+                            if (!jsonStr || jsonStr === "[DONE]") {
+                                continue;
+                            }
+                            let chunk;
+                            try {
+                                chunk = JSON.parse(jsonStr);
+                            }
+                            catch {
+                                continue;
+                            }
+                            const tagged = chunk;
+                            switch (tagged.tag) {
+                                case "complete":
+                                    reader.releaseLock();
+                                    resolve(tagged.data);
+                                    return;
+                                case "error": {
+                                    const message = tagged.error?.message || "Unknown error";
+                                    reader.releaseLock();
+                                    reject(new ExaError(message, HttpStatusCode.internalServerError, new Date().toISOString()));
+                                    return;
+                                }
+                                default:
+                                    break;
+                            }
+                        }
+                    }
+                    reject(new ExaError("Stream ended without a completion event.", HttpStatusCode.internalServerError, new Date().toISOString()));
+                }
+                catch (err) {
+                    reject(err);
+                }
+                finally {
+                    try {
+                        reader.releaseLock();
+                    }
+                    catch {
+                        // ignore
+                    }
+                }
+            })();
+        });
+    }
+}

package/dist/cli.d.ts

@@ -1,8 +1,8 @@
 import type { MessageHistory } from "./messages.ts";
 import type { ModelManager } from "./models/manager.js";
 import type { PromptManager } from "./prompts/manager.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";
 interface CliOptions {
     messageHistory: MessageHistory;
     promptManager: PromptManager;
@@ -17,3 +17,4 @@ export declare class Cli {
     run(): Promise<void>;
 }
 export {};
+//# sourceMappingURL=cli.d.ts.map

package/dist/cli.d.ts.map

@@ -0,0 +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"}

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

@@ -1,2 +1,3 @@
 import type { CommandOptions, ReplCommand } from "./types.ts";
 export declare const applicationLogCommand: ({ terminal, }: CommandOptions) => ReplCommand;
+//# sourceMappingURL=application-log-command.d.ts.map

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

@@ -0,0 +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"}

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

@@ -1,11 +1,10 @@
 import { readFile } from "node:fs/promises";
-import { editor } from "@inquirer/prompts";
 import { config } from "../config.js";
+import { editor } from "../terminal/editor-prompt.js";
 export const applicationLogCommand = ({ terminal, }) => {
     return {
         command: "/application-logs",
         description: "Opens the application log file defined in acai.json in the editor.",
-        result: "continue",
         getSubCommands: () => Promise.resolve([]),
         execute: async () => {
             let logFilePath;
@@ -14,7 +13,7 @@ export const applicationLogCommand = ({ terminal, }) => {
                 logFilePath = projectConfig.logs?.path;
                 if (!logFilePath) {
                     terminal.error("Application log path is not defined in .acai/acai.json under the 'logs.path' key.");
-                    return;
+                    return "continue";
                 }
                 const content = await readFile(logFilePath, { encoding: "utf8" });
                 // Use the editor prompt to display the content (read-only)
@@ -27,8 +26,10 @@ export const applicationLogCommand = ({ terminal, }) => {
                     default: content,
                     // By not providing an onSubmit or similar handler to write the file,
                     // and not calling writeFileSync after, this effectively becomes read-only.
+                    skipPrompt: true,
                 });
                 terminal.info(`Closed log view for: ${logFilePath}`);
+                return "continue";
             }
             catch (error) {
                 if (logFilePath && error.code === "ENOENT") {
@@ -37,6 +38,7 @@ export const applicationLogCommand = ({ terminal, }) => {
                 else {
                     terminal.error(`Error reading or displaying log file ${logFilePath ?? "specified in config"}: ${error}`);
                 }
+                return "continue";
             }
         },
     };

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

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

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

@@ -0,0 +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"}

package/dist/commands/clear-command.js

@@ -2,11 +2,10 @@ export const clearCommand = ({ terminal }) => {
     return {
         command: "/clear",
         description: "Clears the terminal screen.",
-        result: "continue", // Keep the REPL running
         getSubCommands: () => Promise.resolve([]),
-        execute: () => {
+        execute: async () => {
             terminal.clear();
-            return Promise.resolve();
+            return "continue";
         },
     };
 };

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

@@ -1,2 +1,3 @@
 import type { CommandOptions, ReplCommand } from "./types.ts";
 export declare const compactCommand: (options: CommandOptions) => ReplCommand;
+//# sourceMappingURL=compact-command.d.ts.map

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

@@ -0,0 +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"}

package/dist/commands/compact-command.js

@@ -4,7 +4,6 @@ export const compactCommand = (options) => {
     return {
         command: "/compact",
         description: "Saves, summarizes, and resets the chat history. Optional instructions can be provided for the summary.",
-        result: "continue",
         getSubCommands: () => Promise.resolve([]),
         execute: async (args) => {
             const { messageHistory, terminal } = options;
@@ -13,6 +12,7 @@ export const compactCommand = (options) => {
                 await summarizeAndReset(options, additionalInstructions);
             }
             terminal.info("Message history summarized and reset.");
+            return "continue";
         },
     };
 };

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"copy-command.d.ts","sourceRoot":"","sources":["../../source/commands/copy-command.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAyB9D,wBAAgB,WAAW,CAAC,OAAO,EAAE,cAAc,GAAG,WAAW,CA6BhE"}

package/dist/commands/copy-command.js

@@ -26,7 +26,6 @@ export function copyCommand(options) {
     return {
         command: "/copy",
         description: "Copy the last assistant response to the clipboard",
-        result: "continue",
         async getSubCommands() {
             return [];
         },
@@ -36,15 +35,17 @@ export function copyCommand(options) {
             const lastText = extractLastAssistantText(history);
             if (!lastText) {
                 terminal.info("No assistant response to copy.");
-                return;
+                return "continue";
             }
             try {
                 await Clipboard.setText(lastText);
                 terminal.success("Copied last response to clipboard.");
+                return "continue";
             }
             catch (err) {
                 const message = err instanceof Error ? err.message : String(err);
                 terminal.error(`Could not copy to clipboard: ${message}`);
+                return "continue";
             }
         },
     };

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

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

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

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

package/dist/commands/edit-command.js

@@ -1,12 +1,12 @@
 import { existsSync, readFileSync, writeFileSync } from "node:fs";
 import { extname, resolve } from "node:path";
-import { editor, search } from "@inquirer/prompts";
-import { globby } from "globby";
+import { editor } from "../terminal/editor-prompt.js";
+import { search } from "../terminal/search-prompt.js";
+import { glob } from "../utils/glob.js";
 export const editCommand = ({ terminal }) => {
     return {
         command: "/edit",
         description: "Opens file in $EDITOR for editing. Usage: /edit [file-path]",
-        result: "continue",
         getSubCommands: () => Promise.resolve([]),
         execute: async (args) => {
             let fileToEdit;
@@ -16,7 +16,7 @@ export const editCommand = ({ terminal }) => {
                 const resolvedPath = resolve(filePath);
                 if (!existsSync(resolvedPath)) {
                     terminal.error(`File not found: ${filePath}`);
-                    return;
+                    return "continue";
                 }
                 fileToEdit = filePath;
             }
@@ -28,7 +28,7 @@ export const editCommand = ({ terminal }) => {
                         if (!input) {
                             return [];
                         }
-                        const foundFiles = await globby(`**/*${input}*`, {
+                        const foundFiles = await glob(`**/*${input}*`, {
                             gitignore: true,
                         });
                         return foundFiles.map((file) => ({
@@ -43,11 +43,13 @@ export const editCommand = ({ terminal }) => {
                 message: `Edit ${fileToEdit}?`,
                 postfix: extname(fileToEdit),
                 default: content,
+                skipPrompt: true,
             });
             writeFileSync(fileToEdit, edit);
             if (content !== edit) {
                 terminal.info(`File updated: ${fileToEdit}`);
             }
+            return "continue";
         },
     };
 };

package/dist/commands/edit-prompt-command.d.ts

@@ -1,2 +1,3 @@
 import type { CommandOptions, ReplCommand } from "./types.ts";
-export declare const editPromptCommand: ({ terminal, promptManager, }: CommandOptions) => ReplCommand;
+export declare const editPromptCommand: ({ terminal, promptManager, promptHistory, }: CommandOptions) => ReplCommand;
+//# sourceMappingURL=edit-prompt-command.d.ts.map

package/dist/commands/edit-prompt-command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"edit-prompt-command.d.ts","sourceRoot":"","sources":["../../source/commands/edit-prompt-command.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAE9D,eAAO,MAAM,iBAAiB,GAAI,6CAI/B,cAAc,KAAG,WAmCnB,CAAC"}