decorated-pi 0.5.5 → 0.7.0

package/settings.ts

@@ -0,0 +1,341 @@
+/**
+ * Settings — 配置读写（唯一写文件）
+ *
+ * 所有其他模块只通过此文件访问 decorated-pi.json
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as os from "node:os";
+import type { Model } from "@earendil-works/pi-ai";
+
+const CONFIG_DIR = path.join(os.homedir(), ".pi", "agent");
+const CONFIG_FILE = path.join(CONFIG_DIR, "decorated-pi.json");
+
+export interface ProviderModelEntry {
+  id: string;
+  name: string;
+  reasoning: boolean;
+  contextWindow: number;
+  maxTokens: number;
+  input: ("text" | "image")[];
+}
+
+export interface ProviderCache {
+  lastSynced?: string;
+  models: ProviderModelEntry[];
+}
+
+export interface McpServerEntry {
+  url?: string;
+  command?: string;
+  args?: string[];
+  env?: Record<string, string>;
+  enabled?: boolean;
+  description?: string;
+}
+
+export interface ModuleSettings {
+  tools?: {
+    /** Replace Pi native edit/write with the patch tool. */
+    patchOverrideEdit?: boolean;
+    /** Interactive ask tool for user clarification (blocks loop until answered). */
+    ask?: boolean;
+    /** Language server diagnostics, hover, definition, references, symbols, rename. */
+    lsp?: boolean;
+    /** MCP client with builtin servers (context7, exa, codegraph). */
+    mcp?: boolean;
+  };
+  hooks?: {
+    /** Redact secrets from read/bash output before model context. */
+    secretRedaction?: boolean;
+    /** Rewrite bash through system RTK when available. */
+    "rtk"?: boolean;
+    /** Send coding activity heartbeats to WakaTime. */
+    wakatime?: boolean;
+  };
+  commands?: {
+    /** Project-aware file search replacing default autocomplete. */
+    atOverride?: boolean;
+    /** /retry command to continue after interruption. */
+    retry?: boolean;
+    /** /usage command for token stats. */
+    usage?: boolean;
+  };
+}
+
+export interface UsageIndexEntry {
+  inode: number;
+  size: number;
+  mtime: number;
+}
+
+export interface DecoratedPiConfig {
+  imageModelKey?: string | null;
+  compactModelKey?: string | null;
+  providers?: Record<string, ProviderCache>;
+  modules?: ModuleSettings;
+  mcpServers?: Record<string, McpServerEntry>;
+  usageIndex?: Record<string, UsageIndexEntry>;
+}
+
+export function loadConfig(): DecoratedPiConfig {
+  try {
+    if (fs.existsSync(CONFIG_FILE)) {
+      const config = JSON.parse(fs.readFileSync(CONFIG_FILE, "utf-8")) as DecoratedPiConfig;
+      if (migrateModuleSettings(config)) {
+        saveConfig(config);
+      }
+      return config;
+    }
+  } catch {}
+  return {};
+}
+
+export function saveConfig(config: Partial<DecoratedPiConfig>) {
+  if (!fs.existsSync(CONFIG_DIR)) fs.mkdirSync(CONFIG_DIR, { recursive: true });
+  const current = loadConfig();
+  fs.writeFileSync(CONFIG_FILE, JSON.stringify({ ...current, ...config }, null, 2), "utf-8");
+}
+
+// ─── 辅助 ──────────────────────────────────────────────────────────────────
+
+export function formatModelKey(m: Model<any>): string {
+  return `${m.provider}/${m.id}`;
+}
+
+export function parseModelKey(key: string): { provider: string; modelId: string } | null {
+  const i = key.indexOf("/");
+  if (i === -1) return null;
+  return { provider: key.slice(0, i), modelId: key.slice(i + 1) };
+}
+
+// ─── Provider ────────────────────────────────────────────────────────────────
+
+export function loadProvider(name: string): ProviderCache | null {
+  return loadConfig().providers?.[name] ?? null;
+}
+
+export function saveProvider(name: string, data: ProviderCache) {
+  if (!fs.existsSync(CONFIG_DIR)) fs.mkdirSync(CONFIG_DIR, { recursive: true });
+  const current = loadConfig();
+  if (!current.providers) current.providers = {};
+  current.providers[name] = data;
+  fs.writeFileSync(CONFIG_FILE, JSON.stringify(current, null, 2) + "\n", "utf-8");
+}
+
+export function removeProvider(name: string) {
+  const current = loadConfig();
+  if (current.providers?.[name]) {
+    delete current.providers[name];
+    fs.writeFileSync(CONFIG_FILE, JSON.stringify(current, null, 2) + "\n", "utf-8");
+  }
+}
+
+// ─── Project-level config ────────────────────────────────────────────────
+
+function projectConfigPath(cwd: string): string {
+  return path.join(cwd, ".pi", "agent", "decorated-pi.json");
+}
+
+function loadProjectConfig(cwd: string): DecoratedPiConfig {
+  try {
+    const p = projectConfigPath(cwd);
+    if (fs.existsSync(p)) return JSON.parse(fs.readFileSync(p, "utf-8"));
+  } catch {}
+  return {};
+}
+
+function saveProjectConfig(cwd: string, partial: Partial<DecoratedPiConfig>) {
+  const p = projectConfigPath(cwd);
+  const dir = path.dirname(p);
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+  const current = loadProjectConfig(cwd);
+  fs.writeFileSync(p, JSON.stringify({ ...current, ...partial }, null, 2), "utf-8");
+}
+
+// ─── Getter ─────────────────────────────────────────────────────────────────
+
+export function getImageModelKey(): string | null {
+  return loadConfig().imageModelKey ?? null;
+}
+
+export function getCompactModelKey(): string | null {
+  return loadConfig().compactModelKey ?? null;
+}
+
+// ─── Setter ─────────────────────────────────────────────────────────────────
+
+export function setImageModelKey(key: string | null) {
+  saveConfig({ imageModelKey: key });
+}
+
+export function setCompactModelKey(key: string | null) {
+  saveConfig({ compactModelKey: key });
+}
+
+// ─── Module Switches ──────────────────────────────────────────────────────────
+
+const DEFAULT_MODULES: Required<ModuleSettings> = {
+  tools: {
+    patchOverrideEdit: true,
+    ask: true,
+    lsp: true,
+    mcp: true,
+  },
+  hooks: {
+    secretRedaction: true,
+    "rtk": true,
+    wakatime: true,
+  },
+  commands: {
+    atOverride: true,
+    retry: true,
+    usage: true,
+  },
+};
+
+/** Maps every module name to its category. Used by isModuleEnabled/setModuleEnabled. */
+const MODULE_TO_CATEGORY: Record<string, keyof ModuleSettings> = {
+  patchOverrideEdit: "tools",
+  ask: "tools",
+  lsp: "tools",
+  mcp: "tools",
+  secretRedaction: "hooks",
+  "rtk": "hooks",
+  wakatime: "hooks",
+  atOverride: "commands",
+  retry: "commands",
+  usage: "commands",
+};
+
+/** Legacy flat module keys that were renamed. Applied before flat→nested migration. */
+const LEGACY_MODULE_KEYS: Record<string, string> = {
+  patch: "patchOverrideEdit",
+  safety: "secretRedaction",
+};
+
+/**
+ * Migrate module settings to the nested tools/hooks/commands layout.
+ * Handles three legacy shapes:
+ *   1. Flat config with current names (patchOverrideEdit, secretRedaction, ...)
+ *   2. Flat config with old names (patch, safety)
+ *   3. Nested config with old inner names (tools.patch, hooks.safety)
+ * Already-correct nested configs are left untouched.
+ */
+function migrateModuleSettings(config: DecoratedPiConfig): boolean {
+  if (!config.modules) return false;
+
+  let migrated = false;
+  const result: ModuleSettings = {};
+
+  // Start from any already-nested values.
+  if (config.modules.tools) result.tools = { ...config.modules.tools };
+  if (config.modules.hooks) result.hooks = { ...config.modules.hooks };
+  if (config.modules.commands) result.commands = { ...config.modules.commands };
+
+  // Rename legacy keys inside already-nested categories.
+  function renameInCategory(
+    category: keyof ModuleSettings,
+    oldKey: string,
+    newKey: string,
+  ) {
+    const cat = result[category] as Record<string, boolean> | undefined;
+    if (cat && oldKey in cat && !(newKey in cat)) {
+      cat[newKey] = cat[oldKey];
+      delete cat[oldKey];
+      migrated = true;
+    }
+  }
+  renameInCategory("tools", "patch", "patchOverrideEdit");
+  renameInCategory("hooks", "safety", "secretRedaction");
+  renameInCategory("commands", "smart-at", "atOverride");
+
+  // Migrate flat keys into nested categories.
+  const flatMapping: Record<string, [keyof ModuleSettings, string]> = {
+    patchOverrideEdit: ["tools", "patchOverrideEdit"],
+    ask: ["tools", "ask"],
+    lsp: ["tools", "lsp"],
+    mcp: ["tools", "mcp"],
+    secretRedaction: ["hooks", "secretRedaction"],
+    "rtk": ["hooks", "rtk"],
+    wakatime: ["hooks", "wakatime"],
+    atOverride: ["commands", "atOverride"],
+    retry: ["commands", "retry"],
+    usage: ["commands", "usage"],
+    patch: ["tools", "patchOverrideEdit"],
+    safety: ["hooks", "secretRedaction"],
+    "smart-at": ["commands", "atOverride"],
+  };
+
+  for (const [key, value] of Object.entries(config.modules)) {
+    if (key === "tools" || key === "hooks" || key === "commands") continue;
+    const mapping = flatMapping[key];
+    if (!mapping) continue;
+    const [category, newKey] = mapping;
+    if (!result[category]) result[category] = {} as any;
+    const cat = result[category] as Record<string, boolean>;
+    if (!(newKey in cat)) {
+      cat[newKey] = value as boolean;
+    }
+    migrated = true;
+  }
+
+  if (!migrated) return false;
+  config.modules = result;
+  return true;
+}
+
+export function isModuleEnabled(name: string): boolean {
+  const category = MODULE_TO_CATEGORY[name];
+  if (!category) return true;
+  const modules = loadConfig().modules ?? {};
+  const cat = modules[category] as Record<string, boolean> | undefined;
+  const defaults = DEFAULT_MODULES[category] as Record<string, boolean>;
+  if (cat && name in cat) return cat[name];
+  return defaults[name] ?? true;
+}
+
+export function setModuleEnabled(name: string, enabled: boolean) {
+  const category = MODULE_TO_CATEGORY[name];
+  if (!category) return;
+  const modules: ModuleSettings = { ...loadConfig().modules };
+  modules[category] = { ...(modules[category] ?? {}), [name]: enabled } as any;
+  saveConfig({ modules });
+}
+
+export function getAllModuleSettings(): Required<ModuleSettings> {
+  const modules = loadConfig().modules ?? {};
+  return {
+    tools: { ...DEFAULT_MODULES.tools, ...modules.tools },
+    hooks: { ...DEFAULT_MODULES.hooks, ...modules.hooks },
+    commands: { ...DEFAULT_MODULES.commands, ...modules.commands },
+  };
+}
+
+/**
+ * Snapshot of the module settings that pi is currently running with.
+ * Captured once when the extension loads; /dp-settings compares the
+ * current effective settings against this snapshot to decide whether a
+ * reload is actually necessary.
+ */
+let loadedModuleSnapshot: Required<ModuleSettings> | null = null;
+
+export function captureModuleSnapshot(): void {
+  loadedModuleSnapshot = getAllModuleSettings();
+}
+
+export function moduleSnapshotChanged(): boolean {
+  if (!loadedModuleSnapshot) return true;
+  return JSON.stringify(loadedModuleSnapshot) !== JSON.stringify(getAllModuleSettings());
+}
+
+// ─── Usage index (增量同步元数据) ─────────────────────────────────────────────
+
+/** 缓存的上次同步状态: { 文件路径 → { inode, size, mtime } } */
+export function loadUsageIndex(): Record<string, UsageIndexEntry> {
+  return loadConfig().usageIndex ?? {};
+}
+
+export function saveUsageIndex(index: Record<string, UsageIndexEntry>) {
+  saveConfig({ usageIndex: index });
+}

package/tools/ask/index.ts

@@ -0,0 +1,93 @@
+/**
+ * ask — ask the user one or more questions and return their answers.
+ *
+ * Supports free text, single-choice, and multiple-choice questions.
+ * Uses a custom TUI component so multiple questions can be presented
+ * together and navigated with Tab / Shift+Tab.
+ */
+
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { Type } from "typebox";
+import { AskComponent, type AskAnswer, type AskQuestion } from "../../ui/ask.js";
+
+const askQuestionSchema = Type.Object({
+  id: Type.String({ description: "Unique identifier for this question in the result." }),
+  type: Type.Union(
+    [Type.Literal("text"), Type.Literal("single"), Type.Literal("multi")],
+    { description: "text = free input, single = one option, multi = many options" },
+  ),
+  question: Type.String({ description: "Question text shown to the user." }),
+  options: Type.Optional(Type.Array(Type.String(), { description: "Options for single or multi choice." })),
+  default: Type.Optional(Type.String({ description: "Default answer. For multi, comma-separated values." })),
+  allowCustom: Type.Optional(Type.Boolean({
+    description: "For single/multi: append an \"Other\" row that toggles into a free-text input. Lets the user enter a custom answer not in the preset list.",
+  })),
+});
+
+function formatAnswer(q: AskQuestion, value: string | string[]): string {
+  if (q.type === "text") return value as string;
+  if (q.type === "single") return value as string;
+  return (value as string[]).join(", ");
+}
+
+export function formatAnswers(questions: AskQuestion[], answers: { id: string; value: string | string[] }[]): string {
+  const lines: string[] = [];
+  for (const q of questions) {
+    const a = answers.find((x) => x.id === q.id);
+    if (!a) continue;
+    lines.push(`${q.question}: ${formatAnswer(q, a.value)}`);
+  }
+  return lines.join("\n");
+}
+
+export function registerAskTool(pi: ExtensionAPI): void {
+  pi.registerTool({
+    name: "ask",
+    label: "Ask user",
+    description: "Ask the user one or more questions and return their answers. Supports free text, single choice, and multiple choice. Use when you need clarification or a decision before continuing.",
+    promptSnippet: "Ask the user one or more clarifying questions",
+    promptGuidelines: [
+      "Before acting on a prompt, ensure you fully understand the user's intent — if ambiguous, ask clarifying questions using the ask tool.",
+    ],
+    parameters: Type.Object({
+      questions: Type.Array(askQuestionSchema, { minItems: 1, description: "Questions to ask. User navigates between them with Tab / Shift+Tab." }),
+    }),
+    execute: async (_id, params, _signal, _update, ctx) => {
+      if (!ctx.hasUI) {
+        return {
+          content: [{ type: "text", text: "ask tool requires an interactive UI session." }],
+          isError: true,
+          details: {},
+        };
+      }
+
+      // Validate options for single/multi.
+      for (const q of params.questions) {
+        if ((q.type === "single" || q.type === "multi") && (!q.options || q.options.length === 0)) {
+          return {
+            content: [{ type: "text", text: `Question "${q.id}" (${q.type}) requires at least one option.` }],
+            isError: true,
+            details: {},
+          };
+        }
+      }
+
+      const answers = await ctx.ui.custom<AskAnswer[] | undefined>(
+        (tui, theme, _kb, done) => new AskComponent(tui, theme, params.questions, done),
+      );
+
+      if (!answers) {
+        return {
+          content: [{ type: "text", text: "User cancelled the questions." }],
+          isError: false,
+          details: { cancelled: true },
+        };
+      }
+
+      return {
+        content: [{ type: "text", text: formatAnswers(params.questions, answers) }],
+        details: { answers },
+      };
+    },
+  });
+}

package/{extensions → tools}/lsp/client.ts

@@ -8,7 +8,6 @@ import {
 } from "./protocol.js";
 import type {
   LspDiagnostic,
-  LspDocumentSymbol,
   LspHover,
   LspLocation,
   LspPosition,
@@ -199,14 +198,6 @@ export class LspClient {
     );
   }
 
-  async documentSymbols(uri: string, timeoutMs?: number): Promise<LspDocumentSymbol[]> {
-    return normalizeDocumentSymbols(
-      await this.#request("textDocument/documentSymbol", {
-        textDocument: { uri },
-      }, timeoutMs),
-    );
-  }
-
   async rename(
     uri: string,
     position: LspPosition,
@@ -260,22 +251,6 @@ function normalizeLocations(result: unknown): LspLocation[] {
   });
 }
 
-function normalizeDocumentSymbols(result: unknown): LspDocumentSymbol[] {
-  if (!result || !Array.isArray(result) || result.length === 0) return [];
-  const first = result[0];
-  if ("range" in first && "selectionRange" in first) {
-    return result as LspDocumentSymbol[];
-  }
-  return result.map((entry: any) => ({
-    name: entry.name,
-    kind: entry.kind,
-    range: entry.location.range,
-    selectionRange: entry.location.range,
-    containerName: entry.containerName,
-    uri: entry.location.uri,
-  }));
-}
-
 function uriToPath(uri: string): string {
   try {
     return uri.startsWith("file:") ? new URL(uri).pathname : uri;

package/{extensions → tools}/lsp/format.ts

@@ -5,10 +5,10 @@
  * Runtime tools.ts has its own inline copies.
  */
 import { fileURLToPath } from "node:url";
-import type { LspDiagnostic, LspHover, LspLocation, LspDocumentSymbol } from "./types.js";
+import type { LspDiagnostic, LspHover, LspLocation } from "./types.js";
 import { LspClientStartError } from "./client.js";
 
-export type { LspDiagnostic, LspHover, LspLocation, LspDocumentSymbol } from "./types.js";
+export type { LspDiagnostic, LspHover, LspLocation } from "./types.js";
 export { LspClientStartError } from "./client.js";
 
 // ─── Error formatting ────────────────────────────────────────────────────
@@ -112,103 +112,6 @@ function fileUrlToPath(uri: string): string {
   try { return uri.startsWith("file:") ? fileURLToPath(uri) : uri; } catch { return uri; }
 }
 
-// ─── Symbols ──────────────────────────────────────────────────────────────
-
-const SYMBOL_KIND_LABELS: Record<number, string> = {
-  2: "module", 3: "namespace", 5: "class", 6: "method", 7: "property",
-  8: "field", 9: "constructor", 11: "interface", 12: "function",
-  13: "variable", 14: "constant", 23: "struct", 24: "event",
-};
-
-export function symbol_kind_label(kind: number): string {
-  return SYMBOL_KIND_LABELS[kind] ?? "symbol";
-}
-
-export function format_document_symbols(file: string, symbols: LspDocumentSymbol[]): string {
-  if (symbols.length === 0) return `${file}: no symbols`;
-  const lines = [`${file}: ${symbols.length} top-level symbol(s)`];
-  appendSymbols(lines, symbols, 1);
-  return lines.join("\n");
-}
-
-function appendSymbols(lines: string[], symbols: LspDocumentSymbol[], depth: number) {
-  for (const s of symbols) {
-    const indent = "  ".repeat(depth);
-    const detail = s.detail ? ` — ${s.detail}` : "";
-    const range = `${s.range.start.line + 1}:${s.range.start.character + 1}`;
-    lines.push(`${indent}${symbol_kind_label(s.kind)} ${s.name}${detail} @ ${range}`);
-    if (s.children?.length) appendSymbols(lines, s.children, depth + 1);
-  }
-}
-
-interface SymbolMatchOptions {
-  max_results: number;
-  top_level_only: boolean;
-  exact_match: boolean;
-  kinds: Set<string>;
-  language: string;
-}
-
-export interface SymbolMatch { symbol: LspDocumentSymbol; depth: number }
-
-export function find_symbol_matches(
-  symbols: LspDocumentSymbol[],
-  query: string,
-  options: SymbolMatchOptions,
-): SymbolMatch[] {
-  const normalized = query.trim().toLowerCase();
-  if (!normalized) return [];
-  const matches: SymbolMatch[] = [];
-  const expandName = (name: string): string[] => {
-    const trimmed = name.trim().toLowerCase();
-    if (!trimmed) return [];
-    const expanded = new Set([trimmed]);
-    if (options.language === "cpp" && trimmed.includes("::")) {
-      const parts = trimmed.split("::").map(p => p.trim()).filter(Boolean);
-      if (parts.length > 0) expanded.add(parts[parts.length - 1]!);
-    }
-    return [...expanded];
-  };
-
-  const matchesQuery = (s: LspDocumentSymbol): boolean => {
-    const name = s.name.trim().toLowerCase();
-    const detail = (s.detail ?? "").trim().toLowerCase();
-    if (options.exact_match) {
-      const exactValues = [...expandName(s.name), ...(detail ? [detail] : [])];
-      return exactValues.some(v => v === normalized);
-    }
-    return name.includes(normalized) || detail.includes(normalized);
-  };
-  const matchesKind = (s: LspDocumentSymbol): boolean =>
-    options.kinds.size === 0 || options.kinds.has(symbol_kind_label(s.kind));
-  const visit = (entries: LspDocumentSymbol[], depth: number) => {
-    for (const symbol of entries) {
-      if (matchesKind(symbol) && matchesQuery(symbol)) {
-        matches.push({ symbol, depth });
-        if (matches.length >= options.max_results) return;
-      }
-      if (!options.top_level_only && symbol.children?.length) {
-        visit(symbol.children, depth + 1);
-        if (matches.length >= options.max_results) return;
-      }
-    }
-  };
-  visit(symbols, 1);
-  return matches;
-}
-
-export function format_symbol_matches(file: string, query: string, matches: SymbolMatch[]): string {
-  if (matches.length === 0) return `${file}: no symbols matching "${query}"`;
-  const lines = [`${file}: ${matches.length} symbol match(es) for "${query}"`];
-  for (const { symbol, depth } of matches) {
-    const indent = "  ".repeat(depth);
-    const detail = symbol.detail ? ` — ${symbol.detail}` : "";
-    const range = `${symbol.range.start.line + 1}:${symbol.range.start.character + 1}`;
-    lines.push(`${indent}${symbol_kind_label(symbol.kind)} ${symbol.name}${detail} @ ${range}`);
-  }
-  return lines.join("\n");
-}
-
 // ─── Collapse (for tools test) ────────────────────────────────────────────
 
 export function collapse_lsp_text(text: string, maxLines = 20) {

package/{extensions → tools}/lsp/index.ts

@@ -1,7 +1,7 @@
 /**
  * LSP Extension — language server integration for Pi.
  *
- * Provides: lsp_diagnostics, lsp_document_symbols.
+ * Provides: lsp_diagnostics.
  */
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { LspServerManager } from "./manager.js";

package/{extensions → tools}/lsp/servers.ts

@@ -4,7 +4,7 @@
 import { existsSync, readdirSync, type Dirent } from "node:fs";
 import { spawnSync } from "node:child_process";
 import { dirname, extname, isAbsolute, join, resolve } from "node:path";
-import type { DependencyStatus } from "../rtk";
+import type { DependencyStatus } from "../../hooks/skeleton.js";
 
 // ─── File extension → language mapping ────────────────────────────────────