@gitkraken/core-gitlens 0.6.0 → 0.7.0

package/dist/plus/agents/providers/claudeCodeTranscript.d.ts

@@ -1,39 +1,40 @@
+//#region ../plus/agents/src/providers/claudeCodeTranscript.d.ts
 export interface TranscriptTitles {
-    custom?: string;
-    ai?: string;
-    agent?: string;
+  custom?: string;
+  ai?: string;
+  agent?: string;
 }
 /** A transcript file discovered by {@link ClaudeCodeTranscriptReader.listSessions}, before its
  *  contents are read — everything here comes from `readdir` + `stat`. */
 export interface TranscriptSessionEntry {
-    readonly sessionId: string;
-    readonly path: string;
-    readonly lastActivityMs: number;
-    readonly size: number;
+  readonly sessionId: string;
+  readonly path: string;
+  readonly lastActivityMs: number;
+  readonly size: number;
 }
 /** A {@link TranscriptSessionEntry} enriched with the fields recovered from the file's head/tail. */
 export interface TranscriptSessionSummary extends TranscriptSessionEntry {
-    readonly titles: TranscriptTitles;
-    readonly lastPrompt?: string;
+  readonly titles: TranscriptTitles;
+  readonly lastPrompt?: string;
 }
 export interface TranscriptSessionListing {
-    readonly sessions: TranscriptSessionSummary[];
-    /** Every transcript in the directory, not just the summarized slice — drives "Showing N of M". */
-    readonly total: number;
+  readonly sessions: TranscriptSessionSummary[];
+  /** Every transcript in the directory, not just the summarized slice — drives "Showing N of M". */
+  readonly total: number;
 }
 /** A transcript found outside the queried cwd's project directory, plus the directory Claude
  *  actually uses to resolve it for `--resume`. */
 export interface ResumableTranscriptSessionSummary extends TranscriptSessionSummary {
-    readonly cwd: string;
+  readonly cwd: string;
 }
 export interface ResumableTranscriptSessionListing {
-    readonly sessions: ResumableTranscriptSessionSummary[];
-    readonly total: number;
+  readonly sessions: ResumableTranscriptSessionSummary[];
+  readonly total: number;
 }
 export interface EndedTranscriptDetails {
-    titles: TranscriptTitles;
-    firstPrompt?: string;
-    lastPrompt?: string;
+  titles: TranscriptTitles;
+  firstPrompt?: string;
+  lastPrompt?: string;
 }
 /**
  * Reads Claude Code transcript JSONL files at `~/.claude/projects/<encoded-cwd>/<sessionId>.jsonl`
@@ -48,143 +49,144 @@ export interface EndedTranscriptDetails {
  * resolve's result.
  */
 export declare class ClaudeCodeTranscriptReader {
-    private readonly _cache;
-    private readonly _generations;
-    private readonly _listings;
-    /** Transcript file names per project directory — the readdir behind both the plain listing and
-     *  the by-id scan, which sweeps every project directory. */
-    private readonly _names;
-    /** Project directories under {@link getProjectsRoot}, re-scanned by every by-id recovery. */
-    private _projectDirs;
-    /** Insertion-ordered LRU — re-inserted on hit, oldest key evicted past {@link summaryCacheLimit}. */
-    private readonly _summaries;
-    /** Resolved project path per transcript path, bounded like {@link _summaries}. */
-    private readonly _transcriptCwds;
-    private _nextGen;
-    /** Bumped by {@link invalidateListings}; async listing scans capture it at entry and skip their
-     *  cache write when it moved, so a stale in-flight result can't re-seed a just-cleared cache. */
-    private _listingGen;
-    /** Drops the directory-listing caches (entries, names, project dirs) so the next listing re-reads
-     *  the store. Called when a session ends or is removed: its transcript may have appeared inside
-     *  the TTL window, and a cached listing would hide the new file from the very fetch meant to
-     *  surface it. Summary and cwd caches are keyed by file identity and stay valid, so they're kept.
-     *  The generation bump makes any in-flight listing skip its own cache write — otherwise a scan
-     *  started before the invalidation would re-seed the caches with pre-end results, freshly
-     *  timestamped (same discipline as `resolve`'s per-session generations). */
-    invalidateListings(): void;
-    resolve(sessionId: string, cwd: string | undefined): Promise<TranscriptTitles | undefined>;
-    forget(sessionId: string): void;
-    /**
-     * One-shot read for an *ended* (terminal, static) session: extracts the transcript titles plus
-     * the first and last user prompts. Unlike {@link resolve}, it bypasses the tail cache — a finished
-     * transcript never grows, so it's read once on demand (when an ended row is opened) and the
-     * result applied to the session. `last-prompt` entries carry the prompt as of that point; the first
-     * one bearing a value is the session's opening prompt, the last its most recent. Returns `undefined`
-     * when no transcript is found (archived/purged) — the caller keeps whatever durable-store fields it
-     * already has.
-     *
-     * Streams the file line-by-line rather than buffering it whole: a finished transcript can run to
-     * tens of MB, but this keeps only one line resident at a time. A *full* scan (not a head/tail
-     * window) is required for correctness — when the first turn is large the opening `last-prompt` sits
-     * past any fixed head window, and a windowed read would then mistake a later prompt for the first,
-     * poisoning the derived session name.
-     */
-    resolveEndedDetails(sessionId: string, cwd: string | undefined): Promise<EndedTranscriptDetails | undefined>;
-    /**
-     * Lists the transcripts of sessions whose working directory is `cwd`, most-recently-active first,
-     * summarizing until `limit` summarizable transcripts are found — not just the first `limit` on
-     * disk, since junk transcripts (dropped below) would otherwise starve the result.
-     * `excludeSessionIds` is skipped before `limit` applies, and excluded entries are also dropped
-     * from `total` — they're already shown elsewhere (e.g. as live sessions), so a caller's "N of M"
-     * count must not double-count them.
-     *
-     * Claude homes a transcript under the directory encoding the cwd from which the session started.
-     * That directory is authoritative for where `claude --resume <id>` can find the transcript, but
-     * Claude does not reliably move it when the session later changes worktrees. Callers that have a
-     * durable session-to-worktree association can recover those moved sessions with
-     * {@link listSessionsByIds}; this method intentionally remains the cheap legacy directory listing.
-     *
-     * Discovery (readdir + stat) covers the whole directory and is cheap; summarizing is not, so it's
-     * capped. Entries whose summary yields neither a title nor a prompt are dropped — those are aborted
-     * or empty transcripts with nothing to show or search on.
-     */
-    listSessions(cwd: string, options?: {
-        limit?: number;
-        excludeSessionIds?: ReadonlySet<string>;
-    }): Promise<TranscriptSessionListing>;
-    /**
-     * Finds a known set of session ids across every Claude project directory except `excludeCwd`'s.
-     * This is the recovery path for durable CLI records whose worktree changed after Claude chose the
-     * transcript's project directory. The caller supplies the association; transcript contents alone
-     * are deliberately not used to guess which current worktree owns an arbitrary old session.
-     *
-     * Each result carries the project path encoded by the directory that actually holds the transcript,
-     * so resuming it does not repeat discovery from the wrong worktree. Duplicate ids are counted once,
-     * with the newest transcript winning.
-     */
-    listSessionsByIds(sessionIds: ReadonlySet<string>, options?: {
-        limit?: number;
-        excludeCwd?: string;
-    }): Promise<ResumableTranscriptSessionListing>;
-    /** Discovers every transcript in `dir`, newest first. The directory also holds one sibling
-     *  subdirectory per session (`<uuid>/subagents`, `<uuid>/tool-results`), so entries must be filtered
-     *  to files — a busy project has roughly as many subdirectories as transcripts. */
-    private listEntries;
-    /** Stats `names` in `dir`, dropping the ones that failed — a transcript can vanish (or be
-     *  archived) between the readdir and the stat. Unsorted; callers order as they need.
-     *  Protected (like {@link readSummary}) so tests can interleave against the listing flow. */
-    protected statEntries(dir: string, names: string[]): Promise<TranscriptSessionEntry[]>;
-    /** The `.jsonl` file names in `dir`, cached for {@link listingCacheTtlMs}. Failures propagate
-     *  uncached: an unreadable directory means different things to different callers, and the next
-     *  call must be free to get a real answer. */
-    private listTranscriptNames;
-    /** Every project directory under the projects root, cached for {@link listingCacheTtlMs} — a
-     *  by-id recovery sweeps all of them, once per queried worktree. */
-    private listProjectDirs;
-    /** Scans project directory names once, then stats only requested transcript ids. */
-    private listEntriesByIds;
-    /** `exhausted` reports whether every candidate was scanned — an exhausted scan has proven the
-     *  exact valid count, so callers can report it instead of an upper bound that would keep a
-     *  "Show More" affordance alive with nothing left to show. */
-    private collectSessions;
-    /** Summarizes one transcript, reusing the cached result while its mtime and size are unchanged. */
-    private resolveSummary;
-    /** Recovers the project path represented by the transcript's containing directory. A resolved
-     *  answer is cached: it's a line-scan of the whole transcript, and the directory holding a given
-     *  path never changes. A miss isn't cached — a `cwd` line can still land on append. */
-    private resolveTranscriptCwd;
-    private rememberTranscriptCwd;
-    /**
-     * Reads a summary from the first and last {@link summaryWindowSize} bytes of the transcript.
-     *
-     * Deliberately does not reuse `resolve` — that scans from the last-read offset and buffers the whole
-     * range, which for a cold multi-MB transcript means loading the entire file. Titles are written early
-     * and re-written as they're refined, while prompts land at the tail, so the two windows recover both
-     * at a fraction of the bytes. The tail is parsed second so the newest value wins.
-     */
-    protected readSummary(entry: TranscriptSessionEntry): Promise<TranscriptSessionSummary>;
-    protected getProjectsRoot(): string;
-    /** Resolves the `~/.claude/projects` directory holding the sessions whose working directory is
-     *  `cwd`, or `undefined` when none exists. Falls back to a case-insensitive name match because on
-     *  Windows our
-     *  paths carry a lower-cased drive letter (`normalizePath`) while Claude encodes the OS-native
-     *  `C:\...` — so the exact name never matches by case. */
-    protected resolveProjectDir(cwd: string | undefined): Promise<string | undefined>;
-    protected locateTranscript(sessionId: string, cwd: string | undefined): Promise<string | undefined>;
-    /**
-     * Reads bytes `[start, end)` from `path` and applies any title entries it finds to a copy of
-     * `baseTitles`. Returns the merged titles and the byte position immediately after the last
-     * newline observed — partial trailing lines (writer hasn't flushed `\n` yet) are intentionally
-     * left unconsumed so they're re-read on the next pass.
-     */
-    protected readRange(path: string, start: number, end: number, sessionId: string, baseTitles: TranscriptTitles): Promise<{
-        titles: TranscriptTitles;
-        consumedEnd: number;
-    }>;
+  private readonly _cache;
+  private readonly _generations;
+  private readonly _listings;
+  /** Transcript file names per project directory — the readdir behind both the plain listing and
+   *  the by-id scan, which sweeps every project directory. */
+  private readonly _names;
+  /** Project directories under {@link getProjectsRoot}, re-scanned by every by-id recovery. */
+  private _projectDirs;
+  /** Insertion-ordered LRU — re-inserted on hit, oldest key evicted past {@link summaryCacheLimit}. */
+  private readonly _summaries;
+  /** Resolved project path per transcript path, bounded like {@link _summaries}. */
+  private readonly _transcriptCwds;
+  private _nextGen;
+  /** Bumped by {@link invalidateListings}; async listing scans capture it at entry and skip their
+   *  cache write when it moved, so a stale in-flight result can't re-seed a just-cleared cache. */
+  private _listingGen;
+  /** Drops the directory-listing caches (entries, names, project dirs) so the next listing re-reads
+   *  the store. Called when a session ends or is removed: its transcript may have appeared inside
+   *  the TTL window, and a cached listing would hide the new file from the very fetch meant to
+   *  surface it. Summary and cwd caches are keyed by file identity and stay valid, so they're kept.
+   *  The generation bump makes any in-flight listing skip its own cache write — otherwise a scan
+   *  started before the invalidation would re-seed the caches with pre-end results, freshly
+   *  timestamped (same discipline as `resolve`'s per-session generations). */
+  invalidateListings(): void;
+  resolve(sessionId: string, cwd: string | undefined): Promise<TranscriptTitles | undefined>;
+  forget(sessionId: string): void;
+  /**
+   * One-shot read for an *ended* (terminal, static) session: extracts the transcript titles plus
+   * the first and last user prompts. Unlike {@link resolve}, it bypasses the tail cache — a finished
+   * transcript never grows, so it's read once on demand (when an ended row is opened) and the
+   * result applied to the session. `last-prompt` entries carry the prompt as of that point; the first
+   * one bearing a value is the session's opening prompt, the last its most recent. Returns `undefined`
+   * when no transcript is found (archived/purged) — the caller keeps whatever durable-store fields it
+   * already has.
+   *
+   * Streams the file line-by-line rather than buffering it whole: a finished transcript can run to
+   * tens of MB, but this keeps only one line resident at a time. A *full* scan (not a head/tail
+   * window) is required for correctness — when the first turn is large the opening `last-prompt` sits
+   * past any fixed head window, and a windowed read would then mistake a later prompt for the first,
+   * poisoning the derived session name.
+   */
+  resolveEndedDetails(sessionId: string, cwd: string | undefined): Promise<EndedTranscriptDetails | undefined>;
+  /**
+   * Lists the transcripts of sessions whose working directory is `cwd`, most-recently-active first,
+   * summarizing until `limit` summarizable transcripts are found — not just the first `limit` on
+   * disk, since junk transcripts (dropped below) would otherwise starve the result.
+   * `excludeSessionIds` is skipped before `limit` applies, and excluded entries are also dropped
+   * from `total` — they're already shown elsewhere (e.g. as live sessions), so a caller's "N of M"
+   * count must not double-count them.
+   *
+   * Claude homes a transcript under the directory encoding the cwd from which the session started.
+   * That directory is authoritative for where `claude --resume <id>` can find the transcript, but
+   * Claude does not reliably move it when the session later changes worktrees. Callers that have a
+   * durable session-to-worktree association can recover those moved sessions with
+   * {@link listSessionsByIds}; this method intentionally remains the cheap legacy directory listing.
+   *
+   * Discovery (readdir + stat) covers the whole directory and is cheap; summarizing is not, so it's
+   * capped. Entries whose summary yields neither a title nor a prompt are dropped — those are aborted
+   * or empty transcripts with nothing to show or search on.
+   */
+  listSessions(cwd: string, options?: {
+    limit?: number;
+    excludeSessionIds?: ReadonlySet<string>;
+  }): Promise<TranscriptSessionListing>;
+  /**
+   * Finds a known set of session ids across every Claude project directory except `excludeCwd`'s.
+   * This is the recovery path for durable CLI records whose worktree changed after Claude chose the
+   * transcript's project directory. The caller supplies the association; transcript contents alone
+   * are deliberately not used to guess which current worktree owns an arbitrary old session.
+   *
+   * Each result carries the project path encoded by the directory that actually holds the transcript,
+   * so resuming it does not repeat discovery from the wrong worktree. Duplicate ids are counted once,
+   * with the newest transcript winning.
+   */
+  listSessionsByIds(sessionIds: ReadonlySet<string>, options?: {
+    limit?: number;
+    excludeCwd?: string;
+  }): Promise<ResumableTranscriptSessionListing>;
+  /** Discovers every transcript in `dir`, newest first. The directory also holds one sibling
+   *  subdirectory per session (`<uuid>/subagents`, `<uuid>/tool-results`), so entries must be filtered
+   *  to files — a busy project has roughly as many subdirectories as transcripts. */
+  private listEntries;
+  /** Stats `names` in `dir`, dropping the ones that failed — a transcript can vanish (or be
+   *  archived) between the readdir and the stat. Unsorted; callers order as they need.
+   *  Protected (like {@link readSummary}) so tests can interleave against the listing flow. */
+  protected statEntries(dir: string, names: string[]): Promise<TranscriptSessionEntry[]>;
+  /** The `.jsonl` file names in `dir`, cached for {@link listingCacheTtlMs}. Failures propagate
+   *  uncached: an unreadable directory means different things to different callers, and the next
+   *  call must be free to get a real answer. */
+  private listTranscriptNames;
+  /** Every project directory under the projects root, cached for {@link listingCacheTtlMs} — a
+   *  by-id recovery sweeps all of them, once per queried worktree. */
+  private listProjectDirs;
+  /** Scans project directory names once, then stats only requested transcript ids. */
+  private listEntriesByIds;
+  /** `exhausted` reports whether every candidate was scanned — an exhausted scan has proven the
+   *  exact valid count, so callers can report it instead of an upper bound that would keep a
+   *  "Show More" affordance alive with nothing left to show. */
+  private collectSessions;
+  /** Summarizes one transcript, reusing the cached result while its mtime and size are unchanged. */
+  private resolveSummary;
+  /** Recovers the project path represented by the transcript's containing directory. A resolved
+   *  answer is cached: it's a line-scan of the whole transcript, and the directory holding a given
+   *  path never changes. A miss isn't cached — a `cwd` line can still land on append. */
+  private resolveTranscriptCwd;
+  private rememberTranscriptCwd;
+  /**
+   * Reads a summary from the first and last {@link summaryWindowSize} bytes of the transcript.
+   *
+   * Deliberately does not reuse `resolve` — that scans from the last-read offset and buffers the whole
+   * range, which for a cold multi-MB transcript means loading the entire file. Titles are written early
+   * and re-written as they're refined, while prompts land at the tail, so the two windows recover both
+   * at a fraction of the bytes. The tail is parsed second so the newest value wins.
+   */
+  protected readSummary(entry: TranscriptSessionEntry): Promise<TranscriptSessionSummary>;
+  protected getProjectsRoot(): string;
+  /** Resolves the `~/.claude/projects` directory holding the sessions whose working directory is
+   *  `cwd`, or `undefined` when none exists. Falls back to a case-insensitive name match because on
+   *  Windows our
+   *  paths carry a lower-cased drive letter (`normalizePath`) while Claude encodes the OS-native
+   *  `C:\...` — so the exact name never matches by case. */
+  protected resolveProjectDir(cwd: string | undefined): Promise<string | undefined>;
+  protected locateTranscript(sessionId: string, cwd: string | undefined): Promise<string | undefined>;
+  /**
+   * Reads bytes `[start, end)` from `path` and applies any title entries it finds to a copy of
+   * `baseTitles`. Returns the merged titles and the byte position immediately after the last
+   * newline observed — partial trailing lines (writer hasn't flushed `\n` yet) are intentionally
+   * left unconsumed so they're re-read on the next pass.
+   */
+  protected readRange(path: string, start: number, end: number, sessionId: string, baseTitles: TranscriptTitles): Promise<{
+    titles: TranscriptTitles;
+    consumedEnd: number;
+  }>;
 }
 /** Encodes a working directory into its `~/.claude/projects` directory name. Claude replaces every
  *  non-alphanumeric character — not just separators — preserving runs (`/home/e/.claude` →
  *  `-home-e--claude`) and case. Separators-only would leave the dot in our own worktree convention
  *  (`<repo>.worktrees/<name>`) intact and compute a directory that never exists. */
 export declare function encodeProjectDirName(cwd: string): string;
+//#endregion
 //# sourceMappingURL=claudeCodeTranscript.d.ts.map