@selesai/code 0.10.2 → 0.11.0

package/dist/extensions/pi-web-agent/src/tools/web-explore.ts

@@ -1,71 +1,71 @@
-import { createResearchWorkflow } from '../orchestration/index.js';
-import { synthesizeAnswer } from '../orchestration/answer-synthesizer.js';
-import type { ResearchEvidence } from '../orchestration/research-types.js';
-import { buildExplorePresentation } from '../presentation/explore-presentation.js';
-import type { EvidenceCaveatReason } from '../orchestration/evidence-quality.js';
-import type { WebExploreResponse } from '../types.js';
-
-export function createWebExploreTool({
-  explore = createResearchWorkflow()
-}: {
-  explore?:
-    | {
-        run: (input: { query: string }) => Promise<{
-          decision: { action: 'answer' | 'research-again' | 'escalate-headless' };
-          evidence: ResearchEvidence[];
-          workerPass: unknown;
-          metadata?: WebExploreResponse['metadata'];
-        }>;
-      }
-    | ((input: { query: string }) => Promise<{
-        decision: { action: 'answer' | 'research-again' | 'escalate-headless' };
-        evidence: ResearchEvidence[];
-        workerPass: unknown;
-        metadata?: WebExploreResponse['metadata'];
-      }>);
-} = {}) {
-  const runExplore = typeof explore === 'function' ? explore : explore.run.bind(explore);
-
-  return async function webExplore({ query }: { query: string }) {
-    const normalizedQuery = query.trim();
-
-    if (!normalizedQuery) {
-      const result: WebExploreResponse = {
-        status: 'error',
-        findings: [],
-        sources: [],
-        error: { code: 'INVALID_QUERY', message: 'Query must not be empty.' }
-      };
-
-      return {
-        ...result,
-        presentation: buildExplorePresentation(result)
-      };
-    }
-
-    const result = await runExplore({ query: normalizedQuery });
-    const sources = result.evidence.slice(0, 4).map((item) => ({
-      title: item.title,
-      url: item.url,
-      method: item.method
-    }));
-    const synthesized = synthesizeAnswer({
-      evidence: result.evidence,
-      partial: result.decision.action !== 'answer',
-      caveatReasons: result.metadata?.caveatReasons as EvidenceCaveatReason[] | undefined
-    });
-
-    const shaped: WebExploreResponse = {
-      status: 'ok',
-      findings: synthesized.findings,
-      sources,
-      caveat: synthesized.caveat,
-      metadata: result.metadata
-    };
-
-    return {
-      ...shaped,
-      presentation: buildExplorePresentation(shaped)
-    };
-  };
-}
+import { createResearchWorkflow } from '../orchestration/index.js';
+import { synthesizeAnswer } from '../orchestration/answer-synthesizer.js';
+import type { ResearchEvidence } from '../orchestration/research-types.js';
+import { buildExplorePresentation } from '../presentation/explore-presentation.js';
+import type { EvidenceCaveatReason } from '../orchestration/evidence-quality.js';
+import type { WebExploreResponse } from '../types.js';
+
+export function createWebExploreTool({
+  explore = createResearchWorkflow()
+}: {
+  explore?:
+    | {
+        run: (input: { query: string }) => Promise<{
+          decision: { action: 'answer' | 'research-again' | 'escalate-headless' };
+          evidence: ResearchEvidence[];
+          workerPass: unknown;
+          metadata?: WebExploreResponse['metadata'];
+        }>;
+      }
+    | ((input: { query: string }) => Promise<{
+        decision: { action: 'answer' | 'research-again' | 'escalate-headless' };
+        evidence: ResearchEvidence[];
+        workerPass: unknown;
+        metadata?: WebExploreResponse['metadata'];
+      }>);
+} = {}) {
+  const runExplore = typeof explore === 'function' ? explore : explore.run.bind(explore);
+
+  return async function webExplore({ query }: { query: string }) {
+    const normalizedQuery = query.trim();
+
+    if (!normalizedQuery) {
+      const result: WebExploreResponse = {
+        status: 'error',
+        findings: [],
+        sources: [],
+        error: { code: 'INVALID_QUERY', message: 'Query must not be empty.' }
+      };
+
+      return {
+        ...result,
+        presentation: buildExplorePresentation(result)
+      };
+    }
+
+    const result = await runExplore({ query: normalizedQuery });
+    const sources = result.evidence.slice(0, 4).map((item) => ({
+      title: item.title,
+      url: item.url,
+      method: item.method
+    }));
+    const synthesized = synthesizeAnswer({
+      evidence: result.evidence,
+      partial: result.decision.action !== 'answer',
+      caveatReasons: result.metadata?.caveatReasons as EvidenceCaveatReason[] | undefined
+    });
+
+    const shaped: WebExploreResponse = {
+      status: 'ok',
+      findings: synthesized.findings,
+      sources,
+      caveat: synthesized.caveat,
+      metadata: result.metadata
+    };
+
+    return {
+      ...shaped,
+      presentation: buildExplorePresentation(shaped)
+    };
+  };
+}

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

@@ -1,31 +1,31 @@
-import { headlessFetch } from '../fetch/headless-fetch.js';
-import { buildFetchPresentation } from '../presentation/fetch-presentation.js';
-import type { WebFetchHeadlessResponse } from '../types.js';
-
-export function createWebFetchHeadlessTool({
-  fetchPage = headlessFetch
-}: {
-  fetchPage?: (url: string) => Promise<WebFetchHeadlessResponse>;
-} = {}) {
-  return async function webFetchHeadless({ url }: { url: string }): Promise<WebFetchHeadlessResponse> {
-    if (!/^https?:\/\//.test(url)) {
-      const result: WebFetchHeadlessResponse = {
-        status: 'unsupported',
-        url,
-        metadata: { method: 'headless', cacheHit: false },
-        error: { code: 'UNSUPPORTED_URL', message: 'Only http and https URLs are supported.' }
-      };
-
-      return {
-        ...result,
-        presentation: buildFetchPresentation(result)
-      };
-    }
-
-    const result = await fetchPage(url);
-    return {
-      ...result,
-      presentation: buildFetchPresentation(result)
-    };
-  };
-}
+import { headlessFetch } from '../fetch/headless-fetch.js';
+import { buildFetchPresentation } from '../presentation/fetch-presentation.js';
+import type { WebFetchHeadlessResponse } from '../types.js';
+
+export function createWebFetchHeadlessTool({
+  fetchPage = headlessFetch
+}: {
+  fetchPage?: (url: string) => Promise<WebFetchHeadlessResponse>;
+} = {}) {
+  return async function webFetchHeadless({ url }: { url: string }): Promise<WebFetchHeadlessResponse> {
+    if (!/^https?:\/\//.test(url)) {
+      const result: WebFetchHeadlessResponse = {
+        status: 'unsupported',
+        url,
+        metadata: { method: 'headless', cacheHit: false },
+        error: { code: 'UNSUPPORTED_URL', message: 'Only http and https URLs are supported.' }
+      };
+
+      return {
+        ...result,
+        presentation: buildFetchPresentation(result)
+      };
+    }
+
+    const result = await fetchPage(url);
+    return {
+      ...result,
+      presentation: buildFetchPresentation(result)
+    };
+  };
+}

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

@@ -1,31 +1,31 @@
-import { createHttpFetcher } from '../fetch/http-fetch.js';
-import { buildFetchPresentation } from '../presentation/fetch-presentation.js';
-import type { WebFetchResponse } from '../types.js';
-
-export function createWebFetchTool({
-  fetchPage = createHttpFetcher()
-}: {
-  fetchPage?: (url: string) => Promise<WebFetchResponse>;
-} = {}) {
-  return async function webFetch({ url }: { url: string }): Promise<WebFetchResponse> {
-    if (!/^https?:\/\//.test(url)) {
-      const result: WebFetchResponse = {
-        status: 'unsupported',
-        url,
-        metadata: { method: 'http', cacheHit: false },
-        error: { code: 'UNSUPPORTED_URL', message: 'Only http and https URLs are supported.' }
-      };
-
-      return {
-        ...result,
-        presentation: buildFetchPresentation(result)
-      };
-    }
-
-    const result = await fetchPage(url);
-    return {
-      ...result,
-      presentation: buildFetchPresentation(result)
-    };
-  };
-}
+import { createHttpFetcher } from '../fetch/http-fetch.js';
+import { buildFetchPresentation } from '../presentation/fetch-presentation.js';
+import type { WebFetchResponse } from '../types.js';
+
+export function createWebFetchTool({
+  fetchPage = createHttpFetcher()
+}: {
+  fetchPage?: (url: string) => Promise<WebFetchResponse>;
+} = {}) {
+  return async function webFetch({ url }: { url: string }): Promise<WebFetchResponse> {
+    if (!/^https?:\/\//.test(url)) {
+      const result: WebFetchResponse = {
+        status: 'unsupported',
+        url,
+        metadata: { method: 'http', cacheHit: false },
+        error: { code: 'UNSUPPORTED_URL', message: 'Only http and https URLs are supported.' }
+      };
+
+      return {
+        ...result,
+        presentation: buildFetchPresentation(result)
+      };
+    }
+
+    const result = await fetchPage(url);
+    return {
+      ...result,
+      presentation: buildFetchPresentation(result)
+    };
+  };
+}

package/dist/extensions/pi-web-agent/src/tools/web-search.ts

@@ -1,157 +1,157 @@
-import { createCacheKey, createTtlCache } from '../cache/ttl-cache.js';
-import { buildSearchPresentation } from '../presentation/search-presentation.js';
-import { fetchDuckDuckGoHtml, parseDuckDuckGoResults } from '../search/duckduckgo.js';
-import type { WebSearchResponse } from '../types.js';
-
-function classifySearchFailure(error: unknown) {
-  const rawMessage = error instanceof Error ? error.message : 'Unknown search failure.';
-  const normalized = rawMessage.toLowerCase();
-
-  if (
-    normalized.includes('blocked') ||
-    normalized.includes('rate limit') ||
-    normalized.includes('rate-limit') ||
-    normalized.includes('403') ||
-    normalized.includes('429') ||
-    normalized.includes('captcha') ||
-    normalized.includes('challenge')
-  ) {
-    return {
-      code: 'BLOCKED',
-      message: 'DuckDuckGo search appears to be blocked or rate limited.'
-    };
-  }
-
-  return {
-    code: 'FETCH_FAILED',
-    message: `DuckDuckGo search request failed: ${rawMessage}`
-  };
-}
-
-function htmlLooksBlocked(html: string) {
-  const normalized = html.toLowerCase();
-
-  return (
-    normalized.includes('captcha') ||
-    normalized.includes('challenge') ||
-    normalized.includes('verify you are human') ||
-    normalized.includes('are you a robot') ||
-    normalized.includes('unusual traffic')
-  );
-}
-
-export function createWebSearchTool({
-  searchHtml = fetchDuckDuckGoHtml,
-  cache = createTtlCache<WebSearchResponse>({ ttlMs: 30_000 })
-}: {
-  searchHtml?: (query: string) => Promise<string>;
-  cache?: {
-    get(key: string): WebSearchResponse | undefined;
-    set(key: string, value: WebSearchResponse): void;
-  };
-} = {}) {
-  return async function webSearch({ query }: { query: string }): Promise<WebSearchResponse> {
-    const normalizedQuery = query.trim();
-
-    if (!normalizedQuery) {
-      const result: WebSearchResponse = {
-        status: 'error',
-        results: [],
-        metadata: { backend: 'duckduckgo', cacheHit: false },
-        error: { code: 'INVALID_QUERY', message: 'Query must not be empty.' }
-      };
-      return {
-        ...result,
-        presentation: buildSearchPresentation(result)
-      };
-    }
-
-    const cacheKey = createCacheKey(['web_search', normalizedQuery]);
-    const cached = cache.get(cacheKey);
-    if (cached) {
-      const result: WebSearchResponse = {
-        ...cached,
-        metadata: { ...cached.metadata, cacheHit: true }
-      };
-      return {
-        ...result,
-        presentation: buildSearchPresentation(result)
-      };
-    }
-
-    try {
-      const html = await searchHtml(normalizedQuery);
-      const parsed = parseDuckDuckGoResults(html);
-
-      if (parsed.results.length > 0) {
-        const result: WebSearchResponse = {
-          status: 'ok',
-          results: parsed.results,
-          metadata: { backend: 'duckduckgo', cacheHit: false }
-        };
-        cache.set(cacheKey, result);
-        return {
-          ...result,
-          presentation: buildSearchPresentation(result)
-        };
-      }
-
-      if (parsed.noResults) {
-        const result: WebSearchResponse = {
-          status: 'error',
-          results: [],
-          metadata: { backend: 'duckduckgo', cacheHit: false },
-          error: {
-            code: 'NO_RESULTS',
-            message: 'DuckDuckGo returned no usable results for this query.'
-          }
-        };
-        return {
-          ...result,
-          presentation: buildSearchPresentation(result)
-        };
-      }
-
-      if (htmlLooksBlocked(html)) {
-        const result: WebSearchResponse = {
-          status: 'error',
-          results: [],
-          metadata: { backend: 'duckduckgo', cacheHit: false },
-          error: {
-            code: 'BLOCKED',
-            message: 'DuckDuckGo search appears to be blocked or rate limited.'
-          }
-        };
-        return {
-          ...result,
-          presentation: buildSearchPresentation(result)
-        };
-      }
-
-      const result: WebSearchResponse = {
-        status: 'error',
-        results: [],
-        metadata: { backend: 'duckduckgo', cacheHit: false },
-        error: {
-          code: 'PARSE_FAILED',
-          message: 'DuckDuckGo returned a page, but it did not match the expected results format.'
-        }
-      };
-      return {
-        ...result,
-        presentation: buildSearchPresentation(result)
-      };
-    } catch (error) {
-      const result: WebSearchResponse = {
-        status: 'error',
-        results: [],
-        metadata: { backend: 'duckduckgo', cacheHit: false },
-        error: classifySearchFailure(error)
-      };
-      return {
-        ...result,
-        presentation: buildSearchPresentation(result)
-      };
-    }
-  };
-}
+import { createCacheKey, createTtlCache } from '../cache/ttl-cache.js';
+import { buildSearchPresentation } from '../presentation/search-presentation.js';
+import { fetchDuckDuckGoHtml, parseDuckDuckGoResults } from '../search/duckduckgo.js';
+import type { WebSearchResponse } from '../types.js';
+
+function classifySearchFailure(error: unknown) {
+  const rawMessage = error instanceof Error ? error.message : 'Unknown search failure.';
+  const normalized = rawMessage.toLowerCase();
+
+  if (
+    normalized.includes('blocked') ||
+    normalized.includes('rate limit') ||
+    normalized.includes('rate-limit') ||
+    normalized.includes('403') ||
+    normalized.includes('429') ||
+    normalized.includes('captcha') ||
+    normalized.includes('challenge')
+  ) {
+    return {
+      code: 'BLOCKED',
+      message: 'DuckDuckGo search appears to be blocked or rate limited.'
+    };
+  }
+
+  return {
+    code: 'FETCH_FAILED',
+    message: `DuckDuckGo search request failed: ${rawMessage}`
+  };
+}
+
+function htmlLooksBlocked(html: string) {
+  const normalized = html.toLowerCase();
+
+  return (
+    normalized.includes('captcha') ||
+    normalized.includes('challenge') ||
+    normalized.includes('verify you are human') ||
+    normalized.includes('are you a robot') ||
+    normalized.includes('unusual traffic')
+  );
+}
+
+export function createWebSearchTool({
+  searchHtml = fetchDuckDuckGoHtml,
+  cache = createTtlCache<WebSearchResponse>({ ttlMs: 30_000 })
+}: {
+  searchHtml?: (query: string) => Promise<string>;
+  cache?: {
+    get(key: string): WebSearchResponse | undefined;
+    set(key: string, value: WebSearchResponse): void;
+  };
+} = {}) {
+  return async function webSearch({ query }: { query: string }): Promise<WebSearchResponse> {
+    const normalizedQuery = query.trim();
+
+    if (!normalizedQuery) {
+      const result: WebSearchResponse = {
+        status: 'error',
+        results: [],
+        metadata: { backend: 'duckduckgo', cacheHit: false },
+        error: { code: 'INVALID_QUERY', message: 'Query must not be empty.' }
+      };
+      return {
+        ...result,
+        presentation: buildSearchPresentation(result)
+      };
+    }
+
+    const cacheKey = createCacheKey(['web_search', normalizedQuery]);
+    const cached = cache.get(cacheKey);
+    if (cached) {
+      const result: WebSearchResponse = {
+        ...cached,
+        metadata: { ...cached.metadata, cacheHit: true }
+      };
+      return {
+        ...result,
+        presentation: buildSearchPresentation(result)
+      };
+    }
+
+    try {
+      const html = await searchHtml(normalizedQuery);
+      const parsed = parseDuckDuckGoResults(html);
+
+      if (parsed.results.length > 0) {
+        const result: WebSearchResponse = {
+          status: 'ok',
+          results: parsed.results,
+          metadata: { backend: 'duckduckgo', cacheHit: false }
+        };
+        cache.set(cacheKey, result);
+        return {
+          ...result,
+          presentation: buildSearchPresentation(result)
+        };
+      }
+
+      if (parsed.noResults) {
+        const result: WebSearchResponse = {
+          status: 'error',
+          results: [],
+          metadata: { backend: 'duckduckgo', cacheHit: false },
+          error: {
+            code: 'NO_RESULTS',
+            message: 'DuckDuckGo returned no usable results for this query.'
+          }
+        };
+        return {
+          ...result,
+          presentation: buildSearchPresentation(result)
+        };
+      }
+
+      if (htmlLooksBlocked(html)) {
+        const result: WebSearchResponse = {
+          status: 'error',
+          results: [],
+          metadata: { backend: 'duckduckgo', cacheHit: false },
+          error: {
+            code: 'BLOCKED',
+            message: 'DuckDuckGo search appears to be blocked or rate limited.'
+          }
+        };
+        return {
+          ...result,
+          presentation: buildSearchPresentation(result)
+        };
+      }
+
+      const result: WebSearchResponse = {
+        status: 'error',
+        results: [],
+        metadata: { backend: 'duckduckgo', cacheHit: false },
+        error: {
+          code: 'PARSE_FAILED',
+          message: 'DuckDuckGo returned a page, but it did not match the expected results format.'
+        }
+      };
+      return {
+        ...result,
+        presentation: buildSearchPresentation(result)
+      };
+    } catch (error) {
+      const result: WebSearchResponse = {
+        status: 'error',
+        results: [],
+        metadata: { backend: 'duckduckgo', cacheHit: false },
+        error: classifySearchFailure(error)
+      };
+      return {
+        ...result,
+        presentation: buildSearchPresentation(result)
+      };
+    }
+  };
+}