@gitkraken/core-gitlens 0.2.0 → 0.3.1

package/src/plus/agents/providers/claudeCodeTranscript.ts

@@ -0,0 +1,214 @@
+import { createReadStream } from 'fs';
+import { readdir, stat } from 'fs/promises';
+import { homedir } from 'os';
+import { join } from 'path';
+
+export interface TranscriptTitles {
+	custom?: string;
+	ai?: string;
+	agent?: string;
+}
+
+interface CacheEntry {
+	path: string;
+	mtimeMs: number;
+	size: number;
+	nextOffset: number;
+	titles: TranscriptTitles;
+}
+
+interface TitleEntry {
+	type: string;
+	sessionId?: string;
+	customTitle?: string;
+	aiTitle?: string;
+	agentName?: string;
+}
+
+/**
+ * Reads Claude Code transcript JSONL files at `~/.claude/projects/<encoded-cwd>/<sessionId>.jsonl`
+ * to surface `custom-title`, `ai-title`, and `agent-name` entries as fallback session names.
+ *
+ * Maintains a per-session cache keyed by mtime + last-read byte offset, so repeated calls only
+ * read the appended tail. Last occurrence per type wins.
+ *
+ * `resolve` is async, so a `forget` (or a newer `resolve`) for the same session can land between
+ * its `await`s. A per-session generation counter is stamped at entry and re-checked before the
+ * final cache write, so a stale `resolve` can't resurrect a forgotten entry or clobber a newer
+ * resolve's result.
+ */
+export class ClaudeCodeTranscriptReader {
+	private readonly _cache = new Map<string, CacheEntry>();
+	private readonly _generations = new Map<string, number>();
+	private _nextGen = 0;
+
+	async resolve(sessionId: string, cwd: string | undefined): Promise<TranscriptTitles | undefined> {
+		const gen = ++this._nextGen;
+		this._generations.set(sessionId, gen);
+
+		const cached = this._cache.get(sessionId);
+		const path = cached?.path ?? (await this.locateTranscript(sessionId, cwd));
+		if (path == null) return undefined;
+
+		let stats;
+		try {
+			stats = await stat(path);
+		} catch {
+			// File disappeared; drop any stale cache entry so a future call retries discovery.
+			// Skip the delete if a newer resolve/forget claimed the slot — their state is fresher.
+			if (this._generations.get(sessionId) === gen) {
+				this._cache.delete(sessionId);
+				this._generations.delete(sessionId);
+			}
+			return undefined;
+		}
+
+		if (stats.mtimeMs === cached?.mtimeMs && stats.size === cached?.size) {
+			return cached.titles;
+		}
+
+		// Truncation or rewrite: stat shrank below our read cursor or mtime moved backward → full re-scan.
+		const startFromScratch = cached == null || stats.size < cached.nextOffset || stats.mtimeMs < cached.mtimeMs;
+		const startOffset = startFromScratch ? 0 : cached.nextOffset;
+		const baseTitles: TranscriptTitles = startFromScratch ? {} : { ...cached.titles };
+
+		const { titles, consumedEnd } =
+			stats.size > startOffset
+				? await this.readRange(path, startOffset, stats.size, sessionId, baseTitles)
+				: { titles: baseTitles, consumedEnd: startOffset };
+
+		// If `forget` ran or a newer `resolve` started while we were awaiting, skip the cache write
+		// — the entry we'd be writing reflects stale state.
+		if (this._generations.get(sessionId) !== gen) return titles;
+
+		const entry: CacheEntry = {
+			path: path,
+			mtimeMs: stats.mtimeMs,
+			size: stats.size,
+			nextOffset: consumedEnd,
+			titles: titles,
+		};
+		this._cache.set(sessionId, entry);
+		return titles;
+	}
+
+	forget(sessionId: string): void {
+		this._cache.delete(sessionId);
+		this._generations.delete(sessionId);
+	}
+
+	protected async locateTranscript(sessionId: string, cwd: string | undefined): Promise<string | undefined> {
+		const root = join(homedir(), '.claude', 'projects');
+		const fileName = `${sessionId}.jsonl`;
+
+		if (cwd != null && cwd.length > 0) {
+			const encoded = cwd.replace(/[/\\:]/g, '-');
+			const candidate = join(root, encoded, fileName);
+			if (await fileExists(candidate)) return candidate;
+		}
+
+		let dirs: string[];
+		try {
+			dirs = await readdir(root);
+		} catch {
+			return undefined;
+		}
+
+		const candidates = await Promise.all(
+			dirs.map(async dir => {
+				const candidate = join(root, dir, fileName);
+				return (await fileExists(candidate)) ? candidate : undefined;
+			}),
+		);
+		return candidates.find(c => c != null);
+	}
+
+	/**
+	 * 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 async readRange(
+		path: string,
+		start: number,
+		end: number,
+		sessionId: string,
+		baseTitles: TranscriptTitles,
+	): Promise<{ titles: TranscriptTitles; consumedEnd: number }> {
+		const buffer = await readSlice(path, start, end);
+		const titles: TranscriptTitles = { ...baseTitles };
+
+		let lastNewlineEnd = start;
+		let lineStart = 0;
+		for (let i = 0; i < buffer.length; i++) {
+			if (buffer[i] !== 0x0a) continue;
+
+			// Slice the line (trim a trailing \r for CRLF files), then advance the cursor past the \n
+			// regardless of whether the line yielded anything — we've fully observed those bytes.
+			const lineEnd = i > lineStart && buffer[i - 1] === 0x0d ? i - 1 : i;
+			if (lineEnd > lineStart) {
+				const line = buffer.toString('utf8', lineStart, lineEnd);
+				applyTitleLine(line, sessionId, titles);
+			}
+			lineStart = i + 1;
+			lastNewlineEnd = start + i + 1;
+		}
+
+		return { titles: titles, consumedEnd: lastNewlineEnd };
+	}
+}
+
+function applyTitleLine(line: string, sessionId: string, titles: TranscriptTitles): void {
+	if (!isLikelyTitleLine(line)) return;
+
+	let entry: TitleEntry;
+	try {
+		entry = JSON.parse(line) as TitleEntry;
+	} catch {
+		return;
+	}
+	if (entry.sessionId != null && entry.sessionId !== sessionId) return;
+
+	switch (entry.type) {
+		case 'custom-title':
+			if (typeof entry.customTitle === 'string' && entry.customTitle.length > 0) {
+				titles.custom = entry.customTitle;
+			}
+			break;
+		case 'ai-title':
+			if (typeof entry.aiTitle === 'string' && entry.aiTitle.length > 0) {
+				titles.ai = entry.aiTitle;
+			}
+			break;
+		case 'agent-name':
+			if (typeof entry.agentName === 'string' && entry.agentName.length > 0) {
+				titles.agent = entry.agentName;
+			}
+			break;
+	}
+}
+
+function isLikelyTitleLine(line: string): boolean {
+	if (!line.includes('"type"')) return false;
+	return line.includes('-title') || line.includes('agent-name');
+}
+
+async function fileExists(path: string): Promise<boolean> {
+	try {
+		const stats = await stat(path);
+		return stats.isFile();
+	} catch {
+		return false;
+	}
+}
+
+function readSlice(path: string, start: number, end: number): Promise<Buffer> {
+	return new Promise((resolve, reject) => {
+		const chunks: Buffer[] = [];
+		const stream = createReadStream(path, { start: start, end: end - 1 });
+		stream.on('data', chunk => chunks.push(chunk as Buffer));
+		stream.on('end', () => resolve(Buffer.concat(chunks)));
+		stream.on('error', reject);
+	});
+}

package/src/plus/agents/sanitizePrompt.ts

@@ -0,0 +1,109 @@
+import { truncate } from '../../utils/string.js';
+
+const maxStoredPromptLength = 500;
+
+// Marker blocks GitLens itself embeds when dispatching Start Work / Start Review prompts to an
+// agent (see `start-work-issue` / `start-review-pullRequest` templates in
+// `packages/plus/ai/src/prompts.ts`). The surrounding template begins with a long
+// "You are an advanced AI programming assistant…" preamble that would otherwise become the
+// session's display name; matching on the block delimiters lets us pull the issue/PR title out
+// of the embedded JSON instead.
+const dispatchBlockRegex = /<(issue|prData)>([\s\S]*?)<\/\1>/;
+
+// Wrappers the Claude Code harness or its VS Code extension prepend to the `prompt` field of
+// `UserPromptSubmit` hook events. These are synthetic context blocks, not user-typed content,
+// and shouldn't appear verbatim in GitLens agent status UI.
+const harnessBlockPatterns: readonly RegExp[] = [
+	// VS Code extension: any current or future IDE-context tag (e.g. <ide_opened_file>,
+	// <ide_selection>). Prefix-matched so newly-added ones are handled automatically.
+	/<(ide_[a-zA-Z0-9_]+)(?:\s[^>]*)?>[\s\S]*?<\/\1>/g,
+	// VS Code extension: @terminal:<name> mention expansion. Gated on the `name` attribute so we
+	// don't strip a bare <terminal> a user pasted as code.
+	/<terminal\s+name="[^"]*"[^>]*>[\s\S]*?<\/terminal>/g,
+	// VS Code extension: @browser mention expansion. Gated on tabGroupId/tabId for the same reason.
+	/<browser\s+[^>]*\b(?:tabGroupId|tabId)="[^"]*"[^>]*>[\s\S]*?<\/browser>/g,
+	// VS Code extension: one-shot system instruction prepended whenever any @browser is present.
+	/<browser_instruction>[\s\S]*?<\/browser_instruction>/g,
+	// CLI harness: background-bash task lifecycle event (status, summary, output-file, etc.).
+	/<task-notification>[\s\S]*?<\/task-notification>/g,
+	// CLI harness: built-in slash-command stdout/stderr echo and caveat note.
+	/<(local-command-(?:stdout|stderr|caveat))>[\s\S]*?<\/\1>/g,
+	// CLI harness: bang-prefix bash invocation echo (input/stdout/stderr).
+	/<(bash-(?:input|stdout|stderr))>[\s\S]*?<\/\1>/g,
+	// CLI harness: tool-permission response wrapper.
+	/<permissionresponse>[\s\S]*?<\/permissionresponse>/g,
+	// Anthropic shared-context blocks (claude.ai web-app feature; defensive).
+	/<shared-context(?:\s[^>]*)?>[\s\S]*?<\/shared-context>/g,
+];
+
+/**
+ * Normalizes a Claude Code `UserPromptSubmit` event prompt into something fit for display in
+ * GitLens (agent status pill, sidebar tooltip, etc.) by stripping harness-injected wrappers.
+ *
+ * Returns `undefined` for empty input or when the prompt was nothing but harness context, so the
+ * caller can skip overwriting the previously-captured user prompt.
+ */
+export function sanitizeAgentPrompt(prompt: string | undefined): string | undefined {
+	if (!prompt) return undefined;
+
+	// Normalize CRLF up-front so the harness-block and whitespace-collapse regexes (which target
+	// `\n`) behave identically for Windows-originated prompts.
+	let result = prompt.replace(/\r\n/g, '\n');
+
+	let stripped = false;
+	for (const pattern of harnessBlockPatterns) {
+		const next = result.replace(pattern, '');
+		if (next !== result) {
+			stripped = true;
+			result = next;
+		}
+	}
+
+	// GitLens-dispatched Start Work / Start Review prompts: replace the template body with just
+	// the issue/PR title so the session name doesn't surface the "You are an advanced AI…"
+	// preamble. Runs AFTER harness stripping so that an `<ide_selection>` (or other wrapper)
+	// containing an `<issue>…</issue>` block doesn't get rewritten to the embedded title — the
+	// wrapper is stripped first and only a genuine dispatch template body triggers the rewrite.
+	// Anything that doesn't yield a usable title falls through to normal sanitization.
+	const dispatchTitle = extractDispatchTitle(result);
+	if (dispatchTitle != null) return dispatchTitle;
+
+	// Only collapse the whitespace runs around stripped blocks. Untouched user prompts pass
+	// through with their internal whitespace intact (the final trim still removes the outer
+	// padding either way).
+	if (stripped) {
+		result = result.replace(/[ \t]+\n/g, '\n').replace(/\n{3,}/g, '\n\n');
+	}
+	result = result.trim();
+	return result || undefined;
+}
+
+/**
+ * Sanitizes and truncates a raw prompt for storage on an `AgentSession`. Use this everywhere a
+ * session's `lastPrompt` / `firstPrompt` is populated so the sanitize+truncate pipeline can't be
+ * applied inconsistently across capture paths (hook events, CLI session-state syncs, etc.).
+ */
+export function prepareStoredPrompt(prompt: string | undefined): string | undefined {
+	const cleaned = sanitizeAgentPrompt(prompt);
+	return cleaned ? truncate(cleaned, maxStoredPromptLength) : undefined;
+}
+
+/**
+ * Looks for a GitLens-dispatch marker block (`<issue>…</issue>` or `<prData>…</prData>`) and
+ * returns the embedded `title` field. Both `IssueShape` and `PullRequestShape` carry `title`, so
+ * a single accessor covers Start Work and Start Review. Returns `undefined` when the block is
+ * absent, the JSON fails to parse, or `title` is missing/empty — those cases fall through to the
+ * regular sanitization path.
+ */
+function extractDispatchTitle(prompt: string): string | undefined {
+	const match = dispatchBlockRegex.exec(prompt);
+	if (match == null) return undefined;
+
+	try {
+		const parsed = JSON.parse(match[2]) as { title?: unknown };
+		const title = typeof parsed.title === 'string' ? parsed.title.trim() : '';
+		return title.length > 0 ? title : undefined;
+	} catch {
+		return undefined;
+	}
+}

package/src/plus/agents/stateMachine.ts

@@ -0,0 +1,197 @@
+import { kill } from 'process';
+import type { AgentSession, AgentSessionStatus, PendingPermissionKind } from './types.js';
+
+/** Cap for derived plan / question summaries — short enough to clamp into a card row without
+ *  truncation eating the leading content, long enough to convey what the prompt is about. */
+const summaryMaxLength = 120;
+
+export function deriveStatusFromEvent(event: string): AgentSessionStatus {
+	switch (event) {
+		case 'SessionStart':
+		case 'Stop':
+		case 'StopFailure':
+			return 'idle';
+		case 'PreToolUse':
+			return 'tool_use';
+		case 'PreCompact':
+			return 'compacting';
+		case 'PermissionRequest':
+		case 'Elicitation':
+			return 'permission_requested';
+		case 'UserPromptSubmit':
+		case 'PostToolUse':
+		case 'PostToolUseFailure':
+		case 'PostCompact':
+		case 'PermissionDenied':
+		case 'ElicitationResult':
+		case 'SubagentStart':
+		case 'SubagentStop':
+			return 'thinking';
+		default:
+			return 'idle';
+	}
+}
+
+export function isProcessAlive(pid: number): boolean {
+	// `kill(0, ...)` and `kill(<negative>, ...)` have process-group semantics on POSIX
+	// (and target the current process under libuv on Windows), so they don't tell us
+	// anything about a specific pid. Reject anything that isn't a real, positive pid.
+	if (!Number.isInteger(pid) || pid <= 0) return false;
+
+	try {
+		kill(pid, 0);
+		return true;
+	} catch (ex) {
+		// The process exists but we can't signal it: sandboxed/different uid (POSIX
+		// EPERM) or `OpenProcess` access-denied (Windows EACCES). Treat as alive.
+		// ESRCH and everything else mean dead.
+		const code = (ex as NodeJS.ErrnoException)?.code;
+		return code === 'EPERM' || code === 'EACCES';
+	}
+}
+
+export function rehydrateSubagents(
+	subagents:
+		| (Omit<AgentSession, 'lastActivity' | 'phaseSince'> & { lastActivity: string; phaseSince: string })[]
+		| undefined,
+): AgentSession[] | undefined {
+	if (subagents == null || subagents.length === 0) return undefined;
+	return subagents.map(s => ({
+		...s,
+		lastActivity: new Date(s.lastActivity),
+		phaseSince: new Date(s.phaseSince),
+	}));
+}
+
+export function describeToolInput(toolName: string, toolInput: Record<string, unknown>): string {
+	let detail: string | undefined;
+	switch (toolName) {
+		case 'Bash':
+			detail = toolInput.command as string | undefined;
+			break;
+		case 'Edit':
+		case 'MultiEdit':
+		case 'Write':
+		case 'Read':
+			detail = toolInput.file_path as string | undefined;
+			break;
+		case 'Grep':
+		case 'Glob':
+			detail = toolInput.pattern as string | undefined;
+			break;
+		case 'WebFetch':
+			detail = toolInput.url as string | undefined;
+			break;
+		case 'WebSearch':
+			detail = toolInput.query as string | undefined;
+			break;
+		case 'NotebookEdit':
+			detail = toolInput.notebook_path as string | undefined;
+			break;
+		case 'ExitPlanMode':
+			detail = extractPlanSummary(toolInput);
+			break;
+		case 'AskUserQuestion':
+			detail = extractQuestionDetails(toolInput)?.text;
+			break;
+	}
+
+	return detail != null ? `${toolName}(${detail})` : toolName;
+}
+
+/** Maps a Claude Code tool name to its UX-relevant prompt kind. `ExitPlanMode` and
+ *  `AskUserQuestion` are the two tools whose semantics differ from a regular permission
+ *  request — everything else falls through to the generic tool kind. */
+export function classifyPermissionKind(toolName: string): PendingPermissionKind {
+	switch (toolName) {
+		case 'ExitPlanMode':
+			return 'plan';
+		case 'AskUserQuestion':
+			return 'question';
+		default:
+			return 'tool';
+	}
+}
+
+/** Extracts a short, scannable summary from an ExitPlanMode plan body. Prefers the first
+ *  Markdown heading (stripped of leading `#`s) so the plan's title surfaces; falls back to
+ *  the first non-empty line if no heading appears. Capped at {@link summaryMaxLength} with an
+ *  ellipsis. */
+export function extractPlanSummary(toolInput: Record<string, unknown>): string | undefined {
+	const plan = toolInput.plan as string | undefined;
+	if (!plan) return undefined;
+
+	let heading: string | undefined;
+	let firstNonEmpty: string | undefined;
+	for (const line of plan.split(/\r?\n/)) {
+		const trimmed = line.trim();
+		if (!trimmed) continue;
+
+		if (trimmed.startsWith('#')) {
+			const stripped = trimmed.replace(/^#+\s*/, '').trim();
+			if (stripped) {
+				heading = stripped;
+				break;
+			}
+		}
+
+		firstNonEmpty ??= trimmed;
+	}
+
+	const summary = heading ?? firstNonEmpty;
+	if (!summary) return undefined;
+
+	return summary.length > summaryMaxLength ? `${summary.slice(0, summaryMaxLength).trimEnd()}…` : summary;
+}
+
+/** Extracts the leading question text + total question count from an AskUserQuestion call.
+ *  Returns undefined if the input doesn't carry a recognisable `questions` array. */
+export function extractQuestionDetails(
+	toolInput: Record<string, unknown>,
+): { text: string; count: number } | undefined {
+	const questions = toolInput.questions as ReadonlyArray<Record<string, unknown>> | undefined;
+	if (!Array.isArray(questions) || questions.length === 0) return undefined;
+
+	const first = questions[0]?.question;
+	if (typeof first !== 'string') return undefined;
+
+	const trimmed = first.trim();
+	if (!trimmed) return undefined;
+
+	const text = trimmed.length > summaryMaxLength ? `${trimmed.slice(0, summaryMaxLength).trimEnd()}…` : trimmed;
+	return { text: text, count: questions.length };
+}
+
+/** Returns the file path a file-mutating tool is targeting, or `undefined` for non-mutating /
+ *  non-file tools. `Read` is intentionally excluded — "working on a file" means writing to it.
+ *  Reads are surfaced separately via {@link getToolReadPath} so consumers (e.g. the treemap
+ *  activity overlay) can render reads with a distinct visual treatment. */
+export function getToolFilePath(toolName: string, toolInput: Record<string, unknown> | undefined): string | undefined {
+	if (toolInput == null) return undefined;
+
+	switch (toolName) {
+		case 'Edit':
+		case 'MultiEdit':
+		case 'Write':
+			return toolInput.file_path as string | undefined;
+		case 'NotebookEdit':
+			return toolInput.notebook_path as string | undefined;
+		default:
+			return undefined;
+	}
+}
+
+/** Returns the file path a read-only file tool is targeting, or `undefined` for non-read /
+ *  non-file tools. Mirrors {@link getToolFilePath} but for `Read`/`NotebookRead`. */
+export function getToolReadPath(toolName: string, toolInput: Record<string, unknown> | undefined): string | undefined {
+	if (toolInput == null) return undefined;
+
+	switch (toolName) {
+		case 'Read':
+			return toolInput.file_path as string | undefined;
+		case 'NotebookRead':
+			return toolInput.notebook_path as string | undefined;
+		default:
+			return undefined;
+	}
+}