kajji 0.1.0 → 0.1.1

package/src/commander/bookmarks.ts

@@ -1,129 +0,0 @@
-import { execute } from "./executor"
-import type { OperationResult } from "./operations"
-
-export interface Bookmark {
-	name: string
-	changeId: string
-	commitId: string
-	description: string
-	isLocal: boolean
-	remote?: string
-}
-
-export interface FetchBookmarksOptions {
-	cwd?: string
-	allRemotes?: boolean
-}
-
-export async function fetchBookmarks(
-	options: FetchBookmarksOptions = {},
-): Promise<Bookmark[]> {
-	const args = ["bookmark", "list"]
-
-	if (options.allRemotes) {
-		args.push("--all-remotes")
-	}
-
-	const result = await execute(args, { cwd: options.cwd })
-
-	if (!result.success) {
-		throw new Error(`jj bookmark list failed: ${result.stderr}`)
-	}
-
-	return parseBookmarkOutput(result.stdout)
-}
-
-export function parseBookmarkOutput(output: string): Bookmark[] {
-	const bookmarks: Bookmark[] = []
-	const lines = output.split("\n")
-
-	for (const line of lines) {
-		if (!line.trim()) continue
-
-		const isRemote = line.startsWith("  @")
-
-		if (isRemote) {
-			const match = line.match(/^\s+@(\S+):\s+(\S+)\s+(\S+)\s*(.*)$/)
-			if (match) {
-				bookmarks.push({
-					name: match[1] ?? "",
-					changeId: match[2] ?? "",
-					commitId: match[3] ?? "",
-					description: match[4]?.trim() ?? "",
-					isLocal: false,
-					remote: match[1],
-				})
-			}
-		} else {
-			const match = line.match(/^(\S+):\s+(\S+)\s+(\S+)\s*(.*)$/)
-			if (match) {
-				bookmarks.push({
-					name: match[1] ?? "",
-					changeId: match[2] ?? "",
-					commitId: match[3] ?? "",
-					description: match[4]?.trim() ?? "",
-					isLocal: true,
-				})
-			}
-		}
-	}
-
-	return bookmarks
-}
-
-export async function jjBookmarkCreate(
-	name: string,
-	options?: { revision?: string },
-): Promise<OperationResult> {
-	const args = ["bookmark", "create", name]
-	if (options?.revision) {
-		args.push("-r", options.revision)
-	}
-	const result = await execute(args)
-	return {
-		...result,
-		command: `jj ${args.join(" ")}`,
-	}
-}
-
-export async function jjBookmarkDelete(name: string): Promise<OperationResult> {
-	const args = ["bookmark", "delete", name]
-	const result = await execute(args)
-	return {
-		...result,
-		command: `jj ${args.join(" ")}`,
-	}
-}
-
-export async function jjBookmarkRename(
-	oldName: string,
-	newName: string,
-): Promise<OperationResult> {
-	const args = ["bookmark", "rename", oldName, newName]
-	const result = await execute(args)
-	return {
-		...result,
-		command: `jj ${args.join(" ")}`,
-	}
-}
-
-export async function jjBookmarkForget(name: string): Promise<OperationResult> {
-	const args = ["bookmark", "forget", name]
-	const result = await execute(args)
-	return {
-		...result,
-		command: `jj ${args.join(" ")}`,
-	}
-}
-
-export async function jjBookmarkSet(
-	name: string,
-	revision: string,
-): Promise<OperationResult> {
-	const args = ["bookmark", "set", name, "-r", revision]
-	const result = await execute(args)
-	return {
-		...result,
-		command: `jj ${args.join(" ")}`,
-	}
-}

package/src/commander/diff.ts

@@ -1,186 +0,0 @@
-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

@@ -1,285 +0,0 @@
-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

@@ -1,87 +0,0 @@
-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)
-}