Refactor workspace management to project management

- Removed WorkspaceContext and related hooks, replacing them with ProjectContext.
- Updated useDevlogDetails hook to utilize currentProject instead of currentWorkspace.
- Created ProjectManagementPage for managing projects, including project creation and status display.
- Implemented ProjectsPage to render ProjectManagementPage.
- Deleted WorkspaceManagementPage and associated styles, as workspace management is no longer supported.
- Adjusted layout to use ProjectProvider instead of WorkspaceProvider.
- Updated SSEEventBridge to work with ProjectDevlogManager instead of WorkspaceDevlogManager.
- Removed unused devlog-manager and workspace-management CSS files.

Author: Marvin Zhang

packages/ai/src/index.ts

@@ -23,5 +23,5 @@ export * from './automation/index.js';
 export {
   MessageData as Message,
   ChatSessionData as ChatSession,
-  WorkspaceDataContainer as WorkspaceData,
+  ProjectDataContainer as ProjectData,
 } from './models/index.js';

packages/cli/src/api/devlog-api-client.ts

@@ -170,9 +170,9 @@ export class DevlogApiClient {
   /**
    * Import chat data to a workspace
    */
-  async importChatData(workspaceId: string, data: ChatImportRequest): Promise<ChatImportResponse> {
+  async importChatData(projectId: string, data: ChatImportRequest): Promise<ChatImportResponse> {
     try {
-      const response = await this.client.post(`/api/workspaces/${workspaceId}/chat/import`, data);
+      const response = await this.client.post(`/api/projects/${projectId}/chat/import`, data);
       return response.data;
     } catch (error) {
       throw error instanceof Error ? error : new Error('Failed to import chat data');
@@ -182,10 +182,10 @@ export class DevlogApiClient {
   /**
    * Get import progress status
    */
-  async getImportProgress(workspaceId: string, importId: string): Promise<ChatProgressResponse> {
+  async getImportProgress(projectId: string, importId: string): Promise<ChatProgressResponse> {
     try {
       const response = await this.client.get(
-        `/api/workspaces/${workspaceId}/chat/import?importId=${importId}`,
+        `/api/projects/${projectId}/chat/import?importId=${importId}`,
       );
       return response.data;
     } catch (error) {
@@ -196,9 +196,9 @@ export class DevlogApiClient {
   /**
    * List workspaces available on the server
    */
-  async listWorkspaces(): Promise<any[]> {
+  async listProjects(): Promise<any[]> {
     try {
-      const response = await this.client.get('/api/workspaces');
+      const response = await this.client.get('/api/projects');
       return response.data.workspaces || [];
     } catch (error) {
       throw error instanceof Error ? error : new Error('Failed to list workspaces');
@@ -208,20 +208,20 @@ export class DevlogApiClient {
   /**
    * Get workspace details
    */
-  async getWorkspace(workspaceId: string): Promise<any> {
+  async getProject(projectId: string): Promise<any> {
     try {
-      const response = await this.client.get(`/api/workspaces/${workspaceId}`);
+      const response = await this.client.get(`/api/projects/${projectId}`);
       return response.data;
     } catch (error) {
-      throw error instanceof Error ? error : new Error(`Failed to get workspace ${workspaceId}`);
+      throw error instanceof Error ? error : new Error(`Failed to get workspace ${projectId}`);
     }
   }
 
   /**
    * Search chat content in a workspace
    */
   async searchChatContent(
-    workspaceId: string,
+    projectId: string,
     query: string,
     options: {
       limit?: number;
@@ -238,7 +238,7 @@ export class DevlogApiClient {
       });
 
       const response = await this.client.get(
-        `/api/workspaces/${workspaceId}/chat/search?${params.toString()}`,
+        `/api/projects/${projectId}/chat/search?${params.toString()}`,
       );
       return response.data;
     } catch (error) {
@@ -249,9 +249,9 @@ export class DevlogApiClient {
   /**
    * Get chat statistics for a workspace
    */
-  async getChatStats(workspaceId: string): Promise<any> {
+  async getChatStats(projectId: string): Promise<any> {
     try {
-      const response = await this.client.get(`/api/workspaces/${workspaceId}/chat/stats`);
+      const response = await this.client.get(`/api/projects/${projectId}/chat/stats`);
       return response.data;
     } catch (error) {
       throw error instanceof Error ? error : new Error('Failed to get chat statistics');

packages/cli/src/index.ts

@@ -4,7 +4,7 @@
  * DevLog CLI - Main Entry Point
  *
  * Command-line interface for streaming chat history to devlog server
- * and managing devlog workspaces.
+ * and managing devlog projects.
  */
 
 import { Command } from 'commander';
@@ -17,12 +17,12 @@ import {
   ChatStatistics,
   CopilotParser,
   SearchResult,
-  WorkspaceDataContainer,
+  ProjectDataContainer,
 } from '@codervisor/devlog-ai';
 import { DevlogApiClient, ChatImportRequest } from './api/devlog-api-client.js';
 import {
-  convertWorkspaceDataToCoreFormat,
-  extractWorkspaceInfo,
+  convertProjectDataToCoreFormat,
+  extractProjectInfo,
   validateConvertedData,
 } from './utils/data-mapper.js';
 import {
@@ -38,7 +38,7 @@ import { loadConfig, ConfigOptions } from './utils/config.js';
 // CLI option interfaces for better type safety
 interface BaseCommandOptions {
   server?: string;
-  workspace?: string;
+  project?: string;
   verbose: boolean;
   config?: string;
 }
@@ -60,10 +60,10 @@ const program = new Command();
 
 program
   .name('devlog')
-  .description('DevLog CLI - Stream chat history and manage devlog workspaces')
+  .description('DevLog CLI - Stream chat history and manage devlog projects')
   .version('0.1.0')
   .option('-s, --server <url>', 'DevLog server URL')
-  .option('-w, --workspace <id>', 'Workspace ID')
+  .option('-w, --project <id>', 'Project ID')
   .option('-c, --config <path>', 'Configuration file path')
   .option('-v, --verbose', 'Show detailed progress', false);
 
@@ -87,16 +87,16 @@ async function setupApiClient(options: BaseCommandOptions): Promise<DevlogApiCli
   });
 }
 
-function getWorkspaceId(options: BaseCommandOptions, config: ConfigOptions): string {
-  const workspaceId = options.workspace || config.workspace || process.env.DEVLOG_WORKSPACE;
-  if (!workspaceId) {
+function getProjectId(options: BaseCommandOptions, config: ConfigOptions): string {
+  const projectId = options.project || config.project || process.env.DEVLOG_PROJECT;
+  if (!projectId) {
     displayError(
       'configuration',
-      'Workspace ID is required. Use --workspace, DEVLOG_WORKSPACE env var, or config file.',
+      'Project ID is required. Use --project, DEVLOG_PROJECT env var, or config file.',
     );
     process.exit(1);
   }
-  return workspaceId;
+  return projectId;
 }
 
 // Chat import command
@@ -120,7 +120,7 @@ program
         try {
           const config = await loadConfig(options.config);
           const apiClient = await setupApiClient(options);
-          const workspaceId = getWorkspaceId(options, config);
+          const projectId = getProjectId(options, config);
 
           // Test connection first
           spinner && (spinner.text = 'Testing server connection...');
@@ -139,30 +139,28 @@ program
           }
 
           const parser = new CopilotParser();
-          const workspaceData = await parser.discoverVSCodeCopilotData();
+          const projectData = await parser.discoverVSCodeCopilotData();
 
-          if (workspaceData.chat_sessions.length === 0) {
+          if (projectData.chat_sessions.length === 0) {
             spinner?.stop();
             displayError('discovery', 'No GitHub Copilot chat data found');
             displayWarning('Make sure VS Code is installed and you have used GitHub Copilot chat');
             process.exit(1);
           }
 
           spinner?.stop();
-          displaySuccess(`Found ${formatCount(workspaceData.chat_sessions.length)} chat sessions`);
+          displaySuccess(`Found ${formatCount(projectData.chat_sessions.length)} chat sessions`);
 
           // Show dry run information
           if (options.dryRun) {
-            const stats = parser.getChatStatistics(workspaceData);
+            const stats = parser.getChatStatistics(projectData);
             displayInfo('DRY RUN - No data will be imported');
             displayChatSummary(stats, [], options.verbose);
             return;
           }
 
           // Convert AI package data to Core package format
-          const convertedData = convertWorkspaceDataToCoreFormat(
-            workspaceData as WorkspaceDataContainer,
-          );
+          const convertedData = convertProjectDataToCoreFormat(projectData as ProjectDataContainer);
 
           // Validate the converted data
           if (!validateConvertedData(convertedData)) {
@@ -176,14 +174,14 @@ program
             sessions: convertedData.sessions,
             messages: convertedData.messages,
             source: options.source,
-            workspaceInfo: extractWorkspaceInfo(workspaceData as WorkspaceDataContainer),
+            projectInfo: extractProjectInfo(projectData as ProjectDataContainer),
           };
 
           // Start import
-          displayInfo(`Importing to workspace: ${workspaceId}`);
+          displayInfo(`Importing to project: ${projectId}`);
           const progressSpinner = ora('Starting import...').start();
 
-          const importResponse = await apiClient.importChatData(workspaceId, importData);
+          const importResponse = await apiClient.importChatData(projectId, importData);
 
           progressSpinner.stop();
           displaySuccess(`Import started: ${importResponse.importId}`);
@@ -204,7 +202,7 @@ program
             await new Promise((resolve) => setTimeout(resolve, 1000));
 
             const progressResponse = await apiClient.getImportProgress(
-              workspaceId,
+              projectId,
               importResponse.importId,
             );
             lastProgress = progressResponse.progress;
@@ -246,9 +244,9 @@ program
         try {
           const config = await loadConfig(options.config);
           const apiClient = await setupApiClient(options);
-          const workspaceId = getWorkspaceId(options, config);
+          const projectId = getProjectId(options, config);
 
-          const stats = await apiClient.getChatStats(workspaceId);
+          const stats = await apiClient.getChatStats(projectId);
 
           displayHeader('DevLog Chat Statistics');
 
@@ -261,7 +259,7 @@ program
             ['Total Sessions', stats.totalSessions?.toString() || '0'],
             ['Total Messages', stats.totalMessages?.toString() || '0'],
             ['Unique Agents', stats.uniqueAgents?.toString() || '0'],
-            ['Workspaces', stats.workspaceCount?.toString() || '0'],
+            ['Projects', stats.projectCount?.toString() || '0'],
           );
 
           if (stats.dateRange?.earliest) {
@@ -294,9 +292,9 @@ program
         try {
           const config = await loadConfig(options.config);
           const apiClient = await setupApiClient(options);
-          const workspaceId = getWorkspaceId(options, config);
+          const projectId = getProjectId(options, config);
 
-          const searchResults = await apiClient.searchChatContent(workspaceId, query, {
+          const searchResults = await apiClient.searchChatContent(projectId, query, {
             limit: parseInt(options.limit, 10),
             caseSensitive: options.caseSensitive,
             searchType: options.searchType,
@@ -327,80 +325,74 @@ program
       }),
   );
 
-// Workspace management commands
+// Project management commands
 program
-  .command('workspace')
-  .description('Workspace management commands')
+  .command('project')
+  .description('Project management commands')
   .addCommand(
     new Command('list')
-      .description('List available workspaces on server')
+      .description('List available projects on server')
       .action(async (options: BaseCommandOptions) => {
         try {
           const apiClient = await setupApiClient(options);
-          const workspaces = await apiClient.listWorkspaces();
+          const projects = await apiClient.listProjects();
 
-          if (workspaces.length === 0) {
-            console.log(chalk.yellow('No workspaces found'));
+          if (projects.length === 0) {
+            console.log(chalk.yellow('No projects found'));
             return;
           }
 
-          displayHeader('Available Workspaces');
+          displayHeader('Available Projects');
 
           const table = new Table({
             head: [chalk.cyan('ID'), chalk.cyan('Name'), chalk.cyan('Status')],
             colWidths: [20, 30, 15],
           });
 
-          for (const workspace of workspaces) {
+          for (const project of projects) {
             table.push([
-              workspace.id || 'N/A',
-              workspace.name || 'Unnamed',
-              workspace.status || 'active',
+              project.id || 'N/A',
+              project.name || 'Unnamed',
+              project.status || 'active',
             ]);
           }
 
           console.log(table.toString());
         } catch (error) {
-          displayError('listing workspaces', error);
+          displayError('listing projects', error);
           process.exit(1);
         }
       }),
   )
   .addCommand(
     new Command('info')
-      .description('Show workspace information')
+      .description('Show project information')
       .action(async (options: BaseCommandOptions) => {
         try {
           const config = await loadConfig(options.config);
           const apiClient = await setupApiClient(options);
-          const workspaceId = getWorkspaceId(options, config);
+          const projectId = getProjectId(options, config);
 
-          const workspace = await apiClient.getWorkspace(workspaceId);
+          const project = await apiClient.getProject(projectId);
 
-          displayHeader(`Workspace: ${workspace.name || workspaceId}`);
+          displayHeader(`Project: ${project.name || projectId}`);
 
           const table = new Table({
             head: [chalk.cyan('Property'), chalk.green('Value')],
             colWidths: [20, 50],
           });
 
           table.push(
-            ['ID', workspace.id || 'N/A'],
-            ['Name', workspace.name || 'Unnamed'],
-            ['Status', workspace.status || 'active'],
-            [
-              'Created',
-              workspace.createdAt ? new Date(workspace.createdAt).toLocaleString() : 'N/A',
-            ],
-            [
-              'Updated',
-              workspace.updatedAt ? new Date(workspace.updatedAt).toLocaleString() : 'N/A',
-            ],
+            ['ID', project.id || 'N/A'],
+            ['Name', project.name || 'Unnamed'],
+            ['Status', project.status || 'active'],
+            ['Created', project.createdAt ? new Date(project.createdAt).toLocaleString() : 'N/A'],
+            ['Updated', project.updatedAt ? new Date(project.updatedAt).toLocaleString() : 'N/A'],
           );
 
           console.log(table.toString());
         } catch (error) {
-          displayError('getting workspace info', error);
+          displayError('getting project info', error);
           process.exit(1);
         }
       }),

packages/mcp/src/config/mcp-config.ts

@@ -7,7 +7,7 @@ export interface MCPServerConfig {
   /** Architecture mode: 'direct' uses core directly, 'api' uses HTTP client */
   mode: 'direct' | 'api';
   /** Default workspace ID */
-  defaultWorkspaceId?: string;
+  defaultProjectId?: string;
   /** Web API configuration (required for 'api' mode) */
   webApi?: {
     /** Base URL for the web API server */
@@ -35,11 +35,11 @@ export interface MCPServerConfig {
  */
 export function loadMCPConfig(): MCPServerConfig {
   const mode = (process.env.MCP_MODE || 'direct') as 'direct' | 'api';
-  const defaultWorkspaceId = process.env.MCP_DEFAULT_WORKSPACE || 'default';
+  const defaultProjectId = process.env.MCP_DEFAULT_PROJECT || 'default';
 
   const config: MCPServerConfig = {
     mode,
-    defaultWorkspaceId,
+    defaultProjectId,
   };
 
   if (mode === 'api') {
@@ -101,7 +101,7 @@ export function validateMCPConfig(config: MCPServerConfig): void {
 export function printConfigSummary(config: MCPServerConfig): void {
   console.log('\n=== MCP Server Configuration ===');
   console.log(`Mode: ${config.mode}`);
-  console.log(`Default Workspace: ${config.defaultWorkspaceId}`);
+  console.log(`Default Project: ${config.defaultProjectId}`);
 
   if (config.mode === 'api' && config.webApi) {
     console.log(`Web API URL: ${config.webApi.baseUrl}`);