@mmmbuto/nexuscli 0.5.0

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

@@ -0,0 +1,151 @@
+/**
+ * Integration Test - Session Sync Flow (Phase 0-2)
+ *
+ * Tests the complete flow:
+ * 1. history.jsonl → HistorySync → database
+ * 2. Chat route with optional conversationId
+ * 3. No ghost sessions created
+ */
+
+const fs = require('fs');
+const path = require('path');
+const HistorySync = require('../services/history-sync');
+const { initDb, getDb, prepare } = require('../db');
+
+describe('Session Sync Integration', () => {
+  let historySync;
+  let testHistoryPath;
+
+  beforeAll(async () => {
+    // Setup in-memory test database
+    await initDb({ skipMigrationCheck: true });
+  });
+
+  beforeEach(() => {
+    // Create test history.jsonl
+    testHistoryPath = path.join(__dirname, 'fixtures', 'test-history-integration.jsonl');
+
+    const testData = [
+      {
+        sessionId: 'session-001',
+        display: 'Fix the database bug',
+        timestamp: Date.now() - 10000,
+        project: '/test/workspace1'
+      },
+      {
+        sessionId: 'session-001',
+        display: 'Add unit tests',
+        timestamp: Date.now() - 5000,
+        project: '/test/workspace1'
+      },
+      {
+        sessionId: 'session-002',
+        display: 'Create new feature',
+        timestamp: Date.now() - 3000,
+        project: '/test/workspace2'
+      }
+    ];
+
+    fs.mkdirSync(path.dirname(testHistoryPath), { recursive: true });
+    fs.writeFileSync(
+      testHistoryPath,
+      testData.map(e => JSON.stringify(e)).join('\n')
+    );
+
+    historySync = new HistorySync({ historyPath: testHistoryPath });
+  });
+
+  afterEach(() => {
+    // Cleanup
+    if (fs.existsSync(testHistoryPath)) {
+      fs.unlinkSync(testHistoryPath);
+    }
+
+    // Clear database
+    const db = getDb();
+    if (db) {
+      db.exec('DELETE FROM messages');
+      db.exec('DELETE FROM conversations');
+      if (db.prepare('SELECT name FROM sqlite_master WHERE name="sessions"').get()) {
+        db.exec('DELETE FROM sessions');
+      }
+    }
+  });
+
+  test('parseHistory correctly groups messages by sessionId', async () => {
+    const sessions = await historySync.parseHistory();
+
+    expect(sessions.size).toBe(2);
+    expect(sessions.get('session-001').messages).toHaveLength(2);
+    expect(sessions.get('session-002').messages).toHaveLength(1);
+  });
+
+  test('syncToDatabase creates conversations without duplicates', async () => {
+    // First sync
+    await historySync.sync(true);
+
+    const db = getDb();
+    const convStmt = prepare('SELECT COUNT(*) as count FROM conversations');
+    const msgStmt = prepare('SELECT COUNT(*) as count FROM messages');
+
+    const conversations = convStmt.get();
+    const messages = msgStmt.get();
+
+    expect(conversations.count).toBe(2);
+    expect(messages.count).toBe(3);
+
+    // Second sync (should not create duplicates)
+    await historySync.sync(true);
+
+    const conversationsAfter = convStmt.get();
+    const messagesAfter = msgStmt.get();
+
+    expect(conversationsAfter.count).toBe(2);
+    expect(messagesAfter.count).toBe(3);
+  });
+
+  test('workspace filtering returns correct sessions', async () => {
+    await historySync.sync(true);
+
+    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');
+  });
+
+  test('conversation titles are generated from first message', async () => {
+    await historySync.sync(true);
+
+    const db = getDb();
+    const stmt = prepare('SELECT id, title FROM conversations WHERE id = ?');
+    const conv = stmt.get('session-001');
+
+    expect(conv).toBeDefined();
+    expect(conv.title).toContain('Fix');
+    expect(conv.title.length).toBeLessThanOrEqual(83); // Max 80 + "..."
+  });
+
+  test('sessions table populated with workspace_path', async () => {
+    await historySync.sync(true);
+
+    const db = getDb();
+
+    // Check if sessions table exists
+    const hasSessionsTable = prepare(
+      "SELECT name FROM sqlite_master WHERE type='table' AND name='sessions'"
+    ).get();
+
+    if (hasSessionsTable) {
+      const stmt = prepare('SELECT COUNT(*) as count FROM sessions');
+      const result = stmt.get();
+
+      expect(result.count).toBeGreaterThan(0);
+    } else {
+      console.warn('sessions table not found - Ultra-Light migration may not have run');
+    }
+  });
+});

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

@@ -0,0 +1,76 @@
+/**
+ * Integration Tests - Ultra-Light Architecture
+ * Phase 7 - End-to-end flow validation
+ */
+
+const { prepare } = require('../db');
+
+describe('Database Integration', () => {
+  test('should initialize database successfully', async () => {
+    const db = await prepare();
+    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);
+  });
+
+  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);
+  });
+
+  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);
+  });
+
+  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');
+  });
+});
+
+describe('Service Integration', () => {
+  test('WorkspaceManager + CliLoader should share path configuration', () => {
+    const WorkspaceManager = require('../services/workspace-manager');
+    const CliLoader = require('../services/cli-loader');
+
+    const manager = new WorkspaceManager();
+    const loader = new CliLoader();
+
+    expect(manager.claudePath).toBe(loader.claudePath);
+    expect(manager.historyPath).toBe(loader.historyPath);
+  });
+
+  test('All services should initialize without errors', () => {
+    const WorkspaceManager = require('../services/workspace-manager');
+    const CliLoader = require('../services/cli-loader');
+    const SummaryGenerator = require('../services/summary-generator');
+
+    expect(() => new WorkspaceManager()).not.toThrow();
+    expect(() => new CliLoader()).not.toThrow();
+    expect(() => new SummaryGenerator({ apiKey: 'test' })).not.toThrow();
+  });
+});
+
+describe('API Routes Availability', () => {
+  test('should have workspaces router module', () => {
+    expect(() => require('../routes/workspaces')).not.toThrow();
+  });
+
+  test('should have sessions router module', () => {
+    expect(() => require('../routes/sessions')).not.toThrow();
+  });
+
+  test('should have chat router module', () => {
+    expect(() => require('../routes/chat')).not.toThrow();
+  });
+});

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

@@ -0,0 +1,118 @@
+/**
+ * Performance Tests - Ultra-Light Architecture
+ * Phase 7 - Performance benchmarks
+ */
+
+const WorkspaceManager = require('../services/workspace-manager');
+const SummaryGenerator = require('../services/summary-generator');
+
+describe('Performance Benchmarks', () => {
+  test('WorkspaceManager cache should improve load time', () => {
+    const manager = new WorkspaceManager();
+
+    // First load (cache miss)
+    const start1 = Date.now();
+    const cache1 = manager.historyCache;
+    const time1 = Date.now() - start1;
+
+    // Second load (should use cache)
+    const start2 = Date.now();
+    const cache2 = manager.historyCache;
+    const time2 = Date.now() - start2;
+
+    // Cache access should be faster
+    expect(time2).toBeLessThanOrEqual(time1 + 1);
+  });
+
+  test('SummaryGenerator should handle large transcripts', () => {
+    const generator = new SummaryGenerator({ apiKey: 'test' });
+
+    // Generate 100 messages
+    const messages = Array(100).fill(null).map((_, i) => ({
+      role: i % 2 === 0 ? 'user' : 'assistant',
+      content: 'A'.repeat(50),
+      created_at: Date.now()
+    }));
+
+    const start = Date.now();
+    const transcript = generator.buildTranscript(messages);
+    const duration = Date.now() - start;
+
+    // Should complete quickly
+    expect(duration).toBeLessThan(100); // 100ms
+    expect(transcript.length).toBeLessThanOrEqual(6000);
+  });
+
+  test('Workspace validation should be fast', async () => {
+    const manager = new WorkspaceManager();
+    const testPath = '/home/user/myproject';
+
+    const start = Date.now();
+    const validated = await manager.validateWorkspace(testPath);
+    const duration = Date.now() - start;
+
+    // Should complete in <10ms
+    expect(duration).toBeLessThan(10);
+    expect(validated).toBe(testPath);
+  });
+
+  test('Title extraction should be fast for large messages', () => {
+    const manager = new WorkspaceManager();
+
+    const messages = [{
+      display: 'This is a very long message that contains multiple sentences and should be truncated to a reasonable length for display purposes in the UI. The title should only show the first few words.'
+    }];
+
+    const start = Date.now();
+    const title = manager.extractTitle(messages);
+    const duration = Date.now() - start;
+
+    // Should complete in <5ms
+    expect(duration).toBeLessThan(5);
+    expect(title.length).toBeLessThanOrEqual(50);
+  });
+});
+
+describe('Memory Efficiency', () => {
+  test('Cache should have TTL mechanism', () => {
+    const manager = new WorkspaceManager();
+    expect(manager.cacheTtlMs).toBe(5 * 60 * 1000); // 5 minutes
+  });
+
+  test('Transcript should be limited to prevent memory bloat', () => {
+    const generator = new SummaryGenerator({ apiKey: 'test' });
+
+    // Create very long messages
+    const messages = Array(200).fill(null).map(() => ({
+      role: 'user',
+      content: 'X'.repeat(1000),
+      created_at: Date.now()
+    }));
+
+    const transcript = generator.buildTranscript(messages);
+
+    // Should be limited to 6000 chars
+    expect(transcript.length).toBeLessThanOrEqual(6000);
+  });
+});
+
+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');
+
+    // Verify comment exists about assistant messages
+    expect(chatCode).toContain('assistant replies stay in CLI files');
+    expect(chatCode).toContain('User message saved');
+  });
+
+  test('should use cache for history.jsonl reads', () => {
+    const fs = require('fs');
+    const managerCode = fs.readFileSync('services/workspace-manager.js', 'utf8');
+
+    // Verify cache implementation exists
+    expect(managerCode).toContain('historyCache');
+    expect(managerCode).toContain('cacheTtlMs');
+    expect(managerCode).toContain('fs.watch');
+  });
+});

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

@@ -0,0 +1,160 @@
+/**
+ * Unit Tests for Ultra-Light Services
+ * Phase 7 - Testing & Deployment
+ */
+
+const WorkspaceManager = require('../services/workspace-manager');
+const CliLoader = require('../services/cli-loader');
+const SummaryGenerator = require('../services/summary-generator');
+
+describe('WorkspaceManager', () => {
+  let manager;
+
+  beforeEach(() => {
+    manager = new WorkspaceManager();
+  });
+
+  test('should validate workspace path', async () => {
+    // Test with allowed path
+    const validPath = '/home/user/myproject';
+    const result = await manager.validateWorkspace(validPath);
+    expect(result).toBe(validPath);
+  });
+
+  test('should reject invalid workspace paths', async () => {
+    // Test with disallowed root
+    const invalidPath = '/etc/passwd';
+    await expect(manager.validateWorkspace(invalidPath)).rejects.toThrow('not in allowed directories');
+  });
+
+  test('should detect non-existent workspace', async () => {
+    const nonExistent = '/var/nonexistent-workspace-12345';
+    await expect(manager.validateWorkspace(nonExistent)).rejects.toThrow('does not exist');
+  });
+
+  test('should have cache configuration', () => {
+    expect(manager.cacheTtlMs).toBe(5 * 60 * 1000); // 5 minutes
+    expect(manager.historyCache).toBeDefined();
+    expect(manager.historyCache.entries).toBeNull();
+    expect(manager.historyCache.timestamp).toBe(0);
+  });
+
+  test('should extract title from messages', () => {
+    const messages = [
+      { display: 'Implement user authentication feature' },
+      { display: 'Follow up on previous discussion' }
+    ];
+    const title = manager.extractTitle(messages);
+    expect(title).toContain('Implement');
+    expect(title.length).toBeLessThanOrEqual(50);
+  });
+});
+
+describe('CliLoader', () => {
+  let loader;
+
+  beforeEach(() => {
+    loader = new CliLoader();
+  });
+
+  test('should initialize with correct claudePath', () => {
+    const expectedPath = require('path').join(process.env.HOME, '.claude');
+    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');
+  });
+});
+
+describe('SummaryGenerator', () => {
+  let generator;
+
+  beforeEach(() => {
+    generator = new SummaryGenerator({ apiKey: 'test-key' });
+  });
+
+  test('should build transcript from messages', () => {
+    const messages = [
+      { role: 'user', content: 'Hello', created_at: Date.now() },
+      { role: 'assistant', content: 'Hi there!', created_at: Date.now() }
+    ];
+    const transcript = generator.buildTranscript(messages);
+    expect(transcript).toContain('USER:');
+    expect(transcript).toContain('ASSISTANT:');
+    expect(transcript).toContain('Hello');
+    expect(transcript).toContain('Hi there');
+  });
+
+  test('should limit transcript size', () => {
+    const longMessages = Array(100).fill(null).map((_, i) => ({
+      role: 'user',
+      content: 'A'.repeat(100),
+      created_at: Date.now()
+    }));
+    const transcript = generator.buildTranscript(longMessages);
+    expect(transcript.length).toBeLessThanOrEqual(6000);
+  });
+
+  test('should build prompt with session info', () => {
+    const sessionId = 'test-session-123';
+    const transcript = 'USER: Test message';
+    const prompt = generator.buildPrompt({ sessionId, transcript, existingSummary: null });
+    expect(prompt).toContain(sessionId);
+    expect(prompt).toContain('JSON');
+    expect(prompt).toContain('summary_short');
+    expect(prompt).toContain('summary_long');
+  });
+
+  test('should parse valid JSON response', () => {
+    const validJson = JSON.stringify({
+      summary_short: 'Short summary',
+      summary_long: 'Long summary with more details',
+      key_decisions: ['Decision 1', 'Decision 2'],
+      tools_used: ['Bash', 'Edit'],
+      files_modified: ['file1.js', 'file2.js']
+    });
+    const result = generator.safeParseJson(validJson);
+    expect(result.summary_short).toBe('Short summary');
+    expect(result.key_decisions).toHaveLength(2);
+    expect(result.tools_used).toContain('Bash');
+  });
+
+  test('should handle invalid JSON', () => {
+    const invalidJson = 'This is not JSON';
+    expect(() => generator.safeParseJson(invalidJson)).toThrow('Failed to parse summary JSON');
+  });
+
+  test('should normalize array fields', () => {
+    const jsonWithStrings = JSON.stringify({
+      summary_short: 'Test',
+      summary_long: 'Test long',
+      key_decisions: 'single decision',
+      tools_used: ['tool1'],
+      files_modified: 'single_file.js'
+    });
+    const result = generator.safeParseJson(jsonWithStrings);
+    expect(Array.isArray(result.key_decisions)).toBe(true);
+    expect(Array.isArray(result.files_modified)).toBe(true);
+  });
+});
+
+describe('Integration - Service Interactions', () => {
+  test('WorkspaceManager should use consistent path resolution', async () => {
+    const manager = new WorkspaceManager();
+    const testPath = '/home/user/myproject';
+    const validated = await manager.validateWorkspace(testPath);
+    expect(validated).toBe(testPath);
+  });
+
+  test('CliLoader and WorkspaceManager should use same Claude path', () => {
+    const manager = new WorkspaceManager();
+    const loader = new CliLoader();
+    expect(manager.claudePath).toBe(loader.claudePath);
+  });
+});