import { createAgentSession } from "@earendil-works/pi-coding-agent";

const { session, extensionsResult, modelFallbackMessage } = await createAgentSession({
  // === 模型 ===
  model: myModel,              // Model 对象（来自 getModel() 或 modelRegistry.find()）
  thinkingLevel: "medium",     // off | minimal | low | medium | high | xhigh

  // === 认证 ===
  authStorage: authStorage,    // AuthStorage 实例（管理 API Key / OAuth）
  modelRegistry: modelRegistry,// ModelRegistry 实例（模型查找 / 遍历）

  // === 工具 ===
  tools: ["read", "bash"],     // 启用的工具名称列表（默认 ["read","bash","edit","write"]）
  excludeTools: ["edit"],      // 禁用的工具名称列表
  customTools: [myTool],       // 自定义工具数组（defineTool() 创建）
  noTools: "builtin",          // "all" 禁用全部 | "builtin" 禁内置保留扩展

  // === 目录 ===
  cwd: process.cwd(),          // 工作目录（DefaultResourceLoader 从此向上发现资源）
  agentDir: getAgentDir(),     // 全局配置目录（默认 ~/.pi/agent）

  // === 资源 ===
  resourceLoader: myLoader,    // ResourceLoader 实例（加载 Extensions/Skills/Prompts）

  // === 会话 ===
  sessionManager: SessionManager.inMemory(),  // 会话管理器

  // === 设置 ===
  settingsManager: settingsManager,  // 设置管理器

  // === 模型切换范围 ===
  scopedModels: [              // 模型轮转候选列表（Ctrl+P）
    { model: opus, thinkingLevel: "high" },
    { model: haiku, thinkingLevel: "off" },
  ],
});

import {
  AuthStorage,
  createAgentSession,
  ModelRegistry,
  SessionManager,
} from "@earendil-works/pi-coding-agent";

// 1. 创建凭据存储和模型注册表
const authStorage = AuthStorage.create();
const modelRegistry = ModelRegistry.create(authStorage);

// 2. 创建会话（内存模式）
const { session } = await createAgentSession({
  sessionManager: SessionManager.inMemory(),
  authStorage,
  modelRegistry,
});

// 3. 订阅事件
session.subscribe((event) => {
  if (event.type === "message_update" &&
      event.assistantMessageEvent.type === "text_delta") {
    process.stdout.write(event.assistantMessageEvent.delta);
  }
});

// 4. 发送提示
await session.prompt("列出当前目录的所有文件");

// 5. 清理
session.dispose();

interface AgentSession {
  // === 会话信息 ===
  sessionFile: string | undefined;   // 会话文件路径（内存模式为 undefined）
  sessionId: string;                 // 会话唯一标识

  // === 消息 ===
  prompt(text: string, options?: PromptOptions): Promise<void>;
  steer(text: string): Promise<void>;
  followUp(text: string): Promise<void>;

  // === 事件 ===
  subscribe(listener: (event: AgentSessionEvent) => void): () => void;

  // === 模型控制 ===
  setModel(model: Model): Promise<void>;
  setThinkingLevel(level: ThinkingLevel): void;
  cycleModel(): Promise<ModelCycleResult | undefined>;
  cycleThinkingLevel(): ThinkingLevel | undefined;

  // === 状态访问 ===
  agent: Agent;                          // 底层的 Agent 实例
  model: Model | undefined;              // 当前模型
  thinkingLevel: ThinkingLevel;          // 当前思考级别
  messages: AgentMessage[];              // 所有消息
  isStreaming: boolean;                  // 是否正在流式输出

  // === 树导航 ===
  navigateTree(targetId: string, options?: {
    summarize?: boolean;
    customInstructions?: string;
    replaceInstructions?: boolean;
    label?: string;
  }): Promise<{ editorText?: string; cancelled: boolean }>;

  // === 上下文压缩 ===
  compact(customInstructions?: string): Promise<CompactionResult>;
  abortCompaction(): void;

  // === 控制 ===
  abort(): Promise<void>;
  dispose(): void;
}

// 基本用法（Agent 未流式输出时）
await session.prompt("帮我重构这段代码");

// 带图片
await session.prompt("这张图片有什么问题？", {
  images: [{
    type: "image",
    source: {
      type: "base64",
      mediaType: "image/png",
      data: "iVBORw0KGgo..."
    }
  }]
});

// 在流式输出中发送——必须指定 streamingBehavior
await session.prompt("停下来，先做这个", { streamingBehavior: "steer" });
await session.prompt("除此之外，再做这个", { streamingBehavior: "followUp" });

interface PromptOptions {
  expandPromptTemplates?: boolean;    // 是否展开 /name 模板
  images?: ImageContent[];            // 附带图片
  streamingBehavior?: "steer" | "followUp";  // 流式输出时的排队策略
  source?: InputSource;               // 输入来源标记
  preflightResult?: (success: boolean) => void;  // 提示预处理完成回调
}

// steer：在当前 LLM 轮次处理完工具调用后、下一轮 LLM 调用前投递
await session.steer("停止当前操作，先修这个 bug");

// followUp：等待 Agent 完全停止后才投递
await session.followUp("完成后，再写一份测试");

const unsubscribe = session.subscribe((event) => {
  switch (event.type) {
    // === 流式文本 ===
    case "message_update":
      if (event.assistantMessageEvent.type === "text_delta") {
        process.stdout.write(event.assistantMessageEvent.delta);
      }
      if (event.assistantMessageEvent.type === "thinking_delta") {
        // 思考过程（启用思考功能时）
      }
      if (event.assistantMessageEvent.type === "toolcall_start") {
        console.log(`[调用工具] ${event.assistantMessageEvent.toolCall.name}`);
      }
      break;

    // === 工具执行 ===
    case "tool_execution_start":
      console.log(`[开始] ${event.toolName}`);
      break;
    case "tool_execution_update":
      // event.partialResult 包含累积输出
      break;
    case "tool_execution_end":
      console.log(`[结果] ${event.isError ? "出错" : "成功"}`);
      break;

    // === 消息生命周期 ===
    case "message_start":
    case "message_end":
      break;

    // === Agent 生命周期 ===
    case "agent_start":
      console.log("[Agent 开始处理]");
      break;
    case "agent_end":
      console.log(`[Agent 完成] 产生 ${event.messages.length} 条消息`);
      break;

    // === 轮次 ===
    case "turn_start":
    case "turn_end":
      break;

    // === 队列 ===
    case "queue_update":
      console.log(`排队中: steering=${event.steering.length}, followUp=${event.followUp.length}`);
      break;

    // === 压缩 ===
    case "compaction_start":
      console.log(`[压缩] 原因: ${event.reason}`);
      break;
    case "compaction_end":
      if (event.result) {
        console.log(`[压缩完成] 从 ${event.result.tokensBefore} 降至 ~${event.result.estimatedTokensAfter} tokens`);
      }
      break;

    // === 自动重试 ===
    case "auto_retry_start":
      console.log(`[重试] 第 ${event.attempt}/${event.maxAttempts} 次, 等待 ${event.delayMs}ms`);
      break;
    case "auto_retry_end":
      console.log(`[重试结束] ${event.success ? "成功" : `失败: ${event.finalError}`}`);
      break;
  }
});

// 取消订阅
unsubscribe();

import { getModel } from "@earendil-works/pi-ai";

// 切换到指定模型
const sonnet = getModel("anthropic", "claude-sonnet-4-20250514");
await session.setModel(sonnet!);

// 设置思考级别
session.setThinkingLevel("high");
session.setThinkingLevel("off");  // 关闭思考（节省 token 和成本）

// 遍历模型（类似 Ctrl+P）
const result = await session.cycleModel();
if (result) {
  console.log(`当前模型: ${result.model.id}，思考: ${result.thinkingLevel}`);
}

// 遍历思考级别
const newLevel = session.cycleThinkingLevel();

// 默认压缩
const result = await session.compact();
console.log(`摘要: ${result.summary}`);
console.log(`tokens: ${result.tokensBefore} → ~${result.estimatedTokensAfter}`);

// 带自定义指令的压缩
await session.compact("重点保留与数据库迁移相关的讨论");

// 中止正在进行的压缩
session.abortCompaction();

interface CompactionResult {
  summary: string;             // 对话摘要
  firstKeptEntryId: string;    // 保留的第一条消息 ID
  tokensBefore: number;        // 压缩前 token 数
  estimatedTokensAfter: number;// 压缩后估算 token 数（启发式）
  details: object;             // 详细信息
}

const result = await session.navigateTree("abc123", {
  summarize: true,                                   // 是否添加摘要
  customInstructions: "从 checkpoint 重新开始分析",  // 自定义指令
  label: "backtrack",                                // 标记节点
});

if (result.cancelled) {
  console.log("导航被取消（Extension 拦截）");
} else {
  console.log(`编辑器文本: ${result.editorText}`);
}

// 中止当前操作（如工具执行、LLM 调用）
await session.abort();

// 释放资源（取消所有事件订阅、清理内存状态）
session.dispose();

import { getModel } from "@earendil-works/pi-ai";
import { Type } from "typebox";
import {
  AuthStorage,
  createAgentSession,
  DefaultResourceLoader,
  defineTool,
  ModelRegistry,
  SessionManager,
  SettingsManager,
} from "@earendil-works/pi-coding-agent";

async function main() {
  // 1. 设置认证存储和模型注册表
  const authStorage = AuthStorage.create();
  // 运行时 API Key 覆写（不写入磁盘）
  if (process.env.MY_API_KEY) {
    authStorage.setRuntimeApiKey("anthropic", process.env.MY_API_KEY);
  }
  const modelRegistry = ModelRegistry.create(authStorage);

  // 2. 定义自定义工具
  const statusTool = defineTool({
    name: "status",
    label: "系统状态",
    description: "获取当前系统运行状态",
    parameters: Type.Object({}),
    execute: async () => ({
      content: [{ type: "text", text: `运行时间: ${process.uptime()}s` }],
      details: {},
    }),
  });

  // 3. 获取模型
  const model = getModel("anthropic", "claude-sonnet-4-20250514");
  if (!model) throw new Error("模型未找到");

  // 4. 设置管理（内存模式，带覆写）
  const settingsManager = SettingsManager.inMemory({
    compaction: { enabled: false },
    retry: { enabled: true, maxRetries: 2 },
  });

  // 5. 资源加载器（自定义系统提示词）
  const loader = new DefaultResourceLoader({
    cwd: process.cwd(),
    agentDir: "~/.pi/agent",
    settingsManager,
    systemPromptOverride: () => "你是一个精简的助手。保持回复简洁。",
  });
  await loader.reload();

  // 6. 创建会话
  const { session } = await createAgentSession({
    cwd: process.cwd(),
    agentDir: "~/.pi/agent",
    model,
    thinkingLevel: "medium",
    authStorage,
    modelRegistry,
    tools: ["read", "bash", "status"],
    customTools: [statusTool],
    resourceLoader: loader,
    sessionManager: SessionManager.inMemory(),
    settingsManager,
  });

  // 7. 订阅事件
  session.subscribe((event) => {
    if (event.type === "message_update" &&
        event.assistantMessageEvent.type === "text_delta") {
      process.stdout.write(event.assistantMessageEvent.delta);
    }
  });

  // 8. 发送提示
  await session.prompt("获取系统状态并列出文件");

  // 9. 清理
  session.dispose();
}

main().catch(console.error);

import {
  type CreateAgentSessionRuntimeFactory,
  createAgentSessionFromServices,
  createAgentSessionRuntime,
  createAgentSessionServices,
  getAgentDir,
  SessionManager,
} from "@earendil-works/pi-coding-agent";

// 定义 Runtime 工厂
const createRuntime: CreateAgentSessionRuntimeFactory = async ({
  cwd, sessionManager, sessionStartEvent
}) => {
  // 创建 cwd 相关服务
  const services = await createAgentSessionServices({ cwd });

  // 从服务创建会话
  const sessionData = await createAgentSessionFromServices({
    services,
    sessionManager,
    sessionStartEvent,
  });

  return {
    ...sessionData,
    services,
    diagnostics: services.diagnostics,
  };
};

// 创建 Runtime
const runtime = await createAgentSessionRuntime(createRuntime, {
  cwd: process.cwd(),
  agentDir: getAgentDir(),
  sessionManager: SessionManager.create(process.cwd()),
});

let session = runtime.session;
let unsubscribe = session.subscribe(handleEvent);

// 新建会话
await runtime.newSession();

// 重要：事件订阅绑定到旧 session 上，需要重新订阅
unsubscribe();
session = runtime.session;
unsubscribe = session.subscribe(handleEvent);

// 如果使用了 Extensions，也需要重新绑定
// await runtime.session.bindExtensions(...);

// 从指定历史消息创建分支（生成新文件）
await runtime.fork("entry-abc123");

// 克隆：在当前路径位置复制到新文件
await runtime.fork("entry-abc123", { position: "at" });

// 交互式模式（完整 TUI）
import { InteractiveMode } from "@earendil-works/pi-coding-agent";
const mode = new InteractiveMode(runtime, { /* options */ });
await mode.run();

// Print 模式（一次性问答）
import { runPrintMode } from "@earendil-works/pi-coding-agent";
await runPrintMode(runtime, {
  mode: "text",
  initialMessage: "列出所有 .ts 文件并统计行数",
  initialImages: [],
  messages: [],
});

// RPC 模式（JSONL 进程间通信）
import { runRpcMode } from "@earendil-works/pi-coding-agent";
await runRpcMode(runtime);

import { runPrintMode } from "@earendil-works/pi-coding-agent";

await runPrintMode(runtime, {
  mode: "text",                         // 输出格式: "text"
  initialMessage: "审查 src/utils.ts",   // 第一条提示
  initialImages: [],                     // 附带图片
  messages: ["再给出重构建议"],          // 后续提示
});

import { spawn } from "child_process";

const pi = spawn("pi", ["--mode", "json", "分析 src/index.ts"]);

// 按行解析 JSONL（同上，不要用 readline）
let buffer = "";
pi.stdout.on("data", (chunk) => {
  buffer += chunk.toString();
  const lines = buffer.split("\n");
  buffer = lines.pop() || "";

  for (const line of lines) {
    if (!line.trim()) continue;
    const event = JSON.parse(line);

    switch (event.type) {
      case "message_update":
        if (event.assistantMessageEvent?.type === "text_delta") {
          process.stdout.write(event.assistantMessageEvent.delta);
        }
        break;
      case "tool_execution_end":
        console.log(`\n[Tool ${event.toolName}] isError=${event.isError}`);
        break;
    }
  }
});

import { getModel } from "@earendil-works/pi-ai";
import {
  AuthStorage,
  createAgentSession,
  ModelRegistry,
  SessionManager,
} from "@earendil-works/pi-coding-agent";
import { readFileSync, writeFileSync, readdirSync } from "fs";
import { join } from "path";

async function reviewFiles(dir: string) {
  const authStorage = AuthStorage.create();
  const modelRegistry = ModelRegistry.create(authStorage);
  const model = getModel("anthropic", "claude-sonnet-4-20250514");
  if (!model) throw new Error("模型未找到");

  const files = readdirSync(dir, { recursive: true })
    .filter(f => f.endsWith(".ts") || f.endsWith(".tsx"))
    .map(f => join(dir, f));

  const results: Record<string, string> = {};

  for (const file of files.slice(0, 5)) {  // 限制 5 个文件避免超时
    const content = readFileSync(file, "utf-8");
    const { session } = await createAgentSession({
      model,
      authStorage,
      modelRegistry,
      thinkingLevel: "medium",
      sessionManager: SessionManager.inMemory(),
    });

    let review = "";
    session.subscribe((event) => {
      if (event.type === "message_update" &&
          event.assistantMessageEvent.type === "text_delta") {
        review += event.assistantMessageEvent.delta;
      }
    });

    console.log(`[审查] ${file}`);
    await session.prompt(`审查以下代码，重点关注安全隐患、逻辑错误和性能问题。给出简明建议。\n\n\`\`\`typescript\n${content}\n\`\`\``);
    results[file] = review;
    session.dispose();
  }

  // 汇总报告
  const report = Object.entries(results)
    .map(([file, review]) => `## ${file}\n\n${review}\n`)
    .join("\n---\n\n");
  writeFileSync("review-report.md", report);
  console.log("审查报告已保存到 review-report.md");
}

reviewFiles("./src").catch(console.error);