moonpi 0.4.4 → 0.4.5

package/README.md

@@ -182,6 +182,16 @@ Example output:
 
 At startup, a notification shows which files are currently selected for injection.
 
+### `/context:clear`
+
+Deselects all currently active context files (both `/pick`-selected and auto-discovered). After clearing, no files are injected into the prompt until you run `/pick` again.
+
+Example output:
+
+```
+Cleared context file selection (3 file(s) deselected). Use /pick to select files.
+```
+
 ## Custom Providers
 
 moonpi includes the support from some custom providers, and provides slash commands to manage custom providers in `~/.pi/agent/models.json`.
@@ -207,6 +217,23 @@ Use `/model` to select a `synthetic` model. Use `/synthetic:quotas` to show your
 
 ![Synthetic quotas output](assets/screenshots/moonpi-syn.png)
 
+#### Web Search
+
+When authenticated with Synthetic, moonpi makes a `web_search` tool available to the agent. This tool uses the [Synthetic search API](https://docs.synthetic.new) to perform zero-data-retention web searches and return results with title, URL, published date, and text excerpt.
+
+The tool is **only visible to the LLM when logged in with Synthetic** — it is not registered at all when no API key is configured, so the model never sees it or knows it exists.
+
+To disable the search tool even when logged in, set `synthetic.search.enabled` to `false` in your config:
+
+```json
+{
+  "synthetic": {
+    "search": {
+      "enabled": false
+    }
+  }
+}
+```
 
 ### Managing Custom Providers
 
@@ -334,6 +361,11 @@ Configure `.pi/moonpi.json` (project) or `~/.pi/agent/moonpi.json` (global):
   "defaultMode": "auto",
   "preserveExternalTools": false,
   "customEditor": true,
+  "synthetic": {
+    "search": {
+      "enabled": true
+    }
+  },
   "contextFiles": {
     "enabled": true,
     "fileNames": ["README.md", "SPECS.md", "SPRINT.md"],
@@ -373,6 +405,12 @@ Configure `.pi/moonpi.json` (project) or `~/.pi/agent/moonpi.json` (global):
 | `preserveExternalTools` | `false` | When `true`, tools registered by other extensions are kept alongside moonpi tools when applying mode tool restrictions |
 | `customEditor` | `true` | When `false`, moonpi skips installing its mode-colored editor, preserving editor customizations from other extensions |
 
+#### Synthetic
+
+| Field | Default | Description |
+| --- | --- | --- |
+| `synthetic.search.enabled` | `true` | When `false`, the `web_search` tool is not registered even if logged in with Synthetic |
+
 #### Keybindings
 
 | Field | Default | Description |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "moonpi",
-  "version": "0.4.4",
+  "version": "0.4.5",
   "description": "Opinionated set of extensions for pi",
   "type": "module",
   "main": "./src/index.ts",

package/src/config.ts

@@ -42,6 +42,11 @@ export const DEFAULT_CONFIG: MoonpiConfig = {
   defaultMode: "auto",
   preserveExternalTools: true,
   customEditor: true,
+  synthetic: {
+    search: {
+      enabled: true,
+    },
+  },
   contextFiles: {
     enabled: true,
     fileNames: ["README.md", "SPECS.md", "SPRINT.md"],
@@ -125,6 +130,7 @@ function mergeConfig(base: MoonpiConfig, raw: Record<string, unknown> | undefine
     defaultMode: base.defaultMode,
     preserveExternalTools: base.preserveExternalTools,
     customEditor: base.customEditor,
+    synthetic: { ...base.synthetic },
     contextFiles: { ...base.contextFiles },
     guards: { ...base.guards },
     keybindings: { ...base.keybindings },
@@ -134,6 +140,14 @@ function mergeConfig(base: MoonpiConfig, raw: Record<string, unknown> | undefine
   if (typeof raw.preserveExternalTools === "boolean") next.preserveExternalTools = raw.preserveExternalTools;
   if (typeof raw.customEditor === "boolean") next.customEditor = raw.customEditor;
 
+  if (isRecord(raw.synthetic)) {
+    if (isRecord(raw.synthetic.search)) {
+      if (typeof raw.synthetic.search.enabled === "boolean") {
+        next.synthetic.search.enabled = raw.synthetic.search.enabled;
+      }
+    }
+  }
+
   if (isRecord(raw.contextFiles)) {
     const context = raw.contextFiles;
     if (typeof context.enabled === "boolean") next.contextFiles.enabled = context.enabled;

package/src/context-files.ts

@@ -484,6 +484,21 @@ export function installContextFiles(pi: ExtensionAPI, controller: MoonpiControll
     },
   });
 
+  pi.registerCommand("context:clear", {
+    description: "Deselect all context files (clear /pick and auto-discovered files)",
+    handler: async (_args, ctx) => {
+      if (!controller.config.contextFiles.enabled) {
+        ctx.ui.notify("moonpi context file injection is disabled in /moonpi:settings.", "warning");
+        return;
+      }
+
+      const previousCount = getEffectiveSelectedContextFilePaths(ctx.cwd, controller).length;
+      controller.state.selectedContextFilePaths = [];
+      controller.persist();
+      ctx.ui.notify(`Cleared context file selection (${previousCount} file(s) deselected). Use /pick to select files.`, "info");
+    },
+  });
+
   pi.on("session_start", async (_event, ctx) => {
     controller.restoreFromSession(ctx);
     const discovery = controller.state.selectedContextFilePaths === undefined ? findDefaultContextFilePaths(ctx.cwd, controller) : undefined;

package/src/index.ts

@@ -140,7 +140,7 @@ ${todoList}`);
 
   // Synthetic is optional; keep core Moonpi mode hooks installed even if provider setup fails.
   try {
-    await installSynthetic(pi);
+    await installSynthetic(pi, controller);
   } catch {
     // Ignore optional provider setup failures.
   }

package/src/modes.ts

@@ -40,6 +40,7 @@ function latestSnapshot(entries: SessionEntry[]): MoonpiSnapshot | undefined {
 export class MoonpiController {
   readonly state = new MoonpiState();
   config: MoonpiConfig = loadMoonpiConfig(process.cwd());
+  syntheticAuthenticated = false;
   private terminalInputUnsubscribe: (() => void) | undefined;
 
   constructor(private readonly pi: ExtensionAPI) {}
@@ -144,9 +145,14 @@ export class MoonpiController {
   }
 
   getToolsForCurrentMode(): string[] {
-    if (!this.config.preserveExternalTools) return STABLE_MOONPI_TOOLS;
-    const externalTools = this.pi.getActiveTools().filter((toolName) => !MOONPI_TOOL_NAMES.has(toolName));
-    return [...new Set([...STABLE_MOONPI_TOOLS, ...externalTools])];
+    let tools = this.config.preserveExternalTools
+      ? [...new Set([...STABLE_MOONPI_TOOLS, ...this.pi.getActiveTools().filter((toolName) => !MOONPI_TOOL_NAMES.has(toolName))])]
+      : [...STABLE_MOONPI_TOOLS];
+
+    if (this.syntheticAuthenticated && this.config.synthetic.search.enabled) {
+      tools.push("web_search");
+    }
+    return tools;
   }
 
   buildModePrompt(): string {

package/src/synthetic.ts

@@ -1,4 +1,7 @@
 import type { ExtensionAPI, ExtensionCommandContext, ExtensionContext, ProviderModelConfig } from "@mariozechner/pi-coding-agent";
+import { Text } from "@mariozechner/pi-tui";
+import { Type, type Static } from "typebox";
+import type { MoonpiController } from "./modes.js";
 import { SYNTHETIC_MODELS_FALLBACK, mergeWithFallback, parseSyntheticModels, readCachedModels, writeCachedModels } from "./synthetic-models.js";
 
 const SYNTHETIC_PROVIDER = "synthetic";
@@ -6,6 +9,7 @@ const SYNTHETIC_API_KEY_ENV = "SYNTHETIC_API_KEY";
 const SYNTHETIC_OPENAI_BASE_URL = "https://api.synthetic.new/openai/v1";
 const SYNTHETIC_MODELS_URL = "https://api.synthetic.new/openai/v1/models";
 const SYNTHETIC_QUOTAS_URL = "https://api.synthetic.new/v2/quotas";
+const SYNTHETIC_SEARCH_URL = "https://api.synthetic.new/v2/search";
 const FETCH_TIMEOUT_MS = 15_000;
 
 type QuotasErrorKind = "cancelled" | "timeout" | "config" | "http" | "network";
@@ -238,6 +242,155 @@ async function getSyntheticApiKey(ctx: ExtensionCommandContext | ExtensionContex
   return storedKey ?? process.env[SYNTHETIC_API_KEY_ENV] ?? "";
 }
 
+// =========================================================================
+// Search API
+// =========================================================================
+
+interface SearchResult {
+  url: string;
+  title: string;
+  text: string;
+  published?: string;
+}
+
+interface SearchResponse {
+  results: SearchResult[];
+}
+
+const SearchParamsSchema = Type.Object({
+  query: Type.String({ description: "Search query" }),
+});
+
+type SearchParams = Static<typeof SearchParamsSchema>;
+
+interface SearchDetails {
+  query: string;
+  resultCount: number;
+}
+
+function formatSearchResults(query: string, results: SearchResult[]): string {
+  if (results.length === 0) {
+    return `No results found for "${query}".`;
+  }
+
+  const lines: string[] = [`Found ${results.length} result${results.length === 1 ? "" : "s"} for "${query}":\n`];
+
+  for (let i = 0; i < results.length; i++) {
+    const result = results[i]!;
+    const num = i + 1;
+    lines.push(`${num}. **${result.title}**`);
+    lines.push(`   ${result.url}`);
+    if (result.published) {
+      try {
+        const date = new Date(result.published);
+        if (!Number.isNaN(date.getTime())) {
+          lines.push(`   Published: ${date.toISOString().split("T")[0]}`);
+        }
+      } catch {
+        // Skip unparseable dates
+      }
+    }
+    lines.push(`   ${result.text}`);
+    lines.push("");
+  }
+
+  return lines.join("\n");
+}
+
+function registerSearchTool(pi: ExtensionAPI): void {
+  pi.registerTool<typeof SearchParamsSchema, SearchDetails>({
+    name: "web_search",
+    label: "web search",
+    description:
+      "Search the web using the Synthetic search API. Returns a list of results with title, URL, and text excerpt.",
+    promptSnippet: "Search the web for information",
+    promptGuidelines: [
+      "Use web_search when you need to find information on the web that you don't already know.",
+      "Prefer web_search over guessing URLs or making assumptions about external documentation.",
+    ],
+    parameters: SearchParamsSchema,
+    async execute(_toolCallId, params: SearchParams, signal, _onUpdate, ctx) {
+      const apiKey = await getSyntheticApiKey(ctx);
+      if (!apiKey) {
+        return {
+          content: [{ type: "text", text: "Error: Synthetic API key not available. Please re-authenticate with /login synthetic." }],
+          details: { query: params.query, resultCount: 0 } satisfies SearchDetails,
+        };
+      }
+
+      const signals = [AbortSignal.timeout(FETCH_TIMEOUT_MS)];
+      if (signal) signals.push(signal);
+      const combinedSignal = AbortSignal.any(signals);
+
+      try {
+        const response = await fetch(SYNTHETIC_SEARCH_URL, {
+          method: "POST",
+          headers: {
+            Authorization: `Bearer ${apiKey}`,
+            "Content-Type": "application/json",
+            "X-Title": "moonpi",
+          },
+          body: JSON.stringify({ query: params.query }),
+          signal: combinedSignal,
+        });
+
+        if (!response.ok) {
+          let message = response.statusText;
+          const body = await response.text();
+          if (body.length > 0) {
+            try {
+              const parsed = JSON.parse(body) as { error?: unknown; message?: unknown };
+              if (typeof parsed.error === "string") message = parsed.error;
+              else if (typeof parsed.message === "string") message = parsed.message;
+              else message = body;
+            } catch {
+              message = body;
+            }
+          }
+          return {
+            content: [{ type: "text", text: `Error: Synthetic search API returned ${response.status}: ${message}` }],
+            details: { query: params.query, resultCount: 0 } satisfies SearchDetails,
+          };
+        }
+
+        const data = (await response.json()) as SearchResponse;
+        const results = data.results ?? [];
+        return {
+          content: [{ type: "text", text: formatSearchResults(params.query, results) }],
+          details: { query: params.query, resultCount: results.length } satisfies SearchDetails,
+        };
+      } catch (error: unknown) {
+        const aborted = combinedSignal.aborted || (error instanceof DOMException && error.name === "AbortError");
+        if (aborted) {
+          if (isTimeoutReason(combinedSignal.reason)) {
+            return {
+              content: [{ type: "text", text: "Error: Synthetic search request timed out." }],
+              details: { query: params.query, resultCount: 0 } satisfies SearchDetails,
+            };
+          }
+          return {
+            content: [{ type: "text", text: "Error: Synthetic search request was cancelled." }],
+            details: { query: params.query, resultCount: 0 } satisfies SearchDetails,
+          };
+        }
+
+        const message = error instanceof Error ? error.message : "Unknown error";
+        return {
+          content: [{ type: "text", text: `Error: Synthetic search failed: ${message}` }],
+          details: { query: params.query, resultCount: 0 } satisfies SearchDetails,
+        };
+      }
+    },
+    renderResult(result, _options, theme) {
+      const text = result.content
+        .filter((item) => item.type === "text")
+        .map((item) => item.text)
+        .join("\n");
+      return new Text(theme.fg("toolOutput", text), 0, 0);
+    },
+  });
+}
+
 async function fetchSyntheticModels(apiKey: string, signal?: AbortSignal): Promise<ProviderModelConfig[] | null> {
   if (!apiKey) return null;
 
@@ -309,7 +462,16 @@ async function refreshLiveModels(pi: ExtensionAPI, apiKey: string, signal?: Abor
   return fetchedModels;
 }
 
-export async function installSynthetic(pi: ExtensionAPI): Promise<void> {
+export async function installSynthetic(pi: ExtensionAPI, controller: MoonpiController): Promise<void> {
+  let searchToolRegistered = false;
+  const searchEnabled = () => controller.config.synthetic.search.enabled;
+
+  function ensureSearchToolRegistered(): void {
+    if (searchToolRegistered || !searchEnabled()) return;
+    searchToolRegistered = true;
+    registerSearchTool(pi);
+  }
+
   // Fast path: read cached models from disk (synchronous, no network).
   // This ensures models are available immediately at init time, which is
   // critical for model restoration on session resume. Without this, models
@@ -327,6 +489,8 @@ export async function installSynthetic(pi: ExtensionAPI): Promise<void> {
   // resolved later in the session_start handler.
   const apiKey = process.env[SYNTHETIC_API_KEY_ENV] ?? "";
   if (apiKey) {
+    controller.syntheticAuthenticated = true;
+    ensureSearchToolRegistered();
     // Fire and forget – we already registered with cached/fallback models,
     // so startup isn't blocked on the network request.
     refreshLiveModels(pi, apiKey).catch(() => {
@@ -338,6 +502,14 @@ export async function installSynthetic(pi: ExtensionAPI): Promise<void> {
   // and refresh the model list from the live API.
   pi.on("session_start", async (_event, ctx) => {
     const apiKey = await getSyntheticApiKey(ctx);
+    const wasAuthenticated = controller.syntheticAuthenticated;
+    controller.syntheticAuthenticated = !!apiKey;
+    if (controller.syntheticAuthenticated && !searchToolRegistered) {
+      ensureSearchToolRegistered();
+    }
+    if (controller.syntheticAuthenticated !== wasAuthenticated) {
+      controller.applyMode(ctx);
+    }
     // Fire-and-forget: don't block session startup on the network request.
     // Cached/fallback models are already registered, so the provider is usable immediately.
     refreshLiveModels(pi, apiKey, ctx.signal).catch(() => {});

package/src/types.ts

@@ -35,6 +35,12 @@ export interface MoonpiConfig {
   /** Whether moonpi installs its custom mode-colored editor. Set to false to preserve
    *  editor customizations from other extensions (e.g. pi-wierd-statusline). */
   customEditor: boolean;
+  synthetic: {
+    search: {
+      /** Whether the web_search tool is available when logged in with Synthetic. */
+      enabled: boolean;
+    };
+  };
   contextFiles: {
     enabled: boolean;
     fileNames: string[];