部署与演示

// src/index.ts

import { Command as Cmd } from 'commander';
import { createApp } from './app';
import chalk from 'chalk';

const program = new Cmd();

program
  .name('interview-diag')
  .description('面试诊断 Agent —— 诊断你的面试回答质量')
  .version('0.1.0');

program
  .command('start')
  .description('启动交互式诊断会话')
  .option('-m, --model <model>', '主力模型', 'claude-sonnet-4-20250514')
  .option('--stt <provider>', 'STT 引擎 (whisper|funasr)', 'whisper')
  .option('--offline', '离线模式（FunASR + 不联网）')
  .action(async (opts) => {
    const app = await createApp(opts);
    await app.repl();
  });

program
  .command('diagnose <file>')
  .description('直接诊断一个文件（非交互式）')
  .option('-f, --format <format>', '输入格式 (transcript|audio)', 'transcript')
  .option('-o, --output <path>', '报告输出路径')
  .action(async (file, opts) => {
    const app = await createApp(opts);
    await app.diagnoseFile(file, opts);
  });

program
  .command('build-kb')
  .description('构建知识库（从 learn-agent-interview 导入）')
  .option('-d, --dir <path>', '面试题目录', '../learn-agent-interview')
  .option('--db <path>', '数据库路径', './data/knowledge.db')
  .action(async (opts) => {
    const { buildKnowledgeBase } = await import('./knowledge/cli');
    await buildKnowledgeBase({
      interviewDir: opts.dir,
      dbPath: opts.db,
      openaiApiKey: process.env.OPENAI_API_KEY!,
    });
  });

program
  .command('stats')
  .description('查看知识库和历史诊断统计')
  .action(async () => {
    const app = await createApp({});
    app.printStats();
  });

program.parse();

// src/app.ts

import { QueryEngine } from './query-engine/engine';
import { createToolRegistry } from './tools';
import { createCommandParser } from './command';
import { SkillRegistry } from './skills/registry';
import { ContextManager } from './context/manager';
import { MemoryStore } from './memory/store';
import { PermissionGate } from './permission/gate';
import { SessionManager } from './session/manager';
import { CheckpointManager } from './session/checkpoint';
import { HookPipeline } from './hooks/pipeline';
import { Orchestrator } from './agent/orchestrator';
import { SubAgentRuntime } from './agent/sub-agent';
import { KnowledgeStore } from './knowledge/store';
import { KnowledgeSearch } from './knowledge/search';
import { handleInput } from './agent/loop';
import * as readline from 'readline';
import chalk from 'chalk';

export async function createApp(opts: any): Promise<App> {
  // 1. 基础设施
  const queryEngine = new QueryEngine({
    anthropicApiKey: process.env.ANTHROPIC_API_KEY!,
    openaiApiKey: process.env.OPENAI_API_KEY!,
    deepseekApiKey: process.env.DEEPSEEK_API_KEY!,
    cachePath: './data/cache.db',
    budget: { maxTotalCost: 2.0 },
  });

  // 2. 知识库
  const knowledgeStore = new KnowledgeStore('./data/knowledge.db');
  const knowledgeSearch = new KnowledgeSearch(knowledgeStore, process.env.OPENAI_API_KEY!);

  // 3. Tools & Skills
  const toolRegistry = createToolRegistry();
  const skillRegistry = new SkillRegistry();

  // 4. 治理层
  const permissionGate = new PermissionGate();
  const hooks = createDefaultHookPipeline(permissionGate, queryEngine);

  // 5. 持久化
  const memoryStore = new MemoryStore('./data/memory.db');
  const sessionManager = new SessionManager('./data/sessions.db');
  const checkpoints = new CheckpointManager(sessionManager.db, 5);

  // 6. Sub-agent
  const subAgentRuntime = new SubAgentRuntime(queryEngine, toolRegistry);
  const orchestrator = new Orchestrator(subAgentRuntime, { maxConcurrency: 3 });

  // 7. Command
  const commandParser = createCommandParser();

  return new App({
    queryEngine, knowledgeSearch, toolRegistry, skillRegistry,
    permissionGate, hooks, memoryStore, sessionManager, checkpoints,
    orchestrator, commandParser, opts,
  });
}

class App {
  private deps: AppDependencies;
  private session: Session | null = null;

  constructor(deps: AppDependencies) {
    this.deps = deps;
  }

  async repl(): Promise<void> {
    this.printBanner();

    const rl = readline.createInterface({
      input: process.stdin,
      output: process.stdout,
      prompt: chalk.cyan('> '),
    });

    rl.prompt();

    rl.on('line', async (line) => {
      const input = line.trim();
      if (!input) { rl.prompt(); return; }
      if (input === 'exit' || input === 'quit') { rl.close(); return; }

      try {
        if (!this.session) {
          this.session = this.deps.sessionManager.create(
            { type: 'transcript', content: '' },
            { model: this.deps.opts.model }
          );
        }
        await handleInput(input, this.session, this.deps);
      } catch (err) {
        console.error(chalk.red(`Error: ${err}`));
      }

      rl.prompt();
    });

    rl.on('close', () => {
      console.log(chalk.dim('\n再见！'));
      process.exit(0);
    });
  }

  async diagnoseFile(filePath: string, opts: any): Promise<void> {
    const session = this.deps.sessionManager.create(
      { type: opts.format, content: filePath },
      { model: this.deps.opts.model }
    );

    const skill = opts.format === 'audio'
      ? this.deps.skillRegistry.resolve('diagnose-audio')
      : this.deps.skillRegistry.resolve('diagnose-transcript');

    const content = await readFile(filePath, 'utf-8');
    const result = await skill.execute(
      { rawInput: content, parsedArgs: { path: filePath } },
      session.makeSkillContext(),
    );

    if (result.report) console.log(result.report);
    if (opts.output) {
      await writeFile(opts.output, result.report ?? JSON.stringify(result.result, null, 2));
      console.log(chalk.green(`\n报告已保存: ${opts.output}`));
    }
  }

  printStats(): void {
    const kbStats = this.deps.knowledgeSearch.store.getStats();
    const memStats = this.deps.memoryStore.getStats();
    const sessions = this.deps.sessionManager.list({ limit: 100 });

    console.log(chalk.bold('\n📊 系统统计\n'));
    console.log(`知识库: ${kbStats.totalEntries} 题 / ${kbStats.dimensions} 维度 / ${kbStats.withEmbedding} 有向量`);
    console.log(`记忆: ${memStats.total} 条 (${Object.entries(memStats.byType).map(([k, v]) => `${k}:${v}`).join(', ')})`);
    console.log(`会话: ${sessions.length} 次 (完成:${sessions.filter(s => s.status === 'completed').length} / 暂停:${sessions.filter(s => s.status === 'paused').length})`);
  }

  private printBanner(): void {
    console.log(chalk.bold(`
┌─────────────────────────────────────────────┐
│  面试诊断 Agent v0.1.0                       │
│  上传面试稿或录音，获得结构化诊断报告          │
│                                             │
│  /help   查看命令    /mock   模拟面试         │
│  /status 查看状态    exit    退出             │
└─────────────────────────────────────────────┘
`));
  }
}