@selesai/code 0.10.1 → 0.10.2

package/dist/extensions/pi-web-agent/src/orchestration/research-types.ts

@@ -1,64 +1,64 @@
-export type ResearchSourceKind =
-  | 'official-docs'
-  | 'official-api'
-  | 'official-discussion'
-  | 'community'
-  | 'issue-thread'
-  | 'package-page'
-  | 'other';
-
-export type ResearchMethod = 'search' | 'http' | 'headless' | 'firecrawl';
-
-export type ResearchEvidence = {
-  title: string;
-  url: string;
-  sourceKind: ResearchSourceKind;
-  method: Exclude<ResearchMethod, 'search'>;
-  summary: string;
-  supports: string[];
-};
-
-export type ResearchGap = {
-  kind: 'needs-more-evidence' | 'conflict' | 'fetch-failed';
-  message: string;
-};
-
-export type ResearchLowValueOutcome = {
-  kind: 'empty-search' | 'bot-check' | 'low-value-page' | 'duplicate-evidence';
-  url?: string;
-  message: string;
-};
-
-export type ResearchWorkerResult = {
-  searchQueries: string[];
-  evidence: ResearchEvidence[];
-  gaps: ResearchGap[];
-  lowValueOutcomes: ResearchLowValueOutcome[];
-  suggestedHeadlessUrl?: string;
-  exhaustedBudget: boolean;
-};
-
-export type ResearchRunMetadata = {
-  searchPasses: number;
-  fetchedPages: number;
-  headlessAttempts: number;
-  exhaustedBudget: boolean;
-};
-
-export type ResearchOrchestratorDecision =
-  | {
-      action: 'answer';
-      rationale: string;
-      approvedEvidence: ResearchEvidence[];
-    }
-  | {
-      action: 'research-again';
-      rationale: string;
-      followupQuery: string;
-    }
-  | {
-      action: 'escalate-headless';
-      rationale: string;
-      url: string;
-      approvedEvidence: ResearchEvidence[];
-    };
+export type ResearchSourceKind =
+  | 'official-docs'
+  | 'official-api'
+  | 'official-discussion'
+  | 'community'
+  | 'issue-thread'
+  | 'package-page'
+  | 'other';
+
+export type ResearchMethod = 'search' | 'http' | 'headless' | 'firecrawl';
+
+export type ResearchEvidence = {
+  title: string;
+  url: string;
+  sourceKind: ResearchSourceKind;
+  method: Exclude<ResearchMethod, 'search'>;
+  summary: string;
+  supports: string[];
+};
+
+export type ResearchGap = {
+  kind: 'needs-more-evidence' | 'conflict' | 'fetch-failed';
+  message: string;
+};
+
+export type ResearchLowValueOutcome = {
+  kind: 'empty-search' | 'bot-check' | 'low-value-page' | 'duplicate-evidence';
+  url?: string;
+  message: string;
+};
+
+export type ResearchWorkerResult = {
+  searchQueries: string[];
+  evidence: ResearchEvidence[];
+  gaps: ResearchGap[];
+  lowValueOutcomes: ResearchLowValueOutcome[];
+  suggestedHeadlessUrl?: string;
+  exhaustedBudget: boolean;
+};
+
+export type ResearchRunMetadata = {
+  searchPasses: number;
+  fetchedPages: number;
+  headlessAttempts: number;
+  exhaustedBudget: boolean;
+};
+
+export type ResearchOrchestratorDecision =
+  | {
+      action: 'answer';
+      rationale: string;
+      approvedEvidence: ResearchEvidence[];
+    }
+  | {
+      action: 'research-again';
+      rationale: string;
+      followupQuery: string;
+    }
+  | {
+      action: 'escalate-headless';
+      rationale: string;
+      url: string;
+      approvedEvidence: ResearchEvidence[];
+    };

package/dist/extensions/pi-web-agent/src/orchestration/research-worker.ts

@@ -1,181 +1,181 @@
-import type { WebFetchResponse, WebSearchResponse } from '../types.js';
-import { selectCandidates } from './candidate-selector.js';
-import { classifySourceProfile } from './source-profile.js';
-import type {
-  ResearchEvidence,
-  ResearchGap,
-  ResearchLowValueOutcome,
-  ResearchSourceKind,
-  ResearchWorkerResult
-} from './research-types.js';
-
-function classifySource(url: string): ResearchSourceKind {
-  return classifySourceProfile(url).sourceKind;
-}
-
-function summarizeText(text: string, maxLength = 180): string {
-  return text.replace(/\s+/g, ' ').trim().slice(0, maxLength);
-}
-
-function isBotCheckContent({ title = '', text }: { title?: string; text: string }) {
-  return /performing security verification|security service|verify you are not a bot|just a moment|checking your browser/i.test(
-    `${title}\n${text}`
-  );
-}
-
-function evidenceFromFetch(fetched: WebFetchResponse, fallbackTitle: string) {
-  const content = fetched.content;
-  if (fetched.status !== 'ok' || !content) return null;
-  if (isBotCheckContent({ title: content.title, text: content.text })) return null;
-
-  const sourceKind = classifySource(fetched.url);
-  if (sourceKind === 'package-page') {
-    return null;
-  }
-
-  return {
-    title: content.title ?? fallbackTitle,
-    url: fetched.url,
-    sourceKind,
-    method: fetched.metadata.method,
-    summary: summarizeText(content.text),
-    supports: [summarizeText(content.text, 120)]
-  } satisfies ResearchEvidence;
-}
-
-function lowValueOutcomeFromFetch(fetched: WebFetchResponse): ResearchLowValueOutcome | null {
-  if (fetched.status !== 'ok' || !fetched.content) return null;
-
-  if (isBotCheckContent({ title: fetched.content.title, text: fetched.content.text })) {
-    return {
-      kind: 'bot-check',
-      url: fetched.url,
-      message: 'Fetched page showed a bot-check or security verification page.'
-    };
-  }
-
-  if (classifySource(fetched.url) !== 'package-page') return null;
-
-  return {
-    kind: 'low-value-page',
-    url: fetched.url,
-    message: 'Fetched page did not add strong research evidence.'
-  };
-}
-
-export function createResearchWorker({
-  search,
-  fetchPage
-}: {
-  search: (input: { query: string }) => Promise<WebSearchResponse>;
-  fetchPage: (input: { url: string }) => Promise<WebFetchResponse>;
-}) {
-  return {
-    async run({
-      query,
-      maxSearchRounds,
-      maxFetches
-    }: {
-      query: string;
-      maxSearchRounds: number;
-      maxFetches: number;
-    }): Promise<ResearchWorkerResult> {
-      const searchQueries = [query];
-      const evidence: ResearchEvidence[] = [];
-      const gaps: ResearchGap[] = [];
-      const lowValueOutcomes: ResearchLowValueOutcome[] = [];
-      let suggestedHeadlessUrl: string | undefined;
-
-      if (maxSearchRounds <= 0 || maxFetches <= 0) {
-        return {
-          searchQueries: [],
-          evidence,
-          gaps: [{ kind: 'needs-more-evidence', message: 'Research worker budget was zero.' }],
-          lowValueOutcomes,
-          suggestedHeadlessUrl,
-          exhaustedBudget: true
-        };
-      }
-
-      const searchResult = await search({ query });
-      if (searchResult.status !== 'ok') {
-        return {
-          searchQueries,
-          evidence,
-          gaps: [
-            {
-              kind: 'fetch-failed',
-              message: searchResult.error?.message ?? 'Search failed during research worker pass.'
-            }
-          ],
-          lowValueOutcomes,
-          suggestedHeadlessUrl,
-          exhaustedBudget: false
-        };
-      }
-
-      if (searchResult.results.length === 0) {
-        return {
-          searchQueries,
-          evidence,
-          gaps,
-          lowValueOutcomes: [
-            {
-              kind: 'empty-search',
-              message: 'Search returned no results for this pass.'
-            }
-          ],
-          suggestedHeadlessUrl,
-          exhaustedBudget: false
-        };
-      }
-
-      const candidates = selectCandidates({
-        query,
-        results: searchResult.results,
-        seenUrls: new Set(evidence.map((item) => item.url)),
-        maxCandidates: maxFetches
-      });
-
-      for (const candidate of candidates) {
-        const fetched = await fetchPage({ url: candidate.url });
-
-        if (fetched.status === 'ok') {
-          const parsedEvidence = evidenceFromFetch(fetched, candidate.title);
-          if (parsedEvidence) {
-            evidence.push(parsedEvidence);
-            continue;
-          }
-
-          const lowValueOutcome = lowValueOutcomeFromFetch(fetched);
-          if (lowValueOutcome) {
-            lowValueOutcomes.push(lowValueOutcome);
-          }
-          continue;
-        }
-
-        if (fetched.status === 'needs_headless') {
-          if (!suggestedHeadlessUrl) {
-            suggestedHeadlessUrl = fetched.url;
-          }
-          gaps.push({ kind: 'fetch-failed', message: `HTTP fetch was weak for ${fetched.url}` });
-          continue;
-        }
-
-        gaps.push({
-          kind: 'fetch-failed',
-          message: fetched.error?.message ?? `Fetch failed for ${candidate.url}`
-        });
-      }
-
-      return {
-        searchQueries,
-        evidence,
-        gaps,
-        lowValueOutcomes,
-        suggestedHeadlessUrl,
-        exhaustedBudget: false
-      };
-    }
-  };
-}
+import type { WebFetchResponse, WebSearchResponse } from '../types.js';
+import { selectCandidates } from './candidate-selector.js';
+import { classifySourceProfile } from './source-profile.js';
+import type {
+  ResearchEvidence,
+  ResearchGap,
+  ResearchLowValueOutcome,
+  ResearchSourceKind,
+  ResearchWorkerResult
+} from './research-types.js';
+
+function classifySource(url: string): ResearchSourceKind {
+  return classifySourceProfile(url).sourceKind;
+}
+
+function summarizeText(text: string, maxLength = 180): string {
+  return text.replace(/\s+/g, ' ').trim().slice(0, maxLength);
+}
+
+function isBotCheckContent({ title = '', text }: { title?: string; text: string }) {
+  return /performing security verification|security service|verify you are not a bot|just a moment|checking your browser/i.test(
+    `${title}\n${text}`
+  );
+}
+
+function evidenceFromFetch(fetched: WebFetchResponse, fallbackTitle: string) {
+  const content = fetched.content;
+  if (fetched.status !== 'ok' || !content) return null;
+  if (isBotCheckContent({ title: content.title, text: content.text })) return null;
+
+  const sourceKind = classifySource(fetched.url);
+  if (sourceKind === 'package-page') {
+    return null;
+  }
+
+  return {
+    title: content.title ?? fallbackTitle,
+    url: fetched.url,
+    sourceKind,
+    method: fetched.metadata.method,
+    summary: summarizeText(content.text),
+    supports: [summarizeText(content.text, 120)]
+  } satisfies ResearchEvidence;
+}
+
+function lowValueOutcomeFromFetch(fetched: WebFetchResponse): ResearchLowValueOutcome | null {
+  if (fetched.status !== 'ok' || !fetched.content) return null;
+
+  if (isBotCheckContent({ title: fetched.content.title, text: fetched.content.text })) {
+    return {
+      kind: 'bot-check',
+      url: fetched.url,
+      message: 'Fetched page showed a bot-check or security verification page.'
+    };
+  }
+
+  if (classifySource(fetched.url) !== 'package-page') return null;
+
+  return {
+    kind: 'low-value-page',
+    url: fetched.url,
+    message: 'Fetched page did not add strong research evidence.'
+  };
+}
+
+export function createResearchWorker({
+  search,
+  fetchPage
+}: {
+  search: (input: { query: string }) => Promise<WebSearchResponse>;
+  fetchPage: (input: { url: string }) => Promise<WebFetchResponse>;
+}) {
+  return {
+    async run({
+      query,
+      maxSearchRounds,
+      maxFetches
+    }: {
+      query: string;
+      maxSearchRounds: number;
+      maxFetches: number;
+    }): Promise<ResearchWorkerResult> {
+      const searchQueries = [query];
+      const evidence: ResearchEvidence[] = [];
+      const gaps: ResearchGap[] = [];
+      const lowValueOutcomes: ResearchLowValueOutcome[] = [];
+      let suggestedHeadlessUrl: string | undefined;
+
+      if (maxSearchRounds <= 0 || maxFetches <= 0) {
+        return {
+          searchQueries: [],
+          evidence,
+          gaps: [{ kind: 'needs-more-evidence', message: 'Research worker budget was zero.' }],
+          lowValueOutcomes,
+          suggestedHeadlessUrl,
+          exhaustedBudget: true
+        };
+      }
+
+      const searchResult = await search({ query });
+      if (searchResult.status !== 'ok') {
+        return {
+          searchQueries,
+          evidence,
+          gaps: [
+            {
+              kind: 'fetch-failed',
+              message: searchResult.error?.message ?? 'Search failed during research worker pass.'
+            }
+          ],
+          lowValueOutcomes,
+          suggestedHeadlessUrl,
+          exhaustedBudget: false
+        };
+      }
+
+      if (searchResult.results.length === 0) {
+        return {
+          searchQueries,
+          evidence,
+          gaps,
+          lowValueOutcomes: [
+            {
+              kind: 'empty-search',
+              message: 'Search returned no results for this pass.'
+            }
+          ],
+          suggestedHeadlessUrl,
+          exhaustedBudget: false
+        };
+      }
+
+      const candidates = selectCandidates({
+        query,
+        results: searchResult.results,
+        seenUrls: new Set(evidence.map((item) => item.url)),
+        maxCandidates: maxFetches
+      });
+
+      for (const candidate of candidates) {
+        const fetched = await fetchPage({ url: candidate.url });
+
+        if (fetched.status === 'ok') {
+          const parsedEvidence = evidenceFromFetch(fetched, candidate.title);
+          if (parsedEvidence) {
+            evidence.push(parsedEvidence);
+            continue;
+          }
+
+          const lowValueOutcome = lowValueOutcomeFromFetch(fetched);
+          if (lowValueOutcome) {
+            lowValueOutcomes.push(lowValueOutcome);
+          }
+          continue;
+        }
+
+        if (fetched.status === 'needs_headless') {
+          if (!suggestedHeadlessUrl) {
+            suggestedHeadlessUrl = fetched.url;
+          }
+          gaps.push({ kind: 'fetch-failed', message: `HTTP fetch was weak for ${fetched.url}` });
+          continue;
+        }
+
+        gaps.push({
+          kind: 'fetch-failed',
+          message: fetched.error?.message ?? `Fetch failed for ${candidate.url}`
+        });
+      }
+
+      return {
+        searchQueries,
+        evidence,
+        gaps,
+        lowValueOutcomes,
+        suggestedHeadlessUrl,
+        exhaustedBudget: false
+      };
+    }
+  };
+}