@qvac/harness 1.0.0-rc.0 → 1.0.0-rc.2

package/dist-lib/lib/tools/exec/adapters/python/worker/entry.js

@@ -1,3 +0,0 @@
-import { defaultLoad } from '../loader.js';
-import { serve } from './serve.js';
-await serve(defaultLoad);

package/dist-lib/lib/tools/exec/obsidian/route.d.ts

@@ -1,17 +0,0 @@
-import type { AbortSignal as BareAbortSignal } from 'bare-abort-controller';
-import type { ToolExecuteContext } from '../../../capabilities/completion.ts';
-import { type CredentialStoreFn } from '../../skills/auth-resolver.ts';
-import { type ExecResult, type KillProcess, type SpawnFn } from '../runner.ts';
-import type { ShellRuntime } from '../adapters/shell/shell-adapter.ts';
-export interface ObsidianRouteOptions {
-    readonly credentialStore?: CredentialStoreFn;
-    readonly spawn?: SpawnFn;
-    readonly killProcess?: KillProcess;
-    readonly loadRuntime?: () => Promise<ShellRuntime>;
-    readonly platform?: string;
-    readonly env?: Record<string, string | undefined>;
-    readonly timeoutMs?: number;
-    readonly maxOutputChars?: number;
-    readonly signal?: BareAbortSignal;
-}
-export declare function routeObsidianCommand(command: string, ctx: ToolExecuteContext | undefined, options?: ObsidianRouteOptions): Promise<ExecResult | null>;

package/dist-lib/lib/tools/exec/obsidian/route.js

@@ -1,91 +0,0 @@
-import process from 'process';
-import { errorMessage } from '../../../guards.js';
-import { credentialRecord } from '../../skills/auth-resolver.js';
-import { isObsidianVaultPath, isSandboxedWorkbenchInstall, OBSIDIAN_VAULT_PATH_CREDENTIAL_KEY } from '../../skills/obsidian-readiness.js';
-import { capOutput, MAX_OUTPUT_CHARS } from '../runner.js';
-import { runObsidianCli } from './cli.js';
-import { normalizeObsidianCommand, parseObsidianCommand } from './command.js';
-import { OBSIDIAN_DESKTOP_AGENT_REQUIRED, OBSIDIAN_NO_SHELL_FALLBACK, OBSIDIAN_VAULT_SETUP_REQUIRED } from './guidance.js';
-import { executeVaultFsAction } from './vault-fs.js';
-const DESKTOP_PLATFORMS = new Set(['darwin', 'linux', 'win32']);
-async function runtimeOf(options) {
-    if (options.spawn) {
-        return { spawn: options.spawn, killProcess: options.killProcess };
-    }
-    return options.loadRuntime ? await options.loadRuntime() : null;
-}
-function limitResult(result, maxOutputChars) {
-    return {
-        stdout: capOutput(result.stdout, maxOutputChars),
-        stderr: capOutput(result.stderr, maxOutputChars),
-        exitCode: result.exitCode
-    };
-}
-function vaultFsResult(stdout, exitCode) {
-    return exitCode === 0
-        ? { stdout, stderr: '', exitCode: 0 }
-        : { stdout: '', stderr: `${stdout}\n\n${OBSIDIAN_NO_SHELL_FALLBACK}`, exitCode };
-}
-function runVaultFs(vaultPath, { action, args, maxOutputChars }) {
-    try {
-        return limitResult(vaultFsResult(executeVaultFsAction(vaultPath, action, args), 0), maxOutputChars);
-    }
-    catch (error) {
-        const message = errorMessage(error);
-        return limitResult(vaultFsResult(message, 1), maxOutputChars);
-    }
-}
-async function resolveVaultPath(credentialStore, ctx) {
-    if (!credentialStore)
-        return null;
-    const record = credentialRecord(await credentialStore(OBSIDIAN_VAULT_PATH_CREDENTIAL_KEY, ctx));
-    const token = record?.token?.trim();
-    if (!token || !isObsidianVaultPath(token)) {
-        return null;
-    }
-    return token;
-}
-export async function routeObsidianCommand(command, ctx, options = {}) {
-    const parsed = parseObsidianCommand(command);
-    if (!parsed) {
-        return null;
-    }
-    const maxOutputChars = options.maxOutputChars ?? MAX_OUTPUT_CHARS;
-    const signal = options.signal ?? ctx?.signal;
-    if (signal?.aborted) {
-        return { stdout: '', stderr: 'Obsidian command aborted.', exitCode: 1 };
-    }
-    const platform = options.platform ?? process.platform;
-    if (!DESKTOP_PLATFORMS.has(platform)) {
-        return {
-            stdout: '',
-            stderr: OBSIDIAN_DESKTOP_AGENT_REQUIRED,
-            exitCode: 1
-        };
-    }
-    const vaultPath = await resolveVaultPath(options.credentialStore, ctx);
-    if (vaultPath) {
-        return runVaultFs(vaultPath, { action: parsed.action, args: parsed.args, maxOutputChars });
-    }
-    if (isSandboxedWorkbenchInstall(options.env ?? process.env)) {
-        return {
-            stdout: '',
-            stderr: OBSIDIAN_VAULT_SETUP_REQUIRED,
-            exitCode: 1
-        };
-    }
-    const runtime = await runtimeOf(options);
-    if (!runtime) {
-        return {
-            stdout: '',
-            stderr: 'Obsidian CLI runtime unavailable. Ask the user to open Obsidian / register the CLI.\n\n' +
-                OBSIDIAN_NO_SHELL_FALLBACK,
-            exitCode: 1
-        };
-    }
-    return runObsidianCli(normalizeObsidianCommand(command), runtime, {
-        timeoutMs: options.timeoutMs,
-        maxOutputChars,
-        signal
-    });
-}

package/dist-lib/lib/tools/mcp-call.d.ts

@@ -1,14 +0,0 @@
-import type { ToolDefinition } from '../capabilities/completion.ts';
-import { type McpFetchFn } from './mcp/protocol.ts';
-import { type CredentialAllowListFn, type CredentialStoreFn } from './skills/auth-resolver.ts';
-import { type HostResolver } from './url-guard.ts';
-export type { McpFetchFn };
-export interface McpCallToolOptions {
-    fetch?: McpFetchFn;
-    credentialStore?: CredentialStoreFn;
-    credentialAllowList?: CredentialAllowListFn;
-    readMethods?: ReadonlyMap<string, ReadonlySet<string>>;
-    resolveHost?: HostResolver;
-}
-export declare function mcpTargetUrl(args: Record<string, unknown>): string;
-export declare function createMcpCallTool({ fetch: fetchImpl, credentialStore, credentialAllowList, readMethods, resolveHost }?: McpCallToolOptions): ToolDefinition;

package/dist-lib/lib/tools/rag-search.d.ts

@@ -1,2 +0,0 @@
-import type { ToolDefinition } from '../capabilities/completion.ts';
-export declare function createRagSearchTool(): ToolDefinition;

package/dist-lib/lib/tools/rag-search.js

@@ -1,105 +0,0 @@
-import { errorMessage } from '../guards.js';
-import { RAG_CITATION_LINE } from '../prompt.js';
-const DEFAULT_LIMIT = 5;
-const MAX_LIMIT = 20;
-const EXCERPT_CHARS = 1200;
-const NOT_AVAILABLE = 'rag_search is not available in this run. The current chat has no indexed knowledge base. Attach documents to the chat and try again.';
-const NO_DOCUMENTS = 'The current chat has no uploaded documents. Attach documents to the chat and try again.';
-const STILL_SYNCING = 'Attachments are still syncing and cannot be searched yet. Try again shortly.';
-const NO_RELEVANT = 'No relevant excerpts were found in the knowledge base. Answer plainly without fabricating sources.';
-export function createRagSearchTool() {
-    return {
-        name: 'rag_search',
-        toolset: 'knowledge',
-        autoApprove: true,
-        description: "Semantic search over the current chat's indexed knowledge base (uploaded documents, PDFs, notes). " +
-            'Returns ranked excerpts with source labels you can cite. Use this when the answer is fuzzy or ' +
-            'conceptual ("summarise the Q3 board notes", "what does the spec say about retries").',
-        parameters: {
-            type: 'object',
-            properties: {
-                query: {
-                    type: 'string',
-                    description: 'Natural-language query to retrieve relevant chunks for.'
-                },
-                limit: { type: 'number', description: 'Maximum excerpts to return (1-20). Defaults to 5.' }
-            },
-            required: ['query']
-        },
-        effect: () => 'read',
-        async execute(args, ctx) {
-            const query = args.query;
-            if (typeof query !== 'string' || query.trim().length === 0) {
-                return { error: 'query must be a non-empty string' };
-            }
-            if (!ctx?.ragSearch) {
-                return { content: NOT_AVAILABLE };
-            }
-            let result;
-            try {
-                result = await ctx.ragSearch({ query, limit: limitFrom(args.limit) });
-            }
-            catch (err) {
-                return { error: `rag_search failed: ${errorMessage(err)}` };
-            }
-            if (!result.enabled) {
-                return { content: NOT_AVAILABLE };
-            }
-            if (result.errorMessage) {
-                return { error: `rag_search failed: ${result.errorMessage}` };
-            }
-            if (result.hits.length === 0) {
-                if (!result.hasKnowledge) {
-                    return { content: NO_DOCUMENTS };
-                }
-                if (result.indexEmpty || result.pendingReferenced) {
-                    return { content: STILL_SYNCING };
-                }
-                return { content: NO_RELEVANT };
-            }
-            return { content: formatHits(result.hits) };
-        }
-    };
-}
-function limitFrom(raw) {
-    if (typeof raw !== 'number' || !Number.isFinite(raw))
-        return DEFAULT_LIMIT;
-    return Math.min(MAX_LIMIT, Math.max(1, Math.floor(raw)));
-}
-function formatHits(hits) {
-    const blocks = hits
-        .map((hit, index) => `${labelFor(hit, index)}\n${truncate(hit.content.trim())}`)
-        .join('\n\n');
-    return `${blocks}\n\n${RAG_CITATION_LINE}`;
-}
-function labelFor(hit, index) {
-    const metadata = parseMetadata(hit.metadataJson);
-    const title = metadata.title ?? 'document';
-    const chunk = metadata.chunkIndex ?? index;
-    return `[Source ${index + 1}: ${title}, chunk ${chunk}, score ${hit.score.toFixed(3)}]`;
-}
-function parseMetadata(raw) {
-    if (!raw)
-        return {};
-    try {
-        const parsed = JSON.parse(raw);
-        if (typeof parsed !== 'object' || parsed === null) {
-            return {};
-        }
-        return {
-            title: 'title' in parsed && typeof parsed.title === 'string' ? parsed.title : undefined,
-            chunkIndex: 'chunkIndex' in parsed &&
-                typeof parsed.chunkIndex === 'number' &&
-                Number.isSafeInteger(parsed.chunkIndex) &&
-                parsed.chunkIndex >= 0
-                ? parsed.chunkIndex
-                : undefined
-        };
-    }
-    catch {
-        return {};
-    }
-}
-function truncate(text) {
-    return text.length <= EXCERPT_CHARS ? text : `${text.slice(0, EXCERPT_CHARS)}…`;
-}

package/dist-lib/lib/tools/weather-lookup.d.ts

@@ -1,8 +0,0 @@
-import type { ToolDefinition } from '../capabilities/completion.ts';
-import type { FetchFn } from './http-request.ts';
-import { type HostResolver } from './url-guard.ts';
-export interface WeatherLookupToolOptions {
-    fetch?: FetchFn;
-    resolveHost?: HostResolver;
-}
-export declare function createWeatherLookupTool({ fetch: fetchImpl, resolveHost }?: WeatherLookupToolOptions): ToolDefinition;

package/dist-lib/lib/tools/weather-lookup.js

@@ -1,122 +0,0 @@
-import { noRedirectFetch } from '#no-redirect-fetch';
-import { AbortController } from 'bare-abort-controller';
-import { lookupHost } from '../dns-lookup.js';
-import { errorMessage } from '../guards.js';
-import { isRedirectStatus } from './http-request/request.js';
-import { resolveOutboundUrl } from './url-guard.js';
-import { checkQualifier, cityMatches, describePlace, qualifierOf } from './weather-lookup/place.js';
-import { placeOf, renderReport, WeatherJsonSchema } from './weather-lookup/report.js';
-const WEATHER_HOST = 'wttr.in';
-const LOOKUP_TIMEOUT_MS = 15_000;
-const MAX_BODY_BYTES = 400_000;
-export function createWeatherLookupTool({ fetch: fetchImpl, resolveHost = lookupHost } = {}) {
-    return {
-        name: 'weather_lookup',
-        toolset: 'http-request',
-        skillGated: true,
-        autoApprove: true,
-        description: 'Look up the current weather and a three-day forecast for a place, via wttr.in. ' +
-            'Returns the place the service resolved on its first line, then the conditions now and ' +
-            'one line per day. Use it for any question about weather, temperature or forecast.',
-        parameters: {
-            type: 'object',
-            properties: {
-                location: {
-                    type: 'string',
-                    description: 'The place exactly as the user wrote it, including any country or state: ' +
-                        '"Nassau, Bahamas", "Paris, Texas", "London"'
-                }
-            },
-            required: ['location']
-        },
-        effect: () => 'read',
-        resource: () => ({ kind: 'host', label: WEATHER_HOST }),
-        async execute(args, ctx) {
-            const raw = args.location;
-            if (typeof raw !== 'string' || raw.trim().length === 0) {
-                return { error: 'location must be a non-empty string' };
-            }
-            const location = raw.trim();
-            if (ctx?.signal?.aborted) {
-                return { error: 'weather_lookup cancelled' };
-            }
-            const url = new URL(`https://${WEATHER_HOST}/${encodeURIComponent(location)}?format=j1`);
-            const fetch = fetchImpl ?? noRedirectFetch;
-            const controller = new AbortController();
-            const timeout = setTimeout(() => controller.abort(undefined), LOOKUP_TIMEOUT_MS);
-            const onCallerAbort = () => controller.abort(undefined);
-            ctx?.signal?.addEventListener('abort', onCallerAbort);
-            try {
-                const check = await resolveOutboundUrl(url, resolveHost, ctx?.signal);
-                if (check.blocked) {
-                    return { error: check.blocked };
-                }
-                const response = await fetch(url, {
-                    method: 'GET',
-                    headers: { Accept: 'application/json' },
-                    signal: controller.signal,
-                    redirect: 'manual',
-                    validatedAddresses: check.addresses,
-                    maxBytes: MAX_BODY_BYTES
-                });
-                if (isRedirectStatus(response.status)) {
-                    return { error: `${WEATHER_HOST} redirected the lookup for "${location}"` };
-                }
-                const body = await response.text();
-                if (/location not found/i.test(body)) {
-                    return { content: notFound(location) };
-                }
-                if (response.status !== 200) {
-                    return { error: unavailable(`it answered HTTP ${response.status}`), code: 'transport' };
-                }
-                let json;
-                try {
-                    json = WeatherJsonSchema.parse(JSON.parse(body));
-                }
-                catch {
-                    return { error: unavailable('it did not return a forecast') };
-                }
-                const place = placeOf(json);
-                if (place === null) {
-                    return { content: notFound(location) };
-                }
-                const qualifier = qualifierOf(location);
-                const verdict = qualifier === null ? null : checkQualifier(qualifier, place);
-                const named = cityMatches(location, place);
-                if (verdict === 'contradiction' && !named) {
-                    return {
-                        content: `No such place: "${location}". ${WEATHER_HOST} resolved it to ` +
-                            `${describePlace(place)}, which is somewhere else.`
-                    };
-                }
-                const verified = qualifier === null ? named : verdict === 'match';
-                return { content: renderReport(json, place, { asked: location, verified }) };
-            }
-            catch (err) {
-                if (ctx?.signal?.aborted) {
-                    return { error: 'weather_lookup cancelled' };
-                }
-                if (controller.signal.aborted) {
-                    return {
-                        error: `weather_lookup timed out after ${LOOKUP_TIMEOUT_MS} ms`,
-                        code: 'timeout'
-                    };
-                }
-                return {
-                    error: unavailable(errorMessage(err)),
-                    code: 'transport'
-                };
-            }
-            finally {
-                clearTimeout(timeout);
-                ctx?.signal?.removeEventListener('abort', onCallerAbort);
-            }
-        }
-    };
-}
-function unavailable(reason) {
-    return `The weather service could not be reached: ${reason}.`;
-}
-function notFound(location) {
-    return `No such place: "${location}". ${WEATHER_HOST} does not know it.`;
-}

package/dist-lib/lib/tools/web-search.d.ts

@@ -1,6 +0,0 @@
-import type { ToolDefinition } from '../capabilities/completion.ts';
-import type { Fetcher } from '../web-search/types.ts';
-export interface WebSearchToolOptions {
-    fetch?: Fetcher;
-}
-export declare function createWebSearchTool({ fetch }?: WebSearchToolOptions): ToolDefinition;

package/dist-lib/lib/web-search/engine-registry.d.ts

@@ -1,7 +0,0 @@
-import type { SearchEngine } from './types.ts';
-export interface EngineEntry {
-    readonly name: string;
-    readonly fn: SearchEngine;
-}
-export declare const DEFAULT_MAX_RESULTS = 8;
-export declare const ENGINES: ReadonlyArray<EngineEntry>;

package/dist-lib/lib/web-search/engine-registry.js

@@ -1,17 +0,0 @@
-import { searchAol } from './engines/aol.js';
-import { searchBing } from './engines/bing.js';
-import { searchBrave } from './engines/brave.js';
-import { searchDuckDuckGo } from './engines/duckduckgo.js';
-import { searchGoogle } from './engines/google.js';
-import { searchWikipedia } from './engines/wikipedia.js';
-import { searchYahoo } from './engines/yahoo.js';
-export const DEFAULT_MAX_RESULTS = 8;
-export const ENGINES = [
-    { name: 'duckduckgo', fn: searchDuckDuckGo },
-    { name: 'brave', fn: searchBrave },
-    { name: 'google', fn: searchGoogle },
-    { name: 'yahoo', fn: searchYahoo },
-    { name: 'aol', fn: searchAol },
-    { name: 'bing', fn: searchBing },
-    { name: 'wikipedia', fn: searchWikipedia }
-];