stage-tui 1.0.7

package/src/app.tsx

@@ -0,0 +1,127 @@
+import { useRenderer, useTerminalDimensions } from "@opentui/react"
+
+import type { StageConfig } from "./config"
+import { BranchDialog } from "./ui/components/branch-dialog"
+import { CommitHistoryDialog } from "./ui/components/commit-history-dialog"
+import { useGitTuiController } from "./hooks/use-git-tui-controller"
+import { CommitDialog } from "./ui/components/commit-dialog"
+import { DiffWorkspace } from "./ui/components/diff-workspace"
+import { FooterBar } from "./ui/components/footer-bar"
+import { ShortcutsDialog } from "./ui/components/shortcuts-dialog"
+import { TopBar } from "./ui/components/top-bar"
+import { resolveUiTheme } from "./ui/theme"
+
+type AppProps = {
+  config: StageConfig
+}
+
+export function App({ config }: AppProps) {
+  const renderer = useRenderer()
+  const { width: terminalWidth = 0, height: terminalHeight = 0 } = useTerminalDimensions()
+  const theme = resolveUiTheme(config.ui.theme)
+  const controller = useGitTuiController(renderer, config)
+  const activeScreen = controller.branchDialogOpen
+    ? "branch"
+    : controller.commitDialogOpen
+      ? "commit"
+      : controller.historyDialogOpen
+        ? "history"
+        : controller.shortcutsDialogOpen
+          ? "shortcuts"
+          : "main"
+
+  return (
+    <box
+      style={{
+        width: "100%",
+        height: "100%",
+        flexDirection: "column",
+      }}
+    >
+      <TopBar
+        currentBranch={controller.currentBranch}
+        tracking={controller.tracking}
+        theme={theme}
+      />
+
+      {activeScreen === "main" ? (
+        <DiffWorkspace
+          fileRows={controller.fileRows}
+          fileIndex={controller.fileIndex}
+          selectedFilePath={controller.selectedFilePath}
+          focus={controller.focus}
+          terminalWidth={terminalWidth}
+          terminalHeight={terminalHeight}
+          diffText={controller.diffText}
+          diffMessage={controller.diffMessage}
+          diffFiletype={controller.diffFiletype}
+          diffView={config.ui.diffView}
+          theme={theme}
+        />
+      ) : null}
+
+      {activeScreen === "branch" ? (
+        <BranchDialog
+          open={true}
+          mode={controller.branchDialogMode}
+          focus={controller.focus}
+          currentBranch={controller.currentBranch}
+          branchOptions={controller.branchOptions}
+          branchOptionsKey={controller.branchOptionsKey}
+          branchIndex={controller.branchIndex}
+          onBranchChange={controller.onBranchDialogChange}
+          branchStrategyOptions={controller.branchStrategyOptions}
+          branchStrategyIndex={controller.branchStrategyIndex}
+          onBranchStrategyChange={controller.onBranchStrategyChange}
+          branchName={controller.newBranchName}
+          branchNameRef={controller.branchNameRef}
+          onBranchNameInput={controller.onBranchNameInput}
+          theme={theme}
+        />
+      ) : null}
+
+      {activeScreen === "commit" ? (
+        <CommitDialog
+          open={true}
+          focus={controller.focus}
+          summary={controller.summary}
+          descriptionRenderKey={controller.descriptionRenderKey}
+          summaryRef={controller.summaryRef}
+          descriptionRef={controller.descriptionRef}
+          onSummaryInput={controller.onSummaryInput}
+          theme={theme}
+        />
+      ) : null}
+
+      {activeScreen === "history" ? (
+        <CommitHistoryDialog
+          open={true}
+          mode={controller.historyMode}
+          focus={controller.focus}
+          currentBranch={controller.currentBranch}
+          commitOptions={controller.commitOptions}
+          commitIndex={controller.commitIndex}
+          onCommitChange={controller.onCommitIndexChange}
+          actionOptions={controller.actionOptions}
+          actionIndex={controller.actionIndex}
+          onActionChange={controller.onActionIndexChange}
+          selectedCommitTitle={controller.selectedCommitTitle}
+          theme={theme}
+        />
+      ) : null}
+
+      {activeScreen === "shortcuts" ? (
+        <ShortcutsDialog open={true} aiCommitEnabled={config.ai.enabled} theme={theme} />
+      ) : null}
+
+      <FooterBar
+        statusMessage={controller.statusMessage}
+        showShortcutsHint={config.ui.showShortcutsHint}
+        terminalWidth={terminalWidth}
+        fatalError={controller.fatalError}
+        isBusy={controller.isBusy}
+        theme={theme}
+      />
+    </box>
+  )
+}

package/src/config-file.ts

@@ -0,0 +1,40 @@
+import { mkdir, writeFile } from "node:fs/promises"
+import { dirname } from "node:path"
+
+import type { StageConfig } from "./config"
+
+export async function ensureUserConfigFile(configPath: string, defaults: StageConfig): Promise<void> {
+  await mkdir(dirname(configPath), { recursive: true })
+  try {
+    await writeFile(configPath, createDefaultConfigToml(defaults), { flag: "wx" })
+  } catch (error) {
+    const err = error as NodeJS.ErrnoException
+    if (err.code !== "EEXIST") throw error
+  }
+}
+
+function createDefaultConfigToml(defaults: StageConfig): string {
+  return [
+    "[ui]",
+    `diff_view = "${defaults.ui.diffView}"`,
+    `theme = "${defaults.ui.theme}"`,
+    `hide_whitespace_changes = ${defaults.ui.hideWhitespaceChanges}`,
+    `show_shortcuts_hint = ${defaults.ui.showShortcutsHint}`,
+    "",
+    "[history]",
+    `limit = ${defaults.history.limit}`,
+    "",
+    "[git]",
+    `auto_stage_on_commit = ${defaults.git.autoStageOnCommit}`,
+    "",
+    "[ai]",
+    `enabled = ${defaults.ai.enabled}`,
+    `provider = "${defaults.ai.provider}"`,
+    'api_key = ""',
+    `model = "${defaults.ai.model}"`,
+    `reasoning_effort = "${defaults.ai.reasoningEffort}"`,
+    `max_files = ${defaults.ai.maxFiles}`,
+    `max_chars_per_file = ${defaults.ai.maxCharsPerFile}`,
+    "",
+  ].join("\n")
+}

package/src/config.ts

@@ -0,0 +1,283 @@
+import { homedir } from "node:os"
+import { join, resolve } from "node:path"
+
+import { ensureUserConfigFile } from "./config-file"
+
+export type StageConfig = {
+  ui: {
+    diffView: "unified" | "split"
+    theme: "auto" | "dark" | "light"
+    hideWhitespaceChanges: boolean
+    showShortcutsHint: boolean
+  }
+  history: {
+    limit: number
+  }
+  git: {
+    autoStageOnCommit: boolean
+  }
+  ai: {
+    enabled: boolean
+    provider: "cerebras"
+    apiKey: string
+    model: string
+    reasoningEffort: "low" | "medium" | "high"
+    maxFiles: number
+    maxCharsPerFile: number
+  }
+}
+
+export type ResolvedStageConfig = {
+  config: StageConfig
+  source: string
+}
+
+export const DEFAULT_STAGE_CONFIG: StageConfig = {
+  ui: {
+    diffView: "unified",
+    theme: "auto",
+    hideWhitespaceChanges: true,
+    showShortcutsHint: true,
+  },
+  history: {
+    limit: 200,
+  },
+  git: {
+    autoStageOnCommit: true,
+  },
+  ai: {
+    enabled: false,
+    provider: "cerebras",
+    apiKey: "",
+    model: "gpt-oss-120b",
+    reasoningEffort: "low",
+    maxFiles: 32,
+    maxCharsPerFile: 4000,
+  },
+}
+
+export async function loadStageConfig(cwd: string): Promise<ResolvedStageConfig> {
+  const envPath = process.env.STAGE_CONFIG?.trim()
+  if (envPath) {
+    const explicitPath = resolve(cwd, envPath)
+    const file = Bun.file(explicitPath)
+    if (!(await file.exists())) {
+      throw new Error(`Config file from STAGE_CONFIG was not found: ${explicitPath}`)
+    }
+    const raw = await file.text()
+    return {
+      config: parseStageConfigToml(raw, explicitPath),
+      source: explicitPath,
+    }
+  }
+
+  const localPath = resolve(cwd, ".stage-manager.toml")
+  const localFile = Bun.file(localPath)
+  if (await localFile.exists()) {
+    const raw = await localFile.text()
+    return {
+      config: parseStageConfigToml(raw, localPath),
+      source: localPath,
+    }
+  }
+
+  const userPath = getUserConfigPath()
+  const userFile = Bun.file(userPath)
+  if (await userFile.exists()) {
+    const raw = await userFile.text()
+    return {
+      config: parseStageConfigToml(raw, userPath),
+      source: userPath,
+    }
+  }
+
+  await ensureUserConfigFile(userPath, DEFAULT_STAGE_CONFIG)
+  const createdRaw = await Bun.file(userPath).text()
+  return {
+    config: parseStageConfigToml(createdRaw, userPath),
+    source: userPath,
+  }
+}
+
+export function getUserConfigPath(): string {
+  const xdg = process.env.XDG_CONFIG_HOME?.trim()
+  const configRoot = xdg ? xdg : join(homedir(), ".config")
+  return join(configRoot, "stage-manager", "config.toml")
+}
+
+function parseStageConfigToml(raw: string, sourcePath: string): StageConfig {
+  let parsed: unknown
+  try {
+    parsed = Bun.TOML.parse(raw)
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error)
+    throw new Error(`Invalid TOML in ${sourcePath}: ${message}`)
+  }
+
+  const root = asRecord(parsed, `Config root in ${sourcePath}`)
+  assertNoUnknownKeys(root, ["ui", "history", "git", "ai"], `Config root in ${sourcePath}`)
+
+  const config = cloneConfig(DEFAULT_STAGE_CONFIG)
+
+  if (root.ui !== undefined) {
+    const ui = asRecord(root.ui, `[ui] in ${sourcePath}`)
+    assertNoUnknownKeys(ui, ["diff_view", "theme", "hide_whitespace_changes", "show_shortcuts_hint"], `[ui] in ${sourcePath}`)
+
+    if (ui.diff_view !== undefined) {
+      if (ui.diff_view !== "unified" && ui.diff_view !== "split") {
+        throw new Error(`Invalid value for ui.diff_view in ${sourcePath}. Expected "unified" or "split".`)
+      }
+      config.ui.diffView = ui.diff_view
+    }
+
+    if (ui.theme !== undefined) {
+      if (ui.theme !== "auto" && ui.theme !== "dark" && ui.theme !== "light") {
+        throw new Error(`Invalid value for ui.theme in ${sourcePath}. Expected "auto", "dark", or "light".`)
+      }
+      config.ui.theme = ui.theme
+    }
+
+    if (ui.hide_whitespace_changes !== undefined) {
+      config.ui.hideWhitespaceChanges = asBoolean(ui.hide_whitespace_changes, `ui.hide_whitespace_changes in ${sourcePath}`)
+    }
+
+    if (ui.show_shortcuts_hint !== undefined) {
+      config.ui.showShortcutsHint = asBoolean(ui.show_shortcuts_hint, `ui.show_shortcuts_hint in ${sourcePath}`)
+    }
+  }
+
+  if (root.history !== undefined) {
+    const history = asRecord(root.history, `[history] in ${sourcePath}`)
+    assertNoUnknownKeys(history, ["limit"], `[history] in ${sourcePath}`)
+
+    if (history.limit !== undefined) {
+      const limit = asInteger(history.limit, `history.limit in ${sourcePath}`)
+      if (limit <= 0) {
+        throw new Error(`history.limit in ${sourcePath} must be greater than 0.`)
+      }
+      config.history.limit = limit
+    }
+  }
+
+  if (root.git !== undefined) {
+    const git = asRecord(root.git, `[git] in ${sourcePath}`)
+    assertNoUnknownKeys(git, ["auto_stage_on_commit"], `[git] in ${sourcePath}`)
+
+    if (git.auto_stage_on_commit !== undefined) {
+      config.git.autoStageOnCommit = asBoolean(git.auto_stage_on_commit, `git.auto_stage_on_commit in ${sourcePath}`)
+    }
+  }
+
+  if (root.ai !== undefined) {
+    const ai = asRecord(root.ai, `[ai] in ${sourcePath}`)
+    assertNoUnknownKeys(ai, ["enabled", "provider", "api_key", "model", "reasoning_effort", "max_files", "max_chars_per_file"], `[ai] in ${sourcePath}`)
+
+    if (ai.enabled !== undefined) {
+      config.ai.enabled = asBoolean(ai.enabled, `ai.enabled in ${sourcePath}`)
+    }
+
+    if (ai.provider !== undefined) {
+      if (ai.provider !== "cerebras") {
+        throw new Error(`Invalid value for ai.provider in ${sourcePath}. Expected "cerebras".`)
+      }
+      config.ai.provider = ai.provider
+    }
+
+    if (ai.api_key !== undefined) {
+      if (typeof ai.api_key !== "string") {
+        throw new Error(`ai.api_key in ${sourcePath} must be a string.`)
+      }
+      config.ai.apiKey = ai.api_key.trim()
+    }
+
+    if (ai.model !== undefined) {
+      if (typeof ai.model !== "string" || !ai.model.trim()) {
+        throw new Error(`ai.model in ${sourcePath} must be a non-empty string.`)
+      }
+      config.ai.model = ai.model.trim()
+    }
+
+    if (ai.reasoning_effort !== undefined) {
+      if (ai.reasoning_effort !== "low" && ai.reasoning_effort !== "medium" && ai.reasoning_effort !== "high") {
+        throw new Error(`Invalid value for ai.reasoning_effort in ${sourcePath}. Expected "low", "medium", or "high".`)
+      }
+      config.ai.reasoningEffort = ai.reasoning_effort
+    }
+
+    if (ai.max_files !== undefined) {
+      const maxFiles = asInteger(ai.max_files, `ai.max_files in ${sourcePath}`)
+      if (maxFiles <= 0) {
+        throw new Error(`ai.max_files in ${sourcePath} must be greater than 0.`)
+      }
+      config.ai.maxFiles = maxFiles
+    }
+
+    if (ai.max_chars_per_file !== undefined) {
+      const maxCharsPerFile = asInteger(ai.max_chars_per_file, `ai.max_chars_per_file in ${sourcePath}`)
+      if (maxCharsPerFile <= 0) {
+        throw new Error(`ai.max_chars_per_file in ${sourcePath} must be greater than 0.`)
+      }
+      config.ai.maxCharsPerFile = maxCharsPerFile
+    }
+  }
+
+  if (config.ai.enabled && !config.ai.apiKey) {
+    throw new Error(`ai.enabled is true in ${sourcePath}, but ai.api_key is empty.`)
+  }
+
+  return config
+}
+
+function cloneConfig(config: StageConfig): StageConfig {
+  return {
+    ui: {
+      diffView: config.ui.diffView,
+      theme: config.ui.theme,
+      hideWhitespaceChanges: config.ui.hideWhitespaceChanges,
+      showShortcutsHint: config.ui.showShortcutsHint,
+    },
+    history: {
+      limit: config.history.limit,
+    },
+    git: {
+      autoStageOnCommit: config.git.autoStageOnCommit,
+    },
+    ai: {
+      enabled: config.ai.enabled,
+      provider: config.ai.provider,
+      apiKey: config.ai.apiKey,
+      model: config.ai.model,
+      reasoningEffort: config.ai.reasoningEffort,
+      maxFiles: config.ai.maxFiles,
+      maxCharsPerFile: config.ai.maxCharsPerFile,
+    },
+  }
+}
+
+function asRecord(value: unknown, label: string): Record<string, unknown> {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new Error(`${label} must be a table/object.`)
+  }
+  return value as Record<string, unknown>
+}
+
+function asBoolean(value: unknown, label: string): boolean {
+  if (typeof value !== "boolean") {
+    throw new Error(`${label} must be a boolean.`)
+  }
+  return value
+}
+
+function asInteger(value: unknown, label: string): number {
+  if (typeof value !== "number" || !Number.isInteger(value)) {
+    throw new Error(`${label} must be an integer.`)
+  }
+  return value
+}
+
+function assertNoUnknownKeys(record: Record<string, unknown>, knownKeys: string[], label: string): void {
+  const unknown = Object.keys(record).filter((key) => !knownKeys.includes(key))
+  if (unknown.length > 0) {
+    throw new Error(`${label} has unsupported keys: ${unknown.join(", ")}`)
+  }
+}

package/src/git-branch-name.ts

@@ -0,0 +1,13 @@
+export function normalizeBranchName(input: string): string {
+  const normalized = input
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9/]+/g, "-")
+    .replace(/-+/g, "-")
+    .replace(/\/+/g, "/")
+    .replace(/\/-/g, "/")
+    .replace(/-\//g, "/")
+    .replace(/^[-/]+|[-/]+$/g, "")
+
+  return normalized
+}

package/src/git-process.ts

@@ -0,0 +1,25 @@
+export type GitCommandResult = {
+  code: number
+  stdout: string
+  stderr: string
+}
+
+export async function runGitRaw(cwd: string, args: string[]): Promise<GitCommandResult> {
+  const proc = Bun.spawn(["git", ...args], {
+    cwd,
+    stdout: "pipe",
+    stderr: "pipe",
+  })
+
+  const [stdout, stderr, code] = await Promise.all([
+    new Response(proc.stdout).text(),
+    new Response(proc.stderr).text(),
+    proc.exited,
+  ])
+
+  return {
+    code,
+    stdout: stdout.trimEnd(),
+    stderr: stderr.trimEnd(),
+  }
+}

package/src/git-status-parser.ts

@@ -0,0 +1,103 @@
+import type { ChangedFile } from "./git"
+
+const STATUS_NAME: Record<string, string> = {
+  " ": "clean",
+  M: "modified",
+  A: "added",
+  D: "deleted",
+  R: "renamed",
+  C: "copied",
+  U: "unmerged",
+  "?": "untracked",
+}
+
+export function parseBranchLine(line: string): {
+  branch: string
+  upstream: string | null
+  ahead: number
+  behind: number
+} {
+  if (!line.startsWith("##")) {
+    return { branch: "unknown", upstream: null, ahead: 0, behind: 0 }
+  }
+
+  const raw = line.slice(2).trim()
+  if (raw.startsWith("No commits yet on ")) {
+    return {
+      branch: raw.replace("No commits yet on ", "").trim(),
+      upstream: null,
+      ahead: 0,
+      behind: 0,
+    }
+  }
+
+  if (raw.startsWith("HEAD")) {
+    return { branch: "detached", upstream: null, ahead: 0, behind: 0 }
+  }
+
+  const [localPart, trackingPart] = raw.split("...")
+  const branch = (localPart ?? "unknown").trim()
+  let upstream: string | null = null
+  let ahead = 0
+  let behind = 0
+
+  if (trackingPart) {
+    const match = trackingPart.match(/^([^\s]+)(?: \[(.+)\])?$/)
+    if (match) {
+      upstream = match[1] ?? null
+      const tracking = match[2] ?? ""
+      for (const token of tracking.split(",").map((item) => item.trim())) {
+        if (token.startsWith("ahead ")) {
+          ahead = Number(token.slice("ahead ".length)) || 0
+        } else if (token.startsWith("behind ")) {
+          behind = Number(token.slice("behind ".length)) || 0
+        }
+      }
+    } else {
+      upstream = trackingPart.trim() || null
+    }
+  }
+
+  return { branch, upstream, ahead, behind }
+}
+
+export function parseChangedFiles(lines: string[]): ChangedFile[] {
+  return lines
+    .map((line) => {
+      const indexStatus = line[0] ?? " "
+      const worktreeStatus = line[1] ?? " "
+      const pathPart = line.slice(3).trim()
+      const path = pathPart.includes(" -> ") ? (pathPart.split(" -> ").pop() ?? "").trim() : pathPart
+      if (!path) return null
+
+      const untracked = indexStatus === "?" && worktreeStatus === "?"
+      const staged = !untracked && indexStatus !== " "
+      const unstaged = !untracked && worktreeStatus !== " "
+
+      return {
+        path,
+        indexStatus,
+        worktreeStatus,
+        staged,
+        unstaged,
+        untracked,
+        statusLabel: buildStatusLabel(indexStatus, worktreeStatus),
+      } satisfies ChangedFile
+    })
+    .filter((file): file is ChangedFile => Boolean(file))
+}
+
+function buildStatusLabel(indexStatus: string, worktreeStatus: string): string {
+  if (indexStatus === "?" && worktreeStatus === "?") {
+    return "untracked"
+  }
+
+  const parts: string[] = []
+  if (indexStatus !== " ") {
+    parts.push(`staged ${STATUS_NAME[indexStatus] ?? indexStatus}`)
+  }
+  if (worktreeStatus !== " ") {
+    parts.push(`unstaged ${STATUS_NAME[worktreeStatus] ?? worktreeStatus}`)
+  }
+  return parts.join(", ") || "clean"
+}