decorated-pi 0.5.4 → 0.6.0

package/extensions/index.ts

@@ -1,154 +0,0 @@
-/**
- * decorated-pi — Essential utilities for pi
- */
-
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-
-import { setupSafety } from "./safety/index.js";
-import { setupModelIntegration } from "./model-integration";
-import { setupSlash } from "./slash";
-import { setupSubdirAgents } from "./subdir-agents";
-import { setupSessionTitle } from "./session-title";
-import { setupIO } from "./io";
-import { setupLsp } from "./lsp/index";
-import { collectLspDependencyStatuses } from "./lsp/servers";
-import { setupProviders } from "./providers/index";
-import { getSmartAtDependencyStatuses, setupSmartAt } from "./smart-at";
-import { setupMcp } from "./mcp/index.js";
-import { collectMcpDependencyStatuses } from "./mcp/builtin";
-import { setupWakatime } from "./wakatime";
-import { findSystemRtk, getRtkDependencyStatuses, setupRtkIntegration, type DependencyStatus } from "./rtk";
-import { isModuleEnabled } from "./settings";
-
-function collectDependencyStatuses(cwd: string): DependencyStatus[] {
-  const statuses: DependencyStatus[] = [];
-  if (isModuleEnabled("rtk")) statuses.push(...getRtkDependencyStatuses());
-  if (isModuleEnabled("smart-at")) statuses.push(...getSmartAtDependencyStatuses(cwd));
-  if (isModuleEnabled("lsp")) statuses.push(...collectLspDependencyStatuses(cwd));
-  if (isModuleEnabled("mcp")) statuses.push(...collectMcpDependencyStatuses(cwd));
-  return statuses;
-}
-
-function formatDependencyLines(statuses: DependencyStatus[]): string[] {
-  const missing = statuses.filter((item) => item.state === "missing");
-  const grouped = new Map<string, string[]>();
-
-  for (const item of missing) {
-    const labels = grouped.get(item.module) ?? [];
-    labels.push(item.label);
-    grouped.set(item.module, labels);
-  }
-
-  const lines = ["[decorated-pi] missing dependencies:"];
-  for (const [module, labels] of grouped) {
-    lines.push(`  [${module}] ${labels.join(", ")}`);
-  }
-  return lines;
-}
-
-function setupDependencyReminders(pi: ExtensionAPI) {
-  let notifyTimer: ReturnType<typeof setTimeout> | undefined;
-
-  pi.on("session_start", async (event, ctx) => {
-    if (!ctx.hasUI) return;
-    if (event.reason !== "startup" && event.reason !== "reload") return;
-
-    const statuses = collectDependencyStatuses(ctx.cwd);
-    const missing = statuses.filter((item) => item.state === "missing");
-    if (missing.length === 0) return;
-
-    if (notifyTimer) clearTimeout(notifyTimer);
-    const message = formatDependencyLines(statuses).join("\n");
-
-    // Defer until after pi finishes startup/reload UI rebuild, otherwise
-    // notify() is appended to the chat and then wiped by rebuildChatFromMessages().
-    notifyTimer = setTimeout(() => {
-      notifyTimer = undefined;
-      try {
-        ctx.ui.notify(message, "info");
-      } catch {
-        // Extension context may be stale if another reload/session switch happened.
-      }
-    }, 0);
-  });
-
-  pi.on("session_shutdown", async () => {
-    if (!notifyTimer) return;
-    clearTimeout(notifyTimer);
-    notifyTimer = undefined;
-  });
-}
-
-const DECORATED_PI_GUIDANCE_MARKER = "## Decorated Pi Guidance";
-
-function setupGuidance(pi: ExtensionAPI) {
-  pi.on("before_agent_start", async (event) => {
-    // Remove "Current date: YYYY-MM-DD" from system prompt to improve cache stability
-    let prompt = event.systemPrompt.replace(/\nCurrent date: \d{4}-\d{2}-\d{2}/, "");
-
-    if (!prompt.includes(DECORATED_PI_GUIDANCE_MARKER)) {
-      const guidance = [
-        DECORATED_PI_GUIDANCE_MARKER,
-        "",
-        "- Before acting on a user's prompt, ensure you fully understand their needs. If the intent is ambiguous, ask clarifying questions. Proceed only when the intent is clear.",
-        "- Look before you leap! Ensure you have conducted thorough research before taking any action.",
-        "- Exercise caution when performing any **write** operations, especially when you are in a research or exploration phase.",
-        "- You don't need to read **AGENTS.md** or **CLAUDE.md** files unless you're explicitly asked to, these files will loaded automatically if neccessary.",
-        "- CAUTION: Do not perform write operations in the following directories unless explicitly instructed: `node_modules`, `venv`, `env`, `__pycache__`, `.git` or any other hidden directories.",
-        "",
-        "### Secret Redaction",
-        "",
-        "- When you see masked secret values (e.g. `sk-***...***` where `*`, `#`, or `?` are mask characters), the real value has been redacted by the system. Do not attempt to read or guess it. If you need the secret, use tools like `jq` or `grep` to extract it from the original source file.",
-      ].join("\n");
-
-      prompt = `${prompt}\n\n${guidance}`;
-    }
-
-    sortSystemPromptOptions(event.systemPromptOptions);
-    return { systemPrompt: prompt };
-  });
-}
-
-/** Sort all fields in systemPromptOptions alphabetically for stable system prompt. */
-export function sortSystemPromptOptions(opts: {
-  toolSnippets?: Record<string, string>;
-  selectedTools?: string[];
-  promptGuidelines?: string[];
-  skills?: Array<{ name: string; description: string; filePath: string }>;
-}) {
-  const sortedToolNames = Object.keys(opts.toolSnippets ?? {}).sort((a, b) => a.localeCompare(b));
-  const sortedToolSnippets: Record<string, string> = {};
-  for (const name of sortedToolNames) {
-    sortedToolSnippets[name] = opts.toolSnippets![name];
-  }
-  opts.toolSnippets = sortedToolSnippets;
-  if (opts.selectedTools) {
-    opts.selectedTools = sortedToolNames;
-  }
-  if (opts.promptGuidelines) {
-    opts.promptGuidelines = [...opts.promptGuidelines].sort((a, b) => a.localeCompare(b));
-  }
-  if (opts.skills) {
-    opts.skills = [...opts.skills].sort((a, b) => a.name.localeCompare(b.name));
-  }
-}
-
-export default function (pi: ExtensionAPI) {
-  // Always loaded — core commands and providers
-  setupSlash(pi);
-  setupProviders(pi);
-  setupModelIntegration(pi);
-  setupSubdirAgents(pi);
-  setupSessionTitle(pi);
-  setupGuidance(pi);
-  setupDependencyReminders(pi);
-
-  // Configurable modules
-  if (isModuleEnabled("patch")) setupIO(pi);
-  if (isModuleEnabled("safety")) setupSafety(pi);
-  if (isModuleEnabled("lsp")) setupLsp(pi);
-  if (isModuleEnabled("smart-at")) setupSmartAt(pi);
-  if (isModuleEnabled("mcp")) setupMcp(pi);
-  if (isModuleEnabled("wakatime")) setupWakatime(pi);
-  if (isModuleEnabled("rtk") && findSystemRtk()) setupRtkIntegration(pi);
-}

package/extensions/io-tool-output.ts

@@ -1,33 +0,0 @@
-/**
- * Shared tool-output externalization helpers.
- *
- * Used by `setupIO` (for read / bash) and `maybeExternalizeMcpResult` (for MCP tools).
- * Each writes to the same temp dir; MCP also adds a 2KB preview, while read / bash
- * emit a single-line placeholder.
- */
-import * as fs from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-import { randomBytes } from "node:crypto";
-
-export const TOOL_OUTPUT_TEMP_DIR = path.join(os.tmpdir(), "decorated-pi-results");
-
-/** Write content to a temp file under TOOL_OUTPUT_TEMP_DIR.
- *  Returns the file path, or undefined on failure (e.g., /tmp full). */
-export function writeOutputToTemp(
-  toolName: string,
-  toolCallId: string,
-  content: string,
-): string | undefined {
-  try {
-    if (!fs.existsSync(TOOL_OUTPUT_TEMP_DIR)) {
-      fs.mkdirSync(TOOL_OUTPUT_TEMP_DIR, { recursive: true });
-    }
-    const id = toolCallId ? toolCallId.slice(0, 12) : randomBytes(8).toString("hex");
-    const filePath = path.join(TOOL_OUTPUT_TEMP_DIR, `${toolName}-${id}.txt`);
-    fs.writeFileSync(filePath, content, "utf-8");
-    return filePath;
-  } catch {
-    return undefined;
-  }
-}

package/extensions/mcp/index.ts

@@ -1,435 +0,0 @@
-import { keyHint, type ExtensionAPI, type ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { Text } from "@earendil-works/pi-tui";
-import { McpConnection } from "./client.js";
-import {
-  resolveMcpConfigs,
-  loadMcpCache, updateServerCache, cleanupStaleCache,
-  maybeExternalizeMcpResult,
-  BUILTIN_MCP_SERVERS,
-  type McpServerConfig, type McpToolCache,
-} from "./builtin.js";
-
-export interface McpServerStatus {
-  name: string;
-  url: string;
-  source: string;
-  state: "connecting" | "connected" | "failed" | "disabled";
-  toolCount: number;
-  tools: Array<{ name: string; description?: string; inputSchema?: Record<string, unknown> }>;
-  error?: string;
-}
-
-let activeConnections: McpConnection[] = [];
-let allServers = new Map<string, McpServerStatus>();
-let cachedConfigs: McpServerConfig[] = [];
-let connectPromise: Promise<void> | null = null;
-let cachedCwd = "";
-
-const MCP_RESULT_FOLD_LINES = 45;
-
-function trimTrailingEmptyLines(lines: string[]): string[] {
-  let end = lines.length;
-  while (end > 0 && lines[end - 1] === "") end -= 1;
-  return lines.slice(0, end);
-}
-
-function collapseMcpText(text: string, maxLines = MCP_RESULT_FOLD_LINES) {
-  const lines = trimTrailingEmptyLines(text.split("\n"));
-  const totalLines = lines.length;
-  const displayLines = lines.slice(0, maxLines);
-  const remainingLines = Math.max(0, totalLines - maxLines);
-  return { totalLines, displayLines, remainingLines };
-}
-
-function getTextContent(result: { content?: Array<{ type: string; text?: string }> }): string {
-  return (result.content ?? [])
-    .filter((c): c is { type: "text"; text?: string } => c.type === "text")
-    .map((c) => c.text ?? "")
-    .join("\n");
-}
-
-function formatMcpResultText(text: string, expanded: boolean, theme: any): string {
-  const { totalLines, displayLines, remainingLines } = collapseMcpText(
-    text,
-    expanded ? Number.MAX_SAFE_INTEGER : MCP_RESULT_FOLD_LINES,
-  );
-  
-  // Check for externalization message in the last line
-  const lastLine = displayLines[displayLines.length - 1] || "";
-  let outputLines = [...displayLines];
-  let truncationMsg = "";
-  
-  if (lastLine.startsWith('[Truncated: ') && lastLine.endsWith(']')) {
-    truncationMsg = lastLine;
-    outputLines = outputLines.slice(0, -1);
-  }
-  
-  const outputText = outputLines.join("\n");
-  let rendered = outputText ? theme.fg("toolOutput", outputText) : "";
-  
-  if (truncationMsg) {
-    rendered += (rendered ? "\n" : "") + theme.fg("warning", truncationMsg);
-  }
-  
-  if (!expanded && remainingLines > 0) {
-    rendered += `${theme.fg("muted", `\n... (${remainingLines} more lines, ${totalLines} total,`)} ${keyHint("app.tools.expand", "to expand")})`;
-  }
-  return rendered;
-}
-
-function renderMcpResult(result: any, options: { expanded: boolean }, theme: any, context: any) {
-  const component = context.lastComponent ?? new Text("", 0, 0);
-  component.setText(formatMcpResultText(getTextContent(result), options.expanded, theme));
-  return component;
-}
-
-// ── config helpers ────────────────────────────────────────────────────────
-
-export function updateConfigEnabled(serverName: string, enabled: boolean): void {
-  const config = cachedConfigs.find(c => c.name === serverName);
-  if (config) config.enabled = enabled;
-  const server = allServers.get(serverName);
-  if (server) {
-    if (!enabled) {
-      // Stash the real connection state, set to disabled
-      server.state = "disabled";
-    } else {
-      // Re-enable: if there's still an active connection, restore it
-      const conn = activeConnections.find(c => c.serverName === serverName);
-      server.state = conn ? "connected" : "connecting";
-    }
-  }
-}
-
-// ── helpers ───────────────────────────────────────────────────────────────
-
-function makeToolName(serverName: string, toolName: string): string {
-  return `${serverName}_${toolName}`;
-}
-
-function makeToolLabel(serverName: string, toolName: string, desc?: string): string {
-  return `MCP ${serverName}: ${toolName}${desc ? ` (${desc.slice(0, 20)})` : ""}`;
-}
-
-// ── cache helpers ─────────────────────────────────────────────────────────
-
-function cacheScopeForSource(source: string): "global" | "project" {
-  return source === "project" ? "project" : "global";
-}
-
-// ── register cached tools ─────────────────────────────────────────────────
-
-function registerCachedToolsFromCache(
-  pi: ExtensionAPI,
-  cache: McpCache,
-  configs: McpServerConfig[]
-): void {
-  for (const config of configs) {
-    if (!config.enabled) continue;
-    const entry = cache.servers[config.name];
-    if (!entry || entry.tools.length === 0) continue;
-
-    for (const t of entry.tools) {
-      const toolName = makeToolName(config.name, t.name);
-      const desc = t.description || `${t.name} (MCP tool)`;
-      pi.registerTool({
-        name: toolName,
-        label: makeToolLabel(config.name, t.name, t.description),
-        description: desc,
-        promptSnippet: desc || `MCP tool ${config.name}/${t.name}`,
-        renderResult: renderMcpResult,
-        parameters: t.inputSchema,
-        execute: async (_id, params, _signal, _update, _ctx) => {
-          const conn = activeConnections.find(c => c.serverName === config.name);
-          if (!conn) {
-            // Tool is registered from cache before connectAll finishes. Tell the
-            // model to retry — connection is establishing in the background.
-            const status = allServers.get(config.name);
-            const state = status?.state ?? "connecting";
-            return {
-              content: [{ type: "text", text: `MCP server "${config.name}" is ${state}. Please retry shortly.` }],
-              isError: false,
-              details: {},
-            };
-          }
-          try {
-            const text = await conn.callTool(t.name, params as Record<string, unknown>);
-            return maybeExternalizeMcpResult(text, toolName, _id);
-          } catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            return {
-              content: [{ type: "text", text: `MCP call failed on "${config.name}/${t.name}": ${msg}` }],
-              isError: true,
-              details: {},
-            };
-          }
-        },
-      });
-    }
-  }
-}
-
-function registerCachedTools(pi: ExtensionAPI, configs: McpServerConfig[]): void {
-  const cache = loadMcpCache(cachedCwd);
-  if (!cache) return;
-  registerCachedToolsFromCache(pi, cache, configs);
-}
-
-// ── connect ───────────────────────────────────────────────────────────────
-
-async function connectAll(
-  configs: McpServerConfig[],
-  ui?: { notify: (msg: string, type: string) => void }
-): Promise<{ schemaChanges: string[]; hasNewServer: boolean }> {
-  // Load current cache for comparison
-  const cache = loadMcpCache(cachedCwd);
-  const schemaChanges: string[] = [];
-
-  allServers = new Map(
-    configs.map((s) => [
-      s.name,
-      {
-        name: s.name,
-        url: s.url ?? s.command ?? "(unknown)",
-        source: s.source,
-        state: "connecting" as const,
-        toolCount: 0,
-        tools: [],
-      },
-    ]),
-  );
-
-  connectPromise = Promise.all(
-    configs.map(async (server) => {
-      const conn = new McpConnection(server.name, server);
-      conn.source = server.source;
-
-      try {
-        await conn.connect(30_000);
-        activeConnections.push(conn);
-
-        const actualTools = conn.tools.map((t) => ({
-          name: t.name,
-          description: t.description,
-          inputSchema: t.inputSchema,
-        }));
-
-        // Check if schema changed
-        const cachedEntry = cache?.servers[server.name];
-        if (cachedEntry && cachedEntry.tools.length > 0) {
-          const cachedToolNames = new Set(cachedEntry.tools.map(t => t.name));
-          const actualToolNames = new Set(actualTools.map(t => t.name));
-          const added = actualTools.filter(t => !cachedToolNames.has(t.name));
-          const removed = cachedEntry.tools.filter(t => !actualToolNames.has(t.name));
-          const changed = actualTools.filter(t => {
-            const cached = cachedEntry.tools.find(ct => ct.name === t.name);
-            return cached && JSON.stringify(cached.inputSchema) !== JSON.stringify(t.inputSchema);
-          });
-
-          if (added.length > 0 || removed.length > 0 || changed.length > 0) {
-            const parts: string[] = [];
-            if (added.length) parts.push(`${added.length} added`);
-            if (removed.length) parts.push(`${removed.length} removed`);
-            if (changed.length) parts.push(`${changed.length} changed`);
-            schemaChanges.push(`${server.name} (${parts.join(', ')})`);
-          }
-        }
-
-        allServers.set(server.name, {
-          name: server.name,
-          url: server.url ?? server.command ?? "(unknown)",
-          source: server.source,
-          state: "connected",
-          toolCount: conn.tools.length,
-          tools: actualTools,
-        });
-
-        // Update cache with this server's tools
-        const tools: McpToolCache[] = conn.tools.map(t => ({
-          name: t.name,
-          description: t.description,
-          inputSchema: t.inputSchema,
-        }));
-        updateServerCache(
-          server.name,
-          { tools, cachedAt: Date.now() },
-          cacheScopeForSource(server.source),
-          cachedCwd || undefined,
-        );
-      } catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
-        allServers.set(server.name, {
-          name: server.name,
-          url: server.url ?? server.command ?? "(unknown)",
-          source: server.source,
-          state: "failed",
-          toolCount: 0,
-          tools: [],
-          error: msg,
-        });
-      }
-    }),
-  ).then(() => undefined);
-
-  await connectPromise;
-  connectPromise = null;
-
-  // Determine whether any server had no cached tools (first-time connection).
-  let hasNewServer = false;
-  for (const server of configs) {
-    const cachedEntry = cache?.servers[server.name];
-    if (!cachedEntry || cachedEntry.tools.length === 0) {
-      hasNewServer = true;
-      break;
-    }
-  }
-
-  return { schemaChanges, hasNewServer };
-}
-
-// ── setup ─────────────────────────────────────────────────────────────────
-
-export function setupMcp(pi: ExtensionAPI) {
-  pi.on("session_start", async (_event, ctx: ExtensionContext) => {
-    await teardownMcp();
-    cachedCwd = ctx.cwd;
-
-    const configs = resolveMcpConfigs(ctx.cwd).sort((a, b) => a.name.localeCompare(b.name));
-    cachedConfigs = configs;
-    if (configs.length === 0) return;
-
-    // Clean stale cache entries for removed servers
-    cleanupStaleCache(configs, cachedCwd);
-
-    const enabledConfigs = configs.filter(s => s.enabled);
-
-    // Load cache and register tools immediately (before connectAll)
-    const cache = loadMcpCache(cachedCwd);
-    if (cache) {
-      registerCachedToolsFromCache(pi, cache, enabledConfigs);
-    }
-
-    // Connect in background (fire-and-forget, don't block session_start)
-    void connectAll(enabledConfigs, ctx.hasUI ? ctx.ui : undefined).then(({ schemaChanges, hasNewServer }) => {
-      // Re-register tools when:
-      //   - A server was not in cache before (first connection)
-      //   - Schema changed (tools added/removed/changed)
-      if (hasNewServer || schemaChanges.length > 0) {
-        const cache = loadMcpCache(cachedCwd);
-        if (cache) {
-          registerCachedToolsFromCache(pi, cache, enabledConfigs);
-        }
-      }
-      if (schemaChanges.length > 0 && ctx.hasUI) {
-        ctx.ui.notify(`MCP schema updated: ${schemaChanges.join('; ')}.`, "info");
-      }
-    });
-  });
-
-  pi.on("session_shutdown", () => {
-    void teardownMcp();
-  });
-}
-
-export function getMcpStatus(): McpServerStatus[] {
-  const cache = loadMcpCache(cachedCwd);
-  const result: McpServerStatus[] = [];
-  for (const config of cachedConfigs) {
-    const connected = allServers.get(config.name);
-    if (connected) {
-      result.push(connected);
-    } else {
-      const cachedEntry = cache?.servers[config.name];
-      result.push({
-        name: config.name,
-        url: config.url ?? config.command ?? "(unknown)",
-        source: config.source,
-        state: config.enabled ? "connecting" : "disabled",
-        toolCount: cachedEntry?.tools.length ?? 0,
-        tools: cachedEntry?.tools ?? [],
-      });
-    }
-  }
-  return result;
-}
-
-// ── refresh single server cache ───────────────────────────────────────────
-
-export const __mcpIndexTest = { collapseMcpText };
-
-export async function refreshServerCache(
-  serverName: string,
-  registry: any,
-): Promise<{ ok: boolean; error?: string }> {
-  const config = resolveMcpConfigs(cachedCwd).find(s => s.name === serverName);
-  if (!config) return { ok: false, error: `Server "${serverName}" not found in config.` };
-
-  // Disconnect existing connection for this server
-  const existing = activeConnections.find(c => c.serverName === serverName);
-  if (existing) {
-    try { await existing.disconnect(); } catch { /* ignore */ }
-    activeConnections = activeConnections.filter(c => c.serverName !== serverName);
-  }
-
-  const conn = new McpConnection(config.name, config);
-  conn.source = config.source;
-
-  try {
-    await conn.connect(30_000);
-    activeConnections.push(conn);
-
-    allServers.set(config.name, {
-      name: config.name,
-      url: config.url ?? config.command ?? "(unknown)",
-      source: config.source,
-      state: "connected",
-      toolCount: conn.tools.length,
-      tools: conn.tools.map(t => ({
-        name: t.name,
-        description: t.description,
-        inputSchema: t.inputSchema,
-      })),
-    });
-
-    const tools: McpToolCache[] = conn.tools.map(t => ({
-      name: t.name,
-      description: t.description,
-      inputSchema: t.inputSchema,
-    }));
-    updateServerCache(
-      config.name,
-      { tools, cachedAt: Date.now() },
-      cacheScopeForSource(config.source),
-      cachedCwd || undefined,
-    );
-
-    return { ok: true };
-  } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    allServers.set(config.name, {
-      name: config.name,
-      url: config.url ?? config.command ?? "(unknown)",
-      source: config.source,
-      state: "failed",
-      toolCount: 0,
-      tools: [],
-      error: msg,
-    });
-    return { ok: false, error: msg };
-  }
-}
-
-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();
-  cachedConfigs = [];
-}