subrouter-cli 0.0.0-stage → 0.1.0

package/src/adapters/openai.ts

@@ -0,0 +1,227 @@
+// OpenAI Chat Completions wire <-> normalized types.
+// Arguments travel as JSON strings; tool-call deltas arrive chunked by index and are
+// merged here, never parsed mid-stream.
+
+import { RouterError } from '../client.ts';
+import type {
+  AssistantTurn,
+  ChatMessage,
+  ChatRequest,
+  StopReason,
+  StreamEvent,
+  TokenUsage,
+  ToolCall,
+} from '../types.ts';
+
+type Wire = Record<string, unknown>;
+
+/** Normalized request -> Chat Completions body. */
+export function toWireBody(req: ChatRequest): Wire {
+  const messages: Wire[] = [];
+  if (req.system) messages.push({ role: 'system', content: req.system });
+  for (const m of req.messages) {
+    if (m.role === 'assistant') {
+      const wire: Wire = { role: 'assistant', content: m.content };
+      if (m.toolCalls && m.toolCalls.length > 0) {
+        wire.tool_calls = m.toolCalls.map((c) => ({
+          id: c.id,
+          type: 'function',
+          function: { name: c.name, arguments: c.argumentsJson },
+        }));
+      }
+      // A tool_calls-only turn must not carry an empty content string.
+      if (!m.content && wire.tool_calls) delete wire.content;
+      messages.push(wire);
+    } else if (m.role === 'tool') {
+      messages.push({ role: 'tool', tool_call_id: m.toolCallId ?? '', content: m.content });
+    } else if (m.role === 'user' && m.images?.length) {
+      const content: Wire[] = m.content ? [{ type: 'text', text: m.content }] : [];
+      content.push(...m.images.map((image) => ({
+        type: 'image_url', image_url: { url: `data:${image.mediaType};base64,${image.data}` },
+      })));
+      messages.push({ role: 'user', content });
+    } else {
+      messages.push({ role: m.role, content: m.content });
+    }
+  }
+  const body: Wire = { model: req.model, messages, stream: req.stream };
+  if (req.tools && req.tools.length > 0) {
+    body.tools = req.tools.map((t) => ({
+      type: 'function',
+      function: { name: t.name, description: t.description, parameters: t.parameters },
+    }));
+  }
+  if (req.maxTokens) body.max_tokens = req.maxTokens;
+  if (req.effort && req.effort !== 'auto') body.reasoning_effort = req.effort;
+  return body;
+}
+
+/** Lenient tool-arguments parse: {} plus a flag on malformed JSON, never a throw. */
+export function parseToolArgs(raw: string): { arguments: Record<string, unknown>; invalid: boolean } {
+  try {
+    const value: unknown = JSON.parse(raw || '{}');
+    if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+      return { arguments: value as Record<string, unknown>, invalid: false };
+    }
+    return { arguments: {}, invalid: true };
+  } catch {
+    return { arguments: {}, invalid: true };
+  }
+}
+
+function parseWireToolCalls(wire: unknown): ToolCall[] {
+  if (!Array.isArray(wire)) return [];
+  const result: ToolCall[] = [];
+  for (const entry of wire) {
+    if (typeof entry !== 'object' || entry === null) continue;
+    const c = entry as Wire;
+    const fn = c.function;
+    const name = typeof fn === 'object' && fn !== null ? (fn as Wire).name : undefined;
+    if (typeof c.id !== 'string' || typeof name !== 'string') continue;
+    const rawArgs = typeof fn === 'object' && fn !== null ? ((fn as Wire).arguments as string | undefined) ?? '' : '';
+    const { arguments: parsed, invalid } = parseToolArgs(rawArgs);
+    result.push({ id: c.id, name, arguments: parsed, argumentsJson: rawArgs, argumentsInvalid: invalid });
+  }
+  return result;
+}
+
+export function mapFinishReason(finishReason: unknown): StopReason {
+  switch (finishReason) {
+    case 'stop':
+      return 'stop';
+    case 'tool_calls':
+      return 'tool_calls';
+    case 'length':
+      return 'length';
+    case 'content_filter':
+      return 'refusal';
+    default:
+      return 'unknown';
+  }
+}
+
+function parseUsage(wire: unknown): TokenUsage | undefined {
+  if (typeof wire !== 'object' || wire === null) return undefined;
+  const u = wire as Wire;
+  if (typeof u.prompt_tokens !== 'number' || typeof u.completion_tokens !== 'number') return undefined;
+  return { inputTokens: u.prompt_tokens, outputTokens: u.completion_tokens };
+}
+
+/** Non-streaming Chat Completions response -> AssistantTurn. */
+export function parseCompleteBody(json: unknown): AssistantTurn {
+  const root = json as Wire;
+  const choice = (root.choices as Wire[] | undefined)?.[0];
+  if (!choice || typeof choice !== 'object') {
+    throw new RouterError('The router returned an invalid completion response.');
+  }
+  const msg = (choice.message ?? {}) as Wire;
+  const content = typeof msg.content === 'string' ? msg.content : '';
+  const toolCalls = parseWireToolCalls(msg.tool_calls);
+  const message: ChatMessage = { role: 'assistant', content };
+  if (toolCalls.length > 0) message.toolCalls = toolCalls;
+  return {
+    message,
+    stopReason: mapFinishReason(choice.finish_reason),
+    usage: parseUsage(root.usage),
+  };
+}
+
+interface PendingToolCall {
+  index: number;
+  id: string;
+  name: string;
+  args: string;
+  started: boolean;
+}
+
+/**
+ * Streaming state machine. Feed one SSE `data:` payload per push(); get StreamEvents.
+ * Emits a single 'stop' event once finish_reason appears (verified live: the final
+ * chunk carries finish_reason + usage).
+ */
+export class OpenAiStreamParser {
+  private text = '';
+  private reasoning = '';
+  private toolCalls: PendingToolCall[] = [];
+  private stopped = false;
+
+  push(payload: string): StreamEvent[] {
+    if (this.stopped) return [];
+    let json: unknown;
+    try {
+      json = JSON.parse(payload);
+    } catch {
+      throw new RouterError('The router returned an invalid streaming response.');
+    }
+    const root = json as Wire;
+    if (root.error) {
+      const err = root.error as Wire;
+      const message = typeof err.message === 'string' ? err.message : 'The router could not complete the stream.';
+      throw new RouterError(message);
+    }
+
+    const events: StreamEvent[] = [];
+    const choice = (root.choices as Wire[] | undefined)?.[0];
+    const delta = (choice?.delta ?? {}) as Wire;
+
+    if (typeof delta.content === 'string' && delta.content) {
+      this.text += delta.content;
+      events.push({ kind: 'text', text: delta.content });
+    }
+    if (typeof delta.reasoning_content === 'string' && delta.reasoning_content) {
+      this.reasoning += delta.reasoning_content;
+      events.push({ kind: 'reasoning', text: delta.reasoning_content });
+    }
+    if (Array.isArray(delta.tool_calls)) {
+      for (const call of delta.tool_calls as Wire[]) {
+        if (typeof call !== 'object' || call === null) continue;
+        const index = typeof call.index === 'number' ? call.index : 0;
+        let entry = this.toolCalls.find((t) => t.index === index);
+        if (!entry) {
+          entry = { index, id: '', name: '', args: '', started: false };
+          this.toolCalls.push(entry);
+        }
+        if (typeof call.id === 'string' && call.id) entry.id = call.id;
+        const fn = call.function;
+        let argDelta = '';
+        if (typeof fn === 'object' && fn !== null) {
+          if (typeof (fn as Wire).name === 'string' && (fn as Wire).name) entry.name = (fn as Wire).name as string;
+          if (typeof (fn as Wire).arguments === 'string') {
+            argDelta = (fn as Wire).arguments as string;
+            entry.args += argDelta;
+          }
+        }
+        if (!entry.started) {
+          entry.started = true;
+          events.push({ kind: 'tool_call_start', index, id: entry.id, name: entry.name });
+        }
+        if (argDelta) {
+          events.push({ kind: 'tool_call_args', index, delta: argDelta });
+        }
+      }
+    }
+
+    if (typeof choice?.finish_reason === 'string' && choice.finish_reason) {
+      const usage = parseUsage(root.usage);
+      this.stopped = true;
+      events.push({ kind: 'stop', stopReason: mapFinishReason(choice.finish_reason), usage });
+    }
+    return events;
+  }
+
+  /** The assembled assistant message for this turn. */
+  assistantMessage(): ChatMessage {
+    const message: ChatMessage = { role: 'assistant', content: this.text };
+    if (this.toolCalls.length > 0) {
+      message.toolCalls = this.toolCalls.map((t) => {
+        const { arguments: parsed, invalid } = parseToolArgs(t.args);
+        return { id: t.id, name: t.name, arguments: parsed, argumentsJson: t.args, argumentsInvalid: invalid };
+      });
+    }
+    return message;
+  }
+
+  reasoningSoFar(): string {
+    return this.reasoning;
+  }
+}

package/src/approval.ts

@@ -0,0 +1,21 @@
+// Permission modes are session-local; the legacy auto_approve setting is file-only.
+export const APPROVAL_MODES = ['ask', 'files', 'auto', 'absolute'] as const;
+export type ApprovalMode = typeof APPROVAL_MODES[number];
+
+export const APPROVAL_DESCRIPTIONS: Record<ApprovalMode, string> = {
+  ask: 'Ask before file changes and terminal commands',
+  files: 'Allow project file changes; ask before terminal commands',
+  auto: 'Allow files and recognized tasks; ask before risky or unknown commands',
+  absolute: 'DANGER: entire drive and arbitrary commands without approval; warning required',
+};
+
+export const APPROVAL_LABELS: Record<ApprovalMode, string> = {
+  ask: 'ask before writes',
+  files: 'files allowed · commands ask',
+  auto: 'guarded auto',
+  absolute: 'ABSOLUTE — NO APPROVALS',
+};
+
+export function parseApprovalMode(value: string): ApprovalMode | undefined {
+  return APPROVAL_MODES.find((mode) => mode === value.toLowerCase());
+}

package/src/chatviewport.ts

@@ -0,0 +1,123 @@
+// A bounded display buffer for app-managed scrollback; the composer is not part of it.
+import { stripVTControlCharacters } from 'node:util';
+
+function cells(c: string): number {
+  if (/\p{Mark}/u.test(c)) return 0;
+  const cp = c.codePointAt(0)!;
+  return cp >= 0x1100 && (cp <= 0x115f || cp >= 0x2e80 && cp <= 0xa4cf ||
+    cp >= 0xac00 && cp <= 0xd7a3 || cp >= 0xf900 && cp <= 0xfaff ||
+    cp >= 0xfe10 && cp <= 0xfe6f || cp >= 0xff00 && cp <= 0xff60 || cp >= 0x1f300) ? 2 : 1;
+}
+
+export interface ChatPosition { line: number; length: number }
+
+export class ChatViewport {
+  private lines = [''];
+  private anchors = new Set<ChatPosition>();
+  offset = 0;
+
+  clear(): void { this.lines = ['']; this.anchors.clear(); this.offset = 0; }
+
+  position(): ChatPosition {
+    const position = { line: this.lines.length - 1, length: this.lines.at(-1)!.length };
+    this.anchors.add(position);
+    return position;
+  }
+
+  release(...positions: ChatPosition[]): void {
+    for (const position of positions) this.anchors.delete(position);
+  }
+
+  private trim(): void {
+    if (this.lines.length <= 10_000) return;
+    const removed = this.lines.length - 10_000;
+    this.lines.splice(0, removed);
+    for (const anchor of this.anchors) anchor.line = Math.max(0, anchor.line - removed);
+  }
+
+  replace(start: ChatPosition, end: ChatPosition, text: string, columns: number): void {
+    const before = this.offset ? this.rows(columns).length : 0;
+    const oldEndLine = end.line;
+    const oldEndLength = end.length;
+    const prefix = this.lines[start.line]?.slice(0, start.length) ?? '';
+    const suffix = this.lines[end.line]?.slice(end.length) ?? '';
+    const inserted = (prefix + text).split('\n');
+    const newEndLine = start.line + inserted.length - 1;
+    const newEndLength = inserted.at(-1)!.length;
+    inserted[inserted.length - 1] += suffix;
+    this.lines.splice(start.line, oldEndLine - start.line + 1, ...inserted);
+    const delta = newEndLine - oldEndLine;
+    for (const anchor of this.anchors) {
+      if (anchor === start) continue;
+      if (anchor === end) { anchor.line = newEndLine; anchor.length = newEndLength; }
+      else if (anchor.line > oldEndLine) anchor.line += delta;
+      else if (anchor.line === oldEndLine && anchor.length >= oldEndLength) {
+        anchor.line = newEndLine;
+        anchor.length = newEndLength + anchor.length - oldEndLength;
+      }
+    }
+    this.trim();
+    if (this.offset) this.offset = Math.max(0, this.offset + this.rows(columns).length - before);
+  }
+
+  remove(start: ChatPosition, end: ChatPosition): void {
+    this.replace(start, end, '', 80);
+    this.offset = 0;
+  }
+
+  append(text: string, columns: number): void {
+    const before = this.offset ? this.rows(columns).length : 0;
+    for (const part of text.split(/(\n|\r\x1b\[K)/)) {
+      if (part === '\n') this.lines.push('');
+      else if (part === '\r\x1b[K') this.lines[this.lines.length - 1] = '';
+      else this.lines[this.lines.length - 1] += part;
+    }
+    this.trim();
+    if (this.offset) this.offset = Math.max(0, this.offset + this.rows(columns).length - before);
+  }
+
+  rows(columns: number): string[] {
+    const rows: string[] = [];
+    columns = Math.max(1, columns);
+    let style = '';
+    for (const line of this.lines) {
+      let row = style, used = 0;
+      for (const token of line.match(/\x1b\[[0-?]*[ -/]*[@-~]|\x1b.|[^\x1b]/gu) ?? []) {
+        if (token.startsWith('\x1b')) {
+          if (/^\x1b\[[\d;]*m$/.test(token)) {
+            row += token;
+            style = /^\x1b\[(0)?m$/.test(token) ? '' : style + token;
+          }
+          continue;
+        }
+        if (token === '\r' || token < ' ') continue;
+        if (used + cells(token) > columns) {
+          rows.push(row + (style ? '\x1b[0m' : ''));
+          row = style;
+          used = 0;
+        }
+        row += token;
+        used += cells(token);
+      }
+      rows.push(row + (style ? '\x1b[0m' : ''));
+    }
+    return rows;
+  }
+
+  scroll(delta: number, columns: number, height: number): void {
+    this.offset = Math.max(0, Math.min(Math.max(0, this.rows(columns).length - height), this.offset + delta));
+  }
+
+  visible(columns: number, height: number): string[] {
+    const rows = this.rows(columns);
+    const end = Math.max(height, rows.length - this.offset);
+    this.offset = Math.min(this.offset, Math.max(0, rows.length - height));
+    return rows.slice(Math.max(0, end - height), end);
+  }
+
+  caret(columns: number, height: number): { row: number; column: number } {
+    const rows = this.rows(columns);
+    const last = stripVTControlCharacters(rows.at(-1) ?? '');
+    return { row: Math.min(height, rows.length), column: Math.min(columns + 1, [...last].reduce((sum, c) => sum + cells(c), 0) + 1) };
+  }
+}