@minko-ai/minko 0.1.0 → 0.1.1

package/src/providers/anthropic.ts

@@ -1,215 +0,0 @@
-import type { ProviderConfig } from '../config/store.ts';
-import { HttpError } from '../util/errors.ts';
-import type { ChatMessage, Provider, StreamHandlers, ToolCall, ToolSpec, TurnResult, Usage } from './types.ts';
-import { sseEvents } from './sse.ts';
-
-type Block =
-  | { type: 'text'; text: string }
-  | { type: 'tool_use'; id: string; name: string; input: unknown }
-  | { type: 'tool_result'; tool_use_id: string; content: string };
-
-type AnthropicMessage = { role: 'user' | 'assistant'; content: Block[] };
-
-export function toAnthropicMessages(messages: ChatMessage[]): {
-  system: string;
-  messages: AnthropicMessage[];
-} {
-  const systemParts: string[] = [];
-  const out: AnthropicMessage[] = [];
-  const push = (role: 'user' | 'assistant', blocks: Block[]): void => {
-    if (blocks.length === 0) { return; }
-    const last = out.length > 0 ? out[out.length - 1] : undefined;
-    if (last && last.role === role) {
-      last.content.push(...blocks);
-      return;
-    }
-    out.push({ role, content: blocks });
-  };
-
-  for (const message of messages) {
-    if (message.role === 'system') {
-      systemParts.push(message.content);
-      continue;
-    }
-    if (message.role === 'tool') {
-      push('user', [{ type: 'tool_result', tool_use_id: message.toolCallId, content: message.content }]);
-      continue;
-    }
-    if (message.role === 'assistant') {
-      const blocks: Block[] = [];
-      if (message.content.length > 0) { blocks.push({ type: 'text', text: message.content }); }
-      for (const call of message.toolCalls) {
-        blocks.push({ type: 'tool_use', id: call.id, name: call.name, input: safeParse(call.arguments) });
-      }
-      push('assistant', blocks);
-      continue;
-    }
-    push('user', [{ type: 'text', text: message.content }]);
-  }
-
-  return { system: systemParts.join('\n\n'), messages: out };
-}
-
-function safeParse(raw: string): unknown {
-  if (raw.trim().length === 0) { return {}; }
-  try {
-    return JSON.parse(raw);
-  } catch {
-    return {};
-  }
-}
-
-export class AnthropicProvider implements Provider {
-  config: ProviderConfig;
-
-  constructor(config: ProviderConfig) {
-    this.config = config;
-  }
-
-  async stream(
-    messages: ChatMessage[],
-    tools: ToolSpec[],
-    handlers: StreamHandlers,
-    signal: AbortSignal,
-  ): Promise<TurnResult> {
-    const converted = toAnthropicMessages(messages);
-    const body: Record<string, unknown> = {
-      model: this.config.model,
-      max_tokens: this.config.maxTokens && this.config.maxTokens > 0 ? this.config.maxTokens : 8192,
-      system: converted.system,
-      messages: converted.messages,
-      stream: true,
-    };
-    if (tools.length > 0) {
-      body.tools = tools.map((tool) => ({
-        name: tool.name,
-        description: tool.description,
-        input_schema: tool.parameters,
-      }));
-    }
-
-    const response = await fetch(messagesUrl(this.config.baseUrl), {
-      method: 'POST',
-      headers: {
-        'content-type': 'application/json',
-        'x-api-key': this.config.apiKey,
-        'anthropic-version': '2023-06-01',
-      },
-      body: JSON.stringify(body),
-      signal,
-    });
-    if (!response.ok) {
-      throw new HttpError(response.status, await response.text());
-    }
-    if (!response.body) {
-      throw new Error('服务端没有返回可读的流');
-    }
-
-    const textParts: string[] = [];
-    const reasoningParts: string[] = [];
-    const toolCalls: ToolCall[] = [];
-    let usage: Usage = { input: 0, output: 0 };
-    let current: { kind: 'text' | 'thinking' | 'tool'; id: string; name: string; json: string } | null = null;
-
-    for await (const event of sseEvents(response.body)) {
-      let payload: Record<string, unknown>;
-      try {
-        payload = JSON.parse(event.data) as Record<string, unknown>;
-      } catch {
-        continue;
-      }
-      switch (event.event) {
-        case 'message_start': {
-          const message = payload.message as Record<string, unknown> | undefined;
-          const rawUsage = message?.usage as Record<string, unknown> | undefined;
-          if (rawUsage) {
-            usage = { input: numberOrZero(rawUsage.input_tokens), output: numberOrZero(rawUsage.output_tokens) };
-            handlers.onUsage?.(usage);
-          }
-          break;
-        }
-        case 'content_block_start': {
-          const block = payload.content_block as Record<string, unknown> | undefined;
-          const index = typeof payload.index === 'number' ? payload.index : -1;
-          if (!block) { break; }
-          if (block.type === 'tool_use') {
-            current = {
-              kind: 'tool',
-              id: typeof block.id === 'string' ? block.id : 'tool_' + index,
-              name: typeof block.name === 'string' ? block.name : '',
-              json: '',
-            };
-          } else if (block.type === 'thinking') {
-            current = { kind: 'thinking', id: '', name: '', json: '' };
-          } else {
-            current = { kind: 'text', id: '', name: '', json: '' };
-            const initial = block.text;
-            if (typeof initial === 'string' && initial.length > 0) {
-              textParts.push(initial);
-              handlers.onText?.(initial);
-            }
-          }
-          break;
-        }
-        case 'content_block_delta': {
-          const delta = payload.delta as Record<string, unknown> | undefined;
-          if (!delta) { break; }
-          if (delta.type === 'text_delta' && typeof delta.text === 'string') {
-            textParts.push(delta.text);
-            handlers.onText?.(delta.text);
-          } else if (delta.type === 'thinking_delta' && typeof delta.thinking === 'string') {
-            reasoningParts.push(delta.thinking);
-            handlers.onReasoning?.(delta.thinking);
-          } else if (delta.type === 'input_json_delta' && typeof delta.partial_json === 'string' && current) {
-            current.json += delta.partial_json;
-          }
-          break;
-        }
-        case 'content_block_stop': {
-          if (current && current.kind === 'tool') {
-            const call: ToolCall = {
-              id: current.id,
-              name: current.name,
-              arguments: current.json.trim().length > 0 ? current.json : '{}',
-            };
-            toolCalls.push(call);
-            handlers.onToolCall?.(call);
-          }
-          current = null;
-          break;
-        }
-        case 'message_delta': {
-          const rawUsage = payload.usage as Record<string, unknown> | undefined;
-          if (rawUsage && typeof rawUsage.output_tokens === 'number') {
-            usage = { input: usage.input, output: rawUsage.output_tokens };
-            handlers.onUsage?.(usage);
-          }
-          break;
-        }
-        default:
-          break;
-      }
-    }
-
-    return {
-      text: textParts.join(''),
-      reasoning: reasoningParts.join(''),
-      toolCalls,
-      usage,
-    };
-  }
-}
-
-function messagesUrl(baseUrl: string): string {
-  const base = baseUrl.replace(/\/+$/, '');
-  if (/\/v1$/i.test(base)) { return base + '/messages'; }
-  return base + '/v1/messages';
-}
-
-function numberOrZero(value: unknown): number {
-  return typeof value === 'number' && Number.isFinite(value) ? value : 0;
-}
-
-export function createAnthropicProvider(config: ProviderConfig): Provider {
-  return new AnthropicProvider(config);
-}

package/src/providers/openai.ts

@@ -1,158 +0,0 @@
-import type { ProviderConfig } from '../config/store.ts';
-import { HttpError } from '../util/errors.ts';
-import type { ChatMessage, Provider, StreamHandlers, ToolCall, ToolSpec, TurnResult, Usage } from './types.ts';
-import { sseEvents } from './sse.ts';
-
-type OpenAiToolCallDelta = {
-  index?: number;
-  id?: string;
-  function?: { name?: string; arguments?: string };
-};
-
-export function toOpenAiMessages(messages: ChatMessage[]): unknown[] {
-  return messages.map((message) => {
-    if (message.role === 'tool') {
-      return { role: 'tool', tool_call_id: message.toolCallId, content: message.content };
-    }
-    if (message.role === 'assistant') {
-      const out: Record<string, unknown> = {
-        role: 'assistant',
-        content: message.content.length > 0 ? message.content : null,
-      };
-      if (message.toolCalls.length > 0) {
-        out.tool_calls = message.toolCalls.map((call) => ({
-          id: call.id,
-          type: 'function',
-          function: { name: call.name, arguments: call.arguments },
-        }));
-      }
-      return out;
-    }
-    return { role: message.role, content: message.content };
-  });
-}
-
-export class OpenAiProvider implements Provider {
-  config: ProviderConfig;
-
-  constructor(config: ProviderConfig) {
-    this.config = config;
-  }
-
-  async stream(
-    messages: ChatMessage[],
-    tools: ToolSpec[],
-    handlers: StreamHandlers,
-    signal: AbortSignal,
-  ): Promise<TurnResult> {
-    const body: Record<string, unknown> = {
-      model: this.config.model,
-      messages: toOpenAiMessages(messages),
-      stream: true,
-      stream_options: { include_usage: true },
-    };
-    if (this.config.maxTokens && this.config.maxTokens > 0) {
-      body.max_tokens = this.config.maxTokens;
-    }
-    if (tools.length > 0) {
-      body.tools = tools.map((tool) => ({
-        type: 'function',
-        function: { name: tool.name, description: tool.description, parameters: tool.parameters },
-      }));
-      body.tool_choice = 'auto';
-    }
-
-    const response = await fetch(joinUrl(this.config.baseUrl, 'chat/completions'), {
-      method: 'POST',
-      headers: {
-        'content-type': 'application/json',
-        authorization: 'Bearer ' + this.config.apiKey,
-      },
-      body: JSON.stringify(body),
-      signal,
-    });
-    if (!response.ok) {
-      throw new HttpError(response.status, await response.text());
-    }
-    if (!response.body) {
-      throw new Error('服务端没有返回可读的流');
-    }
-
-    const textParts: string[] = [];
-    const reasoningParts: string[] = [];
-    const calls = new Map<number, { id: string; name: string; args: string }>();
-    let usage: Usage = { input: 0, output: 0 };
-
-    for await (const event of sseEvents(response.body)) {
-      if (event.data === '[DONE]') { break; }
-      let payload: Record<string, unknown>;
-      try {
-        payload = JSON.parse(event.data) as Record<string, unknown>;
-      } catch {
-        continue;
-      }
-      const rawUsage = payload.usage as Record<string, unknown> | undefined;
-      if (rawUsage) {
-        usage = {
-          input: numberOrZero(rawUsage.prompt_tokens),
-          output: numberOrZero(rawUsage.completion_tokens),
-        };
-        handlers.onUsage?.(usage);
-      }
-      const choices = payload.choices as Array<Record<string, unknown>> | undefined;
-      const choice = choices && choices.length > 0 ? choices[0] : undefined;
-      if (!choice) { continue; }
-      const delta = (choice.delta ?? {}) as Record<string, unknown>;
-
-      const content = delta.content;
-      if (typeof content === 'string' && content.length > 0) {
-        textParts.push(content);
-        handlers.onText?.(content);
-      }
-      const reasoning = delta.reasoning_content;
-      if (typeof reasoning === 'string' && reasoning.length > 0) {
-        reasoningParts.push(reasoning);
-        handlers.onReasoning?.(reasoning);
-      }
-      const toolDeltas = delta.tool_calls;
-      if (Array.isArray(toolDeltas)) {
-        for (const raw of toolDeltas as OpenAiToolCallDelta[]) {
-          const index = typeof raw.index === 'number' ? raw.index : 0;
-          const entry = calls.get(index) ?? { id: '', name: '', args: '' };
-          if (typeof raw.id === 'string' && raw.id.length > 0) { entry.id = raw.id; }
-          if (raw.function) {
-            if (typeof raw.function.name === 'string') { entry.name += raw.function.name; }
-            if (typeof raw.function.arguments === 'string') { entry.args += raw.function.arguments; }
-          }
-          calls.set(index, entry);
-        }
-      }
-    }
-
-    const toolCalls: ToolCall[] = [...calls.entries()]
-      .sort((a, b) => a[0] - b[0])
-      .flatMap(([index, entry]) => entry.name.length === 0
-        ? []
-        : [{ id: entry.id || 'call_' + index, name: entry.name, arguments: entry.args || '{}' }]);
-
-    return {
-      text: textParts.join(''),
-      reasoning: reasoningParts.join(''),
-      toolCalls,
-      usage,
-    };
-  }
-}
-
-function numberOrZero(value: unknown): number {
-  return typeof value === 'number' && Number.isFinite(value) ? value : 0;
-}
-
-export function joinUrl(baseUrl: string, suffix: string): string {
-  const base = baseUrl.replace(/\/+$/, '');
-  return base + '/' + suffix.replace(/^\/+/, '');
-}
-
-export function createOpenAiProvider(config: ProviderConfig): Provider {
-  return new OpenAiProvider(config);
-}

package/src/providers/sse.ts

@@ -1,57 +0,0 @@
-export type SseEvent = { event: string; data: string };
-
-/**
- * Parses a Server-Sent Events body. Handles CRLF, split chunks and comments.
- */
-export async function* sseEvents(body: ReadableStream<Uint8Array>): AsyncGenerator<SseEvent> {
-  const reader = body.getReader();
-  const decoder = new TextDecoder();
-  let buffer = '';
-  let event = '';
-  let data: string[] = [];
-
-  const flush = (): SseEvent | null => {
-    if (data.length === 0) {
-      event = '';
-      return null;
-    }
-    const payload: SseEvent = { event: event || 'message', data: data.join('\n') };
-    event = '';
-    data = [];
-    return payload;
-  };
-
-  try {
-    for (;;) {
-      const { done, value } = await reader.read();
-      if (done) { break; }
-      buffer += decoder.decode(value, { stream: true });
-      let index = buffer.indexOf('\n');
-      while (index >= 0) {
-        let line = buffer.slice(0, index);
-        buffer = buffer.slice(index + 1);
-        if (line.endsWith('\r')) { line = line.slice(0, -1); }
-        if (line.length === 0) {
-          const parsed = flush();
-          if (parsed) { yield parsed; }
-        } else if (line.startsWith(':')) {
-          // heartbeat / comment
-        } else if (line.startsWith('data:')) {
-          data.push(line.slice(5).replace(/^ /, ''));
-        } else if (line.startsWith('event:')) {
-          event = line.slice(6).trim();
-        }
-        index = buffer.indexOf('\n');
-      }
-    }
-    buffer += decoder.decode();
-    if (buffer.trim().length > 0) {
-      const line = buffer.replace(/\r$/, '');
-      if (line.startsWith('data:')) { data.push(line.slice(5).replace(/^ /, '')); }
-    }
-    const tail = flush();
-    if (tail) { yield tail; }
-  } finally {
-    reader.releaseLock();
-  }
-}

package/src/providers/types.ts

@@ -1,59 +0,0 @@
-export type ToolCall = {
-  id: string;
-  name: string;
-  /** Raw JSON string exactly as the model produced it. */
-  arguments: string;
-};
-
-export type ChatMessage =
-  | { role: 'system'; content: string }
-  | { role: 'user'; content: string }
-  | { role: 'assistant'; content: string; toolCalls: ToolCall[] }
-  | { role: 'tool'; toolCallId: string; name: string; content: string };
-
-export type JsonSchema = {
-  type: 'object';
-  properties: Record<string, unknown>;
-  required?: string[];
-  additionalProperties?: boolean;
-};
-
-export type ToolSpec = {
-  name: string;
-  description: string;
-  parameters: JsonSchema;
-};
-
-export type Usage = { input: number; output: number };
-
-export type StreamHandlers = {
-  onText?: (text: string) => void;
-  onReasoning?: (text: string) => void;
-  onToolCall?: (call: ToolCall) => void;
-  onUsage?: (usage: Usage) => void;
-};
-
-export type TurnResult = {
-  text: string;
-  reasoning: string;
-  toolCalls: ToolCall[];
-  usage: Usage;
-};
-
-export interface Provider {
-  stream(
-    messages: ChatMessage[],
-    tools: ToolSpec[],
-    handlers: StreamHandlers,
-    signal: AbortSignal,
-  ): Promise<TurnResult>;
-}
-
-export function parseToolArguments(raw: string): Record<string, unknown> {
-  if (raw.trim().length === 0) { return {}; }
-  const parsed: unknown = JSON.parse(raw);
-  if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) {
-    throw new Error('工具参数必须是 JSON 对象');
-  }
-  return parsed as Record<string, unknown>;
-}

package/src/session/store.ts

@@ -1,125 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import { sessionsDir } from '../config/paths.ts';
-import type { ChatMessage } from '../providers/types.ts';
-
-export type SessionMeta = {
-  id: string;
-  title: string;
-  cwd: string;
-  model: string;
-  createdAt: string;
-  updatedAt: string;
-};
-
-export type SessionRecord = {
-  meta: SessionMeta;
-  messages: ChatMessage[];
-};
-
-/** Sessions live in ~/.minko/sessions/<id>.jsonl: one meta line, then messages. */
-export class SessionStore {
-  dir: string;
-
-  constructor(dir: string = sessionsDir()) {
-    this.dir = dir;
-  }
-
-  fileFor(id: string): string {
-    if (!/^[A-Za-z0-9._-]+$/.test(id)) { throw new Error('非法的会话 id'); }
-    return path.join(this.dir, id + '.jsonl');
-  }
-
-  create(cwd: string, model: string, id?: string): SessionMeta {
-    const now = new Date().toISOString();
-    const meta: SessionMeta = {
-      id: id ?? newSessionId(),
-      title: '新会话',
-      cwd,
-      model,
-      createdAt: now,
-      updatedAt: now,
-    };
-    this.write(meta, []);
-    return meta;
-  }
-
-  save(meta: SessionMeta, messages: ChatMessage[]): void {
-    this.write({ ...meta, updatedAt: new Date().toISOString() }, messages);
-  }
-
-  load(id: string): SessionRecord | null {
-    const file = this.fileFor(id);
-    if (!fs.existsSync(file)) { return null; }
-    const lines = fs.readFileSync(file, 'utf8').split('\n');
-    let meta: SessionMeta | null = null;
-    const messages: ChatMessage[] = [];
-    for (const line of lines) {
-      if (line.trim().length === 0) { continue; }
-      let record: Record<string, unknown>;
-      try {
-        record = JSON.parse(line) as Record<string, unknown>;
-      } catch {
-        continue;
-      }
-      if (record.type === 'meta' && record.meta) {
-        meta = record.meta as SessionMeta;
-      } else if (record.type === 'message' && record.message) {
-        messages.push(record.message as ChatMessage);
-      }
-    }
-    if (!meta) { return null; }
-    return { meta, messages };
-  }
-
-  list(): SessionMeta[] {
-    if (!fs.existsSync(this.dir)) { return []; }
-    const metas: SessionMeta[] = [];
-    for (const name of fs.readdirSync(this.dir)) {
-      if (!name.endsWith('.jsonl')) { continue; }
-      const record = this.load(name.slice(0, -6));
-      if (record) { metas.push(record.meta); }
-    }
-    metas.sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
-    return metas;
-  }
-
-  latest(cwd?: string): SessionMeta | null {
-    const candidates = this.list();
-    if (cwd === undefined) { return candidates.length > 0 ? candidates[0] : null; }
-    const resolved = path.resolve(cwd);
-    return candidates.find((meta) => path.resolve(meta.cwd) === resolved) ?? null;
-  }
-
-  delete(id: string): boolean {
-    const file = this.fileFor(id);
-    if (!fs.existsSync(file)) { return false; }
-    fs.unlinkSync(file);
-    return true;
-  }
-
-  private write(meta: SessionMeta, messages: ChatMessage[]): void {
-    fs.mkdirSync(this.dir, { recursive: true });
-    const lines = [JSON.stringify({ type: 'meta', meta })];
-    for (const message of messages) {
-      lines.push(JSON.stringify({ type: 'message', message }));
-    }
-    fs.writeFileSync(this.fileFor(meta.id), lines.join('\n') + '\n', 'utf8');
-  }
-}
-
-export function newSessionId(now: Date = new Date()): string {
-  const pad = (value: number, width: number = 2): string => String(value).padStart(width, '0');
-  const stamp = String(now.getFullYear())
-    + pad(now.getMonth() + 1) + pad(now.getDate()) + '-'
-    + pad(now.getHours()) + pad(now.getMinutes()) + pad(now.getSeconds());
-  const random = Math.random().toString(36).slice(2, 6);
-  return stamp + '-' + random;
-}
-
-export function titleFromMessages(messages: ChatMessage[]): string {
-  const first = messages.find((message) => message.role === 'user');
-  if (!first || first.role !== 'user') { return '新会话'; }
-  const line = first.content.replace(/\s+/g, ' ').trim();
-  return line.length > 40 ? line.slice(0, 40) + '…' : (line || '新会话');
-}

package/src/theme.ts

@@ -1,41 +0,0 @@
-/** Minko keeps one colour family everywhere: violet. */
-export type Palette = {
-  primary: string;
-  deep: string;
-  soft: string;
-  accent: string;
-  text: string;
-  muted: string;
-  dim: string;
-  ok: string;
-  warn: string;
-  error: string;
-  border: string;
-  panel: string;
-};
-
-export const PURPLE: Palette = {
-  primary: '#a78bfa',
-  deep: '#7c3aed',
-  soft: '#c4b5fd',
-  accent: '#d8b4fe',
-  text: '#ece9f5',
-  muted: '#9a94ab',
-  dim: '#6b6580',
-  ok: '#4ade80',
-  warn: '#fbbf24',
-  error: '#f87171',
-  border: '#4c3a7a',
-  panel: '#1b1726',
-};
-
-/** Colour is on when writing to a terminal, off for pipes and NO_COLOR. */
-export function colorEnabled(env: Record<string, string | undefined> = process.env,
-  isTTY: boolean = Boolean(process.stdout.isTTY)): boolean {
-  const noColor = env.NO_COLOR;
-  if (noColor !== undefined && noColor !== '') { return false; }
-  const force = env.FORCE_COLOR;
-  if (force !== undefined && force !== '') { return force !== '0'; }
-  if (env.TERM === 'dumb') { return false; }
-  return isTTY;
-}