@almyty/chat 0.2.0 → 1.3.0

package/dist/turn.js

@@ -0,0 +1,147 @@
+/**
+ * One turn of a conversation, driven the same way in both modes.
+ *
+ * The REPL and the non-interactive path used to be different code, and
+ * the non-interactive path did not exist. Both now call `runTurn`,
+ * which owns the choice between a streamed autonomous run and a
+ * streamed workflow pipeline, the cancellation handshake, and the
+ * cost tally. It takes the gateway as an interface so it can be tested
+ * against a fake without a network or a terminal.
+ */
+import { drain, finalText, initialStreamState, reduceStreamEvent, routingFromSteps, } from './stream.js';
+function isAborted(err, signal) {
+    const e = err;
+    return !!signal?.aborted || (!!e && (e.name === 'AbortError' || e.code === 'ABORT_ERR'));
+}
+/** True when the pipeline stream endpoint is not there to be used. */
+function streamUnavailable(err) {
+    const status = err?.status;
+    if (status === 404 || status === 405)
+        return true;
+    return /Unknown agent action|SSE 404|SSE 405/.test(err?.message ?? '');
+}
+/** Wire the reducer's output into the hooks, once per event. */
+function pump(hooks, state, event) {
+    const before = state.partial;
+    const beforeLabel = state.label;
+    let next = reduceStreamEvent(state, event);
+    const drained = drain(next);
+    next = drained.state;
+    for (const activity of drained.activities)
+        hooks?.activity?.(activity);
+    if (next.partial !== before)
+        hooks?.partial?.(next.partial);
+    if (next.label !== beforeLabel)
+        hooks?.label?.(next.label);
+    return next;
+}
+/** Fill in attribution and totals the stream did not carry. */
+function settleUsage(usage, run) {
+    const settled = { ...usage };
+    if (!settled.model && run) {
+        const routing = routingFromSteps(run.steps);
+        if (routing) {
+            settled.model = routing.model ?? settled.model;
+            settled.rationale = routing.rationale ?? settled.rationale;
+            settled.attempt = routing.attempt ?? settled.attempt;
+        }
+    }
+    // The persisted totals are authoritative when the stream missed
+    // events (a reconnect, or a fallback to polling).
+    if (run && typeof run.totalCost === 'number' && run.totalCost > settled.cost)
+        settled.cost = run.totalCost;
+    if (run && typeof run.totalTokens === 'number' && run.totalTokens > settled.tokens)
+        settled.tokens = run.totalTokens;
+    return settled;
+}
+export async function runTurn(target, message, options = {}) {
+    const { hooks, signal } = options;
+    let state = initialStreamState();
+    hooks?.label?.(state.label);
+    if (options.mode === 'autonomous') {
+        let runId;
+        let conversationId = options.conversationId;
+        if (options.pendingRunId) {
+            await target.sendRunInput(options.pendingRunId, message);
+            runId = options.pendingRunId;
+        }
+        else {
+            const run = await target.startRun(message, { ...options.limits, conversationId });
+            runId = run.id;
+            conversationId = run.conversationId ?? conversationId;
+        }
+        let final;
+        try {
+            final = await target.streamRun(runId, (event) => { state = pump(hooks, state, event); }, signal);
+        }
+        catch (err) {
+            if (!isAborted(err, signal))
+                throw err;
+            // Stop the run where it is running, not just where it is watched.
+            // Killing the client alone leaves the run spending money with
+            // nobody reading the answer.
+            await target.cancelRun(runId).catch(() => { });
+            return {
+                status: 'cancelled',
+                text: state.partial.trim(),
+                usage: settleUsage(state.usage, undefined),
+                runId,
+                conversationId,
+            };
+        }
+        if (state.cancelled) {
+            return { status: 'cancelled', text: state.partial.trim(), usage: settleUsage(state.usage, final), runId, conversationId };
+        }
+        const usage = settleUsage(state.usage, final);
+        const text = finalText(state, final?.output);
+        if (final?.status === 'waiting_input') {
+            return { status: 'waiting_input', text, usage, runId, conversationId, pendingRunId: runId };
+        }
+        if (state.failed || final?.status === 'failed' || final?.status === 'timeout') {
+            return { status: 'failed', text, usage, error: state.failed ?? final?.error ?? 'The run failed', runId, conversationId };
+        }
+        return { status: 'completed', text, usage, runId, conversationId };
+    }
+    // Workflow agents: a pipeline, streamed so its nodes are visible.
+    // The execution id arrives on execution.started and is the only handle
+    // on the pipeline: it is not known before the stream opens, and without
+    // it a cancel has nothing to name.
+    let executionId;
+    try {
+        await target.streamInvoke({ message }, (event) => {
+            const id = event?.data?.executionId;
+            if (typeof id === 'string' && id)
+                executionId = id;
+            state = pump(hooks, state, event);
+        }, signal);
+    }
+    catch (err) {
+        if (isAborted(err, signal)) {
+            // Stop the pipeline where it is running, not just where it is
+            // watched -- the same handshake the autonomous branch does with
+            // cancelRun. A workflow run is an execution, not a run, so
+            // cancelRun could never reach it: Ctrl-C reported `cancelled`
+            // while the pipeline ran on, billing model calls nobody would read.
+            if (executionId)
+                await target.cancelExecution(executionId).catch(() => { });
+            return { status: 'cancelled', text: state.partial.trim(), usage: state.usage, conversationId: options.conversationId };
+        }
+        if (!streamUnavailable(err))
+            throw err;
+        // A deployment without the pipeline stream still answers the
+        // blocking call; the run is just invisible while it happens.
+        const result = await target.invoke({ message });
+        const output = result?.output ?? result?.data?.output ?? result;
+        return {
+            status: result?.status && result.status !== 'completed' ? 'failed' : 'completed',
+            text: finalText(state, output),
+            usage: state.usage,
+            error: result?.error,
+            conversationId: options.conversationId,
+        };
+    }
+    if (state.failed) {
+        return { status: 'failed', text: finalText(state), usage: state.usage, error: state.failed, conversationId: options.conversationId };
+    }
+    return { status: 'completed', text: finalText(state), usage: state.usage, conversationId: options.conversationId };
+}

package/dist/version.d.ts

@@ -0,0 +1,2 @@
+export declare function readVersion(fallback?: string): string;
+export declare const VERSION: string;

package/dist/version.js

@@ -0,0 +1,27 @@
+/**
+ * The CLI's own version, read from its package.json at startup.
+ *
+ * Hardcoding it drifted: `--version` answered 0.2.0 while the
+ * published package was 1.2.0, so a bug report never identified the
+ * build it came from. Both `dist/index.js` and `src/index.tsx` sit one
+ * directory below the package root, so the same relative path resolves
+ * for the built bin and for `tsx src/index.tsx`.
+ *
+ * A single-file executable (the `/apps` tui target compiles this client
+ * with `bun --compile`) has no package.json to read, so it falls back.
+ * A compiled terminal app's version is the app's, not this client's,
+ * and the build is where that belongs.
+ */
+import { readFileSync } from 'node:fs';
+export function readVersion(fallback = '0.0.0') {
+    try {
+        const pkg = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf-8'));
+        return typeof pkg.version === 'string' && pkg.version.length > 0
+            ? pkg.version
+            : fallback;
+    }
+    catch {
+        return fallback;
+    }
+}
+export const VERSION = readVersion();

package/dist/viewport.d.ts

@@ -0,0 +1,61 @@
+/**
+ * How much of the transcript fits on screen.
+ *
+ * ink redraws its whole tree, so a transcript taller than the terminal
+ * garbles the frame instead of scrolling it. The fix is to draw only
+ * what fits and say how much is above. Pure arithmetic, kept out of the
+ * components so it can be tested at any terminal size — including the
+ * 40-column window nobody remembers to try.
+ */
+/** Narrowest width worth laying out for. */
+export declare const MIN_COLUMNS = 40;
+/** Fewest transcript rows to draw, even on a very short terminal. */
+export declare const MIN_ROWS = 5;
+export declare function columns(stdoutColumns?: number): number;
+/**
+ * Rows left for the transcript once the header, prompt and status bar
+ * have taken theirs.
+ */
+export declare function usableRows(stdoutRows: number | undefined, chromeRows: number): number;
+/**
+ * How many terminal columns a string occupies.
+ *
+ * `String.length` counts UTF-16 units, which is not width. A CJK
+ * character is one unit and two columns; an emoji is two units and two
+ * columns; a combining mark or a zero-width joiner is a unit and no
+ * columns. Measuring by length made a Japanese or Chinese transcript
+ * estimate half its real height, so the window packed twice what fits
+ * and ink drew a frame taller than the terminal — the garbling the rest
+ * of this module exists to prevent.
+ */
+export declare function displayWidth(text: string): number;
+/**
+ * Rows one message will occupy at this width.
+ *
+ * Counts the wrap, not the characters: a 300-character paragraph is
+ * four rows at 80 columns and eight at 40.
+ */
+export declare function estimateLines(text: string, cols: number): number;
+export interface WindowSelection {
+    startIdx: number;
+    endIdx: number;
+    hiddenBefore: number;
+    hiddenAfter: number;
+}
+/**
+ * The slice of messages to draw.
+ *
+ * Walks backwards from the end so the newest message is always visible:
+ * a transcript that scrolls away from the answer you just asked for is
+ * worse than one that hides the beginning. The newest message is kept
+ * even when it alone is taller than the window, because dropping it
+ * would leave an empty screen.
+ */
+export declare function selectWindow(messages: Array<{
+    text: string;
+}>, options: {
+    rows: number;
+    cols: number;
+    reservedRows?: number;
+    scrollOffset?: number;
+}): WindowSelection;

package/dist/viewport.js

@@ -0,0 +1,118 @@
+/**
+ * How much of the transcript fits on screen.
+ *
+ * ink redraws its whole tree, so a transcript taller than the terminal
+ * garbles the frame instead of scrolling it. The fix is to draw only
+ * what fits and say how much is above. Pure arithmetic, kept out of the
+ * components so it can be tested at any terminal size — including the
+ * 40-column window nobody remembers to try.
+ */
+/** Narrowest width worth laying out for. */
+export const MIN_COLUMNS = 40;
+/** Fewest transcript rows to draw, even on a very short terminal. */
+export const MIN_ROWS = 5;
+export function columns(stdoutColumns) {
+    return Math.max(stdoutColumns && stdoutColumns > 0 ? stdoutColumns : 80, MIN_COLUMNS);
+}
+/**
+ * Rows left for the transcript once the header, prompt and status bar
+ * have taken theirs.
+ */
+export function usableRows(stdoutRows, chromeRows) {
+    const total = stdoutRows && stdoutRows > 0 ? stdoutRows : 24;
+    return Math.max(total - chromeRows, MIN_ROWS);
+}
+/**
+ * Code points that take two terminal columns: the East Asian Wide and
+ * Fullwidth ranges, plus the emoji blocks terminals render double-width.
+ */
+function isWide(cp) {
+    return ((cp >= 0x1100 && cp <= 0x115f) || // Hangul Jamo
+        (cp >= 0x2e80 && cp <= 0x303e) || // CJK radicals, Kangxi, CJK symbols
+        (cp >= 0x3041 && cp <= 0x33ff) || // Hiragana, Katakana, Hangul, CJK compatibility
+        (cp >= 0x3400 && cp <= 0x4dbf) || // CJK extension A
+        (cp >= 0x4e00 && cp <= 0x9fff) || // CJK unified ideographs
+        (cp >= 0xa000 && cp <= 0xa4cf) || // Yi
+        (cp >= 0xac00 && cp <= 0xd7a3) || // Hangul syllables
+        (cp >= 0xf900 && cp <= 0xfaff) || // CJK compatibility ideographs
+        (cp >= 0xfe30 && cp <= 0xfe6f) || // CJK compatibility forms
+        (cp >= 0xff00 && cp <= 0xff60) || // Fullwidth forms
+        (cp >= 0xffe0 && cp <= 0xffe6) ||
+        (cp >= 0x1f300 && cp <= 0x1f64f) || // emoji, pictographs
+        (cp >= 0x1f680 && cp <= 0x1f6ff) ||
+        (cp >= 0x1f900 && cp <= 0x1f9ff) ||
+        (cp >= 0x20000 && cp <= 0x3fffd) // CJK extension B and later
+    );
+}
+/**
+ * How many terminal columns a string occupies.
+ *
+ * `String.length` counts UTF-16 units, which is not width. A CJK
+ * character is one unit and two columns; an emoji is two units and two
+ * columns; a combining mark or a zero-width joiner is a unit and no
+ * columns. Measuring by length made a Japanese or Chinese transcript
+ * estimate half its real height, so the window packed twice what fits
+ * and ink drew a frame taller than the terminal — the garbling the rest
+ * of this module exists to prevent.
+ */
+export function displayWidth(text) {
+    let width = 0;
+    for (const ch of text) {
+        const cp = ch.codePointAt(0);
+        // Zero-width: combining marks, joiners, variation selectors.
+        if (cp === 0x200b || cp === 0x200d || cp === 0xfeff ||
+            (cp >= 0x0300 && cp <= 0x036f) ||
+            (cp >= 0x1ab0 && cp <= 0x1aff) ||
+            (cp >= 0x20d0 && cp <= 0x20f0) ||
+            (cp >= 0xfe00 && cp <= 0xfe0f)) {
+            continue;
+        }
+        width += isWide(cp) ? 2 : 1;
+    }
+    return width;
+}
+/**
+ * Rows one message will occupy at this width.
+ *
+ * Counts the wrap, not the characters: a 300-character paragraph is
+ * four rows at 80 columns and eight at 40.
+ */
+export function estimateLines(text, cols) {
+    const textWidth = Math.max(cols - 10, 20);
+    const lines = text.split('\n');
+    let total = 1; // the margin every message carries
+    for (const line of lines) {
+        total += Math.max(1, Math.ceil(Math.max(displayWidth(line), 1) / textWidth));
+    }
+    return total;
+}
+/**
+ * The slice of messages to draw.
+ *
+ * Walks backwards from the end so the newest message is always visible:
+ * a transcript that scrolls away from the answer you just asked for is
+ * worse than one that hides the beginning. The newest message is kept
+ * even when it alone is taller than the window, because dropping it
+ * would leave an empty screen.
+ */
+export function selectWindow(messages, options) {
+    const scrollOffset = Math.max(0, Math.min(options.scrollOffset ?? 0, messages.length));
+    const available = Math.max(options.rows - (options.reservedRows ?? 0), MIN_ROWS);
+    const endIdx = Math.max(0, messages.length - scrollOffset);
+    let used = 0;
+    let startIdx = endIdx;
+    for (let i = endIdx - 1; i >= 0; i--) {
+        const cost = estimateLines(messages[i].text, options.cols);
+        // The last message always goes in; anything earlier has to fit.
+        if (used + cost > available && i < endIdx - 1)
+            break;
+        used += cost;
+        startIdx = i;
+    }
+    return {
+        startIdx,
+        endIdx,
+        hiddenBefore: startIdx,
+        hiddenAfter: messages.length - endIdx,
+    };
+}

package/package.json

@@ -1,7 +1,10 @@
 {
   "name": "@almyty/chat",
-  "version": "0.2.0",
-  "description": "Interactive chat REPL with almyty agents",
+  "version": "1.3.0",
+  "publishConfig": {
+    "access": "public"
+  },
+  "description": "Chat with your almyty agents in an interactive terminal REPL — multi-turn and streaming, with tool calls and autonomous runs.",
   "type": "module",
   "main": "dist/index.js",
   "bin": {
@@ -12,7 +15,8 @@
   ],
   "scripts": {
     "build": "tsc && chmod +x dist/index.js",
-    "dev": "tsx src/index.ts",
+    "dev": "tsx src/index.tsx",
+    "typecheck": "tsc --noEmit",
     "test": "vitest run",
     "test:watch": "vitest",
     "prepublishOnly": "npm run build"
@@ -25,20 +29,32 @@
     "cli"
   ],
   "author": "almyty",
-  "license": "BSL-1.1",
+  "license": "Apache-2.0",
   "dependencies": {
-    "@almyty/client": "^0.1.0",
-    "@types/react": "^19.2.14",
+    "@almyty/client": "^1.2.0",
     "ink": "^7.0.1",
     "ink-spinner": "^5.0.0",
-    "ink-testing-library": "^4.0.0",
     "ink-text-input": "^6.0.0",
     "react": "^19.2.5"
   },
   "devDependencies": {
     "@types/node": "^25.4.0",
+    "@types/react": "^19.2.14",
+    "ink-testing-library": "^4.0.0",
     "tsx": "^4.7.0",
     "typescript": "^5.3.0",
     "vitest": "^4.1.0"
+  },
+  "homepage": "https://almyty.com",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/almyty-inc/almyty.git",
+    "directory": "packages/chat-cli"
+  },
+  "bugs": {
+    "url": "https://github.com/almyty-inc/almyty/issues"
+  },
+  "overrides": {
+    "postcss": "^8.5.23"
   }
 }