任务与调度

// TaskCreateTool: 创建任务并设置依赖
interface TaskCreateInput {
  subject: string;       // 简短标题（祈使句式）
  description: string;   // 详细描述
  activeForm?: string;   // 进行中时的显示文本
  metadata?: Record<string, unknown>;
}

interface Task {
  id: string;
  subject: string;
  description: string;
  status: "pending" | "in_progress" | "completed" | "deleted";
  owner?: string;
  blocks: string[];      // 此任务完成后才能开始的任务
  blockedBy: string[];   // 此任务依赖的前置任务
  activeForm?: string;
}

// 创建一组有依赖关系的任务
async function createTaskPipeline(
  store: TaskStore
): Promise<void> {
  // 任务 1: 基础设施
  const t1 = store.create({
    subject: "搭建数据库 Schema",
    description: "创建用户表、权限表和会话表",
    activeForm: "搭建数据库 Schema 中"
  });

  // 任务 2: 依赖任务 1
  const t2 = store.create({
    subject: "实现 API 端点",
    description: "基于 Schema 实现 CRUD API"
  });
  store.update(t2.id, {
    addBlockedBy: [t1.id]
  });

  // 任务 3: 依赖任务 2
  const t3 = store.create({
    subject: "编写集成测试",
    description: "测试所有 API 端点"
  });
  store.update(t3.id, {
    addBlockedBy: [t2.id]
  });

  // 开始执行任务 1
  store.update(t1.id, {
    status: "in_progress"
  });
}

// CronCreateTool: 标准 5 字段 Cron 调度
interface CronCreateInput {
  cron: string;          // "M H DoM Mon DoW"
  prompt: string;        // 触发时执行的提示词
  recurring?: boolean;   // 默认 true，false 为单次
  durable?: boolean;     // 默认 false，true 持久化到磁盘
}

interface CronJob {
  id: string;
  cron: string;
  prompt: string;
  recurring: boolean;
  durable: boolean;
  nextFireTime: Date;
  createdAt: Date;
  expiresAt: Date;       // 循环任务 7 天后过期
}

// 调度器核心逻辑
class CronScheduler {
  private jobs: Map<string, CronJob> = new Map();
  private readonly STORAGE_PATH =
    ".claude/scheduled_tasks.json";

  create(input: CronCreateInput): CronJob {
    const job: CronJob = {
      id: generateId(),
      cron: input.cron,
      prompt: input.prompt,
      recurring: input.recurring !== false,
      durable: input.durable || false,
      nextFireTime: computeNextFire(input.cron),
      createdAt: new Date(),
      expiresAt: new Date(
        Date.now() + 7 * 24 * 60 * 60 * 1000
      )
    };

    this.jobs.set(job.id, job);

    // 持久化到磁盘
    if (job.durable) {
      this.persistToDisk();
    }
    return job;
  }

  // REPL 空闲时检查并触发到期任务
  async tick(): Promise<void> {
    const now = new Date();
    for (const [id, job] of this.jobs) {
      // 过期检查
      if (now > job.expiresAt) {
        this.jobs.delete(id);
        continue;
      }
      // 触发检查
      if (now >= job.nextFireTime) {
        await this.fire(job);
        if (job.recurring) {
          job.nextFireTime = computeNextFire(job.cron);
        } else {
          this.jobs.delete(id);
        }
      }
    }
  }

  private async fire(job: CronJob): Promise<void> {
    // 将 prompt 加入 REPL 消息队列
    enqueuePrompt(job.prompt);
  }

  private persistToDisk(): void {
    const durableJobs = [...this.jobs.values()]
      .filter(j => j.durable);
    writeFileSync(
      this.STORAGE_PATH,
      JSON.stringify(durableJobs, null, 2)
    );
  }
}

// services/autoDream: AI 梦境知识整合
const consolidationPrompt = [
  "回顾本次对话的完整历史。",
  "提取关键技术决策和发现。",
  "识别用户的编码偏好和风格。",
  "总结项目结构和架构特征。",
  "生成简洁的知识摘要用于后续参考。"
].join("\n");

// 梦境锁：防止并发执行
class ConsolidationLock {
  private locked = false;
  private lockHolder: string | null = null;

  acquire(taskId: string): boolean {
    if (this.locked) return false;
    this.locked = true;
    this.lockHolder = taskId;
    return true;
  }

  release(taskId: string): void {
    if (this.lockHolder === taskId) {
      this.locked = false;
      this.lockHolder = null;
    }
  }
}

// DreamTask: 后台知识整合任务
class DreamTask {
  private lock = new ConsolidationLock();

  async execute(
    conversationHistory: Message[]
  ): Promise<DreamResult | null> {
    const taskId = "dream-" + Date.now();

    // 尝试获取锁
    if (!this.lock.acquire(taskId)) {
      return null; // 已有梦境任务在执行
    }

    try {
      // 构建整合上下文
      const context = conversationHistory
        .filter(m => m.role !== "system")
        .map(m => m.role + ": " + summarize(m.content))
        .join("\n");

      // 执行 AI 反思
      const result = await callModel({
        system: consolidationPrompt,
        messages: [
          { role: "user", content: context }
        ]
      });

      // 保存知识摘要
      return {
        summary: result.content,
        timestamp: Date.now(),
        messageCount: conversationHistory.length
      };
    } finally {
      this.lock.release(taskId);
    }
  }
}

// 自动触发条件
function shouldStartDream(
  state: AppState
): boolean {
  const idleTime = Date.now() - state.lastUserInput;
  const messageCount = state.conversationLength;
  // 空闲 2 分钟且对话超过 20 条消息
  return idleTime > 120_000 && messageCount > 20;
}