@fatdoge/wtree 0.1.0

package/dist-node/api/core/config.js

@@ -0,0 +1,21 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+const CONFIG_DIR = path.join(os.homedir(), '.config', 'wtree');
+const CONFIG_PATH = path.join(CONFIG_DIR, 'config.json');
+export function readConfig() {
+    try {
+        const raw = fs.readFileSync(CONFIG_PATH, 'utf-8');
+        return JSON.parse(raw);
+    }
+    catch {
+        return {};
+    }
+}
+export function writeConfig(next) {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true });
+    fs.writeFileSync(CONFIG_PATH, JSON.stringify(next, null, 2), 'utf-8');
+}
+export function getConfigPaths() {
+    return { dir: CONFIG_DIR, path: CONFIG_PATH };
+}

package/dist-node/api/core/exec.js

@@ -0,0 +1,24 @@
+import { spawnSync } from 'node:child_process';
+export function exec(command, args, options = {}) {
+    const r = spawnSync(command, args, {
+        cwd: options.cwd,
+        encoding: 'utf-8',
+    });
+    const stdout = (r.stdout || '').toString();
+    const stderr = (r.stderr || '').toString();
+    const ok = r.status === 0;
+    return {
+        ok,
+        stdout: stdout.trimEnd(),
+        stderr: stderr.trimEnd(),
+        exitCode: r.status,
+    };
+}
+export function execOrThrow(command, args, options = {}) {
+    const r = exec(command, args, { cwd: options.cwd });
+    if (r.ok)
+        return r;
+    const error = new Error(`${options.errorCode ? `[${options.errorCode}] ` : ''}${command} ${args.join(' ')}\n${r.stderr || r.stdout}`);
+    error.exec = { command, args, ...r };
+    throw error;
+}

package/dist-node/api/core/git.js

@@ -0,0 +1,24 @@
+import path from 'node:path';
+import { exec, execOrThrow } from './exec.js';
+const withSafeArgs = (args) => ['-c', 'safe.directory=*', ...args];
+export function getRepoRoot(cwd) {
+    const common = exec('git', withSafeArgs(['rev-parse', '--path-format=absolute', '--git-common-dir']), { cwd });
+    if (common.ok && common.stdout.trim()) {
+        return path.dirname(common.stdout.trim());
+    }
+    const top = exec('git', withSafeArgs(['rev-parse', '--show-toplevel']), { cwd });
+    if (top.ok && top.stdout.trim()) {
+        return top.stdout.trim();
+    }
+    throw new Error('无法确定 Git 根目录。请确保在 Git 仓库中运行。');
+}
+export function getGitDirAbsolute(rootDir) {
+    const r = execOrThrow('git', withSafeArgs(['rev-parse', '--path-format=absolute', '--git-dir']), { cwd: rootDir, errorCode: 'GIT_DIR' });
+    return r.stdout.trim();
+}
+export function git(rootDir, args) {
+    return exec('git', withSafeArgs(args), { cwd: rootDir });
+}
+export function gitOrThrow(rootDir, args, errorCode) {
+    return execOrThrow('git', withSafeArgs(args), { cwd: rootDir, errorCode });
+}

package/dist-node/api/core/id.js

@@ -0,0 +1,6 @@
+export function idFromPath(p) {
+    return Buffer.from(p, 'utf-8').toString('base64url');
+}
+export function pathFromId(id) {
+    return Buffer.from(id, 'base64url').toString('utf-8');
+}

package/dist-node/api/core/open.js

@@ -0,0 +1,51 @@
+import { spawnSync } from 'node:child_process';
+import process from 'node:process';
+function hasCommand(cmd) {
+    try {
+        const checkCmd = process.platform === 'win32' ? 'where' : 'which';
+        const r = spawnSync(checkCmd, [cmd], { stdio: 'ignore' });
+        return r.status === 0;
+    }
+    catch {
+        return false;
+    }
+}
+export function openPath(targetPath, openCommand) {
+    const platform = process.platform;
+    if (openCommand) {
+        const r = spawnSync(openCommand, [targetPath], { stdio: 'ignore' });
+        return r.status === 0;
+    }
+    if (platform === 'darwin') {
+        const r = spawnSync('open', [targetPath], { stdio: 'ignore' });
+        return r.status === 0;
+    }
+    if (platform === 'win32') {
+        const r = spawnSync('cmd', ['/c', 'start', '', targetPath], {
+            stdio: 'ignore',
+            windowsVerbatimArguments: true,
+        });
+        return r.status === 0;
+    }
+    const r = spawnSync('xdg-open', [targetPath], { stdio: 'ignore' });
+    return r.status === 0;
+}
+export function openEditor(targetPath, editorCommand) {
+    if (editorCommand) {
+        // Split command and args? For now assume command is single word or handled by spawnSync if passed as array.
+        // Actually spawnSync(cmd, args) expects cmd to be executable.
+        // If editorCommand is "code -r", it might fail if passed as cmd.
+        // We should probably split by space if user provided args, but let's keep it simple: assume user provides executable name.
+        // Or we can use shell: true for custom commands.
+        const r = spawnSync(editorCommand, [targetPath], { stdio: 'ignore', shell: true });
+        return r.status === 0;
+    }
+    const editors = ['trae', 'cursor', 'code'];
+    for (const ed of editors) {
+        if (hasCommand(ed)) {
+            const r = spawnSync(ed, [targetPath], { stdio: 'ignore' });
+            return r.status === 0;
+        }
+    }
+    return false;
+}

package/dist-node/api/core/worktree.js

@@ -0,0 +1,58 @@
+import path from 'node:path';
+import { gitOrThrow } from './git.js';
+import { idFromPath } from './id.js';
+export function parseWorktreePorcelain(output) {
+    const lines = output.split('\n');
+    const items = [];
+    let current = {};
+    const flush = () => {
+        if (!current.path)
+            return;
+        items.push({
+            path: current.path,
+            head: current.head || '',
+            branch: current.branch,
+            isLocked: Boolean(current.isLocked),
+        });
+        current = {};
+    };
+    for (const line of lines) {
+        if (line.startsWith('worktree ')) {
+            flush();
+            current.path = line.slice('worktree '.length).trim();
+            continue;
+        }
+        if (line.startsWith('HEAD ')) {
+            current.head = line.slice('HEAD '.length).trim();
+            continue;
+        }
+        if (line.startsWith('branch ')) {
+            const b = line.slice('branch '.length).trim();
+            current.branch = b.replace(/^refs\/heads\//, '');
+            continue;
+        }
+        if (line.startsWith('locked')) {
+            current.isLocked = true;
+            continue;
+        }
+    }
+    flush();
+    return items;
+}
+export function listWorktrees(rootDir) {
+    const r = gitOrThrow(rootDir, ['worktree', 'list', '--porcelain'], 'WORKTREE_LIST');
+    const raw = parseWorktreePorcelain(r.stdout);
+    return raw
+        .filter((wt) => wt.path)
+        .map((wt) => {
+        const normalized = path.resolve(wt.path);
+        return {
+            id: idFromPath(normalized),
+            path: normalized,
+            head: wt.head,
+            branch: wt.branch,
+            isMain: path.resolve(normalized) === path.resolve(rootDir),
+            isLocked: wt.isLocked,
+        };
+    });
+}

package/dist-node/api/core/worktree.test.js

@@ -0,0 +1,30 @@
+import { describe, expect, it } from 'vitest';
+import { parseWorktreePorcelain } from './worktree.js';
+describe('parseWorktreePorcelain', () => {
+    it('parses multiple worktrees with branch and locked', () => {
+        const output = [
+            'worktree /repo',
+            'HEAD 1111111111111111111111111111111111111111',
+            'branch refs/heads/main',
+            'worktree /repo/worktrees/feature-a',
+            'HEAD 2222222222222222222222222222222222222222',
+            'branch refs/heads/feature/a',
+            'locked',
+            '',
+        ].join('\n');
+        const items = parseWorktreePorcelain(output);
+        expect(items).toHaveLength(2);
+        expect(items[0]).toEqual({
+            path: '/repo',
+            head: '1111111111111111111111111111111111111111',
+            branch: 'main',
+            isLocked: false,
+        });
+        expect(items[1]).toEqual({
+            path: '/repo/worktrees/feature-a',
+            head: '2222222222222222222222222222222222222222',
+            branch: 'feature/a',
+            isLocked: true,
+        });
+    });
+});

package/dist-node/api/createApiApp.js

@@ -0,0 +1,26 @@
+import express from 'express';
+import cors from 'cors';
+import { createWorktreeRouter } from './routes/worktrees.js';
+export function createApiApp(getRepoRoot) {
+    const app = express();
+    app.use(cors());
+    app.use(express.json({ limit: '10mb' }));
+    app.use(express.urlencoded({ extended: true, limit: '10mb' }));
+    app.use('/api', createWorktreeRouter(getRepoRoot));
+    app.get('/api/health', (req, res) => {
+        res.status(200).json({ ok: true, data: { status: 'ok' } });
+    });
+    app.use((error, req, res, next) => {
+        void error;
+        void req;
+        void next;
+        res.status(500).json({
+            ok: false,
+            error: { code: 'INTERNAL', message: 'Server internal error' },
+        });
+    });
+    app.use((req, res) => {
+        res.status(404).json({ ok: false, error: { code: 'NOT_FOUND', message: 'API not found' } });
+    });
+    return app;
+}

package/dist-node/api/routes/worktrees.js

@@ -0,0 +1,213 @@
+import express from 'express';
+import path from 'node:path';
+import { getGitDirAbsolute } from '../core/git.js';
+import { listWorktrees } from '../core/worktree.js';
+import { gitOrThrow } from '../core/git.js';
+import { pathFromId } from '../core/id.js';
+import { openPath, openEditor } from '../core/open.js';
+import { readConfig, writeConfig } from '../core/config.js';
+export function createWorktreeRouter(getRepoRoot) {
+    const router = express.Router();
+    const errMsg = (e) => (e instanceof Error ? e.message : String(e));
+    router.get('/repo', (req, res) => {
+        try {
+            const rootPath = getRepoRoot();
+            const gitDirPath = getGitDirAbsolute(rootPath);
+            res.json({ ok: true, data: { rootPath, gitDirPath } });
+        }
+        catch (e) {
+            res.status(400).json({
+                ok: false,
+                error: { code: 'REPO_NOT_FOUND', message: errMsg(e) || 'Repo not found' },
+            });
+        }
+    });
+    router.get('/worktrees', (req, res) => {
+        try {
+            const root = getRepoRoot();
+            const items = listWorktrees(root);
+            res.json({ ok: true, data: items });
+        }
+        catch (e) {
+            res.status(500).json({
+                ok: false,
+                error: { code: 'WORKTREE_LIST_FAILED', message: errMsg(e) || 'List failed' },
+            });
+        }
+    });
+    router.post('/worktrees', (req, res) => {
+        try {
+            const root = getRepoRoot();
+            const body = req.body;
+            if (!body || !body.ref || !body.path) {
+                res.status(400).json({
+                    ok: false,
+                    error: { code: 'INVALID_INPUT', message: 'ref 与 path 不能为空' },
+                });
+                return;
+            }
+            const targetDir = path.isAbsolute(body.path)
+                ? body.path
+                : path.resolve(root, body.path);
+            if (body.newBranch && body.newBranch.trim()) {
+                gitOrThrow(root, ['branch', body.newBranch.trim(), body.ref.trim()], 'BRANCH_CREATE');
+                gitOrThrow(root, ['worktree', 'add', targetDir, body.newBranch.trim()], 'WORKTREE_ADD');
+            }
+            else {
+                gitOrThrow(root, ['worktree', 'add', targetDir, body.ref.trim()], 'WORKTREE_ADD');
+            }
+            const items = listWorktrees(root);
+            const created = items.find((x) => path.resolve(x.path) === path.resolve(targetDir));
+            if (!created) {
+                res.json({
+                    ok: false,
+                    error: { code: 'WORKTREE_CREATE_UNKNOWN', message: 'Worktree 创建成功但未能读取到列表' },
+                });
+                return;
+            }
+            res.json({ ok: true, data: created });
+        }
+        catch (e) {
+            res.status(500).json({
+                ok: false,
+                error: {
+                    code: 'WORKTREE_CREATE_FAILED',
+                    message: '创建失败',
+                    details: errMsg(e),
+                },
+            });
+        }
+    });
+    router.delete('/worktrees/:id', (req, res) => {
+        const force = req.query.force === '1' || req.query.force === 'true';
+        try {
+            const root = getRepoRoot();
+            const p = pathFromId(req.params.id);
+            const args = force ? ['worktree', 'remove', '--force', p] : ['worktree', 'remove', p];
+            gitOrThrow(root, args, 'WORKTREE_REMOVE');
+            res.json({ ok: true, data: { removed: true } });
+        }
+        catch (e) {
+            res.status(500).json({
+                ok: false,
+                error: {
+                    code: 'WORKTREE_REMOVE_FAILED',
+                    message: '删除失败',
+                    details: errMsg(e),
+                },
+            });
+        }
+    });
+    router.post('/worktrees/:id/open', (req, res) => {
+        try {
+            const p = pathFromId(req.params.id);
+            const cfg = readConfig();
+            const type = req.body.type || 'folder';
+            let ok = false;
+            if (type === 'editor') {
+                ok = openEditor(p, cfg.editorCommand);
+            }
+            else {
+                ok = openPath(p, cfg.openCommand);
+            }
+            if (!ok) {
+                res.status(500).json({
+                    ok: false,
+                    error: {
+                        code: 'OPEN_FAILED',
+                        message: type === 'editor'
+                            ? '无法打开编辑器 (未找到 Trae/Cursor/VSCode，请在设置中配置 editorCommand)'
+                            : '打开失败',
+                    },
+                });
+                return;
+            }
+            res.json({ ok: true, data: { launched: true } });
+        }
+        catch (e) {
+            res.status(500).json({
+                ok: false,
+                error: { code: 'OPEN_FAILED', message: errMsg(e) || '打开失败' },
+            });
+        }
+    });
+    router.post('/worktrees/:id/lock', (req, res) => {
+        try {
+            const root = getRepoRoot();
+            const p = pathFromId(req.params.id);
+            gitOrThrow(root, ['worktree', 'lock', p], 'WORKTREE_LOCK');
+            res.json({ ok: true, data: { locked: true } });
+        }
+        catch (e) {
+            res.status(500).json({
+                ok: false,
+                error: { code: 'LOCK_FAILED', message: errMsg(e) || 'Lock failed' },
+            });
+        }
+    });
+    router.post('/worktrees/:id/unlock', (req, res) => {
+        try {
+            const root = getRepoRoot();
+            const p = pathFromId(req.params.id);
+            gitOrThrow(root, ['worktree', 'unlock', p], 'WORKTREE_UNLOCK');
+            res.json({ ok: true, data: { unlocked: true } });
+        }
+        catch (e) {
+            res.status(500).json({
+                ok: false,
+                error: { code: 'UNLOCK_FAILED', message: errMsg(e) || 'Unlock failed' },
+            });
+        }
+    });
+    router.post('/worktrees/prune', (req, res) => {
+        try {
+            const root = getRepoRoot();
+            gitOrThrow(root, ['worktree', 'prune'], 'WORKTREE_PRUNE');
+            res.json({ ok: true, data: { pruned: true } });
+        }
+        catch (e) {
+            res.status(500).json({
+                ok: false,
+                error: { code: 'PRUNE_FAILED', message: errMsg(e) || 'Prune failed' },
+            });
+        }
+    });
+    router.get('/branches', (req, res) => {
+        try {
+            const root = getRepoRoot();
+            const local = gitOrThrow(root, ['branch', '--format=%(refname:short)']).stdout
+                .split('\n')
+                .map((b) => b.trim())
+                .filter(Boolean);
+            const remote = gitOrThrow(root, ['branch', '-r', '--format=%(refname:short)']).stdout
+                .split('\n')
+                .map((b) => b.trim())
+                .filter((b) => b && !b.includes('/HEAD'));
+            const all = Array.from(new Set([...local, ...remote])).sort();
+            res.json({ ok: true, data: all });
+        }
+        catch (e) {
+            res.status(500).json({
+                ok: false,
+                error: { code: 'BRANCH_LIST_FAILED', message: errMsg(e) || 'List branches failed' },
+            });
+        }
+    });
+    router.get('/config', (req, res) => {
+        res.json({ ok: true, data: readConfig() });
+    });
+    router.put('/config', (req, res) => {
+        try {
+            const next = req.body || {};
+            writeConfig(next);
+            res.json({ ok: true, data: readConfig() });
+        }
+        catch (e) {
+            res.status(500).json({
+                ok: false,
+                error: { code: 'CONFIG_WRITE_FAILED', message: '保存失败', details: errMsg(e) },
+            });
+        }
+    });
+    return router;
+}

package/dist-node/api/server.js

@@ -0,0 +1,29 @@
+/**
+ * local server entry file, for local development
+ */
+import app from './app.js';
+/**
+ * start server with port
+ */
+const PORT = process.env.PORT || 3001;
+const server = app.listen(PORT, () => {
+    console.log(`Server ready on port ${PORT}`);
+});
+/**
+ * close server
+ */
+process.on('SIGTERM', () => {
+    console.log('SIGTERM signal received');
+    server.close(() => {
+        console.log('Server closed');
+        process.exit(0);
+    });
+});
+process.on('SIGINT', () => {
+    console.log('SIGINT signal received');
+    server.close(() => {
+        console.log('Server closed');
+        process.exit(0);
+    });
+});
+export default app;

package/dist-node/api/ui/startUiDev.js

@@ -0,0 +1,65 @@
+import os from 'node:os';
+import path from 'node:path';
+import fs from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { createServer } from 'vite';
+import { createApiApp } from '../createApiApp.js';
+import { openPath } from '../core/open.js';
+function findUiRoot(fromDir) {
+    let cur = fromDir;
+    for (let i = 0; i < 10; i += 1) {
+        const indexHtml = path.join(cur, 'index.html');
+        const viteConfig = path.join(cur, 'vite.config.ts');
+        if (exists(indexHtml) && exists(viteConfig))
+            return cur;
+        const parent = path.dirname(cur);
+        if (parent === cur)
+            break;
+        cur = parent;
+    }
+    return fromDir;
+}
+function exists(p) {
+    return fs.existsSync(p);
+}
+export async function startUiDevServer(options) {
+    const repoRoot = options.repoRoot;
+    const open = options.open !== false;
+    const uiPort = Number.isFinite(options.uiPort) ? options.uiPort : 5173;
+    const apiApp = createApiApp(() => repoRoot);
+    const apiServer = apiApp.listen(0, '127.0.0.1');
+    await new Promise((resolve) => apiServer.once('listening', () => resolve()));
+    const apiAddress = apiServer.address();
+    const apiPort = typeof apiAddress === 'object' && apiAddress ? apiAddress.port : 0;
+    process.env.WTUI_API_URL = `http://127.0.0.1:${apiPort}`;
+    process.env.VITE_WTUI_API_URL = process.env.WTUI_API_URL;
+    const here = path.dirname(fileURLToPath(import.meta.url));
+    const uiRoot = findUiRoot(path.resolve(here, '..', '..'));
+    const prevCwd = process.cwd();
+    process.chdir(uiRoot);
+    const vite = await createServer({
+        root: uiRoot,
+        configFile: path.join(uiRoot, 'vite.config.ts'),
+        cacheDir: path.join(os.tmpdir(), 'wtui-vite-cache'),
+        server: {
+            host: '127.0.0.1',
+            port: uiPort,
+            strictPort: false,
+        },
+        clearScreen: false,
+        appType: 'spa',
+    });
+    await vite.listen();
+    const url = vite.resolvedUrls?.local?.[0] || `http://127.0.0.1:${uiPort}/`;
+    if (open) {
+        openPath(url);
+    }
+    return {
+        uiUrl: url,
+        close: async () => {
+            await vite.close();
+            await new Promise((resolve) => apiServer.close(() => resolve()));
+            process.chdir(prevCwd);
+        },
+    };
+}

package/dist-node/shared/wtui-types.js

@@ -0,0 +1 @@
+export {};

package/index.html

@@ -0,0 +1,24 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <link rel="icon" type="image/svg+xml" href="/favicon.svg" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>TreeLab - Git Worktree Manager</title>
+    <script type="module">
+      if (import.meta.hot?.on) {
+        import.meta.hot.on('vite:error', (error) => {
+          if (error.err) {
+            console.error(
+              [error.err.message, error.err.frame].filter(Boolean).join('\n'),
+            )
+          }
+        })
+      }
+    </script>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/main.tsx"></script>
+  </body>
+</html>

package/package.json

@@ -0,0 +1,89 @@
+{
+  "name": "@fatdoge/wtree",
+  "private": false,
+  "version": "0.1.0",
+  "description": "CLI + UI tool for managing git worktrees",
+  "keywords": [
+    "git",
+    "worktree",
+    "cli",
+    "ui",
+    "manager"
+  ],
+  "author": "fatdoge",
+  "license": "MIT",
+  "type": "module",
+  "bin": {
+    "wtree": "dist-node/api/cli/wtree.js"
+  },
+  "files": [
+    "dist-node",
+    "dist",
+    "api",
+    "src",
+    "shared",
+    "index.html",
+    "vite.config.ts",
+    "tailwind.config.js",
+    "postcss.config.js",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "client:dev": "vite",
+    "build:ui": "vite build",
+    "build:cli": "tsc -p tsconfig.node.json",
+    "build": "pnpm run build:cli && pnpm run build:ui",
+    "lint": "eslint .",
+    "preview": "vite preview",
+    "check": "tsc --noEmit && tsc -p tsconfig.node.json --noEmit",
+    "server:dev": "nodemon",
+    "dev": "concurrently \"pnpm run client:dev\" \"pnpm run server:dev\"",
+    "wtree": "tsx api/cli/wtree.ts",
+    "test": "vitest run"
+  },
+  "dependencies": {
+    "@vitejs/plugin-react": "^4.4.1",
+    "autoprefixer": "^10.4.21",
+    "chalk": "^5.6.0",
+    "clsx": "^2.1.1",
+    "cors": "^2.8.5",
+    "dotenv": "^17.2.1",
+    "express": "^4.21.2",
+    "i18next": "^25.8.17",
+    "i18next-browser-languagedetector": "^8.2.1",
+    "inquirer": "^12.9.4",
+    "lucide-react": "^0.511.0",
+    "postcss": "^8.5.3",
+    "react": "^18.3.1",
+    "react-dom": "^18.3.1",
+    "react-i18next": "^16.5.7",
+    "react-router-dom": "^7.3.0",
+    "tailwind-merge": "^3.0.2",
+    "tailwindcss": "^3.4.17",
+    "vite": "^6.3.5",
+    "vite-plugin-trae-solo-badge": "^1.0.0",
+    "vite-tsconfig-paths": "^5.1.4",
+    "zustand": "^5.0.3"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.25.0",
+    "@types/cors": "^2.8.19",
+    "@types/express": "^4.17.21",
+    "@types/node": "^22.15.30",
+    "@types/react": "^18.3.12",
+    "@types/react-dom": "^18.3.1",
+    "@vercel/node": "^5.3.6",
+    "babel-plugin-react-dev-locator": "^1.0.0",
+    "concurrently": "^9.2.0",
+    "eslint": "^9.25.0",
+    "eslint-plugin-react-hooks": "^5.2.0",
+    "eslint-plugin-react-refresh": "^0.4.19",
+    "globals": "^16.0.0",
+    "nodemon": "^3.1.10",
+    "tsx": "^4.20.3",
+    "typescript": "~5.8.3",
+    "typescript-eslint": "^8.30.1",
+    "vitest": "^2.1.9"
+  }
+}