jeopi-cli 16.2.14 → 16.2.17

package/dist/types/dap/types.d.ts

@@ -0,0 +1,534 @@
+import type { ptree } from "jeopi-utils";
+export type DapMessage = DapRequestMessage | DapResponseMessage | DapEventMessage;
+export type DapSessionStatus = "launching" | "configuring" | "stopped" | "running" | "terminated";
+export interface DapProtocolMessage {
+    seq: number;
+    type: "request" | "response" | "event";
+}
+export interface DapRequestMessage extends DapProtocolMessage {
+    type: "request";
+    command: string;
+    arguments?: unknown;
+}
+export interface DapResponseMessage extends DapProtocolMessage {
+    type: "response";
+    request_seq: number;
+    success: boolean;
+    command: string;
+    message?: string;
+    body?: unknown;
+}
+export interface DapEventMessage extends DapProtocolMessage {
+    type: "event";
+    event: string;
+    body?: unknown;
+}
+export interface DapErrorBody {
+    id?: number;
+    format: string;
+    variables?: Record<string, string>;
+    showUser?: boolean;
+    sendTelemetry?: boolean;
+    url?: string;
+    urlLabel?: string;
+}
+export interface DapSource {
+    name?: string;
+    path?: string;
+    sourceReference?: number;
+    presentationHint?: "normal" | "emphasize" | "deemphasize";
+    origin?: string;
+    adapterData?: unknown;
+}
+export interface DapBreakpoint {
+    id?: number;
+    verified: boolean;
+    message?: string;
+    source?: DapSource;
+    line?: number;
+    column?: number;
+    endLine?: number;
+    endColumn?: number;
+    instructionReference?: string;
+    offset?: number;
+}
+export interface DapSourceBreakpoint {
+    line: number;
+    column?: number;
+    condition?: string;
+    hitCondition?: string;
+    logMessage?: string;
+}
+export interface DapFunctionBreakpoint {
+    name: string;
+    condition?: string;
+    hitCondition?: string;
+}
+export interface DapInitializeArguments {
+    clientID?: string;
+    clientName?: string;
+    adapterID?: string;
+    locale?: string;
+    linesStartAt1?: boolean;
+    columnsStartAt1?: boolean;
+    pathFormat?: "path" | "uri";
+    supportsVariableType?: boolean;
+    supportsVariablePaging?: boolean;
+    supportsRunInTerminalRequest?: boolean;
+    supportsStartDebuggingRequest?: boolean;
+    supportsMemoryReferences?: boolean;
+    supportsProgressReporting?: boolean;
+    supportsInvalidatedEvent?: boolean;
+    supportsArgsCanBeInterpretedByShell?: boolean;
+}
+export interface DapCapabilities {
+    supportsConfigurationDoneRequest?: boolean;
+    supportsFunctionBreakpoints?: boolean;
+    supportsConditionalBreakpoints?: boolean;
+    supportsTerminateRequest?: boolean;
+    supportsTerminateThreadsRequest?: boolean;
+    supportsEvaluateForHovers?: boolean;
+    supportsSetVariable?: boolean;
+    supportsRestartRequest?: boolean;
+    supportsCompletionsRequest?: boolean;
+    supportsLogPoints?: boolean;
+    supportsDisassembleRequest?: boolean;
+    supportsReadMemoryRequest?: boolean;
+    supportsWriteMemoryRequest?: boolean;
+    supportsModulesRequest?: boolean;
+    supportsLoadedSourcesRequest?: boolean;
+    supportsExceptionInfoRequest?: boolean;
+    supportsInstructionBreakpoints?: boolean;
+    supportsDataBreakpoints?: boolean;
+    supportsSteppingGranularity?: boolean;
+    supportsClipboardContext?: boolean;
+    [key: string]: unknown;
+}
+export interface DapLaunchArguments {
+    program: string;
+    args?: string[];
+    cwd?: string;
+    stopOnEntry?: boolean;
+    stopAtBeginningOfMainSubprogram?: boolean;
+    request?: "launch";
+    [key: string]: unknown;
+}
+export interface DapAttachArguments {
+    pid?: number;
+    processId?: number;
+    port?: number;
+    host?: string;
+    cwd?: string;
+    request?: "attach";
+    [key: string]: unknown;
+}
+export interface DapConfigurationDoneArguments {
+    threadId?: number;
+}
+export interface DapSetBreakpointsArguments {
+    source: DapSource;
+    breakpoints: DapSourceBreakpoint[];
+    sourceModified?: boolean;
+}
+export interface DapSetBreakpointsResponse {
+    breakpoints: DapBreakpoint[];
+}
+export interface DapSetFunctionBreakpointsArguments {
+    breakpoints: DapFunctionBreakpoint[];
+}
+export interface DapSetFunctionBreakpointsResponse {
+    breakpoints: DapBreakpoint[];
+}
+export interface DapInstructionBreakpoint {
+    instructionReference: string;
+    offset?: number;
+    condition?: string;
+    hitCondition?: string;
+}
+export interface DapSetInstructionBreakpointsArguments {
+    breakpoints: DapInstructionBreakpoint[];
+}
+export interface DapDataBreakpointInfoArguments {
+    variablesReference?: number;
+    name: string;
+    frameId?: number;
+}
+export interface DapDataBreakpointInfoResponse {
+    dataId: string | null;
+    description: string;
+    accessTypes?: Array<"read" | "write" | "readWrite">;
+    canPersist?: boolean;
+}
+export interface DapDataBreakpoint {
+    dataId: string;
+    accessType?: "read" | "write" | "readWrite";
+    condition?: string;
+    hitCondition?: string;
+}
+export interface DapSetDataBreakpointsArguments {
+    breakpoints: DapDataBreakpoint[];
+}
+export interface DapContinueArguments {
+    threadId: number;
+    singleThread?: boolean;
+}
+export interface DapContinueResponse {
+    allThreadsContinued?: boolean;
+}
+export interface DapPauseArguments {
+    threadId: number;
+}
+export interface DapStepArguments {
+    threadId: number;
+    singleThread?: boolean;
+    granularity?: "statement" | "line" | "instruction";
+}
+export interface DapTerminateArguments {
+    restart?: boolean;
+}
+export interface DapDisconnectArguments {
+    restart?: boolean;
+    terminateDebuggee?: boolean;
+    suspendDebuggee?: boolean;
+}
+export interface DapStackTraceArguments {
+    threadId: number;
+    startFrame?: number;
+    levels?: number;
+    format?: Record<string, unknown>;
+}
+export interface DapStackFrame {
+    id: number;
+    name: string;
+    source?: DapSource;
+    line: number;
+    column: number;
+    endLine?: number;
+    endColumn?: number;
+    instructionPointerReference?: string;
+    moduleId?: number | string;
+    presentationHint?: "normal" | "label" | "subtle";
+}
+export interface DapStackTraceResponse {
+    stackFrames: DapStackFrame[];
+    totalFrames?: number;
+}
+export interface DapScopesArguments {
+    frameId: number;
+}
+export interface DapScope {
+    name: string;
+    presentationHint?: "arguments" | "locals" | "registers" | string;
+    variablesReference: number;
+    expensive: boolean;
+    source?: DapSource;
+    line?: number;
+    column?: number;
+    endLine?: number;
+    endColumn?: number;
+}
+export interface DapScopesResponse {
+    scopes: DapScope[];
+}
+export interface DapVariablesArguments {
+    variablesReference: number;
+    filter?: "indexed" | "named";
+    start?: number;
+    count?: number;
+    format?: Record<string, unknown>;
+}
+export interface DapVariable {
+    name: string;
+    value: string;
+    type?: string;
+    presentationHint?: {
+        kind?: string;
+        attributes?: string[];
+        visibility?: string;
+        lazy?: boolean;
+    };
+    evaluateName?: string;
+    variablesReference: number;
+    namedVariables?: number;
+    indexedVariables?: number;
+    memoryReference?: string;
+}
+export interface DapVariablesResponse {
+    variables: DapVariable[];
+}
+export interface DapDisassembleArguments {
+    memoryReference: string;
+    offset?: number;
+    instructionOffset?: number;
+    instructionCount: number;
+    resolveSymbols?: boolean;
+}
+export interface DapDisassembledInstruction {
+    address: string;
+    instructionBytes?: string;
+    instruction: string;
+    symbol?: string;
+    location?: DapSource;
+    line?: number;
+    column?: number;
+    endLine?: number;
+    endColumn?: number;
+}
+export interface DapDisassembleResponse {
+    instructions: DapDisassembledInstruction[];
+}
+export interface DapReadMemoryArguments {
+    memoryReference: string;
+    offset?: number;
+    count: number;
+}
+export interface DapReadMemoryResponse {
+    address: string;
+    unreadableBytes?: number;
+    data?: string;
+}
+export interface DapWriteMemoryArguments {
+    memoryReference: string;
+    offset?: number;
+    data: string;
+    allowPartial?: boolean;
+}
+export interface DapWriteMemoryResponse {
+    offset?: number;
+    bytesWritten?: number;
+}
+export interface DapModule {
+    id: number | string;
+    name: string;
+    path?: string;
+    isOptimized?: boolean;
+    isUserCode?: boolean;
+    version?: string;
+    symbolStatus?: string;
+    symbolFilePath?: string;
+    dateTimeStamp?: string;
+    addressRange?: string;
+}
+export interface DapModulesArguments {
+    startModule?: number;
+    moduleCount?: number;
+}
+export interface DapModulesResponse {
+    modules: DapModule[];
+    totalModules?: number;
+}
+export interface DapLoadedSourcesResponse {
+    sources: DapSource[];
+}
+export interface DapEvaluateArguments {
+    expression: string;
+    frameId?: number;
+    context?: "watch" | "repl" | "hover" | "clipboard" | "variables";
+    format?: Record<string, unknown>;
+}
+export interface DapEvaluateResponse {
+    result: string;
+    type?: string;
+    presentationHint?: {
+        kind?: string;
+        attributes?: string[];
+        visibility?: string;
+        lazy?: boolean;
+    };
+    variablesReference: number;
+    namedVariables?: number;
+    indexedVariables?: number;
+    memoryReference?: string;
+}
+export interface DapThread {
+    id: number;
+    name: string;
+}
+export interface DapThreadsResponse {
+    threads: DapThread[];
+}
+export interface DapOutputEventBody {
+    category?: "console" | "important" | "stdout" | "stderr" | "telemetry" | string;
+    output: string;
+    group?: "start" | "startCollapsed" | "end";
+    variablesReference?: number;
+    source?: DapSource;
+    line?: number;
+    column?: number;
+    data?: unknown;
+}
+export interface DapStoppedEventBody {
+    reason: string;
+    description?: string;
+    threadId?: number;
+    preserveFocusHint?: boolean;
+    text?: string;
+    allThreadsStopped?: boolean;
+    hitBreakpointIds?: number[];
+}
+export interface DapContinuedEventBody {
+    threadId: number;
+    allThreadsContinued?: boolean;
+}
+export interface DapExitedEventBody {
+    exitCode?: number;
+}
+export interface DapTerminatedEventBody {
+    restart?: boolean | Record<string, unknown>;
+}
+export interface DapInitializedEventBody {
+}
+export interface DapRunInTerminalArguments {
+    kind?: "integrated" | "external";
+    title?: string;
+    cwd?: string;
+    args: string[];
+    env?: Record<string, string | null>;
+}
+export interface DapRunInTerminalResponse {
+    processId?: number;
+    shellProcessId?: number;
+}
+export interface DapStartDebuggingArguments {
+    request: "launch" | "attach";
+    configuration: Record<string, unknown>;
+}
+export interface DapPendingRequest {
+    resolve: (body: unknown) => void;
+    reject: (error: Error) => void;
+    command: string;
+}
+export interface DapClientState {
+    adapterName: string;
+    cwd: string;
+    proc: ptree.ChildProcess<"pipe">;
+    requestSeq: number;
+    pendingRequests: Map<number, DapPendingRequest>;
+    messageBuffer: Uint8Array;
+    isReading: boolean;
+    lastActivity: number;
+    capabilities?: DapCapabilities;
+}
+export interface DapAdapterConfig {
+    command: string;
+    args?: string[];
+    languages?: string[];
+    fileTypes?: string[];
+    rootMarkers?: string[];
+    launchDefaults?: Record<string, unknown>;
+    attachDefaults?: Record<string, unknown>;
+    /** "stdio" (default): communicate via stdin/stdout pipes.
+     *  "socket": adapter uses a network socket instead of stdio.
+     *  On Linux, connects via a unix domain socket.
+     *  On macOS, the adapter dials into a local TCP listener (--client-addr). */
+    connectMode?: "stdio" | "socket";
+    /** When true, the adapter accepts a directory as the launch `program`
+     *  (e.g. dlv treats it as a Go package path). When false/undefined, the
+     *  debug tool rejects directory programs upfront. */
+    acceptsDirectoryProgram?: boolean;
+}
+export interface DapResolvedAdapter {
+    name: string;
+    command: string;
+    args: string[];
+    resolvedCommand: string;
+    languages: string[];
+    fileTypes: string[];
+    rootMarkers: string[];
+    launchDefaults: Record<string, unknown>;
+    attachDefaults: Record<string, unknown>;
+    connectMode: "stdio" | "socket";
+    acceptsDirectoryProgram: boolean;
+}
+export interface DapBreakpointRecord {
+    id?: number;
+    verified: boolean;
+    line: number;
+    condition?: string;
+    message?: string;
+}
+export interface DapInstructionBreakpointRecord {
+    id?: number;
+    verified: boolean;
+    instructionReference: string;
+    offset?: number;
+    condition?: string;
+    hitCondition?: string;
+    message?: string;
+}
+export interface DapDataBreakpointRecord {
+    id?: number;
+    verified: boolean;
+    dataId: string;
+    accessType?: "read" | "write" | "readWrite";
+    condition?: string;
+    hitCondition?: string;
+    message?: string;
+}
+export interface DapFunctionBreakpointRecord {
+    id?: number;
+    verified: boolean;
+    name: string;
+    condition?: string;
+    message?: string;
+}
+export interface DapStopLocation {
+    threadId?: number;
+    frameId?: number;
+    reason?: string;
+    description?: string;
+    text?: string;
+    frameName?: string;
+    instructionPointerReference?: string;
+    source?: DapSource;
+    line?: number;
+    column?: number;
+}
+export interface DapSessionSummary {
+    id: string;
+    adapter: string;
+    cwd: string;
+    program?: string;
+    status: DapSessionStatus;
+    launchedAt: string;
+    lastUsedAt: string;
+    threadId?: number;
+    frameId?: number;
+    stopReason?: string;
+    stopDescription?: string;
+    frameName?: string;
+    instructionPointerReference?: string;
+    source?: DapSource;
+    line?: number;
+    column?: number;
+    breakpointFiles: number;
+    breakpointCount: number;
+    functionBreakpointCount: number;
+    outputBytes: number;
+    outputTruncated: boolean;
+    exitCode?: number;
+    needsConfigurationDone: boolean;
+}
+export interface DapContinueOutcome {
+    snapshot: DapSessionSummary;
+    state: "running" | "stopped" | "terminated";
+    timedOut: boolean;
+}
+export interface DapLaunchSessionOptions {
+    adapter: DapResolvedAdapter;
+    program: string;
+    args?: string[];
+    cwd: string;
+    /** Per-launch overrides merged over `adapter.launchDefaults`. Used to
+     *  inject adapter-specific values that depend on the resolved program
+     *  (e.g. dlv's `mode` switches between `debug` and `exec` based on
+     *  whether `program` is a Go package path or a compiled binary). */
+    extraLaunchArguments?: Record<string, unknown>;
+}
+export interface DapAttachSessionOptions {
+    adapter: DapResolvedAdapter;
+    cwd: string;
+    pid?: number;
+    port?: number;
+    host?: string;
+}

package/dist/types/debug/index.d.ts

@@ -0,0 +1,15 @@
+import { Container } from "jeopi-tui";
+import type { InteractiveModeContext } from "../modes/types";
+/**
+ * Debug selector component.
+ */
+export declare class DebugSelectorComponent extends Container {
+    #private;
+    private ctx;
+    constructor(ctx: InteractiveModeContext, onDone: () => void);
+    handleInput(keyData: string): void;
+}
+/**
+ * Show the debug selector.
+ */
+export declare function showDebugSelector(ctx: InteractiveModeContext, done: () => void): DebugSelectorComponent;

package/dist/types/debug/log-formatting.d.ts

@@ -0,0 +1,4 @@
+export declare function formatDebugLogLine(line: string, maxWidth: number): string;
+export declare function formatDebugLogExpandedLines(line: string, maxWidth: number): string[];
+export declare function parseDebugLogTimestampMs(line: string): number | undefined;
+export declare function parseDebugLogPid(line: string): number | undefined;

package/dist/types/debug/log-viewer.d.ts

@@ -0,0 +1,69 @@
+import { type Component } from "jeopi-tui";
+import type { DebugLogSource } from "./report-bundle";
+export declare const SESSION_BOUNDARY_WARNING = "### WARNING - Logs above are older than current session!";
+export declare const LOAD_OLDER_LABEL = "### MOVE UP TO LOAD MORE...";
+type DebugLogViewerModelOptions = {
+    processStartMs?: number;
+    processPid?: number;
+    hasOlderLogs?: () => boolean;
+    loadOlderLogs?: (limitDays?: number) => Promise<string>;
+};
+type ViewerRow = {
+    kind: "warning";
+} | {
+    kind: "load-older";
+} | {
+    kind: "log";
+    logIndex: number;
+};
+export declare function splitLogText(logText: string): string[];
+export declare function buildLogCopyPayload(lines: string[]): string;
+export declare class DebugLogViewerModel {
+    #private;
+    constructor(logText: string, options?: DebugLogViewerModelOptions);
+    get logCount(): number;
+    get visibleLogCount(): number;
+    get rows(): readonly ViewerRow[];
+    get cursorRowIndex(): number | undefined;
+    get cursorLogIndex(): number | undefined;
+    get filterQuery(): string;
+    get cursorRowKind(): ViewerRow["kind"] | undefined;
+    get expandedCount(): number;
+    isProcessFilterEnabled(): boolean;
+    isCursorAtFirstSelectableRow(): boolean;
+    getRawLine(logIndex: number): string;
+    setFilterQuery(query: string): void;
+    toggleProcessFilter(): void;
+    moveCursor(delta: number, extendSelection: boolean): void;
+    moveCursorToRow(rowIndex: number, extendSelection: boolean): boolean;
+    getSelectedLogIndices(): number[];
+    getSelectedCount(): number;
+    isSelected(logIndex: number): boolean;
+    isExpanded(logIndex: number): boolean;
+    expandSelected(): void;
+    collapseSelected(): void;
+    getSelectedRawLines(): string[];
+    selectAllVisible(): void;
+    canLoadOlder(): boolean;
+    loadOlder(additionalCount?: number): Promise<boolean>;
+    prependLogs(logText: string): number;
+}
+interface DebugLogViewerComponentOptions {
+    logs: string;
+    terminalRows: number;
+    onExit: () => void;
+    onStatus?: (message: string) => void;
+    onError?: (message: string) => void;
+    processStartMs?: number;
+    processPid?: number;
+    logSource?: DebugLogSource;
+    onUpdate?: () => void;
+}
+export declare class DebugLogViewerComponent implements Component {
+    #private;
+    constructor(options: DebugLogViewerComponentOptions);
+    handleInput(keyData: string): void;
+    invalidate(): void;
+    render(width: number): readonly string[];
+}
+export {};

package/dist/types/debug/profiler.d.ts

@@ -0,0 +1,24 @@
+/**
+ * CPU and heap profiling wrappers for debug reports.
+ */
+export interface CpuProfile {
+    data: string;
+    markdown: string;
+}
+export interface ProfilerSession {
+    /** Stop profiling and return the profile data */
+    stop(): Promise<CpuProfile>;
+}
+/**
+ * Start CPU profiling.
+ * Returns a session that can be stopped to get the profile data.
+ */
+export declare function startCpuProfile(): Promise<ProfilerSession>;
+export interface HeapSnapshot {
+    data: string;
+}
+/**
+ * Generate a heap snapshot.
+ * Uses Bun's built-in generateHeapSnapshot.
+ */
+export declare function generateHeapSnapshotData(): HeapSnapshot;

package/dist/types/debug/protocol-probe.d.ts

@@ -0,0 +1,38 @@
+import { Container, type ImageBudget, type TextSizingScale } from "jeopi-tui";
+/**
+ * Encode raw 8-bit RGB pixels (`width * height * 3` bytes, row-major) as a PNG
+ * (color type 2, no interlacing). The IDAT payload is a real zlib stream from
+ * {@link zlib.deflateSync}, so the output is a fully valid PNG that every image
+ * protocol — including Sixel, which decodes the bytes natively — accepts.
+ */
+export declare function encodeRgbPng(width: number, height: number, rgb: Uint8Array): Uint8Array;
+export interface SampleImage {
+    base64: string;
+    mimeType: string;
+    dimensions: {
+        widthPx: number;
+        heightPx: number;
+    };
+}
+/** Build a deterministic RGB gradient PNG (red across, green down, constant blue). */
+export declare function buildSampleImage(width?: number, height?: number): SampleImage;
+/**
+ * OSC 66 text-sizing sample lines, one scaled span per requested scale. Each
+ * scaled row is followed by `scale - 1` blank rows that reserve the vertical
+ * cells its multi-cell glyphs occupy — mirroring the markdown H1 renderer so
+ * the next line does not paint over the bottom of the glyphs.
+ */
+export declare function buildLargeTextLines(scales?: readonly TextSizingScale[]): string[];
+export interface ProtocolProbeOptions {
+    image: SampleImage;
+    imageBudget: ImageBudget;
+    /** Whether the desktop notification was suppressed (e.g. `PI_NOTIFICATIONS=off`). */
+    notificationSuppressed: boolean;
+}
+/**
+ * Self-contained panel that renders one sample of every special terminal
+ * protocol into the chat transcript.
+ */
+export declare class ProtocolProbeComponent extends Container {
+    constructor(options: ProtocolProbeOptions);
+}