feat: added placeholder

when no project and no open workspace folder

Author: woung717

package.json

@@ -13,7 +13,7 @@
     "type": "git",
     "url": "https://github.com/woung717/backtest-manager-vscode.git"
   },
-  "version": "0.1.3",
+  "version": "0.1.4",
   "engines": {
     "vscode": "^1.98.0"
   },
@@ -138,6 +138,27 @@
         }
       ]
     },
+    "viewsWelcome": [
+      {
+        "view": "projectTreeView",
+        "contents": 
+          "Welcome to the Backtest Manager! \nYou can create a new project by clicking the '+' button in the view title. \n [Create a Project](command:backtestManager.createNewProject)\n To run a backtest, open a Python file in your project and click the 'Run Backtest' button in the editor title.",
+        "when": "workbenchState != empty"
+      },
+      {
+        "view": "projectTreeView",
+        "contents":
+          "Workspace folder is not open. Please open a folder to use Backtest Manager. \n [Open Folder](command:workbench.action.files.openFolder)",
+        "when": "workbenchState == empty"
+      },
+      {
+        "view": "datasetTreeView",
+        "contents": 
+          "Workspace folder is not open. Please open a folder to use Backtest Manager.",
+        "when": "workbenchState == empty"
+      }
+
+    ],
     "menus": {
       "view/title": [
         {

src/database.ts

@@ -2,7 +2,6 @@
 import * as path from 'path';
 import * as zlib from 'zlib';
 import vscode from 'vscode';
-import { promisify } from 'util';
 import { Backtest } from './types';
 import { ProjectInfo } from './types';
 
@@ -11,154 +10,120 @@ export class Database {
   private static instance: Database;
   private db: any;
   private dbPath = '';
-  private initialized = false;
   private isLoaded = false;
   private readonly CONFIG_FILE_NAME: string = '.backtest-man';
-  private readonly gzip = promisify(zlib.gzip);
-  private readonly gunzip = promisify(zlib.gunzip);
 
   private constructor() {}
 
   public static getInstance(workspacePath: string): Database {
     if (!Database.instance) {
       Database.instance = new Database();
       Database.instance.initialize(workspacePath);
-    } else if (!Database.instance.initialized) {
+    } else if (!Database.instance.isLoaded) {
       Database.instance.initialize(workspacePath);
     }
-    
-    if (!Database.instance.initialized) {
-      throw new Error('Database could not be initialized.');
-    }
-
     return Database.instance;
   }
 
-  private async unzipIfNeeded(line: string): Promise<string> {
+  private unzipIfNeeded(line: string): string | undefined {
     try {
       const buffer = Buffer.from(line, 'base64');
       if (buffer[0] === 0x1f && buffer[1] === 0x8b) {
-        const decompressed = await this.gunzip(buffer);
-        return decompressed.toString('utf-8');
+        return zlib.gunzipSync(buffer).toString('utf-8');
       }
       return line;
     } catch (error) {
+      vscode.window.showErrorMessage(`Error unzipping file: ${error}`);
       throw new Error(`Error unzipping file: ${error}`);
     }
   }
 
-  private async zip(line: string): Promise<string> {
+  private zip(line: string): string {
     try {
-      const compressed = await this.gzip(Buffer.from(line, 'utf-8'));
-      return compressed.toString('base64');
+      return zlib.gzipSync(Buffer.from(line, 'utf-8')).toString('base64');
     } catch (error) {
+      vscode.window.showErrorMessage(`Error unzipping file: ${error}`);
       throw new Error(`Error zipping file: ${error}`);
     }
   }
 
-  private async initialize(workspacePath: string): Promise<void> {
-    if (this.initialized) {
-      return;
-    }
-
-    if (!workspacePath) {
-        this.initialized = false;
-        throw new Error('Workspace path is required to initialize the database.');
-    }
-
+  private initialize(workspacePath: string) {
     this.dbPath = path.join(workspacePath, this.CONFIG_FILE_NAME);
+    this.db = new this.Datastore({
+      filename: this.dbPath,
+      beforeDeserialization: (line: string) => this.unzipIfNeeded(line),
+      afterSerialization: (line: string) => this.zip(line)
+    });
 
     try {
-      this.db = new this.Datastore({ 
-        filename: this.dbPath,
-        beforeDeserialization: async (line: string) => {
-          return await this.unzipIfNeeded(line);
-        },
-        afterSerialization: async (line: string) => {
-          return await this.zip(line);
-        }
-      });
-      
-      this.initialized = true;
-    } catch (error) {
-      this.initialized = false;
-      throw new Error(`Error initializing database at ${this.dbPath}: ${error instanceof Error ? error.message : String(error)}`);
-    }
-
-    try {
-      await vscode.workspace.fs.stat(vscode.Uri.file(this.dbPath));
+      vscode.workspace.fs.stat(vscode.Uri.file(this.dbPath));
       this.enableStorage();
+      this.isLoaded = true;
     } catch {
-      console.log(`Database file not found at ${this.dbPath}.`);
+      this.isLoaded = false;
     }
   }
 
-  private async enableStorage(): Promise<void> {
-    if (!this.initialized) {
-      return;
-    }
-
-    await this.db.loadDatabaseAsync();
-    await this.db.compactDatafileAsync();
-
+  private enableStorage(): void {
+    this.db.loadDatabase();
+    this.db.persistence.compactDatafile();
     this.db.persistence.setAutocompactionInterval(1000 * 60 * 10);
-
-    this.isLoaded = true;
   }
 
   public isDatabaseLoaded(): boolean {
     return this.isLoaded;
   }
 
-  public async getProjects(): Promise<(ProjectInfo & { results: Backtest[] })[]> {
-    return await this.db.findAsync({});
+  public getProjects(): (ProjectInfo & { results: Backtest[] })[] {
+    if (!this.isLoaded) {
+      return [];
+    }
+    return this.db.find({});
   }
 
-  public async getProject(projectId: string): Promise<(ProjectInfo & { results: Backtest[] }) | undefined> {
-    return await this.db.findOneAsync({ _id: projectId });
+  public getProject(projectId: string): (ProjectInfo & { results: Backtest[] }) | undefined {
+    return this.db.findOne({ _id: projectId });
   }
 
-  public async getProjectByName(projectName: string): Promise<(ProjectInfo & { results: Backtest[] }) | undefined> {
-    return await this.db.findOneAsync({ name: projectName });
+  public getProjectByName(projectName: string): (ProjectInfo & { results: Backtest[] }) | undefined {
+    return this.db.findOne({ name: projectName });
   }
 
-  public async addProject(projectData: ProjectInfo): Promise<ProjectInfo> {
-    await this.enableStorage();
-
+  public addProject(projectData: ProjectInfo): ProjectInfo {
+    this.enableStorage();
     const projectToInsert = {
-      ...projectData, 
-      results: projectData.results || [], // Initialize if not present
-      lastConfig: projectData.lastConfig || {}, // Initialize if not present
-      created: projectData.created || new Date(), // Set if not present
-      updated: projectData.updated || new Date(), // Set if not present
+      ...projectData,
+      results: projectData.results || [],
+      lastConfig: projectData.lastConfig || {},
+      created: projectData.created || new Date(),
+      updated: projectData.updated || new Date(),
     };
-    const insertedProject = await this.db.insertAsync(projectToInsert);
-
-    return insertedProject as ProjectInfo; // Cast because NeDB types might be generic
+    const insertedProject = this.db.insert(projectToInsert);
+    return insertedProject as ProjectInfo;
   }
 
-  public async updateProject(projectId: string, updates: Partial<ProjectInfo>): Promise<void> {
-    await this.db.updateAsync({ _id: projectId }, { $set: updates }, {});
+  public updateProject(projectId: string, updates: Partial<ProjectInfo>): void {
+    this.db.update({ _id: projectId }, { $set: updates }, {});
   }
 
-  public async updateLastConfig(projectId: string, config: any): Promise<void> {
-    await this.db.updateAsync({ _id: projectId }, { $set: { lastConfig: config } }, {});
+  public updateLastConfig(projectId: string, config: any): void {
+    this.db.update({ _id: projectId }, { $set: { lastConfig: config } }, {});
   }
 
-  public async deleteProject(projectId: string): Promise<void> {
-    const numRemoved = await this.db.removeAsync({ _id: projectId }, {});
+  public deleteProject(projectId: string): void {
+    const numRemoved = this.db.remove({ _id: projectId }, {});
     if (numRemoved === 0) {
       throw new Error(`Project not found: ${projectId}`);
     }
   }
 
-  public async getBacktestResults(projectId: string): Promise<Backtest[]> {
-    const project = await this.getProject(projectId);
+  public getBacktestResults(projectId: string): Backtest[] {
+    const project = this.getProject(projectId);
     return project?.results || [];
   }
 
-  public async addBacktestResult(projectId: string, result: Backtest): Promise<void> {
-    const numUpdated = await this.db.updateAsync(
+  public addBacktestResult(projectId: string, result: Backtest): void {
+    const numUpdated = this.db.update(
       { _id: projectId },
       { $push: { results: result } },
       {}
@@ -168,8 +133,8 @@ export class Database {
     }
   }
 
-  public async deleteBacktestResult(projectId: string, resultId: string): Promise<void> {
-    const numUpdated = await this.db.updateAsync(
+  public deleteBacktestResult(projectId: string, resultId: string): void {
+    const numUpdated = this.db.update(
       { _id: projectId },
       { $pull: { results: { id: resultId } } },
       {}
@@ -179,7 +144,7 @@ export class Database {
     }
   }
 
-  public async saveDatabase(): Promise<void> {
-    await this.db.persistence.compactDatafileAsync();
+  public saveDatabase(): void {
+    this.db.persistence.compactDatafile();
   }
 }

src/datasetTreeProvider.ts

@@ -43,8 +43,6 @@ export class DatasetTreeProvider implements vscode.TreeDataProvider<DatasetTreeI
   constructor(
     private datasetService: IDatasetService, // Injected service
   ) {
-    // Initialize with loading state
-    this.data = [new DatasetTreeItem('loading', 'Loading Datasets...', true)];
     // Trigger initial load
     this.refresh().catch(err => {
         console.error('Failed to load datasets:', err);

src/extension.ts

@@ -41,11 +41,10 @@ export function activate(context: vscode.ExtensionContext) {
   // Get workspace path
   const workspaceFolders = vscode.workspace.workspaceFolders;
   if (!workspaceFolders || workspaceFolders.length === 0) {
-    vscode.window.showErrorMessage('Workspace folder is not open. Please open a folder to use Backtest Manager.');
     return;
   }
-  const workspacePath = workspaceFolders[0].uri.fsPath;
 
+  const workspacePath = workspaceFolders[0].uri.fsPath;
   const database = Database.getInstance(workspacePath);
 
   // Instantiate Services

src/projectTreeProvider.ts

@@ -22,24 +22,20 @@ export class ProjectTreeItem {
 }
 
 export class ProjectTreeProvider implements vscode.TreeDataProvider<ProjectTreeItem> {
-  // private db: Database; // Removed
   private data: ProjectTreeItem[] = [
-    new ProjectTreeItem('loading', 'Loading Projects...', undefined, undefined, undefined, undefined)
   ];
 
   private _onDidChangeTreeData: vscode.EventEmitter<ProjectTreeItem | undefined | null | void> = new vscode.EventEmitter<ProjectTreeItem | undefined | null | void>();
   readonly onDidChangeTreeData: vscode.Event<ProjectTreeItem | undefined | null | void> = this._onDidChangeTreeData.event;
 
-  constructor(private projectService: IProjectService) { // Modified constructor
-    // Trigger initial load async
+  constructor(private projectService: IProjectService) { 
     this.refresh().catch(error => {
       vscode.window.showErrorMessage(`Error during initial project load: ${error instanceof Error ? error.message : String(error)}`);
     });
   }
 
   private async loadProjects(): Promise<void> {
     try {
-      // projectService.getProjects() is expected to return ProjectInfo with 'results' (Backtest[]) populated.
       let projects = await this.projectService.getProjects();
 
       projects = projects.sort((a, b) => a.name.localeCompare(b.name));
@@ -121,7 +117,7 @@ export class ProjectTreeProvider implements vscode.TreeDataProvider<ProjectTreeI
     if (element.contextValue === 'project' && element.projectInfo) {
       treeItem.tooltip = `Project: ${element.projectInfo.name}\nPath: ${element.projectInfo.path}\nEngine: ${element.projectInfo.engine}`;
     } else if (element.contextValue === 'backtestResult' && element.backtestResult) {
-      treeItem.tooltip = `Backtest Result\nStrategy: ${element.backtestResult.strategy}\nTotal Return: ${(element.backtestResult.performance?.totalReturn * 100 || 0).toFixed(2)}%`;
+      treeItem.tooltip = `Backtest Result\nTotal Return: ${(element.backtestResult.performance?.totalReturn * 100 || 0).toFixed(2)}%`;
       treeItem.command = {
         command: 'backtestManager.showBacktestResult',
         title: 'View Backtest Result',

src/services/projectService.ts

@@ -24,15 +24,15 @@ export class ProjectService implements IProjectService {
   constructor(private database: Database, private workspaceRootPath: string) {} // Updated constructor
 
   async getProjects(): Promise<ProjectInfo[]> {
-    return await this.database.getProjects();
+    return this.database.getProjects();
   }
 
   async getProject(projectId: string): Promise<ProjectInfo | null> {
     if (!this.database.isDatabaseLoaded()) {
       return null;
     }
 
-    const project = await this.database.getProject(projectId);
+    const project = this.database.getProject(projectId);
     return project || null; // NeDB findOne can return undefined, ensure null if not found
   }
 
@@ -41,7 +41,7 @@ export class ProjectService implements IProjectService {
       return null; 
     }
 
-    const project = await this.database.getProjectByName(projectName);
+    const project = this.database.getProjectByName(projectName);
     return project || null; // Ensure null if not found
   }
 
@@ -65,17 +65,17 @@ export class ProjectService implements IProjectService {
       lastConfig: {} // Initialize as empty object or specific default config structure
     };
 
-    return await this.database.addProject(newProjectForDb);
+    return this.database.addProject(newProjectForDb);
   }
 
   async updateProject(projectId: string, projectData: Partial<ProjectInfo>): Promise<ProjectInfo | null> {
-    await this.database.updateProject(projectId, projectData);
+    this.database.updateProject(projectId, projectData);
     return await this.getProject(projectId); // Fetch and return updated project
   }
 
   async deleteProject(projectId: string): Promise<boolean> {
     try {
-      await this.database.deleteProject(projectId);
+      this.database.deleteProject(projectId);
       return true;
     } catch (error) {
       console.error(`Error deleting project ${projectId}:`, error);
@@ -84,17 +84,17 @@ export class ProjectService implements IProjectService {
   }
 
   async addBacktestResult(projectId: string, backtestResult: Backtest): Promise<ProjectInfo | null> {
-    await this.database.addBacktestResult(projectId, backtestResult);
+    this.database.addBacktestResult(projectId, backtestResult);
     return await this.getProject(projectId);
   }
 
   async deleteBacktestResult(projectId: string, backtestResultId: string): Promise<ProjectInfo | null> {
-    await this.database.deleteBacktestResult(projectId, backtestResultId);
+    this.database.deleteBacktestResult(projectId, backtestResultId);
     return await this.getProject(projectId);
   }
 
   async updateLastConfig(projectId: string, config: any): Promise<ProjectInfo | null> {
-    await this.database.updateLastConfig(projectId, config);
+    this.database.updateLastConfig(projectId, config);
     return await this.getProject(projectId);
   }