@fatdoge/wtree 0.1.0

package/api/core/config.ts

@@ -0,0 +1,26 @@
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+
+import type { WtuiConfig } from '../../shared/wtui-types.js'
+
+const CONFIG_DIR = path.join(os.homedir(), '.config', 'wtree')
+const CONFIG_PATH = path.join(CONFIG_DIR, 'config.json')
+
+export function readConfig(): WtuiConfig {
+  try {
+    const raw = fs.readFileSync(CONFIG_PATH, 'utf-8')
+    return JSON.parse(raw) as WtuiConfig
+  } catch {
+    return {}
+  }
+}
+
+export function writeConfig(next: WtuiConfig) {
+  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/api/core/exec.ts

@@ -0,0 +1,55 @@
+import { spawnSync } from 'node:child_process'
+
+export type ExecResult = {
+  ok: boolean
+  stdout: string
+  stderr: string
+  exitCode: number | null
+}
+
+export type ExecError = Error & {
+  exec?: {
+    command: string
+    args: string[]
+    ok: boolean
+    stdout: string
+    stderr: string
+    exitCode: number | null
+  }
+}
+
+export function exec(
+  command: string,
+  args: string[],
+  options: { cwd?: string } = {},
+): ExecResult {
+  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: string,
+  args: string[],
+  options: { cwd?: string; errorCode?: string } = {},
+) {
+  const r = exec(command, args, { cwd: options.cwd })
+  if (r.ok) return r
+  const error: ExecError = new Error(
+    `${options.errorCode ? `[${options.errorCode}] ` : ''}${command} ${args.join(' ')}\n${r.stderr || r.stdout}`,
+  )
+  error.exec = { command, args, ...r }
+  throw error
+}

package/api/core/git.ts

@@ -0,0 +1,35 @@
+import path from 'node:path'
+import { exec, execOrThrow } from './exec.js'
+
+const withSafeArgs = (args: string[]) => ['-c', 'safe.directory=*', ...args]
+
+export function getRepoRoot(cwd: string) {
+  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: string) {
+  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: string, args: string[]) {
+  return exec('git', withSafeArgs(args), { cwd: rootDir })
+}
+
+export function gitOrThrow(rootDir: string, args: string[], errorCode?: string) {
+  return execOrThrow('git', withSafeArgs(args), { cwd: rootDir, errorCode })
+}

package/api/core/id.ts

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

package/api/core/open.ts

@@ -0,0 +1,58 @@
+import { spawnSync } from 'node:child_process'
+import process from 'node:process'
+
+function hasCommand(cmd: string) {
+  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: string, openCommand?: string) {
+  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: string, editorCommand?: string) {
+  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/api/core/worktree.test.ts

@@ -0,0 +1,33 @@
+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/api/core/worktree.ts

@@ -0,0 +1,72 @@
+import path from 'node:path'
+import { gitOrThrow } from './git.js'
+import { idFromPath } from './id.js'
+import type { WorktreeItem } from '../../shared/wtui-types.js'
+
+export type WorktreeRaw = {
+  path: string
+  head: string
+  branch?: string
+  isLocked: boolean
+}
+
+export function parseWorktreePorcelain(output: string): WorktreeRaw[] {
+  const lines = output.split('\n')
+  const items: WorktreeRaw[] = []
+  let current: Partial<WorktreeRaw> = {}
+
+  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: string): WorktreeItem[] {
+  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/api/createApiApp.ts

@@ -0,0 +1,33 @@
+import express, { type Request, type Response, type NextFunction } from 'express'
+import cors from 'cors'
+import { createWorktreeRouter } from './routes/worktrees.js'
+
+export function createApiApp(getRepoRoot: () => string) {
+  const app: express.Application = 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: Request, res: Response) => {
+    res.status(200).json({ ok: true, data: { status: 'ok' } })
+  })
+
+  app.use((error: Error, req: Request, res: Response, next: NextFunction) => {
+    void error
+    void req
+    void next
+    res.status(500).json({
+      ok: false,
+      error: { code: 'INTERNAL', message: 'Server internal error' },
+    })
+  })
+
+  app.use((req: Request, res: Response) => {
+    res.status(404).json({ ok: false, error: { code: 'NOT_FOUND', message: 'API not found' } })
+  })
+
+  return app
+}

package/api/index.ts

@@ -0,0 +1,9 @@
+/**
+ * Vercel deploy entry handler, for serverless deployment, please don't modify this file
+ */
+import type { VercelRequest, VercelResponse } from '@vercel/node';
+import app from './app.js';
+
+export default function handler(req: VercelRequest, res: VercelResponse) {
+  return app(req, res);
+}

package/api/routes/worktrees.ts

@@ -0,0 +1,255 @@
+import express, { type Request, type Response } 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'
+import type {
+  ApiResult,
+  CreateWorktreeRequest,
+  RepoInfo,
+  WtuiConfig,
+  WorktreeItem,
+} from '../../shared/wtui-types.js'
+
+export function createWorktreeRouter(getRepoRoot: () => string) {
+  const router = express.Router()
+
+  const errMsg = (e: unknown) => (e instanceof Error ? e.message : String(e))
+
+  router.get('/repo', (req: Request, res: Response<ApiResult<RepoInfo>>) => {
+    try {
+      const rootPath = getRepoRoot()
+      const gitDirPath = getGitDirAbsolute(rootPath)
+      res.json({ ok: true, data: { rootPath, gitDirPath } })
+    } catch (e: unknown) {
+      res.status(400).json({
+        ok: false,
+        error: { code: 'REPO_NOT_FOUND', message: errMsg(e) || 'Repo not found' },
+      })
+    }
+  })
+
+  router.get(
+    '/worktrees',
+    (req: Request, res: Response<ApiResult<WorktreeItem[]>>) => {
+      try {
+        const root = getRepoRoot()
+        const items = listWorktrees(root)
+        res.json({ ok: true, data: items })
+      } catch (e: unknown) {
+        res.status(500).json({
+          ok: false,
+          error: { code: 'WORKTREE_LIST_FAILED', message: errMsg(e) || 'List failed' },
+        })
+      }
+    },
+  )
+
+  router.post(
+    '/worktrees',
+    (
+      req: Request<Record<string, never>, ApiResult<WorktreeItem>, CreateWorktreeRequest>,
+      res: Response<ApiResult<WorktreeItem>>,
+    ) => {
+      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: unknown) {
+        res.status(500).json({
+          ok: false,
+          error: {
+            code: 'WORKTREE_CREATE_FAILED',
+            message: '创建失败',
+            details: errMsg(e),
+          },
+        })
+      }
+    },
+  )
+
+  router.delete(
+    '/worktrees/:id',
+    (req: Request<{ id: string }>, res: Response<ApiResult<{ removed: true }>>) => {
+      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: unknown) {
+        res.status(500).json({
+          ok: false,
+          error: {
+            code: 'WORKTREE_REMOVE_FAILED',
+            message: '删除失败',
+            details: errMsg(e),
+          },
+        })
+      }
+    },
+  )
+
+  router.post(
+    '/worktrees/:id/open',
+    (req: Request<{ id: string }, ApiResult<{ launched: true }>, { type?: 'folder' | 'editor' }>, res: Response<ApiResult<{ launched: true }>>) => {
+      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: unknown) {
+        res.status(500).json({
+          ok: false,
+          error: { code: 'OPEN_FAILED', message: errMsg(e) || '打开失败' },
+        })
+      }
+    },
+  )
+
+  router.post(
+    '/worktrees/:id/lock',
+    (req: Request<{ id: string }>, res: Response<ApiResult<{ locked: true }>>) => {
+      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: unknown) {
+        res.status(500).json({
+          ok: false,
+          error: { code: 'LOCK_FAILED', message: errMsg(e) || 'Lock failed' },
+        })
+      }
+    },
+  )
+
+  router.post(
+    '/worktrees/:id/unlock',
+    (req: Request<{ id: string }>, res: Response<ApiResult<{ unlocked: true }>>) => {
+      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: unknown) {
+        res.status(500).json({
+          ok: false,
+          error: { code: 'UNLOCK_FAILED', message: errMsg(e) || 'Unlock failed' },
+        })
+      }
+    },
+  )
+
+  router.post('/worktrees/prune', (req: Request, res: Response<ApiResult<{ pruned: true }>>) => {
+    try {
+      const root = getRepoRoot()
+      gitOrThrow(root, ['worktree', 'prune'], 'WORKTREE_PRUNE')
+      res.json({ ok: true, data: { pruned: true } })
+    } catch (e: unknown) {
+      res.status(500).json({
+        ok: false,
+        error: { code: 'PRUNE_FAILED', message: errMsg(e) || 'Prune failed' },
+      })
+    }
+  })
+
+  router.get('/branches', (req: Request, res: Response<ApiResult<string[]>>) => {
+    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: unknown) {
+      res.status(500).json({
+        ok: false,
+        error: { code: 'BRANCH_LIST_FAILED', message: errMsg(e) || 'List branches failed' },
+      })
+    }
+  })
+
+  router.get('/config', (req: Request, res: Response<ApiResult<WtuiConfig>>) => {
+    res.json({ ok: true, data: readConfig() })
+  })
+
+  router.put(
+    '/config',
+    (req: Request<Record<string, never>, ApiResult<WtuiConfig>, WtuiConfig>, res: Response<ApiResult<WtuiConfig>>) => {
+      try {
+        const next = req.body || {}
+        writeConfig(next)
+        res.json({ ok: true, data: readConfig() })
+      } catch (e: unknown) {
+        res.status(500).json({
+          ok: false,
+          error: { code: 'CONFIG_WRITE_FAILED', message: '保存失败', details: errMsg(e) },
+        })
+      }
+    },
+  )
+
+  return router
+}

package/api/server.ts

@@ -0,0 +1,34 @@
+/**
+ * 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;