@xagent-ai/cli 1.2.0 → 1.2.2

package/src/auth.ts

@@ -163,7 +163,7 @@ export class AuthService {
       const token = await this.retrieveXAgentToken();
 
       // 2. 调用后端验证用户
-      const xagentApiBaseUrl = this.authConfig.xagentApiBaseUrl || 'https://154.8.140.52:443';
+      const xagentApiBaseUrl = this.authConfig.xagentApiBaseUrl || 'https://www.xagent-colife.net';
       const httpsAgent = new https.Agent({ rejectUnauthorized: false });
       const response = await axios.get(`${xagentApiBaseUrl}/api/auth/me`, {
         headers: { 'Authorization': `Bearer ${token}` },
@@ -171,7 +171,7 @@ export class AuthService {
       });
 
       // 3. Set authentication configuration
-      this.authConfig.baseUrl = 'https://154.8.140.52:443/v1';
+      this.authConfig.baseUrl = 'https://www.xagent-colife.net/v1';
       this.authConfig.xagentApiBaseUrl = xagentApiBaseUrl;
       this.authConfig.apiKey = token;
     this.authConfig.type = AuthType.OAUTH_XAGENT;
@@ -376,10 +376,10 @@ export class AuthService {
 
   private async retrieveXAgentToken(): Promise<string> {
     // Use xagentApiBaseUrl from config, fallback to default
-    const webBaseUrl = this.authConfig.xagentApiBaseUrl || 'https://154.8.140.52';
+    const webBaseUrl = this.authConfig.xagentApiBaseUrl || 'https://www.xagent-colife.net';
     const authUrl = `${webBaseUrl}/login`;
     // Callback URL tells frontend where to store token
-    const callbackUrl = 'https://154.8.140.52:443/callback';
+    const callbackUrl = 'https://www.xagent-colife.net/callback';
 
     // 如果已有保存的token，通过URL参数传给Web页面
     const existingToken = this.authConfig.apiKey;

package/src/cli.ts

@@ -10,9 +10,11 @@ import { getMCPManager } from './mcp.js';
 import { getLogger, setConfigProvider } from './logger.js';
 import { theme, icons, colors } from './theme.js';
 import { getCancellationManager } from './cancellation.js';
-import { readFileSync } from 'fs';
+import { readFileSync, promises as fs } from 'fs';
+import path from 'path';
 import { dirname, join } from 'path';
 import { fileURLToPath } from 'url';
+import { glob } from 'glob';
 
 // Get current directory
 const __filename = fileURLToPath(import.meta.url);
@@ -517,6 +519,198 @@ program
     }
   });
 
+program
+  .command('memory')
+  .description('Manage memory files (list or clean)')
+  .option('-l, --list', 'List all memory files')
+  .option('--clean', 'Clean all project memories (keep global memory)')
+  .option('--clean-project', 'Clean the current project\'s memory only')
+  .option('--clean-all', 'Clean all memories (including global memory)')
+  .action(async (options) => {
+    const separator = icons.separator.repeat(40);
+    console.log('');
+    console.log(colors.primaryBright(`${icons.folder} Memory Management`));
+    console.log(colors.border(separator));
+    console.log('');
+
+    const { getMemoryManager } = await import('./memory.js');
+    const memoryManager = getMemoryManager(process.cwd());
+    const memoriesDir = memoryManager.getMemoriesDir();
+
+    // Helper to get memory info
+    const getMemoryInfo = (fileName: string) => {
+      if (fileName === 'global.md') {
+        return { type: 'global', description: 'Global memory (shared across all projects)' };
+      }
+      const match = fileName.match(/^project_(.+)_\w{16}\.md$/);
+      if (match) {
+        return { type: 'project', description: `Project: ${match[1]}` };
+      }
+      return { type: 'unknown', description: fileName };
+    };
+
+    if (options.list) {
+      // List all memory files
+      console.log(colors.textMuted(`Memory directory: ${memoriesDir}`));
+      console.log('');
+
+      try {
+        const files = await fs.readdir(memoriesDir).catch(() => []);
+        if (files.length === 0) {
+          console.log(colors.textMuted('No memory files found.'));
+          console.log('');
+          return;
+        }
+
+        const globalFile = files.find(f => f === 'global.md');
+        const projectFiles = files.filter(f => f.startsWith('project_'));
+
+        if (globalFile) {
+          const info = getMemoryInfo(globalFile);
+          console.log(`  ${colors.success(icons.success)} ${colors.primaryBright('global.md')}`);
+          console.log(`    ${colors.textDim(`  ${info.description}`)}`);
+          console.log('');
+        }
+
+        if (projectFiles.length > 0) {
+          console.log(colors.primaryBright(`  Project Memories (${projectFiles.length})`));
+          console.log('');
+
+          for (const file of projectFiles) {
+            const info = getMemoryInfo(file);
+            const filePath = join(memoriesDir, file);
+            try {
+              const stat = await fs.stat(filePath);
+              const size = stat.size;
+              const sizeStr = size < 1024 ? `${size} B` : `${(size / 1024).toFixed(1)} KB`;
+              console.log(`  ${colors.success(icons.success)} ${colors.primaryBright(file)}`);
+              console.log(`    ${colors.textDim(`  ${info.description} | Size: ${sizeStr}`)}`);
+            } catch {
+              console.log(`  ${colors.success(icons.success)} ${colors.primaryBright(file)}`);
+              console.log(`    ${colors.textDim(`  ${info.description}`)}`);
+            }
+            console.log('');
+          }
+        }
+
+        console.log(colors.textMuted(`Total: ${files.length} memory file(s)`));
+        console.log('');
+      } catch (error) {
+        console.log(colors.textMuted('No memory files found.'));
+        console.log('');
+      }
+    } else if (options.clean) {
+      // Clean all project memories (keep global.md)
+      console.log(colors.textMuted('Cleaning all project memories...'));
+      console.log(colors.textMuted(`Keeping: ${colors.primaryBright('global.md')}`));
+      console.log('');
+
+      try {
+        const files = await fs.readdir(memoriesDir).catch(() => []);
+        const projectFiles = files.filter(f => f.startsWith('project_'));
+
+        if (projectFiles.length === 0) {
+          console.log(colors.textMuted('No project memories to clean.'));
+          console.log('');
+          return;
+        }
+
+        let cleaned = 0;
+        for (const file of projectFiles) {
+          await fs.unlink(join(memoriesDir, file));
+          cleaned++;
+        }
+
+        console.log(colors.success(`✅ Cleaned ${cleaned} project memory file(s)`));
+        // TODO: 如果需要自动重建 project memory，取消下面注释
+        // await memoryManager.saveMemory('# Project Context\n\nProject-specific context will be added here.', 'project');
+        // console.log(colors.textMuted('  Recreated current project memory'));
+        console.log(colors.textMuted('  Use /init to initialize if needed'));
+        console.log('');
+      } catch (error: any) {
+        const { message, suggestion } = formatError(error);
+        console.log(colors.error(`Failed to clean project memories: ${message}`));
+        console.log(colors.textMuted(suggestion));
+        console.log('');
+      }
+    } else if (options.cleanProject) {
+      // Clean only the current project's memory
+      console.log(colors.textMuted(`Cleaning current project memory...`));
+      console.log(colors.textMuted(`Project: ${colors.primaryBright(process.cwd())}`));
+      console.log('');
+
+      try {
+        // Find and delete the current project's memory file
+        const memoryFiles = memoryManager.getMemoryFiles();
+        const currentProjectMemory = memoryFiles.find(m => m.level === 'project');
+
+        if (currentProjectMemory) {
+          await fs.unlink(currentProjectMemory.path);
+          console.log(colors.success(`✅ Cleaned current project memory`));
+          console.log(colors.textMuted(`  File: ${path.basename(currentProjectMemory.path)}`));
+        } else {
+          console.log(colors.textMuted('No memory found for the current project.'));
+        }
+        // TODO: 如果需要自动重建 project memory，取消下面注释
+        // await memoryManager.saveMemory('# Project Context\n\nProject-specific context will be added here.', 'project');
+        // console.log(colors.textMuted('  Recreated current project memory'));
+        console.log(colors.textMuted('  Use /init to initialize if needed'));
+        console.log('');
+      } catch (error: any) {
+        const { message, suggestion } = formatError(error);
+        console.log(colors.error(`Failed to clean project memory: ${message}`));
+        console.log(colors.textMuted(suggestion));
+        console.log('');
+      }
+    } else if (options.cleanAll) {
+      // Clean all memories including global
+      console.log(colors.warning(`${icons.warning} This will delete ALL memory files including global memory.`));
+      console.log('');
+      console.log(colors.textMuted('Files to be deleted:'));
+      console.log(colors.textMuted(`  - global.md (global memory)`));
+      console.log(colors.textMuted(`  - all project memories`));
+      console.log('');
+
+      try {
+        const files = await fs.readdir(memoriesDir).catch(() => []);
+        if (files.length === 0) {
+          console.log(colors.textMuted('No memory files to clean.'));
+          console.log('');
+          return;
+        }
+
+        let cleaned = 0;
+        for (const file of files) {
+          await fs.unlink(join(memoriesDir, file));
+          cleaned++;
+        }
+
+        // Recreate global memory (always keep global memory available)
+        await memoryManager.saveMemory('# Global Context\n\nGlobal preferences and settings will be added here.', 'global');
+        // TODO: 如果需要同时重建 project memory，取消下面注释
+        // await memoryManager.saveMemory('# Project Context\n\nProject-specific context will be added here.', 'project');
+
+        console.log(colors.success(`✅ Cleaned ${cleaned} memory file(s)`));
+        console.log(colors.textMuted('  Recreated global memory'));
+        console.log(colors.textMuted('  Use /init to initialize project memory if needed'));
+        console.log('');
+      } catch (error: any) {
+        const { message, suggestion } = formatError(error);
+        console.log(colors.error(`Failed to clean memories: ${message}`));
+        console.log(colors.textMuted(suggestion));
+        console.log('');
+      }
+    } else {
+      // No option specified, show help
+      console.log(colors.textMuted('Usage:'));
+      console.log(`  ${colors.primaryBright('xagent memory -l')}               ${colors.textDim('| List all memory files')}`);
+      console.log(`  ${colors.primaryBright('xagent memory --clean')}          ${colors.textDim('| Clean all project memories (keep global)')}`);
+      console.log(`  ${colors.primaryBright('xagent memory --clean-project')}  ${colors.textDim('| Clean current project memory only')}`);
+      console.log(`  ${colors.primaryBright('xagent memory --clean-all')}      ${colors.textDim('| Clean ALL memories (including global)')}`);
+      console.log('');
+    }
+  });
+
 program.parse(process.argv);
 
 if (!process.argv.slice(2).length) {

package/src/config.ts

@@ -11,13 +11,13 @@ const DEFAULT_SETTINGS: Settings = {
   selectedAuthType: AuthType.OAUTH_XAGENT,
   apiKey: '',
   // LLM API - for main conversation and task processing (OpenAI compatible format)
-  baseUrl: 'http://xagent-colife.net:3000/v1',
+  baseUrl: 'https://www.xagent-colife.net:3000/v1',
   modelName: 'Qwen3-Coder',
   // xAgent API - for token validation and other backend calls (without /v1)
-  xagentApiBaseUrl: 'http://xagent-colife.net:3000',
+  xagentApiBaseUrl: 'https://www.xagent-colife.net:3000',
   // VLM API - for GUI automation (browser/desktop operations)
   guiSubagentModel: 'Qwen3-Coder',
-  guiSubagentBaseUrl: 'http://xagent-colife.net:3000/v3',
+  guiSubagentBaseUrl: 'https://www.xagent-colife.net:3000/v3',
   guiSubagentApiKey: '',
   searchApiKey: '',
   skillsPath: '',  // Will be auto-detected if not set

package/src/memory.ts

@@ -3,27 +3,43 @@ import fsSync from 'fs';
 import path from 'path';
 import os from 'os';
 import { glob } from 'glob';
+import crypto from 'crypto';
 
 export interface MemoryFile {
   path: string;
   content: string;
   level: 'global' | 'project' | 'subdirectory';
+  projectRoot?: string;
 }
 
 export class MemoryManager {
+  private memoriesDir: string;
   private globalMemoryPath: string;
   private projectMemoryPath: string;
+  private projectRoot: string | null = null;
   private memoryFiles: MemoryFile[] = [];
   private contextFileNames: string | string[];
 
   constructor(projectRoot?: string, contextFileName: string | string[] = 'XAGENT.md') {
-    this.globalMemoryPath = path.join(os.homedir(), '.xagent', 'XAGENT.md');
-    this.projectMemoryPath = projectRoot 
-      ? path.join(projectRoot, 'XAGENT.md')
-      : '';
+    this.memoriesDir = path.join(os.homedir(), '.xagent', 'memories');
+    this.globalMemoryPath = path.join(this.memoriesDir, 'global.md');
+
+    if (projectRoot) {
+      this.projectRoot = path.resolve(projectRoot);
+      this.projectMemoryPath = this.getProjectMemoryPath(this.projectRoot);
+    } else {
+      this.projectMemoryPath = '';
+    }
     this.contextFileNames = contextFileName;
   }
 
+  private getProjectMemoryPath(projectRoot: string): string {
+    const hash = crypto.createHash('md5').update(projectRoot).digest('hex').substring(0, 16);
+    const sanitizedName = projectRoot.replace(/[:\\\/]/g, '_').replace(/[^a-zA-Z0-9_\-]/g, '');
+    const name = sanitizedName.length > 50 ? sanitizedName.substring(0, 50) : sanitizedName;
+    return path.join(this.memoriesDir, `project_${name}_${hash}.md`);
+  }
+
   async loadMemory(): Promise<string> {
     this.memoryFiles = [];
     let combinedMemory = '';
@@ -32,6 +48,15 @@ export class MemoryManager {
     if (globalMemory) {
       this.memoryFiles.push(globalMemory);
       combinedMemory += globalMemory.content + '\n\n';
+    } else {
+      // Global memory not found, create default content
+      const defaultContent = '# Global Context\n\nGlobal preferences and settings will be added here.';
+      await this.saveMemory(defaultContent, 'global');
+      const newMemory = await this.loadMemoryFile(this.globalMemoryPath, 'global');
+      if (newMemory) {
+        this.memoryFiles.push(newMemory);
+        combinedMemory += newMemory.content + '\n\n';
+      }
     }
 
     if (this.projectMemoryPath) {
@@ -40,11 +65,15 @@ export class MemoryManager {
         this.memoryFiles.push(projectMemory);
         combinedMemory += projectMemory.content + '\n\n';
       }
-
-      // const subdirectoryMemories = await this.loadSubdirectoryMemories();
-      // for (const memory of subdirectoryMemories) {
-      //   this.memoryFiles.push(memory);
-      //   combinedMemory += memory.content + '\n\n';
+      // else {
+      //   // Project memory not found, create default content
+      //   const defaultContent = '# Project Context\n\nProject-specific context will be added here.';
+      //   await this.saveMemory(defaultContent, 'project');
+      //   const newMemory = await this.loadMemoryFile(this.projectMemoryPath, 'project');
+      //   if (newMemory) {
+      //     this.memoryFiles.push(newMemory);
+      //     combinedMemory += newMemory.content + '\n\n';
+      //   }
       // }
     }
 
@@ -133,7 +162,7 @@ export class MemoryManager {
 
   async saveMemory(content: string, scope: 'global' | 'project' = 'global'): Promise<void> {
     const filePath = scope === 'global' ? this.globalMemoryPath : this.projectMemoryPath;
-    
+
     if (!filePath) {
       throw new Error('Project memory path not set');
     }
@@ -142,7 +171,7 @@ export class MemoryManager {
     await fs.mkdir(dir, { recursive: true });
 
     await fs.writeFile(filePath, content, 'utf-8');
-    
+
     if (scope === 'global') {
       const existingMemory = this.memoryFiles.find(m => m.level === 'global');
       if (existingMemory) {
@@ -150,12 +179,19 @@ export class MemoryManager {
       } else {
         this.memoryFiles.push({ path: filePath, content, level: 'global' });
       }
+    } else {
+      const existingMemory = this.memoryFiles.find(m => m.level === 'project');
+      if (existingMemory) {
+        existingMemory.content = content;
+      } else {
+        this.memoryFiles.push({ path: filePath, content, level: 'project', projectRoot: this.projectRoot || undefined });
+      }
     }
   }
 
   async addMemoryEntry(entry: string, scope: 'global' | 'project' = 'global'): Promise<void> {
     const filePath = scope === 'global' ? this.globalMemoryPath : this.projectMemoryPath;
-    
+
     if (!filePath) {
       throw new Error('Project memory path not set');
     }
@@ -177,9 +213,14 @@ export class MemoryManager {
     return [...this.memoryFiles];
   }
 
+  getMemoriesDir(): string {
+    return this.memoriesDir;
+  }
+
   async initializeProject(projectRoot: string): Promise<void> {
-    this.projectMemoryPath = path.join(projectRoot, 'XAGENT.md');
-    
+    this.projectRoot = path.resolve(projectRoot);
+    this.projectMemoryPath = this.getProjectMemoryPath(this.projectRoot);
+
     const existingMemory = await this.loadMemoryFile(this.projectMemoryPath, 'project');
     if (existingMemory) {
       console.log('XAGENT.md already exists. Skipping initialization.');