@geteigen/cli 0.0.0-stage → 3.1.0

package/dist/shared/issueTranscript.js

@@ -0,0 +1,387 @@
+export function emptyIssueTranscript(partial) {
+    return {
+        cursorAgentId: null,
+        available: false,
+        live: false,
+        error: null,
+        runs: [],
+        items: [],
+        ...partial,
+    };
+}
+export function parseStoredTranscriptItems(raw) {
+    if (raw == null)
+        return [];
+    let parsed = raw;
+    if (typeof raw === "string") {
+        const trimmed = raw.trim();
+        if (!trimmed)
+            return [];
+        try {
+            parsed = JSON.parse(trimmed);
+        }
+        catch {
+            return [];
+        }
+    }
+    if (!Array.isArray(parsed))
+        return [];
+    const items = [];
+    for (const row of parsed) {
+        if (!isRecord(row))
+            continue;
+        const kind = asText(row.kind);
+        if (kind !== "user" &&
+            kind !== "assistant" &&
+            kind !== "thinking" &&
+            kind !== "tool" &&
+            kind !== "error") {
+            continue;
+        }
+        const text = asText(row.text);
+        const toolName = asText(row.toolName);
+        if (!text && kind !== "tool")
+            continue;
+        items.push({
+            id: asText(row.id) || `stored:${items.length + 1}`,
+            kind,
+            text: text || toolName || "tool",
+            toolName: toolName || undefined,
+            detail: asText(row.detail) || undefined,
+            path: asText(row.path) || undefined,
+            status: row.status === "running" || row.status === "done" || row.status === "error"
+                ? row.status
+                : undefined,
+            runId: asText(row.runId) || undefined,
+        });
+    }
+    return items;
+}
+export function applyIssueStreamEvent(items, event) {
+    const next = items.slice();
+    if (event.kind === "user") {
+        const text = event.text.trim();
+        if (!text)
+            return next;
+        next.push({
+            id: `${event.runId || "run"}:user:${next.length}`,
+            kind: "user",
+            text,
+            runId: event.runId,
+        });
+        return next;
+    }
+    if (event.kind === "assistant") {
+        const text = event.text.trim();
+        if (!text)
+            return next;
+        for (let i = next.length - 1; i >= 0; i--) {
+            const item = next[i];
+            if (item.kind === "assistant" && (!event.runId || item.runId === event.runId)) {
+                next[i] = { ...item, text };
+                return next;
+            }
+            if (item.kind === "user")
+                break;
+        }
+        next.push({
+            id: `${event.runId || "run"}:assistant:${next.length}`,
+            kind: "assistant",
+            text,
+            runId: event.runId,
+        });
+        return next;
+    }
+    if (event.kind === "thinking") {
+        const text = event.text.trim();
+        if (!text)
+            return next;
+        for (let i = next.length - 1; i >= 0; i--) {
+            const item = next[i];
+            if (item.kind === "thinking" && (!event.runId || item.runId === event.runId)) {
+                next[i] = { ...item, text };
+                return next;
+            }
+            if (item.kind === "user" || item.kind === "assistant" || item.kind === "tool")
+                break;
+        }
+        next.push({
+            id: `${event.runId || "run"}:thinking:${next.length}`,
+            kind: "thinking",
+            text,
+            runId: event.runId,
+        });
+        return next;
+    }
+    if (event.kind === "error") {
+        const text = event.text.trim();
+        if (!text)
+            return next;
+        next.push({
+            id: `${event.runId || "run"}:error:${next.length}`,
+            kind: "error",
+            text,
+            runId: event.runId,
+        });
+        return next;
+    }
+    const id = `${event.runId || "run"}:tool:${event.callId}`;
+    const idx = next.findIndex((item) => item.id === id);
+    const row = {
+        id,
+        kind: "tool",
+        text: event.detail || event.path || event.name,
+        toolName: event.name,
+        detail: event.detail,
+        path: event.path,
+        status: event.kind === "tool_start" ? "running" : "done",
+        runId: event.runId,
+    };
+    if (idx >= 0)
+        next[idx] = row;
+    else
+        next.push(row);
+    return next;
+}
+/**
+ * Build a chat timeline from listed/hydrated Cursor run metadata.
+ * `run.conversation()` is avoided here — on cloud that replays SSE.
+ */
+export function transcriptItemsFromListedRuns(runs) {
+    const items = [];
+    for (const run of runs) {
+        const result = run.result?.trim();
+        if (result) {
+            items.push({
+                id: `${run.id}:result`,
+                kind: "assistant",
+                text: result,
+                runId: run.id,
+            });
+        }
+        const error = run.error?.trim();
+        if (run.status === "error" && error) {
+            items.push({
+                id: `${run.id}:error`,
+                kind: "error",
+                text: error,
+                runId: run.id,
+            });
+        }
+        if (run.status === "running" && !result) {
+            items.push({
+                id: `${run.id}:running`,
+                kind: "tool",
+                text: "Run in progress",
+                toolName: "run",
+                status: "running",
+                runId: run.id,
+            });
+        }
+    }
+    return items;
+}
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function asText(value) {
+    return typeof value === "string" ? value : "";
+}
+function toolPath(args, result) {
+    const fromArgs = pathFromRecord(args);
+    if (fromArgs)
+        return fromArgs;
+    if (!isRecord(result))
+        return undefined;
+    if (isRecord(result.value))
+        return pathFromRecord(result.value);
+    return pathFromRecord(result);
+}
+function pathFromRecord(value) {
+    if (!isRecord(value))
+        return undefined;
+    for (const key of [
+        "path",
+        "filePath",
+        "file_path",
+        "target_file",
+        "targetFile",
+    ]) {
+        const raw = value[key];
+        if (typeof raw === "string" && raw.trim())
+            return raw.trim();
+    }
+    return undefined;
+}
+function toolDetail(name, args) {
+    if (!isRecord(args))
+        return "";
+    const command = asText(args.command).trim();
+    if (command)
+        return command.slice(0, 200);
+    const query = asText(args.pattern ??
+        args.globPattern ??
+        args.glob_pattern ??
+        args.query ??
+        args.targetDirectory).trim();
+    if (query)
+        return query.slice(0, 200);
+    const path = pathFromRecord(args);
+    if (path)
+        return path;
+    if (name === "updateTodos" || name === "todo") {
+        const todos = Array.isArray(args.todos) ? args.todos : [];
+        return todos.length
+            ? `${todos.length} todo${todos.length === 1 ? "" : "s"}`
+            : "Updating todos";
+    }
+    return "";
+}
+function toolStatus(result) {
+    if (!isRecord(result))
+        return "running";
+    if (result.status === "error" || result.status === "failure")
+        return "error";
+    if (result.status === "success" || result.value !== undefined)
+        return "done";
+    return "done";
+}
+function toolResultDetail(result, fallback) {
+    if (!isRecord(result))
+        return fallback;
+    if (result.status === "error") {
+        const err = result.error;
+        if (typeof err === "string" && err.trim())
+            return err.trim().slice(0, 240);
+        if (isRecord(err) && typeof err.message === "string") {
+            return err.message.trim().slice(0, 240);
+        }
+        return fallback || "error";
+    }
+    const value = isRecord(result.value) ? result.value : result;
+    const stdout = asText(value.stdout).trim();
+    if (stdout)
+        return stdout.split("\n")[0].slice(0, 200);
+    const path = pathFromRecord(value);
+    if (path)
+        return path;
+    if (typeof value.linesCreated === "number") {
+        return `${value.linesCreated} lines`;
+    }
+    if (typeof value.exitCode === "number")
+        return `exit ${value.exitCode}`;
+    return fallback;
+}
+function nextId(runId, seq) {
+    seq.n += 1;
+    return `${runId}:${seq.n}`;
+}
+function pushUser(items, runId, seq, text) {
+    const trimmed = text.trim();
+    if (!trimmed)
+        return;
+    items.push({
+        id: nextId(runId, seq),
+        kind: "user",
+        text: trimmed,
+        runId,
+    });
+}
+function convertAgentSteps(items, runId, seq, steps) {
+    if (!Array.isArray(steps))
+        return;
+    for (const step of steps) {
+        if (!isRecord(step))
+            continue;
+        const type = asText(step.type);
+        const message = isRecord(step.message) ? step.message : {};
+        if (type === "assistantMessage") {
+            const text = asText(message.text).trim();
+            if (!text)
+                continue;
+            items.push({
+                id: nextId(runId, seq),
+                kind: "assistant",
+                text,
+                runId,
+            });
+            continue;
+        }
+        if (type === "thinkingMessage") {
+            const text = asText(message.text).trim();
+            if (!text)
+                continue;
+            items.push({
+                id: nextId(runId, seq),
+                kind: "thinking",
+                text,
+                runId,
+            });
+            continue;
+        }
+        if (type !== "toolCall")
+            continue;
+        const toolName = asText(message.type) || "tool";
+        const args = message.args;
+        const result = message.result;
+        const startDetail = toolDetail(toolName, args);
+        const path = toolPath(args, result);
+        const status = toolStatus(result);
+        items.push({
+            id: nextId(runId, seq),
+            kind: "tool",
+            text: startDetail || path || toolName,
+            toolName,
+            detail: toolResultDetail(result, startDetail || path || ""),
+            path,
+            status,
+            runId,
+        });
+    }
+}
+function convertOneTurn(items, runId, seq, raw) {
+    if (!isRecord(raw))
+        return;
+    const type = asText(raw.type);
+    const turn = isRecord(raw.turn) ? raw.turn : raw;
+    if (type === "shellConversationTurn" || ("shellCommand" in turn && !("steps" in turn))) {
+        const command = isRecord(turn.shellCommand)
+            ? asText(turn.shellCommand.command).trim()
+            : "";
+        const output = isRecord(turn.shellOutput) ? turn.shellOutput : null;
+        const stdout = output ? asText(output.stdout).trim() : "";
+        const exitCode = output && typeof output.exitCode === "number" ? output.exitCode : undefined;
+        items.push({
+            id: nextId(runId, seq),
+            kind: "tool",
+            text: command || "shell",
+            toolName: "shell",
+            detail: stdout.split("\n")[0]?.slice(0, 200) ||
+                (exitCode !== undefined ? `exit ${exitCode}` : command),
+            status: output ? (exitCode === 0 || exitCode === undefined ? "done" : "error") : "running",
+            runId,
+        });
+        return;
+    }
+    if (isRecord(turn.userMessage)) {
+        pushUser(items, runId, seq, asText(turn.userMessage.text));
+    }
+    else if (typeof turn.text === "string" && type === "user") {
+        pushUser(items, runId, seq, turn.text);
+    }
+    convertAgentSteps(items, runId, seq, turn.steps);
+}
+/**
+ * Flatten Cursor `run.conversation()` turns into a read-only chat timeline.
+ * Pure: does not call Cursor.
+ */
+export function conversationTurnsToItems(runId, turns) {
+    if (!Array.isArray(turns))
+        return [];
+    const items = [];
+    const seq = { n: 0 };
+    for (const turn of turns) {
+        convertOneTurn(items, runId, seq, turn);
+    }
+    return items;
+}

package/dist/shared/issues.d.ts

@@ -0,0 +1,139 @@
+import type { AgentBackendKind } from "./backends/types.js";
+export declare const ISSUE_STATUSES: readonly ["draft", "queued", "running", "needs_input", "in_review", "done", "failed", "cancelled"];
+export type IssueStatus = (typeof ISSUE_STATUSES)[number];
+export declare const ISSUE_PRIORITIES: readonly ["low", "medium", "high", "urgent"];
+export type IssuePriority = (typeof ISSUE_PRIORITIES)[number];
+export declare const DEFAULT_PICKUP_DELAY_MS: number;
+export declare const MIN_PICKUP_DELAY_MS = 0;
+export declare const MAX_PICKUP_DELAY_MS: number;
+export declare const DEFAULT_MAX_CONCURRENT_ISSUES = 2;
+export declare const MAX_CONCURRENT_ISSUES_CAP = 8;
+export declare const LINEAR_PROVIDER = "linear";
+export declare const DEFAULT_ALLOW_AGENT_SPAWN = false;
+export declare const DEFAULT_MAX_SPAWN_PER_BATCH = 10;
+export declare const MAX_SPAWN_PER_BATCH_CAP = 20;
+export declare const MAX_LINEAR_IMPORT_ISSUES = 20;
+export declare const ISSUE_LEASE_MS: number;
+export declare const ISSUE_POLL_MS = 15000;
+export declare const ISSUE_HEARTBEAT_MS = 30000;
+export declare const MAX_ISSUE_TITLE = 200;
+export declare const MAX_ISSUE_DESCRIPTION = 20000;
+export declare const MAX_WRITEUP_CHARS = 80000;
+export declare const MAX_ISSUE_ATTACHMENTS = 8;
+export declare const MAX_ISSUE_ATTACHMENT_BYTES: number;
+export declare const MAX_ISSUE_ATTEMPTS = 3;
+export interface IssueAttachmentInfo {
+    id: string;
+    issueId: string;
+    name: string;
+    mime: string;
+    size: number;
+    url: string;
+    createdAt: number;
+}
+export interface IssueEventInfo {
+    id: string;
+    issueId: string;
+    kind: string;
+    message: string;
+    createdAt: number;
+}
+export interface IssueInfo {
+    id: string;
+    orgId?: string | null;
+    creatorId: string;
+    creatorName?: string | null;
+    title: string;
+    description: string;
+    repoUrl: string;
+    startingRef: string;
+    priority: IssuePriority;
+    status: IssueStatus;
+    pickupDelayMs: number;
+    runAfter: number;
+    startedAt?: number | null;
+    finishedAt?: number | null;
+    /** Which agent runs it. Older issues are Cursor. */
+    backend: AgentBackendKind;
+    /** Run on this Machine instead of the cloud (null = cloud). */
+    machineId?: string | null;
+    machineName?: string | null;
+    modelId: string;
+    cursorAgentId?: string | null;
+    prUrl?: string | null;
+    branch?: string | null;
+    error?: string | null;
+    writeupMd?: string | null;
+    attempt: number;
+    createdAt: number;
+    updatedAt: number;
+    attachments: IssueAttachmentInfo[];
+    events?: IssueEventInfo[];
+    externalProvider?: string | null;
+    externalId?: string | null;
+    externalIdentifier?: string | null;
+    externalUrl?: string | null;
+}
+export interface IssueSettingsInfo {
+    scopeKey: string;
+    defaultPickupDelayMs: number;
+    autoStart: boolean;
+    /** Default agent for new issues in this workspace. */
+    backend: AgentBackendKind;
+    /** Default machine for new issues (null = cloud). */
+    machineId?: string | null;
+    modelId: string;
+    maxConcurrent: number;
+    allowAgentSpawn: boolean;
+    maxSpawnPerBatch: number;
+    updatedAt: number;
+}
+export declare function isIssueStatus(value: unknown): value is IssueStatus;
+export declare function isIssuePriority(value: unknown): value is IssuePriority;
+export declare function issueSettingsScopeKey(input: {
+    orgId?: string | null;
+    userId: string;
+}): string;
+export declare function clampPickupDelayMs(raw: unknown, fallback?: number): number;
+export declare function clampMaxConcurrent(raw: unknown, ceiling?: number): number;
+export declare function clampMaxSpawnPerBatch(raw: unknown): number;
+/** `PER-9` / Linear URL tail → uppercase identifier, or null. */
+export declare function parseLinearIdentifier(raw: unknown): string | null;
+export declare function mapLinearPriority(raw: unknown): IssuePriority;
+export declare function parseGithubHttpsRepo(raw: string): string | null;
+export declare function issueStatusLabel(status: IssueStatus): string;
+export declare function canEditIssue(issue: {
+    creatorId: string;
+    orgId?: string | null;
+}, actor: {
+    userId: string;
+    orgRole?: string | null;
+}): boolean;
+export declare function canQueueIssue(status: IssueStatus): boolean;
+export declare function canCancelIssue(status: IssueStatus): boolean;
+export declare function canRetryIssue(status: IssueStatus): boolean;
+/** True while the issue page should refresh itself (pickup / agent still moving). */
+export declare function issueStatusIsActive(status: IssueStatus): boolean;
+/** Unwrap a full-document markdown fence the model sometimes wraps around writeups. */
+export declare function sanitizeIssueWriteup(raw: string): string;
+export declare function looksLikeIssueWriteup(text: string): boolean;
+export declare function buildFallbackIssueWriteup(input: {
+    title: string;
+    description?: string;
+    prUrl?: string | null;
+}): string;
+export declare function buildIssueFixPrompt(input: {
+    issueId: string;
+    title: string;
+    description: string;
+    repoUrl: string;
+    startingRef: string;
+    attachmentNotes?: string;
+    /** Shown to CLI agents so they upload screenshots and recordings. */
+    artifactRules?: string;
+}): string;
+export declare function buildIssueWriteupPrompt(input: {
+    issueId: string;
+    title: string;
+    prUrl?: string | null;
+}): string;