@mmmbuto/nexuscli 0.9.6 → 0.9.7-termux

package/lib/server/services/session-importer.js

@@ -5,6 +5,7 @@
  *  - Claude: ~/.claude/projects/<slug>/<sessionId>.jsonl
  *  - Codex : ~/.codex/sessions/<sessionId>.jsonl
  *  - Gemini: ~/.gemini/sessions/<sessionId>.jsonl
+ *  - Qwen  : ~/.qwen/projects/<sanitized>/chats/<sessionId>.jsonl
  *
  * Note:
  *  - Usa FILESYSTEM come source of truth: non legge contenuti, solo metadati.
@@ -22,19 +23,21 @@ const HOME = process.env.HOME || '';
 const CLAUDE_PROJECTS = path.join(HOME, '.claude', 'projects');
 const CODEX_SESSIONS = path.join(HOME, '.codex', 'sessions');
 const GEMINI_SESSIONS = path.join(HOME, '.gemini', 'sessions');
+const QWEN_PROJECTS = path.join(HOME, '.qwen', 'projects');
 
 class SessionImporter {
   constructor() {}
 
   /**
    * Importa tutte le sessioni per tutti gli engine
-   * @returns {{claude:number, codex:number, gemini:number}}
+   * @returns {{claude:number, codex:number, gemini:number, qwen:number}}
    */
   importAll() {
     const claude = this.importClaudeSessions();
     const codex = this.importCodexSessions();
     const gemini = this.importGeminiSessions();
-    return { claude, codex, gemini };
+    const qwen = this.importQwenSessions();
+    return { claude, codex, gemini, qwen };
   }
 
   /**
@@ -110,6 +113,36 @@ class SessionImporter {
     return imported;
   }
 
+  /**
+   * Qwen: ~/.qwen/projects/<sanitized>/chats/<sessionId>.jsonl
+   */
+  importQwenSessions() {
+    let imported = 0;
+    if (!fs.existsSync(QWEN_PROJECTS)) return imported;
+
+    const projects = fs.readdirSync(QWEN_PROJECTS);
+    for (const project of projects) {
+      const projectDir = path.join(QWEN_PROJECTS, project);
+      if (!fs.statSync(projectDir).isDirectory()) continue;
+
+      const chatsDir = path.join(projectDir, 'chats');
+      if (!fs.existsSync(chatsDir)) continue;
+
+      const files = fs.readdirSync(chatsDir).filter(f => f.endsWith('.jsonl'));
+      for (const file of files) {
+        const sessionId = file.replace('.jsonl', '');
+        if (this.sessionExists(sessionId)) continue;
+
+        this.insertSession(sessionId, 'qwen', '', null);
+        imported++;
+      }
+    }
+
+    if (imported > 0) saveDb();
+    console.log(`[SessionImporter] Qwen imported: ${imported}`);
+    return imported;
+  }
+
   /**
    * Inserisce riga minima in sessions
    */

package/lib/server/services/session-manager.js

@@ -1,7 +1,7 @@
 /**
  * SessionManager - Session Sync Pattern Implementation (TRI CLI v0.4.0)
  *
- * Simplified session management for Claude/Codex/Gemini engines.
+ * Simplified session management for Claude/Codex/Gemini/Qwen engines.
  * Principle: FILESYSTEM = SOURCE OF TRUTH
  *
  * Flow:
@@ -22,6 +22,7 @@ const SESSION_DIRS = {
   claude: path.join(process.env.HOME || '', '.claude', 'projects'),
   codex: path.join(process.env.HOME || '', '.codex', 'sessions'),
   gemini: path.join(process.env.HOME || '', '.gemini', 'sessions'),
+  qwen: path.join(process.env.HOME || '', '.qwen', 'projects'),
 };
 
 class SessionManager {
@@ -52,9 +53,9 @@ class SessionManager {
   sessionFileExists(sessionId, engine, workspacePath) {
     const normalizedEngine = this._normalizeEngine(engine);
 
-    // Codex/Gemini exec mode doesn't create session files - trust DB mapping
+    // Codex/Gemini/Qwen exec mode doesn't require filesystem checks - trust DB mapping
     // Session continuity is managed via NexusCLI's message DB + contextBridge
-    if (normalizedEngine === 'codex' || normalizedEngine === 'gemini') {
+    if (normalizedEngine === 'codex' || normalizedEngine === 'gemini' || normalizedEngine === 'qwen') {
       return true; // Always trust DB for exec-mode CLI sessions
     }
 
@@ -108,6 +109,11 @@ class SessionManager {
       case 'gemini':
         // Gemini sessions: ~/.gemini/sessions/<sessionId>.jsonl
         return path.join(SESSION_DIRS.gemini, `${sessionId}.jsonl`);
+      case 'qwen': {
+        // Qwen sessions: ~/.qwen/projects/<sanitized-cwd>/chats/<sessionId>.jsonl
+        const project = this._pathToQwenProject(workspacePath);
+        return path.join(SESSION_DIRS.qwen, project, 'chats', `${sessionId}.jsonl`);
+      }
 
       default:
         console.warn(`[SessionManager] Unknown engine: ${engine}`);
@@ -124,6 +130,7 @@ class SessionManager {
     if (lower.includes('claude')) return 'claude';
     if (lower.includes('codex') || lower.includes('openai')) return 'codex';
     if (lower.includes('gemini') || lower.includes('google')) return 'gemini';
+    if (lower.includes('qwen')) return 'qwen';
     return lower;
   }
 
@@ -138,6 +145,15 @@ class SessionManager {
     return workspacePath.replace(/\//g, '-');
   }
 
+  /**
+   * Convert workspace path to Qwen project dir (matches Qwen Storage.sanitizeCwd)
+   * Replaces non-alphanumeric characters with '-'
+   */
+  _pathToQwenProject(workspacePath) {
+    if (!workspacePath) return 'default';
+    return workspacePath.replace(/[^a-zA-Z0-9]/g, '-');
+  }
+
   /**
    * Generate workspace hash (legacy method, kept for compatibility)
    * @deprecated Use _pathToSlug instead (matches Claude Code behavior)
@@ -325,7 +341,12 @@ class SessionManager {
         this.lastAccess.delete(cacheKey);
 
         // Delete the original .jsonl file (SYNC DELETE)
-        const sessionFile = this._getSessionFilePath(session.id, session.engine, session.workspace_path);
+        const sessionFile = this._getSessionFilePath(
+          session.id,
+          session.engine,
+          session.workspace_path,
+          session.session_path
+        );
         if (sessionFile && fs.existsSync(sessionFile)) {
           try {
             fs.unlinkSync(sessionFile);
@@ -353,10 +374,11 @@ class SessionManager {
   /**
    * Get the filesystem path for a session file
    */
-  _getSessionFilePath(sessionId, engine, workspacePath) {
+  _getSessionFilePath(sessionId, engine, workspacePath, sessionPath) {
     const normalizedEngine = engine?.toLowerCase().includes('claude') ? 'claude'
       : engine?.toLowerCase().includes('codex') ? 'codex'
       : engine?.toLowerCase().includes('gemini') ? 'gemini'
+      : engine?.toLowerCase().includes('qwen') ? 'qwen'
       : 'claude';
 
     switch (normalizedEngine) {
@@ -367,6 +389,11 @@ class SessionManager {
         return path.join(SESSION_DIRS.codex, `${sessionId}.jsonl`);
       case 'gemini':
         return path.join(SESSION_DIRS.gemini, `${sessionId}.jsonl`);
+      case 'qwen': {
+        const project = this._pathToQwenProject(workspacePath);
+        const fileId = sessionPath || sessionId;
+        return path.join(SESSION_DIRS.qwen, project, 'chats', `${fileId}.jsonl`);
+      }
       default:
         return null;
     }

package/lib/server/tests/history-sync.test.js

@@ -4,6 +4,7 @@ const os = require('os');
 
 describe('HistorySync', () => {
   let tmpDir;
+  let testHome;
   let historyPath;
   let HistorySync;
   let initDb;
@@ -26,7 +27,8 @@ describe('HistorySync', () => {
   beforeEach(async () => {
     // Fresh temp DB per test
     tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'nexus-db-'));
-    process.env.NEXUSCLI_DB_DIR = tmpDir;
+    testHome = fs.mkdtempSync(path.join(os.tmpdir(), 'nexuscli-home-'));
+    process.env.HOME = testHome;
 
     jest.resetModules();
     ({ initDb, prepare, getDb } = require('../db'));
@@ -83,7 +85,14 @@ describe('HistorySync', () => {
   test('getWorkspaceSessions filters by workspace path', async () => {
     await historySync.sync(true);
 
-    const sessions = await historySync.getWorkspaceSessions('/test/path');
+    const grouped = await historySync.getWorkspaceSessions('/test/path');
+    const sessions = [
+      ...grouped.today,
+      ...grouped.yesterday,
+      ...grouped.last7days,
+      ...grouped.last30days,
+      ...grouped.older
+    ];
     expect(sessions).toHaveLength(1);
     expect(sessions[0].id).toBe('test-1');
   });

package/lib/server/tests/integration-session-sync.test.js

@@ -9,16 +9,34 @@
 
 const fs = require('fs');
 const path = require('path');
-const HistorySync = require('../services/history-sync');
-const { initDb, getDb, prepare } = require('../db');
+const os = require('os');
+
+let HistorySync;
+let initDb;
+let getDb;
+let prepare;
 
 describe('Session Sync Integration', () => {
   let historySync;
   let testHistoryPath;
 
   beforeAll(async () => {
+    const testHome = fs.mkdtempSync(path.join(os.tmpdir(), 'nexuscli-home-'));
+    process.env.HOME = testHome;
+
+    jest.resetModules();
+    HistorySync = require('../services/history-sync');
+    ({ initDb, getDb, prepare } = require('../db'));
+
     // Setup in-memory test database
-    await initDb({ skipMigrationCheck: true });
+    await initDb();
+  });
+
+  afterAll(() => {
+    const db = getDb && getDb();
+    if (db && typeof db.close === 'function') {
+      db.close();
+    }
   });
 
   beforeEach(() => {
@@ -110,11 +128,25 @@ describe('Session Sync Integration', () => {
     const workspace1Sessions = await historySync.getWorkspaceSessions('/test/workspace1');
     const workspace2Sessions = await historySync.getWorkspaceSessions('/test/workspace2');
 
-    expect(workspace1Sessions).toHaveLength(1);
-    expect(workspace1Sessions[0].id).toBe('session-001');
-
-    expect(workspace2Sessions).toHaveLength(1);
-    expect(workspace2Sessions[0].id).toBe('session-002');
+    const ws1 = [
+      ...workspace1Sessions.today,
+      ...workspace1Sessions.yesterday,
+      ...workspace1Sessions.last7days,
+      ...workspace1Sessions.last30days,
+      ...workspace1Sessions.older
+    ];
+    expect(ws1).toHaveLength(1);
+    expect(ws1[0].id).toBe('session-001');
+
+    const ws2 = [
+      ...workspace2Sessions.today,
+      ...workspace2Sessions.yesterday,
+      ...workspace2Sessions.last7days,
+      ...workspace2Sessions.last30days,
+      ...workspace2Sessions.older
+    ];
+    expect(ws2).toHaveLength(1);
+    expect(ws2[0].id).toBe('session-002');
   });
 
   test('conversation titles are generated from first message', async () => {

package/lib/server/tests/integration.test.js

@@ -3,38 +3,56 @@
  * Phase 7 - End-to-end flow validation
  */
 
-const { prepare } = require('../db');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const TEST_HOME = fs.mkdtempSync(path.join(os.tmpdir(), 'nexuscli-home-'));
+process.env.HOME = TEST_HOME;
+
+let initDb;
+let getDb;
+let prepare;
+
+beforeAll(async () => {
+  jest.resetModules();
+  ({ initDb, getDb, prepare } = require('../db'));
+  await initDb(); // run migrations for session tables
+});
+
+afterAll(() => {
+  const db = getDb && getDb();
+  if (db && typeof db.close === 'function') {
+    db.close();
+  }
+});
 
 describe('Database Integration', () => {
   test('should initialize database successfully', async () => {
-    const db = await prepare();
+    const db = getDb();
     expect(db).toBeDefined();
     expect(typeof db.exec).toBe('function');
   });
 
   test('should have sessions table', async () => {
-    const db = await prepare();
-    const result = db.exec("SELECT name FROM sqlite_master WHERE type='table' AND name='sessions'");
-    expect(result.length).toBeGreaterThan(0);
+    const row = prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='sessions'").get();
+    expect(row).not.toBeNull();
   });
 
   test('should have session_summaries table', async () => {
-    const db = await prepare();
-    const result = db.exec("SELECT name FROM sqlite_master WHERE type='table' AND name='session_summaries'");
-    expect(result.length).toBeGreaterThan(0);
+    const row = prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='session_summaries'").get();
+    expect(row).not.toBeNull();
   });
 
   test('should have workspace_memory table', async () => {
-    const db = await prepare();
-    const result = db.exec("SELECT name FROM sqlite_master WHERE type='table' AND name='workspace_memory'");
-    expect(result.length).toBeGreaterThan(0);
+    const row = prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='workspace_memory'").get();
+    expect(row).not.toBeNull();
   });
 
   test('should query sessions successfully', async () => {
-    const db = await prepare();
-    const result = db.exec("SELECT COUNT(*) as count FROM sessions");
-    expect(result.length).toBeGreaterThan(0);
-    expect(result[0].columns).toContain('count');
+    const row = prepare('SELECT COUNT(*) as count FROM sessions').get();
+    expect(row).toBeDefined();
+    expect(Object.prototype.hasOwnProperty.call(row, 'count')).toBe(true);
   });
 });
 
@@ -47,7 +65,6 @@ describe('Service Integration', () => {
     const loader = new CliLoader();
 
     expect(manager.claudePath).toBe(loader.claudePath);
-    expect(manager.historyPath).toBe(loader.historyPath);
   });
 
   test('All services should initialize without errors', () => {

package/lib/server/tests/performance.test.js

@@ -3,6 +3,13 @@
  * Phase 7 - Performance benchmarks
  */
 
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const TEST_HOME = fs.mkdtempSync(path.join(os.tmpdir(), 'nexuscli-home-'));
+process.env.HOME = TEST_HOME;
+
 const WorkspaceManager = require('../services/workspace-manager');
 const SummaryGenerator = require('../services/summary-generator');
 
@@ -45,7 +52,9 @@ describe('Performance Benchmarks', () => {
 
   test('Workspace validation should be fast', async () => {
     const manager = new WorkspaceManager();
-    const testPath = '/var/www/myapp';
+    const baseDir = path.join(process.env.HOME || os.tmpdir(), '.nexuscli-test');
+    fs.mkdirSync(baseDir, { recursive: true });
+    const testPath = fs.mkdtempSync(path.join(baseDir, 'ws-'));
 
     const start = Date.now();
     const validated = await manager.validateWorkspace(testPath);
@@ -97,18 +106,16 @@ describe('Memory Efficiency', () => {
 });
 
 describe('Ultra-Light Compliance', () => {
-  test('should not store assistant messages in DB (code verification)', () => {
-    const fs = require('fs');
-    const chatCode = fs.readFileSync('routes/chat.js', 'utf8');
+  test('should persist both user and assistant messages (code verification)', () => {
+    const chatCode = fs.readFileSync(path.join(__dirname, '..', 'routes', 'chat.js'), 'utf8');
 
-    // Verify comment exists about assistant messages
-    expect(chatCode).toContain('assistant replies stay in CLI files');
-    expect(chatCode).toContain('User message saved');
+    // Verify both user and assistant messages are persisted
+    expect(chatCode).toContain('[Chat] Saved user message');
+    expect(chatCode).toContain('[Chat] Saved assistant message');
   });
 
   test('should use cache for history.jsonl reads', () => {
-    const fs = require('fs');
-    const managerCode = fs.readFileSync('services/workspace-manager.js', 'utf8');
+    const managerCode = fs.readFileSync(path.join(__dirname, '..', 'services', 'workspace-manager.js'), 'utf8');
 
     // Verify cache implementation exists
     expect(managerCode).toContain('historyCache');

package/lib/server/tests/services.test.js

@@ -3,6 +3,13 @@
  * Phase 7 - Testing & Deployment
  */
 
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const TEST_HOME = fs.mkdtempSync(path.join(os.tmpdir(), 'nexuscli-home-'));
+process.env.HOME = TEST_HOME;
+
 const WorkspaceManager = require('../services/workspace-manager');
 const CliLoader = require('../services/cli-loader');
 const SummaryGenerator = require('../services/summary-generator');
@@ -15,8 +22,10 @@ describe('WorkspaceManager', () => {
   });
 
   test('should validate workspace path', async () => {
-    // Test with allowed path
-    const validPath = '/var/www/myapp';
+    // Test with allowed path (Termux-first)
+    const baseDir = path.join(process.env.HOME || os.tmpdir(), '.nexuscli-test');
+    fs.mkdirSync(baseDir, { recursive: true });
+    const validPath = fs.mkdtempSync(path.join(baseDir, 'ws-'));
     const result = await manager.validateWorkspace(validPath);
     expect(result).toBe(validPath);
   });
@@ -28,7 +37,8 @@ describe('WorkspaceManager', () => {
   });
 
   test('should detect non-existent workspace', async () => {
-    const nonExistent = '/var/nonexistent-workspace-12345';
+    const baseDir = path.join(process.env.HOME || os.tmpdir(), '.nexuscli-test');
+    const nonExistent = path.join(baseDir, 'nonexistent-workspace-12345');
     await expect(manager.validateWorkspace(nonExistent)).rejects.toThrow('does not exist');
   });
 
@@ -41,7 +51,7 @@ describe('WorkspaceManager', () => {
 
   test('should extract title from messages', () => {
     const messages = [
-      { display: 'Implement user authentication feature' },
+      { role: 'user', display: 'Implement user authentication feature' },
       { display: 'Follow up on previous discussion' }
     ];
     const title = manager.extractTitle(messages);
@@ -62,11 +72,6 @@ describe('CliLoader', () => {
     expect(loader.claudePath).toBe(expectedPath);
   });
 
-  test('should initialize with correct historyPath', () => {
-    const expectedPath = require('path').join(process.env.HOME, '.claude', 'history.jsonl');
-    expect(loader.historyPath).toBe(expectedPath);
-  });
-
   test('should have loadMessagesFromCLI method', () => {
     expect(typeof loader.loadMessagesFromCLI).toBe('function');
   });
@@ -147,7 +152,9 @@ describe('SummaryGenerator', () => {
 describe('Integration - Service Interactions', () => {
   test('WorkspaceManager should use consistent path resolution', async () => {
     const manager = new WorkspaceManager();
-    const testPath = '/var/www/myapp';
+    const baseDir = path.join(process.env.HOME || os.tmpdir(), '.nexuscli-test');
+    fs.mkdirSync(baseDir, { recursive: true });
+    const testPath = fs.mkdtempSync(path.join(baseDir, 'ws-'));
     const validated = await manager.validateWorkspace(testPath);
     expect(validated).toBe(testPath);
   });

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@mmmbuto/nexuscli",
-  "version": "0.9.6",
-  "description": "NexusCLI - TRI CLI Control Plane (Claude/Codex/Gemini)",
+  "version": "0.9.7-termux",
+  "description": "NexusCLI - TRI CLI Control Plane (Claude/Codex/Gemini/Qwen)",
   "main": "lib/server/server.js",
   "bin": {
     "nexuscli": "bin/nexuscli.js"