arbors 0.1.0

package/skills/arbors-usage/SKILL.md

@@ -0,0 +1,129 @@
+---
+name: arbors-usage
+description: This skill should be used when the user asks to "create a worktree", "switch worktree", "manage worktrees", "use arbors", "set up arbors", "install arbors", "configure arbors", "remove worktree", "list worktrees", "delete worktree", or mentions git worktree management with arbors. Also trigger when the user asks about arbors's project structure, how arbors works internally, how to develop or contribute to arbors, or troubleshoot arbors issues.
+---
+
+# arbors — Git Worktree Manager
+
+arbors is a CLI/TUI tool for managing git worktrees. It handles worktree creation, `.git/info/exclude` file copying, package manager auto-detection, dependency installation, and project registry tracking.
+
+## Quick Reference
+
+```sh
+arbors add <branch>                     # Checkout existing branch (local → remote auto)
+arbors add -c <branch> [--base <base>]  # Create new branch + worktree
+arbors remove <branch>                  # Remove worktree (safety checks first)
+arbors list [--plain]                   # List arbors-managed worktrees
+arbors excluded                         # Show .git/info/exclude patterns
+arbors config                           # Show current configuration
+```
+
+## Installation & Setup
+
+Build and link globally:
+
+```sh
+cd <arbors-repo>
+pnpm install && pnpm build
+npm link
+```
+
+Shell integration is required for auto-cd — a child process (node) cannot change the parent shell's cwd, so the wrapper script captures arbors's `__ARBORS_CD__:<path>` protocol output and runs `cd` in the parent shell.
+
+```sh
+# ~/.zshrc
+source /path/to/arbors/shell/arbors-wrapper.zsh
+
+# ~/.bashrc
+source /path/to/arbors/shell/arbors-wrapper.sh
+```
+
+## How `arbors add` Works
+
+The `add` command handles both new and existing branches via the `-c` flag:
+
+### With `-c` (create new branch)
+
+`arbors add -c <branch> [--base <base>]`
+
+1. Validate branch name against `/^[a-zA-Z0-9][a-zA-Z0-9._\/-]*$/` (slashes allowed, no `..`)
+2. Check if branch already exists — error if so
+3. Run `git fetch origin <base>` then `git worktree add -b <branch> ~/arbors/{repo}/<dir> origin/<base>` (dir = branch with `/` → `-`)
+4. Copy files matching `.git/info/exclude` patterns (if `copyExcludes: true`)
+5. Detect runtime manager (mise.toml → `mise install`, .nvmrc → `nvm install`)
+6. Detect package manager (pnpm-lock.yaml → pnpm, yarn.lock → yarn, package-lock.json → npm) and run install
+7. Register in `~/.arbors/db.json` (project + worktree tracking)
+
+### Without `-c` (checkout existing branch)
+
+`arbors add <branch>`
+
+1. Validate branch name
+2. If local branch exists → `git worktree add ~/arbors/{repo}/<dir> <branch>`
+3. Else if remote branch exists → `git fetch origin <branch>`, then create worktree from `origin/<branch>`
+4. Else → error with hint to use `arbors add -c`
+5. Copy excluded files, install deps, register in db (same as above)
+
+## Safety
+
+- `arbors remove` refuses to delete worktrees with uncommitted changes (`git status --porcelain`)
+- Cannot remove the main worktree
+- Name validation allows slashes (`feature/login`) but prevents path traversal (`..`) and unsafe characters
+- Branch deletion (`git branch -D <branch>`) happens after worktree removal
+- Branch existence is checked before creation to prevent overwriting
+
+## Configuration
+
+Global: `~/.arbors/config.json` — Project override: `.arbors/config.json` (in repo root, takes precedence)
+
+| Key              | Values                                 | Default             |
+| ---------------- | -------------------------------------- | ------------------- |
+| `runtime`        | `"node"`, `"bun"`                      | `"node"`            |
+| `language`       | `"en"`, `"ko"`, `"ja"`                 | `"en"`              |
+| `packageManager` | `"auto"`, `"pnpm"`, `"yarn"`, `"npm"` | `"auto"`            |
+| `copyExcludes`   | `true`, `false`                        | `true`              |
+| `copySkip`       | `string[]`                             | `["node_modules"]`  |
+| `worktreeDir`    | string with `{repo}` placeholder       | `"~/arbors/{repo}"` |
+
+## Data Files
+
+- `~/.arbors/config.json` — Global configuration
+- `~/.arbors/db.json` — Project registry + worktree tracking (projects and worktrees per project)
+- `.arbors/config.json` — Per-project config override
+- `.git/info/exclude` — Patterns for files to copy into new worktrees
+
+## Project Architecture
+
+For development and contribution context:
+
+```
+src/
+├── config.ts              # Config loading (global → project merge)
+├── git/
+│   ├── worktree.ts        # Core: create/remove/list worktrees, detect default branch
+│   ├── safety.ts          # Name validation, uncommitted changes check, main worktree guard
+│   └── exclude.ts         # Parse .git/info/exclude, find matching files, copy to worktree
+├── project/
+│   ├── registry.ts        # ~/.arbors/db.json read/write, project + worktree CRUD
+│   └── setup.ts           # Package manager & runtime manager detection and install
+├── runtime/
+│   ├── adapter.ts         # RuntimeAdapter interface (exec, glob, readFile, etc.)
+│   ├── node.ts            # Node.js implementation
+│   ├── bun.ts             # Bun implementation
+│   └── index.ts           # Factory: createAdapter(runtime)
+└── i18n/                  # en, ko, ja message catalogs
+bin/arbors.ts               # CLI entry point (parseArgs, command dispatch)
+shell/arbors-wrapper.{zsh,sh}  # Shell wrappers for auto-cd
+```
+
+Key pattern: all file/process operations go through `RuntimeAdapter`, enabling both Node and Bun runtimes.
+
+### Development Commands
+
+```sh
+pnpm test       # vitest
+pnpm lint       # oxlint
+pnpm format     # oxfmt
+pnpm build      # tsup
+pnpm typecheck  # tsc --noEmit
+```

package/src/config.ts

@@ -0,0 +1,66 @@
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+
+export interface ArborConfig {
+  runtime: "bun" | "node";
+  language: "ko" | "en" | "ja";
+  packageManager: "auto" | "pnpm" | "yarn" | "npm";
+  copyExcludes: boolean;
+  copySkip: string[];
+  worktreeDir: string;
+}
+
+const DEFAULT_CONFIG: ArborConfig = {
+  runtime: "node",
+  language: "en",
+  packageManager: "auto",
+  copyExcludes: true,
+  copySkip: ["node_modules"],
+  worktreeDir: "~/arbors/{repo}",
+} satisfies ArborConfig;
+
+const GLOBAL_CONFIG_PATH = join(homedir(), ".arbors", "config.json");
+const PROJECT_CONFIG_DIR = ".arbors";
+const PROJECT_CONFIG_FILE = "config.json";
+
+const mergeConfig = (base: ArborConfig, override: Partial<ArborConfig>): ArborConfig => {
+  return { ...base, ...override };
+};
+
+const readJsonFile = async (
+  readFile: (path: string) => Promise<string>,
+  exists: (path: string) => Promise<boolean>,
+  path: string,
+): Promise<Partial<ArborConfig>> => {
+  if (!(await exists(path))) return {};
+
+  try {
+    const content = await readFile(path);
+    return JSON.parse(content) as Partial<ArborConfig>;
+  } catch {
+    return {};
+  }
+};
+
+export const loadConfig = async (
+  readFile: (path: string) => Promise<string>,
+  exists: (path: string) => Promise<boolean>,
+  projectRoot?: string,
+): Promise<ArborConfig> => {
+  const globalOverride = await readJsonFile(readFile, exists, GLOBAL_CONFIG_PATH);
+  const merged = mergeConfig(DEFAULT_CONFIG, globalOverride);
+
+  if (!projectRoot) return merged;
+
+  const projectConfigPath = resolve(projectRoot, PROJECT_CONFIG_DIR, PROJECT_CONFIG_FILE);
+  const projectOverride = await readJsonFile(readFile, exists, projectConfigPath);
+
+  return mergeConfig(merged, projectOverride);
+};
+
+export const getGlobalConfigPath = (): string => GLOBAL_CONFIG_PATH;
+
+export const getProjectConfigPath = (projectRoot: string): string =>
+  resolve(projectRoot, PROJECT_CONFIG_DIR, PROJECT_CONFIG_FILE);
+
+export { DEFAULT_CONFIG, mergeConfig };

package/src/git/exclude.ts

@@ -0,0 +1,63 @@
+import { join } from "node:path";
+import type { RuntimeAdapter } from "../runtime/adapter.js";
+import { getRepoRoot } from "./worktree.js";
+
+export const getExcludePatterns = async (adapter: RuntimeAdapter): Promise<string[]> => {
+  const repoRoot = await getRepoRoot(adapter);
+  const excludePath = join(repoRoot, ".git", "info", "exclude");
+
+  if (!(await adapter.exists(excludePath))) return [];
+
+  const content = await adapter.readFile(excludePath);
+
+  return content
+    .split("\n")
+    .map((line) => line.trim())
+    .filter((line) => line !== "" && !line.startsWith("#"));
+};
+
+export const findExcludedEntries = async (
+  adapter: RuntimeAdapter,
+  patterns: string[],
+): Promise<string[]> => {
+  const repoRoot = await getRepoRoot(adapter);
+  const cleaned = patterns.map((p) => p.replace(/^\//, ""));
+
+  const groups = await Promise.all(
+    cleaned.map((pattern) => adapter.glob(pattern, repoRoot)),
+  );
+
+  return [...new Set(groups.flat())].sort();
+};
+
+export const copyExcludedFiles = async (
+  adapter: RuntimeAdapter,
+  worktreePath: string,
+  skipPatterns: string[] = [],
+): Promise<string[]> => {
+  const patterns = await getExcludePatterns(adapter);
+  if (patterns.length === 0) return [];
+
+  const repoRoot = await getRepoRoot(adapter);
+  const allEntries = await findExcludedEntries(adapter, patterns);
+  const entries = allEntries.filter(
+    (e) => !skipPatterns.some((s) => e === s || e.startsWith(`${s}/`)),
+  );
+
+  const copied: string[] = [];
+
+  await Promise.all(
+    entries.map(async (entry) => {
+      const src = join(repoRoot, entry);
+      const dest = join(worktreePath, entry);
+      try {
+        await adapter.copy(src, dest);
+        copied.push(entry);
+      } catch {
+        // Skip non-copyable entries (sockets, pipes, etc.)
+      }
+    }),
+  );
+
+  return copied;
+};

package/src/git/safety.ts

@@ -0,0 +1,40 @@
+import type { RuntimeAdapter } from "../runtime/adapter.js";
+import { listWorktrees } from "./worktree.js";
+
+const VALID_NAME_PATTERN = /^[a-zA-Z0-9][a-zA-Z0-9._\/-]*$/;
+
+export const validateWorktreeName = (name: string): boolean =>
+  VALID_NAME_PATTERN.test(name) && !name.includes("..");
+
+export const hasUncommittedChanges = async (
+  adapter: RuntimeAdapter,
+  worktreePath: string,
+): Promise<boolean> => {
+  const result = await adapter.exec("git", ["-C", worktreePath, "status", "--porcelain"]);
+
+  return result.exitCode === 0 && result.stdout.length > 0;
+};
+
+export const isMainWorktree = async (
+  adapter: RuntimeAdapter,
+  worktreePath: string,
+): Promise<boolean> => {
+  const worktrees = await listWorktrees(adapter);
+  const target = worktrees.find((wt) => wt.path === worktreePath);
+  return target?.isMain ?? false;
+};
+
+export const canSafelyRemove = async (
+  adapter: RuntimeAdapter,
+  worktreePath: string,
+): Promise<{ safe: boolean; reason?: string }> => {
+  if (await isMainWorktree(adapter, worktreePath)) {
+    return { safe: false, reason: "cannotDeleteMain" };
+  }
+
+  if (await hasUncommittedChanges(adapter, worktreePath)) {
+    return { safe: false, reason: "uncommittedChanges" };
+  }
+
+  return { safe: true };
+};

package/src/git/worktree.ts

@@ -0,0 +1,171 @@
+import { homedir } from "node:os";
+import { basename, resolve } from "node:path";
+import type { RuntimeAdapter } from "../runtime/adapter.js";
+
+export interface WorktreeInfo {
+  path: string;
+  branch: string;
+  isMain: boolean;
+}
+
+export const getRepoRoot = async (adapter: RuntimeAdapter): Promise<string> => {
+  const result = await adapter.exec("git", ["rev-parse", "--show-toplevel"]);
+  if (result.exitCode !== 0) throw new Error("Not a git repository");
+  return result.stdout;
+};
+
+export const getRepoName = async (adapter: RuntimeAdapter): Promise<string> => {
+  const root = await getRepoRoot(adapter);
+  return basename(root);
+};
+
+export const getDefaultBranch = async (adapter: RuntimeAdapter): Promise<string> => {
+  const result = await adapter.exec("git", ["symbolic-ref", "refs/remotes/origin/HEAD"]);
+
+  if (result.exitCode === 0) {
+    return result.stdout.replace("refs/remotes/origin/", "");
+  }
+
+  const mainCheck = await adapter.exec("git", ["rev-parse", "--verify", "main"]);
+  return mainCheck.exitCode === 0 ? "main" : "master";
+};
+
+const parseWorktreeBlock = (block: string, isFirst: boolean): WorktreeInfo | null => {
+  const lines = block.split("\n");
+  const pathLine = lines.find((l) => l.startsWith("worktree "));
+  const branchLine = lines.find((l) => l.startsWith("branch "));
+
+  if (!pathLine) return null;
+
+  const path = pathLine.slice(9);
+  const branch = branchLine?.slice(7).replace("refs/heads/", "") ?? "";
+
+  return { path, branch, isMain: isFirst };
+};
+
+export const listWorktrees = async (adapter: RuntimeAdapter): Promise<WorktreeInfo[]> => {
+  const result = await adapter.exec("git", ["worktree", "list", "--porcelain"]);
+  if (result.exitCode !== 0) return [];
+
+  return result.stdout
+    .split("\n\n")
+    .map((block: string, index: number) => parseWorktreeBlock(block, index === 0))
+    .filter((wt): wt is WorktreeInfo => wt !== null);
+};
+
+export const branchExists = async (adapter: RuntimeAdapter, branchName: string): Promise<boolean> => {
+  const result = await adapter.exec("git", ["rev-parse", "--verify", branchName]);
+  return result.exitCode === 0;
+};
+
+export const remoteBranchExists = async (adapter: RuntimeAdapter, branchName: string): Promise<boolean> => {
+  const result = await adapter.exec("git", ["ls-remote", "--heads", "origin", branchName]);
+  return result.exitCode === 0 && result.stdout.length > 0;
+};
+
+const branchToDir = (branch: string): string => branch.replaceAll("/", "-");
+
+const resolveWorktreeDir = (worktreeDir: string, repoName: string): string => {
+  const expanded = worktreeDir.replace(/^~/, homedir()).replace("{repo}", repoName);
+  return resolve(expanded);
+};
+
+export const createWorktree = async (
+  adapter: RuntimeAdapter,
+  branch: string,
+  worktreeDir: string,
+  baseBranch?: string,
+): Promise<string> => {
+  const repoName = await getRepoName(adapter);
+  const base = baseBranch ?? (await getDefaultBranch(adapter));
+  const worktreePath = resolve(resolveWorktreeDir(worktreeDir, repoName), branchToDir(branch));
+
+  if (await branchExists(adapter, branch)) {
+    throw new Error(`Branch '${branch}' already exists`);
+  }
+
+  await adapter.exec("git", ["fetch", "origin", base]);
+
+  const result = await adapter.exec("git", [
+    "worktree",
+    "add",
+    "-b",
+    branch,
+    worktreePath,
+    `origin/${base}`,
+  ]);
+
+  if (result.exitCode !== 0) {
+    throw new Error(result.stderr || "Failed to create worktree");
+  }
+
+  return worktreePath;
+};
+
+export interface CheckoutResult {
+  path: string;
+  created: boolean;
+}
+
+export const checkoutWorktree = async (
+  adapter: RuntimeAdapter,
+  branch: string,
+  worktreeDir: string,
+): Promise<CheckoutResult> => {
+  const existing = (await listWorktrees(adapter)).find((wt) => wt.branch === branch);
+  if (existing) return { path: existing.path, created: false };
+
+  const repoName = await getRepoName(adapter);
+  const worktreePath = resolve(resolveWorktreeDir(worktreeDir, repoName), branchToDir(branch));
+
+  const result = await adapter.exec("git", ["worktree", "add", worktreePath, branch]);
+
+  if (result.exitCode !== 0) {
+    throw new Error(result.stderr || "Failed to checkout worktree");
+  }
+
+  return { path: worktreePath, created: true };
+};
+
+export const checkoutRemoteWorktree = async (
+  adapter: RuntimeAdapter,
+  branch: string,
+  worktreeDir: string,
+): Promise<CheckoutResult> => {
+  const existing = (await listWorktrees(adapter)).find((wt) => wt.branch === branch);
+  if (existing) return { path: existing.path, created: false };
+
+  await adapter.exec("git", ["fetch", "origin", branch]);
+
+  const repoName = await getRepoName(adapter);
+  const worktreePath = resolve(resolveWorktreeDir(worktreeDir, repoName), branchToDir(branch));
+
+  const result = await adapter.exec("git", [
+    "worktree",
+    "add",
+    "-b",
+    branch,
+    worktreePath,
+    `origin/${branch}`,
+  ]);
+
+  if (result.exitCode !== 0) {
+    throw new Error(result.stderr || "Failed to checkout remote worktree");
+  }
+
+  return { path: worktreePath, created: true };
+};
+
+export const removeWorktree = async (
+  adapter: RuntimeAdapter,
+  worktreePath: string,
+  branch: string,
+): Promise<void> => {
+  const removeResult = await adapter.exec("git", ["worktree", "remove", "--force", worktreePath]);
+
+  if (removeResult.exitCode !== 0) {
+    throw new Error(removeResult.stderr || "Failed to remove worktree");
+  }
+
+  await adapter.exec("git", ["branch", "-D", branch]);
+};

package/src/i18n/en.ts

@@ -0,0 +1,63 @@
+export interface Messages {
+  selectProject: string;
+  noProjects: string;
+  recentProjects: string;
+  selectWorktree: string;
+  noWorktrees: string;
+  createNew: string;
+  creating: string;
+  removing: string;
+  copying: string;
+  installing: string;
+  created: string;
+  removed: string;
+  copied: string;
+  installed: string;
+  resultsFound: (count: number) => string;
+  notGitRepo: string;
+  worktreeExists: string;
+  worktreeNotFound: string;
+  uncommittedChanges: string;
+  cannotDeleteMain: string;
+  invalidName: string;
+  helpFooter: string;
+  helpWorktree: string;
+  configSaved: string;
+  configCurrent: string;
+  version: string;
+  usage: string;
+  commands: string;
+  options: string;
+}
+
+export const en: Messages = {
+  selectProject: "Select a project:",
+  noProjects: "No projects registered. Run arbors in a git repository first.",
+  recentProjects: "Recent projects",
+  selectWorktree: "Select a worktree:",
+  noWorktrees: "No worktrees found.",
+  createNew: "Create new worktree",
+  creating: "Creating worktree...",
+  removing: "Removing worktree...",
+  copying: "Copying excluded files...",
+  installing: "Installing dependencies...",
+  created: "Worktree created",
+  removed: "Worktree removed",
+  copied: "Excluded files copied",
+  installed: "Dependencies installed",
+  resultsFound: (count) => `${count} result${count === 1 ? "" : "s"} found`,
+  notGitRepo: "Not a git repository.",
+  worktreeExists: "Worktree already exists.",
+  worktreeNotFound: "Worktree not found.",
+  uncommittedChanges: "Worktree has uncommitted changes. Commit or stash them first.",
+  cannotDeleteMain: "Cannot delete the main worktree.",
+  invalidName: "Invalid worktree name.",
+  helpFooter: "Tab: autocomplete | Enter: select | Esc: cancel",
+  helpWorktree: "Ctrl+B: new branch | Ctrl+X: delete | Esc: back",
+  configSaved: "Configuration saved.",
+  configCurrent: "Current configuration:",
+  version: "arbors v0.1.0",
+  usage: "Usage: arbors [command] [options]",
+  commands: "Commands:",
+  options: "Options:",
+};

package/src/i18n/index.ts

@@ -0,0 +1,37 @@
+import type { Messages } from "./en.js";
+import { en } from "./en.js";
+
+export type { Messages };
+
+type SupportedLanguage = "ko" | "en" | "ja";
+
+const LANG_MAP: Record<string, SupportedLanguage> = {
+  ko: "ko",
+  "ko-kr": "ko",
+  ko_kr: "ko",
+  en: "en",
+  "en-us": "en",
+  en_us: "en",
+  "en-gb": "en",
+  en_gb: "en",
+  ja: "ja",
+  "ja-jp": "ja",
+  ja_jp: "ja",
+};
+
+const detectLanguage = (): SupportedLanguage => {
+  const lang = (process.env.LANG ?? process.env.LANGUAGE ?? "en").split(".")[0].toLowerCase();
+
+  return LANG_MAP[lang] ?? LANG_MAP[lang.split(/[-_]/)[0]] ?? "en";
+};
+
+const loaders: Record<SupportedLanguage, () => Promise<Messages>> = {
+  en: async () => en,
+  ko: async () => (await import("./ko.js")).ko,
+  ja: async () => (await import("./ja.js")).ja,
+};
+
+export const loadMessages = async (configLanguage?: SupportedLanguage): Promise<Messages> => {
+  const lang = configLanguage ?? detectLanguage();
+  return loaders[lang]();
+};

package/src/i18n/ja.ts

@@ -0,0 +1,40 @@
+import type { Messages } from "./en.js";
+
+export const ja: Messages = {
+  selectProject: "プロジェクトを選択してください:",
+  noProjects: "登録されたプロジェクトがありません。gitリポジトリでarborsを先に実行してください。",
+  recentProjects: "最近のプロジェクト",
+
+  selectWorktree: "ワークツリーを選択してください:",
+  noWorktrees: "ワークツリーがありません。",
+  createNew: "新しいワークツリーを作成",
+
+  creating: "ワークツリーを作成中...",
+  removing: "ワークツリーを削除中...",
+  copying: "除外ファイルをコピー中...",
+  installing: "依存関係をインストール中...",
+
+  created: "ワークツリーを作成しました",
+  removed: "ワークツリーを削除しました",
+  copied: "除外ファイルをコピーしました",
+  installed: "依存関係をインストールしました",
+  resultsFound: (count: number) => `${count}件の結果`,
+
+  notGitRepo: "gitリポジトリではありません。",
+  worktreeExists: "ワークツリーはすでに存在します。",
+  worktreeNotFound: "ワークツリーが見つかりません。",
+  uncommittedChanges: "コミットされていない変更があります。コミットまたはスタッシュしてください。",
+  cannotDeleteMain: "メインワークツリーは削除できません。",
+  invalidName: "無効なワークツリー名です。",
+
+  helpFooter: "Tab: 補完 | Enter: 選択 | Esc: キャンセル",
+  helpWorktree: "Ctrl+B: 新ブランチ | Ctrl+X: 削除 | Esc: 戻る",
+
+  configSaved: "設定を保存しました。",
+  configCurrent: "現在の設定:",
+
+  version: "arbors v0.1.0",
+  usage: "使い方: arbors [コマンド] [オプション]",
+  commands: "コマンド:",
+  options: "オプション:",
+} as const;

package/src/i18n/ko.ts

@@ -0,0 +1,40 @@
+import type { Messages } from "./en.js";
+
+export const ko: Messages = {
+  selectProject: "프로젝트를 선택하세요:",
+  noProjects: "등록된 프로젝트가 없습니다. git 저장소에서 arbors를 먼저 실행하세요.",
+  recentProjects: "최근 프로젝트",
+
+  selectWorktree: "워크트리를 선택하세요:",
+  noWorktrees: "워크트리가 없습니다.",
+  createNew: "새 워크트리 생성",
+
+  creating: "워크트리 생성 중...",
+  removing: "워크트리 삭제 중...",
+  copying: "제외 파일 복사 중...",
+  installing: "의존성 설치 중...",
+
+  created: "워크트리 생성 완료",
+  removed: "워크트리 삭제 완료",
+  copied: "제외 파일 복사 완료",
+  installed: "의존성 설치 완료",
+  resultsFound: (count: number) => `${count}개 결과`,
+
+  notGitRepo: "git 저장소가 아닙니다.",
+  worktreeExists: "워크트리가 이미 존재합니다.",
+  worktreeNotFound: "워크트리를 찾을 수 없습니다.",
+  uncommittedChanges: "커밋되지 않은 변경사항이 있습니다. 커밋하거나 스태시하세요.",
+  cannotDeleteMain: "메인 워크트리는 삭제할 수 없습니다.",
+  invalidName: "올바르지 않은 워크트리 이름입니다.",
+
+  helpFooter: "Tab: 자동완성 | Enter: 선택 | Esc: 취소",
+  helpWorktree: "Ctrl+B: 새 브랜치 | Ctrl+X: 삭제 | Esc: 뒤로",
+
+  configSaved: "설정이 저장되었습니다.",
+  configCurrent: "현재 설정:",
+
+  version: "arbors v0.1.0",
+  usage: "사용법: arbors [명령어] [옵션]",
+  commands: "명령어:",
+  options: "옵션:",
+} as const;