sonex-agent 0.1.0-alpha.1

package/dist/activity.js

@@ -0,0 +1,18 @@
+import { MAX_ACTIVITY_ITEMS } from './constants.js';
+import { trimList } from './list.js';
+/**
+ * Coordinates the upsert activity operation for the CLI UI runtime.
+ *
+ * @param items Input value used by the upsert activity operation.
+ * @param item Input value used by the upsert activity operation.
+ * @returns The computed result for the surrounding CLI UI flow.
+ */
+export function upsertActivity(items, item) {
+    const index = items.findIndex((existing) => existing.id === item.id);
+    if (index === -1) {
+        return trimList([...items, item], MAX_ACTIVITY_ITEMS);
+    }
+    const next = [...items];
+    next[index] = { ...next[index], ...item };
+    return trimList(next, MAX_ACTIVITY_ITEMS);
+}

package/dist/chat-document.js

@@ -0,0 +1,40 @@
+export function chatDocumentSegments(document) {
+    const segments = [];
+    const append = (segment) => {
+        if (!segment.text)
+            return;
+        const previous = segments[segments.length - 1];
+        if (previous?.style === segment.style && previous.href === segment.href) {
+            previous.text += segment.text;
+        }
+        else {
+            segments.push({ ...segment });
+        }
+    };
+    document.blocks.forEach((block, index) => {
+        if (block.type === 'spacer') {
+            append({ text: '\n', style: 'plain' });
+            return;
+        }
+        if (block.type === 'code_block') {
+            append({ text: block.text, style: 'code' });
+        }
+        else {
+            if (block.type === 'list_item') {
+                const level = Math.max(0, Math.min(2, Math.floor(block.level ?? 0)));
+                append({ text: `${'  '.repeat(level)}${block.marker} `, style: 'list_marker' });
+            }
+            for (const span of block.spans) {
+                append({
+                    text: span.text,
+                    style: block.type === 'heading' ? 'heading' : span.style,
+                    ...(span.href ? { href: span.href } : {}),
+                });
+            }
+        }
+        if (index < document.blocks.length - 1) {
+            append({ text: '\n', style: 'plain' });
+        }
+    });
+    return segments;
+}

package/dist/chat-message.js

@@ -0,0 +1,93 @@
+import stringWidth from 'string-width';
+import { BORDER_BLUE, SPOTIFY_GREEN } from './constants.js';
+export const CHAT_USER_MARKER_COLOR = "#808791";
+export const CHAT_SYSTEM_MARKER_COLOR = "#c8a6ff";
+export const CHAT_WARNING_MARKER_COLOR = "#d4a72c";
+export const CHAT_ERROR_MARKER_COLOR = "#ef4444";
+export const CHAT_MESSAGE_TEXT_COLOR = "#ffffff";
+export function wrapChatMessageContent(content, width) {
+    const boundedWidth = Math.max(1, Math.floor(width));
+    const physicalLines = [];
+    for (const logicalLine of content.split("\n")) {
+        if (logicalLine.length === 0) {
+            physicalLines.push("");
+            continue;
+        }
+        let line = "";
+        let lineWidth = 0;
+        for (const char of Array.from(logicalLine)) {
+            const charWidth = stringWidth(char);
+            if (line.length > 0 && lineWidth + charWidth > boundedWidth) {
+                physicalLines.push(line);
+                line = "";
+                lineWidth = 0;
+            }
+            if (line.length === 0 && charWidth > boundedWidth) {
+                physicalLines.push(char);
+                continue;
+            }
+            line += char;
+            lineWidth += charWidth;
+        }
+        if (line.length > 0) {
+            physicalLines.push(line);
+        }
+    }
+    return physicalLines.length > 0 ? physicalLines : [""];
+}
+export function wrapChatMessageSegments(segments, width) {
+    const boundedWidth = Math.max(1, Math.floor(width));
+    const lines = [[]];
+    let lineWidth = 0;
+    const append = (text, style) => {
+        if (!text)
+            return;
+        const line = lines[lines.length - 1];
+        const previous = line[line.length - 1];
+        if (previous?.style === style) {
+            previous.text += text;
+        }
+        else {
+            line.push({ text, style });
+        }
+    };
+    for (const segment of segments) {
+        for (const character of Array.from(segment.text)) {
+            if (character === "\n") {
+                lines.push([]);
+                lineWidth = 0;
+                continue;
+            }
+            const characterWidth = stringWidth(character);
+            if (lineWidth > 0 && lineWidth + characterWidth > boundedWidth) {
+                lines.push([]);
+                lineWidth = 0;
+            }
+            append(character, segment.style);
+            lineWidth += characterWidth;
+        }
+    }
+    return lines.length > 0 ? lines : [[]];
+}
+export function resolveChatMarkerColor(role, theme, tone) {
+    if (role === "user")
+        return CHAT_USER_MARKER_COLOR;
+    if (tone === "error")
+        return CHAT_ERROR_MARKER_COLOR;
+    if (tone === "warning")
+        return CHAT_WARNING_MARKER_COLOR;
+    if (tone === "system")
+        return CHAT_SYSTEM_MARKER_COLOR;
+    if (theme === "spotify")
+        return SPOTIFY_GREEN;
+    return BORDER_BLUE;
+}
+export function resolveChatContentColor(role, tone) {
+    if (role === "user")
+        return CHAT_MESSAGE_TEXT_COLOR;
+    if (tone === "error")
+        return CHAT_ERROR_MARKER_COLOR;
+    if (tone === "warning")
+        return CHAT_WARNING_MARKER_COLOR;
+    return CHAT_MESSAGE_TEXT_COLOR;
+}

package/dist/chat-theme.js

@@ -0,0 +1,18 @@
+import { BORDER_BLUE, SPOTIFY_GREEN, TOOL_NAVY } from './constants.js';
+const DEFAULT_AGENT_CHAT_THEME = {
+    accent: BORDER_BLUE,
+    strongText: BORDER_BLUE,
+    highlightBackground: TOOL_NAVY,
+    codeBackground: '#252933',
+    linkText: '#9fd9ff',
+};
+const SPOTIFY_AGENT_CHAT_THEME = {
+    accent: SPOTIFY_GREEN,
+    strongText: SPOTIFY_GREEN,
+    highlightBackground: '#0b3d20',
+    codeBackground: '#252933',
+    linkText: '#73d998',
+};
+export function resolveAgentChatTheme(theme) {
+    return theme === 'spotify' ? SPOTIFY_AGENT_CHAT_THEME : DEFAULT_AGENT_CHAT_THEME;
+}

package/dist/chat-window.js

@@ -0,0 +1,104 @@
+import { MAX_CHAT_ITEMS, MIN_CHAT_VIEWPORT_ROWS } from './constants.js';
+import { wrapChatMessageContent } from './chat-message.js';
+/**
+ * Coordinates the trim list operation for the CLI UI runtime.
+ *
+ * @param items Input value used by the trim list operation.
+ * @param limit Input value used by the trim list operation.
+ * @returns The computed result for the surrounding CLI UI flow.
+ */
+export function trimList(items, limit) {
+    return items.slice(Math.max(0, items.length - limit));
+}
+/**
+ * Coordinates the clamp operation for the CLI UI runtime.
+ *
+ * @param value Input value used by the clamp operation.
+ * @param min Input value used by the clamp operation.
+ * @param max Input value used by the clamp operation.
+ * @returns The computed result for the surrounding CLI UI flow.
+ */
+export function clamp(value, min, max) {
+    return Math.min(max, Math.max(min, value));
+}
+export function appendChatTimelineItems(state, appendedItems, limit) {
+    if (appendedItems.length === 0)
+        return state;
+    const items = trimList([...state.items, ...appendedItems], limit);
+    const scrollOffset = state.scrollOffset > 0
+        ? clamp(state.scrollOffset + appendedItems.length, 0, Math.max(0, items.length - 1))
+        : 0;
+    return { items, scrollOffset };
+}
+export function chatTimelineReducer(state, action) {
+    switch (action.type) {
+        case "append":
+            return appendChatTimelineItems(state, action.items, MAX_CHAT_ITEMS);
+        case "scroll":
+            return {
+                ...state,
+                scrollOffset: clamp(state.scrollOffset + action.delta, 0, action.maxScrollOffset),
+            };
+        case "clamp":
+            return {
+                ...state,
+                scrollOffset: clamp(state.scrollOffset, 0, action.maxScrollOffset),
+            };
+        case "resetScroll":
+            return { ...state, scrollOffset: 0 };
+    }
+}
+/**
+ * Coordinates the estimate chat item rows operation for the CLI UI runtime.
+ *
+ * @param item Input value used by the estimate chat item rows operation.
+ * @returns The computed result for the surrounding CLI UI flow.
+ */
+function estimateChatItemRows(item, wrapWidth, headerVariant) {
+    if (item.type === "info_banner") {
+        return headerVariant === "compact" ? 6 : 9;
+    }
+    return wrapChatMessageContent(item.content, wrapWidth).length + 2;
+}
+export function getChatContentRows(items, wrapWidth, headerVariant = "full") {
+    return items.reduce((rows, item) => rows + estimateChatItemRows(item, wrapWidth, headerVariant), 0);
+}
+/**
+ * Coordinates the get visible chat window operation for the CLI UI runtime.
+ *
+ * @param items Input value used by the get visible chat window operation.
+ * @param viewportRows Input value used by the get visible chat window operation.
+ * @param scrollOffset Input value used by the get visible chat window operation.
+ * @returns The computed result for the surrounding CLI UI flow.
+ */
+export function getVisibleChatWindow(items, viewportRows, scrollOffset, wrapWidth, headerVariant = "full") {
+    if (items.length === 0) {
+        return { items: [], hasHiddenAbove: false, hasHiddenBelow: false, maxScrollOffset: 0 };
+    }
+    const contentRows = Math.max(MIN_CHAT_VIEWPORT_ROWS, viewportRows);
+    const totalRows = getChatContentRows(items, wrapWidth, headerVariant);
+    const maxScrollOffset = totalRows > contentRows
+        ? Math.max(0, items.length - 1)
+        : 0;
+    const boundedOffset = clamp(scrollOffset, 0, maxScrollOffset);
+    const endExclusive = Math.max(1, items.length - boundedOffset);
+    let startIndex = endExclusive;
+    let usedRows = 0;
+    while (startIndex > 0) {
+        const nextRows = estimateChatItemRows(items[startIndex - 1], wrapWidth, headerVariant);
+        if (usedRows > 0 && usedRows + nextRows > contentRows) {
+            break;
+        }
+        usedRows += nextRows;
+        startIndex -= 1;
+        if (usedRows >= contentRows) {
+            break;
+        }
+    }
+    return {
+        items: items.slice(startIndex, endExclusive),
+        hasHiddenAbove: startIndex > 0,
+        hasHiddenBelow: endExclusive < items.length,
+        maxScrollOffset,
+    };
+}

package/dist/command-panel.js

@@ -0,0 +1,45 @@
+export const HELP_PANEL_VISIBLE_COMMANDS = 8;
+/**
+ * Coordinates the visible command window operation for the CLI UI runtime.
+ *
+ * @param commands Input value used by the visible command window operation.
+ * @param selectedIndex Input value used by the visible command window operation.
+ * @param visibleLimit Input value used by the visible command window operation.
+ * @returns The computed result for the surrounding CLI UI flow.
+ */
+export function visibleCommandWindow(commands, selectedIndex, visibleLimit) {
+    if (commands.length === 0) {
+        return { items: [], boundedIndex: 0, startIndex: 0 };
+    }
+    const boundedIndex = Math.min(Math.max(selectedIndex, 0), commands.length - 1);
+    const limit = Math.min(Math.max(1, visibleLimit), commands.length);
+    const maxStart = Math.max(0, commands.length - limit);
+    const startIndex = Math.min(Math.max(0, boundedIndex - limit + 1), maxStart);
+    return {
+        items: commands.slice(startIndex, startIndex + limit),
+        boundedIndex,
+        startIndex,
+    };
+}
+export function selectedHelpPanelCommand(commands, selectedIndex) {
+    if (commands.length === 0)
+        return null;
+    const boundedIndex = Math.min(Math.max(selectedIndex, 0), commands.length - 1);
+    return commands[boundedIndex] ?? null;
+}
+/**
+ * Coordinates the help panel commands operation for the CLI UI runtime.
+ *
+ * @param commands Input value used by the help panel commands operation.
+ * @returns The computed result for the surrounding CLI UI flow.
+ */
+export function helpPanelCommands(commands) {
+    return [...commands]
+        .filter((command) => command.enabled !== false)
+        .sort((a, b) => a.name.localeCompare(b.name))
+        .map((command) => ({
+        name: command.name,
+        usage: command.usage,
+        description: command.description,
+    }));
+}

package/dist/commands.js

@@ -0,0 +1,70 @@
+import { SLASH_COMMANDS } from './constants.js';
+import { localizeSlashCommands } from './i18n.js';
+export const SPOTIFY_MODE_COMMAND_NAMES = ["bye", "extension", "exit", "info", "lang", "login", "logout", "memory", "model", "playlist", "queue", "random", "recommend", "settings", "spotify"];
+const SPOTIFY_MODE_COMMANDS = SPOTIFY_MODE_COMMAND_NAMES.map((name) => (SLASH_COMMANDS.find((command) => command.name === name))).filter((command) => Boolean(command?.enabled !== false));
+function commandSuggestionsFrom(commands, input, language) {
+    const trimmed = input.trimStart();
+    if (!trimmed.startsWith("/"))
+        return [];
+    const token = trimmed.slice(1).split(/\s+/, 1)[0]?.toLowerCase() ?? "";
+    return localizeSlashCommands(commands.filter((command) => command.enabled !== false && command.name.startsWith(token)), language);
+}
+/**
+ * Coordinates the slash command suggestions operation for the CLI UI runtime.
+ *
+ * @param input Input value used by the slash command suggestions operation.
+ * @returns The computed result for the surrounding CLI UI flow.
+ */
+export function slashCommandSuggestions(input, language = "en") {
+    return commandSuggestionsFrom(SLASH_COMMANDS, input, language);
+}
+export function spotifyModeSlashCommands(input = "/", language = "en") {
+    return commandSuggestionsFrom(SPOTIFY_MODE_COMMANDS, input, language);
+}
+/**
+ * Coordinates the slash command token operation for the CLI UI runtime.
+ *
+ * @param input Input value used by the slash command token operation.
+ * @returns The computed result for the surrounding CLI UI flow.
+ */
+export function slashCommandToken(input) {
+    const trimmed = input.trimStart();
+    if (!trimmed.startsWith("/"))
+        return "";
+    return trimmed.slice(1).split(/\s+/, 1)[0]?.toLowerCase() ?? "";
+}
+/**
+ * Coordinates the matching slash command operation for the CLI UI runtime.
+ *
+ * @param input Input value used by the matching slash command operation.
+ * @returns The computed result for the surrounding CLI UI flow.
+ */
+export function matchingSlashCommand(input) {
+    const token = slashCommandToken(input);
+    return SLASH_COMMANDS.find((command) => command.enabled !== false
+        && (command.name === token || command.aliases?.includes(token)));
+}
+/**
+ * Coordinates the has slash command arguments operation for the CLI UI runtime.
+ *
+ * @param input Input value used by the has slash command arguments operation.
+ * @returns The computed result for the surrounding CLI UI flow.
+ */
+export function hasSlashCommandArguments(input) {
+    const trimmed = input.trimStart();
+    const spaceIndex = trimmed.indexOf(" ");
+    return spaceIndex !== -1 && trimmed.slice(spaceIndex + 1).trim().length > 0;
+}
+/**
+ * Coordinates the complete slash command operation for the CLI UI runtime.
+ *
+ * @param command Input value used by the complete slash command operation.
+ * @returns The computed result for the surrounding CLI UI flow.
+ */
+export function completeSlashCommand(command) {
+    return command.needsArgument ? `/${command.name} ` : `/${command.name}`;
+}
+export function unknownSlashCommandMessage(input) {
+    const command = input.trimStart().split(/\s+/, 1)[0] || "/";
+    return `Unknown command: ${command}. Type /help to view available commands.`;
+}