@kagan-sh/opensearch 0.1.0

package/dist/sources/code.js

@@ -0,0 +1,36 @@
+import { failure, messageFromError } from "./shared";
+export async function searchCode(query, depth) {
+    const source = "code";
+    try {
+        const url = `https://grep.app/api/search?q=${encodeURIComponent(query)}&limit=${depth === "quick" ? 5 : 10}`;
+        const res = await fetch(url);
+        if (!res.ok) {
+            return failure(source, "request_failed", `grep.app search failed with status ${res.status}.`);
+        }
+        const body = (await res.json());
+        if (body.hits && !Array.isArray(body.hits.hits)) {
+            return failure(source, "invalid_response", "grep.app search returned an invalid payload.");
+        }
+        const list = body.hits?.hits ?? [];
+        return {
+            source,
+            results: list.map((hit, i) => {
+                const repo = hit.repo?.raw ?? "unknown";
+                const path = hit.path?.raw ?? "";
+                return {
+                    id: `code-${repo}-${path}-${i}`,
+                    type: source,
+                    title: path ? `${repo}/${path}` : repo,
+                    snippet: (hit.content?.snippet ?? "").slice(0, 700),
+                    url: `https://grep.app/search?q=${encodeURIComponent(query)}`,
+                    relevance: typeof hit.score === "number"
+                        ? Math.min(1, Math.max(0, hit.score / 100))
+                        : 0.5,
+                };
+            }),
+        };
+    }
+    catch (error) {
+        return failure(source, "request_failed", `grep.app search failed: ${messageFromError(error)}`);
+    }
+}

package/dist/sources/session.d.ts

@@ -0,0 +1,4 @@
+import type { createOpencodeClient } from "@opencode-ai/sdk";
+import type { Depth } from "../schema";
+import { type SourceSearchOutcome } from "./shared";
+export declare function searchSessions(client: ReturnType<typeof createOpencodeClient>, directory: string, query: string, depth: Depth): Promise<SourceSearchOutcome>;

package/dist/sources/session.js

@@ -0,0 +1,75 @@
+import { failure, messageFromError, sourceError } from "./shared";
+function words(query) {
+    return query.toLowerCase().split(/\s+/).filter(Boolean);
+}
+function count(text, key) {
+    return text.toLowerCase().split(key.toLowerCase()).length - 1;
+}
+function text(parts) {
+    return parts
+        .filter((part) => part.type === "text" || part.type === "reasoning")
+        .map((part) => part.text ?? "")
+        .join("\n");
+}
+export async function searchSessions(client, directory, query, depth) {
+    const source = "session";
+    const key = words(query);
+    if (key.length === 0) {
+        return {
+            source,
+            results: [],
+        };
+    }
+    let listRes;
+    try {
+        listRes = await client.session.list({ query: { directory } });
+    }
+    catch (error) {
+        return failure(source, "request_failed", `Session search failed: ${messageFromError(error)}`);
+    }
+    if (!Array.isArray(listRes?.data)) {
+        return failure(source, "invalid_response", "Session search returned an invalid session list.");
+    }
+    const list = listRes.data;
+    const top = list
+        .filter((item) => key.some((word) => item.title.toLowerCase().includes(word)))
+        .slice(0, depth === "quick" ? 5 : 15);
+    const settled = await Promise.allSettled(top.map(async (item) => {
+        const msgRes = await client.session.messages({
+            path: { id: item.id },
+            query: { directory, limit: depth === "quick" ? 50 : 200 },
+        });
+        if (!Array.isArray(msgRes.data)) {
+            throw new Error("invalid session transcript payload");
+        }
+        const body = msgRes.data.map((row) => text(row.parts)).join("\n");
+        const hit = key.reduce((sum, word) => sum + count(body, word), 0);
+        const rel = Math.min(1, hit / Math.max(1, key.length * 4));
+        if (hit === 0)
+            return null;
+        return {
+            id: item.id,
+            type: source,
+            title: item.title,
+            snippet: body.slice(0, 700) || item.title,
+            url: item.id,
+            relevance: rel,
+            timestamp: item.time.updated,
+        };
+    }));
+    const results = settled.flatMap((item) => {
+        if (item.status !== "fulfilled" || item.value === null)
+            return [];
+        return [item.value];
+    });
+    const failed = settled.filter((item) => item.status === "rejected").length;
+    return {
+        source,
+        results,
+        ...(failed > 0
+            ? {
+                error: sourceError(source, "request_failed", `Failed to read ${failed} session ${failed === 1 ? "transcript" : "transcripts"}.`),
+            }
+            : {}),
+    };
+}

package/dist/sources/shared.d.ts

@@ -0,0 +1,9 @@
+import type { RawResult, SourceError, SourceId } from "../schema";
+export type SourceSearchOutcome = {
+    source: SourceId;
+    results: RawResult[];
+    error?: SourceError;
+};
+export declare function sourceError(source: SourceId, code: SourceError["code"], message: string): SourceError;
+export declare function failure(source: SourceId, code: SourceError["code"], message: string): SourceSearchOutcome;
+export declare function messageFromError(error: unknown): string;

package/dist/sources/shared.js

@@ -0,0 +1,19 @@
+export function sourceError(source, code, message) {
+    return {
+        source,
+        code,
+        message,
+    };
+}
+export function failure(source, code, message) {
+    return {
+        source,
+        results: [],
+        error: sourceError(source, code, message),
+    };
+}
+export function messageFromError(error) {
+    if (error instanceof Error && error.message)
+        return error.message;
+    return String(error);
+}

package/dist/sources/web.d.ts

@@ -0,0 +1,3 @@
+import type { Depth } from "../schema";
+import { type SourceSearchOutcome } from "./shared";
+export declare function searchWeb(query: string, key: string | undefined, depth: Depth): Promise<SourceSearchOutcome>;

package/dist/sources/web.js

@@ -0,0 +1,53 @@
+import { failure, messageFromError } from "./shared";
+export async function searchWeb(query, key, depth) {
+    const source = "web";
+    if (!key) {
+        return failure(source, "unavailable", "Web source requires OPENSEARCH_WEB_KEY or EXA_API_KEY.");
+    }
+    try {
+        const res = await fetch("https://api.exa.ai/search", {
+            method: "POST",
+            headers: {
+                "x-api-key": key,
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify({
+                query,
+                numResults: depth === "quick" ? 5 : 10,
+                type: "auto",
+                contents: {
+                    text: {
+                        maxCharacters: 1000,
+                    },
+                },
+            }),
+        });
+        if (!res.ok) {
+            return failure(source, "request_failed", `Exa search failed with status ${res.status}.`);
+        }
+        const body = (await res.json());
+        if (!Array.isArray(body.results)) {
+            return failure(source, "invalid_response", "Exa search returned an invalid payload.");
+        }
+        const list = body.results;
+        return {
+            source,
+            results: list.map((item, i) => ({
+                id: item.id ?? `web-${i}`,
+                type: source,
+                title: item.title ?? item.url ?? "Untitled",
+                snippet: (item.text ?? "").slice(0, 700),
+                url: item.url,
+                relevance: typeof item.score === "number"
+                    ? Math.min(1, Math.max(0, item.score))
+                    : 0.5,
+                timestamp: item.publishedDate
+                    ? Date.parse(item.publishedDate) || undefined
+                    : undefined,
+            })),
+        };
+    }
+    catch (error) {
+        return failure(source, "request_failed", `Exa search failed: ${messageFromError(error)}`);
+    }
+}

package/dist/synth.d.ts

@@ -0,0 +1,3 @@
+import type { createOpencodeClient } from "@opencode-ai/sdk";
+import { type RawResult, type Synthesis } from "./schema";
+export declare function synthesize(client: ReturnType<typeof createOpencodeClient>, directory: string, raw: RawResult[], query: string): Promise<Synthesis>;

package/dist/synth.js

@@ -0,0 +1,79 @@
+import { SynthesisSchema, synthesisJsonSchema, } from "./schema";
+const PROMPT = `You are a synthesis engine for opensearch.
+
+Goal:
+- Produce a laconic direct answer to the user query.
+- Every factual claim must map to source IDs from the provided sources.
+- Set confidence by source agreement and evidence quality.
+- Suggest 2-3 concise followup queries.
+
+Output rules:
+- Return valid JSON only.
+- Use source IDs exactly as provided.
+- Do not invent sources.
+- Keep answer compact and concrete.`;
+function text(parts) {
+    return parts
+        .filter((part) => part.type === "text" || part.type === "reasoning")
+        .map((part) => part.text ?? "")
+        .join("\n");
+}
+function parse(input) {
+    const body = input.trim();
+    if (!body)
+        return null;
+    try {
+        return JSON.parse(body);
+    }
+    catch {
+        const start = body.indexOf("{");
+        const end = body.lastIndexOf("}");
+        if (start < 0 || end <= start)
+            return null;
+        return JSON.parse(body.slice(start, end + 1));
+    }
+}
+export async function synthesize(client, directory, raw, query) {
+    const made = await client.session.create({
+        query: { directory },
+        body: { title: "opensearch-synth" },
+    });
+    const id = made.data?.id;
+    if (!id) {
+        throw new Error("Unable to create a synthesis session.");
+    }
+    const input = `${PROMPT}\n\nUser query:\n${query}\n\nSources:\n${raw
+        .map((item, i) => `${i + 1}. id=${item.id} type=${item.type} title=${item.title}\nurl=${item.url ?? ""}\nrelevance=${item.relevance}\nsnippet=${item.snippet}`)
+        .join("\n\n")}`;
+    try {
+        const req = {
+            path: { id },
+            query: { directory },
+            body: {
+                agent: undefined,
+                noReply: false,
+                parts: [{ type: "text", text: input }],
+                format: {
+                    type: "json_schema",
+                    schema: synthesisJsonSchema(),
+                    retryCount: 2,
+                },
+            },
+        };
+        const msg = await client.session.prompt(req);
+        const body = parse(text(msg.data?.parts ?? []));
+        if (!body) {
+            throw new Error("Synthesis returned no JSON output.");
+        }
+        const parsed = SynthesisSchema.safeParse(body);
+        if (!parsed.success) {
+            throw new Error("Synthesis returned an invalid payload.");
+        }
+        return parsed.data;
+    }
+    finally {
+        await client.session
+            .delete({ path: { id }, query: { directory } })
+            .catch(() => true);
+    }
+}

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "@kagan-sh/opensearch",
+  "version": "0.1.0",
+  "description": "OpenCode plugin that combines session, web, and code search",
+  "homepage": "https://kagan-sh.github.io/opensearch/",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kagan-sh/opensearch.git"
+  },
+  "bugs": {
+    "url": "https://github.com/kagan-sh/opensearch/issues"
+  },
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "CONTRIBUTING.md",
+    "SKILL.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "bun tsc",
+    "typecheck": "bun tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "docs:build": "mkdocs build --strict",
+    "docs:serve": "mkdocs serve",
+    "check": "bun run typecheck && bun run test && bun run build",
+    "release": "semantic-release",
+    "release:dry-run": "semantic-release --dry-run"
+  },
+  "dependencies": {
+    "@opencode-ai/plugin": "1.2.27",
+    "@opencode-ai/sdk": "1.2.27",
+    "zod": "^3.24.0",
+    "zod-to-json-schema": "^3.24.0"
+  },
+  "devDependencies": {
+    "@types/bun": "1.3.11",
+    "conventional-changelog-conventionalcommits": "9.3.0",
+    "semantic-release": "25.0.3",
+    "typescript": "5.9.3",
+    "vitest": "4.1.0"
+  },
+  "peerDependencies": {
+    "bun": ">=1.2.0"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/",
+    "provenance": true
+  }
+}