import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
import { Type } from "typebox";

export default function (pi: ExtensionAPI) {
  // ① 订阅事件
  pi.on("session_start", async (_event, ctx) => {
    ctx.ui.notify("Extension loaded!", "info");
  });

  // ② 拦截工具调用（危险命令闸门）
  pi.on("tool_call", async (event, ctx) => {
    if (event.toolName === "bash" && event.input.command?.includes("rm -rf")) {
      const ok = await ctx.ui.confirm("Dangerous!", "Allow rm -rf?");
      if (!ok) return { block: true, reason: "Blocked by user" };
    }
  });

  // ③ 注册 LLM 可调用的自定义工具
  pi.registerTool({
    name: "greet",
    label: "Greet",
    description: "Greet someone by name",
    parameters: Type.Object({ name: Type.String({ description: "Name to greet" }) }),
    async execute(toolCallId, params, signal, onUpdate, ctx) {
      return { content: [{ type: "text", text: `Hello, ${params.name}!` }], details: {} };
    },
  });

  // ④ 注册斜杠命令
  pi.registerCommand("hello", {
    description: "Say hello",
    handler: async (args, ctx) => ctx.ui.notify(`Hello ${args || "world"}!`, "info"),
  });
}

{
  "packages": ["npm:@foo/bar@1.0.0", "git:github.com/user/repo@v1"],
  "extensions": ["/path/to/local/extension.ts", "/path/to/dir"]
}

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

pi.on("tool_call", async (event, ctx) => {
  // isToolCallEventType 收窄类型，拿到 typed input
  if (isToolCallEventType("bash", event)) {
    // input 可变！原地修改会真实影响执行，且后续 handler 能看到
    event.input.command = `source ~/.profile\n${event.input.command}`;

    if (event.input.command.includes("rm -rf")) {
      return { block: true, reason: "Dangerous command", terminate: true };
    }
  }
});

import { Type } from "typebox";
import { StringEnum } from "@earendil-works/pi-ai";

pi.registerTool({
  name: "todo",
  label: "Todo",
  description: "List or add items in the project todo list",
  // 进系统提示词 Available tools 区的一行简介（不加就不出现）
  promptSnippet: "Manage the shared todo list",
  // 进 Guidelines 区的子弹。注意：必须自带工具名！
  promptGuidelines: [
    "Use todo for task planning instead of direct file edits when the user asks for a task list."
  ],
  parameters: Type.Object({
    action: StringEnum(["list", "add"] as const),
    text: Type.Optional(Type.String()),
  }),
  prepareArguments(args) { return args; }, // 校验前的兼容垫片

  async execute(toolCallId, params, signal, onUpdate, ctx) {
    if (signal?.aborted) return { content: [{ type: "text", text: "Cancelled" }] };

    // 流式进度（TUI 实时可见）
    onUpdate?.({ content: [{ type: "text", text: "Working..." }], details: { progress: 50 } });

    const result = await pi.exec("some-command", [], { signal });

    return {
      content: [{ type: "text", text: "Done" }],  // → 给 LLM
      details: { data: result },                    // → 给渲染/状态恢复
      // terminate: true,  // 本批全是 terminate 则跳过后续 LLM 调用
    };
  },

  renderCall(args, theme, context) { /* TUI 里怎么画调用行 */ },
  renderResult(result, options, theme, context) { /* TUI 里怎么画结果 */ },
});

import { truncateHead, DEFAULT_MAX_LINES, DEFAULT_MAX_BYTES,
         withFileMutationQueue } from "@earendil-works/pi-coding-agent";

async execute(_id, params, _signal, _onUpdate, ctx) {
  const abs = resolve(ctx.cwd, params.path);
  return withFileMutationQueue(abs, async () => {
    const output = await runCommand();
    const t = truncateHead(output, { maxLines: DEFAULT_MAX_LINES, maxBytes: DEFAULT_MAX_BYTES });
    let text = t.content;
    if (t.truncated) text += `\n\n[Truncated. Full output saved to ${tempFile}]`;
    return { content: [{ type: "text", text }] };
  });
}

// 阻塞式对话框
const choice = await ctx.ui.select("Pick one:", ["A", "B", "C"]);
const ok     = await ctx.ui.confirm("Delete?", "This cannot be undone");
const name   = await ctx.ui.input("Name:", "placeholder");
const text   = await ctx.ui.editor("Edit:", "prefilled");

// 非阻塞
ctx.ui.notify("Done!", "info");  // "info" | "warning" | "error"

// 倒计时自动关闭：confirm 超时返回 false，其余返回 undefined
const sure = await ctx.ui.confirm("Timed", "Auto-cancel in 5s. Sure?", { timeout: 5000 });

// 常驻元素
ctx.ui.setStatus("my-ext", "Processing...");            // footer 状态
ctx.ui.setWidget("my-widget", ["Line 1", "Line 2"]);      // 编辑器上方小部件
ctx.ui.setWidget("w", [...], { placement: "belowEditor" }); // 或编辑器下方
ctx.ui.setTitle("pi - my-project");
ctx.ui.setWorkingMessage("Thinking deeply...");           // 流式时的 loader 文案

// 完整自定义组件：临时替换编辑器，done() 收场
const result = await ctx.ui.custom<boolean>((tui, theme, keybindings, done) => {
  const text = new Text("Enter=确认 Esc=取消", 1, 1);
  text.onKey = (key) => {
    if (key === "return") done(true);
    if (key === "escape") done(false);
    return true;
  };
  return text;
});
// 加 { overlay: true } 变悬浮 modal，不清屏

export default function (pi: ExtensionAPI) {
  let items: string[] = [];

  // 重启/reload 后从会话重建状态
  pi.on("session_start", async (_e, ctx) => {
    items = [];
    for (const entry of ctx.sessionManager.getBranch()) {
      if (entry.type === "message" && entry.message.role === "toolResult"
          && entry.message.toolName === "my_tool") {
        items = entry.message.details?.items ?? [];  // 从 details 恢复
      }
    }
  });

  pi.registerTool({
    name: "my_tool", /* ... */
    async execute(_id, params) {
      items.push(params.text);
      return {
        content: [{ type: "text", text: "Added" }],
        details: { items: [...items] },  // 存快照 → 天然支持 /tree 分支回溯
      };
    },
  });

  // 纯展示卡片（LLM 看不到）
  pi.appendEntry("status-card", { title: "Indexed files", count: 17 });
}

// ① 简单注册：本地 OpenAI 兼容端点
pi.registerProvider("local-openai", {
  baseUrl: "http://localhost:1234/v1",
  apiKey: "$LOCAL_API_KEY",              // 支持 $ENV / ${ENV} / !command
  api: "openai-completions",             // 或 anthropic-messages / openai-responses …
  models: [{ id: "qwen3-32b", name: "Qwen3 32B", reasoning: false,
             input: ["text"], cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
             contextWindow: 128000, maxTokens: 16384 }],
});

// ② 动态发现：live llama.cpp，刷新时拉 /v1/models
pi.registerProvider("llama.cpp", {
  baseUrl: "http://localhost:8080/v1",
  apiKey: "$LLAMA_API_KEY",
  api: "openai-completions",
  async refreshModels({ signal }) {
    const r = await fetch("http://localhost:8080/v1/models", { signal });
    const { data } = await r.json();
    return data.map(({ id }) => ({ id, name: id, reasoning: false,
      input: ["text"], cost: { input:0, output:0, cacheRead:0, cacheWrite:0 },
      contextWindow: 128000, maxTokens: 16384 }));
  },
});

// ③ 只覆盖 baseUrl，模型全保留
pi.registerProvider("anthropic", { baseUrl: "https://proxy.example.com" });

// ④ 带 OAuth 登录流（出现在 /login 菜单）
pi.registerProvider("corporate-ai", {
  baseUrl: "https://ai.corp.com", api: "openai-responses", models: [/*…*/],
  oauth: {
    name: "Corporate AI (SSO)",
    async login(callbacks) {
      callbacks.onAuth({ url: "https://sso.corp.com/..." });
      const code = await callbacks.onPrompt({ message: "Enter code:" });
      return { refresh: code, access: code, expires: Date.now() + 3600000 };
    },
    async refreshToken(credentials, signal) { signal.throwIfAborted(); return credentials; },
    getApiKey(credentials) { return credentials.access; },
  },
});

pi.unregisterProvider("my-proxy");  // 移除；被覆盖的内置模型恢复原样