atoo-studio 0.0.1 → 0.0.2

package/dist/src/services/project-watcher.js

@@ -0,0 +1,307 @@
+import fs from 'fs';
+import path from 'path';
+import { getFileTree } from './fs-browser.js';
+import * as gitOps from './git-ops.js';
+import { store } from '../state/store.js';
+import { db } from '../state/db.js';
+// Debounce interval for filesystem events (ms)
+const DEBOUNCE_MS = 500;
+const watches = new Map();
+function broadcastToStatus(msg) {
+    const data = JSON.stringify(msg);
+    for (const ws of store.statusClients) {
+        if (ws.readyState === 1)
+            ws.send(data);
+    }
+}
+function handleFileChange(entry) {
+    if (entry.debounceTimer)
+        clearTimeout(entry.debounceTimer);
+    entry.debounceTimer = setTimeout(async () => {
+        entry.debounceTimer = null;
+        try {
+            const files = await getFileTree(entry.projectPath, 0, false, 1);
+            broadcastToStatus({
+                type: 'project_files_changed',
+                projectId: entry.projectId,
+                projectPath: entry.projectPath,
+                files,
+            });
+        }
+        catch (err) {
+            console.error(`[project-watcher] Error reading file tree for ${entry.projectId}:`, err);
+        }
+        // Also refresh git status — working tree changes affect git status
+        if (entry.gitWatcher) {
+            handleGitChange(entry);
+        }
+    }, DEBOUNCE_MS);
+}
+async function handleGitChange(entry) {
+    if (entry.gitDebounceTimer)
+        clearTimeout(entry.gitDebounceTimer);
+    entry.gitDebounceTimer = setTimeout(async () => {
+        entry.gitDebounceTimer = null;
+        try {
+            const [status, branches, stashes, remotes] = await Promise.all([
+                gitOps.gitStatus(entry.projectPath),
+                gitOps.gitBranches(entry.projectPath),
+                gitOps.gitStashList(entry.projectPath),
+                gitOps.gitRemotes(entry.projectPath),
+            ]);
+            let commits = [];
+            try {
+                commits = await gitOps.gitLog(entry.projectPath, undefined, 30);
+            }
+            catch { }
+            // Also refresh file tree — git operations (revert, checkout, stash) change working tree
+            try {
+                const files = await getFileTree(entry.projectPath, 0, false, 1);
+                broadcastToStatus({
+                    type: 'project_files_changed',
+                    projectId: entry.projectId,
+                    projectPath: entry.projectPath,
+                    files,
+                });
+            }
+            catch { }
+            broadcastToStatus({
+                type: 'project_git_changed',
+                projectId: entry.projectId,
+                projectPath: entry.projectPath,
+                gitChanges: status,
+                gitLog: {
+                    branches: branches.branches,
+                    currentBranch: branches.currentBranch,
+                    remotes,
+                    commits,
+                },
+                stashes,
+            });
+        }
+        catch (err) {
+            console.error(`[project-watcher] Error reading git data for ${entry.projectId}:`, err);
+        }
+    }, DEBOUNCE_MS);
+}
+// Reconcile worktree-linked projects: read .git/worktrees/ subdirectories and
+// ensure each worktree has a corresponding child project in the DB.
+function handleWorktreesChange(entry) {
+    if (entry.worktreesDebounceTimer)
+        clearTimeout(entry.worktreesDebounceTimer);
+    entry.worktreesDebounceTimer = setTimeout(() => {
+        entry.worktreesDebounceTimer = null;
+        reconcileWorktrees(entry.projectId, entry.projectPath);
+    }, DEBOUNCE_MS);
+}
+export function reconcileWorktrees(projectId, projectPath) {
+    const worktreesDir = path.join(projectPath, '.git', 'worktrees');
+    const discoveredPaths = new Map(); // wtPath -> branch
+    if (fs.existsSync(worktreesDir)) {
+        try {
+            const entries = fs.readdirSync(worktreesDir, { withFileTypes: true });
+            for (const ent of entries) {
+                if (!ent.isDirectory())
+                    continue;
+                const wtDir = path.join(worktreesDir, ent.name);
+                // Read gitdir to find the worktree path
+                const gitdirFile = path.join(wtDir, 'gitdir');
+                if (!fs.existsSync(gitdirFile))
+                    continue;
+                try {
+                    const gitdirContent = fs.readFileSync(gitdirFile, 'utf8').trim();
+                    // gitdir points to <worktree-path>/.git — so the worktree path is the parent
+                    const wtPath = path.dirname(gitdirContent);
+                    // Read branch from HEAD
+                    let branch = ent.name;
+                    const headFile = path.join(wtDir, 'HEAD');
+                    if (fs.existsSync(headFile)) {
+                        const headContent = fs.readFileSync(headFile, 'utf8').trim();
+                        const match = headContent.match(/^ref: refs\/heads\/(.+)$/);
+                        if (match)
+                            branch = match[1];
+                    }
+                    discoveredPaths.set(wtPath, branch);
+                }
+                catch { }
+            }
+        }
+        catch { }
+    }
+    // Get existing child projects
+    const existingChildren = db.getChildProjects(projectId);
+    const existingPaths = new Set(existingChildren.map(c => c.path));
+    // Get environments this parent is linked to (so we can link new children too)
+    const parentEnvs = db.getEnvironmentsForProject(projectId);
+    // Record all discovered worktree paths in history (idempotent)
+    for (const [wtPath] of discoveredPaths) {
+        db.recordWorktreePath(projectId, wtPath);
+    }
+    // Add new worktrees as child projects
+    for (const [wtPath, branch] of discoveredPaths) {
+        if (existingPaths.has(wtPath))
+            continue;
+        console.log(`[project-watcher] Discovered new worktree: ${wtPath} (${branch})`);
+        const childProject = db.createProject(branch, wtPath, { parentProjectId: projectId });
+        // Link to same environments as parent
+        for (const env of parentEnvs) {
+            db.linkProject(childProject.id, env.id);
+        }
+        // Start watching the child project
+        watchProject(childProject.id, wtPath);
+        // Notify frontend
+        broadcastToStatus({ type: 'worktrees_changed', parentProjectId: projectId });
+    }
+    // Remove child projects whose worktree no longer exists
+    for (const child of existingChildren) {
+        if (!discoveredPaths.has(child.path)) {
+            console.log(`[project-watcher] Worktree removed: ${child.path}`);
+            unwatchProject(child.id);
+            db.deleteProject(child.id);
+            broadcastToStatus({ type: 'worktrees_changed', parentProjectId: projectId });
+        }
+    }
+}
+function startWorktreesWatcher(entry) {
+    const worktreesDir = path.join(entry.projectPath, '.git', 'worktrees');
+    if (!fs.existsSync(worktreesDir))
+        return null;
+    try {
+        const watcher = fs.watch(worktreesDir, (_eventType, _filename) => {
+            const e = watches.get(entry.projectId);
+            if (e)
+                handleWorktreesChange(e);
+        });
+        watcher.on('error', () => { });
+        return watcher;
+    }
+    catch {
+        return null;
+    }
+}
+export function watchProject(projectId, projectPath) {
+    // Already watching
+    if (watches.has(projectId))
+        return;
+    try {
+        const watcher = fs.watch(projectPath, { recursive: true }, (_eventType, filename) => {
+            if (!filename)
+                return;
+            // Skip .git directory changes - handled by git watcher
+            if (filename.startsWith('.git' + path.sep) || filename === '.git')
+                return;
+            const entry = watches.get(projectId);
+            if (entry)
+                handleFileChange(entry);
+        });
+        let gitWatcher = null;
+        const gitPath = path.join(projectPath, '.git');
+        if (fs.existsSync(gitPath)) {
+            const stat = fs.statSync(gitPath);
+            if (stat.isDirectory()) {
+                // Normal project with .git directory
+                try {
+                    gitWatcher = fs.watch(gitPath, { recursive: true }, (_eventType, filename) => {
+                        const entry = watches.get(projectId);
+                        if (!entry)
+                            return;
+                        handleGitChange(entry);
+                        // If change is in the worktrees/ subdir or worktrees dir was created/removed, reconcile
+                        if (filename && (filename === 'worktrees' || filename.startsWith('worktrees' + path.sep))) {
+                            // Start worktrees watcher if it doesn't exist yet
+                            if (!entry.worktreesWatcher) {
+                                entry.worktreesWatcher = startWorktreesWatcher(entry);
+                            }
+                            handleWorktreesChange(entry);
+                        }
+                    });
+                    gitWatcher.on('error', () => { });
+                }
+                catch { }
+            }
+            else if (stat.isFile()) {
+                // Worktree project with .git file pointing to main repo
+                try {
+                    const content = fs.readFileSync(gitPath, 'utf8').trim();
+                    const match = content.match(/^gitdir:\s*(.+)$/);
+                    if (match) {
+                        const gitDir = path.resolve(projectPath, match[1]);
+                        if (fs.existsSync(gitDir)) {
+                            gitWatcher = fs.watch(gitDir, { recursive: true }, () => {
+                                const entry = watches.get(projectId);
+                                if (entry)
+                                    handleGitChange(entry);
+                            });
+                            gitWatcher.on('error', () => { });
+                        }
+                    }
+                }
+                catch { }
+            }
+        }
+        const entry = {
+            watcher,
+            gitWatcher,
+            worktreesWatcher: null,
+            debounceTimer: null,
+            gitDebounceTimer: null,
+            worktreesDebounceTimer: null,
+            projectId,
+            projectPath,
+        };
+        watches.set(projectId, entry);
+        // Start worktrees watcher if .git/worktrees/ already exists
+        entry.worktreesWatcher = startWorktreesWatcher(entry);
+        // Initial reconciliation of worktrees
+        const gitPath2 = path.join(projectPath, '.git');
+        if (fs.existsSync(gitPath2) && fs.statSync(gitPath2).isDirectory()) {
+            reconcileWorktrees(projectId, projectPath);
+        }
+        watcher.on('error', () => {
+            unwatchProject(projectId);
+        });
+        console.log(`[project-watcher] Watching ${projectPath} (project ${projectId})`);
+    }
+    catch (err) {
+        console.error(`[project-watcher] Failed to watch ${projectPath}:`, err);
+    }
+}
+export function unwatchProject(projectId) {
+    const entry = watches.get(projectId);
+    if (!entry)
+        return;
+    if (entry.debounceTimer)
+        clearTimeout(entry.debounceTimer);
+    if (entry.gitDebounceTimer)
+        clearTimeout(entry.gitDebounceTimer);
+    if (entry.worktreesDebounceTimer)
+        clearTimeout(entry.worktreesDebounceTimer);
+    try {
+        entry.watcher.close();
+    }
+    catch { }
+    try {
+        entry.gitWatcher?.close();
+    }
+    catch { }
+    try {
+        entry.worktreesWatcher?.close();
+    }
+    catch { }
+    watches.delete(projectId);
+    console.log(`[project-watcher] Stopped watching project ${projectId}`);
+}
+export function watchEnvironmentProjects(envId) {
+    const projects = db.getProjectsForEnvironment(envId);
+    for (const proj of projects) {
+        watchProject(proj.id, proj.path);
+    }
+}
+export function unwatchAll() {
+    for (const id of Array.from(watches.keys())) {
+        unwatchProject(id);
+    }
+}
+export function isWatching(projectId) {
+    return watches.has(projectId);
+}

package/dist/src/services/remote-fs-browser.d.ts

@@ -0,0 +1,11 @@
+interface FileNode {
+    name: string;
+    type: 'file' | 'dir';
+    children?: FileNode[];
+}
+export declare function getRemoteFileTree(connId: string, dirPath: string, depth?: number): Promise<FileNode[]>;
+export declare function readRemoteFileContent(connId: string, filePath: string): Promise<{
+    content: string;
+    lang: string;
+}>;
+export {};

package/dist/src/services/remote-fs-browser.js

@@ -0,0 +1,50 @@
+import path from 'path';
+import { sshManager } from './ssh-manager.js';
+const SKIP_DIRS = new Set(['.git', 'node_modules', '.next', '.nuxt', 'dist', 'build', '__pycache__', '.venv', 'venv', '.cache', '.parcel-cache', 'coverage', '.svn', '.hg']);
+const MAX_DEPTH = 8;
+const MAX_ENTRIES = 2000;
+export async function getRemoteFileTree(connId, dirPath, depth = 0) {
+    if (depth > MAX_DEPTH)
+        return [];
+    let entries;
+    try {
+        entries = await sshManager.sftpReaddir(connId, dirPath);
+    }
+    catch {
+        return [];
+    }
+    const result = [];
+    let count = 0;
+    for (const entry of entries) {
+        if (count >= MAX_ENTRIES)
+            break;
+        if (entry.type === 'dir') {
+            if (SKIP_DIRS.has(entry.name))
+                continue;
+            const children = await getRemoteFileTree(connId, path.posix.join(dirPath, entry.name), depth + 1);
+            result.push({ name: entry.name, type: 'dir', children });
+        }
+        else {
+            result.push({ name: entry.name, type: 'file' });
+        }
+        count++;
+    }
+    return result;
+}
+const EXT_LANG_MAP = {
+    ts: 'typescript', tsx: 'typescript', js: 'javascript', jsx: 'javascript',
+    py: 'python', rs: 'rust', go: 'go', java: 'java', c: 'c', cpp: 'cpp', h: 'c',
+    cs: 'csharp', rb: 'ruby', php: 'php', swift: 'swift', kt: 'kotlin',
+    json: 'json', yaml: 'yaml', yml: 'yaml', toml: 'toml', xml: 'xml',
+    md: 'markdown', html: 'html', css: 'css', scss: 'scss', less: 'less',
+    sql: 'sql', sh: 'shell', bash: 'shell', zsh: 'shell',
+    dockerfile: 'dockerfile', makefile: 'makefile',
+    astro: 'html', vue: 'html', svelte: 'html',
+};
+export async function readRemoteFileContent(connId, filePath) {
+    const content = await sshManager.sftpReadFile(connId, filePath);
+    const ext = path.extname(filePath).toLowerCase().replace('.', '');
+    const basename = path.basename(filePath).toLowerCase();
+    const lang = EXT_LANG_MAP[ext] || EXT_LANG_MAP[basename] || 'plaintext';
+    return { content, lang };
+}

package/dist/src/services/remote-git-ops.d.ts

@@ -0,0 +1,71 @@
+export declare function gitInit(connId: string, cwd: string): Promise<void>;
+export declare function gitClone(connId: string, url: string, dest: string): Promise<void>;
+export declare function gitStatus(connId: string, cwd: string): Promise<{
+    status: string;
+    file: string;
+    staged: boolean;
+    indexStatus: string;
+    workTreeStatus: string;
+    oldPath: string | undefined;
+}[]>;
+export declare function gitLog(connId: string, cwd: string, branch?: string, count?: number): Promise<{
+    hash: string;
+    fullHash: string;
+    msg: string;
+    fullMessage: string;
+    author: string;
+    date: string;
+    files: never[];
+    merge: boolean;
+}[]>;
+export declare function gitCommitFiles(connId: string, cwd: string, hash: string): Promise<{
+    path: string;
+    status: string;
+    additions: number;
+    deletions: number;
+}[]>;
+export declare function gitBranches(connId: string, cwd: string): Promise<{
+    branches: string[];
+    currentBranch: string;
+}>;
+export declare function gitCheckout(connId: string, cwd: string, branch: string): Promise<void>;
+export declare function gitCommit(connId: string, cwd: string, message: string): Promise<void>;
+export declare function gitPush(connId: string, cwd: string): Promise<void>;
+export declare function gitStash(connId: string, cwd: string): Promise<void>;
+export declare function gitStashList(connId: string, cwd: string): Promise<{
+    id: string;
+    name: string;
+}[]>;
+export declare function gitStashApply(connId: string, cwd: string, id: string): Promise<void>;
+export declare function gitStashDrop(connId: string, cwd: string, id: string): Promise<void>;
+export declare function gitCreateBranch(connId: string, cwd: string, name: string): Promise<void>;
+export declare function gitFetch(connId: string, cwd: string): Promise<void>;
+export declare function gitRemotes(connId: string, cwd: string): Promise<{
+    name: string;
+    url: string;
+    type: string;
+}[]>;
+export declare function gitAddRemote(connId: string, cwd: string, name: string, url: string): Promise<void>;
+export declare function gitRemoveRemote(connId: string, cwd: string, name: string): Promise<void>;
+export declare function gitEditRemote(connId: string, cwd: string, name: string, url: string): Promise<void>;
+export declare function gitDiff(connId: string, cwd: string, file?: string): Promise<string>;
+export declare function gitRevert(connId: string, cwd: string, file?: string): Promise<void>;
+export declare function gitUnstageFile(connId: string, cwd: string, file: string): Promise<void>;
+export declare function gitStageFile(connId: string, cwd: string, file: string): Promise<void>;
+export declare function gitShowFile(connId: string, cwd: string, file: string, ref?: string): Promise<string>;
+export declare function gitBlame(connId: string, cwd: string, file: string): Promise<string>;
+export declare function gitFileLog(connId: string, cwd: string, file: string): Promise<{
+    hash: string;
+    author: string;
+    date: string;
+    msg: string;
+}[]>;
+export declare function gitWorktreeList(connId: string, cwd: string): Promise<{
+    path: string;
+    head: string;
+    branch: string;
+    bare?: boolean;
+}[]>;
+export declare function gitWorktreeAdd(connId: string, cwd: string, wtPath: string, branch?: string, newBranch?: boolean): Promise<void>;
+export declare function gitWorktreeRemove(connId: string, cwd: string, worktreePath: string): Promise<void>;
+export declare function gitBranchDelete(connId: string, cwd: string, branch: string): Promise<void>;

package/dist/src/services/remote-git-ops.js

@@ -0,0 +1,215 @@
+import { sshManager } from './ssh-manager.js';
+function shellEscape(s) {
+    return "'" + s.replace(/'/g, "'\\''") + "'";
+}
+async function git(connId, args, cwd) {
+    const escapedArgs = args.map(a => shellEscape(a)).join(' ');
+    return sshManager.exec(connId, `git ${escapedArgs}`, { cwd });
+}
+export async function gitInit(connId, cwd) {
+    await git(connId, ['init'], cwd);
+}
+export async function gitClone(connId, url, dest) {
+    await sshManager.exec(connId, `git clone ${shellEscape(url)} ${shellEscape(dest)}`);
+}
+export async function gitStatus(connId, cwd) {
+    const output = await git(connId, ['status', '--porcelain', '-uall', '-M'], cwd);
+    return output.split('\n').filter(Boolean).map(line => {
+        const x = line[0];
+        const y = line[1];
+        const rest = line.substring(3);
+        let file = rest;
+        let oldPath;
+        if (x === 'R' || y === 'R') {
+            const arrowIdx = rest.indexOf(' -> ');
+            if (arrowIdx >= 0) {
+                file = rest.substring(0, arrowIdx);
+                oldPath = rest.substring(arrowIdx + 4);
+            }
+        }
+        let status = (x + y).trim() || '?';
+        const staged = x !== ' ' && x !== '?' && x !== '!';
+        return { status, file, staged, indexStatus: x, workTreeStatus: y, oldPath };
+    });
+}
+export async function gitLog(connId, cwd, branch, count = 30) {
+    const SEP = '---GIT-LOG-SEP---';
+    const args = ['log', `--format=${SEP}%n%H%n%h%n%an%n%ar%n%s%n%B`, '-n', String(count)];
+    if (branch)
+        args.push(branch);
+    const output = await git(connId, args, cwd);
+    const entries = output.split(SEP).filter(e => e.trim());
+    return entries.map(entry => {
+        const lines = entry.trim().split('\n');
+        const fullHash = lines[0] || '';
+        const hash = lines[1] || '';
+        const author = lines[2] || '';
+        const date = lines[3] || '';
+        const msg = lines[4] || '';
+        const fullMessage = lines.slice(5).join('\n').trim() || msg;
+        const isMerge = msg.toLowerCase().startsWith('merge');
+        return { hash, fullHash, msg, fullMessage, author, date, files: [], merge: isMerge };
+    });
+}
+export async function gitCommitFiles(connId, cwd, hash) {
+    const output = await git(connId, ['diff-tree', '--no-commit-id', '-r', '--name-status', hash], cwd);
+    return output.trim().split('\n').filter(Boolean).map(line => {
+        const parts = line.split('\t');
+        const statusChar = parts[0]?.[0] || 'M';
+        const filePath = parts[1] || '';
+        const statusMap = { A: 'A', M: 'M', D: 'D', R: 'R', C: 'C' };
+        return { path: filePath, status: statusMap[statusChar] || 'M', additions: 0, deletions: 0 };
+    });
+}
+export async function gitBranches(connId, cwd) {
+    const output = await git(connId, ['branch', '-a', '--no-color'], cwd);
+    const branches = [];
+    let currentBranch = '';
+    output.split('\n').filter(Boolean).forEach(line => {
+        const trimmed = line.trim();
+        if (trimmed.startsWith('* ')) {
+            currentBranch = trimmed.substring(2);
+            branches.push(currentBranch);
+        }
+        else {
+            branches.push(trimmed);
+        }
+    });
+    return { branches, currentBranch };
+}
+export async function gitCheckout(connId, cwd, branch) {
+    await git(connId, ['checkout', branch], cwd);
+}
+export async function gitCommit(connId, cwd, message) {
+    await git(connId, ['add', '-A'], cwd);
+    await git(connId, ['commit', '-m', message], cwd);
+}
+export async function gitPush(connId, cwd) {
+    await git(connId, ['push'], cwd);
+}
+export async function gitStash(connId, cwd) {
+    await git(connId, ['stash', 'push'], cwd);
+}
+export async function gitStashList(connId, cwd) {
+    const output = await git(connId, ['stash', 'list'], cwd);
+    return output.split('\n').filter(Boolean).map((line, i) => ({
+        id: `stash@{${i}}`,
+        name: line,
+    }));
+}
+export async function gitStashApply(connId, cwd, id) {
+    await git(connId, ['stash', 'apply', id], cwd);
+}
+export async function gitStashDrop(connId, cwd, id) {
+    await git(connId, ['stash', 'drop', id], cwd);
+}
+export async function gitCreateBranch(connId, cwd, name) {
+    await git(connId, ['checkout', '-b', name], cwd);
+}
+export async function gitFetch(connId, cwd) {
+    await git(connId, ['fetch', '--all'], cwd);
+}
+export async function gitRemotes(connId, cwd) {
+    const output = await git(connId, ['remote', '-v'], cwd);
+    const remotes = [];
+    const seen = new Set();
+    output.split('\n').filter(Boolean).forEach(line => {
+        const parts = line.split(/\s+/);
+        const name = parts[0];
+        const url = parts[1];
+        if (!seen.has(name)) {
+            seen.add(name);
+            remotes.push({ name, url, type: url.includes('@') ? 'ssh' : 'https' });
+        }
+    });
+    return remotes;
+}
+export async function gitAddRemote(connId, cwd, name, url) {
+    await git(connId, ['remote', 'add', name, url], cwd);
+}
+export async function gitRemoveRemote(connId, cwd, name) {
+    await git(connId, ['remote', 'remove', name], cwd);
+}
+export async function gitEditRemote(connId, cwd, name, url) {
+    await git(connId, ['remote', 'set-url', name, url], cwd);
+}
+export async function gitDiff(connId, cwd, file) {
+    const args = ['diff'];
+    if (file)
+        args.push('--', file);
+    return await git(connId, args, cwd);
+}
+export async function gitRevert(connId, cwd, file) {
+    if (file) {
+        await git(connId, ['checkout', '--', file], cwd);
+    }
+    else {
+        await git(connId, ['checkout', '.'], cwd);
+        await git(connId, ['clean', '-fd'], cwd);
+    }
+}
+export async function gitUnstageFile(connId, cwd, file) {
+    await git(connId, ['reset', 'HEAD', '--', file], cwd);
+}
+export async function gitStageFile(connId, cwd, file) {
+    await git(connId, ['add', file], cwd);
+}
+export async function gitShowFile(connId, cwd, file, ref = 'HEAD') {
+    return await git(connId, ['show', `${ref}:${file}`], cwd);
+}
+export async function gitBlame(connId, cwd, file) {
+    return await git(connId, ['blame', '--porcelain', file], cwd);
+}
+export async function gitFileLog(connId, cwd, file) {
+    const output = await git(connId, ['log', '--format=%h|%an|%ar|%s', '-n', '20', '--follow', '--', file], cwd);
+    return output.split('\n').filter(Boolean).map(line => {
+        const [hash, author, date, ...msgParts] = line.split('|');
+        return { hash, author, date, msg: msgParts.join('|') };
+    });
+}
+export async function gitWorktreeList(connId, cwd) {
+    const output = await git(connId, ['worktree', 'list', '--porcelain'], cwd);
+    const worktrees = [];
+    let current = {};
+    for (const line of output.split('\n')) {
+        if (line.startsWith('worktree ')) {
+            if (current.path)
+                worktrees.push(current);
+            current = { path: line.substring(9) };
+        }
+        else if (line.startsWith('HEAD ')) {
+            current.head = line.substring(5);
+        }
+        else if (line.startsWith('branch ')) {
+            current.branch = line.substring(7).replace('refs/heads/', '');
+        }
+        else if (line === 'bare') {
+            current.bare = true;
+        }
+        else if (line === 'detached') {
+            current.branch = '(detached)';
+        }
+    }
+    if (current.path)
+        worktrees.push(current);
+    return worktrees;
+}
+export async function gitWorktreeAdd(connId, cwd, wtPath, branch, newBranch) {
+    const args = ['worktree', 'add'];
+    if (newBranch && branch) {
+        args.push('-b', branch, wtPath);
+    }
+    else if (branch) {
+        args.push(wtPath, branch);
+    }
+    else {
+        args.push(wtPath);
+    }
+    await git(connId, args, cwd);
+}
+export async function gitWorktreeRemove(connId, cwd, worktreePath) {
+    await git(connId, ['worktree', 'remove', worktreePath], cwd);
+}
+export async function gitBranchDelete(connId, cwd, branch) {
+    await git(connId, ['branch', '-D', branch], cwd);
+}