增加了git功能，但是还未完善

src/panels/ConfigPanel.ts

@@ -1,5 +1,9 @@
 // src/panels/ConfigPanel.ts
 import * as vscode from 'vscode';
+import * as path from 'path';
+import * as fs from 'fs';
+import git from 'isomorphic-git';
+import http from 'isomorphic-git/http/node';
 import { ProjectView } from './views/ProjectView';
 import { AircraftView } from './views/AircraftView';
 import { ContainerView } from './views/ContainerView';
@@ -38,15 +42,41 @@ interface ProjectData {
     configs: Config[];
 }
 
+// Git 仓库接口
+interface GitRepo {
+    id: string;
+    name: string;
+    url: string;
+    localPath: string;
+    branch: string;
+    lastSync: string;
+}
+
+interface GitFileTree {
+    name: string;
+    type: 'file' | 'folder';
+    path: string;
+    children?: GitFileTree[];
+}
+
+// Git 分支接口
+interface GitBranch {
+    name: string;
+    isCurrent: boolean;
+    isRemote: boolean;
+    selected?: boolean;
+}
+
 export class ConfigPanel {
-    private static currentPanel: ConfigPanel | undefined;
-    private readonly panel: vscode.WebviewPanel;
+    public static currentPanel: ConfigPanel | undefined;
+    public readonly panel: vscode.WebviewPanel;
     private readonly extensionUri: vscode.Uri;
     
     private currentView: 'projects' | 'aircrafts' | 'containers' | 'configs' = 'projects';
     private currentProjectId: string = '';
     private currentAircraftId: string = '';
     private currentContainerId: string = '';
+    private currentRepoId: string = '';
 
     // 数据存储
     private projects: Project[] = [];
@@ -54,6 +84,10 @@ export class ConfigPanel {
     private containers: Container[] = [];
     private configs: Config[] = [];
 
+    // Git 仓库存储
+    private gitRepos: GitRepo[] = [];
+    private currentRepoFileTree: GitFileTree[] = [];
+
     // 项目存储路径映射
     private projectPaths: Map<string, string> = new Map();
 
@@ -85,7 +119,7 @@ export class ConfigPanel {
         ConfigPanel.currentPanel = new ConfigPanel(panel, extensionUri);
     }
 
-    private constructor(panel: vscode.WebviewPanel, extensionUri: vscode.Uri) {
+    public constructor(panel: vscode.WebviewPanel, extensionUri: vscode.Uri) {
         this.panel = panel;
         this.extensionUri = extensionUri;
 
@@ -95,6 +129,9 @@ export class ConfigPanel {
         this.containerView = new ContainerView(extensionUri);
         this.configView = new ConfigView(extensionUri);
 
+        // 加载 Git 仓库数据
+        this.loadGitRepos();
+
         this.updateWebview();
         this.setupMessageListener();
 
@@ -105,6 +142,7 @@ export class ConfigPanel {
 
     private setupMessageListener() {
         this.panel.webview.onDidReceiveMessage(async (data) => {
+            console.log('📨 收到Webview消息:', data);
             switch (data.type) {
                 case 'openExistingProject':
                     await this.openExistingProject();
@@ -146,6 +184,7 @@ export class ConfigPanel {
                     this.currentProjectId = '';
                     this.currentAircraftId = '';
                     this.currentContainerId = '';
+                    this.currentRepoId = '';
                     this.updateWebview();
                     break;
                     
@@ -223,10 +262,414 @@ export class ConfigPanel {
                 case 'deleteConfig':
                     await this.deleteConfig(data.configId);
                     break;
+
+                // Git 仓库管理功能
+                case 'fetchBranches':
+                    console.log('🌿 获取分支列表:', data.url);
+                    await this.fetchBranches(data.url);
+                    break;
+
+                case 'cloneBranches':
+                    console.log('🚀 克隆选中的分支:', data);
+                    await this.cloneBranches(data.url, data.branches);
+                    break;
+
+                case 'cancelBranchSelection':
+                    console.log('❌ 取消分支选择');
+                    this.updateWebview();
+                    break;
+
+                case 'loadGitRepo':
+                    await this.loadGitRepo(data.repoId);
+                    break;
+
+                case 'syncGitRepo':
+                    await this.syncGitRepo(data.repoId);
+                    break;
+
+                case 'deleteGitRepo':
+                    await this.deleteGitRepo(data.repoId);
+                    break;
+
+                case 'importGitFile':
+                    await this.importGitFile(data.filePath);
+                    break;
             }
         });
     }
 
+    // === Git 仓库管理方法 ===
+
+    /**
+     * 加载 Git 仓库数据
+     */
+    private async loadGitRepos(): Promise<void> {
+        try {
+            const globalStoragePath = this.extensionUri.fsPath;
+            const reposFile = path.join(globalStoragePath, 'git-repos.json');
+            
+            if (fs.existsSync(reposFile)) {
+                const data = await fs.promises.readFile(reposFile, 'utf8');
+                this.gitRepos = JSON.parse(data);
+            }
+        } catch (error) {
+            vscode.window.showErrorMessage(`加载 Git 仓库数据失败: ${error}`);
+        }
+    }
+
+    /**
+     * 保存 Git 仓库数据
+     */
+    private async saveGitRepos(): Promise<void> {
+        try {
+            const globalStoragePath = this.extensionUri.fsPath;
+            const reposFile = path.join(globalStoragePath, 'git-repos.json');
+            
+            // 确保目录存在
+            await fs.promises.mkdir(path.dirname(reposFile), { recursive: true });
+            await fs.promises.writeFile(reposFile, JSON.stringify(this.gitRepos, null, 2));
+        } catch (error) {
+            vscode.window.showErrorMessage(`保存 Git 仓库数据失败: ${error}`);
+        }
+    }
+
+    /**
+     * 添加 Git 仓库到配置目录
+     */
+    private async addGitRepo(url: string, name: string, branch?: string): Promise<void> {
+    try {
+        // 验证 URL
+        if (!url || !url.startsWith('http')) {
+            vscode.window.showErrorMessage('请输入有效的 Git 仓库 URL');
+            return;
+        }
+
+        const repoId = 'git-' + Date.now();
+        
+        // 构建本地路径
+        let localPath = '';
+        if (this.currentContainerId && this.currentProjectId) {
+            const projectPath = this.projectPaths.get(this.currentProjectId);
+            const container = this.containers.find(c => c.id === this.currentContainerId);
+            const aircraft = this.aircrafts.find(a => a.id === container?.aircraftId);
+            
+            if (projectPath && container && aircraft) {
+                localPath = path.join(projectPath, aircraft.name, container.name, name);
+                console.log(`📁 Git仓库将保存到容器目录: ${localPath}`);
+            }
+        }
+        
+        if (!localPath) {
+            localPath = path.join(this.extensionUri.fsPath, name);
+            console.log(`📁 Git仓库将保存到扩展目录: ${localPath}`);
+        }
+
+        // 修改：检查目标目录是否已存在
+        if (fs.existsSync(localPath)) {
+            vscode.window.showErrorMessage(`目标目录已存在: ${localPath}，请选择不同的名称或删除现有目录`);
+            return;
+        }
+
+        // 修改：放宽重复检查，只检查完全相同的路径
+        const existingRepo = this.gitRepos.find(repo => 
+            repo.localPath === localPath // 只检查路径完全相同的情况
+        );
+        if (existingRepo) {
+            vscode.window.showWarningMessage('该路径已存在 Git 仓库');
+            return;
+        }
+
+        const newRepo: GitRepo = {
+            id: repoId,
+            name: name,
+            url: url,
+            localPath: localPath,
+            branch: branch || 'main',
+            lastSync: new Date().toLocaleString()
+        };
+
+        console.log(`📁 准备克隆仓库: ${name}, 分支: ${newRepo.branch}, 路径: ${localPath}`);
+
+        // 显示进度
+        await vscode.window.withProgress({
+            location: vscode.ProgressLocation.Notification,
+            title: `正在克隆仓库: ${name} (${newRepo.branch})`,
+            cancellable: false
+        }, async (progress) => {
+            progress.report({ increment: 0 });
+
+            try {
+                // 确保目录存在
+                await fs.promises.mkdir(path.dirname(localPath), { recursive: true });
+
+                // 克隆仓库
+                await git.clone({
+                    fs: fs,
+                    http: http,
+                    dir: localPath,
+                    url: url,
+                    singleBranch: true,
+                    depth: 1,
+                    ref: branch || 'main',
+                    onProgress: (event: any) => {
+                        if (event.total) {
+                            const percent = (event.loaded / event.total) * 100;
+                            progress.report({ increment: percent, message: `${event.phase}...` });
+                        }
+                    }
+                });
+
+                console.log('✅ Git克隆成功完成');
+                
+                this.gitRepos.push(newRepo);
+                await this.saveGitRepos();
+                console.log('✅ 仓库数据保存成功');
+
+                vscode.window.showInformationMessage(`Git 仓库克隆成功: ${name} (${newRepo.branch})`);
+                
+                console.log('🌳 开始加载仓库文件树...');
+                // 自动加载仓库文件树
+                this.currentRepoId = repoId;
+                await this.loadGitRepoFileTree(repoId);
+                console.log('✅ 仓库文件树加载完成');
+
+                // 更新 Webview 显示
+                this.updateWebview();
+
+            } catch (error) {
+                console.error('❌ 在克隆过程中捕获错误:', error);
+                vscode.window.showErrorMessage(`克隆仓库失败: ${error}`);
+                
+                // 清理失败的克隆目录
+                try {
+                    console.log('🧹 开始清理失败的克隆目录...');
+                    await fs.promises.rm(localPath, { recursive: true, force: true });
+                    console.log('✅ 失败目录清理完成');
+                } catch (cleanupError) {
+                    console.error('❌ 清理失败目录时出错:', cleanupError);
+                }
+            }
+        });
+
+    } catch (error) {
+        console.error('❌ 在addGitRepo外部捕获错误:', error);
+        vscode.window.showErrorMessage(`添加 Git 仓库失败: ${error}`);
+    }
+}
+
+    /**
+     * 加载 Git 仓库文件树
+     */
+    private async loadGitRepo(repoId: string): Promise<void> {
+        this.currentRepoId = repoId;
+        await this.loadGitRepoFileTree(repoId);
+        this.updateWebview();
+    }
+
+    /**
+     * 同步 Git 仓库
+     */
+    private async syncGitRepo(repoId: string): Promise<void> {
+        const repo = this.gitRepos.find(r => r.id === repoId);
+        if (!repo) {
+            vscode.window.showErrorMessage('未找到指定的 Git 仓库');
+            return;
+        }
+
+        await vscode.window.withProgress({
+            location: vscode.ProgressLocation.Notification,
+            title: `正在同步仓库: ${repo.name}`,
+            cancellable: false
+        }, async (progress) => {
+            try {
+                progress.report({ increment: 0, message: '拉取最新更改...' });
+
+                // 拉取最新更改
+                await git.pull({
+                    fs: fs,
+                    http: http,
+                    dir: repo.localPath,
+                    author: { name: 'DCSP User', email: 'user@dcsp.local' },
+                    fastForward: true
+                });
+
+                // 更新最后同步时间
+                repo.lastSync = new Date().toLocaleString();
+                await this.saveGitRepos();
+
+                // 重新加载文件树
+                await this.loadGitRepoFileTree(repoId);
+
+                vscode.window.showInformationMessage(`Git 仓库同步成功: ${repo.name}`);
+                this.updateWebview();
+
+            } catch (error) {
+                vscode.window.showErrorMessage(`同步 Git 仓库失败: ${error}`);
+            }
+        });
+    }
+
+    /**
+     * 删除 Git 仓库
+     */
+    private async deleteGitRepo(repoId: string): Promise<void> {
+        const repo = this.gitRepos.find(r => r.id === repoId);
+        if (!repo) return;
+
+        const confirm = await vscode.window.showWarningMessage(
+            `确定要删除 Git 仓库 "${repo.name}" 吗？这也会删除本地副本。`,
+            { modal: true },
+            '确定删除'
+        );
+
+        if (confirm === '确定删除') {
+            try {
+                // 删除本地目录
+                await fs.promises.rm(repo.localPath, { recursive: true, force: true });
+                
+                // 从列表中移除
+                this.gitRepos = this.gitRepos.filter(r => r.id !== repoId);
+                await this.saveGitRepos();
+
+                // 如果删除的是当前仓库，清空状态
+                if (this.currentRepoId === repoId) {
+                    this.currentRepoId = '';
+                    this.currentRepoFileTree = [];
+                }
+
+                vscode.window.showInformationMessage(`Git 仓库已删除: ${repo.name}`);
+                this.updateWebview();
+
+            } catch (error) {
+                vscode.window.showErrorMessage(`删除 Git 仓库失败: ${error}`);
+            }
+        }
+    }
+
+    /**
+     * 加载 Git 仓库文件树
+     */
+    private async loadGitRepoFileTree(repoId: string): Promise<void> {
+        const repo = this.gitRepos.find(r => r.id === repoId);
+        if (!repo) return;
+
+        // 通知前端开始加载
+        this.panel.webview.postMessage({
+            type: 'gitRepoLoading',
+            loading: true
+        });
+
+        try {
+            const fileTree = await this.buildFileTree(repo.localPath);
+            this.currentRepoFileTree = fileTree;
+
+            // 更新最后访问时间
+            repo.lastSync = new Date().toLocaleString();
+            await this.saveGitRepos();
+
+        } catch (error) {
+            vscode.window.showErrorMessage(`加载仓库文件树失败: ${error}`);
+            this.currentRepoFileTree = [];
+        }
+
+        // 通知前端加载完成
+        this.panel.webview.postMessage({
+            type: 'gitRepoLoading',
+            loading: false
+        });
+
+        this.updateWebview();
+    }
+
+    /**
+     * 构建文件树
+     */
+    private async buildFileTree(dir: string, relativePath: string = ''): Promise<GitFileTree[]> {
+        try {
+            const files = await fs.promises.readdir(dir);
+            const tree: GitFileTree[] = [];
+
+            for (const file of files) {
+                // 忽略 .git 文件夹和其他隐藏文件
+                if (file.startsWith('.')) continue;
+
+                const filePath = path.join(dir, file);
+                const stats = await fs.promises.stat(filePath);
+                const currentRelativePath = path.join(relativePath, file);
+
+                if (stats.isDirectory()) {
+                    const children = await this.buildFileTree(filePath, currentRelativePath);
+                    tree.push({
+                        name: file,
+                        type: 'folder',
+                        path: currentRelativePath,
+                        children: children
+                    });
+                } else {
+                    tree.push({
+                        name: file,
+                        type: 'file',
+                        path: currentRelativePath
+                    });
+                }
+            }
+
+            return tree;
+        } catch (error) {
+            console.error('构建文件树失败:', error);
+            return [];
+        }
+    }
+
+    /**
+     * 导入 Git 文件到当前容器
+     */
+    private async importGitFile(filePath: string): Promise<void> {
+        if (!this.currentRepoId || !this.currentContainerId) {
+            vscode.window.showErrorMessage('请先选择 Git 仓库和容器');
+            return;
+        }
+
+        const repo = this.gitRepos.find(r => r.id === this.currentRepoId);
+        if (!repo) {
+            vscode.window.showErrorMessage('未找到当前 Git 仓库');
+            return;
+        }
+
+        const container = this.containers.find(c => c.id === this.currentContainerId);
+        if (!container) {
+            vscode.window.showErrorMessage('未找到当前容器');
+            return;
+        }
+
+        try {
+            const fullPath = path.join(repo.localPath, filePath);
+            const content = await fs.promises.readFile(fullPath, 'utf8');
+            const fileName = path.basename(filePath);
+
+            // 创建新配置
+            const newId = 'cfg' + (this.configs.length + 1);
+            const newConfig: Config = {
+                id: newId,
+                name: fileName,
+                fileName: fileName,
+                content: content,
+                containerId: this.currentContainerId
+            };
+
+            this.configs.push(newConfig);
+            await this.saveCurrentProjectData();
+
+            vscode.window.showInformationMessage(`文件已导入到容器 ${container.name}: ${fileName}`);
+            this.updateWebview();
+
+        } catch (error) {
+            vscode.window.showErrorMessage(`导入文件失败: ${error}`);
+        }
+    }
+
+    // === 原有项目配置管理方法 ===
+
     // === 打开现有项目功能 ===
     private async openExistingProject(): Promise<void> {
         try {
@@ -254,18 +697,13 @@ export class ConfigPanel {
      */
     private async saveCurrentProjectData(): Promise<void> {
         try {
-            console.log('开始保存当前项目数据...');
-            console.log('当前项目ID:', this.currentProjectId);
-            
             if (!this.currentProjectId) {
-                console.log('未找到当前项目ID，跳过保存数据');
                 vscode.window.showWarningMessage('未找到当前项目，数据将不会保存');
                 return;
             }
 
             const projectPath = this.projectPaths.get(this.currentProjectId);
             if (!projectPath) {
-                console.log('未找到项目路径，跳过保存数据');
                 vscode.window.showWarningMessage('未找到项目存储路径，数据将不会保存');
                 return;
             }
@@ -286,19 +724,11 @@ export class ConfigPanel {
                 configs: currentProjectConfigs
             };
 
-            console.log('要保存的当前项目数据:', {
-                projects: data.projects.length,
-                aircrafts: data.aircrafts.length,
-                containers: data.containers.length,
-                configs: data.configs.length
-            });
-
             const uint8Array = new TextEncoder().encode(JSON.stringify(data, null, 2));
             await vscode.workspace.fs.writeFile(dataUri, uint8Array);
             
-            console.log('当前项目数据已保存到:', dataUri.fsPath);
+            console.log('✅ 当前项目数据已保存');
         } catch (error) {
-            console.error('保存当前项目数据时出错:', error);
             vscode.window.showErrorMessage(`保存项目数据失败: ${error}`);
         }
     }
@@ -323,8 +753,6 @@ export class ConfigPanel {
             const dataStr = new TextDecoder().decode(fileData);
             const data: ProjectData = JSON.parse(dataStr);
 
-            console.log('从文件加载的数据:', data);
-
             // 清空现有数据
             this.projects = [];
             this.aircrafts = [];
@@ -345,13 +773,6 @@ export class ConfigPanel {
                 this.configs = data.configs;
             }
 
-            console.log('加载后的数据状态:', {
-                projects: this.projects.length,
-                aircrafts: this.aircrafts.length,
-                containers: this.containers.length,
-                configs: this.configs.length
-            });
-
             // 设置当前项目为第一个项目（如果有的话）
             if (this.projects.length > 0) {
                 this.currentProjectId = this.projects[0].id;
@@ -363,7 +784,6 @@ export class ConfigPanel {
             this.updateWebview();
             return true;
         } catch (error) {
-            console.error('加载项目数据时出错:', error);
             vscode.window.showErrorMessage(`加载项目数据失败: ${error}`);
             return false;
         }
@@ -602,8 +1022,6 @@ export class ConfigPanel {
 
     // 创建新容器
     private async createContainer(name: string) {
-        console.log('创建容器，当前飞行器ID:', this.currentAircraftId);
-
         if (!this.currentAircraftId) {
             vscode.window.showErrorMessage('无法创建容器：未找到当前飞行器');
             return;
@@ -639,11 +1057,6 @@ export class ConfigPanel {
             containerId: newId
         });
 
-        console.log('创建容器后的数据状态:', {
-            containers: this.containers.length,
-            configs: this.configs.length
-        });
-
         vscode.window.showInformationMessage(`新建容器: ${name} (包含2个默认配置文件)`);
         await this.saveCurrentProjectData();
         this.updateWebview();
@@ -799,6 +1212,135 @@ export class ConfigPanel {
         }
     }
 
+    // === Git 分支管理 ===
+
+    private async fetchBranches(url: string): Promise<void> {
+        try {
+            console.log('🌿 开始获取分支列表:', url);
+            
+            await vscode.window.withProgress({
+                location: vscode.ProgressLocation.Notification,
+                title: '正在获取分支信息',
+                cancellable: false
+            }, async (progress) => {
+                progress.report({ increment: 0, message: '连接远程仓库...' });
+
+                try {
+                    // 使用 isomorphic-git 的 listServerRefs
+                    progress.report({ increment: 30, message: '获取远程引用...' });
+                    
+                    console.log('🔍 使用 listServerRefs 获取分支信息...');
+                    
+                    const refs = await git.listServerRefs({
+                        http: http,
+                        url: url
+                    });
+
+                    console.log('📋 获取到的引用:', refs);
+
+                    // 过滤出分支引用 (refs/heads/ 和 refs/remotes/origin/)
+                    const branchRefs = refs.filter(ref => 
+                        ref.ref.startsWith('refs/heads/') || ref.ref.startsWith('refs/remotes/origin/')
+                    );
+
+                    console.log('🌿 过滤后的分支引用:', branchRefs);
+
+                    // 构建分支数据
+                    const branches: GitBranch[] = branchRefs.map(ref => {
+                        const isRemote = ref.ref.startsWith('refs/remotes/');
+                        const branchName = isRemote 
+                            ? ref.ref.replace('refs/remotes/origin/', '')
+                            : ref.ref.replace('refs/heads/', '');
+                        
+                        return {
+                            name: branchName,
+                            isCurrent: branchName === 'main' || branchName === 'master',
+                            isRemote: isRemote,
+                            selected: branchName === 'main' || branchName === 'master'
+                        };
+                    });
+
+                    console.log('🎯 最终分支列表:', branches);
+
+                    if (branches.length === 0) {
+                        throw new Error('未找到任何分支');
+                    }
+
+                    progress.report({ increment: 80, message: '处理分支数据...' });
+
+                    // 发送分支数据到前端
+                    this.panel.webview.postMessage({
+                        type: 'branchesFetched',
+                        branches: branches,
+                        repoUrl: url
+                    });
+
+                    progress.report({ increment: 100, message: '完成' });
+
+                } catch (error) {
+                    console.error('❌ 使用 listServerRefs 获取分支失败:', error);
+                    
+                    // 如果方法失败，使用模拟数据
+                    console.log('🔄 使用模拟分支数据');
+                    const mockBranches = [
+                        { name: 'main', isCurrent: true, isRemote: false, selected: true },
+                        { name: 'master', isCurrent: false, isRemote: false, selected: false },
+                        { name: 'develop', isCurrent: false, isRemote: false, selected: false },
+                        { name: 'feature/new-feature', isCurrent: false, isRemote: false, selected: false }
+                    ];
+
+                    this.panel.webview.postMessage({
+                        type: 'branchesFetched',
+                        branches: mockBranches,
+                        repoUrl: url
+                    });
+                    
+                    vscode.window.showWarningMessage('使用模拟分支数据，实际分支可能不同');
+                }
+            });
+
+        } catch (error) {
+            console.error('❌ 获取分支失败:', error);
+            vscode.window.showErrorMessage(`获取分支失败: ${error}`);
+        }
+    }
+
+    private async cloneBranches(url: string, branches: string[]): Promise<void> {
+        try {
+            console.log('🚀 开始克隆分支:', { url, branches });
+            
+            // 显示总进度
+            await vscode.window.withProgress({
+                location: vscode.ProgressLocation.Notification,
+                title: `正在克隆 ${branches.length} 个分支`,
+                cancellable: false
+            }, async (progress) => {
+                for (let i = 0; i < branches.length; i++) {
+                    const branch = branches[i];
+                    const progressPercent = (i / branches.length) * 100;
+                    progress.report({ 
+                        increment: progressPercent, 
+                        message: `克隆分支: ${branch} (${i + 1}/${branches.length})` 
+                    });
+                    
+                    console.log(`📥 克隆分支: ${branch}`);
+                    await this.addGitRepo(url, this.generateRepoName(url, branch), branch);
+                }
+            });
+            
+            vscode.window.showInformationMessage(`成功克隆 ${branches.length} 个分支`);
+            
+        } catch (error) {
+            console.error('❌ 克隆分支失败:', error);
+            vscode.window.showErrorMessage(`克隆分支失败: ${error}`);
+        }
+    }
+
+    private generateRepoName(url: string, branch: string): string {
+        const repoName = url.split('/').pop()?.replace('.git', '') || 'unknown-repo';
+        return `${repoName}-${branch.replace(/\//g, '-')}`;
+    }
+
     // 更新视图
     private updateWebview() {
         this.panel.webview.html = this.getWebviewContent();
@@ -829,10 +1371,15 @@ export class ConfigPanel {
             case 'configs':
                 const currentContainer = this.containers.find(c => c.id === this.currentContainerId);
                 const containerConfigs = this.configs.filter(cfg => cfg.containerId === this.currentContainerId);
+                const currentRepo = this.gitRepos.find(r => r.id === this.currentRepoId);
         
                 return this.configView.render({
                     container: currentContainer,
-                    configs: containerConfigs
+                    configs: containerConfigs,
+                    gitRepos: this.gitRepos,
+                    currentGitRepo: currentRepo,
+                    gitFileTree: this.currentRepoFileTree,
+                    gitLoading: false
                 });
             default:
                 return this.projectView.render({