@almyty/chat 0.1.4 → 1.2.0

package/dist/commands.js

@@ -0,0 +1,79 @@
+// ── Slash command resolution ────────────────────────────────────
+export const SLASH_COMMANDS = [
+    'agents', 'tools', 'runners', 'code', 'code-stop', 'esc', 'help', 'clear', 'quit',
+];
+export const ALIASES = {
+    agent: 'agents', ag: 'agents', switch: 'agents', sw: 'agents',
+    tool: 'tools', t: 'tools',
+    runner: 'runners',
+    stop: 'code-stop',
+    detach: 'esc',
+    h: 'help', '?': 'help',
+    cls: 'clear', c: 'clear',
+    exit: 'quit', q: 'quit',
+};
+export const COMMAND_DESCS = {
+    agents: 'browse and switch agents',
+    tools: 'show available tools',
+    runners: 'list your runners + coding CLIs',
+    code: 'run a coding task on a runner',
+    'code-stop': 'stop the active coding session',
+    esc: 'leave coding mode (session keeps running)',
+    help: 'show commands',
+    clear: 'clear conversation',
+    quit: 'exit',
+};
+export function resolveSlash(input) {
+    const name = input.toLowerCase();
+    if (SLASH_COMMANDS.includes(name))
+        return name;
+    if (ALIASES[name])
+        return ALIASES[name];
+    const prefixed = SLASH_COMMANDS.filter(c => c.startsWith(name));
+    if (prefixed.length === 1)
+        return prefixed[0];
+    return null;
+}
+export function getSuggestion(partial) {
+    if (!partial.startsWith('/') || partial.includes(' '))
+        return '';
+    const p = partial.slice(1).toLowerCase();
+    if (!p)
+        return '';
+    const match = SLASH_COMMANDS.find(c => c.startsWith(p) && c !== p);
+    return match ? `/${match}` : '';
+}
+/**
+ * Where a submitted line goes: slash commands are always commands; when a
+ * coding session is active, everything else routes to the session's stdin;
+ * otherwise it's a normal chat message.
+ */
+export function classifyInput(value, codingActive) {
+    if (value.trim().startsWith('/'))
+        return 'command';
+    return codingActive ? 'coding' : 'chat';
+}
+// ── /code target selection ──────────────────────────────────────
+/** Runner states that can accept a coding dispatch. */
+const DISPATCHABLE_STATES = new Set(['online', 'busy']);
+/**
+ * Expand online runners x detected coding CLIs into a flat choice list for
+ * the selector. Offline/stale runners and runners without any detected
+ * coding CLI are excluded.
+ */
+export function buildCodeChoices(runners) {
+    const choices = [];
+    for (const runner of runners) {
+        if (!DISPATCHABLE_STATES.has(runner.state ?? ''))
+            continue;
+        for (const agent of runner.codingAgents ?? []) {
+            choices.push({
+                runnerId: runner.id,
+                runnerName: runner.name,
+                agentId: agent.id,
+                agentName: agent.displayName || agent.id,
+            });
+        }
+    }
+    return choices;
+}

package/dist/components.d.ts

@@ -0,0 +1,55 @@
+import React from 'react';
+import type { AgentInfo } from '@almyty/client';
+export interface Message {
+    role: 'user' | 'agent' | 'error' | 'info' | 'tool' | 'coding';
+    text: string;
+}
+export declare function MarkdownText({ children, prefix, prefixColor }: {
+    children: string;
+    prefix?: string;
+    prefixColor?: string;
+}): React.JSX.Element;
+export declare function InlineFormat({ text }: {
+    text: string;
+}): React.JSX.Element;
+export declare function boldify(text: string): React.ReactElement;
+export declare function estimateLines(msg: Message, cols: number): number;
+export declare function MessageWindow({ messages, loading, loadingLabel, maxRows, scrollOffset }: {
+    messages: Message[];
+    loading: boolean;
+    loadingLabel: string;
+    maxRows: number;
+    scrollOffset?: number;
+}): React.JSX.Element;
+export declare function Header({ agent, conversationId }: {
+    agent: AgentInfo;
+    conversationId?: string | null;
+}): React.JSX.Element;
+export declare function MessageView({ msg }: {
+    msg: Message;
+}): React.JSX.Element | null;
+export declare function LoadingIndicator({ label }: {
+    label: string;
+}): React.JSX.Element;
+export declare function AgentSelector({ agents, onSelect }: {
+    agents: AgentInfo[];
+    onSelect: (a: AgentInfo) => void;
+}): React.JSX.Element;
+/**
+ * Visible mode banner while a coding session is active: input routes to the
+ * session, /esc detaches, /code-stop kills it.
+ */
+export declare function CodingModeIndicator({ agent, runner }: {
+    agent: string;
+    runner: string;
+}): React.JSX.Element;
+export interface Choice {
+    key: string;
+    label: string;
+    hint?: string;
+}
+export declare function ChoiceSelector({ title, choices, onSelect }: {
+    title: string;
+    choices: Choice[];
+    onSelect: (c: Choice) => void;
+}): React.JSX.Element;

package/dist/components.js

@@ -0,0 +1,183 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { useState } from 'react';
+import { Box, Text, useInput } from 'ink';
+import Spinner from 'ink-spinner';
+// ── Simple markdown rendering ───────────────────────────────────
+export function MarkdownText({ children, prefix, prefixColor }) {
+    const lines = children.split('\n');
+    const elements = [];
+    let inCode = false;
+    let codeLines = [];
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (line.trimStart().startsWith('```')) {
+            if (!inCode) {
+                inCode = true;
+                codeLines = [];
+            }
+            else {
+                inCode = false;
+                elements.push(_jsx(Box, { flexDirection: "column", paddingLeft: 1, paddingRight: 1, marginTop: 1, marginBottom: 1, children: codeLines.map((cl, j) => (_jsx(Text, { color: "white", backgroundColor: "#333", children: `  ${cl}  ` }, j))) }, `code-${i}`));
+            }
+            continue;
+        }
+        if (inCode) {
+            codeLines.push(line);
+            continue;
+        }
+        // Headers
+        const hm = line.match(/^(#{1,3})\s+(.*)/);
+        if (hm) {
+            elements.push(_jsx(Text, { bold: true, color: "#8b5cf6", children: hm[2] }, i));
+            continue;
+        }
+        // Unordered list
+        const ulm = line.match(/^(\s*)[*-]\s+(.*)/);
+        if (ulm) {
+            elements.push(_jsxs(Text, { children: [ulm[1], _jsx(Text, { color: "#8b5cf6", children: "\u2022" }), " ", _jsx(InlineFormat, { text: ulm[2] })] }, i));
+            continue;
+        }
+        // Ordered list
+        const olm = line.match(/^(\s*)(\d+)\.\s+(.*)/);
+        if (olm) {
+            elements.push(_jsxs(Text, { children: [olm[1], _jsxs(Text, { dimColor: true, children: [olm[2], "."] }), " ", _jsx(InlineFormat, { text: olm[3] })] }, i));
+            continue;
+        }
+        // Blank
+        if (!line.trim()) {
+            elements.push(_jsx(Text, { children: " " }, i));
+            continue;
+        }
+        elements.push(_jsx(Text, { children: _jsx(InlineFormat, { text: line }) }, i));
+    }
+    return _jsx(Box, { flexDirection: "column", children: elements });
+}
+export function InlineFormat({ text }) {
+    // Simple bold/code rendering via split
+    const parts = [];
+    let remaining = text;
+    let idx = 0;
+    while (remaining) {
+        // Inline code
+        const codeMatch = remaining.match(/^(.*?)`([^`]+)`(.*)/);
+        if (codeMatch) {
+            if (codeMatch[1])
+                parts.push(_jsx(Text, { children: boldify(codeMatch[1]) }, idx++));
+            parts.push(_jsx(Text, { backgroundColor: "#333", color: "white", children: ` ${codeMatch[2]} ` }, idx++));
+            remaining = codeMatch[3];
+            continue;
+        }
+        parts.push(_jsx(Text, { children: boldify(remaining) }, idx++));
+        break;
+    }
+    return _jsx(_Fragment, { children: parts });
+}
+export function boldify(text) {
+    const parts = [];
+    let remaining = text;
+    let idx = 0;
+    while (remaining) {
+        const bm = remaining.match(/^(.*?)\*\*(.+?)\*\*(.*)/);
+        if (bm) {
+            if (bm[1])
+                parts.push(_jsx(Text, { children: bm[1] }, idx++));
+            parts.push(_jsx(Text, { bold: true, children: bm[2] }, idx++));
+            remaining = bm[3];
+            continue;
+        }
+        parts.push(_jsx(Text, { children: remaining }, idx++));
+        break;
+    }
+    return _jsx(_Fragment, { children: parts });
+}
+// ── Message window (manual scroll) ──────────────────────────────
+export function estimateLines(msg, cols) {
+    const textWidth = Math.max(cols - 10, 20);
+    const lines = msg.text.split('\n');
+    let total = 1; // margin
+    for (const line of lines) {
+        total += Math.max(1, Math.ceil(Math.max(line.length, 1) / textWidth));
+    }
+    return total;
+}
+export function MessageWindow({ messages, loading, loadingLabel, maxRows, scrollOffset = 0 }) {
+    const cols = process.stdout.columns || 80;
+    const available = Math.max(maxRows, 5);
+    // Calculate the end of the visible window (shifted by scrollOffset)
+    const endIdx = Math.max(0, messages.length - scrollOffset);
+    // Walk backwards from endIdx to find how many messages fit
+    let usedRows = loading && scrollOffset === 0 ? 2 : 0;
+    let startIdx = endIdx;
+    for (let i = endIdx - 1; i >= 0; i--) {
+        const est = estimateLines(messages[i], cols);
+        if (usedRows + est > available && i < endIdx - 1)
+            break;
+        usedRows += est;
+        startIdx = i;
+    }
+    const visible = messages.slice(startIdx, endIdx);
+    const hasEarlier = startIdx > 0;
+    const hasLater = endIdx < messages.length;
+    return (_jsxs(Box, { flexDirection: "column", children: [hasEarlier && (_jsx(Box, { paddingLeft: 2, children: _jsxs(Text, { dimColor: true, children: ["\u2191 ", startIdx, " earlier \u00B7 scroll to see more"] }) })), visible.map((msg, i) => (_jsx(MessageView, { msg: msg }, startIdx + i))), loading && scrollOffset === 0 && _jsx(LoadingIndicator, { label: loadingLabel }), hasLater && (_jsx(Box, { paddingLeft: 2, children: _jsxs(Text, { dimColor: true, children: ["\u2193 ", messages.length - endIdx, " newer \u00B7 scroll to see more"] }) }))] }));
+}
+// ── Components ──────────────────────────────────────────────────
+export function Header({ agent, conversationId }) {
+    const convSuffix = conversationId ? `  ${conversationId.slice(0, 8)}` : '';
+    return (_jsxs(Box, { borderStyle: "round", borderColor: "#555", paddingX: 1, flexDirection: "column", children: [_jsx(Text, { wrap: "truncate", children: `⚡ almyty · ${agent.name}  ${agent.mode || ''}${convSuffix}` }), agent.description && _jsx(Text, { dimColor: true, wrap: "truncate", children: agent.description })] }));
+}
+export function MessageView({ msg }) {
+    switch (msg.role) {
+        case 'user':
+            return (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { children: ["\u276F ", msg.text] }) }));
+        case 'agent':
+            return (_jsxs(Box, { marginTop: 1, paddingLeft: 2, flexDirection: "column", children: [_jsx(Text, { color: "#8b5cf6", children: "\u2502" }), _jsx(Box, { paddingLeft: 2, children: _jsx(MarkdownText, { children: msg.text }) })] }));
+        case 'tool':
+            return (_jsx(Box, { paddingLeft: 2, children: _jsxs(Text, { dimColor: true, children: ["\u2502 \u25B8 ", msg.text] }) }));
+        case 'error':
+            return (_jsx(Box, { marginTop: 1, paddingLeft: 2, children: _jsxs(Text, { color: "red", children: ["\u2502 ", msg.text] }) }));
+        case 'info':
+            return (_jsx(Box, { paddingLeft: 2, children: _jsxs(Text, { dimColor: true, children: ["\u2502 ", msg.text] }) }));
+        case 'coding':
+            // Coding-session output: distinct cyan gutter so streamed CLI output
+            // reads apart from agent/chat messages.
+            return (_jsx(Box, { paddingLeft: 2, flexDirection: "column", children: msg.text.replace(/\n+$/, '').split('\n').map((line, i) => (_jsxs(Text, { wrap: "truncate-end", children: [_jsx(Text, { color: "#22d3ee", children: "\u258D " }), _jsx(Text, { dimColor: true, children: line || ' ' })] }, i))) }));
+        default:
+            return null;
+    }
+}
+export function LoadingIndicator({ label }) {
+    return (_jsxs(Box, { marginTop: 1, paddingLeft: 2, children: [_jsx(Text, { color: "#8b5cf6", children: _jsx(Spinner, { type: "dots" }) }), _jsxs(Text, { dimColor: true, children: [" ", label] })] }));
+}
+// ── Agent selector ──────────────────────────────────────────────
+export function AgentSelector({ agents, onSelect }) {
+    const [cursor, setCursor] = useState(0);
+    useInput((input, key) => {
+        if (key.upArrow)
+            setCursor(c => (c - 1 + agents.length) % agents.length);
+        if (key.downArrow)
+            setCursor(c => (c + 1) % agents.length);
+        if (key.return)
+            onSelect(agents[cursor]);
+    });
+    return (_jsxs(Box, { flexDirection: "column", paddingTop: 1, children: [_jsx(Text, { dimColor: true, children: "  Select an agent:" }), _jsx(Text, { children: " " }), agents.map((ag, i) => (_jsxs(Box, { paddingLeft: 2, children: [_jsxs(Text, { color: i === cursor ? '#8b5cf6' : undefined, children: [i === cursor ? '❯' : ' ', ' '] }), _jsx(Text, { bold: i === cursor, children: ag.name }), _jsxs(Text, { dimColor: true, children: [" ", ag.mode] })] }, ag.id))), agents[cursor]?.description && (_jsx(Box, { paddingLeft: 4, paddingTop: 1, children: _jsx(Text, { dimColor: true, children: agents[cursor].description }) }))] }));
+}
+// ── Coding mode ─────────────────────────────────────────────────
+/**
+ * Visible mode banner while a coding session is active: input routes to the
+ * session, /esc detaches, /code-stop kills it.
+ */
+export function CodingModeIndicator({ agent, runner }) {
+    return (_jsxs(Box, { paddingX: 1, children: [_jsx(Text, { backgroundColor: "#0891B2", color: "black", children: " coding " }), _jsxs(Text, { color: "#22d3ee", children: [" ", agent, "@", runner] }), _jsx(Text, { dimColor: true, children: "  input goes to the session \u00B7 /esc detach \u00B7 /code-stop stop" })] }));
+}
+export function ChoiceSelector({ title, choices, onSelect }) {
+    const [cursor, setCursor] = useState(0);
+    useInput((input, key) => {
+        if (key.upArrow)
+            setCursor(c => (c - 1 + choices.length) % choices.length);
+        if (key.downArrow)
+            setCursor(c => (c + 1) % choices.length);
+        if (key.return)
+            onSelect(choices[cursor]);
+    });
+    return (_jsxs(Box, { flexDirection: "column", paddingTop: 1, children: [_jsxs(Text, { dimColor: true, children: ["  ", title] }), _jsx(Text, { children: " " }), choices.map((choice, i) => (_jsxs(Box, { paddingLeft: 2, children: [_jsxs(Text, { color: i === cursor ? '#8b5cf6' : undefined, children: [i === cursor ? '❯' : ' ', ' '] }), _jsx(Text, { bold: i === cursor, children: choice.label }), choice.hint && _jsxs(Text, { dimColor: true, children: [" ", choice.hint] })] }, choice.key)))] }));
+}

package/dist/index.d.ts

@@ -1,9 +1,2 @@
 #!/usr/bin/env node
-/**
- * @almyty/chat — interactive agent chat.
- *
- *   npx @almyty/chat                       # pick from a menu
- *   npx @almyty/chat <agent>               # start chatting
- *   npx @almyty/chat <agent> --resume <id> # resume a conversation
- */
-export {};
+export declare const VERSION = "0.2.0";