gsd-pi 2.33.0-dev.bafba33 → 2.33.1-dev.235d83a

package/dist/resources/extensions/remote-questions/store.ts

@@ -1,81 +0,0 @@
-/**
- * Remote Questions — durable prompt store
- */
-
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
-import { homedir } from "node:os";
-import type { RemotePrompt, RemotePromptRecord, RemotePromptRef, RemoteAnswer, RemotePromptStatus } from "./types.js";
-
-function runtimeDir(): string {
-  return join(homedir(), ".gsd", "runtime", "remote-questions");
-}
-
-function recordPath(id: string): string {
-  return join(runtimeDir(), `${id}.json`);
-}
-
-export function createPromptRecord(prompt: RemotePrompt): RemotePromptRecord {
-  return {
-    version: 1,
-    id: prompt.id,
-    createdAt: prompt.createdAt,
-    updatedAt: Date.now(),
-    status: "pending",
-    channel: prompt.channel,
-    timeoutAt: prompt.timeoutAt,
-    pollIntervalMs: prompt.pollIntervalMs,
-    questions: prompt.questions,
-    context: prompt.context,
-  };
-}
-
-export function writePromptRecord(record: RemotePromptRecord): void {
-  mkdirSync(runtimeDir(), { recursive: true });
-  writeFileSync(recordPath(record.id), JSON.stringify(record, null, 2) + "\n", "utf-8");
-}
-
-export function readPromptRecord(id: string): RemotePromptRecord | null {
-  const path = recordPath(id);
-  if (!existsSync(path)) return null;
-  try {
-    return JSON.parse(readFileSync(path, "utf-8")) as RemotePromptRecord;
-  } catch {
-    return null;
-  }
-}
-
-export function updatePromptRecord(
-  id: string,
-  updates: Partial<RemotePromptRecord>,
-): RemotePromptRecord | null {
-  const current = readPromptRecord(id);
-  if (!current) return null;
-  const merged = {
-    ...current,
-    ...updates,
-    updatedAt: Date.now(),
-  };
-  // After spreading, the merged object satisfies one of the union members
-  // but TypeScript can't prove it statically. The invariant is maintained
-  // by callers: once `ref` is set via markPromptDispatched it is never removed.
-  const next = merged as RemotePromptRecord;
-  writePromptRecord(next);
-  return next;
-}
-
-export function markPromptDispatched(id: string, ref: RemotePromptRef): RemotePromptRecord | null {
-  return updatePromptRecord(id, { ref, status: "pending" });
-}
-
-export function markPromptAnswered(id: string, response: RemoteAnswer): RemotePromptRecord | null {
-  return updatePromptRecord(id, { response, status: "answered", lastPollAt: Date.now() });
-}
-
-export function markPromptStatus(id: string, status: RemotePromptStatus, lastError?: string): RemotePromptRecord | null {
-  return updatePromptRecord(id, {
-    status,
-    lastPollAt: Date.now(),
-    ...(lastError ? { lastError } : {}),
-  });
-}

package/dist/resources/extensions/remote-questions/telegram-adapter.ts

@@ -1,149 +0,0 @@
-/**
- * Remote Questions — Telegram adapter
- */
-
-import { type ChannelAdapter, type RemotePrompt, type RemoteDispatchResult, type RemoteAnswer, type RemotePromptRef } from "./types.js";
-import { formatForTelegram, parseTelegramResponse } from "./format.js";
-import { apiRequest } from "./http-client.js";
-
-const TELEGRAM_API = "https://api.telegram.org";
-
-export class TelegramAdapter implements ChannelAdapter {
-  readonly name = "telegram" as const;
-  private botUserId: number | null = null;
-  private lastUpdateId = 0;
-  private lastSentText = "";
-  private readonly token: string;
-  private readonly chatId: string;
-
-  constructor(token: string, chatId: string) {
-    this.token = token;
-    this.chatId = chatId;
-  }
-
-  async validate(): Promise<void> {
-    const res = await this.telegramApi("getMe");
-    if (!res.ok || !res.result?.id) throw new Error("Telegram auth failed: invalid bot token");
-    this.botUserId = res.result.id;
-  }
-
-  async sendPrompt(prompt: RemotePrompt): Promise<RemoteDispatchResult> {
-    const payload = formatForTelegram(prompt);
-    this.lastSentText = payload.text;
-
-    const params: Record<string, unknown> = {
-      chat_id: this.chatId,
-      text: payload.text,
-      parse_mode: payload.parse_mode,
-    };
-    if (payload.reply_markup) {
-      params.reply_markup = payload.reply_markup;
-    }
-
-    const res = await this.telegramApi("sendMessage", params);
-    if (!res.ok || !res.result?.message_id) {
-      throw new Error(`Telegram sendMessage failed: ${JSON.stringify(res)}`);
-    }
-
-    const messageId = String(res.result.message_id);
-    const messageUrl = this.buildMessageUrl(this.chatId, messageId);
-
-    return {
-      ref: {
-        id: prompt.id,
-        channel: "telegram",
-        messageId,
-        channelId: this.chatId,
-        threadUrl: messageUrl,
-      },
-    };
-  }
-
-  async pollAnswer(prompt: RemotePrompt, ref: RemotePromptRef): Promise<RemoteAnswer | null> {
-    if (!this.botUserId) await this.validate();
-
-    const res = await this.telegramApi("getUpdates", {
-      offset: this.lastUpdateId + 1,
-      timeout: 0,
-      allowed_updates: ["message", "callback_query"],
-    });
-
-    if (!res.ok || !Array.isArray(res.result)) return null;
-
-    for (const update of res.result) {
-      // Advance offset for all updates to prevent reprocessing
-      if (update.update_id > this.lastUpdateId) {
-        this.lastUpdateId = update.update_id;
-      }
-
-      // Handle callback_query (inline keyboard button press)
-      if (update.callback_query) {
-        const cq = update.callback_query;
-        const msg = cq.message;
-        if (
-          msg &&
-          String(msg.chat?.id) === ref.channelId &&
-          String(msg.message_id) === ref.messageId &&
-          cq.from?.id !== this.botUserId
-        ) {
-          // Dismiss the loading spinner on the button
-          try {
-            await this.telegramApi("answerCallbackQuery", { callback_query_id: cq.id });
-          } catch { /* best-effort */ }
-
-          return parseTelegramResponse(cq.data ?? null, null, prompt.questions, prompt.id);
-        }
-      }
-
-      // Handle text reply (reply_to_message)
-      if (update.message) {
-        const msg = update.message;
-        if (
-          String(msg.chat?.id) === ref.channelId &&
-          msg.reply_to_message &&
-          String(msg.reply_to_message.message_id) === ref.messageId &&
-          msg.from?.id !== this.botUserId &&
-          msg.text
-        ) {
-          return parseTelegramResponse(null, msg.text, prompt.questions, prompt.id);
-        }
-      }
-    }
-
-    return null;
-  }
-
-  /**
-   * Acknowledge receipt by editing the original message to append a checkmark.
-   * Best-effort — failures are silently ignored.
-   */
-  async acknowledgeAnswer(ref: RemotePromptRef): Promise<void> {
-    try {
-      await this.telegramApi("editMessageText", {
-        chat_id: ref.channelId,
-        message_id: parseInt(ref.messageId, 10),
-        text: this.lastSentText + "\n\n✅ Answered",
-        parse_mode: "HTML",
-      });
-    } catch {
-      // Best-effort — don't let acknowledgement failures affect the flow
-    }
-  }
-
-  private buildMessageUrl(chatId: string, messageId: string): string | undefined {
-    // Supergroups have chat IDs starting with -100
-    if (chatId.startsWith("-100")) {
-      return `https://t.me/c/${chatId.slice(4)}/${messageId}`;
-    }
-    return undefined;
-  }
-
-  private async telegramApi(method: string, params?: Record<string, unknown>): Promise<any> {
-    return apiRequest(
-      `${TELEGRAM_API}/bot${this.token}/${method}`,
-      "POST",
-      params,
-      { errorLabel: "Telegram API" },
-    );
-  }
-}

package/dist/resources/extensions/remote-questions/types.ts

@@ -1,102 +0,0 @@
-/**
- * Remote Questions — shared types
- */
-
-/** Timeout applied to every outbound HTTP request across all channel adapters. */
-export const PER_REQUEST_TIMEOUT_MS = 15_000;
-
-export type RemoteChannel = "slack" | "discord" | "telegram";
-
-export interface RemoteQuestionOption {
-  label: string;
-  description: string;
-}
-
-export interface RemoteQuestion {
-  id: string;
-  header: string;
-  question: string;
-  options: RemoteQuestionOption[];
-  allowMultiple: boolean;
-}
-
-export interface RemotePrompt {
-  id: string;
-  channel: RemoteChannel;
-  createdAt: number;
-  timeoutAt: number;
-  pollIntervalMs: number;
-  questions: RemoteQuestion[];
-  context?: {
-    source: string;
-  };
-}
-
-export interface RemotePromptRef {
-  id: string;
-  channel: RemoteChannel;
-  messageId: string;
-  channelId: string;
-  threadTs?: string;
-  threadUrl?: string;
-}
-
-export interface RemoteAnswer {
-  answers: Record<string, { answers: string[]; user_note?: string }>;
-}
-
-export type RemotePromptStatus = "pending" | "answered" | "timed_out" | "failed" | "cancelled";
-
-/** Shared fields present on every prompt record regardless of dispatch state. */
-interface RemotePromptRecordBase {
-  version: 1;
-  id: string;
-  createdAt: number;
-  updatedAt: number;
-  channel: RemoteChannel;
-  timeoutAt: number;
-  pollIntervalMs: number;
-  questions: RemoteQuestion[];
-  response?: RemoteAnswer;
-  lastPollAt?: number;
-  lastError?: string;
-  context?: {
-    source: string;
-  };
-}
-
-/** Record before the prompt has been dispatched to a channel. */
-export interface PendingPromptRecord extends RemotePromptRecordBase {
-  status: "pending";
-  ref?: undefined;
-}
-
-/** Record after the prompt has been dispatched (ref is always present). */
-export interface DispatchedPromptRecord extends RemotePromptRecordBase {
-  status: RemotePromptStatus;
-  ref: RemotePromptRef;
-}
-
-/**
- * A prompt record is either pre-dispatch (no ref) or post-dispatch (ref required).
- *
- * Narrow via `record.ref`:
- * ```ts
- * if (record.ref) {
- *   // DispatchedPromptRecord — ref is RemotePromptRef
- * }
- * ```
- */
-export type RemotePromptRecord = PendingPromptRecord | DispatchedPromptRecord;
-
-export interface RemoteDispatchResult {
-  ref: RemotePromptRef;
-}
-
-export interface ChannelAdapter {
-  readonly name: RemoteChannel;
-  validate(): Promise<void>;
-  sendPrompt(prompt: RemotePrompt): Promise<RemoteDispatchResult>;
-  pollAnswer(prompt: RemotePrompt, ref: RemotePromptRef): Promise<RemoteAnswer | null>;
-  acknowledgeAnswer?(ref: RemotePromptRef): Promise<void>;
-}

package/dist/resources/extensions/search-the-web/cache.ts

@@ -1,78 +0,0 @@
-/**
- * LRU cache with TTL — zero external dependencies.
- *
- * - max: maximum entries before oldest is evicted
- * - ttlMs: time-to-live per entry
- *
- * Uses a Map (insertion-ordered) for O(1) LRU eviction:
- * on every access the entry is deleted and re-inserted at the tail.
- */
-export class LRUTTLCache<V> {
-  private readonly max: number;
-  private readonly ttlMs: number;
-  private readonly store = new Map<string, { value: V; expiresAt: number }>();
-  private purgeTimer: ReturnType<typeof setInterval> | null = null;
-
-  constructor(options: { max: number; ttlMs: number }) {
-    this.max = options.max;
-    this.ttlMs = options.ttlMs;
-  }
-
-  get(key: string): V | undefined {
-    const entry = this.store.get(key);
-    if (!entry) return undefined;
-    if (Date.now() > entry.expiresAt) {
-      this.store.delete(key);
-      return undefined;
-    }
-    // Refresh to tail (most-recently-used)
-    this.store.delete(key);
-    this.store.set(key, entry);
-    return entry.value;
-  }
-
-  set(key: string, value: V): void {
-    if (this.store.has(key)) {
-      this.store.delete(key);
-    } else if (this.store.size >= this.max) {
-      const oldest = this.store.keys().next().value;
-      if (oldest !== undefined) this.store.delete(oldest);
-    }
-    this.store.set(key, { value, expiresAt: Date.now() + this.ttlMs });
-  }
-
-  has(key: string): boolean {
-    return this.get(key) !== undefined;
-  }
-
-  purgeStale(): void {
-    const now = Date.now();
-    for (const [key, entry] of this.store) {
-      if (now > entry.expiresAt) this.store.delete(key);
-    }
-  }
-
-  startPurgeInterval(intervalMs: number): void {
-    if (this.purgeTimer !== null) return;
-    this.purgeTimer = setInterval(() => this.purgeStale(), intervalMs);
-    // Don't keep the process alive just for cache cleanup
-    if (this.purgeTimer && typeof this.purgeTimer === "object" && "unref" in this.purgeTimer) {
-      (this.purgeTimer as NodeJS.Timeout).unref();
-    }
-  }
-
-  stopPurgeInterval(): void {
-    if (this.purgeTimer !== null) {
-      clearInterval(this.purgeTimer);
-      this.purgeTimer = null;
-    }
-  }
-
-  clear(): void {
-    this.store.clear();
-  }
-
-  get size(): number {
-    return this.store.size;
-  }
-}

package/dist/resources/extensions/search-the-web/command-search-provider.ts

@@ -1,101 +0,0 @@
-/**
- * /search-provider slash command.
- *
- * Lets users switch between tavily, brave, and auto search backends.
- * Supports direct arg (`/search-provider tavily`) or interactive select UI.
- * Tab completion provides the three valid options with key status.
- *
- * All provider logic lives in provider.ts (S01) — this is pure UI wiring.
- */
-
-import type { ExtensionAPI } from '@gsd/pi-coding-agent'
-import type { AutocompleteItem } from '@gsd/pi-tui'
-import {
-  getTavilyApiKey,
-  getBraveApiKey,
-  getOllamaApiKey,
-  getSearchProviderPreference,
-  setSearchProviderPreference,
-  resolveSearchProvider,
-  type SearchProviderPreference,
-} from './provider.ts'
-
-const VALID_PREFERENCES: SearchProviderPreference[] = ['tavily', 'brave', 'ollama', 'auto']
-
-function keyStatus(provider: 'tavily' | 'brave' | 'ollama'): string {
-  if (provider === 'tavily') return getTavilyApiKey() ? '✓' : '✗'
-  if (provider === 'ollama') return getOllamaApiKey() ? '✓' : '✗'
-  return getBraveApiKey() ? '✓' : '✗'
-}
-
-function buildSelectOptions(): string[] {
-  return [
-    `tavily (key: ${keyStatus('tavily')})`,
-    `brave (key: ${keyStatus('brave')})`,
-    `ollama (key: ${keyStatus('ollama')})`,
-    `auto`,
-  ]
-}
-
-function parseSelectChoice(choice: string): SearchProviderPreference {
-  if (choice.startsWith('tavily')) return 'tavily'
-  if (choice.startsWith('brave')) return 'brave'
-  if (choice.startsWith('ollama')) return 'ollama'
-  return 'auto'
-}
-
-export function registerSearchProviderCommand(pi: ExtensionAPI): void {
-  pi.registerCommand('search-provider', {
-    description: 'Switch search provider (tavily, brave, ollama, auto)',
-
-    getArgumentCompletions(prefix: string): AutocompleteItem[] | null {
-      const trimmed = prefix.trim().toLowerCase()
-      return VALID_PREFERENCES
-        .filter((p) => p.startsWith(trimmed))
-        .map((p) => {
-          let description: string
-          if (p === 'auto') {
-            description = `Auto-select (tavily: ${keyStatus('tavily')}, brave: ${keyStatus('brave')}, ollama: ${keyStatus('ollama')})`
-          } else {
-            description = `key: ${keyStatus(p)}`
-          }
-          return { value: p, label: p, description }
-        })
-    },
-
-    async handler(args, ctx) {
-      const trimmed = args.trim().toLowerCase()
-
-      let chosen: SearchProviderPreference
-
-      if (trimmed && (VALID_PREFERENCES as string[]).includes(trimmed)) {
-        // Direct arg — apply immediately, no select UI
-        chosen = trimmed as SearchProviderPreference
-      } else {
-        // No arg or invalid arg — show interactive select
-        const current = getSearchProviderPreference()
-        const options = buildSelectOptions()
-        const result = await ctx.ui.select(
-          `Search provider (current: ${current})`,
-          options,
-        )
-
-        if (result === undefined) {
-          // User cancelled — bail silently
-          return
-        }
-
-        chosen = parseSelectChoice(Array.isArray(result) ? result[0] : result)
-      }
-
-      setSearchProviderPreference(chosen)
-      const effective = resolveSearchProvider()
-      const isAnthropic = ctx.model?.provider === 'anthropic'
-      const nativeNote = isAnthropic ? '\nNote: Native Anthropic web search is also active (automatic, no API key needed).' : ''
-      ctx.ui.notify(
-        `Search provider set to ${chosen}. Effective provider: ${effective ?? 'none (no API keys)'}${nativeNote}`,
-        'info',
-      )
-    },
-  })
-}