cursor-opencode-provider 0.1.1

package/dist/context/git.d.ts

@@ -0,0 +1,20 @@
+export type RepoInfo = {
+    relative_workspace_path: string;
+    remote_urls: string[];
+    remote_names: string[];
+    repo_name: string;
+    repo_owner: string;
+    is_tracked: boolean;
+    is_local: boolean;
+    workspace_uri: string;
+};
+export type GitRepoInfo = {
+    path: string;
+    status: string;
+    branch_name: string;
+    remote_url?: string;
+};
+export declare function collectGit(workspaceRoot: string): Promise<{
+    repositoryInfo: RepoInfo[];
+    gitRepos: GitRepoInfo[];
+}>;

package/dist/context/git.js

@@ -0,0 +1,59 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import path from "node:path";
+const execFileAsync = promisify(execFile);
+async function git(cwd, args) {
+    try {
+        const { stdout } = await execFileAsync("git", args, { cwd, encoding: "utf-8", timeout: 5000 });
+        return stdout.trim();
+    }
+    catch {
+        return "";
+    }
+}
+export async function collectGit(workspaceRoot) {
+    const root = await git(workspaceRoot, ["rev-parse", "--show-toplevel"]);
+    if (!root)
+        return { repositoryInfo: [], gitRepos: [] };
+    const remotesRaw = await git(root, ["remote", "-v"]);
+    const remote_urls = [];
+    const remote_names = [];
+    for (const line of remotesRaw.split("\n")) {
+        const m = line.match(/^(\S+)\s+(\S+)\s+\(fetch\)/);
+        if (!m)
+            continue;
+        remote_names.push(m[1]);
+        remote_urls.push(m[2]);
+    }
+    const primary = remote_urls[0] ?? "";
+    let repo_owner = "";
+    let repo_name = path.basename(root);
+    const gh = primary.match(/[:/]([^/]+)\/([^/]+?)(?:\.git)?$/);
+    if (gh) {
+        repo_owner = gh[1];
+        repo_name = gh[2];
+    }
+    const branch = (await git(root, ["rev-parse", "--abbrev-ref", "HEAD"])) || "HEAD";
+    const status = await git(root, ["status", "--porcelain", "-b"]);
+    const repositoryInfo = [
+        {
+            relative_workspace_path: ".",
+            remote_urls,
+            remote_names,
+            repo_name,
+            repo_owner,
+            is_tracked: remote_urls.length > 0,
+            is_local: remote_urls.length === 0,
+            workspace_uri: `file://${root}`,
+        },
+    ];
+    const gitRepos = [
+        {
+            path: root,
+            status: status.slice(0, 4000),
+            branch_name: branch,
+            ...(primary ? { remote_url: primary } : {}),
+        },
+    ];
+    return { repositoryInfo, gitRepos };
+}

package/dist/context/index.d.ts

@@ -0,0 +1,2 @@
+export { buildRequestContext, type BuildRequestContextInput } from "./build.js";
+export { opencodeGlobalConfigDir } from "./paths.js";

package/dist/context/index.js

@@ -0,0 +1,2 @@
+export { buildRequestContext } from "./build.js";
+export { opencodeGlobalConfigDir } from "./paths.js";

package/dist/context/layout.d.ts

@@ -0,0 +1,17 @@
+export type LayoutNode = {
+    abs_path: string;
+    children_dirs: LayoutNode[];
+    children_files: Array<{
+        name: string;
+    }>;
+    children_were_processed: boolean;
+    num_files: number;
+};
+/**
+ * Shallow project layout for RequestContext.project_layouts.
+ * Caps depth and entries to keep the payload small.
+ */
+export declare function collectProjectLayout(workspaceRoot: string, opts?: {
+    maxDepth?: number;
+    maxEntries?: number;
+}): Promise<LayoutNode>;

package/dist/context/layout.js

@@ -0,0 +1,58 @@
+import { readdir, stat } from "node:fs/promises";
+import path from "node:path";
+const SKIP = new Set(["node_modules", ".git", "dist", "build", ".next", "coverage", ".turbo"]);
+/**
+ * Shallow project layout for RequestContext.project_layouts.
+ * Caps depth and entries to keep the payload small.
+ */
+export async function collectProjectLayout(workspaceRoot, opts = {}) {
+    const maxDepth = opts.maxDepth ?? 2;
+    const maxEntries = opts.maxEntries ?? 80;
+    return walk(path.resolve(workspaceRoot), 0, maxDepth, maxEntries);
+}
+async function walk(dir, depth, maxDepth, maxEntries) {
+    const node = {
+        abs_path: dir,
+        children_dirs: [],
+        children_files: [],
+        children_were_processed: depth < maxDepth,
+        num_files: 0,
+    };
+    if (depth >= maxDepth)
+        return node;
+    let names;
+    try {
+        names = await readdir(dir);
+    }
+    catch {
+        node.children_were_processed = false;
+        return node;
+    }
+    names.sort();
+    let count = 0;
+    for (const name of names) {
+        if (count >= maxEntries)
+            break;
+        if (name.startsWith(".") && name !== ".opencode" && name !== ".claude" && name !== ".agents")
+            continue;
+        if (SKIP.has(name))
+            continue;
+        const full = path.join(dir, name);
+        let st;
+        try {
+            st = await stat(full);
+        }
+        catch {
+            continue;
+        }
+        count++;
+        if (st.isDirectory()) {
+            node.children_dirs.push(await walk(full, depth + 1, maxDepth, maxEntries));
+        }
+        else {
+            node.children_files.push({ name });
+            node.num_files++;
+        }
+    }
+    return node;
+}

package/dist/context/paths.d.ts

@@ -0,0 +1,3 @@
+/** OpenCode global config dir (`~/.config/opencode`). */
+export declare function opencodeGlobalConfigDir(): string;
+export declare function resolveHomeRelative(p: string): string;

package/dist/context/paths.js

@@ -0,0 +1,11 @@
+import { homedir } from "node:os";
+import path from "node:path";
+/** OpenCode global config dir (`~/.config/opencode`). */
+export function opencodeGlobalConfigDir() {
+    return path.join(homedir(), ".config", "opencode");
+}
+export function resolveHomeRelative(p) {
+    if (p.startsWith("~/"))
+        return path.join(homedir(), p.slice(2));
+    return p;
+}

package/dist/context/plugins.d.ts

@@ -0,0 +1,8 @@
+import type { OpencodeJson } from "./rules.js";
+export type CollectedPlugin = {
+    id: string;
+    source: "npm" | "local";
+    path?: string;
+};
+/** OpenCode plugins from config + local plugin directories (metadata only). */
+export declare function collectPlugins(workspaceRoot: string, config: OpencodeJson): Promise<CollectedPlugin[]>;

package/dist/context/plugins.js

@@ -0,0 +1,50 @@
+import { readdir, stat } from "node:fs/promises";
+import path from "node:path";
+import { opencodeGlobalConfigDir } from "./paths.js";
+async function listLocalPlugins(dir) {
+    try {
+        await stat(dir);
+    }
+    catch {
+        return [];
+    }
+    const out = [];
+    let entries;
+    try {
+        entries = await readdir(dir);
+    }
+    catch {
+        return [];
+    }
+    for (const name of entries) {
+        if (!/\.(m?[jt]s)$/.test(name))
+            continue;
+        const full = path.join(dir, name);
+        out.push({ id: name.replace(/\.(m?[jt]s)$/, ""), source: "local", path: full });
+    }
+    return out;
+}
+/** OpenCode plugins from config + local plugin directories (metadata only). */
+export async function collectPlugins(workspaceRoot, config) {
+    const out = [];
+    const seen = new Set();
+    for (const id of [...(config.plugin ?? []), ...(config.plugins ?? [])]) {
+        if (!id || seen.has(id))
+            continue;
+        seen.add(id);
+        out.push({ id, source: "npm" });
+    }
+    for (const p of await listLocalPlugins(path.join(workspaceRoot, ".opencode", "plugins"))) {
+        if (seen.has(p.id))
+            continue;
+        seen.add(p.id);
+        out.push(p);
+    }
+    for (const p of await listLocalPlugins(path.join(opencodeGlobalConfigDir(), "plugins"))) {
+        if (seen.has(p.id))
+            continue;
+        seen.add(p.id);
+        out.push(p);
+    }
+    return out;
+}

package/dist/context/rules.d.ts

@@ -0,0 +1,19 @@
+export type CollectedRule = {
+    fullPath: string;
+    content: string;
+};
+export type OpencodeJson = {
+    instructions?: string[];
+    permission?: unknown;
+    plugin?: string[];
+    plugins?: string[];
+};
+export declare function loadMergedConfig(workspaceRoot: string): Promise<OpencodeJson>;
+/**
+ * Collect OpenCode instruction files.
+ */
+export declare function collectRules(workspaceRoot: string): Promise<{
+    rules: CollectedRule[];
+    config: OpencodeJson;
+    worktree: string;
+}>;

package/dist/context/rules.js

@@ -0,0 +1,198 @@
+import { readFile, readdir, stat } from "node:fs/promises";
+import { homedir } from "node:os";
+import path from "node:path";
+import { opencodeGlobalConfigDir, resolveHomeRelative } from "./paths.js";
+async function exists(file) {
+    try {
+        await stat(file);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function readJsonConfig(dir) {
+    for (const name of ["opencode.json", "opencode.jsonc"]) {
+        const file = path.join(dir, name);
+        if (!(await exists(file)))
+            continue;
+        try {
+            const raw = await readFile(file, "utf-8");
+            const stripped = raw.replace(/\/\*[\s\S]*?\*\//g, "").replace(/^\s*\/\/.*$/gm, "");
+            return JSON.parse(stripped);
+        }
+        catch {
+            return {};
+        }
+    }
+    return {};
+}
+async function findGitWorktree(start) {
+    let dir = path.resolve(start);
+    for (;;) {
+        if (await exists(path.join(dir, ".git")))
+            return dir;
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            return path.resolve(start);
+        dir = parent;
+    }
+}
+async function findUp(name, start, stop) {
+    let dir = path.resolve(start);
+    const root = path.resolve(stop);
+    for (;;) {
+        const candidate = path.join(dir, name);
+        if (await exists(candidate))
+            return candidate;
+        if (dir === root)
+            return undefined;
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            return undefined;
+        dir = parent;
+    }
+}
+async function readRule(file) {
+    if (!(await exists(file)))
+        return undefined;
+    try {
+        const content = await readFile(file, "utf-8");
+        if (!content.trim())
+            return undefined;
+        return { fullPath: path.resolve(file), content };
+    }
+    catch {
+        return undefined;
+    }
+}
+function globToRegExp(glob) {
+    const norm = glob.replace(/\\/g, "/");
+    let re = "^";
+    for (let i = 0; i < norm.length; i++) {
+        const c = norm[i];
+        if (c === "*") {
+            if (norm[i + 1] === "*") {
+                re += ".*";
+                i++;
+                if (norm[i + 1] === "/")
+                    i++;
+            }
+            else {
+                re += "[^/]*";
+            }
+        }
+        else if (".$^+?()[]{}|".includes(c) || c === "\\") {
+            re += "\\" + c;
+        }
+        else {
+            re += c;
+        }
+    }
+    return new RegExp(re + "$");
+}
+async function expandGlob(pattern, workspaceRoot) {
+    const abs = path.isAbsolute(pattern) ? pattern : path.join(workspaceRoot, pattern);
+    if (!abs.includes("*"))
+        return (await exists(abs)) ? [abs] : [];
+    const out = [];
+    const base = abs.split("*")[0] || workspaceRoot;
+    const startDir = path.dirname(base.endsWith("/") ? base : base);
+    const regex = globToRegExp(abs);
+    async function walk(dir, depth) {
+        if (depth > 8)
+            return;
+        let entries;
+        try {
+            entries = await readdir(dir);
+        }
+        catch {
+            return;
+        }
+        for (const name of entries) {
+            if (name === "node_modules" || name === ".git")
+                continue;
+            const full = path.join(dir, name);
+            let st;
+            try {
+                st = await stat(full);
+            }
+            catch {
+                continue;
+            }
+            if (st.isDirectory())
+                await walk(full, depth + 1);
+            else if (regex.test(full.replace(/\\/g, "/")))
+                out.push(full);
+        }
+    }
+    await walk(startDir, 0);
+    return out;
+}
+export async function loadMergedConfig(workspaceRoot) {
+    const globalConfig = await readJsonConfig(opencodeGlobalConfigDir());
+    const projectConfig = await readJsonConfig(workspaceRoot);
+    return {
+        ...globalConfig,
+        ...projectConfig,
+        instructions: [...(globalConfig.instructions ?? []), ...(projectConfig.instructions ?? [])],
+        plugin: [...new Set([...(globalConfig.plugin ?? []), ...(projectConfig.plugin ?? [])])],
+        plugins: [...new Set([...(globalConfig.plugins ?? []), ...(projectConfig.plugins ?? [])])],
+        permission: projectConfig.permission ?? globalConfig.permission,
+    };
+}
+/**
+ * Collect OpenCode instruction files.
+ */
+export async function collectRules(workspaceRoot) {
+    const worktree = await findGitWorktree(workspaceRoot);
+    const rules = [];
+    const seen = new Set();
+    const config = await loadMergedConfig(workspaceRoot);
+    const add = async (file) => {
+        if (!file)
+            return;
+        const resolved = path.resolve(file);
+        if (seen.has(resolved))
+            return;
+        const rule = await readRule(resolved);
+        if (!rule)
+            return;
+        seen.add(resolved);
+        rules.push(rule);
+    };
+    for (const name of ["AGENTS.md", "CLAUDE.md", "CONTEXT.md"]) {
+        const hit = await findUp(name, workspaceRoot, worktree);
+        if (hit) {
+            await add(hit);
+            break;
+        }
+    }
+    await add(path.join(opencodeGlobalConfigDir(), "AGENTS.md"));
+    await add(path.join(homedir(), ".claude", "CLAUDE.md"));
+    for (const raw of config.instructions ?? []) {
+        if (raw.startsWith("http://") || raw.startsWith("https://")) {
+            try {
+                const ctrl = new AbortController();
+                const t = setTimeout(() => ctrl.abort(), 5000);
+                const res = await fetch(raw, { signal: ctrl.signal });
+                clearTimeout(t);
+                if (!res.ok)
+                    continue;
+                const content = await res.text();
+                if (!content.trim() || seen.has(raw))
+                    continue;
+                seen.add(raw);
+                rules.push({ fullPath: raw, content });
+            }
+            catch {
+                /* ignore */
+            }
+            continue;
+        }
+        const expanded = resolveHomeRelative(raw);
+        for (const m of await expandGlob(expanded, workspaceRoot))
+            await add(m);
+    }
+    return { rules, config, worktree };
+}

package/dist/context/skills.d.ts

@@ -0,0 +1,11 @@
+export type CollectedSkill = {
+    fullPath: string;
+    name: string;
+    description: string;
+    content: string;
+};
+/**
+ * Discover skills the way OpenCode does: `.opencode/skills`, global opencode,
+ * plus `.claude/skills` and `.agents/skills` (project + home).
+ */
+export declare function collectSkills(workspaceRoot: string, worktree: string): Promise<CollectedSkill[]>;

package/dist/context/skills.js

@@ -0,0 +1,104 @@
+import { readdir, readFile, stat } from "node:fs/promises";
+import path from "node:path";
+import { homedir } from "node:os";
+import { opencodeGlobalConfigDir } from "./paths.js";
+async function exists(p) {
+    try {
+        await stat(p);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function parseFrontmatter(raw) {
+    if (!raw.startsWith("---"))
+        return { body: raw };
+    const end = raw.indexOf("\n---", 3);
+    if (end < 0)
+        return { body: raw };
+    const fm = raw.slice(3, end).trim();
+    const body = raw.slice(end + 4).replace(/^\n/, "");
+    let name;
+    let description;
+    for (const line of fm.split("\n")) {
+        const m = line.match(/^(\w+):\s*(.*)$/);
+        if (!m)
+            continue;
+        const key = m[1];
+        let val = m[2].trim();
+        if ((val.startsWith('"') && val.endsWith('"')) || (val.startsWith("'") && val.endsWith("'"))) {
+            val = val.slice(1, -1);
+        }
+        if (key === "name")
+            name = val;
+        if (key === "description")
+            description = val;
+    }
+    return { name, description, body };
+}
+async function loadSkillFile(file) {
+    try {
+        const raw = await readFile(file, "utf-8");
+        const { name, description, body } = parseFrontmatter(raw);
+        const dirName = path.basename(path.dirname(file));
+        return {
+            fullPath: path.resolve(file),
+            name: name || dirName,
+            description: description || "",
+            content: body.slice(0, 20_000),
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
+async function scanSkillsRoot(root, out) {
+    if (!(await exists(root)))
+        return;
+    let entries;
+    try {
+        entries = await readdir(root);
+    }
+    catch {
+        return;
+    }
+    for (const name of entries) {
+        const skillMd = path.join(root, name, "SKILL.md");
+        if (!(await exists(skillMd)))
+            continue;
+        const skill = await loadSkillFile(skillMd);
+        if (!skill)
+            continue;
+        if (!out.has(skill.name))
+            out.set(skill.name, skill);
+    }
+}
+async function walkAncestorsFor(dir, rel, stop, out) {
+    let cur = path.resolve(dir);
+    const root = path.resolve(stop);
+    for (;;) {
+        await scanSkillsRoot(path.join(cur, rel), out);
+        if (cur === root)
+            break;
+        const parent = path.dirname(cur);
+        if (parent === cur)
+            break;
+        cur = parent;
+    }
+}
+/**
+ * Discover skills the way OpenCode does: `.opencode/skills`, global opencode,
+ * plus `.claude/skills` and `.agents/skills` (project + home).
+ */
+export async function collectSkills(workspaceRoot, worktree) {
+    const out = new Map();
+    const home = homedir();
+    await walkAncestorsFor(workspaceRoot, path.join(".opencode", "skills"), worktree, out);
+    await scanSkillsRoot(path.join(opencodeGlobalConfigDir(), "skills"), out);
+    await walkAncestorsFor(workspaceRoot, path.join(".claude", "skills"), worktree, out);
+    await scanSkillsRoot(path.join(home, ".claude", "skills"), out);
+    await walkAncestorsFor(workspaceRoot, path.join(".agents", "skills"), worktree, out);
+    await scanSkillsRoot(path.join(home, ".agents", "skills"), out);
+    return [...out.values()];
+}

package/dist/index.d.ts

@@ -0,0 +1,15 @@
+import { CursorPlugin } from "./plugin.js";
+export type CreateCursorOptions = {
+    name: string;
+    accessToken?: string;
+    apiKey?: string;
+    baseURL?: string;
+    headers?: Record<string, string>;
+    /** OpenCode project / worktree directory for request_context collectors. */
+    workspaceRoot?: string;
+};
+export declare function createCursor(options: CreateCursorOptions): {
+    languageModel(modelId: string): import("@ai-sdk/provider").LanguageModelV3;
+};
+export { CursorPlugin };
+export default CursorPlugin;

package/dist/index.js

@@ -0,0 +1,18 @@
+import { CURSOR_PROVIDER_ID } from "./shared.js";
+import { createCursorLanguageModel } from "./language-model.js";
+import { CursorPlugin } from "./plugin.js";
+export function createCursor(options) {
+    const providerId = options.name || CURSOR_PROVIDER_ID;
+    return {
+        languageModel(modelId) {
+            return createCursorLanguageModel(modelId, providerId, options);
+        },
+    };
+}
+export { CursorPlugin };
+export default CursorPlugin;
+// CursorPluginV2 is NOT re-exported here — see plugin-v2.ts.
+// OpenCode's legacy plugin loader (getLegacyPlugins) iterates all exports
+// and calls getServerPlugin on each; the v2 define() return is not a
+// function, causing "Plugin export is not a function". Load it via
+// the separate "cursor-opencode-provider/plugin/v2" export path.

package/dist/language-model.d.ts

@@ -0,0 +1,45 @@
+import type { LanguageModelV3, LanguageModelV3CallOptions } from "@ai-sdk/provider";
+import type { CreateCursorOptions } from "./index.js";
+import { type CursorSession } from "./session.js";
+export declare function createCursorLanguageModel(modelId: string, providerId: string, options: CreateCursorOptions): LanguageModelV3;
+/**
+ * OpenCode re-sends the full tool-result history on every continuation. Prefer
+ * the newest result that still has a live pending exec on its tagged session.
+ */
+export declare function findContinuationSession(toolResults: Array<{
+    sessionId: string;
+    execId: number;
+}>): CursorSession | undefined;
+type ExtractedToolResult = {
+    sessionId: string;
+    execId: number;
+    toolName: string;
+    output: string;
+    error?: string;
+};
+/**
+ * Tool results that form a live continuation: only the trailing run of `tool`
+ * messages after the last non-tool message. Mid-prompt historical tool results
+ * are ignored — they are conversation history, not replies for a held-open Run.
+ */
+export declare function extractTrailingToolResults(prompt: LanguageModelV3CallOptions["prompt"]): ExtractedToolResult[];
+/**
+ * Map OpenCode's session id header to a stable Cursor conversation_id (UUID).
+ * Falls back to a random UUID when headers are absent (direct SDK use).
+ */
+export declare function resolveConversationId(callOptions: LanguageModelV3CallOptions): string;
+/** Deterministic UUID (version-4 shape) from an arbitrary session key. */
+export declare function sessionIdToUuid(sessionId: string): string;
+/** Exported for tests — AI SDK V3 span ends that must precede finish / tool-call. */
+export declare function spanEndParts(opts: {
+    textStarted: boolean;
+    reasoningStarted: boolean;
+    textId: string;
+    reasoningId: string;
+}): Array<{
+    type: "text-end" | "reasoning-end";
+    id: string;
+}>;
+/** Exported for tests — false for compaction/summary (no tools) and toolChoice none. */
+export declare function computeAllowTools(toolCount: number, toolChoice: LanguageModelV3CallOptions["toolChoice"] | undefined): boolean;
+export {};