pi-ui-extend 0.1.1

package/external/pi-tools-suite/src/default-pi-tools-suite-config.ts

@@ -0,0 +1,355 @@
+// Default user config written when pi-tools-suite.jsonc is missing.
+export const DEFAULT_PI_TOOLS_SUITE_CONFIG_JSONC = `{
+  // Disable individual pi-tools-suite modules by uncommenting entries below.
+  // Later project config in .pi/pi-tools-suite.jsonc can re-enable modules.
+  "disabledModules": [
+    // "ast-grep",
+    // "async-subagents",
+    // "terminal-bell",
+    // "lsp",
+    // "repo-discovery",
+    // "antigravity-auth",
+    // "todo",
+    // "model-tools",
+    // "usage",
+    // "web-search",
+    // "compress"
+  ],
+
+  // Dynamic Context Pruning (DCP) / compress module config.
+  "dcp": {
+    "enabled": true,
+    "manualMode": {
+      "enabled": false,
+      "automaticStrategies": true
+    },
+    "compress": {
+      "minContextPercent": 0.25,
+      "nudgeFrequency": 1,
+      "iterationNudgeThreshold": 8
+    }
+  },
+
+  "asyncSubagents": {
+    "defaultType": "quick",
+    "routing": {
+      "enabled": true,
+      "model": "zai/glm-4.5-air",
+      "maxTaskChars": 1200,
+      "maxTokens": 512,
+      "maxRetries": 1,
+      "temperature": 0,
+      "timeoutMs": 12000,
+      "debug": false
+    },
+    "presets": {
+      "cheap": {
+        "description": "Use cheap GLM/Gemini Flash models for text/code roles; keep vision on the enabled GPT vision model.",
+        "types": {
+          "quick": {
+            "model": "zai/glm-4.5-air",
+            "thinking": "off"
+          },
+          "scan": {
+            "model": "zai/glm-4.5-air",
+            "thinking": "off"
+          },
+          "research": {
+            "model": "zai/glm-5-turbo",
+            "thinking": "low"
+          },
+          "docs": {
+            "model": "zai/glm-4.5-air",
+            "thinking": "low"
+          },
+          "frontend": {
+            "model": "antigravity/gemini-3-flash-preview",
+            "fallbackModels": [
+              "zai/glm-5.1"
+            ],
+            "thinking": "medium"
+          },
+          "tests": {
+            "model": "zai/glm-5-turbo",
+            "thinking": "medium"
+          },
+          "review": {
+            "model": "zai/glm-5.1",
+            "thinking": "high"
+          },
+          "implement": {
+            "model": "zai/glm-5.1",
+            "thinking": "high"
+          },
+          "deep": {
+            "model": "zai/glm-5.1",
+            "thinking": "high"
+          },
+          "vision": {
+            "model": "openai-codex/gpt-5.4-mini",
+            "thinking": "off"
+          }
+        }
+      },
+      "gpt": {
+        "description": "Prefer enabled GPT-family models: spark/mini for cheap roles, gpt-5.5 for heavy roles; fallback cross-provider on quota.",
+        "types": {
+          "quick": {
+            "model": "openai-codex/gpt-5.3-codex-spark",
+            "fallbackModels": [
+              "zai/glm-4.5-air"
+            ],
+            "thinking": "off"
+          },
+          "scan": {
+            "model": "openai-codex/gpt-5.3-codex-spark",
+            "fallbackModels": [
+              "zai/glm-4.5-air"
+            ],
+            "thinking": "off"
+          },
+          "research": {
+            "model": "openai-codex/gpt-5.4-mini",
+            "fallbackModels": [
+              "zai/glm-5-turbo"
+            ],
+            "thinking": "low"
+          },
+          "docs": {
+            "model": "openai-codex/gpt-5.3-codex-spark",
+            "fallbackModels": [
+              "zai/glm-4.5-air"
+            ],
+            "thinking": "low"
+          },
+          "frontend": {
+            "model": "antigravity/gemini-3-flash-preview",
+            "fallbackModels": [
+              "zai/glm-5.1"
+            ],
+            "thinking": "medium"
+          },
+          "tests": {
+            "model": "openai-codex/gpt-5.4-mini",
+            "fallbackModels": [
+              "zai/glm-5-turbo"
+            ],
+            "thinking": "medium"
+          },
+          "review": {
+            "model": "openai-codex/gpt-5.5",
+            "fallbackModels": [
+              "zai/glm-5.1"
+            ],
+            "thinking": "high"
+          },
+          "implement": {
+            "model": "openai-codex/gpt-5.5",
+            "fallbackModels": [
+              "zai/glm-5.1"
+            ],
+            "thinking": "high"
+          },
+          "deep": {
+            "model": "openai-codex/gpt-5.5",
+            "fallbackModels": [
+              "zai/glm-5.1"
+            ],
+            "thinking": "high"
+          },
+          "vision": {
+            "model": "openai-codex/gpt-5.4-mini",
+            "thinking": "off"
+          }
+        }
+      },
+      "deep": {
+        "description": "Use only enabled strong models, mixing GPT, Claude, and Gemini by role.",
+        "types": {
+          "quick": {
+            "model": "openai-codex/gpt-5.4-mini",
+            "fallbackModels": [
+              "zai/glm-4.5-air"
+            ],
+            "thinking": "low"
+          },
+          "scan": {
+            "model": "antigravity/gemini-3-flash-preview",
+            "fallbackModels": [
+              "openai-codex/gpt-5.3-codex-spark",
+              "zai/glm-4.5-air"
+            ],
+            "thinking": "off"
+          },
+          "research": {
+            "model": "antigravity/gemini-3.1-pro-preview",
+            "fallbackModels": [
+              "openai-codex/gpt-5.4-mini",
+              "zai/glm-5-turbo"
+            ],
+            "thinking": "medium"
+          },
+          "docs": {
+            "model": "antigravity/gemini-2.5-flash",
+            "fallbackModels": [
+              "openai-codex/gpt-5.3-codex-spark",
+              "zai/glm-4.5-air"
+            ],
+            "thinking": "medium"
+          },
+          "frontend": {
+            "model": "antigravity/gemini-3.1-pro-preview-customtools",
+            "fallbackModels": [
+              "zai/glm-5.1"
+            ],
+            "thinking": "low"
+          },
+          "tests": {
+            "model": "antigravity/antigravity-claude-sonnet-4-6",
+            "fallbackModels": [
+              "openai-codex/gpt-5.4-mini",
+              "zai/glm-5-turbo"
+            ],
+            "thinking": "high"
+          },
+          "review": {
+            "model": "antigravity/antigravity-claude-sonnet-4-6",
+            "fallbackModels": [
+              "openai-codex/gpt-5.5",
+              "zai/glm-5.1"
+            ],
+            "thinking": "high"
+          },
+          "implement": {
+            "model": "openai-codex/gpt-5.5",
+            "fallbackModels": [
+              "zai/glm-5.1"
+            ],
+            "thinking": "high"
+          },
+          "deep": {
+            "model": "antigravity/antigravity-claude-opus-4-6-thinking",
+            "fallbackModels": [
+              "openai-codex/gpt-5.5",
+              "zai/glm-5.1"
+            ],
+            "thinking": "high"
+          },
+          "vision": {
+            "model": "openai-codex/gpt-5.4-mini",
+            "thinking": "off"
+          }
+        }
+      }
+    },
+    "types": {
+      "quick": {
+        "description": "Use for tiny cheap tasks: answer a simple question, inspect one known file, or verify one fact. Not for broad repo search.",
+        "model": "zai/glm-5-turbo",
+        "thinking": "off"
+      },
+      "scan": {
+        "description": "Use for finding files, symbols, text, or inventory across a repo. Return paths/facts; do not judge code quality.",
+        "model": "zai/glm-5-turbo",
+        "thinking": "off",
+        "tools": [
+          "read",
+          "grep"
+        ]
+      },
+      "research": {
+        "description": "Use for multi-file codebase research: read several files and explain how something works. No edits.",
+        "model": "zai/glm-5-turbo",
+        "thinking": "low",
+        "tools": [
+          "read",
+          "grep"
+        ]
+      },
+      "docs": {
+        "description": "Use for documentation work: README/API docs review, docs gaps, changelog, migration notes, examples.",
+        "model": "zai/glm-5-turbo",
+        "thinking": "low"
+      },
+      "frontend": {
+        "description": "Use for frontend UI/UX visual work: styling, layout, typography, animation, responsive states, component polish, accessibility. Avoid backend/business logic unless needed for UI behavior.",
+        "model": "antigravity/gemini-3-flash-preview",
+        "fallbackModels": [
+          "openai-codex/gpt-5.4-mini",
+          "zai/glm-5.1"
+        ],
+        "thinking": "medium",
+        "promptAppend": [
+          "Act as a frontend UI/UX engineer for visual and product-facing work.",
+          "Prioritize layout, typography, spacing, color, motion, responsive states, accessibility, and consistency with the existing design system.",
+          "Before editing, inspect nearby components/styles and infer the project's design language. Avoid backend/business-logic changes unless required for UI behavior.",
+          "When no mockup exists, choose a clear aesthetic direction and explain it briefly. Verify with targeted build/lint/tests or screenshot-relevant checks when possible."
+        ]
+      },
+      "tests": {
+        "description": "Use for tests: locate coverage, find gaps, run/check targeted test commands, diagnose failing tests.",
+        "model": "zai/glm-5-turbo",
+        "thinking": "medium",
+        "tools": [
+          "read",
+          "grep",
+          "bash"
+        ]
+      },
+      "review": {
+        "description": "Use for review/audit of existing code or changes: correctness, security, performance, maintainability, API risks, quality. Do not implement new code.",
+        "model": "openai-codex/gpt-5.5",
+        "fallbackModels": [
+          "zai/glm-5.1"
+        ],
+        "thinking": "high",
+        "tools": [
+          "read",
+          "grep"
+        ]
+      },
+      "implement": {
+        "description": "Use when the sub-agent should make or plan code changes for a feature, bug fix, or refactor.",
+        "model": "openai-codex/gpt-5.5",
+        "fallbackModels": [
+          "zai/glm-5.1"
+        ],
+        "thinking": "high"
+      },
+      "deep": {
+        "description": "Use for broad hard reasoning: architecture, system design, cross-module impact, complex tradeoffs.",
+        "model": "openai-codex/gpt-5.5",
+        "fallbackModels": [
+          "zai/glm-5.1"
+        ],
+        "thinking": "high"
+      },
+      "vision": {
+        "description": "Use only when task has imagePaths, screenshots, or asks to inspect visible UI/image content for a text-only parent.",
+        "model": "openai-codex/gpt-5.4-mini",
+        "thinking": "off",
+        "promptAppend": [
+          "You are a vision helper for a parent model that may not be able to see images.",
+          "Inspect any attached images and any image paths mentioned in the task/scope. Describe concrete visible details, UI state, text, layout, errors, and uncertainties.",
+          "If focus instructions are provided, prioritize them, but still mention other important visible findings.",
+          "Do not make code changes. Return a compact visual description that the parent agent can rely on."
+        ]
+      }
+    }
+  },
+
+  // Compact tool-renderer preview policy and name colors by tool name.
+  // direction=head keeps the first lines; direction=tail keeps the last lines.
+  // color accepts a Pi theme color name or a #rrggbb RGB literal. Tool entries
+  // override default and can also set compactHidden.
+  "toolRenderer": {},
+
+  "promptCommands": {
+    "commands": {
+      "commit": {
+        "prompt": "Commit all changes"
+      }
+    }
+  }
+}
+`;

package/external/pi-tools-suite/src/index.ts

@@ -0,0 +1,46 @@
+import { loadPiToolsSuiteConfig } from "./config";
+import { publishStartupModuleList } from "./startup-section";
+
+type ExtensionAPI = any;
+
+type ExtensionFactory = (pi: ExtensionAPI) => void | Promise<void>;
+
+type ExtensionModule = {
+	default: ExtensionFactory;
+};
+
+const MODULES: Array<{ name: string; load: () => Promise<ExtensionModule> }> = [
+	{ name: "ast-grep", load: () => import("./ast-grep/index") },
+	{ name: "async-subagents", load: () => import("./async-subagents/index") },
+	{ name: "terminal-bell", load: () => import("./terminal-bell/index") },
+	{ name: "lsp", load: () => import("./lsp/index") },
+	{ name: "repo-discovery", load: () => import("./repo-discovery/index") },
+	{ name: "antigravity-auth", load: () => import("./antigravity-auth/index") },
+	{ name: "todo", load: () => import("./todo/index") },
+	{ name: "model-tools", load: () => import("./model-tools/index") },
+	{ name: "usage", load: () => import("./usage/index") },
+	{ name: "web-search", load: () => import("./web-search/index") },
+	{ name: "compress", load: () => import("./compress/index") },
+	{ name: "prompt-commands", load: () => import("./prompt-commands/index") },
+];
+
+export default async function piToolsSuite(pi: ExtensionAPI) {
+	const loadedModuleNames: string[] = [];
+	const config = loadPiToolsSuiteConfig(MODULES.map((module) => module.name));
+	const disabledModules = new Set(config.enabled ? config.disabledModules : MODULES.map((module) => module.name));
+
+	for (const module of MODULES) {
+		if (disabledModules.has(module.name)) continue;
+
+		try {
+			const loaded = await module.load();
+			await loaded.default(pi);
+			loadedModuleNames.push(module.name);
+		} catch (error) {
+			const message = error instanceof Error ? error.stack ?? error.message : String(error);
+			throw new Error(`Failed to load pi-tools-suite module ${module.name}: ${message}`);
+		}
+	}
+
+	await publishStartupModuleList(loadedModuleNames);
+}

package/external/pi-tools-suite/src/lib/lsp.ts

@@ -0,0 +1,62 @@
+import type { AgentToolResult, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { existsSync } from "node:fs";
+import { toAbsolutePath } from "../lsp/_shared/paths.js";
+import { getGlobalLspManager } from "../lsp/manager.js";
+import { getEventPaths, isMutationToolResult } from "../lsp/mutation-events.js";
+
+export type LspEnrichableToolResult<TDetails = unknown> = AgentToolResult<TDetails>;
+
+export type LspMutationToolResultInput<TDetails = unknown> = {
+  toolName: string;
+  input: unknown;
+  result: LspEnrichableToolResult<TDetails>;
+  ctx: ExtensionContext;
+  isError?: boolean;
+};
+
+function textContent(text: string): AgentToolResult<unknown>["content"][number] {
+  return { type: "text", text };
+}
+
+function hasLspDiagnosticsContent(result: LspEnrichableToolResult): boolean {
+  return result.content.some((part) => typeof (part as { text?: unknown }).text === "string" && (part as { text: string }).text.includes("LSP diagnostics:"));
+}
+
+function isMissingFileError(error: unknown): boolean {
+  return (error as { code?: unknown })?.code === "ENOENT" || String((error as Error)?.message ?? error).includes("ENOENT");
+}
+
+export async function appendLspDiagnosticsToMutationResult<T extends LspEnrichableToolResult>(options: LspMutationToolResultInput<T["details"]> & { result: T }): Promise<T> {
+  if (options.isError || !isMutationToolResult({ toolName: options.toolName, input: options.input, details: options.result.details })) return options.result;
+  if (hasLspDiagnosticsContent(options.result)) return options.result;
+
+  try {
+    const files = [...new Set(getEventPaths(options.input, options.result.details).map((inputPath) => toAbsolutePath(inputPath, options.ctx.cwd)))].filter((file) => existsSync(file));
+    if (files.length === 0) return options.result;
+
+    const manager = getGlobalLspManager();
+    const summaries: string[] = [];
+    for (const file of files) {
+      const summary = await manager.updateDiagnosticsForFile(options.ctx, file);
+      if (summary.trim()) summaries.push(summary);
+    }
+
+    const summary = summaries.join("\n\n");
+    if (!summary.trim()) return options.result;
+
+    return {
+      ...options.result,
+      content: [...options.result.content, textContent(summary)],
+    };
+  } catch (error) {
+    if (isMissingFileError(error)) return options.result;
+    return {
+      ...options.result,
+      content: [...options.result.content, textContent(`LSP diagnostics:\n\n⚠️ lsp: ${(error as Error).message}`)],
+    };
+  }
+}
+
+export async function shutdownGlobalLspManager(): Promise<void> {
+  await getGlobalLspManager().shutdownAll();
+}

package/external/pi-tools-suite/src/lib/project.ts

@@ -0,0 +1,42 @@
+import { existsSync, statSync } from "node:fs";
+import path from "node:path";
+
+export function directoryExists(file: string): boolean {
+	try {
+		return existsSync(file) && statSync(file).isDirectory();
+	} catch {
+		return false;
+	}
+}
+
+export function fileExists(file: string): boolean {
+	try {
+		return existsSync(file) && statSync(file).isFile();
+	} catch {
+		return false;
+	}
+}
+
+export function findProjectRoot(cwd: string): string {
+	let dir = path.resolve(cwd);
+	let packageRoot: string | undefined;
+
+	while (true) {
+		if (directoryExists(path.join(dir, ".indexer-cli"))) return dir;
+		if (directoryExists(path.join(dir, ".git"))) return dir;
+		if (!packageRoot && fileExists(path.join(dir, "package.json"))) packageRoot = dir;
+
+		const parent = path.dirname(dir);
+		if (parent === dir) return packageRoot ?? path.resolve(cwd);
+		dir = parent;
+	}
+}
+
+export function findIndexedProjectRoot(cwd: string): string | undefined {
+	const projectRoot = findProjectRoot(cwd);
+	return directoryExists(path.join(projectRoot, ".indexer-cli")) ? projectRoot : undefined;
+}
+
+export function hasIndexedProjectRoot(cwd: string = process.cwd()): boolean {
+	return findIndexedProjectRoot(cwd) !== undefined;
+}

package/external/pi-tools-suite/src/lib/tool-args.ts

@@ -0,0 +1,137 @@
+export type ModelProfile = "claude" | "codex";
+
+export function detectModelProfile(model: unknown): ModelProfile {
+  if (typeof model === "string") return detectModelProfileFromText(model);
+  if (!model || typeof model !== "object") return "claude";
+  const record = model as Record<string, unknown>;
+  const values = [record.provider, record.id, record.name]
+    .filter((value): value is string => typeof value === "string")
+    .join(" ");
+
+  return detectModelProfileFromText(values);
+}
+
+function detectModelProfileFromText(value: string): ModelProfile {
+  const values = value.toLowerCase();
+
+  if (
+    values.includes("codex") ||
+    values.includes("gpt") ||
+    /\bo\d/.test(values) ||
+    values.includes("openai")
+  ) {
+    return "codex";
+  }
+  return "claude";
+}
+
+const CLAUDE_TOOL_ALIASES: Record<string, string | undefined> = {
+  read: "Read",
+  Read: "Read",
+  edit: "Edit",
+  Edit: "Edit",
+  write: "Write",
+  Write: "Write",
+  bash: "Bash",
+  Bash: "Bash",
+  shell_command: "Bash",
+  shell: "Bash",
+  grep: "Grep",
+  Grep: "Grep",
+  find: "Glob",
+  ls: "Glob",
+  LS: "Glob",
+  glob: "Glob",
+  Glob: "Glob",
+};
+
+const CODEX_TOOL_ALIASES: Record<string, string | undefined> = {
+  read: "read",
+  Read: "read",
+  bash: "shell",
+  Bash: "shell",
+  shell_command: "shell",
+  shell: "shell",
+  edit: "apply_patch",
+  Edit: "apply_patch",
+  write: "apply_patch",
+  Write: "apply_patch",
+  apply_patch: "apply_patch",
+  grep: "shell",
+  Grep: "shell",
+  find: "shell",
+  ls: "shell",
+  LS: "shell",
+  glob: "shell",
+  Glob: "shell",
+};
+
+export function selectSuitableToolsForModel(model: unknown, tools: readonly string[]): string[] {
+  const aliases = detectModelProfile(model) === "codex" ? CODEX_TOOL_ALIASES : CLAUDE_TOOL_ALIASES;
+  const selected: string[] = [];
+  for (const tool of tools) {
+    const name = typeof tool === "string" ? tool.trim() : "";
+    if (!name) continue;
+    const mapped = aliases[name];
+    if (mapped && !selected.includes(mapped)) selected.push(mapped);
+  }
+  return selected;
+}
+
+export function toReadArgs(input: { file_path?: string; path?: string; offset?: number; limit?: number }) {
+  return { path: input.file_path ?? input.path ?? "", offset: input.offset, limit: input.limit };
+}
+
+export function toEditArgs(input: {
+  file_path?: string;
+  path?: string;
+  old_string?: string;
+  new_string?: string;
+  replace_all?: boolean;
+}) {
+  return {
+    path: input.file_path ?? input.path ?? "",
+    edits: [{ oldText: input.old_string ?? "", newText: input.new_string ?? "" }],
+  };
+}
+
+export function toWriteArgs(input: { file_path?: string; path?: string; content?: string }) {
+  return { path: input.file_path ?? input.path ?? "", content: input.content ?? "" };
+}
+
+export function toGrepArgs(input: {
+  pattern: string;
+  path?: string;
+  glob?: string;
+  case_sensitive?: boolean;
+  regex?: boolean;
+  before_context?: number;
+  after_context?: number;
+  context?: number;
+  limit?: number;
+  max_count?: number;
+}) {
+  const before = input.before_context ?? 0;
+  const after = input.after_context ?? 0;
+  return {
+    pattern: input.pattern,
+    path: input.path,
+    glob: input.glob,
+    ignoreCase: input.case_sensitive === undefined ? undefined : !input.case_sensitive,
+    literal: input.regex === undefined ? undefined : !input.regex,
+    context: input.context ?? (Math.max(before, after) || undefined),
+    limit: input.limit ?? input.max_count,
+  };
+}
+
+export function toShellCommand(input: { command?: string }) {
+  return (input.command ?? "").trim();
+}
+
+export function prepareApplyPatchArgs(args: unknown): { input: string } {
+  if (typeof args === "string") return { input: args };
+  if (!args || typeof args !== "object") return { input: "" };
+  const record = args as Record<string, unknown>;
+  const input = record.input ?? record.patch;
+  return { input: typeof input === "string" ? input : "" };
+}