@selesai/code 0.9.6 → 0.9.8

package/dist/extensions/pi-web-agent/src/fetch/headless-fetch.ts

@@ -1,117 +1,117 @@
-import { chromium } from 'playwright';
-import { extractReadableContentSafely } from '../extract/readability.js';
-import { resolveBrowserExecutable, type BrowserResolutionResult } from './browser-resolution.js';
-import type { WebFetchHeadlessResponse } from '../types.js';
-
-function cleanupRenderedText(text: string): string {
-  let cleaned = text.replace(/(Show more)(\s+\1){1,}/gi, '$1');
-  cleaned = cleaned.replace(/(Privacy Terms)(\s+\1){1,}/gi, '$1');
-  cleaned = cleaned.replace(/\s+/g, ' ').trim();
-  return cleaned;
-}
-
-export async function headlessFetch(
-  url: string,
-  {
-    configuredPath,
-    resolveBrowser = (options?: { configuredPath?: string }) =>
-      resolveBrowserExecutable({ configuredPath: options?.configuredPath }),
-    launchBrowser = ({ executablePath, headless }: { executablePath?: string; headless: true }) =>
-      chromium.launch(executablePath ? { executablePath, headless } : { headless }),
-    now = () => Date.now()
-  }: {
-    configuredPath?: string;
-    resolveBrowser?: (options?: { configuredPath?: string }) => Promise<BrowserResolutionResult>;
-    launchBrowser?: (options: { executablePath?: string; headless: true }) => Promise<{
-      newContext: () => Promise<{ newPage: () => Promise<any>; close: () => Promise<void> }>;
-      close: () => Promise<void>;
-    }>;
-    now?: () => number;
-  } = {}
-): Promise<WebFetchHeadlessResponse> {
-  const resolved = await resolveBrowser({ configuredPath });
-  if (!resolved.ok && resolved.error.code === 'CONFIGURED_BROWSER_NOT_FOUND') {
-    return {
-      status: 'error',
-      url,
-      metadata: { method: 'headless', cacheHit: false },
-      error: resolved.error
-    };
-  }
-
-  const browserName = resolved.ok ? resolved.browser : 'chromium';
-  const launchOptions = resolved.ok
-    ? { executablePath: resolved.executablePath, headless: true as const }
-    : { headless: true as const };
-
-  let browser: Awaited<ReturnType<typeof launchBrowser>> | undefined;
-  let context: Awaited<ReturnType<Awaited<ReturnType<typeof launchBrowser>>['newContext']>> | undefined;
-  let page: Awaited<ReturnType<Awaited<ReturnType<Awaited<ReturnType<typeof launchBrowser>>['newContext']>>['newPage']>> | undefined;
-
-  try {
-    browser = await launchBrowser(launchOptions);
-    context = await browser.newContext();
-    page = await context.newPage();
-
-    const startedAt = now();
-    await page.goto(url, { waitUntil: 'domcontentloaded', timeout: 20000 });
-    await page.waitForLoadState('load', { timeout: 10000 });
-    await page.waitForLoadState('networkidle', { timeout: 5000 }).catch(() => undefined);
-    const html = await page.content();
-    const finishedAt = now();
-
-    const extraction = extractReadableContentSafely(html);
-    const cleanedContent = {
-      ...extraction.content,
-      text: cleanupRenderedText(extraction.content.text)
-    };
-
-    if (!cleanedContent.text || cleanedContent.text.length < 40) {
-      return {
-        status: 'blocked',
-        url,
-        metadata: {
-          method: 'headless',
-          cacheHit: false,
-          browser: browserName,
-          navigationMs: finishedAt - startedAt
-        },
-        error: {
-          code: 'HEADLESS_EXTRACTION_WEAK',
-          message: 'Rendered page did not produce enough readable content.'
-        }
-      };
-    }
-
-    return {
-      status: 'ok',
-      url,
-      content: cleanedContent,
-      metadata: {
-        method: 'headless',
-        cacheHit: false,
-        browser: browserName,
-        navigationMs: finishedAt - startedAt,
-        truncated: cleanedContent.text.length >= 4000
-      }
-    };
-  } catch (error) {
-    return {
-      status: 'error',
-      url,
-      metadata: {
-        method: 'headless',
-        cacheHit: false,
-        browser: browserName
-      },
-      error: {
-        code: 'HEADLESS_NAVIGATION_FAILED',
-        message: error instanceof Error ? error.message : 'Unknown headless navigation failure.'
-      }
-    };
-  } finally {
-    await page?.close?.().catch(() => undefined);
-    await context?.close?.().catch(() => undefined);
-    await browser?.close?.().catch(() => undefined);
-  }
-}
+import { chromium } from 'playwright';
+import { extractReadableContentSafely } from '../extract/readability.js';
+import { resolveBrowserExecutable, type BrowserResolutionResult } from './browser-resolution.js';
+import type { WebFetchHeadlessResponse } from '../types.js';
+
+function cleanupRenderedText(text: string): string {
+  let cleaned = text.replace(/(Show more)(\s+\1){1,}/gi, '$1');
+  cleaned = cleaned.replace(/(Privacy Terms)(\s+\1){1,}/gi, '$1');
+  cleaned = cleaned.replace(/\s+/g, ' ').trim();
+  return cleaned;
+}
+
+export async function headlessFetch(
+  url: string,
+  {
+    configuredPath,
+    resolveBrowser = (options?: { configuredPath?: string }) =>
+      resolveBrowserExecutable({ configuredPath: options?.configuredPath }),
+    launchBrowser = ({ executablePath, headless }: { executablePath?: string; headless: true }) =>
+      chromium.launch(executablePath ? { executablePath, headless } : { headless }),
+    now = () => Date.now()
+  }: {
+    configuredPath?: string;
+    resolveBrowser?: (options?: { configuredPath?: string }) => Promise<BrowserResolutionResult>;
+    launchBrowser?: (options: { executablePath?: string; headless: true }) => Promise<{
+      newContext: () => Promise<{ newPage: () => Promise<any>; close: () => Promise<void> }>;
+      close: () => Promise<void>;
+    }>;
+    now?: () => number;
+  } = {}
+): Promise<WebFetchHeadlessResponse> {
+  const resolved = await resolveBrowser({ configuredPath });
+  if (!resolved.ok && resolved.error.code === 'CONFIGURED_BROWSER_NOT_FOUND') {
+    return {
+      status: 'error',
+      url,
+      metadata: { method: 'headless', cacheHit: false },
+      error: resolved.error
+    };
+  }
+
+  const browserName = resolved.ok ? resolved.browser : 'chromium';
+  const launchOptions = resolved.ok
+    ? { executablePath: resolved.executablePath, headless: true as const }
+    : { headless: true as const };
+
+  let browser: Awaited<ReturnType<typeof launchBrowser>> | undefined;
+  let context: Awaited<ReturnType<Awaited<ReturnType<typeof launchBrowser>>['newContext']>> | undefined;
+  let page: Awaited<ReturnType<Awaited<ReturnType<Awaited<ReturnType<typeof launchBrowser>>['newContext']>>['newPage']>> | undefined;
+
+  try {
+    browser = await launchBrowser(launchOptions);
+    context = await browser.newContext();
+    page = await context.newPage();
+
+    const startedAt = now();
+    await page.goto(url, { waitUntil: 'domcontentloaded', timeout: 20000 });
+    await page.waitForLoadState('load', { timeout: 10000 });
+    await page.waitForLoadState('networkidle', { timeout: 5000 }).catch(() => undefined);
+    const html = await page.content();
+    const finishedAt = now();
+
+    const extraction = extractReadableContentSafely(html);
+    const cleanedContent = {
+      ...extraction.content,
+      text: cleanupRenderedText(extraction.content.text)
+    };
+
+    if (!cleanedContent.text || cleanedContent.text.length < 40) {
+      return {
+        status: 'blocked',
+        url,
+        metadata: {
+          method: 'headless',
+          cacheHit: false,
+          browser: browserName,
+          navigationMs: finishedAt - startedAt
+        },
+        error: {
+          code: 'HEADLESS_EXTRACTION_WEAK',
+          message: 'Rendered page did not produce enough readable content.'
+        }
+      };
+    }
+
+    return {
+      status: 'ok',
+      url,
+      content: cleanedContent,
+      metadata: {
+        method: 'headless',
+        cacheHit: false,
+        browser: browserName,
+        navigationMs: finishedAt - startedAt,
+        truncated: cleanedContent.text.length >= 4000
+      }
+    };
+  } catch (error) {
+    return {
+      status: 'error',
+      url,
+      metadata: {
+        method: 'headless',
+        cacheHit: false,
+        browser: browserName
+      },
+      error: {
+        code: 'HEADLESS_NAVIGATION_FAILED',
+        message: error instanceof Error ? error.message : 'Unknown headless navigation failure.'
+      }
+    };
+  } finally {
+    await page?.close?.().catch(() => undefined);
+    await context?.close?.().catch(() => undefined);
+    await browser?.close?.().catch(() => undefined);
+  }
+}

package/dist/extensions/pi-web-agent/src/fetch/http-fetch.ts

@@ -1,67 +1,67 @@
-import { extractReadableContentSafely } from '../extract/readability.js';
-import type { WebFetchResponse } from '../types.js';
-
-function looksLikeScriptShell(html: string): boolean {
-  const lower = html.toLowerCase();
-  return lower.includes('<script') && (lower.includes('id="app"') || lower.includes('id="root"'));
-}
-
-function isWeakHttpContent(options: { html: string; title?: string; text: string }): boolean {
-  const normalizedText = options.text.replace(/\s+/g, ' ').trim();
-  const normalizedHtml = options.html.replace(/\s+/g, ' ').trim();
-  const textLength = normalizedText.length;
-  const htmlLength = normalizedHtml.length;
-  const hasGenericShellMarker = /enable javascript|javascript required|please turn on javascript/i.test(
-    options.html
-  );
-  const veryShortBody = textLength > 0 && textLength < 120;
-  const lowDensity = htmlLength > 0 && textLength / htmlLength < 0.02;
-
-  return veryShortBody && (lowDensity || hasGenericShellMarker);
-}
-
-export function createHttpFetcher({
-  fetchImpl = fetch
-}: {
-  fetchImpl?: typeof fetch;
-} = {}) {
-  return async function httpFetch(url: string): Promise<WebFetchResponse> {
-    const response = await fetchImpl(url);
-    const contentType = response.headers.get('content-type') ?? '';
-
-    if (!contentType.includes('text/html')) {
-      return {
-        status: 'unsupported',
-        url: response.url,
-        metadata: { method: 'http', cacheHit: false, contentType }
-      };
-    }
-
-    const html = await response.text();
-    const extraction = extractReadableContentSafely(html);
-    const content = extraction.content;
-
-    if (
-      looksLikeScriptShell(html) ||
-      content.text.length < 40 ||
-      isWeakHttpContent({ html, title: content.title, text: content.text })
-    ) {
-      return {
-        status: 'needs_headless',
-        url: response.url,
-        metadata: { method: 'http', cacheHit: false, contentType },
-        error: {
-          code: 'WEAK_EXTRACTION',
-          message: 'HTTP extraction was not reliable enough.'
-        }
-      };
-    }
-
-    return {
-      status: 'ok',
-      url: response.url,
-      content,
-      metadata: { method: 'http', cacheHit: false, contentType, truncated: content.text.length >= 4000 }
-    };
-  };
-}
+import { extractReadableContentSafely } from '../extract/readability.js';
+import type { WebFetchResponse } from '../types.js';
+
+function looksLikeScriptShell(html: string): boolean {
+  const lower = html.toLowerCase();
+  return lower.includes('<script') && (lower.includes('id="app"') || lower.includes('id="root"'));
+}
+
+function isWeakHttpContent(options: { html: string; title?: string; text: string }): boolean {
+  const normalizedText = options.text.replace(/\s+/g, ' ').trim();
+  const normalizedHtml = options.html.replace(/\s+/g, ' ').trim();
+  const textLength = normalizedText.length;
+  const htmlLength = normalizedHtml.length;
+  const hasGenericShellMarker = /enable javascript|javascript required|please turn on javascript/i.test(
+    options.html
+  );
+  const veryShortBody = textLength > 0 && textLength < 120;
+  const lowDensity = htmlLength > 0 && textLength / htmlLength < 0.02;
+
+  return veryShortBody && (lowDensity || hasGenericShellMarker);
+}
+
+export function createHttpFetcher({
+  fetchImpl = fetch
+}: {
+  fetchImpl?: typeof fetch;
+} = {}) {
+  return async function httpFetch(url: string): Promise<WebFetchResponse> {
+    const response = await fetchImpl(url);
+    const contentType = response.headers.get('content-type') ?? '';
+
+    if (!contentType.includes('text/html')) {
+      return {
+        status: 'unsupported',
+        url: response.url,
+        metadata: { method: 'http', cacheHit: false, contentType }
+      };
+    }
+
+    const html = await response.text();
+    const extraction = extractReadableContentSafely(html);
+    const content = extraction.content;
+
+    if (
+      looksLikeScriptShell(html) ||
+      content.text.length < 40 ||
+      isWeakHttpContent({ html, title: content.title, text: content.text })
+    ) {
+      return {
+        status: 'needs_headless',
+        url: response.url,
+        metadata: { method: 'http', cacheHit: false, contentType },
+        error: {
+          code: 'WEAK_EXTRACTION',
+          message: 'HTTP extraction was not reliable enough.'
+        }
+      };
+    }
+
+    return {
+      status: 'ok',
+      url: response.url,
+      content,
+      metadata: { method: 'http', cacheHit: false, contentType, truncated: content.text.length >= 4000 }
+    };
+  };
+}

package/dist/extensions/pi-web-agent/src/orchestration/answer-synthesizer.ts

@@ -1,60 +1,60 @@
-import type { ResearchEvidence } from './research-types.js';
-import type { EvidenceCaveatReason } from './evidence-quality.js';
-
-function normalizeSummary(summary: string) {
-  return summary.replace(/\s+/g, ' ').trim();
-}
-
-function sentenceForReason(reason: EvidenceCaveatReason): string {
-  switch (reason) {
-    case 'community-only':
-      return 'the strongest readable sources were mostly community/practical context';
-    case 'low-diversity':
-      return 'the source set was narrow';
-    case 'unreadable-direct-source':
-      return 'one or more linked sources could not be read reliably';
-    case 'unreadable-thread-source':
-      return 'one or more thread sources could not be read reliably';
-    case 'possible-conflict':
-      return 'readable sources include cautionary or possibly conflicting guidance';
-    case 'bot-check':
-      return 'some candidate sources showed bot-check or security verification pages';
-  }
-}
-
-function joinReasons(reasons: string[]) {
-  if (reasons.length === 0) return '';
-  if (reasons.length === 1) return reasons[0];
-  return `${reasons.slice(0, -1).join(', ')}, and ${reasons.at(-1)}`;
-}
-
-function caveatText(partial: boolean, caveatReasons: EvidenceCaveatReason[] = []) {
-  if (!partial) return undefined;
-  const specificReasons = caveatReasons.map(sentenceForReason);
-  if (specificReasons.length > 0) {
-    return `Evidence is partial: ${joinReasons(specificReasons)}.`;
-  }
-  return 'Evidence is partial, so this answer is based on the strongest source found within the bounded research budget.';
-}
-
-export function synthesizeAnswer({
-  evidence,
-  partial,
-  caveatReasons = []
-}: {
-  evidence: ResearchEvidence[];
-  partial: boolean;
-  caveatReasons?: EvidenceCaveatReason[];
-}) {
-  const findings = evidence.slice(0, 5).map((item) => {
-    const summary = normalizeSummary(item.summary);
-    return item.sourceKind === 'community' || item.sourceKind === 'issue-thread'
-      ? `Community/practical context: ${summary}`
-      : summary;
-  });
-
-  return {
-    findings,
-    caveat: caveatText(partial, caveatReasons)
-  };
-}
+import type { ResearchEvidence } from './research-types.js';
+import type { EvidenceCaveatReason } from './evidence-quality.js';
+
+function normalizeSummary(summary: string) {
+  return summary.replace(/\s+/g, ' ').trim();
+}
+
+function sentenceForReason(reason: EvidenceCaveatReason): string {
+  switch (reason) {
+    case 'community-only':
+      return 'the strongest readable sources were mostly community/practical context';
+    case 'low-diversity':
+      return 'the source set was narrow';
+    case 'unreadable-direct-source':
+      return 'one or more linked sources could not be read reliably';
+    case 'unreadable-thread-source':
+      return 'one or more thread sources could not be read reliably';
+    case 'possible-conflict':
+      return 'readable sources include cautionary or possibly conflicting guidance';
+    case 'bot-check':
+      return 'some candidate sources showed bot-check or security verification pages';
+  }
+}
+
+function joinReasons(reasons: string[]) {
+  if (reasons.length === 0) return '';
+  if (reasons.length === 1) return reasons[0];
+  return `${reasons.slice(0, -1).join(', ')}, and ${reasons.at(-1)}`;
+}
+
+function caveatText(partial: boolean, caveatReasons: EvidenceCaveatReason[] = []) {
+  if (!partial) return undefined;
+  const specificReasons = caveatReasons.map(sentenceForReason);
+  if (specificReasons.length > 0) {
+    return `Evidence is partial: ${joinReasons(specificReasons)}.`;
+  }
+  return 'Evidence is partial, so this answer is based on the strongest source found within the bounded research budget.';
+}
+
+export function synthesizeAnswer({
+  evidence,
+  partial,
+  caveatReasons = []
+}: {
+  evidence: ResearchEvidence[];
+  partial: boolean;
+  caveatReasons?: EvidenceCaveatReason[];
+}) {
+  const findings = evidence.slice(0, 5).map((item) => {
+    const summary = normalizeSummary(item.summary);
+    return item.sourceKind === 'community' || item.sourceKind === 'issue-thread'
+      ? `Community/practical context: ${summary}`
+      : summary;
+  });
+
+  return {
+    findings,
+    caveat: caveatText(partial, caveatReasons)
+  };
+}

package/dist/extensions/pi-web-agent/src/orchestration/candidate-selector.ts

@@ -1,50 +1,50 @@
-import type { SearchResult } from '../types.js';
-import { classifySourceProfile } from './source-profile.js';
-
-function wantsDiscussionSources(query = '') {
-  return /reddit|forum|forums|discussion|thread|comments|community|user experience|people recommend/i.test(query);
-}
-
-function candidateScore(result: SearchResult, query?: string) {
-  const url = result.url.toLowerCase();
-  const profile = classifySourceProfile(result.url);
-  const wantsThreads = wantsDiscussionSources(query);
-
-  if (profile.kind === 'official-docs') return 0;
-  if (profile.kind === 'official-api') return 1;
-
-  if (wantsThreads) {
-    if (profile.kind === 'forum-thread') return 2;
-    if (profile.kind === 'issue-thread') return 3;
-    if (url.includes('github.com/')) return 4;
-    if (profile.kind === 'package-page') return 6;
-    return 5;
-  }
-
-  if (profile.kind === 'issue-thread') return 2;
-  if (url.includes('github.com/')) return 3;
-  if (profile.kind === 'package-page') return 5;
-  return 4;
-}
-
-export function selectCandidates({
-  query,
-  results,
-  seenUrls,
-  maxCandidates
-}: {
-  query?: string;
-  results: SearchResult[];
-  seenUrls: Set<string>;
-  maxCandidates: number;
-}) {
-  const deduped = new Map<string, SearchResult>();
-  for (const result of results) {
-    if (seenUrls.has(result.url)) continue;
-    if (!deduped.has(result.url)) deduped.set(result.url, result);
-  }
-
-  return [...deduped.values()]
-    .sort((left, right) => candidateScore(left, query) - candidateScore(right, query))
-    .slice(0, maxCandidates);
-}
+import type { SearchResult } from '../types.js';
+import { classifySourceProfile } from './source-profile.js';
+
+function wantsDiscussionSources(query = '') {
+  return /reddit|forum|forums|discussion|thread|comments|community|user experience|people recommend/i.test(query);
+}
+
+function candidateScore(result: SearchResult, query?: string) {
+  const url = result.url.toLowerCase();
+  const profile = classifySourceProfile(result.url);
+  const wantsThreads = wantsDiscussionSources(query);
+
+  if (profile.kind === 'official-docs') return 0;
+  if (profile.kind === 'official-api') return 1;
+
+  if (wantsThreads) {
+    if (profile.kind === 'forum-thread') return 2;
+    if (profile.kind === 'issue-thread') return 3;
+    if (url.includes('github.com/')) return 4;
+    if (profile.kind === 'package-page') return 6;
+    return 5;
+  }
+
+  if (profile.kind === 'issue-thread') return 2;
+  if (url.includes('github.com/')) return 3;
+  if (profile.kind === 'package-page') return 5;
+  return 4;
+}
+
+export function selectCandidates({
+  query,
+  results,
+  seenUrls,
+  maxCandidates
+}: {
+  query?: string;
+  results: SearchResult[];
+  seenUrls: Set<string>;
+  maxCandidates: number;
+}) {
+  const deduped = new Map<string, SearchResult>();
+  for (const result of results) {
+    if (seenUrls.has(result.url)) continue;
+    if (!deduped.has(result.url)) deduped.set(result.url, result);
+  }
+
+  return [...deduped.values()]
+    .sort((left, right) => candidateScore(left, query) - candidateScore(right, query))
+    .slice(0, maxCandidates);
+}