Function buildFileTree

frontend/src/file-picker.ts:94–172

(
    files: vscode.Uri[],
    context: vscode.ExtensionContext,
    includeTokens: boolean = true
)

 * Optionally includes token estimates for cost calculation
 */
export async function buildFileTree(
    files: vscode.Uri[],
    context: vscode.ExtensionContext,
    includeTokens: boolean = true
): Promise<{ tree: FileTreeNode; totalFiles: number }> {
    const workspaceRoot = vscode.workspace.workspaceFolders?.[0]?.uri.fsPath;
    if (!workspaceRoot) {
        return { tree: createEmptyRoot(), totalFiles: 0 };
    }

    const cache = getSelectionCache(context);

    // Get file sizes for token estimation (batch stat calls)
    const fileSizes = new Map<string, number>();
    if (includeTokens) {
        await Promise.all(files.map(async (file) => {
            try {
                const stat = await vscode.workspace.fs.stat(file);
                fileSizes.set(file.fsPath, stat.size);
            } catch {
                fileSizes.set(file.fsPath, 0);
            }
        }));
    }

    const root: FileTreeNode = {
        path: workspaceRoot,
        name: path.basename(workspaceRoot),
        isDirectory: true,
        depth: 0,
        selected: false,
        children: []
    };

    for (const file of files) {
        const relativePath = path.relative(workspaceRoot, file.fsPath);
        const parts = relativePath.split(path.sep);

        let current = root;
        let currentPath = workspaceRoot;
        for (let i = 0; i < parts.length; i++) {
            const part = parts[i];
            const isLast = i === parts.length - 1;
            currentPath = path.join(currentPath, part);

            let child = current.children.find(c => c.name === part);
            if (!child) {
                // Use relative path for cache lookup (cache stores relative paths)
                const cached = cache.files[relativePath];

                // Determine selection: use cache if exists, otherwise select by default
                const isSelected = isLast
                    ? (cached !== undefined ? cached.selected : true)
                    : false;

                // Estimate tokens from file size (1 token ≈ 4 bytes for code)
                const fileSize = fileSizes.get(file.fsPath) || 0;
                const tokens = isLast ? Math.ceil(fileSize / 4) : undefined;