@zhijiewang/openharness 2.22.1 → 2.24.0

package/dist/tools/ExaSearchTool/index.js

@@ -0,0 +1,165 @@
+import { z } from "zod";
+const SEARCH_TYPES = ["auto", "neural", "fast", "keyword"];
+const CATEGORIES = ["company", "research paper", "news", "personal site", "financial report", "people"];
+const inputSchema = z.object({
+    query: z.string(),
+    num_results: z.number().optional(),
+    type: z.enum(SEARCH_TYPES).optional(),
+    category: z.enum(CATEGORIES).optional(),
+    include_domains: z.array(z.string()).optional(),
+    exclude_domains: z.array(z.string()).optional(),
+    include_text: z.array(z.string()).optional(),
+    exclude_text: z.array(z.string()).optional(),
+    start_published_date: z.string().optional(),
+    end_published_date: z.string().optional(),
+    user_location: z.string().optional(),
+    text: z.boolean().optional(),
+    highlights: z.boolean().optional(),
+    summary: z.boolean().optional(),
+    summary_query: z.string().optional(),
+    max_text_chars: z.number().optional(),
+});
+const DEFAULT_NUM_RESULTS = 5;
+const MAX_TEXT_CHARS = 1500;
+const ENDPOINT = "https://api.exa.ai/search";
+const INTEGRATION_HEADER = "openharness";
+export function buildRequestBody(input) {
+    const body = {
+        query: input.query,
+        numResults: input.num_results ?? DEFAULT_NUM_RESULTS,
+    };
+    if (input.type)
+        body.type = input.type;
+    if (input.category)
+        body.category = input.category;
+    if (input.include_domains?.length)
+        body.includeDomains = input.include_domains;
+    if (input.exclude_domains?.length)
+        body.excludeDomains = input.exclude_domains;
+    if (input.include_text?.length)
+        body.includeText = input.include_text;
+    if (input.exclude_text?.length)
+        body.excludeText = input.exclude_text;
+    if (input.start_published_date)
+        body.startPublishedDate = input.start_published_date;
+    if (input.end_published_date)
+        body.endPublishedDate = input.end_published_date;
+    if (input.user_location)
+        body.userLocation = input.user_location;
+    const wantText = input.text ?? true;
+    const wantHighlights = input.highlights ?? true;
+    const wantSummary = input.summary ?? false;
+    const contents = {};
+    if (wantText) {
+        contents.text = { maxCharacters: input.max_text_chars ?? MAX_TEXT_CHARS };
+    }
+    if (wantHighlights) {
+        contents.highlights = true;
+    }
+    if (wantSummary) {
+        contents.summary = input.summary_query ? { query: input.summary_query } : true;
+    }
+    if (Object.keys(contents).length > 0) {
+        body.contents = contents;
+    }
+    return body;
+}
+export function extractSnippet(item) {
+    if (item.highlights && item.highlights.length > 0) {
+        return item.highlights.join(" … ");
+    }
+    if (item.summary)
+        return item.summary;
+    if (item.text) {
+        const trimmed = item.text.replace(/\s+/g, " ").trim();
+        return trimmed.length > 300 ? `${trimmed.slice(0, 300)}…` : trimmed;
+    }
+    return "";
+}
+export function formatResults(response) {
+    if (!response.results || response.results.length === 0) {
+        return "No results found.";
+    }
+    return response.results
+        .map((r, i) => {
+        const title = r.title?.trim() || "(untitled)";
+        const snippet = extractSnippet(r);
+        const meta = [];
+        if (r.author)
+            meta.push(`by ${r.author}`);
+        if (r.publishedDate)
+            meta.push(r.publishedDate.slice(0, 10));
+        const metaLine = meta.length ? `   ${meta.join(" · ")}\n` : "";
+        const snippetLine = snippet ? `   ${snippet}\n` : "";
+        return `${i + 1}. ${title}\n   ${r.url}\n${metaLine}${snippetLine}`.trimEnd();
+    })
+        .join("\n\n");
+}
+export const ExaSearchTool = {
+    name: "ExaSearch",
+    description: "Search the web with Exa — neural/fast/auto search with content retrieval, domain and date filters, and category targeting.",
+    inputSchema,
+    riskLevel: "medium",
+    isReadOnly() {
+        return true;
+    },
+    isConcurrencySafe() {
+        return true;
+    },
+    async call(input, _context) {
+        const apiKey = process.env.EXA_API_KEY;
+        if (!apiKey) {
+            return {
+                output: "Error: EXA_API_KEY environment variable is not set.",
+                isError: true,
+            };
+        }
+        const body = buildRequestBody(input);
+        try {
+            const response = await fetch(ENDPOINT, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    "x-api-key": apiKey,
+                    "x-exa-integration": INTEGRATION_HEADER,
+                    "User-Agent": "OpenHarness/1.0",
+                },
+                body: JSON.stringify(body),
+                signal: AbortSignal.timeout(30_000),
+            });
+            if (!response.ok) {
+                const errText = await response.text().catch(() => "");
+                const detail = errText ? `: ${errText.slice(0, 500)}` : "";
+                return {
+                    output: `Error: Exa API returned ${response.status} ${response.statusText}${detail}`,
+                    isError: true,
+                };
+            }
+            const json = (await response.json());
+            return { output: formatResults(json), isError: false };
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            return { output: `Error performing Exa search: ${message}`, isError: true };
+        }
+    },
+    prompt() {
+        return `Search the web using Exa's neural search engine and return ranked results with snippets. Requires EXA_API_KEY env var. Parameters:
+- query (string, required): The search query.
+- num_results (number, optional): Max results to return (default 5).
+- type (string, optional): "auto" (default), "neural", "fast", or "keyword".
+- category (string, optional): One of "company", "research paper", "news", "personal site", "financial report", "people".
+- include_domains (string[], optional): Restrict to these domains.
+- exclude_domains (string[], optional): Skip these domains.
+- include_text (string[], optional): Results must contain these phrases.
+- exclude_text (string[], optional): Skip results containing these phrases.
+- start_published_date / end_published_date (string, optional): ISO 8601 publication date filters.
+- user_location (string, optional): Two-letter ISO country code.
+- text (boolean, optional): Include page text (default true).
+- highlights (boolean, optional): Include highlight snippets (default true).
+- summary (boolean, optional): Include AI-generated summary (default false).
+- summary_query (string, optional): Custom summarization query.
+- max_text_chars (number, optional): Cap text length per result (default 1500).`;
+    },
+};
+//# sourceMappingURL=index.js.map

package/dist/tools.js

@@ -14,6 +14,7 @@ import { CronCreateTool, CronDeleteTool, CronListTool } from "./tools/CronTool/i
 import { DiagnosticsTool } from "./tools/DiagnosticsTool/index.js";
 import { EnterPlanModeTool } from "./tools/EnterPlanModeTool/index.js";
 import { EnterWorktreeTool } from "./tools/EnterWorktreeTool/index.js";
+import { ExaSearchTool } from "./tools/ExaSearchTool/index.js";
 import { ExitPlanModeTool } from "./tools/ExitPlanModeTool/index.js";
 import { ExitWorktreeTool } from "./tools/ExitWorktreeTool/index.js";
 import { FileEditTool } from "./tools/FileEditTool/index.js";
@@ -87,6 +88,7 @@ export function getAllTools() {
     const extended = [
         WebFetchTool,
         WebSearchTool,
+        ExaSearchTool,
         TaskGetTool,
         TaskStopTool,
         TaskOutputTool,

package/dist/utils/fuzzy.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Subsequence-match scoring for slash-command and similar pickers.
+ *
+ * Given a query, returns matched candidates in best-first order with all
+ * non-matches dropped. A candidate matches when every query character appears
+ * in the candidate name in order (not necessarily contiguous). Score rewards
+ * contiguous runs, prefix matches, and word-boundary hits so "git" still
+ * surfaces "/git" before "/login" when typing "g".
+ *
+ * Audit U-B3: replaces the prior `startsWith` filter in `src/repl.ts`.
+ */
+export type FuzzyEntry<T> = T & {
+    name: string;
+};
+export type FuzzyResult<T> = {
+    entry: FuzzyEntry<T>;
+    score: number;
+};
+/**
+ * Score a single candidate against the query. Returns `null` when query is not
+ * a subsequence of name. Higher scores are better.
+ *
+ * Scoring rubric (additive):
+ *  +100  candidate name starts with query (still earns subsequence bonus on top)
+ *  +50   per character of contiguous run (max once per matched char pair)
+ *  +20   match on a word-boundary char (after `-`, `_`, ` `, ':' or at start)
+ *  +1    base per matched character
+ *  -1    per skipped (unmatched) character before final query char
+ */
+export declare function fuzzyScore(query: string, name: string): number | null;
+/**
+ * Filter and rank entries by `entry.name` against `query`. Stable for ties:
+ * preserves the original input order so registration-order categories stay
+ * naturally contiguous when scores are equal.
+ */
+export declare function fuzzyFilter<T extends {
+    name: string;
+}>(query: string, entries: T[]): FuzzyResult<T>[];
+//# sourceMappingURL=fuzzy.d.ts.map

package/dist/utils/fuzzy.js

@@ -0,0 +1,70 @@
+/**
+ * Subsequence-match scoring for slash-command and similar pickers.
+ *
+ * Given a query, returns matched candidates in best-first order with all
+ * non-matches dropped. A candidate matches when every query character appears
+ * in the candidate name in order (not necessarily contiguous). Score rewards
+ * contiguous runs, prefix matches, and word-boundary hits so "git" still
+ * surfaces "/git" before "/login" when typing "g".
+ *
+ * Audit U-B3: replaces the prior `startsWith` filter in `src/repl.ts`.
+ */
+/**
+ * Score a single candidate against the query. Returns `null` when query is not
+ * a subsequence of name. Higher scores are better.
+ *
+ * Scoring rubric (additive):
+ *  +100  candidate name starts with query (still earns subsequence bonus on top)
+ *  +50   per character of contiguous run (max once per matched char pair)
+ *  +20   match on a word-boundary char (after `-`, `_`, ` `, ':' or at start)
+ *  +1    base per matched character
+ *  -1    per skipped (unmatched) character before final query char
+ */
+export function fuzzyScore(query, name) {
+    if (query.length === 0)
+        return 0;
+    const q = query.toLowerCase();
+    const n = name.toLowerCase();
+    let qi = 0;
+    let score = 0;
+    let lastMatchIdx = -2;
+    for (let i = 0; i < n.length && qi < q.length; i++) {
+        if (n[i] === q[qi]) {
+            score += 1;
+            const isBoundary = i === 0 || /[-_ :./]/.test(n[i - 1]);
+            if (isBoundary)
+                score += 20;
+            if (i === lastMatchIdx + 1)
+                score += 50;
+            lastMatchIdx = i;
+            qi++;
+        }
+    }
+    if (qi < q.length)
+        return null;
+    // Prefix bonus: candidate begins with the full query verbatim.
+    if (n.startsWith(q))
+        score += 100;
+    // Penalty for skipped chars between first and last match.
+    const span = lastMatchIdx - (n.indexOf(q[0]) ?? 0);
+    if (span > q.length)
+        score -= span - q.length;
+    return score;
+}
+/**
+ * Filter and rank entries by `entry.name` against `query`. Stable for ties:
+ * preserves the original input order so registration-order categories stay
+ * naturally contiguous when scores are equal.
+ */
+export function fuzzyFilter(query, entries) {
+    const out = [];
+    for (const entry of entries) {
+        const score = fuzzyScore(query, entry.name);
+        if (score === null)
+            continue;
+        out.push({ entry: entry, score });
+    }
+    out.sort((a, b) => b.score - a.score);
+    return out;
+}
+//# sourceMappingURL=fuzzy.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zhijiewang/openharness",
-  "version": "2.22.1",
+  "version": "2.24.0",
   "description": "Open-source terminal coding agent. Works with any LLM.",
   "type": "module",
   "bin": {