omegon 0.6.0

package/extensions/view/uri-resolver.ts

@@ -0,0 +1,148 @@
+/**
+ * URI resolver for context-aware OSC 8 hyperlinks.
+ *
+ * Routes file paths to the best URI scheme based on:
+ *   - File extension (.md → mdserve, code → editor, .excalidraw → Obsidian)
+ *   - Running services (mdserve port in shared state)
+ *   - User config (.pi/config.json editor preference)
+ *   - Obsidian vault detection (walk parents for .obsidian/)
+ *
+ * Fallback is always file://
+ */
+
+import { existsSync, readFileSync } from "node:fs";
+import { basename, dirname, extname, join, relative } from "node:path";
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+export interface PiConfig {
+  editor?: string;
+}
+
+export interface ResolveUriOptions {
+  mdservePort?: number;
+  config?: PiConfig;
+  /** Override project root for mdserve relative paths. Defaults to cwd. */
+  projectRoot?: string;
+}
+
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+
+const CODE_EXTS = new Set([
+  ".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs",
+  ".py", ".rs", ".go", ".c", ".cpp", ".cc", ".h", ".hpp",
+  ".java", ".kt", ".rb", ".lua", ".sh", ".bash", ".zsh",
+  ".css", ".scss", ".less", ".sql", ".swift", ".zig",
+  ".vue", ".svelte", ".elm", ".hs", ".ml", ".ex", ".exs",
+  ".php", ".pl", ".r", ".scala", ".dart", ".nim",
+]);
+
+const MARKDOWN_EXTS = new Set([".md", ".markdown", ".mdx"]);
+
+const KNOWN_EDITORS = new Set(["vscode", "cursor", "zed"]);
+
+// ---------------------------------------------------------------------------
+// Config loading
+// ---------------------------------------------------------------------------
+
+/**
+ * Load .pi/config.json from the given directory (or cwd).
+ * Returns empty config on missing/invalid file — never throws.
+ */
+export function loadConfig(root?: string): PiConfig {
+  const configPath = join(root ?? process.cwd(), ".pi", "config.json");
+  try {
+    if (!existsSync(configPath)) return {};
+    const raw = JSON.parse(readFileSync(configPath, "utf-8"));
+    if (raw && typeof raw === "object" && !Array.isArray(raw)) {
+      return { editor: typeof raw.editor === "string" ? raw.editor : undefined };
+    }
+    return {};
+  } catch {
+    return {};
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Obsidian vault detection
+// ---------------------------------------------------------------------------
+
+/**
+ * Walk parent directories looking for .obsidian/ folder.
+ * Returns { vaultName, vaultRoot } or undefined.
+ */
+export function detectObsidianVault(absPath: string): { vaultName: string; vaultRoot: string } | undefined {
+  let dir = dirname(absPath);
+  const seen = new Set<string>();
+  while (dir && !seen.has(dir)) {
+    seen.add(dir);
+    if (existsSync(join(dir, ".obsidian"))) {
+      return { vaultName: basename(dir), vaultRoot: dir };
+    }
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return undefined;
+}
+
+// ---------------------------------------------------------------------------
+// URI resolution
+// ---------------------------------------------------------------------------
+
+/**
+ * Resolve the best URI for a given absolute file path.
+ */
+export function resolveUri(absPath: string, options?: ResolveUriOptions): string {
+  const ext = extname(absPath).toLowerCase();
+  const config = options?.config ?? loadConfig();
+  const mdservePort = options?.mdservePort;
+  const projectRoot = options?.projectRoot ?? process.cwd();
+
+  // Markdown → mdserve if running, else file://
+  if (MARKDOWN_EXTS.has(ext)) {
+    if (mdservePort) {
+      const rel = relative(projectRoot, absPath);
+      return `http://localhost:${mdservePort}/${rel}`;
+    }
+    return `file://${absPath}`;
+  }
+
+  // Excalidraw → Obsidian if vault detected, else file://
+  if (ext === ".excalidraw") {
+    const vault = detectObsidianVault(absPath);
+    if (vault) {
+      const relPath = relative(vault.vaultRoot, absPath);
+      return `obsidian://open?vault=${encodeURIComponent(vault.vaultName)}&file=${encodeURIComponent(relPath)}`;
+    }
+    return `file://${absPath}`;
+  }
+
+  // Code files → editor scheme if configured, else file://
+  if (CODE_EXTS.has(ext)) {
+    const editor = config.editor;
+    if (editor && KNOWN_EDITORS.has(editor)) {
+      return `${editor}://file/${absPath}`;
+    }
+    return `file://${absPath}`;
+  }
+
+  // Everything else (images, PDFs, etc.) → file://
+  return `file://${absPath}`;
+}
+
+// ---------------------------------------------------------------------------
+// OSC 8 helpers
+// ---------------------------------------------------------------------------
+
+/**
+ * Wrap text in an OSC 8 hyperlink escape sequence.
+ * Terminals that don't support OSC 8 simply ignore the sequences.
+ */
+export function osc8Link(uri: string, text: string): string {
+  return `\x1b]8;;${uri}\x1b\\${text}\x1b]8;;\x1b\\`;
+}

package/extensions/web-search/index.ts

@@ -0,0 +1,182 @@
+// @secret BRAVE_API_KEY "Brave Search API key"
+// @secret TAVILY_API_KEY "Tavily Search API key"
+// @secret SERPER_API_KEY "Serper/Google Search API key"
+
+import type { ExtensionAPI } from "@cwilson613/pi-coding-agent";
+import { Type } from "@sinclair/typebox";
+import { StringEnum } from "../lib/typebox-helpers";
+import { getAvailableProviders, getProvider, type SearchResult } from "./providers.ts";
+
+function deduplicateResults(results: SearchResult[]): SearchResult[] {
+  const seen = new Map<string, SearchResult>();
+  for (const r of results) {
+    const key = r.url.replace(/\/$/, "").toLowerCase();
+    if (seen.has(key)) {
+      // Merge provider attribution
+      const existing = seen.get(key)!;
+      if (!existing.provider.includes(r.provider)) {
+        existing.provider += `, ${r.provider}`;
+      }
+      // Prefer longer snippet
+      if (r.snippet.length > existing.snippet.length) {
+        existing.snippet = r.snippet;
+      }
+      if (r.content && (!existing.content || r.content.length > existing.content.length)) {
+        existing.content = r.content;
+      }
+    } else {
+      seen.set(key, { ...r });
+    }
+  }
+  return Array.from(seen.values());
+}
+
+function formatResults(results: SearchResult[], mode: string): string {
+  if (results.length === 0) return "No results found.";
+
+  const lines: string[] = [];
+  for (const r of results) {
+    lines.push(`### ${r.title}`);
+    lines.push(`**URL:** ${r.url}`);
+    lines.push(`**Source:** ${r.provider}`);
+    lines.push(`${r.snippet}`);
+    if (r.content) {
+      lines.push(`\n<extracted_content>\n${r.content.slice(0, 2000)}\n</extracted_content>`);
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+
+export default function (pi: ExtensionAPI) {
+  // Secrets are resolved into process.env by the 00-secrets extension
+  // before this extension loads. No .env files needed.
+
+  pi.registerTool({
+    name: "web_search",
+    label: "Web Search",
+    description: `Search the web using multiple providers. Available modes:
+- "quick": Use a single provider (fastest)
+- "deep": Use a single provider, more results
+- "compare": Fan out to ALL configured providers in parallel, deduplicate results. Best for research and verification.
+
+Available providers: brave (independent index), tavily (AI-optimized, extracts content), serper (Google results).
+Only providers with configured API keys are available.`,
+    promptSnippet: "Search the web via multiple providers (brave, tavily, serper) with quick/deep/compare modes",
+    promptGuidelines: [
+      "Use 'compare' mode for research requiring cross-source verification",
+    ],
+    parameters: Type.Object({
+      query: Type.String({ description: "Search query" }),
+      provider: Type.Optional(
+        StringEnum(["brave", "tavily", "serper"], {
+          description: "Specific provider. Omit to auto-select (quick) or fan out (compare).",
+        })
+      ),
+      mode: Type.Optional(
+        StringEnum(["quick", "deep", "compare"], {
+          description: "Search mode. Default: quick",
+        })
+      ),
+      max_results: Type.Optional(
+        Type.Number({ description: "Max results per provider. Default: 5", minimum: 1, maximum: 20 })
+      ),
+      topic: Type.Optional(
+        StringEnum(["general", "news"], {
+          description: "Search topic. Default: general",
+        })
+      ),
+    }),
+    async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
+      const mode = params.mode || "quick";
+      const maxResults = params.max_results || (mode === "deep" ? 10 : 5);
+      const topic = params.topic || "general";
+      const available = getAvailableProviders();
+
+      if (available.length === 0) {
+        return {
+          content: [{
+            type: "text",
+            text: "No search providers configured. Run `/secrets configure BRAVE_API_KEY` (or TAVILY_API_KEY, SERPER_API_KEY) to set up at least one provider.",
+          }],
+          details: { error: true },
+        };
+      }
+
+      let results: SearchResult[] = [];
+      let providersUsed: string[] = [];
+
+      if (mode === "compare") {
+        // Fan out to all available providers in parallel
+        const settled = await Promise.allSettled(
+          available.map((p) => p.search(params.query, maxResults, topic))
+        );
+        for (let i = 0; i < settled.length; i++) {
+          const outcome = settled[i];
+          if (outcome.status === "fulfilled") {
+            results.push(...outcome.value);
+            providersUsed.push(available[i].name);
+          } else {
+            providersUsed.push(`${available[i].name} (error: ${outcome.reason?.message || "unknown"})`);
+          }
+        }
+        results = deduplicateResults(results);
+      } else {
+        // Single provider
+        let provider;
+        if (params.provider) {
+          provider = getProvider(params.provider);
+          if (!provider) {
+            return {
+              content: [{
+                type: "text",
+                text: `Provider "${params.provider}" not available. Configured: ${available.map((p) => p.name).join(", ")}`,
+              }],
+              details: { error: true },
+            };
+          }
+        } else {
+          // Auto-select: prefer tavily (content extraction), then serper (google), then brave
+          provider =
+            available.find((p) => p.name === "tavily") ||
+            available.find((p) => p.name === "serper") ||
+            available[0];
+        }
+        try {
+          results = await provider.search(params.query, maxResults, topic);
+          providersUsed.push(provider.name);
+        } catch (err: any) {
+          return {
+            content: [{ type: "text", text: `Search error (${provider.name}): ${err.message}` }],
+            details: { error: true },
+          };
+        }
+      }
+
+      const header = `**Query:** ${params.query}\n**Mode:** ${mode} | **Providers:** ${providersUsed.join(", ")} | **Results:** ${results.length}\n\n---\n\n`;
+      const body = formatResults(results, mode);
+
+      return {
+        content: [{ type: "text", text: header + body }],
+        details: {
+          resultCount: results.length,
+          providers: providersUsed,
+          mode,
+        },
+      };
+    },
+  });
+
+  // Notify on load with provider status
+  pi.on("session_start", async (_event, ctx) => {
+    const available = getAvailableProviders();
+    if (available.length > 0) {
+      ctx.ui.notify(
+        `Web Search: ${available.map((p) => p.name).join(", ")} ready`,
+        "info"
+      );
+    } else {
+      ctx.ui.notify("Web Search: No API keys configured", "warning");
+    }
+  });
+}

package/extensions/web-search/providers.ts

@@ -0,0 +1,121 @@
+// Web search provider implementations
+
+export interface SearchResult {
+  title: string;
+  url: string;
+  snippet: string;
+  content?: string; // Tavily returns extracted content
+  provider: string;
+}
+
+export interface SearchProvider {
+  name: string;
+  available: boolean;
+  search(query: string, maxResults: number, topic: string): Promise<SearchResult[]>;
+}
+
+// --- Brave Search ---
+
+function braveProvider(): SearchProvider {
+  const apiKey = process.env.BRAVE_API_KEY;
+  return {
+    name: "brave",
+    available: !!apiKey,
+    async search(query, maxResults, topic) {
+      const params = new URLSearchParams({
+        q: query,
+        count: String(maxResults),
+        ...(topic === "news" ? { freshness: "pd" } : {}),
+      });
+      const res = await fetch(
+        `https://api.search.brave.com/res/v1/web/search?${params}`,
+        { headers: { "X-Subscription-Token": apiKey!, Accept: "application/json" } }
+      );
+      if (!res.ok) throw new Error(`Brave ${res.status}: ${await res.text()}`);
+      const data = await res.json();
+      return (data.web?.results || []).slice(0, maxResults).map((r: any) => ({
+        title: r.title,
+        url: r.url,
+        snippet: r.description || "",
+        provider: "brave",
+      }));
+    },
+  };
+}
+
+// --- Tavily ---
+
+function tavilyProvider(): SearchProvider {
+  const apiKey = process.env.TAVILY_API_KEY;
+  return {
+    name: "tavily",
+    available: !!apiKey,
+    async search(query, maxResults, topic) {
+      const res = await fetch("https://api.tavily.com/search", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          api_key: apiKey,
+          query,
+          max_results: maxResults,
+          include_answer: false,
+          include_raw_content: false,
+          topic: topic === "news" ? "news" : "general",
+        }),
+      });
+      if (!res.ok) throw new Error(`Tavily ${res.status}: ${await res.text()}`);
+      const data = await res.json();
+      return (data.results || []).slice(0, maxResults).map((r: any) => ({
+        title: r.title,
+        url: r.url,
+        snippet: r.content || "",
+        content: r.raw_content || undefined,
+        provider: "tavily",
+      }));
+    },
+  };
+}
+
+// --- Serper (Google) ---
+
+function serperProvider(): SearchProvider {
+  const apiKey = process.env.SERPER_API_KEY;
+  return {
+    name: "serper",
+    available: !!apiKey,
+    async search(query, maxResults, topic) {
+      const endpoint =
+        topic === "news"
+          ? "https://google.serper.dev/news"
+          : "https://google.serper.dev/search";
+      const res = await fetch(endpoint, {
+        method: "POST",
+        headers: { "X-API-KEY": apiKey!, "Content-Type": "application/json" },
+        body: JSON.stringify({ q: query, num: maxResults }),
+      });
+      if (!res.ok) throw new Error(`Serper ${res.status}: ${await res.text()}`);
+      const data = await res.json();
+      const results = topic === "news" ? data.news || [] : data.organic || [];
+      return results.slice(0, maxResults).map((r: any) => ({
+        title: r.title,
+        url: r.link,
+        snippet: r.snippet || r.description || "",
+        provider: "serper",
+      }));
+    },
+  };
+}
+
+// --- Registry ---
+
+export function getProviders(): SearchProvider[] {
+  return [braveProvider(), tavilyProvider(), serperProvider()];
+}
+
+export function getAvailableProviders(): SearchProvider[] {
+  return getProviders().filter((p) => p.available);
+}
+
+export function getProvider(name: string): SearchProvider | undefined {
+  return getProviders().find((p) => p.name === name && p.available);
+}

package/extensions/web-ui/index.ts

@@ -0,0 +1,110 @@
+import { spawn as nodeSpawn } from "node:child_process";
+import type { ExtensionAPI } from "@cwilson613/pi-coding-agent";
+import { startWebUIServer, type WebUIServer } from "./server.ts";
+
+let server: WebUIServer | null = null;
+let spawnFn: typeof nodeSpawn = nodeSpawn;
+
+export function _setSpawnFn(fn: typeof nodeSpawn): typeof nodeSpawn {
+  const prev = spawnFn;
+  spawnFn = fn;
+  return prev;
+}
+
+export function _setServer(next: WebUIServer | null): void {
+  server = next;
+}
+
+/** Returns the current server instance. Prefer this over the live-binding export for reliable cross-Node-version semantics. */
+export function _getServer(): WebUIServer | null {
+  return server;
+}
+
+function openBrowser(url: string, ctx: Parameters<typeof notify>[0]): void {
+  let cmd: string;
+  let args: string[];
+
+  if (process.platform === "darwin") {
+    cmd = "open";
+    args = [url];
+  } else if (process.platform === "win32") {
+    // cmd.exe `start` requires an empty-string window-title when the next token is a URL.
+    cmd = "cmd";
+    args = ["/c", "start", "", url];
+  } else {
+    cmd = "xdg-open";
+    args = [url];
+  }
+
+  const child = spawnFn(cmd, args, { stdio: "ignore" });
+  if (typeof child.on === "function") {
+    child.on("error", (err: Error) => {
+      notify(ctx, `Failed to open browser (${cmd}): ${err.message}`);
+    });
+  }
+  if (typeof child.unref === "function") {
+    child.unref();
+  }
+}
+
+function notify(ctx: { ui?: { notify?: (msg: string, level?: "info" | "warning" | "error") => void } }, message: string): void {
+  if (typeof ctx.ui?.notify === "function") ctx.ui.notify(message, "info");
+}
+
+export default function webUiExtension(pi: ExtensionAPI): void {
+  pi.registerCommand("web-ui", {
+    description: "Localhost-only read-only web UI dashboard (/web-ui [start|stop|status|open])",
+    handler: async (args, ctx) => {
+      const subcommand = args.trim().split(/\s+/)[0]?.toLowerCase() || "status";
+
+      switch (subcommand) {
+        case "status":
+        case "": {
+          if (!server) {
+            notify(ctx, "web-ui server is stopped. Run `/web-ui start` to start it.");
+          } else {
+            const uptimeSec = Math.round((Date.now() - server.startedAt) / 1000);
+            notify(ctx, `web-ui server is running at ${server.url} (uptime ${uptimeSec}s)`);
+          }
+          return;
+        }
+        case "start": {
+          if (server) {
+            notify(ctx, `web-ui server is already running at ${server.url}`);
+            return;
+          }
+          server = await startWebUIServer({ repoRoot: ctx.cwd ?? process.cwd() });
+          notify(ctx, `web-ui server started at ${server.url}. Run \`/web-ui open\` to open it in your browser.`);
+          return;
+        }
+        case "stop": {
+          if (!server) {
+            notify(ctx, "web-ui server is not running.");
+            return;
+          }
+          await server.stop().catch(() => {});
+          server = null;
+          notify(ctx, "web-ui server stopped.");
+          return;
+        }
+        case "open": {
+          if (!server) {
+            notify(ctx, "web-ui server is not running. Run `/web-ui start` first.");
+            return;
+          }
+          openBrowser(server.url, ctx);
+          notify(ctx, `Opening ${server.url} in your default browser…`);
+          return;
+        }
+        default:
+          notify(ctx, "Usage: /web-ui [start|stop|status|open]");
+      }
+    },
+  });
+
+  pi.on("session_shutdown", async () => {
+    if (!server) return;
+    await server.stop().catch(() => {});
+    server = null;
+  });
+}