@minko-ai/minko 0.0.0-stage → 0.1.0

package/src/cli/app.ts

@@ -0,0 +1,396 @@
+import * as readline from 'node:readline/promises';
+import type { Interface } from 'node:readline/promises';
+import { Painter, truncateVisible } from '../ui/ansi.ts';
+import { Spinner } from '../ui/spinner.ts';
+import { StreamRenderer } from '../ui/md.ts';
+import { printBanner, formatDuration, formatTokens } from '../ui/banner.ts';
+import type { AgentHooks, AgentOutcome } from '../agent/loop.ts';
+import { runAgent } from '../agent/loop.ts';
+import { systemPrompt } from '../agent/prompt.ts';
+import { ALL_TOOLS } from '../tools/registry.ts';
+import type { ChatMessage, Provider } from '../providers/types.ts';
+import type { Config } from '../config/store.ts';
+import type { ApprovalRequest } from '../tools/types.ts';
+import { SessionStore, titleFromMessages } from '../session/store.ts';
+import type { SessionMeta } from '../session/store.ts';
+import { friendlyError } from '../util/errors.ts';
+import { HELP_TEXT } from './argv.ts';
+
+export type AppOptions = {
+  config: Config;
+  provider: Provider;
+  providerName: string;
+  model: string;
+  cwd: string;
+  auto: boolean;
+  print: boolean;
+  prompt?: string;
+  continueSession: boolean;
+  resumeId?: string;
+  setModel: (model: string) => Provider;
+};
+
+type SessionState = {
+  meta: SessionMeta;
+  history: ChatMessage[];
+};
+
+export async function runApp(options: AppOptions): Promise<number> {
+  const store = new SessionStore();
+  const session = openSession(store, options);
+  if (!session) { return 1; }
+
+  const interactive = !options.print && Boolean(process.stdin.isTTY && process.stdout.isTTY);
+  if (!interactive) {
+    return await runOneShot(options, store, session);
+  }
+  return await runInteractive(options, store, session);
+}
+
+function openSession(store: SessionStore, options: AppOptions): SessionState | null {
+  if (options.resumeId) {
+    const record = store.load(options.resumeId);
+    if (!record) {
+      process.stderr.write('找不到会话 ' + options.resumeId + '\n');
+      return null;
+    }
+    return { meta: record.meta, history: record.messages };
+  }
+  if (options.continueSession) {
+    const meta = store.latest(options.cwd);
+    if (meta) {
+      const record = store.load(meta.id);
+      if (record) { return { meta: record.meta, history: record.messages }; }
+    }
+  }
+  const meta = store.create(options.cwd, options.model);
+  return { meta, history: [] };
+}
+
+function fullMessages(session: SessionState, options: AppOptions): ChatMessage[] {
+  return [
+    { role: 'system', content: systemPrompt({ cwd: options.cwd }) },
+    ...session.history,
+  ];
+}
+
+async function runOneShot(
+  options: AppOptions,
+  store: SessionStore,
+  session: SessionState,
+): Promise<number> {
+  const prompt = options.prompt;
+  if (!prompt || prompt.trim().length === 0) {
+    process.stderr.write('非交互模式需要给出提示词，例如：minko -p "列出当前目录"\n');
+    return 1;
+  }
+  session.history.push({ role: 'user', content: prompt });
+  session.meta.title = titleFromMessages(session.history);
+  store.save(session.meta, session.history);
+
+  const controller = new AbortController();
+  process.on('SIGINT', () => controller.abort());
+
+  const hooks: AgentHooks = {
+    onText: (text) => process.stdout.write(text),
+    onToolStart: (call) => {
+      process.stderr.write('\n· ' + call.name + ' ' + summarizeArguments(call.arguments) + '\n');
+    },
+    onToolEnd: (call, result) => {
+      process.stderr.write('  ' + (result.ok ? '✓' : '✗') + ' ' + formatDuration(result.ms) + '\n');
+    },
+    approve: async (request: ApprovalRequest) => {
+      if (options.auto) { return true; }
+      process.stderr.write('\n· 需要确认：' + request.title + ' — ' + request.detail
+        + '\n  （一次性模式下默认拒绝；加 --auto 允许）\n');
+      return false;
+    },
+  };
+
+  try {
+    const outcome = await runAgent({
+      provider: options.provider,
+      tools: ALL_TOOLS,
+      messages: fullMessages(session, options),
+      cwd: options.cwd,
+      signal: controller.signal,
+      approval: options.auto ? 'auto' : 'ask',
+      hooks,
+    });
+    process.stdout.write('\n');
+    session.history = withoutSystem(outcome.messages);
+    store.save(session.meta, session.history);
+    return 0;
+  } catch (error) {
+    process.stderr.write('\n' + friendlyError(error) + '\n');
+    return 1;
+  }
+}
+
+async function runInteractive(
+  options: AppOptions,
+  store: SessionStore,
+  session: SessionState,
+): Promise<number> {
+  const painter = new Painter();
+  let provider = options.provider;
+  let model = options.model;
+
+  printBanner(painter, {
+    model,
+    cwd: options.cwd,
+    session: session.meta.id,
+    continued: session.history.length > 0,
+  });
+
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    terminal: true,
+  });
+
+  let running: AbortController | null = null;
+  let closing = false;
+
+  const shutdown = (): void => {
+    if (closing) { return; }
+    closing = true;
+    if (running) { running.abort(); }
+    rl.close();
+  };
+
+  rl.on('SIGINT', () => {
+    if (running) { running.abort(); } else { shutdown(); }
+  });
+  process.on('SIGINT', () => {
+    if (running) { running.abort(); } else { shutdown(); }
+  });
+
+  const allowedTools = new Set<string>();
+
+  const approve = async (request: ApprovalRequest): Promise<boolean> => {
+    if (allowedTools.has(request.tool)) { return true; }
+    process.stdout.write('\n  ' + painter.warn('⚠ ') + painter.bold(request.title) + '\n');
+    const lines = request.detail.split('\n').slice(0, 8);
+    for (const line of lines) {
+      process.stdout.write('    ' + painter.dim(truncateVisible(line, 100)) + '\n');
+    }
+    let answer = '';
+    try {
+      answer = (await rl.question('  ' + painter.muted('[y] 允许一次   [a] 总是允许   [n] 拒绝') + ' › '))
+        .trim().toLowerCase();
+    } catch {
+      return false;
+    }
+    if (answer === 'a' || answer === 'always') {
+      allowedTools.add(request.tool);
+      return true;
+    }
+    return answer === 'y' || answer === 'yes' || answer === '是';
+  };
+
+  const runTurn = async (input: string): Promise<void> => {
+    session.history.push({ role: 'user', content: input });
+    session.meta.title = titleFromMessages(session.history);
+    store.save(session.meta, session.history);
+
+    process.stdout.write('\n');
+    const spinner = new Spinner(painter);
+    const renderer = new StreamRenderer(painter, (chunk) => process.stdout.write(chunk));
+    const controller = new AbortController();
+    running = controller;
+    const startedAt = Date.now();
+    let bullet = false;
+    let streamedAny = false;
+
+    const ensureBullet = (): void => {
+      spinner.stop();
+      if (!bullet) {
+        process.stdout.write(painter.primary('⏺ '));
+        bullet = true;
+      }
+      streamedAny = true;
+    };
+
+    const hooks: AgentHooks = {
+      onText: (text) => {
+        ensureBullet();
+        renderer.push(text);
+      },
+      onToolStart: (call) => {
+        spinner.stop();
+        renderer.finish();
+        bullet = false;
+        process.stdout.write('\n  ' + painter.primary('⏺ ') + painter.soft(call.name)
+          + '  ' + painter.muted(summarizeArguments(call.arguments)) + '\n');
+        spinner.start('执行中');
+      },
+      onToolEnd: (_call, result) => {
+        spinner.stop();
+        const mark = result.ok ? painter.ok('✓') : painter.error('✗');
+        process.stdout.write('    ' + mark + ' ' + painter.dimmed(formatDuration(result.ms)) + '\n');
+        if (result.output.trim().length > 0) {
+          const lines = result.output.replace(/\r\n/g, '\n').split('\n');
+          const shown = lines.slice(0, 6);
+          for (const line of shown) {
+            process.stdout.write('    ' + painter.fg('#8f7fb8', '│ ') + painter.dim(truncateVisible(line, 110)) + '\n');
+          }
+          if (lines.length > 6) {
+            process.stdout.write('    ' + painter.fg('#8f7fb8', '│ ') + painter.dimmed('… 还有 ' + (lines.length - 6) + ' 行') + '\n');
+          }
+        }
+      },
+      approve,
+    };
+
+    spinner.start('思考中');
+    try {
+      const outcome: AgentOutcome = await runAgent({
+        provider,
+        tools: ALL_TOOLS,
+        messages: fullMessages(session, options),
+        cwd: options.cwd,
+        signal: controller.signal,
+        approval: options.auto ? 'auto' : 'ask',
+        hooks,
+      });
+      spinner.stop();
+      renderer.finish();
+      if (!streamedAny) { process.stdout.write(painter.dimmed('（没有文字回复）') + '\n'); }
+      const elapsed = Date.now() - startedAt;
+      process.stdout.write('  ' + painter.dimmed('✻ ' + formatDuration(elapsed)
+        + (outcome.usage.input > 0 || outcome.usage.output > 0
+          ? ' · ' + formatTokens(outcome.usage.input) + ' 输入 / ' + formatTokens(outcome.usage.output) + ' 输出'
+          : '')) + '\n');
+      session.history = withoutSystem(outcome.messages);
+      store.save(session.meta, session.history);
+    } catch (error) {
+      spinner.stop();
+      renderer.finish();
+      if (error instanceof Error && error.name === 'AbortError') {
+        process.stdout.write('\n  ' + painter.warn('已中断') + '\n');
+      } else {
+        process.stdout.write('\n  ' + painter.error(friendlyError(error)) + '\n');
+      }
+    } finally {
+      running = null;
+      process.stdout.write('\n');
+    }
+  };
+
+  if (options.prompt && options.prompt.trim().length > 0) {
+    await runTurn(options.prompt.trim());
+  }
+
+  while (!closing) {
+    let line = '';
+    try {
+      line = await rl.question(painter.primary('› '));
+    } catch {
+      break;
+    }
+    const text = line.trim();
+    if (text.length === 0) { continue; }
+    if (text.startsWith('/')) {
+      const done = await handleCommand(text, {
+        painter, session, store, options, rl,
+        setModel: (next: string) => {
+          provider = options.setModel(next);
+          model = next;
+        },
+        currentModel: () => model,
+      });
+      if (done) { break; }
+      continue;
+    }
+    await runTurn(text);
+  }
+
+  rl.close();
+  return 0;
+}
+
+type CommandContext = {
+  painter: Painter;
+  session: SessionState;
+  store: SessionStore;
+  options: AppOptions;
+  rl: Interface;
+  setModel: (model: string) => void;
+  currentModel: () => string;
+};
+
+async function handleCommand(text: string, context: CommandContext): Promise<boolean> {
+  const { painter, session, store, options } = context;
+  const [name, ...rest] = text.slice(1).split(/\s+/);
+  const argument = rest.join(' ').trim();
+
+  switch (name) {
+    case 'exit':
+    case 'quit':
+      return true;
+    case 'help':
+      process.stdout.write('\n' + HELP_TEXT.split('\n').map((line) => '  ' + line).join('\n') + '\n\n');
+      return false;
+    case 'new': {
+      session.meta = store.create(options.cwd, options.model);
+      session.history = [];
+      process.stdout.write('  ' + painter.ok('✓ ') + painter.muted('新会话 ' + session.meta.id) + '\n');
+      return false;
+    }
+    case 'clear':
+      session.history = [];
+      store.save(session.meta, session.history);
+      process.stdout.write('  ' + painter.ok('✓ ') + painter.muted('上下文已清空') + '\n');
+      return false;
+    case 'cwd':
+      process.stdout.write('  ' + painter.muted(options.cwd) + '\n');
+      return false;
+    case 'model': {
+      if (argument.length === 0) {
+        process.stdout.write('  ' + painter.muted('当前模型：' + context.currentModel()) + '\n');
+        return false;
+      }
+      try {
+        context.setModel(argument);
+        process.stdout.write('  ' + painter.ok('✓ ') + '已切换到 ' + painter.soft(argument)
+          + painter.dimmed('（仅本次运行，持久化请用 minko config）') + '\n');
+      } catch (error) {
+        process.stdout.write('  ' + painter.error(friendlyError(error)) + '\n');
+      }
+      return false;
+    }
+    case 'sessions': {
+      const metas = store.list().slice(0, 10);
+      if (metas.length === 0) {
+        process.stdout.write('  ' + painter.muted('还没有保存的会话') + '\n');
+        return false;
+      }
+      for (const meta of metas) {
+        const current = meta.id === session.meta.id ? painter.primary('●') : painter.dimmed('○');
+        process.stdout.write('  ' + current + ' ' + painter.soft(meta.id) + ' '
+          + painter.muted(meta.title) + painter.dimmed('  ' + meta.updatedAt.slice(0, 16).replace('T', ' ')) + '\n');
+      }
+      return false;
+    }
+    default:
+      process.stdout.write('  ' + painter.muted('未知命令 /' + name + '，试试 /help') + '\n');
+      return false;
+  }
+}
+
+function withoutSystem(messages: ChatMessage[]): ChatMessage[] {
+  return messages.filter((message) => message.role !== 'system');
+}
+
+function summarizeArguments(raw: string): string {
+  if (raw.trim().length === 0) { return ''; }
+  try {
+    const args = JSON.parse(raw) as Record<string, unknown>;
+    if (typeof args.command === 'string') { return truncateVisible(args.command, 90); }
+    if (typeof args.path === 'string') { return truncateVisible(args.path, 90); }
+    return truncateVisible(raw.replace(/\s+/g, ' '), 90);
+  } catch {
+    return truncateVisible(raw.replace(/\s+/g, ' '), 90);
+  }
+}

package/src/cli/argv.ts

@@ -0,0 +1,139 @@
+export type ConfigArgs = {
+  command: 'config';
+  preset?: string;
+  apiKey?: string;
+  model?: string;
+  baseUrl?: string;
+  name?: string;
+  use?: string;
+  list: boolean;
+};
+
+export type ParsedArgs =
+  | { command: 'help' }
+  | { command: 'version' }
+  | { command: 'link' }
+  | { command: 'sessions'; json: boolean }
+  | ConfigArgs
+  | {
+    command: 'run';
+    prompt?: string;
+    print: boolean;
+    continue: boolean;
+    resume?: string;
+    auto: boolean;
+    model?: string;
+  };
+
+const BOOLEAN = new Set([
+  '-p', '--print', '-c', '--continue', '--auto',
+  '-h', '--help', '-V', '--version', '--json', '--list', '-l', '--link', '-link',
+]);
+
+const VALUED = new Set([
+  '-r', '--resume', '--model', '--base-url', '--api-key',
+  '--provider', '--preset', '--name', '--use',
+]);
+
+export function parseArgs(argv: string[]): ParsedArgs {
+  const flags = new Map<string, string | true>();
+  const positional: string[] = [];
+
+  for (let index = 0; index < argv.length; index += 1) {
+    const token = argv[index];
+    if (token === '--') {
+      positional.push(...argv.slice(index + 1));
+      break;
+    }
+    if (token.startsWith('-') && token !== '-') {
+      const equals = token.indexOf('=');
+      if (equals > 0) {
+        const key = token.slice(0, equals);
+        if (!VALUED.has(key)) { throw new Error('未知选项：' + key); }
+        flags.set(key, token.slice(equals + 1));
+        continue;
+      }
+      if (VALUED.has(token)) {
+        const value = argv[index + 1];
+        if (value === undefined) { throw new Error('选项 ' + token + ' 缺少值'); }
+        flags.set(token, value);
+        index += 1;
+        continue;
+      }
+      if (BOOLEAN.has(token)) {
+        flags.set(token, true);
+        continue;
+      }
+      throw new Error('未知选项：' + token + '（运行 minko --help 查看用法）');
+    }
+    positional.push(token);
+  }
+
+  if (flag(flags, '-h', '--help')) { return { command: 'help' }; }
+  if (flag(flags, '-V', '--version')) { return { command: 'version' }; }
+  if (flag(flags, '--link', '-link')) { return { command: 'link' }; }
+
+  const sub = positional[0];
+  if (sub === 'config') {
+    return {
+      command: 'config',
+      preset: text(flags, '--preset'),
+      apiKey: text(flags, '--api-key'),
+      model: text(flags, '--model'),
+      baseUrl: text(flags, '--base-url'),
+      name: text(flags, '--name'),
+      use: text(flags, '--use'),
+      list: Boolean(flag(flags, '--list', '-l')),
+    };
+  }
+  if (sub === 'sessions') {
+    return { command: 'sessions', json: Boolean(flag(flags, '--json')) };
+  }
+
+  const prompt = positional.length > 0 ? positional.join(' ') : undefined;
+  return {
+    command: 'run',
+    prompt,
+    print: Boolean(flag(flags, '-p', '--print')),
+    continue: Boolean(flags.has('-c') || flags.has('--continue')),
+    resume: text(flags, '-r') ?? text(flags, '--resume'),
+    auto: Boolean(flags.has('--auto')),
+    model: text(flags, '--model'),
+  };
+}
+
+function flag(flags: Map<string, string | true>, ...names: string[]): boolean {
+  return names.some((name) => flags.has(name));
+}
+
+function text(flags: Map<string, string | true>, ...names: string[]): string | undefined {
+  for (const name of names) {
+    const value = flags.get(name);
+    if (typeof value === 'string') { return value; }
+  }
+  return undefined;
+}
+
+export const HELP_TEXT = [
+  '用法：minko [选项] [提示词]',
+  '',
+  '直接运行 minko 进入交互模式；带提示词则执行一轮后退出。',
+  '',
+  '选项',
+  '  -p, --print          一次性输出，不进入交互',
+  '  -c, --continue       继续当前目录最近一次会话',
+  '  -r, --resume <id>    继续指定会话',
+  '      --model <id>     本次使用指定模型',
+  '      --auto           不再逐条确认写文件和命令（危险）',
+  '  -h, --help           显示帮助',
+  '  -V, --version        显示版本',
+  '',
+  '命令',
+  '  minko config         配置服务商与 API Key',
+  '  minko config --list  查看已配置的模型',
+  '  minko sessions       列出保存的会话',
+  '  minko -link          手机远控配对（规划中）',
+  '',
+  '会话内命令',
+  '  /help  /new  /clear  /model <id>  /sessions  /exit',
+].join('\n');