@plusplusoneplusplus/coc 1.0.0

package/dist/server/repos/tree-service.js

@@ -0,0 +1,693 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RepoTreeService = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const childProcess = __importStar(require("child_process"));
+const child_process_1 = require("child_process");
+const util_1 = require("util");
+const execFileAsync = (0, util_1.promisify)(child_process_1.execFile);
+/** Extension → MIME type map for common file types. */
+const MIME_MAP = {
+    '.js': 'application/javascript',
+    '.mjs': 'application/javascript',
+    '.cjs': 'application/javascript',
+    '.ts': 'application/typescript',
+    '.tsx': 'application/typescript',
+    '.jsx': 'application/javascript',
+    '.json': 'application/json',
+    '.html': 'text/html',
+    '.htm': 'text/html',
+    '.css': 'text/css',
+    '.md': 'text/markdown',
+    '.markdown': 'text/markdown',
+    '.txt': 'text/plain',
+    '.xml': 'application/xml',
+    '.yaml': 'application/x-yaml',
+    '.yml': 'application/x-yaml',
+    '.toml': 'application/toml',
+    '.sh': 'application/x-sh',
+    '.bash': 'application/x-sh',
+    '.py': 'text/x-python',
+    '.rb': 'text/x-ruby',
+    '.go': 'text/x-go',
+    '.rs': 'text/x-rust',
+    '.java': 'text/x-java',
+    '.c': 'text/x-c',
+    '.cpp': 'text/x-c++',
+    '.h': 'text/x-c',
+    '.hpp': 'text/x-c++',
+    '.cs': 'text/x-csharp',
+    '.swift': 'text/x-swift',
+    '.kt': 'text/x-kotlin',
+    '.scala': 'text/x-scala',
+    '.php': 'text/x-php',
+    '.sql': 'application/sql',
+    '.graphql': 'application/graphql',
+    '.svg': 'image/svg+xml',
+    '.png': 'image/png',
+    '.jpg': 'image/jpeg',
+    '.jpeg': 'image/jpeg',
+    '.gif': 'image/gif',
+    '.webp': 'image/webp',
+    '.ico': 'image/x-icon',
+    '.pdf': 'application/pdf',
+    '.zip': 'application/zip',
+    '.gz': 'application/gzip',
+    '.tar': 'application/x-tar',
+    '.wasm': 'application/wasm',
+    '.woff': 'font/woff',
+    '.woff2': 'font/woff2',
+    '.ttf': 'font/ttf',
+    '.eot': 'application/vnd.ms-fontobject',
+    '.env': 'text/plain',
+    '.log': 'text/plain',
+    '.csv': 'text/csv',
+    '.lock': 'text/plain',
+};
+/** Maximum file size for readBlob (1 MB). */
+const MAX_BLOB_SIZE = 1 * 1024 * 1024;
+/** Number of bytes to scan for binary detection. */
+const BINARY_PROBE_SIZE = 8192;
+function getMimeType(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    return MIME_MAP[ext] ?? 'application/octet-stream';
+}
+/**
+ * Returns true if the buffer likely represents binary content
+ * (contains null bytes in the first 8 KB).
+ */
+function isBinary(buffer) {
+    const limit = Math.min(buffer.length, BINARY_PROBE_SIZE);
+    for (let i = 0; i < limit; i++) {
+        if (buffer[i] === 0)
+            return true;
+    }
+    return false;
+}
+/**
+ * Strips leading path separators so that absolute-looking relative paths
+ * (e.g. "/" or "/src") are treated as repo-relative instead of filesystem root.
+ */
+function stripLeadingSeparators(p) {
+    return p.replace(/^[/\\]+/, '') || '.';
+}
+/**
+ * Validates that resolvedPath is inside repoRoot (path traversal guard).
+ * Throws if the path escapes the repo root.
+ */
+function assertInsideRepo(repoRoot, resolvedPath) {
+    const normalizedRoot = path.resolve(repoRoot);
+    const normalizedTarget = path.resolve(resolvedPath);
+    if (normalizedTarget !== normalizedRoot && !normalizedTarget.startsWith(normalizedRoot + path.sep)) {
+        throw new Error(`Path traversal detected: path escapes repo root`);
+    }
+}
+/**
+ * Spawns `git check-ignore --stdin` asynchronously and returns stdout.
+ * Resolves to empty string on error or timeout.
+ */
+function spawnGitCheckIgnore(repoRoot, input) {
+    return new Promise((resolve) => {
+        let stdout = '';
+        let settled = false;
+        const settle = () => {
+            if (!settled) {
+                settled = true;
+                clearTimeout(timer);
+                resolve(stdout);
+            }
+        };
+        const child = childProcess.spawn('git', ['check-ignore', '--stdin'], {
+            cwd: repoRoot,
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        child.stdout.on('data', (chunk) => { stdout += chunk.toString('utf-8'); });
+        child.stdin.on('error', () => { }); // ignore broken pipe errors
+        child.stdin.write(input, 'utf-8');
+        child.stdin.end();
+        const timer = setTimeout(() => { try {
+            child.kill();
+        }
+        catch { } settle(); }, 5000);
+        child.on('close', settle);
+        child.on('error', settle);
+    });
+}
+/**
+ * Runs `git check-ignore --stdin` asynchronously to determine which entries are gitignored.
+ * Accepts entries as { name, isDir } pairs relative to `dirPath`.
+ * Returns a Set of entry names that are ignored.
+ * Falls back to an empty set if git is unavailable or the directory is not a git repo.
+ */
+async function getGitIgnoredNames(repoRoot, dirPath, entries) {
+    if (entries.length === 0)
+        return new Set();
+    try {
+        // Build relative paths from repoRoot, using forward slashes.
+        // Directories get a trailing '/' so that gitignore patterns like "dist/" match.
+        const relDir = path.relative(repoRoot, dirPath).split(path.sep).join('/');
+        const lines = [];
+        const nameByLine = [];
+        for (const entry of entries) {
+            const rel = relDir ? `${relDir}/${entry.name}` : entry.name;
+            lines.push(entry.isDir ? `${rel}/` : rel);
+            nameByLine.push(entry.name);
+        }
+        const input = lines.join('\n') + '\n';
+        const stdout = await spawnGitCheckIgnore(repoRoot, input);
+        // Parse output — each ignored line corresponds to the input path.
+        // git outputs the matched paths (with possible trailing '/').
+        const ignoredPaths = new Set();
+        for (const line of stdout.split('\n')) {
+            const trimmed = line.trim();
+            if (trimmed)
+                ignoredPaths.add(trimmed.replace(/\/$/, ''));
+        }
+        // Map back to entry names
+        const ignoredNames = new Set();
+        for (let i = 0; i < lines.length; i++) {
+            const cleanLine = lines[i].replace(/\/$/, '');
+            if (ignoredPaths.has(cleanLine)) {
+                ignoredNames.add(nameByLine[i]);
+            }
+        }
+        return ignoredNames;
+    }
+    catch {
+        // git not available, not a git repo, or empty input — treat nothing as ignored
+        return new Set();
+    }
+}
+class RepoTreeService {
+    static async checkRipgrepAvailable() {
+        if (RepoTreeService.rgAvailable !== undefined)
+            return RepoTreeService.rgAvailable;
+        try {
+            await execFileAsync('rg', ['--version']);
+            RepoTreeService.rgAvailable = true;
+        }
+        catch {
+            RepoTreeService.rgAvailable = false;
+        }
+        return RepoTreeService.rgAvailable;
+    }
+    /**
+     * Uses `rg --files --hidden --max-depth 1` to determine which file entries are gitignored.
+     * rg natively respects .gitignore, so files absent from its output are ignored.
+     * Directories are not handled here (rg --files never lists them).
+     * Returns null if rg is unavailable or encounters an error (caller should fall back).
+     */
+    static async getIgnoredNamesViaRipgrep(absPath, entries) {
+        const available = await RepoTreeService.checkRipgrepAvailable();
+        if (!available)
+            return null;
+        try {
+            const result = await execFileAsync('rg', ['--files', '--hidden', '--max-depth', '1', '--', absPath], {
+                encoding: 'utf-8',
+                maxBuffer: 10 * 1024 * 1024,
+            });
+            const listedFiles = new Set(result.stdout.split('\n')
+                .map((l) => path.basename(l.trim()))
+                .filter(Boolean));
+            // Anything not listed by rg is a gitignored file
+            const ignoredNames = new Set();
+            for (const entry of entries) {
+                if (!entry.isDir && !listedFiles.has(entry.name)) {
+                    ignoredNames.add(entry.name);
+                }
+            }
+            return ignoredNames;
+        }
+        catch (err) {
+            if (err.code === 1)
+                return new Set(); // no files found — nothing ignored
+            return null; // rg error → fall back
+        }
+    }
+    /**
+     * Returns the set of entry names that should be hidden from directory listings.
+     * Primary path: rg for files (non-blocking) + async git check-ignore for dirs.
+     * Fallback: async git check-ignore for all entries when rg is unavailable.
+     */
+    static async getIgnoredNames(repoRoot, absPath, entries) {
+        if (entries.length === 0)
+            return new Set();
+        const dirEntries = entries.filter(e => e.isDir);
+        const rgResult = await RepoTreeService.getIgnoredNamesViaRipgrep(absPath, entries);
+        if (rgResult === null) {
+            // rg unavailable — fall back to async git check-ignore for everything
+            return getGitIgnoredNames(repoRoot, absPath, entries);
+        }
+        // rg available — handle dirs via async git check-ignore, files already covered by rg
+        const dirIgnored = dirEntries.length > 0
+            ? await getGitIgnoredNames(repoRoot, absPath, dirEntries)
+            : new Set();
+        return new Set([...rgResult, ...dirIgnored]);
+    }
+    async listFilesWithRipgrep(repoRoot, options) {
+        const available = await RepoTreeService.checkRipgrepAvailable();
+        if (!available)
+            return null;
+        const maxEntries = options?.maxEntries ?? 5000;
+        const args = ['--files', '--hidden'];
+        if (options?.showIgnored)
+            args.push('--no-ignore');
+        args.push('--', repoRoot);
+        let stdout;
+        try {
+            const result = await execFileAsync('rg', args, {
+                encoding: 'utf-8',
+                maxBuffer: 50 * 1024 * 1024,
+            });
+            stdout = result.stdout;
+        }
+        catch (err) {
+            // exit code 1 = no files found (valid empty result)
+            if (err.code === 1) {
+                return { files: [], truncated: false };
+            }
+            // exit code 2 or other = real error, fall back to existing walk
+            return null;
+        }
+        const allFiles = stdout
+            .split('\n')
+            .map((l) => l.trim())
+            .filter(Boolean)
+            .map((absPath) => path.relative(repoRoot, absPath).split(path.sep).join('/'));
+        const truncated = allFiles.length > maxEntries;
+        return { files: allFiles.slice(0, maxEntries), truncated };
+    }
+    constructor(dataDir, options) {
+        this.dataDir = dataDir;
+        this.maxEntries = options?.maxEntries ?? 5000;
+    }
+    /**
+     * List all registered repos from workspaces.json.
+     * @returns Array of RepoInfo with headSha resolved from git.
+     */
+    async listRepos() {
+        const workspaces = await this.readWorkspaces();
+        return workspaces.map(ws => RepoTreeService.toRepoInfo(ws));
+    }
+    /**
+     * Resolve a repo by ID. Returns undefined if not found.
+     */
+    async resolveRepo(repoId) {
+        const workspaces = await this.readWorkspaces();
+        const ws = workspaces.find(w => w.id === repoId);
+        return ws ? RepoTreeService.toRepoInfo(ws) : undefined;
+    }
+    /**
+     * List the contents of `relativePath` inside the repo identified by `repoId`.
+     *
+     * @param repoId       Stable workspace ID.
+     * @param relativePath Path relative to repo root ('.' or '' = root).
+     * @param options      Optional listing options.
+     * @returns TreeListResult with entries (dirs-first, alpha-sorted), or throws if
+     *          path is outside repo root (traversal guard) or does not exist.
+     */
+    async listDirectory(repoId, relativePath, options) {
+        const repo = await this.resolveRepo(repoId);
+        if (!repo) {
+            throw new Error(`Repo not found: ${repoId}`);
+        }
+        const repoRoot = repo.localPath;
+        const normalizedRel = stripLeadingSeparators(relativePath === '' || relativePath === '.' ? '.' : relativePath);
+        const absPath = path.resolve(repoRoot, normalizedRel);
+        assertInsideRepo(repoRoot, absPath);
+        let stat;
+        try {
+            stat = await fs.promises.stat(absPath);
+        }
+        catch {
+            throw new Error(`Path does not exist: ${relativePath}`);
+        }
+        if (!stat.isDirectory()) {
+            throw new Error(`Not a directory: ${relativePath}`);
+        }
+        const dirents = await fs.promises.readdir(absPath, { withFileTypes: true });
+        // Resolve symlinks and filter out broken ones
+        const resolvedEntries = [];
+        for (const dirent of dirents) {
+            const fullPath = path.join(absPath, dirent.name);
+            if (dirent.isSymbolicLink()) {
+                try {
+                    const targetStat = await fs.promises.stat(fullPath);
+                    resolvedEntries.push({ dirent, isDir: targetStat.isDirectory() });
+                }
+                catch {
+                    // Broken symlink — skip
+                    continue;
+                }
+            }
+            else {
+                resolvedEntries.push({ dirent, isDir: dirent.isDirectory() });
+            }
+        }
+        // Gitignore filtering
+        const showIgnored = options?.showIgnored ?? false;
+        let filteredEntries = resolvedEntries;
+        if (!showIgnored) {
+            const entryInfos = resolvedEntries.map(e => ({ name: e.dirent.name, isDir: e.isDir }));
+            const ignoredNames = await RepoTreeService.getIgnoredNames(repoRoot, absPath, entryInfos);
+            if (ignoredNames.size > 0) {
+                filteredEntries = resolvedEntries.filter(e => !ignoredNames.has(e.dirent.name));
+            }
+        }
+        // Sort: dirs first, then alphabetical
+        filteredEntries.sort((a, b) => {
+            if (a.isDir !== b.isDir)
+                return a.isDir ? -1 : 1;
+            return a.dirent.name.localeCompare(b.dirent.name);
+        });
+        // Size guard
+        const truncated = filteredEntries.length > this.maxEntries;
+        const sliced = truncated ? filteredEntries.slice(0, this.maxEntries) : filteredEntries;
+        // Build TreeEntry[]
+        const entries = [];
+        for (const { dirent, isDir } of sliced) {
+            const fullPath = path.join(absPath, dirent.name);
+            const relPath = path.relative(repoRoot, fullPath).split(path.sep).join('/');
+            let size;
+            if (!isDir) {
+                try {
+                    const fileStat = await fs.promises.stat(fullPath);
+                    size = fileStat.size;
+                }
+                catch {
+                    // Broken symlink or permission error — size stays undefined
+                }
+            }
+            entries.push({
+                name: dirent.name,
+                type: isDir ? 'dir' : 'file',
+                size,
+                path: relPath,
+            });
+        }
+        return { entries, truncated };
+    }
+    /**
+     * List the contents of `relativePath` to the given depth.
+     * depth=1 returns the same flat TreeListResult as listDirectory().
+     * depth>1 populates `children` on directory entries recursively.
+     * Truncated directories are not recursed into.
+     */
+    async listDirectoryDeep(repoId, relativePath, depth, options) {
+        const result = await this.listDirectory(repoId, relativePath, options);
+        if (depth <= 1) {
+            return result;
+        }
+        for (const entry of result.entries) {
+            if (entry.type === 'dir' && !result.truncated) {
+                const child = await this.listDirectoryDeep(repoId, entry.path, depth - 1, options);
+                entry.children = child.entries;
+            }
+        }
+        return result;
+    }
+    /**
+     * Recursively list all files under `relativePath` inside the repo.
+     * Returns a flat array of relative paths (files only, no directories).
+     * Respects gitignore unless `showIgnored` is set. Capped by `maxEntries`.
+     */
+    async listFilesRecursive(repoId, relativePath, options) {
+        const repo = await this.resolveRepo(repoId);
+        if (!repo) {
+            throw new Error(`Repo not found: ${repoId}`);
+        }
+        const repoRoot = repo.localPath;
+        const normalizedRel = stripLeadingSeparators(relativePath === '' || relativePath === '.' ? '.' : relativePath);
+        const absRoot = path.resolve(repoRoot, normalizedRel);
+        assertInsideRepo(repoRoot, absRoot);
+        // Fast path: use ripgrep when listing the entire repo root
+        if (normalizedRel === '.' || normalizedRel === '') {
+            const rgResult = await this.listFilesWithRipgrep(absRoot, {
+                showIgnored: options?.showIgnored,
+                maxEntries: this.maxEntries,
+            });
+            if (rgResult)
+                return rgResult;
+            // rg unavailable or errored — fall through to existing walk
+        }
+        const files = [];
+        const showIgnored = options?.showIgnored ?? false;
+        const walk = async (dir) => {
+            if (files.length >= this.maxEntries)
+                return;
+            let dirents;
+            try {
+                dirents = await fs.promises.readdir(dir, { withFileTypes: true });
+            }
+            catch {
+                return;
+            }
+            // Resolve symlinks and filter broken ones
+            const resolved = [];
+            for (const dirent of dirents) {
+                const fullPath = path.join(dir, dirent.name);
+                if (dirent.isSymbolicLink()) {
+                    try {
+                        const targetStat = await fs.promises.stat(fullPath);
+                        resolved.push({ name: dirent.name, isDir: targetStat.isDirectory() });
+                    }
+                    catch {
+                        continue;
+                    }
+                }
+                else {
+                    resolved.push({ name: dirent.name, isDir: dirent.isDirectory() });
+                }
+            }
+            // Gitignore filtering
+            let filtered = resolved;
+            if (!showIgnored) {
+                const entryInfos = resolved.map(e => ({ name: e.name, isDir: e.isDir }));
+                const ignoredNames = await RepoTreeService.getIgnoredNames(repoRoot, dir, entryInfos);
+                if (ignoredNames.size > 0) {
+                    filtered = resolved.filter(e => !ignoredNames.has(e.name));
+                }
+            }
+            // Sort alphabetically for deterministic output
+            filtered.sort((a, b) => a.name.localeCompare(b.name));
+            for (const entry of filtered) {
+                if (files.length >= this.maxEntries)
+                    return;
+                const fullPath = path.join(dir, entry.name);
+                if (entry.isDir) {
+                    await walk(fullPath);
+                }
+                else {
+                    const relPath = path.relative(repoRoot, fullPath).split(path.sep).join('/');
+                    files.push(relPath);
+                }
+            }
+        };
+        await walk(absRoot);
+        const truncated = files.length >= this.maxEntries;
+        return { files: truncated ? files.slice(0, this.maxEntries) : files, truncated };
+    }
+    /**
+     * Read file content.
+     * @returns content (text or base64), encoding, and mimeType.
+     * @throws if file not found, path traversal detected, or file exceeds 1 MB.
+     */
+    async readBlob(repoId, relativePath) {
+        const repo = await this.resolveRepo(repoId);
+        if (!repo) {
+            throw new Error(`Repo not found: ${repoId}`);
+        }
+        const repoRoot = repo.localPath;
+        const absPath = path.resolve(repoRoot, stripLeadingSeparators(relativePath));
+        assertInsideRepo(repoRoot, absPath);
+        let stat;
+        try {
+            stat = await fs.promises.stat(absPath);
+        }
+        catch {
+            throw new Error(`File not found: ${relativePath}`);
+        }
+        if (!stat.isFile()) {
+            throw new Error(`Not a file: ${relativePath}`);
+        }
+        if (stat.size > MAX_BLOB_SIZE) {
+            throw new Error(`File exceeds maximum size of ${MAX_BLOB_SIZE} bytes: ${relativePath}`);
+        }
+        const buffer = await fs.promises.readFile(absPath);
+        const mimeType = getMimeType(absPath);
+        if (isBinary(buffer)) {
+            return {
+                content: buffer.toString('base64'),
+                encoding: 'base64',
+                mimeType,
+            };
+        }
+        return {
+            content: buffer.toString('utf-8'),
+            encoding: 'utf-8',
+            mimeType,
+        };
+    }
+    /**
+     * Write text content to a file inside a repo.
+     * @throws if repo not found, path traversal detected, or path is a directory.
+     */
+    async writeBlob(repoId, relativePath, content) {
+        const repo = await this.resolveRepo(repoId);
+        if (!repo) {
+            throw new Error(`Repo not found: ${repoId}`);
+        }
+        const repoRoot = repo.localPath;
+        const absPath = path.resolve(repoRoot, stripLeadingSeparators(relativePath));
+        assertInsideRepo(repoRoot, absPath);
+        // Ensure parent directory exists
+        const parentDir = path.dirname(absPath);
+        await fs.promises.mkdir(parentDir, { recursive: true });
+        await fs.promises.writeFile(absPath, content, 'utf-8');
+    }
+    /**
+     * Fuzzy-score a single file path against a query.
+     * Mirrors the scoring logic in QuickOpen.tsx.
+     * Returns 0 if not all query characters are found in order.
+     */
+    static fuzzyScore(query, filePath) {
+        const q = query.toLowerCase();
+        const t = filePath.toLowerCase();
+        if (!q)
+            return 0;
+        let qi = 0;
+        let score = 0;
+        let prevMatchIdx = -1;
+        for (let ti = 0; ti < t.length && qi < q.length; ti++) {
+            if (t[ti] === q[qi]) {
+                if (ti === prevMatchIdx + 1)
+                    score += 2;
+                if (ti === 0 || t[ti - 1] === '/' || t[ti - 1] === '-' || t[ti - 1] === '_' || t[ti - 1] === '.') {
+                    score += 3;
+                }
+                score += 1;
+                prevMatchIdx = ti;
+                qi++;
+            }
+        }
+        if (qi < q.length)
+            return 0;
+        score += Math.max(0, 50 - filePath.length);
+        return score;
+    }
+    /**
+     * Fuzzy-search all files under the repo root.
+     * Returns results sorted by score descending, limited to `options.limit`.
+     *
+     * @param repoId   Stable workspace ID.
+     * @param query    Search query (min 1 character).
+     * @param options  Optional: limit (default 50, max 200), showIgnored (default false).
+     */
+    async searchFiles(repoId, query, options) {
+        const rawLimit = options?.limit ?? 50;
+        const limit = Math.min(Math.max(rawLimit, 1), 200);
+        const { files, truncated } = await this.listFilesRecursive(repoId, '.', {
+            showIgnored: options?.showIgnored ?? false,
+        });
+        const results = [];
+        for (const filePath of files) {
+            const score = RepoTreeService.fuzzyScore(query, filePath);
+            if (score > 0) {
+                results.push({ path: filePath, score });
+            }
+        }
+        results.sort((a, b) => b.score - a.score);
+        return { results: results.slice(0, limit), truncated };
+    }
+    /**
+     * Build a RepoInfo from a WorkspaceInfo.
+     * Pure mapping + git HEAD resolution.
+     */
+    static toRepoInfo(workspace) {
+        let headSha = '';
+        try {
+            headSha = childProcess
+                .execSync('git rev-parse --short HEAD', {
+                cwd: workspace.rootPath,
+                encoding: 'utf-8',
+                timeout: 5000,
+                stdio: ['pipe', 'pipe', 'pipe'],
+            })
+                .trim();
+        }
+        catch {
+            // Not a git repo or git not available
+        }
+        let remoteUrl;
+        try {
+            const url = childProcess
+                .execSync('git remote get-url origin', {
+                cwd: workspace.rootPath,
+                encoding: 'utf-8',
+                timeout: 5000,
+                stdio: ['pipe', 'pipe', 'pipe'],
+            })
+                .trim();
+            if (url)
+                remoteUrl = url;
+        }
+        catch {
+            // No origin remote or not a git repo
+        }
+        return {
+            id: workspace.id,
+            name: workspace.name,
+            localPath: workspace.rootPath,
+            headSha,
+            clonedAt: new Date().toISOString(),
+            ...(remoteUrl ? { remoteUrl } : {}),
+            ...(workspace.remoteUrl ? { remoteUrl: workspace.remoteUrl } : {}),
+        };
+    }
+    async readWorkspaces() {
+        const workspacesPath = path.join(this.dataDir, 'workspaces.json');
+        try {
+            const data = await fs.promises.readFile(workspacesPath, 'utf-8');
+            return JSON.parse(data);
+        }
+        catch {
+            return [];
+        }
+    }
+}
+exports.RepoTreeService = RepoTreeService;
+//# sourceMappingURL=tree-service.js.map