@rama_nigg/open-cursor 2.2.0 → 2.3.0

package/src/streaming/line-buffer.ts

@@ -0,0 +1,44 @@
+export class LineBuffer {
+  private buffer = "";
+  private decoder = new TextDecoder();
+
+  push(chunk: string | Uint8Array): string[] {
+    const text = typeof chunk === "string" ? chunk : this.decoder.decode(chunk);
+    if (!text) {
+      return [];
+    }
+
+    this.buffer += text;
+    const lines = this.buffer.split("\n");
+    this.buffer = lines.pop() ?? "";
+
+    const completed: string[] = [];
+    for (const line of lines) {
+      const normalized = line.endsWith("\r") ? line.slice(0, -1) : line;
+      if (!normalized.trim()) {
+        continue;
+      }
+      completed.push(normalized);
+    }
+
+    return completed;
+  }
+
+  flush(): string[] {
+    if (!this.buffer.trim()) {
+      this.buffer = "";
+      return [];
+    }
+
+    const normalized = this.buffer.endsWith("\r")
+      ? this.buffer.slice(0, -1)
+      : this.buffer;
+    this.buffer = "";
+
+    if (!normalized.trim()) {
+      return [];
+    }
+
+    return [normalized];
+  }
+}

package/src/streaming/openai-sse.ts

@@ -0,0 +1,114 @@
+import {
+  extractText,
+  extractThinking,
+  inferToolName,
+  isAssistantText,
+  isThinking,
+  isToolCall,
+  type StreamJsonEvent,
+  type StreamJsonToolCallEvent,
+} from "./types.js";
+import { DeltaTracker } from "./delta-tracker.js";
+
+type OpenAiToolCall = {
+  index: number;
+  id: string;
+  type: "function";
+  function: {
+    name: string;
+    arguments: string;
+  };
+};
+
+type OpenAiDelta = {
+  content?: string;
+  reasoning_content?: string;
+  tool_calls?: OpenAiToolCall[];
+};
+
+type OpenAiChunk = {
+  id: string;
+  object: "chat.completion.chunk";
+  created: number;
+  model: string;
+  choices: Array<{
+    index: number;
+    delta: OpenAiDelta;
+    finish_reason: string | null;
+  }>;
+};
+
+const createChunk = (id: string, created: number, model: string, delta: OpenAiDelta): OpenAiChunk => ({
+  id,
+  object: "chat.completion.chunk",
+  created,
+  model,
+  choices: [
+    {
+      index: 0,
+      delta,
+      finish_reason: null,
+    },
+  ],
+});
+
+export const formatSseChunk = (payload: object) => `data: ${JSON.stringify(payload)}\n\n`;
+
+export const formatSseDone = () => "data: [DONE]\n\n";
+
+export class StreamToSseConverter {
+  private readonly id: string;
+  private readonly created: number;
+  private readonly model: string;
+  private readonly tracker = new DeltaTracker();
+
+  constructor(model: string, options?: { id?: string; created?: number }) {
+    this.model = model;
+    this.id = options?.id ?? `cursor-acp-${Date.now()}`;
+    this.created = options?.created ?? Math.floor(Date.now() / 1000);
+  }
+
+  handleEvent(event: StreamJsonEvent): string[] {
+    if (isAssistantText(event)) {
+      const delta = this.tracker.nextText(extractText(event));
+      return delta ? [this.chunkWith({ content: delta })] : [];
+    }
+
+    if (isThinking(event)) {
+      const delta = this.tracker.nextThinking(extractThinking(event));
+      return delta ? [this.chunkWith({ reasoning_content: delta })] : [];
+    }
+
+    if (isToolCall(event)) {
+      return [this.chunkWith(this.toolCallDelta(event))];
+    }
+
+    return [];
+  }
+
+  private chunkWith(delta: OpenAiDelta): string {
+    return formatSseChunk(createChunk(this.id, this.created, this.model, delta));
+  }
+
+  private toolCallDelta(event: StreamJsonToolCallEvent): OpenAiDelta {
+    const id = event.call_id ?? "unknown";
+    const toolName = inferToolName(event) || "tool";
+    const toolKey = Object.keys(event.tool_call ?? {})[0];
+    const args = toolKey ? event.tool_call[toolKey]?.args : undefined;
+    const argumentsText = args ? JSON.stringify(args) : "";
+
+    return {
+      tool_calls: [
+        {
+          index: 0,
+          id,
+          type: "function",
+          function: {
+            name: toolName,
+            arguments: argumentsText,
+          },
+        },
+      ],
+    };
+  }
+}

package/src/streaming/parser.ts

@@ -0,0 +1,22 @@
+import type { StreamJsonEvent } from "./types.js";
+import { createLogger } from "../utils/logger.js";
+
+const log = createLogger("streaming:parser");
+
+export const parseStreamJsonLine = (line: string): StreamJsonEvent | null => {
+  const trimmed = line.trim();
+  if (!trimmed) {
+    return null;
+  }
+
+  try {
+    const parsed = JSON.parse(trimmed) as unknown;
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+      return null;
+    }
+    return parsed as StreamJsonEvent;
+  } catch {
+    log.debug("Failed to parse NDJSON line", { line: trimmed.substring(0, 100) });
+    return null;
+  }
+};

package/src/streaming/types.ts

@@ -0,0 +1,152 @@
+export type StreamJsonTextContent = {
+  type: "text";
+  text: string;
+};
+
+export type StreamJsonThinkingContent = {
+  type: "thinking";
+  thinking: string;
+};
+
+export type StreamJsonContent = StreamJsonTextContent | StreamJsonThinkingContent;
+
+export type StreamJsonSystemEvent = {
+  type: "system";
+  subtype?: string;
+  timestamp?: number;
+  session_id?: string;
+  cwd?: string;
+  model?: string;
+  permissionMode?: string;
+  tools?: Array<{ name: string; description?: string }>;
+  message?: string;
+};
+
+export type StreamJsonUserEvent = {
+  type: "user";
+  timestamp?: number;
+  session_id?: string;
+  message: {
+    role: "user";
+    content: StreamJsonContent[];
+  };
+};
+
+export type StreamJsonAssistantEvent = {
+  type: "assistant";
+  timestamp?: number;
+  session_id?: string;
+  message: {
+    role: "assistant";
+    content: StreamJsonContent[];
+  };
+};
+
+/**
+ * Thinking event from cursor-agent stream-json output.
+ * Real format: {"type":"thinking","subtype":"delta","text":"...","session_id":"...","timestamp_ms":...}
+ * OR: {"type":"thinking","subtype":"completed","session_id":"...","timestamp_ms":...}
+ */
+export type StreamJsonThinkingEvent = {
+  type: "thinking";
+  subtype?: "delta" | "completed" | string;
+  text?: string;
+  timestamp?: number;
+  timestamp_ms?: number;
+  session_id?: string;
+};
+
+export type StreamJsonToolCallPayload = {
+  args?: Record<string, unknown>;
+  result?: Record<string, unknown>;
+};
+
+export type StreamJsonToolCallEvent = {
+  type: "tool_call";
+  subtype?: string;
+  timestamp?: number;
+  session_id?: string;
+  call_id?: string;
+  tool_call: Record<string, StreamJsonToolCallPayload>;
+};
+
+export type StreamJsonResultEvent = {
+  type: "result";
+  subtype?: "success" | "error" | string;
+  timestamp?: number;
+  session_id?: string;
+  is_error?: boolean;
+  error?: {
+    message?: string;
+    code?: number | string;
+    details?: string;
+  };
+};
+
+export type StreamJsonEvent =
+  | StreamJsonSystemEvent
+  | StreamJsonUserEvent
+  | StreamJsonAssistantEvent
+  | StreamJsonThinkingEvent
+  | StreamJsonToolCallEvent
+  | StreamJsonResultEvent;
+
+const hasTextContent = (event: StreamJsonAssistantEvent) =>
+  event.message.content.some((content) => content.type === "text");
+
+const hasThinkingContent = (event: StreamJsonAssistantEvent) =>
+  event.message.content.some((content) => content.type === "thinking");
+
+export const isAssistantText = (event: StreamJsonEvent): event is StreamJsonAssistantEvent =>
+  event.type === "assistant" && hasTextContent(event);
+
+export const isThinking = (
+  event: StreamJsonEvent,
+): event is StreamJsonAssistantEvent | StreamJsonThinkingEvent => {
+  if (event.type === "thinking") {
+    return true;
+  }
+
+  return event.type === "assistant" && hasThinkingContent(event);
+};
+
+export const isToolCall = (event: StreamJsonEvent): event is StreamJsonToolCallEvent =>
+  event.type === "tool_call";
+
+export const isResult = (event: StreamJsonEvent): event is StreamJsonResultEvent =>
+  event.type === "result";
+
+export const extractText = (event: StreamJsonAssistantEvent) =>
+  event.message.content
+    .filter((content): content is StreamJsonTextContent => content.type === "text")
+    .map((content) => content.text)
+    .join("");
+
+export const extractThinking = (
+  event: StreamJsonAssistantEvent | StreamJsonThinkingEvent,
+): string => {
+  if (event.type === "thinking") {
+    return event.text ?? "";
+  }
+
+  return event.message.content
+    .filter(
+      (content): content is StreamJsonThinkingContent => content.type === "thinking",
+    )
+    .map((content) => content.thinking)
+    .join("");
+};
+
+export const inferToolName = (event: StreamJsonToolCallEvent) => {
+  const [key] = Object.keys(event.tool_call ?? {});
+  if (!key) {
+    return "";
+  }
+
+  if (key.endsWith("ToolCall")) {
+    const base = key.slice(0, -"ToolCall".length);
+    return base.charAt(0).toLowerCase() + base.slice(1);
+  }
+
+  return key;
+};

package/src/tools/core/executor.ts

@@ -0,0 +1,25 @@
+import type { IToolExecutor, ExecutionResult } from "./types.js";
+import { createLogger } from "../../utils/logger.js";
+
+const log = createLogger("tools:executor:chain");
+
+/**
+ * Executes using the first executor that declares it can handle the toolId.
+ */
+export async function executeWithChain(
+  executors: IToolExecutor[],
+  toolId: string,
+  args: Record<string, unknown>
+): Promise<ExecutionResult> {
+  for (const ex of executors) {
+    if (ex.canExecute(toolId)) {
+      try {
+        return await ex.execute(toolId, args);
+      } catch (err: any) {
+        log.warn("Executor threw unexpected error", { toolId, error: String(err?.message || err) });
+        return { status: "error", error: String(err?.message || err) };
+      }
+    }
+  }
+  return { status: "error", error: `No executor available for ${toolId}` };
+}

package/src/tools/core/registry.ts

@@ -0,0 +1,27 @@
+import type { ToolHandler, Tool } from "./types.js";
+
+interface RegisteredTool {
+  tool: Tool;
+  handler: ToolHandler;
+}
+
+export class ToolRegistry {
+  private tools = new Map<string, RegisteredTool>();
+
+  register(tool: Tool, handler: ToolHandler): void {
+    this.tools.set(tool.name, { tool, handler });
+  }
+
+  getHandler(name: string): ToolHandler | undefined {
+    return this.tools.get(name)?.handler;
+  }
+
+  getTool(name: string): Tool | undefined {
+    return this.tools.get(name)?.tool;
+  }
+
+  list(): Tool[] {
+    return Array.from(this.tools.values()).map((t) => t.tool);
+  }
+}
+

package/src/tools/core/types.ts

@@ -0,0 +1,31 @@
+export interface ExecutionResult {
+  status: "success" | "error";
+  output?: string;
+  error?: string;
+  errorType?: "recoverable" | "fatal";
+}
+
+export interface IToolExecutor {
+  canExecute(toolId: string): boolean;
+  execute(toolId: string, args: Record<string, unknown>): Promise<ExecutionResult>;
+}
+
+export interface ToolHandler {
+  (args: Record<string, unknown>): Promise<string>;
+}
+
+export interface Tool {
+  id: string;
+  name: string;
+  description: string;
+  parameters: any;
+  source: "sdk" | "cli" | "local" | "mcp";
+}
+
+export interface Skill extends Tool {
+  aliases?: string[];
+  category?: string;
+  triggers?: string[];
+  prerequisites?: string[];
+}
+