decorated-pi 0.2.2 → 0.4.0

package/extensions/lsp/types.ts

@@ -0,0 +1,42 @@
+/**
+ * LSP type definitions — minimal set needed by this extension.
+ */
+
+export interface LspPosition {
+  line: number;
+  character: number;
+}
+
+export interface LspRange {
+  start: LspPosition;
+  end: LspPosition;
+}
+
+export interface LspLocation {
+  uri: string;
+  range: LspRange;
+}
+
+export interface LspDiagnostic {
+  range: LspRange;
+  severity?: number;
+  code?: unknown;
+  source?: string;
+  message: string;
+}
+
+export interface LspHover {
+  contents: unknown;
+  range?: LspRange;
+}
+
+export interface LspDocumentSymbol {
+  name: string;
+  kind: number;
+  range: LspRange;
+  selectionRange?: LspRange;
+  containerName?: string;
+  detail?: string;
+  children?: LspDocumentSymbol[];
+  uri?: string;
+}

package/extensions/mcp/builtin.ts

@@ -0,0 +1,126 @@
+/**
+ * MCP server configuration — builtin + global + project-level.
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { loadConfig } from "../settings.js";
+
+export interface McpServerConfig {
+  name: string;
+  url: string;
+  description?: string;
+  enabled: boolean;
+  source: "builtin" | "global" | "project";
+}
+
+/** Builtin servers — zero-config, always available unless overridden. */
+export const BUILTIN_MCP_SERVERS: Omit<McpServerConfig, "source">[] = [
+  {
+    name: "context7",
+    url: "https://mcp.context7.com/mcp",
+    description: "Context7 documentation and code examples",
+    enabled: true,
+  },
+  {
+    name: "exa",
+    url: "https://mcp.exa.ai/mcp",
+    description: "Exa web search",
+    enabled: true,
+  },
+];
+
+// ── Project-level config discovery ─────────────────────────────────────────
+
+const PROJECT_CONFIG_PATHS = [
+  ".pi/mcp.json",
+  ".pi/.mcp.json",
+  ".agents/mcp.json",
+  ".agents/.mcp.json",
+  ".claude/mcp.json",
+  ".claude/.mcp.json",
+  "mcp.json",
+  ".mcp.json",
+];
+
+function readMcpJson(filePath: string): Record<string, { url: string; enabled?: boolean }> | null {
+  try {
+    const raw = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+    if (!raw || typeof raw !== "object" || Array.isArray(raw)) return null;
+    const servers = raw.mcpServers ?? raw["mcp-servers"];
+    if (!servers || typeof servers !== "object" || Array.isArray(servers)) return null;
+    return servers as Record<string, { url: string; enabled?: boolean }>;
+  } catch {
+    return null;
+  }
+}
+
+/** Load project-level MCP configs from cwd and its ancestor directories. */
+export function loadProjectMcpConfigs(cwd: string): McpServerConfig[] {
+  const configs: McpServerConfig[] = [];
+  const seen = new Set<string>();
+
+  let current = path.resolve(cwd);
+  while (true) {
+    for (const relative of PROJECT_CONFIG_PATHS) {
+      const filePath = path.join(current, relative);
+      if (!fs.existsSync(filePath)) continue;
+      const servers = readMcpJson(filePath);
+      if (!servers) continue;
+
+      for (const [name, entry] of Object.entries(servers)) {
+        if (seen.has(name)) continue;
+        seen.add(name);
+        configs.push({
+          name,
+          url: entry.url,
+          enabled: entry.enabled !== false,
+          source: "project",
+        });
+      }
+    }
+
+    const parent = path.dirname(current);
+    if (parent === current) break;
+    current = parent;
+  }
+
+  return configs;
+}
+
+/** Load global MCP configs from ~/.pi/agent/decorated-pi.json. */
+export function loadGlobalMcpConfigs(): McpServerConfig[] {
+  const config = loadConfig();
+  if (!config.mcpServers) return [];
+
+  return Object.entries(config.mcpServers).map(([name, entry]) => ({
+    name,
+    url: entry.url,
+    enabled: entry.enabled !== false,
+    source: "global" as const,
+  }));
+}
+
+/**
+ * Merge all MCP configs: builtin → global → project.
+ * Later sources override earlier ones for the same server name.
+ */
+export function resolveMcpConfigs(cwd: string): McpServerConfig[] {
+  const byName = new Map<string, McpServerConfig>();
+
+  // Builtin (lowest priority)
+  for (const s of BUILTIN_MCP_SERVERS) {
+    byName.set(s.name, { ...s, source: "builtin" });
+  }
+
+  // Global
+  for (const s of loadGlobalMcpConfigs()) {
+    byName.set(s.name, s);
+  }
+
+  // Project (highest priority)
+  for (const s of loadProjectMcpConfigs(cwd)) {
+    byName.set(s.name, s);
+  }
+
+  return [...byName.values()].filter((s) => s.enabled);
+}

package/extensions/mcp/client.ts

@@ -0,0 +1,106 @@
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
+
+export interface McpToolSpec {
+  name: string;
+  description: string;
+  inputSchema: Record<string, unknown>;
+}
+
+/** Per-server MCP client wrapper with fallback transport. */
+export class McpConnection {
+  client: Client;
+  transport: StreamableHTTPClientTransport | SSEClientTransport | undefined;
+  tools: McpToolSpec[] = [];
+  private connected = false;
+
+  source: string = "unknown";
+
+  constructor(
+    public readonly serverName: string,
+    public readonly url: string,
+  ) {
+    this.client = new Client({
+      name: `decorated-pi-${serverName}`,
+      version: "0.3.0",
+    });
+  }
+
+  async connect(timeoutMs = 8000): Promise<void> {
+    const connectWithFallback = async (): Promise<void> => {
+      let lastErr: Error | undefined;
+      try {
+        const transport = new StreamableHTTPClientTransport(new URL(this.url));
+        await this.client.connect(transport);
+        this.transport = transport;
+        this.connected = true;
+      } catch (err) {
+        lastErr = err instanceof Error ? err : new Error(String(err));
+        try {
+          const transport = new SSEClientTransport(new URL(this.url));
+          await this.client.connect(transport);
+          this.transport = transport;
+          this.connected = true;
+        } catch (sseErr) {
+          const sseMessage = sseErr instanceof Error ? sseErr.message : String(sseErr);
+          throw new Error(
+            `MCP ${this.serverName}: StreamableHTTP failed (${lastErr.message}); SSE fallback also failed (${sseMessage})`,
+          );
+        }
+      }
+
+      const result = (await this.client.listTools()) as unknown as {
+        tools: Array<{
+          name: string;
+          description?: string;
+          inputSchema?: Record<string, unknown>;
+        }>;
+      };
+
+      this.tools = (result.tools ?? []).map((t) => ({
+        name: t.name,
+        description: t.description || "",
+        inputSchema: t.inputSchema || { type: "object", properties: {} },
+      }));
+    };
+
+    const timeout = new Promise<never>((_, reject) =>
+      setTimeout(() => reject(new Error(`MCP ${this.serverName}: connection timed out after ${timeoutMs}ms`)), timeoutMs),
+    );
+
+    await Promise.race([connectWithFallback(), timeout]);
+  }
+
+  async callTool(name: string, args: Record<string, unknown>): Promise<string> {
+    if (!this.connected) {
+      throw new Error(`MCP ${this.serverName}: not connected`);
+    }
+    const result = (await this.client.callTool({
+      name,
+      arguments: args,
+    })) as unknown as {
+      content?: Array<{ type: string; text?: string }>;
+      isError?: boolean;
+    };
+
+    const text = (result.content ?? [])
+      .filter((c): c is { type: "text"; text: string } => c.type === "text" && typeof c.text === "string")
+      .map((c) => c.text)
+      .join("\n");
+
+    if (result.isError) {
+      throw new Error(text || `MCP tool "${name}" returned an error`);
+    }
+
+    return text || "(empty result)";
+  }
+
+  async disconnect(): Promise<void> {
+    if (!this.connected) return;
+    this.connected = false;
+    try {
+      await this.client.close();
+    } catch {}
+  }
+}

package/extensions/mcp/index.ts

@@ -0,0 +1,123 @@
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { Type } from "typebox";
+import { McpConnection } from "./client.js";
+import { resolveMcpConfigs } from "./builtin.js";
+
+export interface McpServerStatus {
+  name: string;
+  url: string;
+  source: string;
+  state: "connecting" | "connected" | "failed";
+  toolCount: number;
+  tools: Array<{ name: string; description: string }>;
+  error?: string;
+}
+
+let activeConnections: McpConnection[] = [];
+let allServers = new Map<string, McpServerStatus>();
+let connectPromise: Promise<void> | null = null;
+
+export function setupMcp(pi: ExtensionAPI) {
+  pi.on("session_start", (_event, ctx: ExtensionContext) => {
+    void (async () => {
+      await teardownMcp();
+
+      const configs = resolveMcpConfigs(ctx.cwd);
+      if (configs.length === 0) return;
+
+      // Initialise every target server as "connecting"
+      allServers = new Map(
+        configs.map((s) => [
+          s.name,
+          {
+            name: s.name,
+            url: s.url,
+            source: s.source,
+            state: "connecting" as const,
+            toolCount: 0,
+            tools: [],
+          },
+        ]),
+      );
+
+      connectPromise = Promise.all(
+        configs.map(async (server) => {
+          const conn = new McpConnection(server.name, server.url);
+          conn.source = server.source;
+
+          try {
+            await conn.connect();
+            activeConnections.push(conn);
+
+            for (const tool of conn.tools) {
+              const prefixedName = `${server.name}_${tool.name}`;
+              pi.registerTool({
+                name: prefixedName,
+                label: `MCP: ${tool.name}`,
+                description: tool.description,
+                promptSnippet: tool.description.slice(0, 120),
+                parameters: Type.Unsafe(tool.inputSchema as never),
+                execute: async (_toolCallId, params, _signal, _onUpdate, _ctx2) => {
+                  const text = await conn.callTool(
+                    tool.name,
+                    params as Record<string, unknown>,
+                  );
+                  return {
+                    content: [{ type: "text" as const, text }],
+                    isError: false,
+                    details: { server: server.name, tool: tool.name },
+                  };
+                },
+              });
+            }
+
+            allServers.set(server.name, {
+              name: server.name,
+              url: server.url,
+              source: server.source,
+              state: "connected",
+              toolCount: conn.tools.length,
+              tools: conn.tools.map((t) => ({ name: t.name, description: t.description })),
+            });
+          } catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            allServers.set(server.name, {
+              name: server.name,
+              url: server.url,
+              source: server.source,
+              state: "failed",
+              toolCount: 0,
+              tools: [],
+              error: msg,
+            });
+          }
+        }),
+      ).then(() => undefined);
+
+      await connectPromise;
+      connectPromise = null;
+    })();
+  });
+
+  pi.on("session_shutdown", () => {
+    void teardownMcp();
+  });
+}
+
+export function getMcpStatus(): McpServerStatus[] {
+  return [...allServers.values()];
+}
+
+async function teardownMcp(): Promise<void> {
+  await Promise.all(
+    activeConnections.map(async (conn) => {
+      try {
+        await conn.disconnect();
+      } catch {
+        // Silently ignore disconnect errors.
+      }
+    }),
+  );
+  activeConnections = [];
+  allServers = new Map();
+}

package/extensions/{extend-model.ts → model-integration.ts}

@@ -1,5 +1,5 @@
 /**
- * Extend Model — 模型 SDK
+ * Model Integration — 模型集成
  *
  * 对外接口:
  *   analyzeImage(model, base64, mediaType, apiKey, headers) → Promise<string>
@@ -22,13 +22,14 @@ import {
 } from "@earendil-works/pi-tui";
 import OpenAI from "openai";
 import { fileTypeFromFile } from "file-type";
-import type { Model } from "@earendil-works/pi-ai";
+import { isContextOverflow, type Model } from "@earendil-works/pi-ai";
 import {
   loadConfig, saveConfig, parseModelKey, formatModelKey,
   getImageModelKey, getCompactModelKey,
   setImageModelKey, setCompactModelKey,
 } from "./settings.js";
 import * as fs from "node:fs";
+import * as os from "node:os";
 import { extname, resolve } from "node:path";
 
 // ═══════════════════════════════════════════════════════════════════════════
@@ -349,15 +350,134 @@ function getConfiguredCompactModel(registry: any): Model<any> | null {
   return registry.find(parsed.provider, parsed.modelId) ?? null;
 }
 
+interface PiCompactionSettings {
+  enabled: boolean;
+  reserveTokens: number;
+}
+
+interface AutoCompactionCandidate {
+  messages: any[];
+  usage: { tokens: number | null; contextWindow: number } | undefined;
+}
+
+const DEFAULT_PI_COMPACTION_SETTINGS: PiCompactionSettings = {
+  enabled: true,
+  reserveTokens: 16_384,
+};
+
+function readJsonObject(filePath: string): any | undefined {
+  try {
+    if (!fs.existsSync(filePath)) return undefined;
+    const parsed = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+    return parsed && typeof parsed === "object" ? parsed : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+function loadPiCompactionSettings(cwd: string): PiCompactionSettings {
+  const globalSettings = readJsonObject(resolve(os.homedir(), ".pi", "agent", "settings.json"));
+  const projectSettings = readJsonObject(resolve(cwd, ".pi", "settings.json"));
+  const merged = {
+    ...DEFAULT_PI_COMPACTION_SETTINGS,
+    ...(globalSettings?.compaction ?? {}),
+    ...(projectSettings?.compaction ?? {}),
+  };
+  return {
+    enabled: merged.enabled !== false,
+    reserveTokens: typeof merged.reserveTokens === "number" ? merged.reserveTokens : DEFAULT_PI_COMPACTION_SETTINGS.reserveTokens,
+  };
+}
+
+function getLastAssistantMessage(messages: any[]): any | undefined {
+  for (let i = messages.length - 1; i >= 0; i--) {
+    if (messages[i]?.role === "assistant") return messages[i];
+  }
+  return undefined;
+}
+
+function shouldExpectAutoCompaction(
+  messages: any[],
+  usage: { tokens: number | null; contextWindow: number } | undefined,
+  settings: PiCompactionSettings,
+): boolean {
+  if (!settings.enabled) return false;
+
+  const lastAssistant = getLastAssistantMessage(messages);
+  if (!lastAssistant) return false;
+
+  const contextWindow = usage?.contextWindow ?? 0;
+  if (contextWindow > 0 && isContextOverflow(lastAssistant, contextWindow)) {
+    return true;
+  }
+
+  if (!usage || usage.tokens === null) return false;
+  return usage.tokens > usage.contextWindow - settings.reserveTokens;
+}
+
+function shouldAutoResumeCompaction(
+  prePromptCompactionPending: boolean,
+  postAgentEndCandidate: AutoCompactionCandidate | null,
+  settings: PiCompactionSettings,
+  customInstructions?: string,
+): boolean {
+  if (customInstructions !== undefined) return false;
+  if (prePromptCompactionPending) return true;
+  if (!postAgentEndCandidate) return false;
+  return shouldExpectAutoCompaction(postAgentEndCandidate.messages, postAgentEndCandidate.usage, settings);
+}
+
+export const __modelIntegrationTest = {
+  shouldExpectAutoCompaction,
+  shouldAutoResumeCompaction,
+};
+
 // ═══════════════════════════════════════════════════════════════════════════
 // 主入口（注册所有事件）
 // ═══════════════════════════════════════════════════════════════════════════
 
-export function setupExtendModel(pi: ExtensionAPI) {
+export function setupModelIntegration(pi: ExtensionAPI) {
   setupImageReadFallback(pi);
 
+  let prePromptCompactionPending = false;
+  let postAgentEndCandidate: AutoCompactionCandidate | null = null;
+  let currentCompactionIsAuto = false;
+
+  pi.on("input", () => {
+    prePromptCompactionPending = true;
+    postAgentEndCandidate = null;
+  });
+
+  pi.on("before_agent_start", () => {
+    prePromptCompactionPending = false;
+    postAgentEndCandidate = null;
+  });
+
+  pi.on("agent_start", () => {
+    prePromptCompactionPending = false;
+    postAgentEndCandidate = null;
+  });
+
+  pi.on("agent_end", (event, ctx) => {
+    prePromptCompactionPending = false;
+    postAgentEndCandidate = {
+      messages: event.messages,
+      usage: ctx.getContextUsage(),
+    };
+  });
+
   // 自定义压缩模型
   pi.on("session_before_compact", async (event, ctx) => {
+    const compactionSettings = loadPiCompactionSettings(ctx.cwd);
+    currentCompactionIsAuto = shouldAutoResumeCompaction(
+      prePromptCompactionPending,
+      postAgentEndCandidate,
+      compactionSettings,
+      event.customInstructions,
+    );
+    prePromptCompactionPending = false;
+    postAgentEndCandidate = null;
+
     const model = getConfiguredCompactModel(ctx.modelRegistry);
     if (!model) return; // 没配 → Pi 默认
 
@@ -394,8 +514,11 @@ export function setupExtendModel(pi: ExtensionAPI) {
     }
   });
 
-  // 压缩后自动继续
+  // 压缩后自动继续（仅自动压缩）
   pi.on("session_compact", () => {
+    const shouldResume = currentCompactionIsAuto;
+    currentCompactionIsAuto = false;
+    if (!shouldResume) return;
     pi.sendMessage({
       customType: "auto_compact_resume",
       content: "The context was just auto-compacted. Continue the current task based on the summary above. Do not repeat completed work. If unsure about progress, briefly summarize current state then continue.",