@almyty/chat 0.2.0 → 1.2.0

package/README.md

@@ -40,10 +40,14 @@ Commands:
 
 Requires `npx @almyty/auth login` first. Reads credentials from `~/.almyty/credentials.json`. Override with `ALMYTY_TOKEN` and `ALMYTY_URL` environment variables.
 
-## Docs
+## About almyty
 
-https://almyty.com/docs
+almyty is the full-stack platform for AI agents, agnostic by design: any LLM, any
+API turned into tools, served over MCP, A2A, UTCP, and Agent Skills. Open source,
+no lock-in.
 
-## License
+- Website — https://almyty.com
+- Docs — https://docs.almyty.com
+- Source — https://github.com/almyty-inc/almyty
 
-BSL-1.1
+Apache-2.0 © Almyty Inc.

package/dist/app.d.ts

@@ -1,3 +1,4 @@
+import React from 'react';
 import type { AlmytyClient, GatewayClient, AgentInfo } from '@almyty/client';
 import type { Message } from './components.js';
 export interface AppState {
@@ -8,10 +9,17 @@ export interface AppState {
     conversationId: string | null;
     pendingRunId: string | null;
 }
+/** Active coding session driven from the REPL (chat-to-runner bridge). */
+export interface CodingSessionState {
+    runnerId: string;
+    runnerName: string;
+    agent: string;
+    sessionId: string;
+}
 export declare let exitMessage: string;
 export declare function ChatApp({ client, initialAgent, gw, resumeConversationId }: {
     client: AlmytyClient;
     initialAgent: AgentInfo;
     gw: GatewayClient;
     resumeConversationId?: string;
-}): import("react/jsx-runtime").JSX.Element;
+}): React.JSX.Element;

package/dist/app.js

@@ -1,9 +1,9 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { useState, useCallback, useEffect } from 'react';
+import { useState, useCallback, useEffect, useRef } from 'react';
 import { Box, Text, useApp, useInput } from 'ink';
 import TextInput from 'ink-text-input';
-import { Header, MessageView, LoadingIndicator, AgentSelector } from './components.js';
-import { SLASH_COMMANDS, COMMAND_DESCS, resolveSlash, getSuggestion, ALIASES } from './commands.js';
+import { Header, MessageView, LoadingIndicator, AgentSelector, CodingModeIndicator, ChoiceSelector, } from './components.js';
+import { SLASH_COMMANDS, COMMAND_DESCS, resolveSlash, getSuggestion, ALIASES, classifyInput, buildCodeChoices, } from './commands.js';
 // Mutable module-level variable; written by ChatApp, read by main() after exit
 export let exitMessage = '';
 // ── Chat app ────────────────────────────────────────────────────
@@ -45,6 +45,11 @@ export function ChatApp({ client, initialAgent, gw, resumeConversationId }) {
     const [historyIdx, setHistoryIdx] = useState(-1);
     const [showPicker, setShowPicker] = useState(false);
     const [pickerAgents, setPickerAgents] = useState([]);
+    // Active coding session (input routes to the runner while set).
+    const [coding, setCoding] = useState(null);
+    // Pending runner x CLI pick for /code when multiple targets exist.
+    const [codeChoices, setCodeChoices] = useState(null);
+    const codingAbortRef = useRef(null);
     // Command palette matches
     const slashMatches = input.startsWith('/') && !input.includes(' ')
         ? SLASH_COMMANDS.filter(c => c.startsWith(input.slice(1).toLowerCase()))
@@ -98,6 +103,81 @@ export function ChatApp({ client, initialAgent, gw, resumeConversationId }) {
     const addMessage = useCallback((msg) => {
         setState(s => ({ ...s, messages: [...s.messages, msg] }));
     }, []);
+    // ── Coding session helpers (chat-to-runner bridge) ──────────────
+    /**
+     * Append streamed CLI output to the transcript, merging into the last
+     * coding message so a burst of chunks doesn't explode into hundreds of
+     * transcript entries. Caps a single coding message before rolling over.
+     */
+    const appendCodingOutput = useCallback((text) => {
+        if (!text)
+            return;
+        setState(s => {
+            const msgs = [...s.messages];
+            const last = msgs[msgs.length - 1];
+            if (last && last.role === 'coding' && last.text.length < 4000) {
+                msgs[msgs.length - 1] = { ...last, text: last.text + text };
+            }
+            else {
+                msgs.push({ role: 'coding', text });
+            }
+            return { ...s, messages: msgs };
+        });
+    }, []);
+    const startCoding = useCallback(async (choice, task) => {
+        setState(s => ({ ...s, loading: true, loadingLabel: `Starting ${choice.agentName} on ${choice.runnerName}` }));
+        try {
+            const session = await client.startCodingSession(choice.runnerId, {
+                agent: choice.agentId,
+                task,
+            });
+            setState(s => ({ ...s, loading: false }));
+            setCoding({
+                runnerId: choice.runnerId,
+                runnerName: choice.runnerName,
+                agent: choice.agentId,
+                sessionId: session.sessionId,
+            });
+            addMessage({
+                role: 'info',
+                text: `coding session started — ${choice.agentId}@${choice.runnerName} (cwd ${session.cwd ?? '~'})`,
+            });
+            // Background stream: coding.output chunks land in the transcript,
+            // coding.exit closes the mode. /esc aborts the stream client-side.
+            const ac = new AbortController();
+            codingAbortRef.current = ac;
+            void client.streamCodingEvents(choice.runnerId, session.sessionId, (event) => {
+                if (event.type === 'coding.output') {
+                    const chunk = event.data.data;
+                    if (chunk)
+                        appendCodingOutput(String(chunk));
+                }
+                else if (event.type === 'coding.exit') {
+                    const code = event.data.exitCode;
+                    addMessage({ role: 'info', text: `coding session exited${code != null ? ` (exit ${code})` : ''}` });
+                    codingAbortRef.current = null;
+                    setCoding(null);
+                }
+            }, ac.signal).catch((err) => {
+                if (ac.signal.aborted)
+                    return;
+                addMessage({ role: 'error', text: `coding stream lost: ${err.message}` });
+                codingAbortRef.current = null;
+                setCoding(null);
+            });
+        }
+        catch (err) {
+            setState(s => ({ ...s, loading: false }));
+            addMessage({ role: 'error', text: err.message });
+        }
+    }, [client, addMessage, appendCodingOutput]);
+    /** Detach from coding mode (abort the stream; the remote session is untouched). */
+    const leaveCodingMode = useCallback((note) => {
+        codingAbortRef.current?.abort();
+        codingAbortRef.current = null;
+        setCoding(null);
+        addMessage({ role: 'info', text: note });
+    }, [addMessage]);
     const handleSubmit = useCallback(async (value) => {
         const trimmed = value.trim();
         if (!trimmed)
@@ -110,7 +190,7 @@ export function ChatApp({ client, initialAgent, gw, resumeConversationId }) {
             const cmd = resolveSlash(raw);
             if (!cmd) {
                 addMessage({ role: 'error', text: `Unknown command: /${raw}` });
-                addMessage({ role: 'info', text: `Commands: /help /agents /clear /quit` });
+                addMessage({ role: 'info', text: `Commands: /help /agents /runners /code /clear /quit` });
                 return;
             }
             if (cmd !== raw.toLowerCase() && !Object.entries(ALIASES).some(([k, v]) => k === raw.toLowerCase() && v === cmd)) {
@@ -128,11 +208,15 @@ export function ChatApp({ client, initialAgent, gw, resumeConversationId }) {
                     setState(s => ({ ...s, messages: [] }));
                     return;
                 case 'help':
-                    addMessage({ role: 'info', text: '/agents  browse and switch agents' });
-                    addMessage({ role: 'info', text: '/tools   show available tools' });
-                    addMessage({ role: 'info', text: '/clear   clear conversation' });
-                    addMessage({ role: 'info', text: '/help    show this help' });
-                    addMessage({ role: 'info', text: '/quit    exit' });
+                    addMessage({ role: 'info', text: '/agents     browse and switch agents' });
+                    addMessage({ role: 'info', text: '/tools      show available tools' });
+                    addMessage({ role: 'info', text: '/runners    list your runners + coding CLIs' });
+                    addMessage({ role: 'info', text: '/code       run a coding task on a runner' });
+                    addMessage({ role: 'info', text: '/code-stop  stop the active coding session' });
+                    addMessage({ role: 'info', text: '/esc        leave coding mode (session keeps running)' });
+                    addMessage({ role: 'info', text: '/clear      clear conversation' });
+                    addMessage({ role: 'info', text: '/help       show this help' });
+                    addMessage({ role: 'info', text: '/quit       exit' });
                     addMessage({ role: 'info', text: 'Tab to autocomplete commands.' });
                     return;
                 case 'tools': {
@@ -174,6 +258,91 @@ export function ChatApp({ client, initialAgent, gw, resumeConversationId }) {
                     setShowPicker(true);
                     return;
                 }
+                case 'runners': {
+                    setState(s => ({ ...s, loading: true, loadingLabel: 'Loading runners' }));
+                    try {
+                        const runners = await client.listRunners();
+                        setState(s => ({ ...s, loading: false }));
+                        if (!runners.length) {
+                            addMessage({ role: 'info', text: 'No runners registered. Start one: npx @almyty/runner start' });
+                            return;
+                        }
+                        for (const r of runners) {
+                            const clis = (r.codingAgents ?? []).map(a => a.id).join(', ') || 'no coding CLIs detected';
+                            addMessage({ role: 'info', text: `${r.name} · ${r.state ?? 'unknown'} · ${clis}` });
+                        }
+                    }
+                    catch (err) {
+                        setState(s => ({ ...s, loading: false }));
+                        addMessage({ role: 'error', text: err.message });
+                    }
+                    return;
+                }
+                case 'code': {
+                    const task = args.join(' ').trim();
+                    if (!task) {
+                        addMessage({ role: 'error', text: 'Usage: /code <task>' });
+                        return;
+                    }
+                    if (coding) {
+                        addMessage({ role: 'error', text: 'A coding session is already active — /code-stop or /esc first.' });
+                        return;
+                    }
+                    setState(s => ({ ...s, loading: true, loadingLabel: 'Finding runners' }));
+                    try {
+                        const runners = await client.listRunners();
+                        setState(s => ({ ...s, loading: false }));
+                        const choices = buildCodeChoices(runners);
+                        if (!choices.length) {
+                            addMessage({ role: 'error', text: 'No online runner with a detected coding CLI. Start one: npx @almyty/runner start' });
+                            return;
+                        }
+                        if (choices.length === 1) {
+                            await startCoding(choices[0], task);
+                            return;
+                        }
+                        setCodeChoices({ choices, task });
+                    }
+                    catch (err) {
+                        setState(s => ({ ...s, loading: false }));
+                        addMessage({ role: 'error', text: err.message });
+                    }
+                    return;
+                }
+                case 'code-stop': {
+                    if (!coding) {
+                        addMessage({ role: 'info', text: 'No active coding session.' });
+                        return;
+                    }
+                    try {
+                        await client.stopCodingSession(coding.runnerId, coding.sessionId);
+                    }
+                    catch (err) {
+                        addMessage({ role: 'error', text: err.message });
+                    }
+                    leaveCodingMode('coding session stopped');
+                    return;
+                }
+                case 'esc': {
+                    if (!coding) {
+                        addMessage({ role: 'info', text: 'Not in coding mode.' });
+                        return;
+                    }
+                    leaveCodingMode(`left coding mode — session keeps running on ${coding.runnerName} (/code-stop to kill it)`);
+                    return;
+                }
+            }
+            return;
+        }
+        // Coding mode: anything that isn't a slash command routes to the
+        // session's stdin, not to the chat agent.
+        if (classifyInput(trimmed, coding !== null) === 'coding' && coding) {
+            addMessage({ role: 'user', text: trimmed });
+            try {
+                await client.sendCodingInput(coding.runnerId, coding.sessionId, trimmed);
+            }
+            catch (err) {
+                addMessage({ role: 'error', text: err.message });
             }
             return;
         }
@@ -283,7 +452,7 @@ export function ChatApp({ client, initialAgent, gw, resumeConversationId }) {
             setState(s => ({ ...s, loading: false }));
             addMessage({ role: 'error', text: err.message });
         }
-    }, [state.agent, state.conversationId, state.pendingRunId, client, addMessage, exit]);
+    }, [state.agent, state.conversationId, state.pendingRunId, client, addMessage, exit, coding, startCoding, leaveCodingMode]);
     const handlePickerSelect = useCallback((agent) => {
         setShowPicker(false);
         if (agent.id === state.agent.id)
@@ -300,13 +469,27 @@ export function ChatApp({ client, initialAgent, gw, resumeConversationId }) {
     if (showPicker) {
         return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Header, { agent: state.agent, conversationId: state.conversationId }), _jsx(AgentSelector, { agents: pickerAgents, onSelect: handlePickerSelect })] }));
     }
+    if (codeChoices) {
+        const items = codeChoices.choices.map(c => ({
+            key: `${c.runnerId}:${c.agentId}`,
+            label: c.agentName,
+            hint: `on ${c.runnerName}`,
+        }));
+        return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Header, { agent: state.agent, conversationId: state.conversationId }), _jsx(ChoiceSelector, { title: "Pick a coding CLI + runner:", choices: items, onSelect: (picked) => {
+                        const choice = codeChoices.choices.find(c => `${c.runnerId}:${c.agentId}` === picked.key);
+                        const task = codeChoices.task;
+                        setCodeChoices(null);
+                        if (choice)
+                            void startCoding(choice, task);
+                    } })] }));
+    }
     return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Header, { agent: state.agent, conversationId: state.conversationId }), _jsxs(Box, { flexDirection: "column", flexGrow: 1, paddingRight: 2, overflow: "hidden", children: [state.messages.map((msg, i) => (_jsx(MessageView, { msg: msg }, i))), state.loading && _jsx(LoadingIndicator, { label: state.loadingLabel })] }), paletteOpen && (_jsx(Box, { flexDirection: "column", paddingLeft: 2, children: slashMatches.map((cmd, i) => {
                     const active = i === paletteCursor;
                     const padded = `/${cmd}`.padEnd(10);
                     const desc = COMMAND_DESCS[cmd] ?? '';
                     const line = `${active ? '❯' : ' '} ${padded} ${desc}`;
                     return _jsx(Text, { color: active ? '#8b5cf6' : undefined, bold: active, wrap: "truncate", children: line }, cmd);
-                }) })), _jsx(Box, { children: _jsx(Text, { dimColor: true, children: '─'.repeat(Math.min(process.stdout.columns || 80, 120)) }) }), _jsxs(Box, { paddingX: 1, paddingY: 1, children: [_jsx(Text, { color: "#8b5cf6", children: "\u276F " }), _jsx(Box, { flexGrow: 1, children: _jsx(TextInput, { value: input, onChange: handleInputChange, onSubmit: (val) => {
+                }) })), coding && _jsx(CodingModeIndicator, { agent: coding.agent, runner: coding.runnerName }), _jsx(Box, { children: _jsx(Text, { dimColor: true, children: '─'.repeat(Math.min(process.stdout.columns || 80, 120)) }) }), _jsxs(Box, { paddingX: 1, paddingY: 1, children: [_jsx(Text, { color: coding ? '#22d3ee' : '#8b5cf6', children: "\u276F " }), _jsx(Box, { flexGrow: 1, children: _jsx(TextInput, { value: input, onChange: handleInputChange, onSubmit: (val) => {
                                 if (paletteOpen && slashMatches.length > 0) {
                                     const selected = `/${slashMatches[paletteCursor]}`;
                                     setInput('');
@@ -315,5 +498,5 @@ export function ChatApp({ client, initialAgent, gw, resumeConversationId }) {
                                     return;
                                 }
                                 handleSubmit(val);
-                            }, placeholder: "Type a message or / for commands" }) })] }), _jsx(Box, { paddingX: 1, children: _jsxs(Text, { dimColor: true, children: [state.agent.name, state.agent.tools?.length ? ` · ${state.agent.tools.length} tools` : '', state.conversationId ? ` · ${state.conversationId.slice(0, 8)}` : ''] }) })] }));
+                            }, placeholder: coding ? 'Type input for the coding session or / for commands' : 'Type a message or / for commands' }) })] }), _jsx(Box, { paddingX: 1, children: _jsxs(Text, { dimColor: true, children: [state.agent.name, state.agent.tools?.length ? ` · ${state.agent.tools.length} tools` : '', state.conversationId ? ` · ${state.conversationId.slice(0, 8)}` : '', coding ? ` · coding:${coding.agent}@${coding.runnerName}` : ''] }) })] }));
 }

package/dist/commands.d.ts

@@ -1,5 +1,25 @@
-export declare const SLASH_COMMANDS: readonly ["agents", "tools", "help", "clear", "quit"];
+import type { RunnerSummary } from '@almyty/client';
+export declare const SLASH_COMMANDS: readonly ["agents", "tools", "runners", "code", "code-stop", "esc", "help", "clear", "quit"];
 export declare const ALIASES: Record<string, string>;
 export declare const COMMAND_DESCS: Record<string, string>;
 export declare function resolveSlash(input: string): string | null;
 export declare function getSuggestion(partial: string): string;
+export type InputRoute = 'command' | 'coding' | 'chat';
+/**
+ * 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 declare function classifyInput(value: string, codingActive: boolean): InputRoute;
+export interface CodeChoice {
+    runnerId: string;
+    runnerName: string;
+    agentId: string;
+    agentName: string;
+}
+/**
+ * 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 declare function buildCodeChoices(runners: RunnerSummary[]): CodeChoice[];

package/dist/commands.js

@@ -1,8 +1,13 @@
 // ── Slash command resolution ────────────────────────────────────
-export const SLASH_COMMANDS = ['agents', 'tools', 'help', 'clear', 'quit'];
+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',
@@ -10,6 +15,10 @@ export const ALIASES = {
 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',
@@ -34,3 +43,37 @@ export function getSuggestion(partial) {
     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

@@ -1,17 +1,17 @@
 import React from 'react';
 import type { AgentInfo } from '@almyty/client';
 export interface Message {
-    role: 'user' | 'agent' | 'error' | 'info' | 'tool';
+    role: 'user' | 'agent' | 'error' | 'info' | 'tool' | 'coding';
     text: string;
 }
 export declare function MarkdownText({ children, prefix, prefixColor }: {
     children: string;
     prefix?: string;
     prefixColor?: string;
-}): import("react/jsx-runtime").JSX.Element;
+}): React.JSX.Element;
 export declare function InlineFormat({ text }: {
     text: string;
-}): import("react/jsx-runtime").JSX.Element;
+}): 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 }: {
@@ -20,18 +20,36 @@ export declare function MessageWindow({ messages, loading, loadingLabel, maxRows
     loadingLabel: string;
     maxRows: number;
     scrollOffset?: number;
-}): import("react/jsx-runtime").JSX.Element;
+}): React.JSX.Element;
 export declare function Header({ agent, conversationId }: {
     agent: AgentInfo;
     conversationId?: string | null;
-}): import("react/jsx-runtime").JSX.Element;
+}): React.JSX.Element;
 export declare function MessageView({ msg }: {
     msg: Message;
-}): import("react/jsx-runtime").JSX.Element | null;
+}): React.JSX.Element | null;
 export declare function LoadingIndicator({ label }: {
     label: string;
-}): import("react/jsx-runtime").JSX.Element;
+}): React.JSX.Element;
 export declare function AgentSelector({ agents, onSelect }: {
     agents: AgentInfo[];
     onSelect: (a: AgentInfo) => void;
-}): import("react/jsx-runtime").JSX.Element;
+}): 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

@@ -137,6 +137,10 @@ export function MessageView({ msg }) {
             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;
     }
@@ -157,3 +161,23 @@ export function AgentSelector({ agents, onSelect }) {
     });
     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/package.json

@@ -1,7 +1,10 @@
 {
   "name": "@almyty/chat",
-  "version": "0.2.0",
-  "description": "Interactive chat REPL with almyty agents",
+  "version": "1.2.0",
+  "publishConfig": {
+    "access": "public"
+  },
+  "description": "Chat with your almyty agents in an interactive terminal REPL \u2014 multi-turn and streaming, with tool calls and autonomous runs.",
   "type": "module",
   "main": "dist/index.js",
   "bin": {
@@ -25,9 +28,9 @@
     "cli"
   ],
   "author": "almyty",
-  "license": "BSL-1.1",
+  "license": "Apache-2.0",
   "dependencies": {
-    "@almyty/client": "^0.1.0",
+    "@almyty/client": "^1.2.0",
     "@types/react": "^19.2.14",
     "ink": "^7.0.1",
     "ink-spinner": "^5.0.0",
@@ -40,5 +43,14 @@
     "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"
   }
 }