@neta-art/cohub-cli 10.6.0 → 10.8.0

package/dist/runtime/harnesses/cursor-transcript.js

@@ -0,0 +1,183 @@
+import { createHash } from "node:crypto";
+import { readdirSync } from "node:fs";
+import { readdir, readFile, stat } from "node:fs/promises";
+import { homedir } from "node:os";
+import { basename, dirname, join, posix, relative, resolve, sep, win32 } from "node:path";
+import { record } from "../json-rpc.js";
+import { extendTurn, readChainedLines } from "./chained-transcript.js";
+import { array, missing, text } from "./process.js";
+const TRANSCRIPTS = "agent-transcripts";
+const USER_QUERY = /<user_query>\s*([\s\S]*?)\s*<\/user_query>/;
+const TIMESTAMP = /<timestamp>([^<]*)<\/timestamp>/;
+const MONTHS = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
+/** Chats (`store.db` and `meta.json`) live under the config directory, transcripts under the data directory. */
+export const cursorConfigDirectory = () => process.env.CURSOR_CONFIG_DIR?.trim()
+    || (process.env.XDG_CONFIG_HOME?.trim() ? join(process.env.XDG_CONFIG_HOME.trim(), "cursor") : join(homedir(), ".cursor"));
+const dataDirectory = () => process.env.CURSOR_DATA_DIR?.trim() || join(homedir(), ".cursor");
+export const cursorProjectsRoot = () => join(dataDirectory(), "projects");
+export const cursorChatsRoot = () => join(cursorConfigDirectory(), "chats");
+/** Cursor's project name for a workspace path. */
+export const cursorProjectName = (cwd) => cwd.replace(/[^a-zA-Z0-9]/g, "-").replace(/-+/g, "-").replace(/^-+|-+$/g, "");
+/** Windows reuses a project folder whose name differs only in case, and file events name that folder. */
+function projectFolder(cwd) {
+    const name = cursorProjectName(cwd);
+    if (process.platform !== "win32")
+        return name;
+    try {
+        return readdirSync(cursorProjectsRoot()).find((entry) => entry.toLowerCase() === name.toLowerCase()) ?? name;
+    }
+    catch {
+        return name;
+    }
+}
+export const cursorTranscriptPath = (nativeSessionId, cwd) => join(cursorProjectsRoot(), projectFolder(cwd), TRANSCRIPTS, nativeSessionId, `${nativeSessionId}.jsonl`);
+/** A chat's store directory is keyed by the MD5 of the directory the CLI ran in. */
+export const cursorChatDirectory = (nativeSessionId, cwd) => join(cursorChatsRoot(), createHash("md5").update(resolve(cwd)).digest("hex"), nativeSessionId);
+/** A chat's project never changes, so its header is read once. */
+const headers = new Map();
+/** `<project>/agent-transcripts/<id>/<id>.jsonl`; a subdirectory's project name extends its parent's. Sub-agent files are skipped. */
+function transcriptParts(path, root) {
+    const parts = relative(root, path).split(sep);
+    return parts.length && !parts[0]?.startsWith("..") ? parts : null;
+}
+/** Windows paths ignore case, so a terminal opened as `c:\\users` names the same project as `C:\\Users`. */
+const fold = (value, platform) => platform === "win32" ? value.toLowerCase() : value;
+const ownsProject = (name, cwd, platform = process.platform) => {
+    const project = fold(cursorProjectName(cwd), platform), own = fold(name ?? "", platform);
+    return own === project || own.startsWith(`${project}-`);
+};
+export function acceptsCursorDirectory(path, root, cwd) {
+    const parts = transcriptParts(path, root);
+    if (!parts || parts.length > 3 || !ownsProject(parts[0], cwd))
+        return false;
+    return parts.length === 1 || parts[1] === TRANSCRIPTS;
+}
+export function acceptsCursorTranscript(path, cwd) {
+    const parts = transcriptParts(path, cursorProjectsRoot());
+    return parts?.length === 4 && ownsProject(parts[0], cwd) && parts[1] === TRANSCRIPTS && parts[3] === `${parts[2]}.jsonl`;
+}
+export async function projectDirectory(name, platform = process.platform, list = (directory) => readdir(directory, { withFileTypes: true })) {
+    const paths = platform === "win32" ? win32 : posix;
+    const drive = platform === "win32" ? /^([A-Za-z])(?:-(.*))?$/.exec(name) : null;
+    if (platform === "win32" && !drive)
+        return null;
+    const found = [];
+    const walk = async (directory, rest) => {
+        if (found.length > 1)
+            return;
+        if (!rest) {
+            found.push(directory);
+            return;
+        }
+        const entries = await list(directory).catch(() => []);
+        for (const entry of entries) {
+            if (!entry.isDirectory() && !entry.isSymbolicLink())
+                continue;
+            const part = fold(cursorProjectName(entry.name), platform);
+            if (part && (fold(rest, platform) === part || fold(rest, platform).startsWith(`${part}-`)))
+                await walk(paths.join(directory, entry.name), rest.slice(part.length + 1));
+        }
+    };
+    await (drive ? walk(`${drive[1]?.toUpperCase()}:\\`, drive[2] ?? "") : walk("/", name));
+    return found.length === 1 ? found[0] ?? null : null;
+}
+/**
+ * The transcript does not name its project. A CLI chat's `meta.json` does; the IDE writes the same
+ * transcripts without one, so its project name is resolved to the directory it stands for.
+ */
+export async function cursorSessionHeader(path) {
+    const nativeSessionId = basename(path, ".jsonl");
+    if (basename(dirname(path)) !== nativeSessionId)
+        return null;
+    const known = headers.get(nativeSessionId);
+    if (known)
+        return known;
+    let header = null;
+    const hashes = await readdir(cursorChatsRoot()).catch((error) => { if (missing(error))
+        return []; throw error; });
+    for (const hash of hashes) {
+        const meta = await readFile(join(cursorChatsRoot(), hash, nativeSessionId, "meta.json"), "utf8").then((raw) => record(JSON.parse(raw)), () => null);
+        if (!meta || !text(meta.cwd))
+            continue;
+        header = { harness: "cursor", nativeSessionId, cwd: text(meta.cwd), thread: meta.isSubagent === true ? "spawned" : "user" };
+        break;
+    }
+    const project = basename(dirname(dirname(dirname(path))));
+    const cwd = header ? null : await projectDirectory(project);
+    header ??= cwd ? { harness: "cursor", nativeSessionId, cwd, thread: "user" } : null;
+    if (header)
+        headers.set(nativeSessionId, header);
+    return header;
+}
+/** "Saturday, Aug 01, 2026, 9:30 AM (UTC+8)": minutes only, so Turn times are approximate. */
+function promptTime(value) {
+    const match = /^\w+, (\w{3}) (\d{1,2}), (\d{4}), (\d{1,2}):(\d{2}) (AM|PM) \(UTC(?:([+-])(\d{1,2})(?::(\d{2}))?)?\)$/.exec(value.trim());
+    const month = MONTHS.indexOf(match?.[1] ?? "");
+    if (!match || month < 0)
+        return null;
+    const hour = Number(match[4]) % 12 + (match[6] === "PM" ? 12 : 0);
+    const offset = (match[7] === "-" ? -1 : 1) * (Number(match[8] ?? 0) * 60 + Number(match[9] ?? 0));
+    const time = Date.UTC(Number(match[3]), month, Number(match[2]), hour, Number(match[5])) - offset * 60_000;
+    return Number.isFinite(time) ? new Date(time).toISOString() : null;
+}
+const blocks = (value) => array(record(record(value).message).content).map(record);
+/**
+ * Cursor writes the model's messages without ids or times: a prompt (`<user_query>`, or a bare text
+ * that no other user line follows), one line per reply step with its tool calls (results are not
+ * recorded), and `turn_ended` after every Turn. A user line followed by another is context. A Turn
+ * is keyed by the file's checksum through its prompt, so a rewritten history never reuses a key.
+ */
+export async function readCursorTranscript(path, nativeSessionId, signal) {
+    const read = await readChainedLines(path, signal);
+    const modified = (await stat(path)).mtime.toISOString();
+    const turns = [];
+    let current = null;
+    for (const [index, line] of read.lines.entries()) {
+        const value = line.value;
+        if (value.role === "user") {
+            const raw = blocks(value).map((block) => text(block.text)).join("\n");
+            // A bare text is a prompt only once a reply or end follows it; until then it may be context.
+            const next = read.lines[index + 1]?.value;
+            const query = USER_QUERY.exec(raw)?.[1] ?? (next && next.role !== "user" ? raw.replace(TIMESTAMP, "").trim() : null);
+            if (!query)
+                continue;
+            const startedAt = promptTime(TIMESTAMP.exec(raw)?.[1] ?? "") ?? current?.startedAt ?? modified;
+            current = {
+                key: line.sha256, parentKey: turns.at(-1)?.key ?? null, userContent: [{ type: "text", text: query }], messages: [], startedAt,
+                startBytes: line.startBytes, endBytes: line.endBytes, contentEndBytes: line.endBytes, boundaries: {}, sha256: line.sha256, result: null,
+            };
+            turns.push(current);
+            continue;
+        }
+        if (!current)
+            continue;
+        if (value.role === "assistant") {
+            const content = blocks(value).flatMap((block, position) => {
+                if (block.type === "text")
+                    return text(block.text) ? [{ type: "text", text: text(block.text) }] : [];
+                if (block.type !== "tool_use")
+                    return [];
+                return [{ type: "tool_use", id: `cursor_${line.sha256.slice(0, 24)}_${position}`, name: text(block.name) || "tool", input: record(block.input) }];
+            });
+            if (content.length)
+                current.messages.push({ content, provider: null, model: null, stopReason: content.some((block) => block.type === "tool_use") ? "tool_use" : "stop", errorMessage: null });
+            extendTurn(current, line, true);
+            continue;
+        }
+        if (value.type === "turn_ended" && !current.result) {
+            const status = text(value.status) || "success";
+            const last = current.messages.at(-1);
+            if (last && status === "error")
+                Object.assign(last, { stopReason: "error", errorMessage: text(value.error) || "Turn failed" });
+            if (last && status === "aborted")
+                last.stopReason = "aborted";
+            current.result = { messages: current.messages, completedAt: modified, status: status === "error" ? "failed" : status === "aborted" ? "interrupted" : "completed" };
+            current.ended = true;
+            extendTurn(current, line, false);
+        }
+    }
+    // A Turn ends no later than the next one starts.
+    turns.forEach((turn, index) => { if (turn.result)
+        turn.result.completedAt = turns[index + 1]?.startedAt ?? modified; });
+    return { nativeSessionId, cwd: (await cursorSessionHeader(path))?.cwd ?? "", turns, prefixes: read.prefixes };
+}

package/dist/runtime/harnesses/cursor.d.ts

@@ -0,0 +1,24 @@
+import type { RuntimeExecutionEvent, RuntimeMessage } from "@neta-art/cohub";
+import { type JsonRecord } from "../json-rpc.js";
+import type { HarnessModel, LocalHarnessAdapter } from "./types.js";
+/** The process a Cursor CLI invocation runs, and the variables its launcher would set. */
+export declare function cursorCommand(executable: string, args: string[], cwd: string): {
+    command: [string, string[]];
+    env: Record<string, string>;
+};
+/** `cursor-agent models`: `<id> - <name> (current, default)` per line. */
+export declare function cursorModels(output: string): HarnessModel[];
+/**
+ * Maps `--output-format stream-json --stream-partial-output` onto Cohub's streaming protocol. A reply
+ * step ends once its tool calls returned. Cursor repeats a step's streamed text as one line right
+ * before a tool call, question or retry (with a timestamp) and at the end (without one); such a line
+ * is held until the next event says whether it was a repeat.
+ */
+export declare function cursorTranslator(emit: (event: RuntimeExecutionEvent) => void, identity: {
+    model: string | null;
+}): {
+    result: () => RuntimeMessage | null;
+    last: () => RuntimeMessage;
+    push(event: JsonRecord): boolean;
+};
+export declare const cursorHarness: LocalHarnessAdapter;