patchrelay 0.1.0

package/dist/cli/data.js

@@ -0,0 +1,461 @@
+import pino from "pino";
+import { CodexAppServerClient } from "../codex-app-server.js";
+import { PatchRelayDatabase } from "../db.js";
+import { resolveWorkflowStage } from "../workflow-policy.js";
+function safeJsonParse(value) {
+    if (!value) {
+        return undefined;
+    }
+    try {
+        const parsed = JSON.parse(value);
+        return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function summarizeThread(thread, latestTimestampSeen) {
+    const latestTurn = thread.turns.at(-1);
+    const latestAssistantMessage = latestTurn?.items
+        .filter((item) => item.type === "agentMessage")
+        .at(-1)?.text;
+    return {
+        threadId: thread.id,
+        threadStatus: thread.status,
+        ...(latestTurn ? { latestTurnId: latestTurn.id, latestTurnStatus: latestTurn.status } : {}),
+        ...(latestAssistantMessage ? { latestAssistantMessage } : {}),
+        ...(latestTimestampSeen ? { latestTimestampSeen } : {}),
+    };
+}
+function latestEventTimestamp(db, stageRunId) {
+    const events = db.stageEvents.listThreadEvents(stageRunId);
+    return events.at(-1)?.createdAt;
+}
+function resolveStageFromState(config, projectId, stateName) {
+    const project = config.projects.find((entry) => entry.id === projectId);
+    if (!project) {
+        return undefined;
+    }
+    return resolveWorkflowStage(project, stateName);
+}
+export class CliDataAccess {
+    config;
+    db;
+    codex;
+    codexStarted = false;
+    constructor(config, options) {
+        this.config = config;
+        this.db = options?.db ?? new PatchRelayDatabase(config.database.path, config.database.wal);
+        this.codex = options?.codex;
+    }
+    close() {
+        if (!this.codexStarted) {
+            return;
+        }
+        void this.codex?.stop();
+        this.codexStarted = false;
+    }
+    async inspect(issueKey) {
+        const issue = this.db.issueWorkflows.getTrackedIssueByKey(issueKey);
+        if (!issue) {
+            return undefined;
+        }
+        const ledger = this.getLedgerIssueContext(issue.projectId, issue.linearIssueId);
+        const workspace = this.getWorkspaceForIssue(issue, ledger);
+        const activeStageRun = this.getActiveStageRunForIssue(issue, ledger);
+        const latestStageRun = this.db.issueWorkflows.getLatestStageRunForIssue(issue.projectId, issue.linearIssueId);
+        const latestReport = latestStageRun?.reportJson ? JSON.parse(latestStageRun.reportJson) : undefined;
+        const latestSummary = safeJsonParse(latestStageRun?.summaryJson);
+        const live = activeStageRun?.threadId &&
+            (await this.readLiveSummary(activeStageRun.threadId, latestEventTimestamp(this.db, activeStageRun.id)).catch(() => undefined));
+        const statusNote = (live && live.latestAssistantMessage) ??
+            latestReport?.assistantMessages.at(-1) ??
+            (typeof latestSummary?.latestAssistantMessage === "string" ? latestSummary.latestAssistantMessage : undefined) ??
+            (latestStageRun?.status === "failed" ? "Latest stage failed." : undefined) ??
+            (issue.desiredStage ? `Queued for ${issue.desiredStage}.` : undefined) ??
+            undefined;
+        return {
+            issue,
+            ...(workspace ? { workspace } : {}),
+            ...(activeStageRun ? { activeStageRun } : {}),
+            ...(latestStageRun ? { latestStageRun } : {}),
+            ...(latestReport ? { latestReport } : {}),
+            ...(latestSummary ? { latestSummary } : {}),
+            ...(live ? { live } : {}),
+            ...(statusNote ? { statusNote } : {}),
+        };
+    }
+    async live(issueKey) {
+        const issue = this.db.issueWorkflows.getTrackedIssueByKey(issueKey);
+        if (!issue) {
+            return undefined;
+        }
+        const stageRun = this.getActiveStageRunForIssue(issue);
+        if (!stageRun) {
+            return undefined;
+        }
+        const live = stageRun.threadId &&
+            (await this.readLiveSummary(stageRun.threadId, latestEventTimestamp(this.db, stageRun.id)).catch(() => undefined));
+        return {
+            issue,
+            stageRun,
+            ...(live ? { live } : {}),
+        };
+    }
+    report(issueKey, options) {
+        const issue = this.db.issueWorkflows.getTrackedIssueByKey(issueKey);
+        if (!issue) {
+            return undefined;
+        }
+        const stages = this.db
+            .issueWorkflows.listStageRunsForIssue(issue.projectId, issue.linearIssueId)
+            .filter((stageRun) => {
+            if (options?.stageRunId !== undefined && stageRun.id !== options.stageRunId) {
+                return false;
+            }
+            if (options?.stage !== undefined && stageRun.stage !== options.stage) {
+                return false;
+            }
+            return true;
+        })
+            .reverse()
+            .map((stageRun) => ({
+            stageRun,
+            ...(stageRun.reportJson ? { report: JSON.parse(stageRun.reportJson) } : {}),
+            ...(safeJsonParse(stageRun.summaryJson) ? { summary: safeJsonParse(stageRun.summaryJson) } : {}),
+        }));
+        return { issue, stages };
+    }
+    events(issueKey, options) {
+        const issue = this.db.issueWorkflows.getTrackedIssueByKey(issueKey);
+        if (!issue) {
+            return undefined;
+        }
+        const stageRun = (options?.stageRunId !== undefined ? this.db.issueWorkflows.getStageRun(options.stageRunId) : undefined) ??
+            this.getActiveStageRunForIssue(issue) ??
+            this.db.issueWorkflows.getLatestStageRunForIssue(issue.projectId, issue.linearIssueId);
+        if (!stageRun || stageRun.projectId !== issue.projectId || stageRun.linearIssueId !== issue.linearIssueId) {
+            return undefined;
+        }
+        const events = this.db
+            .stageEvents.listThreadEvents(stageRun.id)
+            .filter((event) => (options?.method ? event.method === options.method : true))
+            .filter((event) => (options?.afterId !== undefined ? event.id > options.afterId : true))
+            .map((event) => ({
+            ...event,
+            ...(safeJsonParse(event.eventJson) ? { parsedEvent: safeJsonParse(event.eventJson) } : {}),
+        }));
+        return { issue, stageRun, events };
+    }
+    worktree(issueKey) {
+        const issue = this.db.issueWorkflows.getTrackedIssueByKey(issueKey);
+        if (!issue) {
+            return undefined;
+        }
+        const workspace = this.getWorkspaceForIssue(issue);
+        if (!workspace) {
+            return undefined;
+        }
+        return {
+            issue,
+            workspace,
+            repoId: issue.projectId,
+        };
+    }
+    open(issueKey) {
+        const worktree = this.worktree(issueKey);
+        if (!worktree) {
+            return undefined;
+        }
+        const ledger = this.getLedgerIssueContext(worktree.issue.projectId, worktree.issue.linearIssueId);
+        const resumeThreadId = (ledger.issueControl?.activeRunLeaseId ? ledger.runLease?.threadId : undefined) ??
+            worktree.workspace.lastThreadId ??
+            worktree.issue.latestThreadId ??
+            ledger.runLease?.threadId;
+        return {
+            ...worktree,
+            ...(resumeThreadId ? { resumeThreadId } : {}),
+        };
+    }
+    retry(issueKey, options) {
+        const issue = this.db.issueWorkflows.getTrackedIssueByKey(issueKey);
+        if (!issue) {
+            return undefined;
+        }
+        const ledger = this.getLedgerIssueContext(issue.projectId, issue.linearIssueId);
+        if (ledger.issueControl?.activeRunLeaseId !== undefined) {
+            throw new Error(`Issue ${issueKey} already has an active stage run.`);
+        }
+        const stage = options?.stage ?? resolveStageFromState(this.config, issue.projectId, issue.currentLinearState);
+        if (!stage) {
+            throw new Error(`Unable to infer a stage for ${issueKey}; pass --stage.`);
+        }
+        const webhookId = `cli-retry-${Date.now()}`;
+        const receipt = this.db.eventReceipts.insertEventReceipt({
+            source: "linear-webhook",
+            externalId: webhookId,
+            eventType: "cli-retry",
+            receivedAt: new Date().toISOString(),
+            acceptanceStatus: "accepted",
+            projectId: issue.projectId,
+            linearIssueId: issue.linearIssueId,
+        });
+        this.db.issueControl.upsertIssueControl({
+            projectId: issue.projectId,
+            linearIssueId: issue.linearIssueId,
+            desiredStage: stage,
+            desiredReceiptId: receipt.id,
+            lifecycleStatus: "queued",
+        });
+        this.db.issueWorkflows.setIssueDesiredStage(issue.projectId, issue.linearIssueId, stage, webhookId);
+        const updated = this.db.issueWorkflows.getTrackedIssue(issue.projectId, issue.linearIssueId);
+        return {
+            issue: updated,
+            stage,
+            ...(options?.reason ? { reason: options.reason } : {}),
+        };
+    }
+    list(options) {
+        const conditions = [];
+        const values = [];
+        if (options?.project) {
+            conditions.push("ai.project_id = ?");
+            values.push(options.project);
+        }
+        const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+        const rows = this.db.connection
+            .prepare(`
+        WITH all_issues AS (
+          SELECT project_id, linear_issue_id FROM issue_projection
+          UNION
+          SELECT project_id, linear_issue_id FROM issue_control
+        )
+        SELECT
+          ai.project_id,
+          ai.linear_issue_id,
+          ip.issue_key,
+          ip.title,
+          ip.current_linear_state,
+          COALESCE(ic.lifecycle_status, 'idle') AS lifecycle_status,
+          COALESCE(ic.updated_at, ip.updated_at) AS updated_at,
+          active_run.stage AS active_stage,
+          latest_run.stage AS latest_stage,
+          latest_run.status AS latest_stage_status
+        FROM all_issues ai
+        LEFT JOIN issue_projection ip
+          ON ip.project_id = ai.project_id AND ip.linear_issue_id = ai.linear_issue_id
+        LEFT JOIN issue_control ic
+          ON ic.project_id = ai.project_id AND ic.linear_issue_id = ai.linear_issue_id
+        LEFT JOIN run_leases active_run
+          ON active_run.id = ic.active_run_lease_id
+        LEFT JOIN run_leases latest_run ON latest_run.id = (
+          SELECT rl.id
+          FROM run_leases rl
+          WHERE rl.project_id = ai.project_id AND rl.linear_issue_id = ai.linear_issue_id
+          ORDER BY rl.id DESC
+          LIMIT 1
+        )
+        ${whereClause}
+        ORDER BY COALESCE(ic.updated_at, ip.updated_at) DESC, ip.issue_key ASC, ai.linear_issue_id ASC
+        `)
+            .all(...values);
+        const items = rows.map((row) => {
+            const projectId = String(row.project_id);
+            const linearIssueId = String(row.linear_issue_id);
+            const issueKey = row.issue_key === null ? undefined : String(row.issue_key);
+            const issue = this.db.issueWorkflows.getTrackedIssue(projectId, linearIssueId);
+            const ledger = issue ? this.getLedgerIssueContext(issue.projectId, issue.linearIssueId) : undefined;
+            return {
+                ...(issueKey ? { issueKey } : {}),
+                ...(row.title === null ? {} : { title: String(row.title) }),
+                projectId,
+                ...(row.current_linear_state === null ? {} : { currentLinearState: String(row.current_linear_state) }),
+                lifecycleStatus: String(row.lifecycle_status),
+                ...(ledger?.runLease
+                    ? { activeStage: ledger.runLease.stage }
+                    : row.active_stage !== null
+                        ? { activeStage: row.active_stage }
+                        : {}),
+                ...(row.latest_stage !== null
+                    ? { latestStage: row.latest_stage }
+                    : ledger?.mirroredStageRun
+                        ? { latestStage: ledger.mirroredStageRun.stage }
+                        : {}),
+                ...(row.latest_stage_status !== null
+                    ? { latestStageStatus: String(row.latest_stage_status) }
+                    : ledger?.mirroredStageRun
+                        ? { latestStageStatus: ledger.mirroredStageRun.status }
+                        : {}),
+                updatedAt: String(row.updated_at),
+            };
+        });
+        return items.filter((item) => {
+            if (options?.active && !item.activeStage) {
+                return false;
+            }
+            if (options?.failed && item.latestStageStatus !== "failed") {
+                return false;
+            }
+            return true;
+        });
+    }
+    getLedgerIssueContext(projectId, linearIssueId) {
+        const issueControl = this.db.issueControl.getIssueControl(projectId, linearIssueId);
+        const runLease = issueControl?.activeRunLeaseId ? this.db.runLeases.getRunLease(issueControl.activeRunLeaseId) : undefined;
+        const workspaceOwnership = issueControl?.activeWorkspaceOwnershipId
+            ? this.db.workspaceOwnership.getWorkspaceOwnership(issueControl.activeWorkspaceOwnershipId)
+            : undefined;
+        const mirroredStageRun = issueControl?.activeRunLeaseId ? this.db.issueWorkflows.getStageRun(issueControl.activeRunLeaseId) : undefined;
+        return {
+            ...(issueControl ? { issueControl } : {}),
+            ...(runLease ? { runLease } : {}),
+            ...(workspaceOwnership ? { workspaceOwnership } : {}),
+            ...(mirroredStageRun ? { mirroredStageRun } : {}),
+        };
+    }
+    getActiveStageRunForIssue(issue, ledger) {
+        const context = ledger ?? this.getLedgerIssueContext(issue.projectId, issue.linearIssueId);
+        const activeStageRun = context.mirroredStageRun ?? this.synthesizeStageRunFromLease(context);
+        if (!activeStageRun) {
+            return undefined;
+        }
+        return activeStageRun.projectId === issue.projectId && activeStageRun.linearIssueId === issue.linearIssueId
+            ? activeStageRun
+            : undefined;
+    }
+    synthesizeStageRunFromLease(ledger) {
+        if (!ledger.runLease) {
+            return undefined;
+        }
+        return {
+            id: -ledger.runLease.id,
+            pipelineRunId: 0,
+            projectId: ledger.runLease.projectId,
+            linearIssueId: ledger.runLease.linearIssueId,
+            workspaceId: 0,
+            stage: ledger.runLease.stage,
+            status: ledger.runLease.status === "failed"
+                ? "failed"
+                : ledger.runLease.status === "completed" || ledger.runLease.status === "released" || ledger.runLease.status === "paused"
+                    ? "completed"
+                    : "running",
+            triggerWebhookId: "ledger-active-run",
+            workflowFile: ledger.runLease.workflowFile,
+            promptText: ledger.runLease.promptText,
+            ...(ledger.runLease.threadId ? { threadId: ledger.runLease.threadId } : {}),
+            ...(ledger.runLease.parentThreadId ? { parentThreadId: ledger.runLease.parentThreadId } : {}),
+            ...(ledger.runLease.turnId ? { turnId: ledger.runLease.turnId } : {}),
+            startedAt: ledger.runLease.startedAt,
+            ...(ledger.runLease.endedAt ? { endedAt: ledger.runLease.endedAt } : {}),
+        };
+    }
+    getWorkspaceForIssue(issue, ledger) {
+        const context = ledger ?? this.getLedgerIssueContext(issue.projectId, issue.linearIssueId);
+        if (!context.issueControl?.activeRunLeaseId) {
+            const activeWorkspace = this.db.issueWorkflows.getActiveWorkspaceForIssue(issue.projectId, issue.linearIssueId);
+            if (activeWorkspace) {
+                return activeWorkspace;
+            }
+        }
+        const workspaceOwnership = context.workspaceOwnership;
+        if (!workspaceOwnership) {
+            return this.db.issueWorkflows.getActiveWorkspaceForIssue(issue.projectId, issue.linearIssueId);
+        }
+        return {
+            id: workspaceOwnership.id,
+            projectId: workspaceOwnership.projectId,
+            linearIssueId: workspaceOwnership.linearIssueId,
+            branchName: workspaceOwnership.branchName,
+            worktreePath: workspaceOwnership.worktreePath,
+            status: workspaceOwnership.status === "released"
+                ? "closed"
+                : workspaceOwnership.status === "paused"
+                    ? "paused"
+                    : "active",
+            ...(context.runLease?.threadId ? { lastThreadId: context.runLease.threadId } : {}),
+            createdAt: workspaceOwnership.createdAt,
+            updatedAt: workspaceOwnership.updatedAt,
+        };
+    }
+    async connect(projectId) {
+        return await this.requestJson("/api/oauth/linear/start", {
+            ...(projectId ? { projectId } : {}),
+        });
+    }
+    async connectStatus(state) {
+        if (!state) {
+            throw new Error("OAuth state is required.");
+        }
+        return await this.requestJson(`/api/oauth/linear/state/${encodeURIComponent(state)}`);
+    }
+    async listInstallations() {
+        return await this.requestJson("/api/installations");
+    }
+    getOperatorBaseUrl() {
+        const host = this.normalizeLocalHost(this.config.server.bind);
+        return `http://${host}:${this.config.server.port}/`;
+    }
+    normalizeLocalHost(bind) {
+        if (bind === "0.0.0.0") {
+            return "127.0.0.1";
+        }
+        if (bind === "::") {
+            return "[::1]";
+        }
+        if (bind.includes(":") && !bind.startsWith("[")) {
+            return `[${bind}]`;
+        }
+        return bind;
+    }
+    async requestJson(pathname, query, init) {
+        const url = new URL(pathname, this.getOperatorBaseUrl());
+        for (const [key, value] of Object.entries(query ?? {})) {
+            if (value) {
+                url.searchParams.set(key, value);
+            }
+        }
+        const response = await fetch(url, {
+            method: init?.method ?? "GET",
+            headers: {
+                accept: "application/json",
+                ...(init?.body !== undefined ? { "content-type": "application/json" } : {}),
+                ...(this.config.operatorApi.bearerToken ? { authorization: `Bearer ${this.config.operatorApi.bearerToken}` } : {}),
+            },
+            ...(init?.body !== undefined ? { body: JSON.stringify(init.body) } : {}),
+        });
+        const body = await response.text();
+        if (!response.ok) {
+            const message = this.readErrorMessage(body);
+            throw new Error(message ?? `Request failed: ${response.status}`);
+        }
+        const parsed = JSON.parse(body);
+        if (parsed.ok === false) {
+            throw new Error(this.readErrorMessage(body) ?? "Request failed.");
+        }
+        return parsed;
+    }
+    readErrorMessage(body) {
+        try {
+            const parsed = JSON.parse(body);
+            return parsed.message ?? parsed.reason;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    async readLiveSummary(threadId, latestTimestampSeen) {
+        const codex = await this.getCodex();
+        const thread = await codex.readThread(threadId, true);
+        return summarizeThread(thread, latestTimestampSeen);
+    }
+    async getCodex() {
+        if (!this.codex) {
+            this.codex = new CodexAppServerClient(this.config.runner.codex, pino({ enabled: false }));
+        }
+        if (!this.codexStarted) {
+            await this.codex.start();
+            this.codexStarted = true;
+        }
+        return this.codex;
+    }
+}

package/dist/cli/formatters/json.js

@@ -0,0 +1,3 @@
+export function formatJson(value) {
+    return `${JSON.stringify(value, null, 2)}\n`;
+}

package/dist/cli/formatters/text.js

@@ -0,0 +1,119 @@
+function value(label, entry) {
+    return `${label}: ${entry ?? "-"}`;
+}
+function truncateLine(input) {
+    if (!input) {
+        return undefined;
+    }
+    const normalized = input.replace(/\s+/g, " ").trim();
+    return normalized.length > 240 ? `${normalized.slice(0, 237)}...` : normalized;
+}
+export function formatInspect(result) {
+    const header = [result.issue?.issueKey ?? result.issue?.linearIssueId ?? "unknown", result.issue?.currentLinearState]
+        .filter(Boolean)
+        .join("  ");
+    const lines = [
+        header,
+        value("Title", result.issue?.title),
+        value("Lifecycle", result.issue?.lifecycleStatus),
+        value("Active stage", result.activeStageRun?.stage),
+        value("Latest stage", result.latestStageRun?.stage),
+        value("Latest result", result.latestStageRun?.status),
+        value("Workspace", result.workspace?.worktreePath),
+        value("Branch", result.workspace?.branchName),
+        value("Latest thread", result.activeStageRun?.threadId ?? result.issue?.latestThreadId ?? result.workspace?.lastThreadId),
+        value("Latest turn", result.live?.latestTurnId ?? result.activeStageRun?.turnId ?? result.latestStageRun?.turnId),
+        result.statusNote ? value("Status", truncateLine(result.statusNote)) : undefined,
+        result.live?.latestTurnStatus ? value("Live turn", result.live.latestTurnStatus) : undefined,
+        result.live?.latestAssistantMessage ? `Latest assistant message:\n${truncateLine(result.live.latestAssistantMessage)}` : undefined,
+    ].filter(Boolean);
+    return `${lines.join("\n")}\n`;
+}
+export function formatLive(result) {
+    const lines = [
+        value("Issue", result.issue.issueKey ?? result.issue.linearIssueId),
+        value("Stage", result.stageRun.stage),
+        value("Thread", result.stageRun.threadId),
+        value("Turn", result.live?.latestTurnId ?? result.stageRun.turnId),
+        value("Turn status", result.live?.latestTurnStatus ?? result.live?.threadStatus ?? result.stageRun.status),
+        value("Latest timestamp", result.live?.latestTimestampSeen),
+        result.live?.latestAssistantMessage ? `Latest assistant message:\n${truncateLine(result.live.latestAssistantMessage)}` : undefined,
+    ].filter(Boolean);
+    return `${lines.join("\n")}\n`;
+}
+export function formatReport(result) {
+    const sections = result.stages.map(({ stageRun, report, summary }) => {
+        const changedFiles = report?.fileChanges
+            .map((entry) => (typeof entry.path === "string" ? entry.path : undefined))
+            .filter(Boolean)
+            .join(", ");
+        const commands = report?.commands.map((command) => command.command).join(" | ");
+        const tools = report?.toolCalls.map((tool) => `${tool.type}:${tool.name}`).join(", ");
+        return [
+            `${stageRun.stage} #${stageRun.id} ${stageRun.status}`,
+            value("Started", stageRun.startedAt),
+            value("Ended", stageRun.endedAt),
+            value("Thread", stageRun.threadId),
+            summary?.latestAssistantMessage ? value("Summary", truncateLine(String(summary.latestAssistantMessage))) : undefined,
+            report?.assistantMessages.at(-1) ? value("Assistant conclusion", truncateLine(report.assistantMessages.at(-1))) : undefined,
+            commands ? value("Commands", commands) : undefined,
+            changedFiles ? value("Changed files", changedFiles) : undefined,
+            tools ? value("Tool calls", tools) : undefined,
+        ]
+            .filter(Boolean)
+            .join("\n");
+    });
+    return `${sections.join("\n\n")}\n`;
+}
+export function formatEvents(result) {
+    const sections = result.events.map((event) => [
+        `#${event.id} ${event.createdAt} ${event.method}`,
+        value("Thread", event.threadId),
+        value("Turn", event.turnId),
+        event.parsedEvent ? JSON.stringify(event.parsedEvent, null, 2) : event.eventJson,
+    ].join("\n"));
+    return `${value("Stage run", result.stageRun.id)}\n${value("Stage", result.stageRun.stage)}\n\n${sections.join("\n\n")}\n`;
+}
+export function formatWorktree(result, cdOnly) {
+    if (cdOnly) {
+        return `${result.workspace.worktreePath}\n`;
+    }
+    return `${[
+        value("Issue", result.issue.issueKey ?? result.issue.linearIssueId),
+        value("Worktree", result.workspace.worktreePath),
+        value("Branch", result.workspace.branchName),
+        value("Repo", result.repoId),
+    ].join("\n")}\n`;
+}
+export function formatOpen(result) {
+    const commands = [
+        `cd ${result.workspace.worktreePath}`,
+        "git branch --show-current",
+        "codex --dangerously-bypass-approvals-and-sandbox",
+    ];
+    if (result.resumeThreadId) {
+        commands.push(`codex --dangerously-bypass-approvals-and-sandbox resume ${result.resumeThreadId}`);
+    }
+    return `${commands.join("\n")}\n`;
+}
+export function formatRetry(result) {
+    return `${[
+        value("Issue", result.issue.issueKey ?? result.issue.linearIssueId),
+        value("Queued stage", result.stage),
+        result.reason ? value("Reason", result.reason) : undefined,
+    ]
+        .filter(Boolean)
+        .join("\n")}\n`;
+}
+export function formatList(items) {
+    return `${items
+        .map((item) => [
+        item.issueKey ?? "-",
+        item.currentLinearState ?? "-",
+        item.lifecycleStatus,
+        item.activeStage ?? "-",
+        item.latestStage ? `${item.latestStage}:${item.latestStageStatus ?? "-"}` : "-",
+        item.updatedAt,
+    ].join("\t"))
+        .join("\n")}\n`;
+}