@demigodmode/pi-web-agent 0.2.2 → 0.3.1

package/dist/tests/release-script.test.js

@@ -1,72 +0,0 @@
-import { describe, expect, it } from 'vitest';
-// Runtime-tested script module; TypeScript doesn't need declarations for this import.
-// @ts-expect-error importing local .mjs helper exports for tests
-import { inferVersionBump, parseUnreleasedSections, rewritePackageLockVersion } from '../scripts/release.mjs';
-describe('release script helpers', () => {
-    it('returns major when Breaking has real entries', () => {
-        const unreleased = {
-            Added: [],
-            Changed: [],
-            Fixed: [],
-            Breaking: ['Removed deprecated install path']
-        };
-        expect(inferVersionBump(unreleased)).toBe('major');
-    });
-    it('returns minor when Added has entries and Breaking does not', () => {
-        const unreleased = {
-            Added: ['Added release automation'],
-            Changed: [],
-            Fixed: [],
-            Breaking: []
-        };
-        expect(inferVersionBump(unreleased)).toBe('minor');
-    });
-    it('returns patch when only fixes or changes exist', () => {
-        const unreleased = {
-            Added: [],
-            Changed: ['Adjusted workflow docs'],
-            Fixed: ['Fixed package metadata regression'],
-            Breaking: []
-        };
-        expect(inferVersionBump(unreleased)).toBe('patch');
-    });
-    it('parses the top unreleased sections from changelog text', () => {
-        const changelog = `# Changelog\n\n## Unreleased\n\n### Added\n- Added release automation\n\n### Changed\n- Tightened docs\n\n### Fixed\n- Fixed package shape\n\n### Breaking\n- None.\n\n## [0.1.0] - 2026-04-20\n`;
-        expect(parseUnreleasedSections(changelog)).toEqual({
-            Added: ['Added release automation'],
-            Changed: ['Tightened docs'],
-            Fixed: ['Fixed package shape'],
-            Breaking: []
-        });
-    });
-    it('rewrites the root package-lock version fields', () => {
-        const packageLock = {
-            name: '@demigodmode/pi-web-agent',
-            version: '0.1.0',
-            lockfileVersion: 3,
-            packages: {
-                '': {
-                    name: '@demigodmode/pi-web-agent',
-                    version: '0.1.0'
-                },
-                'node_modules/example': {
-                    version: '1.2.3'
-                }
-            }
-        };
-        expect(JSON.parse(rewritePackageLockVersion(JSON.stringify(packageLock), '0.2.0'))).toEqual({
-            name: '@demigodmode/pi-web-agent',
-            version: '0.2.0',
-            lockfileVersion: 3,
-            packages: {
-                '': {
-                    name: '@demigodmode/pi-web-agent',
-                    version: '0.2.0'
-                },
-                'node_modules/example': {
-                    version: '1.2.3'
-                }
-            }
-        });
-    });
-});

package/dist/tests/search/duckduckgo.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/tests/search/duckduckgo.test.js

@@ -1,103 +0,0 @@
-import { readFileSync } from 'node:fs';
-import { describe, expect, it } from 'vitest';
-import { buildSearchUrl, parseDuckDuckGoResults } from '../../src/search/duckduckgo.js';
-describe('DuckDuckGo search parsing', () => {
-    it('builds a deterministic search URL', () => {
-        expect(buildSearchUrl('pi web agent')).toBe('https://html.duckduckgo.com/html/?q=pi+web+agent');
-    });
-    it('parses normalized title, url, and snippet records', () => {
-        const html = readFileSync('tests/fixtures/duckduckgo/basic-results.html', 'utf8');
-        const parsed = parseDuckDuckGoResults(html);
-        expect(parsed).toEqual({
-            results: [
-                {
-                    title: 'Example Article',
-                    url: 'https://example.com/article',
-                    snippet: 'First example snippet.'
-                },
-                {
-                    title: 'Another Result',
-                    url: 'https://example.org/post',
-                    snippet: 'Second example snippet.'
-                }
-            ],
-            noResults: false,
-            hasResultContainers: true
-        });
-    });
-    it('decodes DuckDuckGo redirect urls into destination urls', () => {
-        const html = `
-      <div class="result">
-        <a class="result__a" href="//duckduckgo.com/l/?uddg=https%3A%2F%2Fpi.dev%2F&rut=abc">pi.dev</a>
-        <a class="result__snippet">Pi docs</a>
-      </div>
-    `;
-        const parsed = parseDuckDuckGoResults(html);
-        expect(parsed).toEqual({
-            results: [
-                {
-                    title: 'pi.dev',
-                    url: 'https://pi.dev/',
-                    snippet: 'Pi docs'
-                }
-            ],
-            noResults: false,
-            hasResultContainers: true
-        });
-    });
-    it('falls back to the original url when redirect decoding fails', () => {
-        const html = `
-      <div class="result">
-        <a class="result__a" href="//duckduckgo.com/l/?uddg=%E0%A4%A&rut=abc">broken</a>
-        <a class="result__snippet">Broken redirect</a>
-      </div>
-    `;
-        const parsed = parseDuckDuckGoResults(html);
-        expect(parsed).toEqual({
-            results: [
-                {
-                    title: 'broken',
-                    url: '//duckduckgo.com/l/?uddg=%E0%A4%A&rut=abc',
-                    snippet: 'Broken redirect'
-                }
-            ],
-            noResults: false,
-            hasResultContainers: true
-        });
-    });
-    it('detects a no-results page separately from a parse failure', () => {
-        const html = `
-      <html>
-        <body>
-          <div class="results">
-            <div class="no-results">No results found for your search.</div>
-          </div>
-        </body>
-      </html>
-    `;
-        const parsed = parseDuckDuckGoResults(html);
-        expect(parsed).toEqual({
-            results: [],
-            noResults: true,
-            hasResultContainers: false
-        });
-    });
-    it('reports when the page does not match the expected results format', () => {
-        const html = `
-      <html>
-        <body>
-          <main>
-            <h1>Unexpected page</h1>
-            <p>Nothing here looks like a DuckDuckGo results page.</p>
-          </main>
-        </body>
-      </html>
-    `;
-        const parsed = parseDuckDuckGoResults(html);
-        expect(parsed).toEqual({
-            results: [],
-            noResults: false,
-            hasResultContainers: false
-        });
-    });
-});

package/dist/tests/tools/web-explore.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/tests/tools/web-explore.test.js

@@ -1,163 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { createWebExploreTool } from '../../src/tools/web-explore.js';
-describe('web_explore tool', () => {
-    it('returns clean findings, sources, and no caveat when evidence is sufficient', async () => {
-        const webExplore = createWebExploreTool({
-            explore: vi.fn().mockResolvedValue({
-                decision: {
-                    action: 'answer',
-                    rationale: 'Enough evidence.',
-                    approvedEvidence: [
-                        {
-                            title: 'Browsers | Playwright',
-                            url: 'https://playwright.dev/docs/browsers',
-                            sourceKind: 'official-docs',
-                            method: 'http',
-                            summary: 'Use channel for branded browsers.',
-                            supports: ['Use channel']
-                        },
-                        {
-                            title: 'BrowserType | Playwright',
-                            url: 'https://playwright.dev/docs/api/class-browsertype',
-                            sourceKind: 'official-api',
-                            method: 'http',
-                            summary: 'executablePath is supported but use at your own risk.',
-                            supports: ['executablePath is risky']
-                        }
-                    ]
-                },
-                evidence: [
-                    {
-                        title: 'Browsers | Playwright',
-                        url: 'https://playwright.dev/docs/browsers',
-                        sourceKind: 'official-docs',
-                        method: 'http',
-                        summary: 'Use channel for branded browsers.',
-                        supports: ['Use channel']
-                    },
-                    {
-                        title: 'BrowserType | Playwright',
-                        url: 'https://playwright.dev/docs/api/class-browsertype',
-                        sourceKind: 'official-api',
-                        method: 'http',
-                        summary: 'executablePath is supported but use at your own risk.',
-                        supports: ['executablePath is risky']
-                    }
-                ],
-                workerPass: {
-                    searchQueries: ['playwright installed edge executablePath vs channel'],
-                    evidence: [],
-                    gaps: [],
-                    lowValueOutcomes: [],
-                    suggestedHeadlessUrl: undefined,
-                    exhaustedBudget: false
-                }
-            })
-        });
-        const result = await webExplore({
-            query: 'Find current docs or discussions about Playwright launching an installed Chrome or Edge executable instead of a bundled browser, then summarize the recommended approach.'
-        });
-        expect(result.status).toBe('ok');
-        expect(result.findings).toEqual([
-            'Use channel for branded Chrome or Edge when possible.',
-            'Treat executablePath as a fallback because Playwright documents it as use-at-your-own-risk.'
-        ]);
-        expect(result.sources).toEqual([
-            {
-                title: 'Browsers | Playwright',
-                url: 'https://playwright.dev/docs/browsers'
-            },
-            {
-                title: 'BrowserType | Playwright',
-                url: 'https://playwright.dev/docs/api/class-browsertype'
-            }
-        ]);
-        expect(result.caveat).toBeUndefined();
-    });
-    it('returns a caveat when only partial evidence is available', async () => {
-        const webExplore = createWebExploreTool({
-            explore: vi.fn().mockResolvedValue({
-                decision: {
-                    action: 'research-again',
-                    rationale: 'Evidence is partial.',
-                    followupQuery: 'same query'
-                },
-                evidence: [
-                    {
-                        title: 'Coverage | Guide | Vitest',
-                        url: 'https://vitest.dev/guide/coverage.html',
-                        sourceKind: 'official-docs',
-                        method: 'headless',
-                        summary: 'Set coverage.provider to v8 and install @vitest/coverage-v8.',
-                        supports: ['provider: v8', 'install @vitest/coverage-v8']
-                    }
-                ],
-                workerPass: {
-                    searchQueries: ['vitest coverage docs'],
-                    evidence: [],
-                    gaps: [{ kind: 'needs-more-evidence', message: 'Only one strong source was gathered.' }],
-                    lowValueOutcomes: [],
-                    suggestedHeadlessUrl: undefined,
-                    exhaustedBudget: false
-                }
-            })
-        });
-        const result = await webExplore({
-            query: 'Find the current Vitest coverage docs and tell me how to enable coverage with the V8 provider in a TypeScript project.'
-        });
-        expect(result.status).toBe('ok');
-        expect(result.findings).toEqual([
-            'Vitest coverage docs say to set coverage.provider to v8 and install @vitest/coverage-v8.'
-        ]);
-        expect(result.sources).toEqual([
-            {
-                title: 'Coverage | Guide | Vitest',
-                url: 'https://vitest.dev/guide/coverage.html'
-            }
-        ]);
-        expect(result.caveat).toBe('Evidence is partial, so this answer is based on the strongest source found so far.');
-    });
-    it('rejects empty exploration queries', async () => {
-        const webExplore = createWebExploreTool({
-            explore: vi.fn()
-        });
-        await expect(webExplore({ query: '   ' })).resolves.toMatchObject({
-            status: 'error',
-            error: { code: 'INVALID_QUERY' }
-        });
-    });
-    it('does not leak raw internal worker bookkeeping into visible output', async () => {
-        const webExplore = createWebExploreTool({
-            explore: vi.fn().mockResolvedValue({
-                decision: {
-                    action: 'research-again',
-                    rationale: 'Not enough evidence.',
-                    followupQuery: 'same query'
-                },
-                evidence: [
-                    {
-                        title: 'Source A',
-                        url: 'https://example.com/a',
-                        sourceKind: 'community',
-                        method: 'http',
-                        summary: 'A concise summary.',
-                        supports: ['detail a']
-                    }
-                ],
-                workerPass: {
-                    searchQueries: ['q1'],
-                    evidence: [],
-                    gaps: [{ kind: 'needs-more-evidence', message: 'Need more.' }],
-                    lowValueOutcomes: [{ kind: 'empty-search', message: 'No more results.' }],
-                    suggestedHeadlessUrl: 'https://example.com/b',
-                    exhaustedBudget: false
-                }
-            })
-        });
-        const result = await webExplore({ query: 'example query' });
-        expect(JSON.stringify(result)).not.toContain('searchQueries');
-        expect(JSON.stringify(result)).not.toContain('lowValueOutcomes');
-        expect(JSON.stringify(result)).not.toContain('suggestedHeadlessUrl');
-        expect(result.findings).toEqual(['A concise summary.']);
-    });
-});

package/dist/tests/tools/web-fetch-headless.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/tests/tools/web-fetch-headless.test.js

@@ -1,31 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { createWebFetchHeadlessTool } from '../../src/tools/web-fetch-headless.js';
-describe('web_fetch_headless tool', () => {
-    it('passes through headless fetch results', async () => {
-        const tool = createWebFetchHeadlessTool({
-            fetchPage: async () => ({
-                status: 'ok',
-                url: 'https://example.com',
-                metadata: { method: 'headless', cacheHit: false, browser: 'chrome', navigationMs: 1200 },
-                content: { text: 'Rendered text' }
-            })
-        });
-        const result = await tool({ url: 'https://example.com' });
-        expect(result).toMatchObject({
-            status: 'ok',
-            metadata: { method: 'headless', cacheHit: false, browser: 'chrome', navigationMs: 1200 },
-            content: { text: 'Rendered text' }
-        });
-    });
-    it('can be constructed without dependency arguments', () => {
-        expect(typeof createWebFetchHeadlessTool()).toBe('function');
-    });
-    it('rejects unsupported URL schemes before headless execution', async () => {
-        const tool = createWebFetchHeadlessTool();
-        const result = await tool({ url: 'file:///tmp/test.html' });
-        expect(result).toMatchObject({
-            status: 'unsupported',
-            error: { code: 'UNSUPPORTED_URL' }
-        });
-    });
-});

package/dist/tests/tools/web-fetch.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/tests/tools/web-fetch.test.js

@@ -1,27 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { createWebFetchTool } from '../../src/tools/web-fetch.js';
-describe('web_fetch tool', () => {
-    it('rejects unsupported URL schemes before fetching', async () => {
-        const webFetch = createWebFetchTool({ fetchPage: vi.fn() });
-        await expect(webFetch({ url: 'file:///tmp/test.html' })).resolves.toMatchObject({
-            status: 'unsupported',
-            error: { code: 'UNSUPPORTED_URL' }
-        });
-    });
-    it('passes through honest fetch results', async () => {
-        const webFetch = createWebFetchTool({
-            fetchPage: vi.fn().mockResolvedValue({
-                status: 'needs_headless',
-                url: 'https://example.com',
-                metadata: { method: 'http', cacheHit: false },
-                error: { code: 'WEAK_EXTRACTION', message: 'not enough content' }
-            })
-        });
-        await expect(webFetch({ url: 'https://example.com' })).resolves.toMatchObject({
-            status: 'needs_headless'
-        });
-    });
-    it('can be constructed without dependency arguments', () => {
-        expect(typeof createWebFetchTool()).toBe('function');
-    });
-});

package/dist/tests/tools/web-search.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/tests/tools/web-search.test.js

@@ -1,125 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { createWebSearchTool } from '../../src/tools/web-search.js';
-describe('web_search tool', () => {
-    it('returns discovery-only results from the search backend', async () => {
-        const search = createWebSearchTool({
-            searchHtml: vi.fn().mockResolvedValue(`
-        <div class="result">
-          <a class="result__a" href="https://example.com">Example</a>
-          <a class="result__snippet">Snippet</a>
-        </div>
-      `)
-        });
-        await expect(search({ query: 'example' })).resolves.toEqual({
-            status: 'ok',
-            results: [{ title: 'Example', url: 'https://example.com', snippet: 'Snippet' }],
-            metadata: { backend: 'duckduckgo', cacheHit: false }
-        });
-    });
-    it('serves repeated identical queries from cache', async () => {
-        const searchHtml = vi.fn().mockResolvedValue(`
-      <div class="result">
-        <a class="result__a" href="https://example.com">Example</a>
-        <a class="result__snippet">Snippet</a>
-      </div>
-    `);
-        const search = createWebSearchTool({ searchHtml });
-        const first = await search({ query: 'example' });
-        const second = await search({ query: 'example' });
-        expect(searchHtml).toHaveBeenCalledTimes(1);
-        expect(first.metadata.cacheHit).toBe(false);
-        expect(second.metadata.cacheHit).toBe(true);
-    });
-    it('rejects empty queries', async () => {
-        const search = createWebSearchTool({ searchHtml: vi.fn() });
-        await expect(search({ query: '   ' })).resolves.toMatchObject({
-            status: 'error',
-            error: { code: 'INVALID_QUERY' }
-        });
-    });
-    it('returns NO_RESULTS when the backend page is valid but contains no usable results', async () => {
-        const search = createWebSearchTool({
-            searchHtml: vi.fn().mockResolvedValue(`
-        <html>
-          <body>
-            <div class="results">
-              <div class="no-results">No results found for your search.</div>
-            </div>
-          </body>
-        </html>
-      `)
-        });
-        await expect(search({ query: 'missing thing' })).resolves.toMatchObject({
-            status: 'error',
-            error: {
-                code: 'NO_RESULTS',
-                message: 'DuckDuckGo returned no usable results for this query.'
-            }
-        });
-    });
-    it('returns PARSE_FAILED when the backend page cannot be understood as search results', async () => {
-        const search = createWebSearchTool({
-            searchHtml: vi.fn().mockResolvedValue(`
-        <html>
-          <body>
-            <main>
-              <h1>Unexpected page</h1>
-            </main>
-          </body>
-        </html>
-      `)
-        });
-        await expect(search({ query: 'odd page' })).resolves.toMatchObject({
-            status: 'error',
-            error: {
-                code: 'PARSE_FAILED',
-                message: 'DuckDuckGo returned a page, but it did not match the expected results format.'
-            }
-        });
-    });
-    it('returns BLOCKED when the backend clearly looks blocked', async () => {
-        const search = createWebSearchTool({
-            searchHtml: vi.fn().mockRejectedValue(new Error('DuckDuckGo blocked the request with 403'))
-        });
-        await expect(search({ query: 'blocked query' })).resolves.toMatchObject({
-            status: 'error',
-            error: {
-                code: 'BLOCKED',
-                message: 'DuckDuckGo search appears to be blocked or rate limited.'
-            }
-        });
-    });
-    it('returns BLOCKED when a 200 response is really a challenge page', async () => {
-        const search = createWebSearchTool({
-            searchHtml: vi.fn().mockResolvedValue(`
-        <html>
-          <body>
-            <main>
-              <h1>Are you a robot?</h1>
-              <p>Please verify you are human to continue.</p>
-            </main>
-          </body>
-        </html>
-      `)
-        });
-        await expect(search({ query: 'challenge page' })).resolves.toMatchObject({
-            status: 'error',
-            error: {
-                code: 'BLOCKED',
-                message: 'DuckDuckGo search appears to be blocked or rate limited.'
-            }
-        });
-    });
-    it('returns FETCH_FAILED for generic backend failures', async () => {
-        const search = createWebSearchTool({
-            searchHtml: vi.fn().mockRejectedValue(new Error('socket hang up'))
-        });
-        await expect(search({ query: 'network issue' })).resolves.toMatchObject({
-            status: 'error',
-            error: {
-                code: 'FETCH_FAILED',
-                message: 'DuckDuckGo search request failed: socket hang up'
-            }
-        });
-    });
-});

package/dist/vitest.config.d.ts

@@ -1,2 +0,0 @@
-declare const _default: import("vite").UserConfig;
-export default _default;

package/dist/vitest.config.js

@@ -1,13 +0,0 @@
-import { defineConfig } from 'vitest/config';
-export default defineConfig({
-    test: {
-        environment: 'node',
-        include: ['tests/**/*.test.ts'],
-        coverage: {
-            provider: 'v8',
-            reporter: ['text', 'html'],
-            reportsDirectory: 'coverage',
-            exclude: ['scripts/**', 'dist/**', '.pi/**', 'docs/.vitepress/**', 'vitest.config.ts']
-        }
-    }
-});