@selesai/code 0.1.18 → 0.2.0

package/dist/extensions/pi-web-agent/src/backends/factory.ts

@@ -0,0 +1,152 @@
+import { createFirecrawlFetcher } from '../fetch/firecrawl-fetch.js';
+import { createBraveSearchTool } from '../search/brave.js';
+import { createSearxngSearchTool } from '../search/searxng.js';
+import { buildFetchPresentation } from '../presentation/fetch-presentation.js';
+import { buildSearchPresentation } from '../presentation/search-presentation.js';
+import { createWebFetchHeadlessTool } from '../tools/web-fetch-headless.js';
+import { createWebFetchTool } from '../tools/web-fetch.js';
+import { createWebSearchTool } from '../tools/web-search.js';
+import { readBraveKeyFromSettings } from './settings-reader.js';
+import type { WebFetchHeadlessResponse, WebFetchResponse, WebSearchResponse } from '../types.js';
+import { DEFAULT_BACKEND_CONFIG, type BackendConfig } from './config.js';
+
+export type BackendSet = {
+  search: (input: { query: string }) => Promise<WebSearchResponse>;
+  fetchPage: (input: { url: string }) => Promise<WebFetchResponse>;
+  headlessFetch: (input: { url: string }) => Promise<WebFetchHeadlessResponse>;
+};
+
+export type BackendFactoryDeps = {
+  createDuckDuckGoSearch?: typeof createWebSearchTool;
+  createSearxngSearch?: typeof createSearxngSearchTool;
+  createBraveSearch?: typeof createBraveSearchTool;
+  createHttpFetch?: typeof createWebFetchTool;
+  createFirecrawlFetch?: typeof createFirecrawlFetcher;
+  createHeadlessFetch?: typeof createWebFetchHeadlessTool;
+};
+
+function invalidSearxngSearch() {
+  return async function search() {
+    const result: WebSearchResponse = {
+      status: 'error',
+      results: [],
+      metadata: { backend: 'searxng', cacheHit: false },
+      error: {
+        code: 'BACKEND_CONFIG_INVALID',
+        message: 'SearXNG search requires backends.search.baseUrl.'
+      }
+    };
+
+    return { ...result, presentation: buildSearchPresentation(result) };
+  };
+}
+
+function invalidFirecrawlFetch() {
+  return async function fetchPage(url: string): Promise<WebFetchResponse> {
+    const result: WebFetchResponse = {
+      status: 'error',
+      url,
+      metadata: { method: 'firecrawl', cacheHit: false },
+      error: {
+        code: 'BACKEND_CONFIG_INVALID',
+        message: 'Firecrawl fetch requires backends.fetch.baseUrl.'
+      }
+    };
+
+    return { ...result, presentation: buildFetchPresentation(result) };
+  };
+}
+
+function withSearchFallback(
+  primary: BackendSet['search'],
+  fallback: BackendSet['search'],
+  fallbackFrom: 'searxng' | 'brave'
+): BackendSet['search'] {
+  return async (input) => {
+    const first = await primary(input);
+    if (first.status !== 'error') return first;
+
+    const second = await fallback(input);
+    const result: WebSearchResponse = {
+      ...second,
+      metadata: {
+        ...second.metadata,
+        fallbackFrom,
+        fallbackReason: first.error?.message ?? `${fallbackFrom} search failed.`
+      }
+    };
+    return { ...result, presentation: buildSearchPresentation(result) };
+  };
+}
+
+function withFetchFallback(
+  primary: BackendSet['fetchPage'],
+  fallback: BackendSet['fetchPage']
+): BackendSet['fetchPage'] {
+  return async (input) => {
+    const first = await primary(input);
+    if (first.status !== 'error' && first.status !== 'needs_headless') return first;
+
+    const second = await fallback(input);
+    const result: WebFetchResponse = {
+      ...second,
+      metadata: {
+        ...second.metadata,
+        fallbackFrom: 'firecrawl',
+        fallbackReason: first.error?.message ?? 'Firecrawl fetch failed.'
+      }
+    };
+    return { ...result, presentation: buildFetchPresentation(result) };
+  };
+}
+
+export function createBackendSet(
+  config: BackendConfig = DEFAULT_BACKEND_CONFIG,
+  deps: BackendFactoryDeps = {}
+): BackendSet {
+  const createDuckDuckGoSearch = deps.createDuckDuckGoSearch ?? createWebSearchTool;
+  const createSearxngSearch = deps.createSearxngSearch ?? createSearxngSearchTool;
+  const createBraveSearch = deps.createBraveSearch ?? createBraveSearchTool;
+  const createHttpFetch = deps.createHttpFetch ?? createWebFetchTool;
+  const createFirecrawlFetch = deps.createFirecrawlFetch ?? createFirecrawlFetcher;
+  const createHeadlessFetch = deps.createHeadlessFetch ?? createWebFetchHeadlessTool;
+
+  let search = config.search.provider === 'searxng'
+    ? config.search.baseUrl
+      ? createSearxngSearch({ baseUrl: config.search.baseUrl, options: config.search.options })
+      : invalidSearxngSearch()
+    : config.search.provider === 'brave'
+      ? createBraveSearch({ apiKey: process.env.PI_WEB_AGENT_BRAVE_API_KEY ?? readBraveKeyFromSettings() })
+      : createDuckDuckGoSearch();
+
+  if (config.search.provider === 'searxng' && config.search.fallback === 'duckduckgo') {
+    search = withSearchFallback(search, createDuckDuckGoSearch(), 'searxng');
+  }
+
+  if (config.search.provider === 'brave' && config.search.fallback === 'duckduckgo') {
+    search = withSearchFallback(search, createDuckDuckGoSearch(), 'brave');
+  }
+
+  const httpFetch = createHttpFetch();
+  let fetchPage = config.fetch.provider === 'firecrawl'
+    ? config.fetch.baseUrl
+      ? createHttpFetch({
+          fetchPage: createFirecrawlFetch({
+            baseUrl: config.fetch.baseUrl,
+            apiKey: config.fetch.apiKey ?? process.env.PI_WEB_AGENT_FIRECRAWL_API_KEY,
+            options: config.fetch.options
+          })
+        })
+      : createHttpFetch({ fetchPage: invalidFirecrawlFetch() })
+    : httpFetch;
+
+  if (config.fetch.provider === 'firecrawl' && config.fetch.fallback === 'http') {
+    fetchPage = withFetchFallback(fetchPage, httpFetch);
+  }
+
+  return {
+    search,
+    fetchPage,
+    headlessFetch: createHeadlessFetch()
+  };
+}

package/dist/extensions/pi-web-agent/src/backends/settings-reader.ts

@@ -0,0 +1,25 @@
+// ponytail: selesai stores the Brave API key in settings.json (webAgent.braveApiKey),
+// set by the bundled web-agent-onboarding extension. Upstream pi-web-agent reads the
+// key only from PI_WEB_AGENT_BRAVE_API_KEY env var. This helper bridges that gap with a
+// minimal settings.json read. Ceiling: if selesai moves web search config elsewhere, this
+// helper needs updating; upgrade path = upstream pi-web-agent adopting a settings hook.
+import { existsSync, readFileSync } from 'node:fs';
+import { getSettingsPath } from '@earendil-works/pi-coding-agent';
+
+/**
+ * Read the Brave API key from selesai settings.json (webAgent.braveApiKey).
+ * Returns undefined if settings.json or the key is absent. Never throws.
+ */
+export function readBraveKeyFromSettings(settingsPath: string = getSettingsPath()): string | undefined {
+	try {
+		if (!existsSync(settingsPath)) return undefined;
+		const raw = readFileSync(settingsPath, 'utf-8');
+		const parsed = JSON.parse(raw) as Record<string, unknown>;
+		const webAgent = parsed.webAgent;
+		if (!webAgent || typeof webAgent !== 'object' || Array.isArray(webAgent)) return undefined;
+		const apiKey = (webAgent as Record<string, unknown>).braveApiKey;
+		return typeof apiKey === 'string' && apiKey.trim() !== '' ? apiKey : undefined;
+	} catch {
+		return undefined;
+	}
+}

package/dist/extensions/pi-web-agent/src/cache/ttl-cache.ts

@@ -0,0 +1,28 @@
+export function createCacheKey(parts: Array<string | number | boolean>): string {
+  return JSON.stringify(parts);
+}
+
+export function createTtlCache<T>({
+  ttlMs,
+  now = () => Date.now()
+}: {
+  ttlMs: number;
+  now?: () => number;
+}) {
+  const entries = new Map<string, { value: T; expiresAt: number }>();
+
+  return {
+    get(key: string): T | undefined {
+      const entry = entries.get(key);
+      if (!entry) return undefined;
+      if (entry.expiresAt <= now()) {
+        entries.delete(key);
+        return undefined;
+      }
+      return entry.value;
+    },
+    set(key: string, value: T): void {
+      entries.set(key, { value, expiresAt: now() + ttlMs });
+    }
+  };
+}

package/dist/extensions/pi-web-agent/src/changelog-notice.ts

@@ -0,0 +1,133 @@
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+export type ChangelogEntry = {
+  version: string;
+  content: string;
+};
+
+type ChangelogState = {
+  lastChangelogVersion?: string;
+};
+
+type ChangelogOptions = {
+  packageRoot?: string;
+  statePath?: string;
+};
+
+export function parseChangelogEntries(changelog: string): ChangelogEntry[] {
+  const lines = changelog.split(/\r?\n/);
+  const entries: ChangelogEntry[] = [];
+  let currentVersion: string | undefined;
+  let currentLines: string[] = [];
+
+  function flush() {
+    if (currentVersion && currentLines.length > 0) {
+      entries.push({ version: currentVersion, content: currentLines.join('\n').trim() });
+    }
+  }
+
+  for (const line of lines) {
+    if (line.startsWith('## ')) {
+      flush();
+      const match = line.match(/^##\s+\[?(\d+\.\d+\.\d+)\]?/);
+      currentVersion = match?.[1];
+      currentLines = currentVersion ? [line] : [];
+      continue;
+    }
+
+    if (currentVersion) {
+      currentLines.push(line);
+    }
+  }
+
+  flush();
+  return entries;
+}
+
+function compareVersions(left: string, right: string): number {
+  const leftParts = left.split('.').map(Number);
+  const rightParts = right.split('.').map(Number);
+
+  for (let i = 0; i < 3; i += 1) {
+    const diff = (leftParts[i] || 0) - (rightParts[i] || 0);
+    if (diff !== 0) return diff;
+  }
+
+  return 0;
+}
+
+function defaultPackageRoot() {
+  const here = path.dirname(fileURLToPath(import.meta.url));
+  return path.basename(here) === 'dist' ? path.dirname(here) : path.dirname(here);
+}
+
+function defaultStatePath() {
+  const homeDir = process.env.USERPROFILE ?? process.env.HOME ?? '';
+  return path.join(homeDir, '.pi', 'agent', 'extensions', 'pi-web-agent', 'state.json');
+}
+
+async function readPackageVersion(packageRoot: string): Promise<string | undefined> {
+  try {
+    const raw = await readFile(path.join(packageRoot, 'package.json'), 'utf8');
+    const parsed = JSON.parse(raw) as { version?: unknown };
+    return typeof parsed.version === 'string' ? parsed.version : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+async function readChangelogEntries(packageRoot: string): Promise<ChangelogEntry[]> {
+  try {
+    return parseChangelogEntries(await readFile(path.join(packageRoot, 'CHANGELOG.md'), 'utf8'));
+  } catch {
+    return [];
+  }
+}
+
+async function readState(statePath: string): Promise<ChangelogState> {
+  try {
+    return JSON.parse(await readFile(statePath, 'utf8')) as ChangelogState;
+  } catch {
+    return {};
+  }
+}
+
+export async function markChangelogSeen({ statePath = defaultStatePath(), version }: { statePath?: string; version: string }) {
+  try {
+    await mkdir(path.dirname(statePath), { recursive: true });
+    await writeFile(statePath, `${JSON.stringify({ lastChangelogVersion: version }, null, 2)}\n`, 'utf8');
+  } catch {
+    // Changelog display is best effort. Never block extension startup on state persistence.
+  }
+}
+
+export async function getUpdateChangelogNotice(options: ChangelogOptions = {}): Promise<string | undefined> {
+  const packageRoot = options.packageRoot ?? defaultPackageRoot();
+  const statePath = options.statePath ?? defaultStatePath();
+  const version = await readPackageVersion(packageRoot);
+  if (!version) return undefined;
+
+  const state = await readState(statePath);
+  if (!state.lastChangelogVersion) {
+    await markChangelogSeen({ statePath, version });
+    return undefined;
+  }
+
+  if (compareVersions(version, state.lastChangelogVersion) <= 0) {
+    return undefined;
+  }
+
+  const entries = (await readChangelogEntries(packageRoot))
+    .filter((entry) => compareVersions(entry.version, state.lastChangelogVersion || '0.0.0') > 0)
+    .map((entry) => entry.content);
+
+  await markChangelogSeen({ statePath, version });
+  return entries.length > 0 ? entries.join('\n\n') : undefined;
+}
+
+export async function getLatestChangelogEntry(options: ChangelogOptions = {}): Promise<string | undefined> {
+  const entries = await readChangelogEntries(options.packageRoot ?? defaultPackageRoot());
+  return entries[0]?.content;
+}