chatbase 0.0.1 → 0.1.0

package/dist/repl/chat-repl.js

@@ -0,0 +1,129 @@
+import readline from 'node:readline';
+const GREETING = 'Type /exit or press Ctrl-D to quit. Ctrl-C cancels a response. /help for commands.';
+const HELP_LINES = [
+    '/exit    Quit the REPL (same as Ctrl-D)',
+    '/new     Start a fresh conversation (clears the current conversation id)',
+    '/retry   Regenerate the last response (replaces it in the conversation)',
+    '/id      Print the current conversation id',
+    '/help    Show this list'
+];
+/** True for the AbortError a cancelled `send`/`retry` call rejects with —
+ * matches the same duck-typed check `classifyError` uses in base-command.ts. */
+function isAbortError(err) {
+    return err?.name === 'AbortError';
+}
+/**
+ * Runs the interactive chat REPL. Dependency-injected (send/retry/input/
+ * output/info) so tests can drive it with fake streams and fake network
+ * calls — the `chat` command wires real stdin/stdout and `sendChat`.
+ *
+ * Ctrl-C semantics: readline is created with `terminal: true` so it parses
+ * Ctrl-C (byte 0x03) itself and emits its own 'SIGINT' event, distinct from
+ * the process-wide SIGINT the rest of the CLI listens for (see
+ * client/signals.ts) — forcing `terminal: true` is what makes this
+ * intercept work even over the plain PassThrough streams used in tests,
+ * not just a real TTY. While a `send`/`retry` call is in flight, that event
+ * aborts *that call's own* AbortController only; at an idle prompt (nothing
+ * in flight) it exits the REPL, same as /exit.
+ */
+export async function runChatRepl(deps) {
+    const { send, retry, input, output, info } = deps;
+    let conversationId = deps.initialConversationId;
+    let currentController;
+    const rl = readline.createInterface({
+        input,
+        output,
+        terminal: true,
+        prompt: '> '
+    });
+    rl.on('SIGINT', () => {
+        if (currentController) {
+            currentController.abort();
+            return;
+        }
+        rl.close();
+    });
+    // Readline closes the moment its input ends (Ctrl-D, or a piped stream
+    // finishing), but the `for await` loop below may still be draining lines
+    // readline buffered before that. prompt() on a closed interface is a
+    // silent no-op on Node 20/22 but throws ERR_USE_AFTER_CLOSE on Node 24+,
+    // so every prompt goes through this close-aware wrapper.
+    let closed = false;
+    rl.once('close', () => {
+        closed = true;
+    });
+    const prompt = () => {
+        if (!closed)
+            rl.prompt();
+    };
+    /** Runs `fn` under a fresh per-call AbortController wired to the
+     * readline-level Ctrl-C above. Swallows the resulting AbortError (and
+     * any other failure) so one bad turn never crashes the whole REPL —
+     * it prints a note via `info` and returns to the prompt either way. */
+    async function cancelable(fn) {
+        const controller = new AbortController();
+        currentController = controller;
+        try {
+            return await fn(controller.signal);
+        }
+        catch (err) {
+            // A cancelled or failed call may have already streamed partial
+            // text straight to `output` with no trailing newline (send/retry
+            // write tokens as they arrive) — start the note on its own line.
+            output.write('\n');
+            if (isAbortError(err)) {
+                info('[cancelled — response was interrupted]');
+            }
+            else {
+                info(`✗ ${err?.message ?? err}`);
+            }
+            return undefined;
+        }
+        finally {
+            currentController = undefined;
+        }
+    }
+    info(GREETING);
+    prompt();
+    for await (const rawLine of rl) {
+        const line = rawLine.trim();
+        if (line === '') {
+            prompt();
+            continue;
+        }
+        if (line.startsWith('/')) {
+            const cmd = line.split(/\s+/, 1)[0];
+            if (cmd === '/exit')
+                break;
+            if (cmd === '/new') {
+                conversationId = undefined;
+            }
+            else if (cmd === '/retry') {
+                if (!conversationId) {
+                    info('No conversation yet — send a message first.');
+                }
+                else {
+                    await cancelable((signal) => retry(conversationId, signal));
+                }
+            }
+            else if (cmd === '/id') {
+                info(conversationId ?? 'none');
+            }
+            else if (cmd === '/help') {
+                for (const helpLine of HELP_LINES)
+                    info(helpLine);
+            }
+            else {
+                info(`Unknown command: ${cmd} — type /help for a list.`);
+            }
+            prompt();
+            continue;
+        }
+        const result = await cancelable((signal) => send(line, conversationId, signal));
+        if (result?.conversationId)
+            conversationId = result.conversationId;
+        prompt();
+    }
+    rl.close();
+    return { conversationId };
+}

package/dist/version.js

@@ -0,0 +1,3 @@
+import { createRequire } from 'node:module';
+const require = createRequire(import.meta.url);
+export const VERSION = require('../package.json').version;