kajji 0.1.0

package/src/commander/diff.ts

@@ -0,0 +1,186 @@
+import {
+	type PTYStreamingOptions,
+	execute,
+	executePTYStreaming,
+	executeStreaming,
+} from "./executor"
+
+const PROFILE = process.env.KAJJI_PROFILE === "1"
+
+function profile(label: string) {
+	if (!PROFILE) return () => {}
+	const start = performance.now()
+	return (extra?: string) => {
+		const ms = (performance.now() - start).toFixed(2)
+		console.error(`[PROFILE] ${label}: ${ms}ms${extra ? ` (${extra})` : ""}`)
+	}
+}
+
+export interface FetchDiffOptions {
+	cwd?: string
+	columns?: number
+	paths?: string[]
+}
+
+export async function fetchDiff(
+	changeId: string,
+	options: FetchDiffOptions = {},
+): Promise<string> {
+	const endTotal = profile(`fetchDiff(${changeId.slice(0, 8)})`)
+
+	const env: Record<string, string> = {}
+
+	if (options.columns) {
+		env.COLUMNS = String(options.columns)
+	}
+
+	const args = [
+		"diff",
+		"-r",
+		changeId,
+		"--color",
+		"always",
+		"--ignore-working-copy",
+	]
+
+	if (options.paths && options.paths.length > 0) {
+		args.push(...options.paths)
+	}
+
+	const result = await execute(args, { cwd: options.cwd, env })
+
+	if (!result.success) {
+		throw new Error(`jj diff failed: ${result.stderr}`)
+	}
+
+	endTotal()
+	return result.stdout
+}
+
+export interface StreamDiffCallbacks {
+	onUpdate: (content: string, lineCount: number, complete: boolean) => void
+	onError: (error: Error) => void
+}
+
+export function streamDiff(
+	changeId: string,
+	options: FetchDiffOptions,
+	callbacks: StreamDiffCallbacks,
+): { cancel: () => void } {
+	const endTotal = profile(`streamDiff(${changeId.slice(0, 8)})`)
+
+	const env: Record<string, string> = {}
+
+	if (options.columns) {
+		env.COLUMNS = String(options.columns)
+	}
+
+	const args = [
+		"diff",
+		"-r",
+		changeId,
+		"--color",
+		"always",
+		"--ignore-working-copy",
+	]
+
+	if (options.paths && options.paths.length > 0) {
+		args.push(...options.paths)
+	}
+
+	let firstUpdate = true
+	const endFirstChunk = profile("  first chunk")
+
+	return executeStreaming(
+		args,
+		{ cwd: options.cwd, env },
+		{
+			onChunk: (content, lineCount) => {
+				if (firstUpdate) {
+					endFirstChunk(`${lineCount} lines`)
+					firstUpdate = false
+				}
+				callbacks.onUpdate(content, lineCount, false)
+			},
+			onComplete: (result) => {
+				endTotal()
+				if (result.success) {
+					callbacks.onUpdate(
+						result.stdout,
+						result.stdout.split("\n").length,
+						true,
+					)
+				} else {
+					callbacks.onError(new Error(`jj diff failed: ${result.stderr}`))
+				}
+			},
+			onError: callbacks.onError,
+		},
+	)
+}
+
+export interface StreamDiffPTYOptions extends FetchDiffOptions {
+	cols?: number
+	rows?: number
+}
+
+export function streamDiffPTY(
+	changeId: string,
+	options: StreamDiffPTYOptions,
+	callbacks: StreamDiffCallbacks,
+): { cancel: () => void } {
+	const endTotal = profile(`streamDiffPTY(${changeId.slice(0, 8)})`)
+
+	const env: Record<string, string> = {}
+
+	if (options.columns) {
+		env.COLUMNS = String(options.columns)
+	}
+
+	const args = [
+		"diff",
+		"-r",
+		changeId,
+		"--color",
+		"always",
+		"--no-pager",
+		"--ignore-working-copy",
+	]
+
+	if (options.paths && options.paths.length > 0) {
+		args.push(...options.paths)
+	}
+
+	let firstUpdate = true
+	const endFirstChunk = profile("  PTY first chunk")
+
+	const ptyOptions: PTYStreamingOptions = {
+		cwd: options.cwd,
+		env,
+		cols: options.cols,
+		rows: options.rows,
+	}
+
+	return executePTYStreaming(args, ptyOptions, {
+		onChunk: (content, lineCount) => {
+			if (firstUpdate) {
+				endFirstChunk(`${lineCount} lines`)
+				firstUpdate = false
+			}
+			callbacks.onUpdate(content, lineCount, false)
+		},
+		onComplete: (result) => {
+			endTotal()
+			if (result.success) {
+				callbacks.onUpdate(
+					result.stdout,
+					result.stdout.split("\n").length,
+					true,
+				)
+			} else {
+				callbacks.onError(new Error(`jj diff failed: ${result.stderr}`))
+			}
+		},
+		onError: callbacks.onError,
+	})
+}

package/src/commander/executor.ts

@@ -0,0 +1,285 @@
+export interface ExecuteResult {
+	stdout: string
+	stderr: string
+	exitCode: number
+	success: boolean
+}
+
+export interface ExecuteOptions {
+	cwd?: string
+	env?: Record<string, string>
+	timeout?: number
+}
+
+const PROFILE = process.env.KAJJI_PROFILE === "1"
+
+function profile(label: string) {
+	if (!PROFILE) return () => {}
+	const start = performance.now()
+	return (extra?: string) => {
+		const ms = (performance.now() - start).toFixed(2)
+		console.error(`[PROFILE] ${label}: ${ms}ms${extra ? ` (${extra})` : ""}`)
+	}
+}
+
+export async function execute(
+	args: string[],
+	options: ExecuteOptions = {},
+): Promise<ExecuteResult> {
+	const endTotal = profile(`execute [jj ${args[0]}]`)
+	const endSpawn = profile("  spawn")
+
+	const proc = Bun.spawn(["jj", ...args], {
+		cwd: options.cwd,
+		env: {
+			...process.env,
+			// Prevent jj from opening editors
+			JJ_EDITOR: "true",
+			EDITOR: "true",
+			VISUAL: "true",
+			...options.env,
+		},
+		stdin: "ignore",
+		stdout: "pipe",
+		stderr: "pipe",
+	})
+	endSpawn()
+
+	const endRead = profile("  read stdout/stderr")
+	const [stdout, stderr] = await Promise.all([
+		new Response(proc.stdout).text(),
+		new Response(proc.stderr).text(),
+	])
+	endRead(`${stdout.length} chars, ${stdout.split("\n").length} lines`)
+
+	const endWait = profile("  wait for exit")
+	const exitCode = await proc.exited
+	endWait()
+
+	endTotal()
+
+	return {
+		stdout,
+		stderr,
+		exitCode,
+		success: exitCode === 0,
+	}
+}
+
+export async function executeWithColor(
+	args: string[],
+	options: ExecuteOptions = {},
+): Promise<ExecuteResult> {
+	return execute(["--color", "always", ...args], options)
+}
+
+export interface StreamingExecuteCallbacks {
+	onChunk: (content: string, lineCount: number) => void
+	onComplete: (result: ExecuteResult) => void
+	onError: (error: Error) => void
+}
+
+export function executeStreaming(
+	args: string[],
+	options: ExecuteOptions,
+	callbacks: StreamingExecuteCallbacks,
+): { cancel: () => void } {
+	const endTotal = profile(`executeStreaming [jj ${args[0]}]`)
+
+	const proc = Bun.spawn(["jj", ...args], {
+		cwd: options.cwd,
+		env: {
+			...process.env,
+			JJ_EDITOR: "true",
+			EDITOR: "true",
+			VISUAL: "true",
+			...options.env,
+		},
+		stdin: "ignore",
+		stdout: "pipe",
+		stderr: "pipe",
+	})
+
+	let cancelled = false
+	let stdout = ""
+	let lineCount = 0
+
+	const readStream = async () => {
+		try {
+			const reader = proc.stdout.getReader()
+			const decoder = new TextDecoder()
+			let chunkCount = 0
+
+			while (!cancelled) {
+				const { done, value } = await reader.read()
+				if (done) break
+
+				chunkCount++
+				const chunk = decoder.decode(value, { stream: true })
+				stdout += chunk
+
+				const newLines = chunk.split("\n").length - 1
+				lineCount += newLines
+
+				if (PROFILE) {
+					console.error(
+						`[PROFILE]   chunk #${chunkCount}: ${chunk.length} bytes, ${newLines} lines, total ${lineCount} lines`,
+					)
+				}
+
+				callbacks.onChunk(stdout, lineCount)
+
+				await new Promise((r) => setImmediate(r))
+			}
+
+			const stderr = await new Response(proc.stderr).text()
+			const exitCode = await proc.exited
+
+			endTotal()
+
+			if (!cancelled) {
+				callbacks.onComplete({
+					stdout,
+					stderr,
+					exitCode,
+					success: exitCode === 0,
+				})
+			}
+		} catch (error) {
+			if (!cancelled) {
+				callbacks.onError(
+					error instanceof Error ? error : new Error(String(error)),
+				)
+			}
+		}
+	}
+
+	readStream()
+
+	return {
+		cancel: () => {
+			cancelled = true
+			proc.kill()
+		},
+	}
+}
+
+export interface PTYStreamingOptions extends ExecuteOptions {
+	cols?: number
+	rows?: number
+}
+
+/**
+ * Execute jj command via PTY for true streaming output.
+ * Uses Bun.spawn with terminal option (requires Bun 1.3.5+).
+ * Falls back to regular executeStreaming on Windows or if PTY fails.
+ */
+export function executePTYStreaming(
+	args: string[],
+	options: PTYStreamingOptions,
+	callbacks: StreamingExecuteCallbacks,
+): { cancel: () => void } {
+	const endTotal = profile(`executePTYStreaming [jj ${args[0]}]`)
+
+	const cols = options.cols || 120
+	const rows = options.rows || 50
+	const cwd = options.cwd || process.cwd()
+
+	let cancelled = false
+	let stdout = ""
+	let lineCount = 0
+	let chunkCount = 0
+	let pendingUpdate = false
+	let lastUpdateTime = 0
+	const UPDATE_INTERVAL = 60
+	const startTime = performance.now()
+
+	try {
+		const proc = Bun.spawn(["jj", ...args], {
+			cwd,
+			env: {
+				...process.env,
+				JJ_EDITOR: "true",
+				EDITOR: "true",
+				VISUAL: "true",
+				...options.env,
+			},
+			terminal: {
+				cols,
+				rows,
+				data(_terminal, data) {
+					if (cancelled) return
+
+					chunkCount++
+					const chunk = data.toString()
+					stdout += chunk
+
+					if (chunkCount === 1 && PROFILE) {
+						const firstChunkTime = performance.now() - startTime
+						console.error(
+							`[PROFILE]   PTY first chunk: ${firstChunkTime.toFixed(0)}ms, ${chunk.length} bytes`,
+						)
+					}
+
+					let newLines = 0
+					for (let i = 0; i < chunk.length; i++) {
+						if (chunk[i] === "\n") newLines++
+					}
+					lineCount += newLines
+
+					if (PROFILE && chunkCount <= 5) {
+						console.error(
+							`[PROFILE]   PTY chunk #${chunkCount}: ${chunk.length} bytes, ${newLines} lines, total ${lineCount} lines`,
+						)
+					}
+
+					const now = performance.now()
+					const shouldUpdate =
+						chunkCount === 1 || now - lastUpdateTime >= UPDATE_INTERVAL
+					if (shouldUpdate) {
+						lastUpdateTime = now
+						callbacks.onChunk(stdout, lineCount)
+					} else if (!pendingUpdate) {
+						pendingUpdate = true
+						setTimeout(() => {
+							pendingUpdate = false
+							if (!cancelled) {
+								lastUpdateTime = performance.now()
+								callbacks.onChunk(stdout, lineCount)
+							}
+						}, UPDATE_INTERVAL)
+					}
+				},
+			},
+		})
+
+		proc.exited.then((exitCode) => {
+			if (cancelled) return
+
+			proc.terminal?.close()
+			endTotal()
+
+			callbacks.onComplete({
+				stdout,
+				stderr: "",
+				exitCode,
+				success: exitCode === 0,
+			})
+		})
+
+		return {
+			cancel: () => {
+				cancelled = true
+				proc.terminal?.close()
+				proc.kill()
+			},
+		}
+	} catch (error) {
+		if (PROFILE) {
+			console.error(
+				`[PROFILE]   PTY error: ${error}, falling back to pipe streaming`,
+			)
+		}
+		return executeStreaming(args, options, callbacks)
+	}
+}

package/src/commander/files.ts

@@ -0,0 +1,87 @@
+import { execute } from "./executor"
+import type { FileChange, FileStatus } from "./types"
+
+const STATUS_MAP: Record<string, FileStatus> = {
+	A: "added",
+	M: "modified",
+	D: "deleted",
+	R: "renamed",
+	C: "copied",
+}
+
+const BRACED_RENAME_REGEX = /^(.*)\{(.+) => (.+)\}(.*)$/
+
+function parseRenamedPath(rawPath: string): {
+	oldPath: string
+	newPath: string
+} {
+	const match = rawPath.match(BRACED_RENAME_REGEX)
+	if (match?.[2] && match[3]) {
+		const prefix = match[1] ?? ""
+		const oldPart = match[2]
+		const newPart = match[3]
+		const suffix = match[4] ?? ""
+		return {
+			oldPath: prefix + oldPart + suffix,
+			newPath: prefix + newPart + suffix,
+		}
+	}
+
+	const arrowIndex = rawPath.indexOf(" => ")
+	if (arrowIndex !== -1) {
+		return {
+			oldPath: rawPath.slice(0, arrowIndex),
+			newPath: rawPath.slice(arrowIndex + 4),
+		}
+	}
+
+	return { oldPath: rawPath, newPath: rawPath }
+}
+
+export function parseFileSummary(output: string): FileChange[] {
+	const files: FileChange[] = []
+
+	for (const line of output.split("\n")) {
+		const trimmed = line.trim()
+		if (!trimmed) continue
+
+		const statusChar = trimmed[0]
+		if (!statusChar) continue
+		const status = STATUS_MAP[statusChar]
+		if (!status) continue
+
+		const rawPath = trimmed.slice(2)
+
+		if (status === "renamed" || status === "copied") {
+			const { oldPath, newPath } = parseRenamedPath(rawPath)
+			files.push({ path: newPath, status, oldPath })
+		} else {
+			files.push({ path: rawPath, status })
+		}
+	}
+
+	return files
+}
+
+export interface FetchFilesOptions {
+	ignoreWorkingCopy?: boolean
+}
+
+export async function fetchFiles(
+	changeId: string,
+	options: FetchFilesOptions = {},
+): Promise<FileChange[]> {
+	const args = ["diff", "--summary", "-r", changeId]
+
+	if (options.ignoreWorkingCopy) {
+		args.push("--ignore-working-copy")
+	}
+
+	const result = await execute(args)
+
+	if (!result.success) {
+		throw new Error(`Failed to fetch files: ${result.stderr}`)
+	}
+
+	return parseFileSummary(result.stdout)
+}

package/src/commander/log.ts

@@ -0,0 +1,99 @@
+import { execute } from "./executor"
+import type { Commit } from "./types"
+
+const MARKER = "__LJ__"
+
+// Strip ANSI escape codes from a string (for extracting clean metadata)
+// biome-ignore lint/suspicious/noControlCharactersInRegex: intentional ANSI escape sequence
+const stripAnsi = (str: string) => str.replace(/\x1b\[[0-9;]*m/g, "")
+
+function buildTemplate(): string {
+	const styledDescription = `if(empty, label("empty", "(empty) "), "") ++ if(description.first_line(), description.first_line(), label("description placeholder", "(no description set)"))`
+
+	const prefix = [
+		`"${MARKER}"`,
+		"change_id.short()",
+		`"${MARKER}"`,
+		"commit_id.short()",
+		`"${MARKER}"`,
+		"immutable",
+		`"${MARKER}"`,
+		"empty",
+		`"${MARKER}"`,
+		styledDescription,
+		`"${MARKER}"`,
+		"author.name()",
+		`"${MARKER}"`,
+		"author.email()",
+		`"${MARKER}"`,
+		'author.timestamp().local().format("%Y-%m-%d %H:%M:%S %:z")',
+		`"${MARKER}"`,
+	].join(" ++ ")
+
+	return `${prefix} ++ builtin_log_compact`
+}
+
+export function parseLogOutput(output: string): Commit[] {
+	const commits: Commit[] = []
+	let current: Commit | null = null
+
+	for (const line of output.split("\n")) {
+		if (line.includes(MARKER)) {
+			const parts = line.split(MARKER)
+			if (parts.length >= 10) {
+				if (current) {
+					commits.push(current)
+				}
+
+				const gutter = parts[0] ?? ""
+				current = {
+					changeId: stripAnsi(parts[1] ?? ""),
+					commitId: stripAnsi(parts[2] ?? ""),
+					immutable: stripAnsi(parts[3] ?? "") === "true",
+					empty: stripAnsi(parts[4] ?? "") === "true",
+					description: stripAnsi(parts[5] ?? ""),
+					author: stripAnsi(parts[6] ?? ""),
+					authorEmail: stripAnsi(parts[7] ?? ""),
+					timestamp: stripAnsi(parts[8] ?? ""),
+					isWorkingCopy: gutter.includes("@"),
+					lines: [gutter + (parts[9] ?? "")],
+				}
+				continue
+			}
+		}
+
+		if (current && line.trim() !== "") {
+			current.lines.push(line)
+		}
+	}
+
+	if (current) {
+		commits.push(current)
+	}
+
+	return commits
+}
+
+export interface FetchLogOptions {
+	cwd?: string
+	revset?: string
+}
+
+export async function fetchLog(options?: FetchLogOptions): Promise<Commit[]> {
+	const template = buildTemplate()
+	const args = ["log", "--color", "always", "--template", template]
+
+	if (options?.revset) {
+		args.push("-r", options.revset)
+	}
+
+	const result = await execute(args, {
+		cwd: options?.cwd,
+	})
+
+	if (!result.success) {
+		throw new Error(`jj log failed: ${result.stderr}`)
+	}
+
+	return parseLogOutput(result.stdout)
+}