kajji 0.1.0 → 0.2.0

package/README.md

@@ -4,7 +4,7 @@
 
 A simple terminal UI for [Jujutsu](https://github.com/martinvonz/jj), inspired by [lazygit](https://github.com/jesseduffield/lazygit). Built with [OpenTUI](https://github.com/sst/opentui) and [SolidJS](https://www.solidjs.com/).
 
-![kajji screenshot](./kajji.png)
+![kajji screenshot](./assets/kajji.png)
 
 While learning jj I found myself coming back to lazygit to view diffs and traverse the changes I'd made quickly and easily, which has become increasingly important to me with the rise of coding agents. While there are existing jj TUIs, none quite scratched that lazygit itch.
 
@@ -20,35 +20,49 @@ Kajji is my attempt to bring the simplicity and polish of lazygit to jj, while a
 
 ## Features
 
-- **Full-color diffs** — works with difftastic, delta, or your configured diff tool
-- **Commit log** — navigate jj's graph with vim-style keybindings
-- **Bookmarks panel** — drill down into commits and files
-- **Collapsible file tree** — with status colors (A/M/D)
-- **Operation log** — view and restore from jj op history
-- **Git operations** — fetch and push
-- **Undo/redo** — with confirmation showing what will change
-- **Help palette** — press `?` for all keybindings with fuzzy search
+**Core jj operations:**
+- [x] View commit log with graph
+- [x] View diffs (difftastic, delta, etc.)
+- [x] New / edit / describe / squash / abandon
+- [x] Undo / redo with preview
+- [x] Bookmarks (create, delete, rename, move)
+- [x] Git fetch / push
+- [x] Operation log with restore
+- [ ] Rebase
+- [ ] Split
+- [ ] Conflict resolution
+
+**TUI polish:**
+- [x] Vim-style navigation (j/k, ctrl+u/d)
+- [x] Mouse support (click, double-click, scroll)
+- [x] Collapsible file tree with status colors
+- [x] Help palette with fuzzy search (`?`)
+- [ ] Multi-select for batch operations
+- [ ] Search and filter
 
 ## Installation
 
-> **Requirements**: [Bun](https://bun.sh) and [jj](https://github.com/martinvonz/jj)
+> **Requirements**: [jj](https://github.com/martinvonz/jj)
 
 ```bash
-# npm
-npm install -g kajji
+# recommended (standalone binary, no dependencies)
+curl -fsSL https://raw.githubusercontent.com/eliaskc/kajji/main/install.sh | bash
 
-# bun
+# or via package manager
+npm install -g kajji
 bun install -g kajji
-
-# pnpm
 pnpm add -g kajji
+yarn global add kajji
 
-# or run directly
+# or run directly without installing
+npx kajji
 bunx kajji
 ```
 
 ### From source
 
+> **Requirements**: [Bun](https://bun.sh)
+
 ```bash
 git clone https://github.com/eliaskc/kajji.git
 cd kajji
@@ -95,21 +109,10 @@ kajji
 | `c` | Create bookmark |
 | `d` | Delete bookmark |
 | `r` | Rename bookmark |
-| `b` | Create bookmark on commit |
-
-## Next up
-
-- Multi-select for batch rebase and squash
-- Search and filter (log, bookmarks, files)
-- Workspaces tab (monitor agent commits across workspaces)
-
-## Exploring
-
-- Interactive `jj split` (file/hunk selection)
-- Stacked PR creation and overview
-- Configuration (user config file, theme switching)
+| `b` | Set bookmark on commit |
+| `m` | Move bookmark |
 
-See [PROJECT](./context/PROJECT.md) for the full plan.
+See [PROJECT](./context/PROJECT.md) for the full roadmap.
 
 ## Built With
 

package/bin/kajji

@@ -0,0 +1,60 @@
+#!/usr/bin/env node
+
+const childProcess = require("child_process")
+const fs = require("fs")
+const path = require("path")
+const os = require("os")
+
+function run(target) {
+  const result = childProcess.spawnSync(target, process.argv.slice(2), {
+    stdio: "inherit",
+  })
+  if (result.error) {
+    console.error(result.error.message)
+    process.exit(1)
+  }
+  process.exit(typeof result.status === "number" ? result.status : 0)
+}
+
+const envPath = process.env.KAJJI_BIN_PATH
+if (envPath) {
+  run(envPath)
+}
+
+const scriptPath = fs.realpathSync(__filename)
+const scriptDir = path.dirname(scriptPath)
+
+const platformMap = { darwin: "darwin", linux: "linux" }
+const archMap = { x64: "x64", arm64: "arm64" }
+
+const platform = platformMap[os.platform()] || os.platform()
+const arch = archMap[os.arch()] || os.arch()
+const base = "kajji-" + platform + "-" + arch
+
+function findBinary(startDir) {
+  let current = startDir
+  for (;;) {
+    const modules = path.join(current, "node_modules")
+    if (fs.existsSync(modules)) {
+      for (const entry of fs.readdirSync(modules)) {
+        if (!entry.startsWith(base)) continue
+        const candidate = path.join(modules, entry, "bin", "kajji")
+        if (fs.existsSync(candidate)) return candidate
+      }
+    }
+    const parent = path.dirname(current)
+    if (parent === current) return
+    current = parent
+  }
+}
+
+const resolved = findBinary(scriptDir)
+if (!resolved) {
+  console.error(
+    `Could not find kajji binary for your platform (${platform}-${arch}).\n` +
+    `Try installing the platform package: npm install ${base}`
+  )
+  process.exit(1)
+}
+
+run(resolved)

package/package.json

@@ -1,56 +1,36 @@
 {
-	"name": "kajji",
-	"version": "0.1.0",
-	"description": "A terminal UI for Jujutsu: the rudder for your jj",
-	"type": "module",
-	"engines": {
-		"bun": ">=1.0.0"
-	},
-	"bin": {
-		"kajji": "./bin/kajji.js"
-	},
-	"files": ["bin", "src"],
-	"scripts": {
-		"dev": "NODE_ENV=development bun --watch run src/index.tsx",
-		"test": "bun test",
-		"check": "tsc --noEmit",
-		"lint": "biome check .",
-		"lint:fix": "biome check --write ."
-	},
-	"devDependencies": {
-		"@biomejs/biome": "^1.9.4",
-		"@types/bun": "latest"
-	},
-	"peerDependencies": {
-		"typescript": "^5"
-	},
-	"dependencies": {
-		"@babel/core": "^7.28.5",
-		"@babel/preset-typescript": "^7.28.5",
-		"@opentui/core": "^0.1.66",
-		"@opentui/solid": "^0.1.66",
-		"babel-preset-solid": "1.9.9",
-		"fuzzysort": "^3.1.0",
-		"ghostty-opentui": "^1.3.11",
-		"solid-js": "1.9.9"
-	},
-	"keywords": [
-		"jj",
-		"jujutsu",
-		"tui",
-		"terminal",
-		"cli",
-		"vcs",
-		"version-control"
-	],
-	"repository": {
-		"type": "git",
-		"url": "git+https://github.com/eliaskc/kajji.git"
-	},
-	"homepage": "https://github.com/eliaskc/kajji#readme",
-	"bugs": {
-		"url": "https://github.com/eliaskc/kajji/issues"
-	},
-	"author": "eliaskc",
-	"license": "MIT"
-}
+  "name": "kajji",
+  "version": "0.2.0",
+  "description": "A terminal UI for Jujutsu: the rudder for your jj",
+  "bin": {
+    "kajji": "./bin/kajji"
+  },
+  "scripts": {
+    "postinstall": "node ./script/postinstall.mjs"
+  },
+  "optionalDependencies": {
+    "kajji-darwin-arm64": "0.2.0",
+    "kajji-darwin-x64": "0.2.0",
+    "kajji-linux-x64": "0.2.0",
+    "kajji-linux-arm64": "0.2.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/eliaskc/kajji.git"
+  },
+  "homepage": "https://github.com/eliaskc/kajji#readme",
+  "bugs": {
+    "url": "https://github.com/eliaskc/kajji/issues"
+  },
+  "keywords": [
+    "jj",
+    "jujutsu",
+    "tui",
+    "terminal",
+    "cli",
+    "vcs",
+    "version-control"
+  ],
+  "author": "eliaskc",
+  "license": "MIT"
+}

package/script/postinstall.mjs

@@ -0,0 +1,50 @@
+#!/usr/bin/env node
+
+import fs from "node:fs"
+import os from "node:os"
+import path from "node:path"
+import { fileURLToPath } from "node:url"
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url))
+
+const platformMap = { darwin: "darwin", linux: "linux" }
+const archMap = { x64: "x64", arm64: "arm64" }
+
+const platform = platformMap[os.platform()]
+const arch = archMap[os.arch()]
+
+if (!platform || !arch) {
+	console.log(`Unsupported platform: ${os.platform()}-${os.arch()}`)
+	process.exit(0)
+}
+
+const packageName = `kajji-${platform}-${arch}`
+
+let packageDir
+try {
+	const packageJsonPath = require.resolve(`${packageName}/package.json`, {
+		paths: [path.join(__dirname, "..")],
+	})
+	packageDir = path.dirname(packageJsonPath)
+} catch {
+	console.log(`Platform package ${packageName} not found, skipping symlink`)
+	process.exit(0)
+}
+
+const binaryPath = path.join(packageDir, "bin", "kajji")
+const targetPath = path.join(__dirname, "..", "bin", "kajji-binary")
+
+if (!fs.existsSync(binaryPath)) {
+	console.log(`Binary not found at ${binaryPath}`)
+	process.exit(0)
+}
+
+try {
+	if (fs.existsSync(targetPath)) {
+		fs.unlinkSync(targetPath)
+	}
+	fs.symlinkSync(binaryPath, targetPath)
+	console.log(`kajji binary linked: ${targetPath} -> ${binaryPath}`)
+} catch (err) {
+	console.log(`Could not create symlink: ${err.message}`)
+}

package/bin/kajji.js

@@ -1,2 +0,0 @@
-#!/usr/bin/env bun
-import "../src/index.tsx"

package/src/App.tsx

@@ -1,229 +0,0 @@
-import { useRenderer } from "@opentui/solid"
-import { onMount } from "solid-js"
-import { jjGitFetch, jjGitPush } from "./commander/operations"
-import { Layout } from "./components/Layout"
-import { HelpModal } from "./components/modals/HelpModal"
-import { BookmarksPanel } from "./components/panels/BookmarksPanel"
-import { LogPanel } from "./components/panels/LogPanel"
-import { MainArea } from "./components/panels/MainArea"
-import { CommandProvider, useCommand } from "./context/command"
-import { CommandLogProvider, useCommandLog } from "./context/commandlog"
-import { DialogContainer, DialogProvider, useDialog } from "./context/dialog"
-import { FocusProvider, useFocus } from "./context/focus"
-import { KeybindProvider } from "./context/keybind"
-import { LoadingProvider, useLoading } from "./context/loading"
-import { SyncProvider, useSync } from "./context/sync"
-import { ThemeProvider } from "./context/theme"
-
-function AppContent() {
-	const renderer = useRenderer()
-	const { loadLog, loadBookmarks, refresh } = useSync()
-	const focus = useFocus()
-	const command = useCommand()
-	const dialog = useDialog()
-	const commandLog = useCommandLog()
-	const globalLoading = useLoading()
-
-	onMount(() => {
-		loadLog()
-		loadBookmarks()
-
-		renderer.console.keyBindings = [
-			{ name: "y", ctrl: true, action: "copy-selection" },
-		]
-		renderer.console.onCopySelection = (text) => {
-			const proc = Bun.spawn(["pbcopy"], { stdin: "pipe" })
-			proc.stdin.write(text)
-			proc.stdin.end()
-		}
-	})
-
-	command.register(() => [
-		{
-			id: "global.quit",
-			title: "quit",
-			keybind: "quit",
-			context: "global",
-			type: "action",
-			onSelect: () => {
-				renderer.destroy()
-				process.exit(0)
-			},
-		},
-		...(Bun.env.NODE_ENV === "development"
-			? [
-					{
-						id: "global.toggle_console",
-						title: "toggle console",
-						keybind: "toggle_console" as const,
-						context: "global" as const,
-						type: "action" as const,
-						onSelect: () => renderer.console.toggle(),
-					},
-				]
-			: []),
-		{
-			id: "global.focus_next",
-			title: "focus next panel",
-			keybind: "focus_next",
-			context: "global",
-			type: "navigation",
-			visibility: "help-only",
-			onSelect: () => focus.cycleNext(),
-		},
-		{
-			id: "global.focus_prev",
-			title: "focus previous panel",
-			keybind: "focus_prev",
-			context: "global",
-			type: "navigation",
-			visibility: "help-only",
-			onSelect: () => focus.cyclePrev(),
-		},
-		{
-			id: "global.focus_panel_1",
-			title: "focus log panel",
-			keybind: "focus_panel_1",
-			context: "global",
-			type: "navigation",
-			visibility: "help-only",
-			onSelect: () => focus.setPanel("log"),
-		},
-		{
-			id: "global.focus_panel_2",
-			title: "focus refs panel",
-			keybind: "focus_panel_2",
-			context: "global",
-			type: "navigation",
-			visibility: "help-only",
-			onSelect: () => focus.setPanel("refs"),
-		},
-		{
-			id: "global.focus_panel_3",
-			title: "focus detail panel",
-			keybind: "focus_panel_3",
-			context: "global",
-			type: "navigation",
-			visibility: "help-only",
-			onSelect: () => focus.setPanel("detail"),
-		},
-		{
-			id: "global.help",
-			title: "help",
-			keybind: "help",
-			context: "global",
-			type: "action",
-			onSelect: () =>
-				dialog.toggle("help", () => <HelpModal />, {
-					hints: [{ key: "enter", label: "execute" }],
-				}),
-		},
-		{
-			id: "global.refresh",
-			title: "refresh",
-			keybind: "refresh",
-			context: "global",
-			type: "action",
-			visibility: "help-only",
-			onSelect: () => refresh(),
-		},
-		{
-			id: "global.git_fetch",
-			title: "git fetch",
-			keybind: "jj_git_fetch",
-			context: "global",
-			type: "git",
-			visibility: "help-only",
-			onSelect: async () => {
-				const result = await globalLoading.run("Fetching...", () =>
-					jjGitFetch(),
-				)
-				commandLog.addEntry(result)
-				if (result.success) {
-					refresh()
-				}
-			},
-		},
-		{
-			id: "global.git_fetch_all",
-			title: "git fetch all",
-			keybind: "jj_git_fetch_all",
-			context: "global",
-			type: "git",
-			visibility: "help-only",
-			onSelect: async () => {
-				const result = await globalLoading.run("Fetching all...", () =>
-					jjGitFetch({ allRemotes: true }),
-				)
-				commandLog.addEntry(result)
-				if (result.success) {
-					refresh()
-				}
-			},
-		},
-		{
-			id: "global.git_push",
-			title: "git push",
-			keybind: "jj_git_push",
-			context: "global",
-			type: "git",
-			visibility: "help-only",
-			onSelect: async () => {
-				const result = await globalLoading.run("Pushing...", () => jjGitPush())
-				commandLog.addEntry(result)
-				if (result.success) {
-					refresh()
-				}
-			},
-		},
-		{
-			id: "global.git_push_all",
-			title: "git push all",
-			keybind: "jj_git_push_all",
-			context: "global",
-			type: "git",
-			visibility: "help-only",
-			onSelect: async () => {
-				const result = await globalLoading.run("Pushing all...", () =>
-					jjGitPush({ all: true }),
-				)
-				commandLog.addEntry(result)
-				if (result.success) {
-					refresh()
-				}
-			},
-		},
-	])
-
-	return (
-		<DialogContainer>
-			<Layout
-				top={<LogPanel />}
-				bottom={<BookmarksPanel />}
-				right={<MainArea />}
-			/>
-		</DialogContainer>
-	)
-}
-
-export function App() {
-	return (
-		<ThemeProvider>
-			<FocusProvider>
-				<LoadingProvider>
-					<SyncProvider>
-						<KeybindProvider>
-							<CommandLogProvider>
-								<DialogProvider>
-									<CommandProvider>
-										<AppContent />
-									</CommandProvider>
-								</DialogProvider>
-							</CommandLogProvider>
-						</KeybindProvider>
-					</SyncProvider>
-				</LoadingProvider>
-			</FocusProvider>
-		</ThemeProvider>
-	)
-}

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(" ")}`,
-	}
-}