sonex-agent 0.1.0-alpha.1

package/dist/playback-keymap.js

@@ -0,0 +1,59 @@
+const LOCAL_PLAYBACK_SOURCES = new Set(["local", "youtube", "online"]);
+const EXTERNAL_PLAYBACK_SOURCES = new Set(["spotify"]);
+/**
+ * Maps raw terminal input bytes to mini-player playback shortcut actions.
+ */
+export function playbackShortcutFromInput(input) {
+    if (input === " ")
+        return "togglePlayback";
+    if (input === "\x1b[19~")
+        return "volumeDown";
+    if (input === "\x1b[20~")
+        return "volumeUp";
+    if (input === "\x13")
+        return "saveToPlaylist";
+    return null;
+}
+/**
+ * Clamps a playback volume adjustment to the local player range.
+ */
+export function clampPlaybackVolume(currentVolume, delta) {
+    const current = typeof currentVolume === "number" && Number.isFinite(currentVolume)
+        ? currentVolume
+        : 100;
+    return Math.min(100, Math.max(0, current + delta));
+}
+/**
+ * Builds the existing local playback command for a parsed shortcut action.
+ */
+export function playbackCommandForShortcut(action, player) {
+    if (action === "togglePlayback") {
+        return player.is_playing === true ? "/pause" : "/resume";
+    }
+    if (action === "saveToPlaylist") {
+        return "/playlist save";
+    }
+    const delta = action === "volumeDown" ? -5 : 5;
+    return `/volume ${clampPlaybackVolume(player.volume_percent, delta)}`;
+}
+/**
+ * Returns whether the active player state belongs to local/online playback.
+ */
+export function isLocalPlaybackShortcutSource(player) {
+    const source = typeof player.source === "string" ? player.source.toLowerCase() : "";
+    const provider = typeof player.provider === "string" ? player.provider.toLowerCase() : "";
+    if (EXTERNAL_PLAYBACK_SOURCES.has(source) || EXTERNAL_PLAYBACK_SOURCES.has(provider)) {
+        return false;
+    }
+    if (!source && !provider)
+        return true;
+    return LOCAL_PLAYBACK_SOURCES.has(source) || LOCAL_PLAYBACK_SOURCES.has(provider);
+}
+/**
+ * Returns whether the active player state belongs to Spotify playback.
+ */
+export function isSpotifyPlaybackShortcutSource(player) {
+    const source = typeof player.source === "string" ? player.source.toLowerCase() : "";
+    const provider = typeof player.provider === "string" ? player.provider.toLowerCase() : "";
+    return source === "spotify" || provider === "spotify";
+}

package/dist/provider-state.js

@@ -0,0 +1,67 @@
+export const initialProviderState = {
+    spotifyMode: { enabled: false },
+    providerMode: { provider: 'normal', enabled: false },
+    spotifySetup: null,
+    authSetup: null,
+};
+export function reduceProviderState(state, action) {
+    if (action.type === 'replace')
+        return action.state;
+    if (action.type === 'clear_spotify_setup')
+        return { ...state, spotifySetup: null };
+    if (action.type === 'clear_auth_setup')
+        return { ...state, authSetup: null };
+    const event = action.event;
+    switch (event.type) {
+        case 'spotify_mode':
+            return {
+                ...state,
+                spotifyMode: {
+                    enabled: event.enabled,
+                    device_id: event.device_id,
+                    device_name: event.device_name,
+                },
+            };
+        case 'provider_mode':
+            return {
+                ...state,
+                providerMode: {
+                    provider: event.provider,
+                    enabled: event.enabled,
+                    connection_status: event.connection_status,
+                },
+            };
+        case 'spotify_setup':
+            return {
+                ...state,
+                spotifySetup: {
+                    step: event.step,
+                    title: event.title,
+                    message: event.message,
+                    prompt: event.prompt,
+                    mask: event.mask,
+                    active: event.active !== false,
+                },
+            };
+        case 'auth_setup':
+            return {
+                ...state,
+                authSetup: event.active === false && event.step === 'model'
+                    ? null
+                    : {
+                        provider: event.provider,
+                        step: event.step,
+                        title: event.title,
+                        message: event.message,
+                        prompt: event.prompt,
+                        placeholder: event.placeholder,
+                        help_text: event.help_text,
+                        mask: event.mask,
+                        active: event.active !== false,
+                        methods: event.methods,
+                        providers: event.providers,
+                        models: event.models,
+                    },
+            };
+    }
+}

package/dist/runtime-state.js

@@ -0,0 +1,91 @@
+import { upsertActivity } from './activity.js';
+import { shouldStartLaunchPreparing } from './launch-preparing.js';
+export const createInitialRuntimeState = (statusText) => ({
+    sessionId: null,
+    tokenUsage: { inputTokens: 0, outputTokens: 0 },
+    agentWorkingTurnId: null,
+    activityItems: [],
+    statusText,
+    launchPreparing: false,
+    recommendInputLocked: false,
+});
+const clearsLaunchPreparing = new Set([
+    'track_panel',
+    'memory_panel',
+    'extension_panel',
+    'player',
+    'confirm',
+    'spotify_setup',
+    'auth_setup',
+    'help_panel',
+    'bye',
+]);
+export function reduceRuntimeState(state, action) {
+    if (action.type === 'replace')
+        return action.state;
+    if (action.type === 'set_status')
+        return { ...state, statusText: action.text };
+    if (action.type === 'clear_agent_working')
+        return { ...state, agentWorkingTurnId: null };
+    const event = action.event;
+    const next = clearsLaunchPreparing.has(event.type)
+        ? { ...state, launchPreparing: false }
+        : state;
+    switch (event.type) {
+        case 'session_state':
+            return { ...next, sessionId: event.session_id };
+        case 'usage_state':
+            return {
+                ...next,
+                tokenUsage: {
+                    inputTokens: event.input_tokens,
+                    outputTokens: event.output_tokens,
+                },
+            };
+        case 'agent_working_state':
+            return {
+                ...next,
+                agentWorkingTurnId: event.active
+                    ? event.turn_id
+                    : next.agentWorkingTurnId === event.turn_id
+                        ? null
+                        : next.agentWorkingTurnId,
+            };
+        case 'activity': {
+            const launchPreparing = shouldStartLaunchPreparing(event)
+                ? true
+                : event.status === 'success' || event.status === 'error'
+                    ? false
+                    : next.launchPreparing;
+            return {
+                ...next,
+                activityItems: upsertActivity(next.activityItems, event),
+                launchPreparing,
+            };
+        }
+        case 'status':
+            return {
+                ...next,
+                statusText: event.message,
+                launchPreparing: action.rawEvent?.type === 'status'
+                    ? action.rawEvent.active !== false && action.rawEvent.message === 'Preparing playback...'
+                    : event.active !== false && event.message === 'Preparing playback...',
+            };
+        case 'input_state':
+            return {
+                ...next,
+                recommendInputLocked: event.disabled && event.reason === 'recommendation',
+            };
+        case 'track_panel':
+        case 'memory_panel':
+        case 'extension_panel':
+        case 'spotify_setup':
+        case 'auth_setup':
+        case 'help_panel':
+            return { ...next, statusText: event.title };
+        case 'bye':
+            return { ...next, statusText: event.message ?? `Session saved to ${event.path}. Bye.` };
+        default:
+            return next;
+    }
+}

package/dist/shell-state.js

@@ -0,0 +1,37 @@
+import { resolveRegionAfterPlayerEvent, toggleShellRegion } from './layout.js';
+export const initialShellState = {
+    region: 'chat',
+    playbackSessionActive: false,
+};
+export function surfaceForShellRegion(region) {
+    return region === 'chat' || region === 'memoryPanel' ? 'main' : 'alternate';
+}
+export function planShellSurfaceTransition(currentRegion, nextRegion) {
+    return {
+        changed: currentRegion !== nextRegion,
+        target: surfaceForShellRegion(nextRegion),
+    };
+}
+export function reduceShellState(state, action) {
+    if (action.type === 'replace')
+        return action.state;
+    if (action.type === 'set_region')
+        return { ...state, region: action.region };
+    if (action.type === 'player_event') {
+        const transition = resolveRegionAfterPlayerEvent({
+            currentRegion: state.region,
+            wasSessionActive: state.playbackSessionActive,
+            player: action.player,
+            spotifyModeEnabled: action.spotifyModeEnabled,
+            providerMode: action.providerMode,
+        });
+        return {
+            region: transition.region,
+            playbackSessionActive: transition.sessionActive,
+        };
+    }
+    return {
+        ...state,
+        region: toggleShellRegion(state.region, state.playbackSessionActive, action.spotifyModeEnabled, action.providerModeEnabled),
+    };
+}

package/dist/sonex-logo.js

@@ -0,0 +1,9 @@
+export const SONEX_LOGO = [
+    "███████╗ ██████╗ ███╗   ██╗███████╗██╗  ██╗",
+    "██╔════╝██╔═══██╗████╗  ██║██╔════╝╚██╗██╔╝",
+    "███████╗██║   ██║██╔██╗ ██║█████╗   ╚███╔╝ ",
+    "╚════██║██║   ██║██║╚██╗██║██╔══╝   ██╔██╗ ",
+    "███████║╚██████╔╝██║ ╚████║███████╗██╔╝ ██╗",
+    "╚══════╝ ╚═════╝ ╚═╝  ╚═══╝╚══════╝╚═╝  ╚═╝",
+];
+export const SONEX_LOGO_WIDTH = 43;

package/dist/terminal-clear.js

@@ -0,0 +1,10 @@
+const CLEAR_SCREEN_AND_HOME = '\u001B[2J\u001B[H';
+/**
+ * Coordinates the clear terminal for layout switch operation for the CLI UI runtime.
+ *
+ * @param stdout Input value used by the clear terminal for layout switch operation.
+ * @returns The computed result for the surrounding CLI UI flow.
+ */
+export function clearTerminalForLayoutSwitch(stdout) {
+    stdout.write(CLEAR_SCREEN_AND_HOME);
+}

package/dist/terminal-frame-writer.js

@@ -0,0 +1,133 @@
+export const APP_CLEAR_SCREEN = '\u001B[2J\u001B[H';
+export const INK_CLEAR_SCREEN = '\u001B[2J\u001B[3J\u001B[H';
+const SAVE_CURSOR = '\u001B7';
+const RESTORE_CURSOR = '\u001B8';
+const ERASE_LINE = '\u001B[2K';
+const TRAILING_ROW_BACKGROUND_MARKER = /\u001B\]777;sonex-fill-trailing-row=([0-9a-fA-F]{6})\u0007/;
+const TERMINAL_CONTROL_SEQUENCE = /\u001B(?:\][^\u0007]*(?:\u0007|\u001B\\)|\[[0-?]*[ -/]*[@-~]|[()][0-2A-Z]|[=>78])/g;
+const normalizeTrueColor = (color) => (/^#?([0-9a-fA-F]{6})$/.exec(color)?.[1] ?? "000000");
+export const withTrueColorBackground = (value, color) => {
+    const normalized = normalizeTrueColor(color);
+    const red = Number.parseInt(normalized.slice(0, 2), 16);
+    const green = Number.parseInt(normalized.slice(2, 4), 16);
+    const blue = Number.parseInt(normalized.slice(4, 6), 16);
+    return `\u001B[48;2;${red};${green};${blue}m${value}\u001B[49m`;
+};
+export const trailingRowBackgroundMarker = (color) => {
+    const normalized = normalizeTrueColor(color);
+    return `\u001B]777;sonex-fill-trailing-row=${normalized}\u0007`;
+};
+const fillTrailingRowBackground = (chunk, columns) => {
+    const color = TRAILING_ROW_BACKGROUND_MARKER.exec(chunk)?.[1];
+    const output = chunk.replace(TRAILING_ROW_BACKGROUND_MARKER, "");
+    const width = Math.max(0, Math.floor(columns ?? 0));
+    if (!color || width === 0 || !output.endsWith("\n"))
+        return output;
+    return `${output}${withTrueColorBackground(" ".repeat(width), color)}\r`;
+};
+const sameDimensions = (left, right) => (left?.columns === right.columns && left?.rows === right.rows);
+const changedRowsOutput = (previousRows, nextRows) => {
+    let output = "";
+    for (let index = 0; index < nextRows.length; index += 1) {
+        if (previousRows[index] === nextRows[index])
+            continue;
+        output += `\u001B[${index + 1};1H${ERASE_LINE}${nextRows[index]}`;
+    }
+    return output ? `${SAVE_CURSOR}${output}${RESTORE_CURSOR}` : "";
+};
+/**
+ * Converts Ink's repeated full-screen frames into row-level terminal updates.
+ *
+ * Ink clears the entire terminal whenever rendered output fills its height.
+ * Sonex intentionally fills the terminal so its input dock remains anchored at
+ * the bottom, which otherwise turns every cursor blink into a full repaint.
+ */
+export class IncrementalTerminalFrameWriter {
+    getDimensions;
+    previousRows = null;
+    previousDimensions = null;
+    constructor(getDimensions) {
+        this.getDimensions = getDimensions;
+    }
+    transform(chunk) {
+        if (chunk.startsWith(APP_CLEAR_SCREEN)) {
+            this.reset();
+            return chunk;
+        }
+        if (!chunk.startsWith(INK_CLEAR_SCREEN)) {
+            return chunk;
+        }
+        const frame = chunk.slice(INK_CLEAR_SCREEN.length);
+        if (!frame) {
+            this.reset();
+            return chunk;
+        }
+        const nextRows = frame.split("\n");
+        const nextDimensions = this.getDimensions();
+        const previousRows = this.previousRows;
+        const canUpdateIncrementally = (previousRows !== null
+            && previousRows.length === nextRows.length
+            && sameDimensions(this.previousDimensions, nextDimensions));
+        if (!canUpdateIncrementally) {
+            this.previousRows = nextRows;
+            this.previousDimensions = nextDimensions;
+            return chunk;
+        }
+        const output = changedRowsOutput(previousRows, nextRows);
+        this.previousRows = nextRows;
+        this.previousDimensions = nextDimensions;
+        return output || null;
+    }
+    reset() {
+        this.previousRows = null;
+        this.previousDimensions = null;
+    }
+}
+const completeSuppressedWrite = (args) => {
+    const callback = args.at(-1);
+    if (typeof callback === "function") {
+        queueMicrotask(() => callback());
+    }
+};
+export const stripTerminalControlSequences = (value) => (value.replace(TERMINAL_CONTROL_SEQUENCE, ""));
+/**
+ * Wraps stdout while preserving its width, events, and direct-write behavior.
+ *
+ * Ink treats any frame at least as tall as `stdout.rows` as a full-screen app
+ * and clears both the visible buffer and scrollback. The renderer-facing proxy
+ * intentionally hides `rows`; App receives the real stream separately for
+ * layout, resize handling, and direct alternate-screen writers.
+ */
+export const createIncrementalStdout = (stdout) => {
+    const frameWriter = new IncrementalTerminalFrameWriter(() => ({
+        columns: stdout.columns,
+        rows: stdout.rows,
+    }));
+    const writeThrough = stdout.write.bind(stdout);
+    const incrementalWrite = ((chunk, ...args) => {
+        if (typeof chunk !== "string") {
+            return writeThrough(chunk, ...args);
+        }
+        const safeChunk = stdout.isTTY === true
+            ? fillTrailingRowBackground(chunk, stdout.columns)
+            : stripTerminalControlSequences(chunk);
+        const output = frameWriter.transform(safeChunk);
+        if (output === null) {
+            completeSuppressedWrite(args);
+            return true;
+        }
+        return writeThrough(output, ...args);
+    });
+    return new Proxy(stdout, {
+        get(target, property) {
+            if (property === "write")
+                return incrementalWrite;
+            if (property === "reset")
+                return () => frameWriter.reset();
+            if (property === "rows")
+                return undefined;
+            const value = Reflect.get(target, property, target);
+            return typeof value === "function" ? value.bind(target) : value;
+        },
+    });
+};

package/dist/terminal-surface.js

@@ -0,0 +1,80 @@
+export const ALT_SCREEN_ENTER = '\u001B[?1049h\u001B[2J\u001B[H';
+export const ALT_SCREEN_CLEAR = '\u001B[2J\u001B[H';
+export const ALT_SCREEN_LEAVE = '\u001B[?1049l';
+export const MOUSE_TRACKING_DISABLE = '\u001B[?1006l\u001B[?1000l';
+export const CURSOR_SHOW = '\u001B[?25h';
+export class TerminalSurfaceController {
+    options;
+    surface = 'main';
+    rendererClear = () => undefined;
+    disposed = false;
+    constructor(options) {
+        this.options = options;
+    }
+    attachRendererClear(clear) {
+        this.rendererClear = clear;
+    }
+    prepare() {
+        if (this.options.isTTY) {
+            this.options.write(MOUSE_TRACKING_DISABLE);
+        }
+    }
+    transition(next, commit) {
+        if (this.disposed)
+            return;
+        if (!this.options.isTTY) {
+            this.surface = 'main';
+            commit('main');
+            return;
+        }
+        if (next === this.surface && next === 'main') {
+            commit('main');
+            return;
+        }
+        try {
+            this.rendererClear();
+            this.options.resetFrame();
+            if (next === 'alternate' && this.surface === 'main') {
+                this.surface = 'alternate';
+                this.options.write(ALT_SCREEN_ENTER);
+            }
+            else if (next === 'alternate') {
+                this.options.write(ALT_SCREEN_CLEAR);
+            }
+            else {
+                this.options.write(ALT_SCREEN_LEAVE);
+                this.surface = 'main';
+            }
+            commit(this.surface);
+        }
+        catch (error) {
+            this.dispose();
+            throw error;
+        }
+    }
+    dispose() {
+        if (this.disposed)
+            return;
+        this.disposed = true;
+        if (!this.options.isTTY) {
+            this.bestEffort(this.options.resetFrame);
+            this.surface = 'main';
+            return;
+        }
+        this.bestEffort(this.rendererClear);
+        this.bestEffort(this.options.resetFrame);
+        const leave = this.surface === 'alternate' ? ALT_SCREEN_LEAVE : '';
+        this.bestEffort(() => {
+            this.options.write(`${leave}${MOUSE_TRACKING_DISABLE}${CURSOR_SHOW}`);
+        });
+        this.surface = 'main';
+    }
+    bestEffort(operation) {
+        try {
+            operation();
+        }
+        catch {
+            // Terminal restoration must continue even if one cleanup step fails.
+        }
+    }
+}

package/dist/text-stream.js

@@ -0,0 +1,17 @@
+export const TEXT_STREAM_INTERVAL_MS = 16;
+export const TEXT_STREAM_TARGET_FRAMES = 60;
+export const textStreamUnits = (text) => Array.from(text);
+export const nextTextStreamOffset = (current, total) => {
+    const normalizedTotal = Math.max(0, Math.floor(total));
+    const normalizedCurrent = Math.min(normalizedTotal, Math.max(0, Math.floor(current)));
+    if (normalizedCurrent >= normalizedTotal)
+        return normalizedTotal;
+    const chunkSize = Math.max(1, Math.ceil(normalizedTotal / TEXT_STREAM_TARGET_FRAMES));
+    return Math.min(normalizedTotal, normalizedCurrent + chunkSize);
+};
+export const streamedChatMessage = (item, units, visibleUnitCount) => ({
+    ...item,
+    content: units.slice(0, Math.max(0, visibleUnitCount)).join(''),
+    segments: undefined,
+    document: undefined,
+});

package/dist/track-panel.js

@@ -0,0 +1,95 @@
+import stringWidth from 'string-width';
+const textValue = (value) => String(value ?? "").trim();
+const TRACK_PANEL_INDEX_WIDTH = 3;
+const TRACK_PANEL_ARTIST_WIDTH = 24;
+const ELLIPSIS = "...";
+const codepoints = (value) => Array.from(value);
+function fitDisplayWidthWithEllipsis(value, width) {
+    const normalized = textValue(value) || "-";
+    if (stringWidth(normalized) <= width) {
+        return normalized + " ".repeat(Math.max(0, width - stringWidth(normalized)));
+    }
+    const contentWidth = Math.max(0, width - stringWidth(ELLIPSIS));
+    let rendered = "";
+    let renderedWidth = 0;
+    for (const char of codepoints(normalized)) {
+        const charWidth = stringWidth(char);
+        if (renderedWidth + charWidth > contentWidth)
+            break;
+        rendered += char;
+        renderedWidth += charWidth;
+    }
+    const result = `${rendered}${ELLIPSIS}`;
+    return result + " ".repeat(Math.max(0, width - stringWidth(result)));
+}
+function truncateDisplayWidthWithEllipsis(value, width) {
+    const normalized = textValue(value) || "-";
+    if (width <= 0)
+        return "";
+    if (stringWidth(normalized) <= width)
+        return normalized;
+    const contentWidth = Math.max(0, width - stringWidth(ELLIPSIS));
+    let rendered = "";
+    let renderedWidth = 0;
+    for (const char of codepoints(normalized)) {
+        const charWidth = stringWidth(char);
+        if (renderedWidth + charWidth > contentWidth)
+            break;
+        rendered += char;
+        renderedWidth += charWidth;
+    }
+    return `${rendered}${ELLIPSIS}`;
+}
+function padStartDisplayWidth(value, width) {
+    const normalized = textValue(value) || "-";
+    const renderedWidth = stringWidth(normalized);
+    return " ".repeat(Math.max(0, width - renderedWidth)) + normalized;
+}
+export function formatTrackPanelIndex(track) {
+    const index = padStartDisplayWidth(track.index, TRACK_PANEL_INDEX_WIDTH);
+    return track.queued ? `✓${index}` : ` ${index}`;
+}
+export function formatTrackPanelLine(track, rowWidth) {
+    const prefix = [
+        formatTrackPanelIndex(track),
+        fitDisplayWidthWithEllipsis(track.artist, TRACK_PANEL_ARTIST_WIDTH),
+    ].join(" ");
+    const titleWidth = Math.max(0, rowWidth - stringWidth(prefix) - 1);
+    return `${prefix} ${truncateDisplayWidthWithEllipsis(track.title, titleWidth)}`;
+}
+export function trackPanelTrackKey(track) {
+    for (const field of [
+        "cache_id",
+        "uri",
+        "spotify_url",
+        "requires_resolution",
+        "youtube_url",
+        "url",
+        "stream_url",
+        "audio_path",
+        "file_path",
+        "path",
+        "id",
+    ]) {
+        const value = textValue(track[field]);
+        if (value)
+            return `${field}:${value}`;
+    }
+    const name = textValue(track.name || track.title);
+    const artist = textValue(track.artist);
+    const album = textValue(track.album);
+    const duration = Number(track.duration_ms || 0);
+    if (!name)
+        return "";
+    if (artist || album || duration || textValue(track.provider || track.source) === "local") {
+        return `text:${name.toLowerCase()}|${artist.toLowerCase()}|${album.toLowerCase()}|${duration}`;
+    }
+    return "";
+}
+export function markQueuedTracks(tracks, queuedTracks) {
+    const queuedKeys = new Set(queuedTracks.map(trackPanelTrackKey).filter(Boolean));
+    return tracks.map((track) => {
+        const key = trackPanelTrackKey(track);
+        return { ...track, queued: Boolean(key && queuedKeys.has(key)) };
+    });
+}