@rama_nigg/open-cursor 2.2.1 → 2.3.0

package/src/tools/discovery.ts

@@ -0,0 +1,140 @@
+import type { ToolListResponse } from "@opencode-ai/sdk";
+import { createLogger } from "../utils/logger";
+import stripAnsi from "strip-ansi";
+
+const log = createLogger("tools:discovery");
+
+export interface OpenCodeTool {
+  id: string;
+  name: string; // namespaced for OpenAI (e.g., oc_<id>)
+  description: string;
+  parameters: any; // JSON Schema
+  source: "sdk" | "cli" | "mcp";
+}
+
+export interface DiscoveryOptions {
+  ttlMs?: number;
+  executor?: "sdk" | "cli" | "auto";
+}
+
+export class OpenCodeToolDiscovery {
+  private client: any;
+  private cache: Map<string, OpenCodeTool> = new Map();
+  private cacheExpiry = 0;
+  private ttl: number;
+  private executorPref: "sdk" | "cli" | "auto";
+
+  constructor(client: any, opts: DiscoveryOptions = {}) {
+    this.client = client;
+    this.ttl = opts.ttlMs ?? Number(process.env.CURSOR_ACP_TOOL_CACHE_TTL_MS || 60000);
+    // Default: auto (SDK first, CLI fallback). Users can force sdk or cli.
+    const envPref = process.env.CURSOR_ACP_TOOL_EXECUTOR as any;
+    this.executorPref = opts.executor ?? (envPref === "sdk" || envPref === "cli" ? envPref : "auto");
+  }
+
+  async listTools(): Promise<OpenCodeTool[]> {
+    const now = Date.now();
+    if (this.cache.size > 0 && now < this.cacheExpiry) {
+      return Array.from(this.cache.values());
+    }
+
+    let tools: OpenCodeTool[] = [];
+
+    // Try SDK first (tool.list) if available
+    if (this.executorPref !== "cli" && this.client?.tool?.list) {
+      try {
+        const resp: ToolListResponse = await this.client.tool.list({});
+        const rawTools = Array.isArray(resp?.data) ? resp.data : (resp?.data as any)?.tools || [];
+        tools = rawTools.map((t: any) => this.normalize(t, "sdk"));
+
+        // Merge MCP tools if available on client (best-effort)
+        const mcpTools = await this.tryListMcpTools();
+        tools = tools.concat(mcpTools);
+      } catch (err) {
+        log.debug("SDK tool.list failed, will try CLI", { error: String(err) });
+      }
+    }
+
+    // Fallback: CLI opencode tool list --json (only if executorPref allows)
+    if (tools.length === 0 && this.executorPref !== "sdk") {
+      try {
+        const { spawnSync } = await import("node:child_process");
+        const cliCmd = process.env.OPENCODE_TOOL_LIST_SHIM
+          ? process.env.OPENCODE_TOOL_LIST_SHIM.split(" ")
+          : ["opencode", "tool", "list", "--json"];
+        const res = spawnSync(cliCmd[0], cliCmd.slice(1), { encoding: "utf-8" });
+        const parsed = this.parseCliJson(res.stdout || "");
+        if (parsed?.data?.tools?.length) {
+          tools = parsed.data.tools.map((t: any) => this.normalize(t, "cli"));
+        } else {
+          log.debug("CLI tool list failed", { status: res.status, stderr: res.stderr });
+        }
+      } catch (err) {
+        log.debug("CLI tool list error", { error: String(err) });
+      }
+    }
+
+    // Silent skip if none
+
+    // Deduplicate by id after namespace
+    const map = new Map<string, OpenCodeTool>();
+    for (const t of tools) {
+      map.set(t.name, t);
+    }
+    this.cache = map;
+    this.cacheExpiry = now + this.ttl;
+    return Array.from(this.cache.values());
+  }
+
+  getToolByName(name: string): OpenCodeTool | undefined {
+    return this.cache.get(name);
+  }
+
+  private normalize(t: any, source: "sdk" | "cli" | "mcp"): OpenCodeTool {
+    const id = String(t.id || t.name || "unknown");
+    const name = this.namespace(id);
+    return {
+      id,
+      name,
+      description: String(t.description || "OpenCode tool"),
+      parameters: t.parameters || { type: "object", properties: {} },
+      source,
+    };
+  }
+
+  private namespace(id: string): string {
+    const sanitized = id.replace(/[^a-zA-Z0-9_\-]/g, "_").slice(0, 59); // leave room for prefix
+    return `oc_${sanitized}`;
+  }
+
+  // Best-effort MCP discovery (if SDK exposes it)
+  private async tryListMcpTools(): Promise<OpenCodeTool[]> {
+    try {
+      const mcpList = this.client?.mcp?.tool?.list ? await this.client.mcp.tool.list() : null;
+      if (!mcpList?.data?.tools) return [];
+      return mcpList.data.tools.map((t: any) => this.normalize(t, "mcp"));
+    } catch (err) {
+      log.debug("MCP tool discovery skipped", { error: String(err) });
+      return [];
+    }
+  }
+
+  // Parse JSON from noisy CLI output (strip ANSI, take last JSON object)
+  private parseCliJson(stdout: string): any | null {
+    const clean = stripAnsi(stdout || "").trim();
+    if (!clean) return null;
+    // Fast path
+    try {
+      return JSON.parse(clean);
+    } catch {}
+    // Find last '{'
+    const lastBrace = clean.lastIndexOf("{");
+    if (lastBrace >= 0) {
+      const substr = clean.slice(lastBrace);
+      try {
+        return JSON.parse(substr);
+      } catch {}
+    }
+    return null;
+  }
+}

package/src/tools/executors/cli.ts

@@ -0,0 +1,58 @@
+import stripAnsi from "strip-ansi";
+import type { IToolExecutor, ExecutionResult } from "../core/types.js";
+import { createLogger } from "../../utils/logger.js";
+
+const log = createLogger("tools:executor:cli");
+
+export class CliExecutor implements IToolExecutor {
+  constructor(private timeoutMs: number) {}
+
+  canExecute(): boolean {
+    return true; // last-resort; can gate by env if needed
+  }
+
+  async execute(toolId: string, args: Record<string, unknown>): Promise<ExecutionResult> {
+    try {
+      const { spawn } = await import("node:child_process");
+      const child = spawn("opencode", ["tool", "run", toolId, "--json", JSON.stringify(args)], {
+        stdio: ["ignore", "pipe", "pipe"],
+      });
+
+      const stdoutChunks: Buffer[] = [];
+      const stderrChunks: Buffer[] = [];
+
+      const exited = new Promise<{ code: number | null }>((resolve) => child.on("close", (code) => resolve({ code })));
+
+      const stdout = new Promise<string>((resolve) => {
+        child.stdout?.on("data", (c) => stdoutChunks.push(Buffer.from(c)));
+        child.stdout?.on("end", () => resolve(Buffer.concat(stdoutChunks).toString("utf-8")));
+      });
+
+      const stderr = new Promise<string>((resolve) => {
+        child.stderr?.on("data", (c) => stderrChunks.push(Buffer.from(c)));
+        child.stderr?.on("end", () => resolve(Buffer.concat(stderrChunks).toString("utf-8")));
+      });
+
+      const { code } = await this.runWithTimeout(exited);
+      const out = await stdout;
+      const err = await stderr;
+
+      if (code === 0) {
+        const clean = stripAnsi(out || "");
+        return { status: "success", output: clean || "(no output)" };
+      }
+      return { status: "error", error: stripAnsi(err || out || `Exit code ${code}`) };
+    } catch (err: any) {
+      log.warn("CLI tool execution failed", { toolId, error: String(err?.message || err) });
+      return { status: "error", error: String(err?.message || err) };
+    }
+  }
+
+  private async runWithTimeout<T>(p: Promise<T>): Promise<T> {
+    if (!this.timeoutMs) return p;
+    return await Promise.race([
+      p,
+      new Promise<T>((_, reject) => setTimeout(() => reject(new Error("tool execution timeout")), this.timeoutMs)),
+    ]);
+  }
+}

package/src/tools/executors/local.ts

@@ -0,0 +1,25 @@
+import type { IToolExecutor, ExecutionResult } from "../core/types.js";
+import type { ToolRegistry } from "../core/registry.js";
+import { createLogger } from "../../utils/logger.js";
+
+const log = createLogger("tools:executor:local");
+
+export class LocalExecutor implements IToolExecutor {
+  constructor(private registry: ToolRegistry) {}
+
+  canExecute(toolId: string): boolean {
+    return Boolean(this.registry.getHandler(toolId));
+  }
+
+  async execute(toolId: string, args: Record<string, unknown>): Promise<ExecutionResult> {
+    const handler = this.registry.getHandler(toolId);
+    if (!handler) return { status: "error", error: `Unknown tool ${toolId}` };
+    try {
+      const out = await handler(args);
+      return { status: "success", output: out };
+    } catch (err: any) {
+      log.warn("Local tool execution failed", { toolId, error: String(err?.message || err) });
+      return { status: "error", error: String(err?.message || err) };
+    }
+  }
+}

package/src/tools/executors/mcp.ts

@@ -0,0 +1,39 @@
+import type { IToolExecutor, ExecutionResult } from "../core/types.js";
+import { createLogger } from "../../utils/logger.js";
+
+const log = createLogger("tools:executor:mcp");
+
+export class McpExecutor implements IToolExecutor {
+  private toolIds = new Set<string>();
+
+  constructor(private client: any, private timeoutMs: number) {}
+
+  setToolIds(ids: Iterable<string>): void {
+    this.toolIds = new Set(ids);
+  }
+
+  canExecute(toolId: string): boolean {
+    return Boolean(this.client?.mcp?.tool?.invoke) && this.toolIds.has(toolId);
+  }
+
+  async execute(toolId: string, args: Record<string, unknown>): Promise<ExecutionResult> {
+    if (!this.canExecute(toolId)) return { status: "error", error: "MCP invoke unavailable" };
+    try {
+      const p = this.client.mcp.tool.invoke(toolId, args);
+      const res = await this.runWithTimeout(p);
+      const out = typeof res === "string" ? res : JSON.stringify(res);
+      return { status: "success", output: out };
+    } catch (err: any) {
+      log.warn("MCP tool execution failed", { toolId, error: String(err?.message || err) });
+      return { status: "error", error: String(err?.message || err) };
+    }
+  }
+
+  private async runWithTimeout<T>(p: Promise<T>): Promise<T> {
+    if (!this.timeoutMs) return p;
+    return await Promise.race([
+      p,
+      new Promise<T>((_, reject) => setTimeout(() => reject(new Error("tool execution timeout")), this.timeoutMs)),
+    ]);
+  }
+}

package/src/tools/executors/sdk.ts

@@ -0,0 +1,39 @@
+import type { IToolExecutor, ExecutionResult } from "../core/types.js";
+import { createLogger } from "../../utils/logger.js";
+
+const log = createLogger("tools:executor:sdk");
+
+export class SdkExecutor implements IToolExecutor {
+  private toolIds = new Set<string>();
+
+  constructor(private client: any, private timeoutMs: number) {}
+
+  setToolIds(ids: Iterable<string>): void {
+    this.toolIds = new Set(ids);
+  }
+
+  canExecute(toolId: string): boolean {
+    return this.toolIds.has(toolId) && Boolean(this.client?.tool?.invoke);
+  }
+
+  async execute(toolId: string, args: Record<string, unknown>): Promise<ExecutionResult> {
+    if (!this.canExecute(toolId)) return { status: "error", error: "SDK invoke unavailable" };
+    try {
+      const p = this.client.tool.invoke(toolId, args);
+      const res = await this.runWithTimeout(p);
+      const out = typeof res === "string" ? res : JSON.stringify(res);
+      return { status: "success", output: out };
+    } catch (err: any) {
+      log.warn("SDK tool execution failed", { toolId, error: String(err?.message || err) });
+      return { status: "error", error: String(err?.message || err) };
+    }
+  }
+
+  private async runWithTimeout<T>(p: Promise<T>): Promise<T> {
+    if (!this.timeoutMs) return p;
+    return await Promise.race([
+      p,
+      new Promise<T>((_, reject) => setTimeout(() => reject(new Error("tool execution timeout")), this.timeoutMs)),
+    ]);
+  }
+}

package/src/tools/index.ts

@@ -0,0 +1,8 @@
+export { ToolRegistry } from "./core/registry.js";
+export { executeWithChain } from "./core/executor.js";
+export { registerDefaultTools, getDefaultToolNames } from "./defaults.js";
+export { LocalExecutor } from "./executors/local.js";
+export { SdkExecutor } from "./executors/sdk.js";
+export { McpExecutor } from "./executors/mcp.js";
+export type { ToolDefinition, ToolCall, ToolResult, ToolHandler } from "./types.js";
+export type { ExecutionResult, IToolExecutor, Skill, Tool } from "./core/types.js";

package/src/tools/registry.ts

@@ -0,0 +1,34 @@
+import type { ToolDefinition, ToolExecutor } from "./types.js";
+
+interface RegisteredTool {
+  definition: ToolDefinition;
+  executor: ToolExecutor;
+}
+
+export class ToolRegistry {
+  private tools: Map<string, RegisteredTool> = new Map();
+
+  register(name: string, definition: ToolDefinition, executor: ToolExecutor): void {
+    this.tools.set(name, { definition, executor });
+  }
+
+  get(name: string): RegisteredTool | undefined {
+    return this.tools.get(name);
+  }
+
+  getAllDefinitions(): ToolDefinition[] {
+    return Array.from(this.tools.values()).map(t => t.definition);
+  }
+
+  getExecutor(name: string): ToolExecutor | undefined {
+    return this.tools.get(name)?.executor;
+  }
+
+  has(name: string): boolean {
+    return this.tools.has(name);
+  }
+
+  getAllToolNames(): string[] {
+    return Array.from(this.tools.keys());
+  }
+}

package/src/tools/router.ts

@@ -0,0 +1,123 @@
+import { createLogger } from "../utils/logger";
+import type { OpenCodeTool } from "./discovery";
+import type { ExecutionResult } from "./core/types.js";
+
+const log = createLogger("tools:router");
+
+export interface ToolCallEvent {
+  type: "tool_call";
+  call_id?: string;
+  tool_call_id?: string;
+  tool_call?: Record<string, { args?: any }>;
+  name?: string;
+}
+
+export interface ToolResultChunk {
+  id: string;
+  object: "chat.completion.chunk";
+  created: number;
+  model: string;
+  choices: Array<{ index: number; delta: any; finish_reason: string | null }>;
+}
+
+export interface RouterContext {
+  execute: (toolId: string, args: Record<string, unknown>) => Promise<ExecutionResult>;
+  toolsByName: Map<string, OpenCodeTool>;
+  resolveName?: (name: string) => string | undefined;
+}
+
+export class ToolRouter {
+  private ctx: RouterContext;
+
+  constructor(ctx: RouterContext) {
+    this.ctx = ctx;
+  }
+
+  isOpenCodeTool(name: string | undefined): boolean {
+    return !!name && name.startsWith("oc_");
+  }
+
+  async handleToolCall(event: ToolCallEvent, meta: { id: string; created: number; model: string }): Promise<ToolResultChunk | null> {
+    const callId = event.call_id || event.tool_call_id || "unknown";
+    let name = event.name || this.inferName(event);
+    if (!this.isOpenCodeTool(name)) return null;
+
+    // Resolve aliases via SkillResolver if configured
+    if (this.ctx.resolveName) {
+      const resolved = this.ctx.resolveName(name);
+      if (resolved) {
+        name = resolved;
+      }
+    }
+
+    const tool = this.ctx.toolsByName.get(name);
+    if (!tool) {
+      log.warn("Unknown tool call", { name });
+      return this.buildResult(meta, callId, name, { status: "error", error: `Unknown tool ${name}` });
+    }
+
+    const args = this.extractArgs(event);
+    log.debug("Executing tool", { name, toolId: tool.id });
+    const t0 = Date.now();
+    const result = await this.ctx.execute(tool.id, args);
+    const elapsed = Date.now() - t0;
+    if (result.status === "error") {
+      log.warn("Tool execution returned error", { name, error: result.error, elapsed });
+    } else {
+      log.debug("Tool execution completed", { name, toolId: tool.id, elapsed });
+    }
+    return this.buildResult(meta, callId, name, result);
+  }
+
+  private extractArgs(event: ToolCallEvent): any {
+    if (event.tool_call) {
+      const [key] = Object.keys(event.tool_call);
+      return event.tool_call[key]?.args || {};
+    }
+    // Some agents send args at top-level
+    return (event as any).arguments || {};
+  }
+
+  private inferName(event: ToolCallEvent): string | undefined {
+    if (event.tool_call) {
+      const [key] = Object.keys(event.tool_call);
+      return key;
+    }
+    return undefined;
+  }
+
+  private buildResult(meta: { id: string; created: number; model: string }, callId: string, name: string, result: { status: string; output?: string; error?: string }): ToolResultChunk {
+    const delta: any = {
+      role: "assistant",
+      tool_calls: [
+        {
+          id: callId,
+          type: "function",
+          function: {
+            name,
+            arguments: "{}",
+          },
+        },
+      ],
+    };
+
+    // OpenAI tool result convention: include output in a message? We'll place in a synthetic "content" string.
+    const content = result.status === "success" ? result.output ?? "" : (result.error || "unknown error");
+
+    delta.tool_calls[0].function.arguments = JSON.stringify({ result: content }).slice(0, 8000); // guard size
+
+    return {
+      id: meta.id,
+      object: "chat.completion.chunk",
+      created: meta.created,
+      model: meta.model,
+      choices: [
+        {
+          index: 0,
+          delta,
+          finish_reason: null,
+        },
+      ],
+    };
+  }
+}

package/src/tools/schema.ts

@@ -0,0 +1,58 @@
+import { createLogger } from "../utils/logger";
+
+const log = createLogger("tools:schema");
+
+// Convert JSON Schema from OpenCode to OpenAI function parameters shape
+export function toOpenAiParameters(schema: any): any {
+  if (!schema || typeof schema !== "object") {
+    return { type: "object", properties: {} };
+  }
+
+  const clone = (obj: any): any => {
+    if (Array.isArray(obj)) return obj.map(clone);
+    if (obj && typeof obj === "object") {
+      const out: any = {};
+      for (const k of Object.keys(obj)) {
+        out[k] = clone(obj[k]);
+      }
+      return out;
+    }
+    return obj;
+  };
+
+  const cleaned = clone(schema);
+
+  // Strip unsupported keywords that can confuse OpenAI tools
+  const stripKeys = ["additionalProperties", "$schema", "$id", "unevaluatedProperties", "definitions", "$defs"];
+  const walk = (node: any) => {
+    if (!node || typeof node !== "object") return;
+    for (const key of stripKeys) {
+      if (key in node) delete node[key];
+    }
+    if (node.properties) {
+      for (const k of Object.keys(node.properties)) {
+        walk(node.properties[k]);
+      }
+    }
+    if (node.items) walk(node.items);
+    if (Array.isArray(node.anyOf)) node.anyOf.forEach(walk);
+    if (Array.isArray(node.oneOf)) node.oneOf.forEach(walk);
+    if (Array.isArray(node.allOf)) node.allOf.forEach(walk);
+  };
+  walk(cleaned);
+
+  // Ensure top-level object
+  if (cleaned.type !== "object") {
+    cleaned.type = "object";
+    if (!cleaned.properties) cleaned.properties = {};
+  }
+  if (!Array.isArray(cleaned.required)) cleaned.required = [];
+
+  return cleaned;
+}
+
+export function describeTool(t: { id: string; description?: string }): string {
+  const base = t.description || "OpenCode tool";
+  // Keep concise
+  return base.length > 400 ? base.slice(0, 400) : base;
+}

package/src/tools/skills/loader.ts

@@ -0,0 +1,61 @@
+import type { OpenCodeTool } from "../discovery.js";
+import type { Skill } from "../core/types.js";
+
+function deriveCategory(name: string): string | undefined {
+  if (!name) return undefined;
+  const segments = name.split(/[\/:]/).filter(Boolean);
+  if (segments.length === 0) return undefined;
+  // Prefer last segment as the skill topic (e.g., superpowers/brainstorming -> brainstorming)
+  return segments[segments.length - 1].toLowerCase();
+}
+
+function deriveTriggers(name: string, description?: string): string[] {
+  const words = new Set<string>();
+  const addWord = (w: string) => {
+    const word = w.toLowerCase().replace(/[^a-z0-9_-]/g, "");
+    if (word.length >= 4) words.add(word);
+  };
+
+  name.split(/[\s\/:_-]+/).forEach(addWord);
+  (description || "")
+    .split(/[\s,.;:()]+/)
+    .filter((w) => w.length >= 4)
+    .slice(0, 12)
+    .forEach(addWord);
+
+  return Array.from(words).slice(0, 6);
+}
+
+export class SkillLoader {
+  load(tools: OpenCodeTool[]): Skill[] {
+    return tools.map((t) => {
+      const baseId = t.id.replace(/[^a-zA-Z0-9_\-]/g, "_");
+      const aliases = [
+        t.name,
+        baseId,
+        `oc_${baseId}`,
+        `oc_skill_${baseId}`,
+        `oc_superskill_${baseId}`,
+        `oc_superpowers_${baseId}`,
+      ];
+      if (t.name === "todowrite") {
+        aliases.push("updateTodos", "updateTodosToolCall", "todoWrite", "todoWriteToolCall");
+      }
+      if (t.name === "todoread") {
+        aliases.push("readTodos", "readTodosToolCall", "todoRead", "todoReadToolCall");
+      }
+      const category = deriveCategory(t.name);
+      const triggers = deriveTriggers(t.name, t.description);
+      return {
+        id: t.id,
+        name: t.name,
+        description: t.description,
+        parameters: t.parameters,
+        source: t.source,
+        aliases,
+        category,
+        triggers,
+      };
+    });
+  }
+}

package/src/tools/skills/resolver.ts

@@ -0,0 +1,21 @@
+import type { Skill } from "../core/types.js";
+
+export class SkillResolver {
+  private aliasToName = new Map<string, string>();
+
+  constructor(skills: Skill[]) {
+    for (const s of skills) {
+      const aliases = new Set<string>([(s.name || "").toLowerCase(), (s.id || "").toLowerCase()]);
+      (s.aliases || []).forEach((a) => aliases.add(a.toLowerCase()));
+      (s.triggers || []).forEach((t) => aliases.add(t.toLowerCase()));
+      for (const a of aliases) {
+        this.aliasToName.set(a, s.name);
+      }
+    }
+  }
+
+  resolve(name?: string): string | undefined {
+    if (!name) return undefined;
+    return this.aliasToName.get(name.toLowerCase());
+  }
+}

package/src/tools/types.ts

@@ -0,0 +1,29 @@
+export interface ToolDefinition {
+  type: "function";
+  function: {
+    name: string;
+    description: string;
+    parameters: {
+      type: "object";
+      properties: Record<string, any>;
+      required?: string[];
+    };
+  };
+}
+
+export interface ToolCall {
+  id: string;
+  type: "function";
+  function: {
+    name: string;
+    arguments: string;
+  };
+}
+
+export interface ToolResult {
+  tool_call_id: string;
+  role: "tool";
+  content: string;
+}
+
+export type ToolHandler = (args: any) => Promise<string>;

package/src/types.ts

@@ -0,0 +1,8 @@
+export interface PluginConfig {
+  maxRetries?: number;
+  backoffBaseMs?: number;
+  backoffMaxMs?: number;
+  timeoutMs?: number;
+  persistSessions?: boolean;
+  sessionRetentionDays?: number;
+}