@xagent-ai/cli 1.0.1

package/src/memory.ts

@@ -0,0 +1,303 @@
+import fs from 'fs/promises';
+import fsSync from 'fs';
+import path from 'path';
+import os from 'os';
+import { glob } from 'glob';
+
+export interface MemoryFile {
+  path: string;
+  content: string;
+  level: 'global' | 'project' | 'subdirectory';
+}
+
+export class MemoryManager {
+  private globalMemoryPath: string;
+  private projectMemoryPath: string;
+  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.contextFileNames = contextFileName;
+  }
+
+  async loadMemory(): Promise<string> {
+    this.memoryFiles = [];
+    let combinedMemory = '';
+
+    const globalMemory = await this.loadMemoryFile(this.globalMemoryPath, 'global');
+    if (globalMemory) {
+      this.memoryFiles.push(globalMemory);
+      combinedMemory += globalMemory.content + '\n\n';
+    }
+
+    if (this.projectMemoryPath) {
+      const projectMemory = await this.loadMemoryFile(this.projectMemoryPath, 'project');
+      if (projectMemory) {
+        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';
+      }
+    }
+
+    return this.processImports(combinedMemory);
+  }
+
+  private async loadMemoryFile(filePath: string, level: 'global' | 'project' | 'subdirectory'): Promise<MemoryFile | null> {
+    try {
+      const content = await fs.readFile(filePath, 'utf-8');
+      return { path: filePath, content, level };
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code !== 'ENOENT') {
+        console.error(`Failed to load memory file ${filePath}:`, error);
+      }
+      return null;
+    }
+  }
+
+  private async loadSubdirectoryMemories(): Promise<MemoryFile[]> {
+    const memories: MemoryFile[] = [];
+    
+    if (!this.projectMemoryPath) {
+      return memories;
+    }
+
+    const projectRoot = path.dirname(this.projectMemoryPath);
+    
+    try {
+      const files = await glob('**/XAGENT.md', {
+        cwd: projectRoot,
+        ignore: ['node_modules/**', '.git/**', 'dist/**', 'build/**']
+      });
+
+      for (const file of files) {
+        if (file !== 'XAGENT.md') {
+          const filePath = path.join(projectRoot, file);
+          const memory = await this.loadMemoryFile(filePath, 'subdirectory');
+          if (memory) {
+            memories.push(memory);
+          }
+        }
+      }
+    } catch (error) {
+      console.error('Failed to load subdirectory memories:', error);
+    }
+
+    return memories;
+  }
+
+  private processImports(content: string): string {
+    // Only match actual import statements: import ... from '@xxx' or import '@xxx'
+    const importRegex = /import\s+(?:(?:\{[^}]*\}|\* as \w+|\w+)\s+from\s+)?['"](@[^'"]+)['"]/g;
+    let processedContent = content;
+    const visitedFiles = new Set<string>();
+
+    const processImport = (match: string, importPath: string): string => {
+      const absolutePath = path.isAbsolute(importPath)
+        ? importPath
+        : path.resolve(process.cwd(), importPath);
+
+      if (visitedFiles.has(absolutePath)) {
+        return '';
+      }
+
+      visitedFiles.add(absolutePath);
+
+      try {
+        const importedContent = fsSync.readFileSync(absolutePath, 'utf-8');
+        return `\n\n${importedContent}\n\n`;
+      } catch (error) {
+        console.warn(`Failed to import ${importPath}:`, error);
+        return '';
+      }
+    };
+
+    let maxIterations = 10;
+    let iterations = 0;
+
+    while (importRegex.test(processedContent) && iterations < maxIterations) {
+      processedContent = processedContent.replace(importRegex, processImport);
+      iterations++;
+    }
+
+    return processedContent;
+  }
+
+  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');
+    }
+
+    const dir = path.dirname(filePath);
+    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) {
+        existingMemory.content = content;
+      } else {
+        this.memoryFiles.push({ path: filePath, content, level: 'global' });
+      }
+    }
+  }
+
+  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');
+    }
+
+    let existingContent = '';
+    try {
+      existingContent = await fs.readFile(filePath, 'utf-8');
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code !== 'ENOENT') {
+        throw error;
+      }
+    }
+
+    const newContent = existingContent + `\n\n## Memory Entry (${new Date().toISOString()})\n\n${entry}\n`;
+    await this.saveMemory(newContent, scope);
+  }
+
+  getMemoryFiles(): MemoryFile[] {
+    return [...this.memoryFiles];
+  }
+
+  async initializeProject(projectRoot: string): Promise<void> {
+    this.projectMemoryPath = path.join(projectRoot, 'XAGENT.md');
+    
+    const existingMemory = await this.loadMemoryFile(this.projectMemoryPath, 'project');
+    if (existingMemory) {
+      console.log('XAGENT.md already exists. Skipping initialization.');
+      return;
+    }
+
+    console.log('Creating XAGENT.md...');
+    await this.saveMemory('# Project Context\n\nProject-specific context will be added here.', 'project');
+    
+    console.log('Analyzing project structure...');
+    const analysis = await this.analyzeProject(projectRoot);
+    
+    console.log('Generating project-specific context...');
+    await this.saveMemory(analysis, 'project');
+    
+    console.log('✅ XAGENT.md has been successfully populated with project-specific information.');
+  }
+
+  private async analyzeProject(projectRoot: string): Promise<string> {
+    let analysis = '# Project Context\n\n';
+
+    try {
+      const packageJsonPath = path.join(projectRoot, 'package.json');
+      const packageJson = await this.loadJsonFile(packageJsonPath);
+      
+      if (packageJson) {
+        analysis += '## Project Overview\n\n';
+        analysis += `Name: ${packageJson.name || 'Unknown'}\n`;
+        analysis += `Version: ${packageJson.version || 'Unknown'}\n`;
+        analysis += `Description: ${packageJson.description || 'No description'}\n\n`;
+
+        if (packageJson.dependencies) {
+          analysis += '## Dependencies\n\n';
+          analysis += '```json\n' + JSON.stringify(packageJson.dependencies, null, 2) + '\n```\n\n';
+        }
+
+        if (packageJson.scripts) {
+          analysis += '## Scripts\n\n';
+          Object.entries(packageJson.scripts).forEach(([name, script]) => {
+            analysis += `- ${name}: ${script}\n`;
+          });
+          analysis += '\n';
+        }
+      }
+
+      const tsconfigPath = path.join(projectRoot, 'tsconfig.json');
+      const tsconfig = await this.loadJsonFile(tsconfigPath);
+      
+      if (tsconfig) {
+        analysis += '## TypeScript Configuration\n\n';
+        analysis += '```json\n' + JSON.stringify(tsconfig, null, 2) + '\n```\n\n';
+      }
+
+      analysis += '## Project Structure\n\n';
+      analysis += '```\n';
+      const structure = await this.getProjectStructure(projectRoot);
+      analysis += structure;
+      analysis += '```\n\n';
+
+      analysis += '## Development Guidelines\n\n';
+      analysis += '- Follow existing code style and conventions\n';
+      analysis += '- Write clear, descriptive commit messages\n';
+      analysis += '- Add tests for new features\n';
+      analysis += '- Update documentation as needed\n';
+    } catch (error) {
+      console.error('Failed to analyze project:', error);
+      analysis += '## Project Analysis Failed\n\n';
+      analysis += 'Unable to analyze project structure automatically.\n';
+    }
+
+    return analysis;
+  }
+
+  private async loadJsonFile(filePath: string): Promise<any> {
+    try {
+      const content = await fs.readFile(filePath, 'utf-8');
+      return JSON.parse(content);
+    } catch (error) {
+      return null;
+    }
+  }
+
+  private async getProjectStructure(rootPath: string, maxDepth: number = 3, currentDepth: number = 0): Promise<string> {
+    if (currentDepth >= maxDepth) {
+      return '';
+    }
+
+    let structure = '';
+    
+    try {
+      const entries = await fs.readdir(rootPath, { withFileTypes: true });
+      
+      for (const entry of entries) {
+        if (entry.name.startsWith('.') || entry.name === 'node_modules' || entry.name === 'dist') {
+          continue;
+        }
+
+        if (entry.isDirectory()) {
+          structure += '  '.repeat(currentDepth) + entry.name + '/\n';
+          const subPath = path.join(rootPath, entry.name);
+          structure += await this.getProjectStructure(subPath, maxDepth, currentDepth + 1);
+        } else {
+          structure += '  '.repeat(currentDepth) + entry.name + '\n';
+        }
+      }
+    } catch (error) {
+      console.error(`Failed to read directory ${rootPath}:`, error);
+    }
+
+    return structure;
+  }
+}
+
+let memoryManagerInstance: MemoryManager | null = null;
+
+export function getMemoryManager(projectRoot?: string, contextFileName?: string | string[]): MemoryManager {
+  if (!memoryManagerInstance || projectRoot) {
+    memoryManagerInstance = new MemoryManager(projectRoot, contextFileName);
+  }
+  return memoryManagerInstance;
+}

package/src/session-manager.ts

@@ -0,0 +1,308 @@
+import fs from 'fs/promises';
+import path from 'path';
+import os from 'os';
+import { Session, SessionInput, SessionOutput } from './types.js';
+
+export class SessionManager {
+  private sessionsDir: string;
+  private sessions: Map<string, Session> = new Map();
+  private currentSessionId: string | null = null;
+  private currentConversationId: string | null = null;
+
+  constructor(projectRoot?: string) {
+    const resolvedProjectRoot = path.resolve(projectRoot || process.cwd());
+    const projectName = path.basename(resolvedProjectRoot);
+    // 获取相对路径部分（从用户目录开始的相对路径）
+    const homeDir = os.homedir();
+    let relativePath = path.relative(homeDir, resolvedProjectRoot);
+    // 如果项目不在用户目录下，使用完整路径
+    if (relativePath.startsWith('..') || path.isAbsolute(relativePath)) {
+      relativePath = resolvedProjectRoot;
+    }
+    // 将路径分隔符替换为下划线，移除非法字符
+    const pathSegment = relativePath.replace(/[:\\\/]/g, '_').replace(/[^a-zA-Z0-9_\-]/g, '');
+    // 构建项目区分的目录结构：路径信息_项目名
+    this.sessionsDir = path.join(homeDir, '.xagent', 'sessions', `${pathSegment}_${projectName}`);
+  }
+
+  async initialize(): Promise<void> {
+    try {
+      await fs.mkdir(this.sessionsDir, { recursive: true });
+      await this.loadSessions();
+    } catch (error) {
+      console.error('Failed to initialize session manager:', error);
+    }
+  }
+
+  private async loadSessions(): Promise<void> {
+    try {
+      const files = await fs.readdir(this.sessionsDir);
+
+      for (const file of files) {
+        if (file.endsWith('.json')) {
+          const filePath = path.join(this.sessionsDir, file);
+          const content = await fs.readFile(filePath, 'utf-8');
+          const session: Session = JSON.parse(content);
+          this.sessions.set(session.id, session);
+        }
+      }
+    } catch (error) {
+      console.error('Failed to load sessions:', error);
+    }
+  }
+
+  async createSession(conversationId: string, agent?: string, executionMode?: string): Promise<Session> {
+    const sessionId = `session_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+    const now = Date.now();
+
+    const session: Session = {
+      id: sessionId,
+      conversationId,
+      startTime: now,
+      inputs: [],
+      outputs: [],
+      agent,
+      executionMode,
+      status: 'active'
+    };
+
+    this.sessions.set(sessionId, session);
+    this.currentSessionId = sessionId;
+    this.currentConversationId = conversationId;
+
+    await this.saveSession(session);
+
+    return session;
+  }
+
+  async saveSession(session: Session): Promise<void> {
+    const filePath = path.join(this.sessionsDir, `${session.id}.json`);
+    await fs.writeFile(filePath, JSON.stringify(session, null, 2), 'utf-8');
+  }
+
+  async addInput(input: SessionInput, sessionId?: string): Promise<void> {
+    const sessId = sessionId || this.currentSessionId;
+
+    if (!sessId) {
+      return;
+    }
+
+    const session = this.sessions.get(sessId);
+
+    if (!session) {
+      return;
+    }
+
+    session.inputs.push(input);
+    await this.saveSession(session);
+  }
+
+  async addOutput(output: SessionOutput, sessionId?: string): Promise<void> {
+    const sessId = sessionId || this.currentSessionId;
+
+    if (!sessId) {
+      return;
+    }
+
+    const session = this.sessions.get(sessId);
+
+    if (!session) {
+      return;
+    }
+
+    session.outputs.push(output);
+    await this.saveSession(session);
+  }
+
+  async endSession(sessionId?: string, status: 'completed' | 'cancelled' = 'completed'): Promise<void> {
+    const sessId = sessionId || this.currentSessionId;
+
+    if (!sessId) {
+      return;
+    }
+
+    const session = this.sessions.get(sessId);
+
+    if (!session) {
+      return;
+    }
+
+    session.endTime = Date.now();
+    session.status = status;
+
+    await this.saveSession(session);
+
+    if (this.currentSessionId === sessId) {
+      this.currentSessionId = null;
+    }
+  }
+
+  async completeCurrentSession(): Promise<void> {
+    await this.endSession(undefined, 'completed');
+  }
+
+  async cancelCurrentSession(): Promise<void> {
+    await this.endSession(undefined, 'cancelled');
+  }
+
+  getSession(sessionId: string): Session | undefined {
+    return this.sessions.get(sessionId);
+  }
+
+  getCurrentSession(): Session | undefined {
+    if (!this.currentSessionId) {
+      return undefined;
+    }
+    return this.sessions.get(this.currentSessionId);
+  }
+
+  getCurrentSessionId(): string | null {
+    return this.currentSessionId;
+  }
+
+  async setCurrentSession(sessionId: string): Promise<void> {
+    const session = this.sessions.get(sessionId);
+
+    if (!session) {
+      throw new Error(`Session not found: ${sessionId}`);
+    }
+
+    this.currentSessionId = sessionId;
+    this.currentConversationId = session.conversationId;
+  }
+
+  listSessions(): Session[] {
+    return Array.from(this.sessions.values())
+      .sort((a, b) => b.startTime - a.startTime);
+  }
+
+  listSessionsByConversation(conversationId: string): Session[] {
+    return this.listSessions().filter(s => s.conversationId === conversationId);
+  }
+
+  async deleteSession(sessionId: string): Promise<void> {
+    const session = this.sessions.get(sessionId);
+
+    if (!session) {
+      throw new Error(`Session not found: ${sessionId}`);
+    }
+
+    const filePath = path.join(this.sessionsDir, `${sessionId}.json`);
+
+    try {
+      await fs.unlink(filePath);
+    } catch (error) {
+      // File might not exist, that's okay
+    }
+
+    this.sessions.delete(sessionId);
+
+    if (this.currentSessionId === sessionId) {
+      this.currentSessionId = null;
+    }
+  }
+
+  async clearSessions(): Promise<void> {
+    for (const sessionId of this.sessions.keys()) {
+      await this.deleteSession(sessionId);
+    }
+  }
+
+  getSessionStats(): {
+    totalSessions: number;
+    activeSessions: number;
+    completedSessions: number;
+    cancelledSessions: number;
+    totalInputs: number;
+    totalOutputs: number;
+  } {
+    const sessions = this.listSessions();
+
+    return {
+      totalSessions: sessions.length,
+      activeSessions: sessions.filter(s => s.status === 'active').length,
+      completedSessions: sessions.filter(s => s.status === 'completed').length,
+      cancelledSessions: sessions.filter(s => s.status === 'cancelled').length,
+      totalInputs: sessions.reduce((sum, s) => sum + s.inputs.length, 0),
+      totalOutputs: sessions.reduce((sum, s) => sum + s.outputs.length, 0)
+    };
+  }
+
+  async searchSessions(query: string): Promise<Session[]> {
+    const lowerQuery = query.toLowerCase();
+
+    return this.listSessions().filter(session => {
+      const inputText = session.inputs.map(i => i.content).join(' ').toLowerCase();
+      const outputText = session.outputs.map(o => o.content).join(' ').toLowerCase();
+
+      return inputText.includes(lowerQuery) || outputText.includes(lowerQuery);
+    });
+  }
+
+  async getSessionByInputIndex(conversationId: string, inputIndex: number): Promise<Session | undefined> {
+    const sessions = this.listSessionsByConversation(conversationId);
+
+    for (const session of sessions) {
+      if (inputIndex >= 0 && inputIndex < session.inputs.length) {
+        return session;
+      }
+    }
+
+    return undefined;
+  }
+
+  async cleanupOldSessions(days: number = 30): Promise<number> {
+    const cutoffDate = Date.now() - (days * 24 * 60 * 60 * 1000);
+    const toDelete: string[] = [];
+
+    for (const [id, session] of this.sessions) {
+      if (session.startTime < cutoffDate) {
+        toDelete.push(id);
+      }
+    }
+
+    for (const id of toDelete) {
+      await this.deleteSession(id);
+    }
+
+    return toDelete.length;
+  }
+
+  setCurrentConversationId(conversationId: string): void {
+    this.currentConversationId = conversationId;
+  }
+
+  getCurrentConversationId(): string | null {
+    return this.currentConversationId;
+  }
+}
+
+let sessionManagerInstance: SessionManager | null = null;
+let currentProjectRoot: string | null = null;
+
+export function getSessionManager(projectRoot?: string): SessionManager {
+  const root = projectRoot || process.cwd();
+
+  if (!sessionManagerInstance || currentProjectRoot !== root) {
+    sessionManagerInstance = new SessionManager(root);
+    sessionManagerInstance.initialize();
+    currentProjectRoot = root;
+  }
+  return sessionManagerInstance;
+}
+
+export async function getOrCreateSession(
+  conversationId: string,
+  agent?: string,
+  executionMode?: string,
+  projectRoot?: string
+): Promise<Session> {
+  const manager = getSessionManager(projectRoot);
+  const currentSession = manager.getCurrentSession();
+
+  if (currentSession && currentSession.status === 'active') {
+    return currentSession;
+  }
+
+  return manager.createSession(conversationId, agent, executionMode);
+}