skyloom 1.4.0

package/src/agents/snow.ts

@@ -0,0 +1,239 @@
+/**
+ * 雪 (Snow) — 架构规划型全能 Agent.
+ * A general-purpose agent specializing in architecture and planning.
+ * Also handles task decomposition and orchestration.
+ */
+
+import { BaseAgent, Task } from '../core/agent';
+
+// Valid agents for task assignment (fair is independent, not part of orchestration)
+const VALID_AGENTS = new Set(['fog', 'rain', 'frost', 'snow', 'dew']);
+
+export class SnowAgent extends BaseAgent {
+  name = 'snow';
+  displayName = '雪';
+  emoji = '❉';
+  specialty = '架构规划';
+  skillNames = ['task_planner', 'arch_designer', 'workflow_designer', 'self_evolve'];
+
+  systemPrompt = `你是 Skyloom 的「雪」。
+
+你是全能 agent —— 代码、写作、审查、部署、规划、研究,你都能独立交付。
+你的特质是「全局视野」:先看清结构、依赖、顺序、风险,再动手。
+混乱的需求经你一拆,就变成清晰的步骤树。这是你看世界的方式,不仅是你做编排时才用。
+
+## 协作
+
+90% 的事自己做完。只有任务跨 5+ 领域、上下文塞不下、或需要多轮独立审查时,才调其他 agent。
+调用时给足上下文,拿到结果整合成完整答复,用户不需要感知协作过程。
+
+## 风格
+
+像雪一样静默但覆盖一切 —— 结构清晰,考虑周全。
+- 大任务先给整体框架,再深入
+- 标注依赖、风险、预计工作量
+- 规划:框架先于理由
+- 执行:按优先级推进,完成后汇总
+- 让人感觉「一切都在掌控之中」`;
+
+  systemPromptEn = `You are "Snow" of Skyloom.
+
+A general-purpose agent — code, writing, review, ops, planning, research — you ship anything alone.
+Your nature: see the whole. Structure, dependencies, sequence, risk — all before the first move.
+Messy requirements come out as clear step trees. That's how you see, not just how you orchestrate.
+
+## Collaboration
+Do 90% alone. Delegate only when 5+ domains, context overflow, or multi-round review is needed.
+Pass full context; synthesize the result yourself.
+
+## Style
+Like snow — silent but all-covering. Clear structure, thorough consideration.
+- Big work: framework first, then detail
+- Note dependencies, risks, effort estimates
+- Planning: structure before justification
+- Execution: prioritize, deliver, summarize
+- Leaves the user feeling "this is under control"`;
+
+  /**
+   * Decompose a goal into tasks and dispatch to agents.
+   */
+  async orchestrate(goal: string): Promise<Task[]> {
+    const prompt = `请将以下目标分解为子任务，并分配给合适的 Agent。
+
+目标: ${goal}
+
+请严格按照以下 JSON Schema 输出，不要包含其他内容：
+{"goal": "目标描述", "steps": [
+  {"id": "1", "description": "任务描述", "agent": "fog"},
+  {"id": "2", "description": "后续任务", "agent": "rain", "depends_on": ["1"]}
+]}
+
+可用 Agent: fog(调研/搜索), rain(代码生成/写作), frost(审查/安全), dew(部署/运维)
+注意:fair 是独立的情感陪伴 agent,**不参与任何任务编排**,绝不要分配给她。
+注意：如果任务有先后依赖关系，必须用 depends_on 字段标出。
+不要使用工具，直接输出 JSON 即可。`;
+
+    this.memory.addMessage('user', prompt);
+    const response = await this.llmLoop();
+    this.memory.addMessage('assistant', response.content);
+
+    // Try schema-validated parsing first
+    try {
+      const { parseTaskPlan } = require('../core/schemas');
+      const parsed = parseTaskPlan(response.content);
+      if (parsed && parsed.steps && parsed.steps.length > 0) {
+        return this.schemaToTasks(parsed, goal);
+      }
+    } catch { /* fallthrough */ }
+
+    // Fallback to heuristic parsing
+    return this.parseTaskPlan(response.content, goal);
+  }
+
+  /**
+   * Produce additional tasks that close the gap reported by the judge.
+   */
+  async replanForMissing(
+    goal: string,
+    priorResults: any[],
+    missing: string,
+    existingIds?: Set<string>
+  ): Promise<Task[]> {
+    const usedIds = existingIds || new Set<string>();
+    const priorLines = priorResults.map(r => {
+      const status = r.success ? '成功' : '失败';
+      return `- task ${r.id} (${r.agent}, ${status}): ${(r.content || '').slice(0, 200)}`;
+    });
+    const priorText = priorLines.length > 0 ? priorLines.join('\n') : '(none yet)';
+
+    // Identify failing agents
+    const failingAgents = new Set(
+      priorResults
+        .filter(r => !r.success || !r.content || r.content.trim().length < 16)
+        .map(r => r.agent)
+        .filter(Boolean)
+    );
+    const failingHint = failingAgents.size > 0
+      ? `\n\n## 已证明无效的 agent\n${[...failingAgents].sort().join(', ')} 已在上一轮返回占位/无交付物。\n**禁止把同类任务再交给以上 agent**。`
+      : '';
+
+    const prompt = `之前的子任务执行后，验收员发现还有缺口。请仅针对**缺失的部分**追加新的子任务。
+
+## 原目标
+${goal}
+
+## 已执行子任务
+${priorText}
+
+## 缺口（验收员报告）
+${missing}
+
+## 已使用的 task id（必须避开）
+${usedIds.size > 0 ? [...usedIds].sort().join(', ') : '(none)'}
+${failingHint}
+
+请输出新任务的 JSON 计划：
+{"steps": [{"id": "新id", "agent": "fog|rain|frost|dew", "description": "具体任务", "depends_on": ["可选已完成任务id"]}]}
+
+约束：
+- 只输出新增任务，不要重复已完成的；id 必须避开上面的列表
+- 控制在 2 个新任务以内（精简优先）
+- 只输出 JSON，无其他文本`;
+
+    this.memory.addMessage('user', prompt);
+    const response = await this.llmLoop();
+    this.memory.addMessage('assistant', response.content);
+
+    let newTasks: Task[];
+    try {
+      const { parseTaskPlan } = require('../core/schemas');
+      const parsed = parseTaskPlan(response.content);
+      if (parsed && parsed.steps) {
+        newTasks = this.schemaToTasks(parsed, goal);
+      } else {
+        newTasks = this.parseTaskPlan(response.content, goal);
+      }
+    } catch {
+      newTasks = this.parseTaskPlan(response.content, goal);
+    }
+
+    // Deduplicate IDs
+    const deduped: Task[] = [];
+    for (const t of newTasks) {
+      if (usedIds.has(t.id)) {
+        t.id = `r${usedIds.size + deduped.length + 1}_${t.id}`;
+      }
+      deduped.push(t);
+      usedIds.add(t.id);
+    }
+    return deduped;
+  }
+
+  private schemaToTasks(plan: any, goal: string): Task[] {
+    const tasks: Task[] = [];
+    for (const step of plan.steps || []) {
+      const sid = String(step.id);
+      const depends: string[] = step.depends_on || [];
+      const agent = VALID_AGENTS.has(step.agent) ? step.agent : 'rain';
+      tasks.push(new Task({
+        id: sid,
+        description: step.description,
+        assignedTo: agent,
+        parentId: depends.length > 0 ? depends[0] : null,
+        dependsOn: depends,
+        metadata: { goal, priority: step.priority || 'medium' },
+      }));
+    }
+    return tasks;
+  }
+
+  private parseTaskPlan(content: string, goal: string): Task[] {
+    // Try to extract JSON from markdown code blocks
+    const jsonBlockPatterns = [
+      /```json\s*\n(.*?)\n```/s,
+      /```\s*\n(\{.*?\})\n```/s,
+    ];
+
+    for (const pattern of jsonBlockPatterns) {
+      const match = content.match(pattern);
+      if (match) {
+        try {
+          const plan = JSON.parse(match[1].trim());
+          const tasks = this.planToTasks(plan, goal);
+          if (tasks.length > 0) return tasks;
+        } catch { /* continue */ }
+      }
+    }
+
+    // Try to find raw JSON in response
+    try {
+      const start = content.indexOf('{');
+      const end = content.lastIndexOf('}') + 1;
+      if (start >= 0 && end > start) {
+        const plan = JSON.parse(content.slice(start, end));
+        const tasks = this.planToTasks(plan, goal);
+        if (tasks.length > 0) return tasks;
+      }
+    } catch { /* continue */ }
+
+    // Fallback: single task for rain
+    return [new Task({ id: '1', description: goal, assignedTo: 'rain', metadata: { goal } })];
+  }
+
+  private planToTasks(plan: Record<string, any>, goal: string): Task[] {
+    const tasks: Task[] = [];
+    for (const step of (plan.steps || []) as any[]) {
+      const agent = VALID_AGENTS.has(step.agent) ? step.agent : 'rain';
+      const depends: string[] = Array.isArray(step.depends_on) ? step.depends_on : [];
+      tasks.push(new Task({
+        id: String(step.id || tasks.length + 1),
+        description: step.description || '',
+        assignedTo: agent,
+        parentId: depends.length > 0 ? depends[0] : null,
+        dependsOn: depends,
+        metadata: { goal, priority: step.priority || 'medium' },
+      }));
+    }
+    return tasks;
+  }
+}

package/src/cli/main.ts

@@ -0,0 +1,405 @@
+#!/usr/bin/env node
+
+/**
+ * CLI interface for Skyloom — terminal agent product.
+ * Uses Commander.js for command routing.
+ */
+
+import { Command } from 'commander';
+import * as fs from 'fs';
+import * as readline from 'readline';
+import chalk from 'chalk';
+import { createSystemContext, orchestrateTask } from '../core/factory';
+import { loadConfig, USER_CONFIG_DIR } from '../core/config';
+import { classify } from '../core/router';
+import { InteractiveMode, ModeController } from './mode';
+
+const MODE = new ModeController();
+const VERSION = '1.4.0';
+
+const program = new Command();
+
+program
+  .name('sky')
+  .description('Skyloom CLI — multi-agent orchestration framework')
+  .version(VERSION);
+
+// ── Chat command ──
+
+program
+  .command('chat')
+  .description('Start interactive chat with an agent')
+  .argument('[agent]', 'Agent name (fog, rain, frost, snow, dew, fair)', 'fog')
+  .option('-m, --model <model>', 'Model to use')
+  .action(async (agentName: string, options: { model?: string }) => {
+    try {
+      await interactiveChat(agentName, options.model);
+    } catch (e) {
+      console.error(chalk.red(`Error: ${e}`));
+      process.exit(1);
+    }
+  });
+
+// ── Task command ──
+
+program
+  .command('task')
+  .description('Execute a multi-agent orchestration task')
+  .argument('[goal]', 'Task goal description')
+  .option('-r, --resume', 'Resume from checkpoint')
+  .action(async (goal?: string, options?: { resume?: boolean }) => {
+    if (!goal) {
+      console.log(chalk.yellow('Please provide a task goal. Usage: sky task "<goal>"'));
+      return;
+    }
+    try {
+      await runTask(goal, options?.resume);
+    } catch (e) {
+      console.error(chalk.red(`Error: ${e}`));
+    }
+  });
+
+// ── Web command ──
+
+program
+  .command('web')
+  .description('Start web server')
+  .option('-p, --port <port>', 'Port to listen on', '3000')
+  .action(async (options: { port?: string }) => {
+    try {
+      // Dynamic import to avoid loading express when not needed
+      const { startWebServer } = await import('../web/server');
+      const port = parseInt(options.port || '3000', 10);
+      await startWebServer(port);
+    } catch (e) {
+      console.error(chalk.red(`Web server error: ${e}`));
+    }
+  });
+
+// ── MCP command ──
+
+program
+  .command('mcp')
+  .description('Start MCP server (stdio JSON-RPC for Claude Desktop etc.)')
+  .action(async () => {
+    try {
+      console.error(chalk.cyan('Starting MCP server on stdio...'));
+      const { startMCPServer } = await import('../core/mcp_server');
+      await startMCPServer();
+    } catch (e) {
+      console.error(chalk.red(`MCP server error: ${e}`));
+      process.exit(1);
+    }
+  });
+
+// ── Config command ──
+
+program
+  .command('config')
+  .description('Show current configuration')
+  .action(() => {
+    const config = loadConfig();
+    console.log(chalk.bold('\nSkyloom Configuration'));
+    console.log(chalk.dim('─'.repeat(40)));
+    console.log(chalk.cyan('Config dir:'), USER_CONFIG_DIR);
+    console.log(chalk.cyan('Agents:'));
+    for (const [name, cfg] of Object.entries(config.agents || {})) {
+      console.log(`  ${chalk.bold(name)}: ${cfg.model || 'default'}`);
+    }
+  });
+
+// ── Init / Setup command ──
+
+program
+  .command('init')
+  .description('Initialize Skyloom configuration')
+  .action(() => {
+    const configDir = USER_CONFIG_DIR;
+    if (!fs.existsSync(configDir)) {
+      fs.mkdirSync(configDir, { recursive: true });
+    }
+    console.log(chalk.green(`✓ Initialized config at ${configDir}`));
+    console.log(chalk.dim('Edit config.yaml in that directory to configure agents and models.'));
+  });
+
+// ── Version command ──
+
+program
+  .command('version')
+  .description('Show version')
+  .action(() => {
+    console.log(`Skyloom v${VERSION}`);
+  });
+
+// ── Interactive chat ──
+
+async function interactiveChat(agentName: string, modelOverride?: string): Promise<void> {
+  const ctx = createSystemContext();
+  const agent = ctx.agentMap.get(agentName);
+  if (!agent) {
+    console.error(chalk.red(`Unknown agent: ${agentName}. Available: ${[...ctx.agentMap.keys()].join(', ')}`));
+    return;
+  }
+
+  await agent.init();
+  const color = getAgentColor(agentName);
+
+  console.log();
+  console.log(chalk.cyan('≈  S K Y L O O M  ≈'));
+  console.log(chalk.dim(`Agent: ${chalk.bold(agent.displayName)}  ·  Model: ${modelOverride || 'default'}`));
+  console.log(chalk.dim('Type /help for commands, /quit to exit'));
+  console.log();
+
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    prompt: '',
+  });
+
+  const inputHistory: string[] = [];
+
+  const processInput = async (input: string): Promise<void> => {
+    const cmd = input.trim();
+    if (!cmd) return;
+
+    // Slash commands
+    if (cmd === '/quit' || cmd === '/exit') {
+      rl.close();
+      return;
+    }
+    if (cmd === '/help') {
+      printHelp();
+      return;
+    }
+    if (cmd === '/clear') {
+      console.clear();
+      return;
+    }
+    if (cmd === '/status') {
+      const status = agent.getStatus();
+      console.log(chalk.bold('\nAgent Status'));
+      console.log(chalk.dim('─'.repeat(40)));
+      console.log(`  ${chalk.cyan(status.displayName)} (${status.name})`);
+      console.log(`  State: ${status.state}`);
+      console.log(`  Specialty: ${status.specialty}`);
+      if (status.skills?.length) {
+        const active = status.skills.filter((s: any) => s.active).map((s: any) => s.name);
+        if (active.length) console.log(`  Active skills: ${chalk.green(active.join(', '))}`);
+      }
+      return;
+    }
+    if (cmd === '/cost') {
+      const totalCost = ctx.llm.getTotalCost();
+      console.log(`  Total cost: ${chalk.green(formatCost(totalCost))}`);
+      return;
+    }
+    if (cmd === '/compact') {
+      const result = await agent.compact();
+      console.log(chalk.green(`  ✓ ${result}`));
+      return;
+    }
+    if (cmd === '/version') {
+      console.log(`  Skyloom v${VERSION}`);
+      return;
+    }
+    if (cmd.startsWith('/model')) {
+      console.log(chalk.dim('  Model management: use config.yaml to change models'));
+      return;
+    }
+    if (cmd.startsWith('/task ')) {
+      const goal = cmd.slice(6).trim();
+      if (goal) {
+        console.log(chalk.cyan(`\n  Orchestrating: ${goal}\n`));
+        await runTask(goal);
+      }
+      return;
+    }
+    if (cmd.startsWith('/')) {
+      printHelp();
+      return;
+    }
+
+    // Save to history
+    if (!inputHistory.includes(cmd)) {
+      inputHistory.push(cmd);
+      if (inputHistory.length > 50) inputHistory.shift();
+    }
+
+    // Classify and route
+    const mode = MODE.current;
+    if (mode === InteractiveMode.PLAN) {
+      console.log(chalk.magenta('\n  [PLAN mode] Routing to orchestrator...\n'));
+      await runTask(cmd);
+      return;
+    }
+
+    const cls = classify(cmd);
+    if (cls === 'orchestrate' && mode !== InteractiveMode.AUTO) {
+      await runTask(cmd);
+      return;
+    }
+
+    // Single-agent chat
+    process.stdout.write(`\n  ${chalk.cyan(agent.displayName)} ${chalk.dim('thinking...')}\n`);
+
+    try {
+      const response = await agent.chat(cmd);
+      process.stdout.write('\n');
+      console.log(chalk.white(response));
+    } catch (e) {
+      console.error(chalk.red(`\n  Error: ${e}`));
+    }
+
+    // AUTO mode: continue if model signals more work
+    if (mode === InteractiveMode.AUTO) {
+      // Simple auto-continue check
+      const lastMsg = agent.memory.shortTerm[agent.memory.shortTerm.length - 1];
+      if (lastMsg && lastMsg.content && shouldAutoContinue(lastMsg.content)) {
+        process.stdout.write(chalk.yellow('\n  [auto-continue]\n'));
+        // Re-trigger
+        try {
+          const response = await agent.chat('请继续完成');
+          process.stdout.write('\n');
+          console.log(chalk.white(response));
+        } catch (e) {
+          console.error(chalk.red(`\n  Error: ${e}`));
+        }
+      }
+    }
+  };
+
+  rl.on('line', async (line) => {
+    try {
+      await processInput(line);
+    } catch (e) {
+      console.error(chalk.red(`Error: ${e}`));
+    }
+    rl.prompt();
+  });
+
+  rl.on('close', () => {
+    console.log(chalk.dim('\n  Session ended'));
+    ctx.closeAll().catch(() => {});
+    process.exit(0);
+  });
+
+  rl.prompt();
+}
+
+async function runTask(goal: string, resume?: boolean): Promise<void> {
+  const ctx = createSystemContext();
+  await ctx.initAll();
+
+  const [_tasks, results, summary] = await orchestrateTask(
+    goal,
+    ctx.agentMap,
+    null,
+    {
+      resultTruncate: 500,
+      maxTaskRetries: 3,
+      maxReplanRounds: 1,
+      resume,
+    }
+  );
+
+  console.log(chalk.bold('\n  Task Results'));
+  console.log(chalk.dim('  ─'.repeat(30)));
+
+  for (const r of results) {
+    const status = r.success ? chalk.green('✓') : chalk.red('✗');
+    console.log(`  ${status} ${chalk.cyan(r.agent)}: ${r.description.slice(0, 60)}...`);
+  }
+
+  console.log(chalk.bold('\n  Summary'));
+  console.log(chalk.dim('  ─'.repeat(30)));
+  console.log(`  ${summary.slice(0, 1000)}`);
+  console.log();
+
+  await ctx.closeAll();
+}
+
+function printHelp(): void {
+  console.log(chalk.bold('\n  Commands'));
+  console.log(chalk.dim('  ─'.repeat(30)));
+  const cmds = [
+    ['/help', 'Show this help'],
+    ['/clear', 'Clear screen'],
+    ['/status', 'Agent status'],
+    ['/cost', 'Usage & cost'],
+    ['/compact', 'Compress context'],
+    ['/version', 'Version info'],
+    ['/task <goal>', 'Multi-agent task'],
+    ['/quit', 'Exit chat'],
+    ['', ''],
+    ['Switch agents:', ''],
+    ['/fog', 'Fog — research'],
+    ['/rain', 'Rain — codegen'],
+    ['/frost', 'Frost — review'],
+    ['/snow', 'Snow — planning'],
+    ['/dew', 'Dew — devops'],
+    ['/fair', 'Fair — companion'],
+  ];
+  for (const [cmd, desc] of cmds) {
+    if (cmd) {
+      console.log(`  ${chalk.cyan(cmd.padEnd(20))}${chalk.dim(desc)}`);
+    } else {
+      console.log();
+    }
+  }
+  console.log();
+}
+
+function getAgentColor(name: string): string {
+  const colors: Record<string, string> = {
+    fog: 'bright_white', rain: 'blue', frost: 'cyan',
+    snow: 'bright_white', dew: 'green', fair: '#FFD700',
+  };
+  return colors[name] || 'white';
+}
+
+function formatCost(cost: number): string {
+  if (cost >= 1.0) return `$${cost.toFixed(2)}`;
+  if (cost >= 0.01) return `$${cost.toFixed(4)}`;
+  if (cost > 0.0) return `${(cost * 100).toFixed(2)}¢`;
+  return '$0';
+}
+
+function shouldAutoContinue(text: string): boolean {
+  const autoContinuePattern = /(?:接下来|下一步|下面我|然后我|接着|继续|next|let me\s|I'[vl]l\s)/i;
+  const autoStopPattern = /(?:完成了|全部完成|以上就|all done|task complete)/i;
+  const tail = text.split('\n').slice(-6).join('\n');
+  if (autoStopPattern.test(tail)) return false;
+  return autoContinuePattern.test(tail);
+}
+
+// ── Parse CLI args and run ──
+
+async function main(): Promise<void> {
+  const args = process.argv.slice(2);
+
+  // If no args or just "chat", start interactive chat
+  if (args.length === 0 || args[0] === 'chat' || (args.length === 1 && !args[0].startsWith('-') && !['task', 'web', 'config', 'init', 'version'].includes(args[0]))) {
+    // Check if first arg is an agent name
+    const knownAgents = new Set(['fog', 'rain', 'frost', 'snow', 'dew', 'fair']);
+    let agent = 'fog';
+    let model: string | undefined;
+
+    for (let i = 0; i < args.length; i++) {
+      if (knownAgents.has(args[i])) {
+        agent = args[i];
+      } else if (args[i] === '-m' || args[i] === '--model') {
+        model = args[++i];
+      }
+    }
+
+    await interactiveChat(agent, model);
+    return;
+  }
+
+  program.parse(process.argv);
+}
+
+main().catch((e) => {
+  console.error(chalk.red(`Fatal error: ${e}`));
+  process.exit(1);
+});

package/src/cli/mode.ts

@@ -0,0 +1,58 @@
+/**
+ * Interactive mode controller — single source of truth for plan/auto/default.
+ */
+
+export enum InteractiveMode {
+  DEFAULT = 'default',
+  PLAN = 'plan',
+  AUTO = 'auto',
+}
+
+const CYCLE: InteractiveMode[] = [
+  InteractiveMode.DEFAULT,
+  InteractiveMode.PLAN,
+  InteractiveMode.AUTO,
+];
+
+const LABEL_STYLE: Record<InteractiveMode, [string, string]> = {
+  [InteractiveMode.DEFAULT]: ['DEFAULT', 'bold cyan'],
+  [InteractiveMode.PLAN]: ['PLAN', 'bold magenta'],
+  [InteractiveMode.AUTO]: ['AUTO', 'bold yellow'],
+};
+
+const DESCRIPTIONS: Record<InteractiveMode, string> = {
+  [InteractiveMode.DEFAULT]: 'smart — router picks the right depth per message',
+  [InteractiveMode.PLAN]: 'plan first, confirm before execute',
+  [InteractiveMode.AUTO]: 'autonomous reasoning & execution',
+};
+
+export class ModeController {
+  private _mode: InteractiveMode | null = null;
+
+  get current(): InteractiveMode {
+    if (this._mode === null) {
+      this._mode = InteractiveMode.DEFAULT;
+    }
+    return this._mode;
+  }
+
+  set(mode: InteractiveMode): InteractiveMode {
+    this._mode = mode;
+    return mode;
+  }
+
+  cycle(): InteractiveMode {
+    const cur = this.current;
+    const idx = CYCLE.indexOf(cur);
+    const next = CYCLE[(idx + 1) % CYCLE.length];
+    return this.set(next);
+  }
+
+  label(): [string, string] {
+    return LABEL_STYLE[this.current];
+  }
+
+  describe(): string {
+    return DESCRIPTIONS[this.current];
+  }
+}