@aladac/hu 0.1.0-a1 → 0.1.0-a2

package/tests/lib/claude-paths.test.ts

@@ -0,0 +1,73 @@
+import { describe, it, expect } from 'vitest';
+import {
+  encodeProjectPath,
+  decodeProjectPath,
+  getProjectsDir,
+  getHistoryPath,
+  getStatsPath,
+  getTodosDir,
+} from '../../src/lib/claude-paths.ts';
+
+describe('claude-paths', () => {
+  describe('encodeProjectPath / decodeProjectPath', () => {
+    it('encodes simple paths by replacing / with -', () => {
+      const testPath = '/Users/chi/Projects/myapp';
+      const encoded = encodeProjectPath(testPath);
+      expect(encoded).toBe('-Users-chi-Projects-myapp');
+    });
+
+    it('decodes paths by replacing - with /', () => {
+      const encoded = '-Users-chi-Projects-myapp';
+      const decoded = decodeProjectPath(encoded);
+      expect(decoded).toBe('/Users/chi/Projects/myapp');
+    });
+
+    it('matches Claude Code directory naming convention', () => {
+      // Real examples from Claude Code
+      expect(decodeProjectPath('-Users-chi')).toBe('/Users/chi');
+      expect(decodeProjectPath('-Users-chi--claude')).toBe('/Users/chi/.claude');
+      expect(decodeProjectPath('-Users-chi-Desktop-new-json')).toBe('/Users/chi/Desktop/new/json');
+    });
+
+    it('handles paths with unicode', () => {
+      const testPath = '/Users/chi/Projects/日本語';
+      const encoded = encodeProjectPath(testPath);
+      expect(encoded).toBe('-Users-chi-Projects-日本語');
+    });
+
+    it('handles paths with spaces', () => {
+      const testPath = '/Users/chi/My Projects/Some App';
+      const encoded = encodeProjectPath(testPath);
+      expect(encoded).toBe('-Users-chi-My Projects-Some App');
+    });
+
+    it('produces directory-safe encoded strings', () => {
+      const testPath = '/Users/chi/Projects/myapp';
+      const encoded = encodeProjectPath(testPath);
+      // Should not contain /
+      expect(encoded).not.toContain('/');
+    });
+  });
+
+  describe('path getters', () => {
+    it('getProjectsDir returns path ending with projects', () => {
+      const projectsDir = getProjectsDir();
+      expect(projectsDir).toContain('projects');
+    });
+
+    it('getHistoryPath returns history.jsonl path', () => {
+      const historyPath = getHistoryPath();
+      expect(historyPath).toMatch(/history\.jsonl$/);
+    });
+
+    it('getStatsPath returns stats-cache.json path', () => {
+      const statsPath = getStatsPath();
+      expect(statsPath).toMatch(/stats-cache\.json$/);
+    });
+
+    it('getTodosDir returns todos directory path', () => {
+      const todosDir = getTodosDir();
+      expect(todosDir).toContain('todos');
+    });
+  });
+});

package/tests/lib/config.test.ts

@@ -0,0 +1,163 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import {
+  expandPath,
+  getConfigDir,
+  getConfigPath,
+  getDatabasePath,
+  ensureConfig,
+  getConfig,
+  getClaudeDir,
+  clearConfigCache,
+  type HuConfig,
+} from '../../src/lib/config.ts';
+
+describe('config', () => {
+  let originalConfigContent: string | null = null;
+  const configPath = getConfigPath();
+
+  beforeEach(() => {
+    clearConfigCache();
+    // Save original config if it exists
+    if (fs.existsSync(configPath)) {
+      originalConfigContent = fs.readFileSync(configPath, 'utf-8');
+    }
+  });
+
+  afterEach(() => {
+    clearConfigCache();
+    // Restore original config
+    if (originalConfigContent !== null) {
+      fs.writeFileSync(configPath, originalConfigContent, 'utf-8');
+    }
+  });
+
+  describe('expandPath', () => {
+    it('expands ~ to home directory', () => {
+      const home = os.homedir();
+      expect(expandPath('~')).toBe(home);
+      expect(expandPath('~/')).toBe(home);
+      expect(expandPath('~/foo/bar')).toBe(path.join(home, 'foo/bar'));
+    });
+
+    it('leaves absolute paths unchanged', () => {
+      expect(expandPath('/foo/bar')).toBe('/foo/bar');
+      expect(expandPath('/tmp')).toBe('/tmp');
+    });
+
+    it('leaves relative paths unchanged', () => {
+      expect(expandPath('foo/bar')).toBe('foo/bar');
+      expect(expandPath('./foo')).toBe('./foo');
+    });
+  });
+
+  describe('getConfig', () => {
+    it('creates config directory and file if missing', () => {
+      ensureConfig();
+      expect(fs.existsSync(getConfigDir())).toBe(true);
+      expect(fs.existsSync(configPath)).toBe(true);
+    });
+
+    it('returns config with all required sections', () => {
+      const config = getConfig();
+      expect(config.general).toBeDefined();
+      expect(config.sync).toBeDefined();
+      expect(config.hooks).toBeDefined();
+      expect(config.search).toBeDefined();
+      expect(config.output).toBeDefined();
+    });
+
+    it('caches config and returns same object', () => {
+      const config1 = getConfig();
+      const config2 = getConfig();
+      expect(config1).toBe(config2);
+    });
+
+    it('reloads config when forceReload is true', () => {
+      const config1 = getConfig();
+      const config2 = getConfig(true);
+      expect(config1).not.toBe(config2);
+    });
+
+    it('merges partial config with defaults', () => {
+      // Write partial config
+      fs.writeFileSync(configPath, `
+[search]
+default_limit = 50
+`, 'utf-8');
+
+      clearConfigCache();
+      const config = getConfig();
+      
+      // Custom value
+      expect(config.search.default_limit).toBe(50);
+      
+      // Default values preserved
+      expect(config.general.database).toBe('hu.db');
+      expect(config.sync.auto_sync_interval).toBe(300);
+      expect(config.hooks.enabled).toBe(true);
+    });
+
+    it('handles invalid TOML gracefully', () => {
+      // Write invalid TOML
+      fs.writeFileSync(configPath, 'invalid = [toml', 'utf-8');
+
+      clearConfigCache();
+      const config = getConfig();
+      
+      // Should return defaults
+      expect(config.general.database).toBe('hu.db');
+    });
+  });
+
+  describe('getDatabasePath', () => {
+    it('resolves relative path to config dir', () => {
+      const config: HuConfig = {
+        ...getConfig(),
+        general: { claude_dir: '~/.claude', database: 'hu.db' },
+      };
+      const dbPath = getDatabasePath(config);
+      expect(dbPath).toBe(path.join(getConfigDir(), 'hu.db'));
+    });
+
+    it('expands ~ in database path', () => {
+      const config: HuConfig = {
+        ...getConfig(),
+        general: { claude_dir: '~/.claude', database: '~/data/hu.db' },
+      };
+      const dbPath = getDatabasePath(config);
+      expect(dbPath).toBe(path.join(os.homedir(), 'data/hu.db'));
+    });
+
+    it('uses absolute path as-is', () => {
+      const config: HuConfig = {
+        ...getConfig(),
+        general: { claude_dir: '~/.claude', database: '/var/lib/hu/hu.db' },
+      };
+      const dbPath = getDatabasePath(config);
+      expect(dbPath).toBe('/var/lib/hu/hu.db');
+    });
+  });
+
+  describe('getClaudeDir', () => {
+    it('expands ~ in claude_dir', () => {
+      const config: HuConfig = {
+        ...getConfig(),
+        general: { claude_dir: '~/.claude', database: 'hu.db' },
+      };
+      const claudeDir = getClaudeDir(config);
+      expect(claudeDir).toBe(path.join(os.homedir(), '.claude'));
+    });
+
+    it('uses absolute path as-is', () => {
+      const config: HuConfig = {
+        ...getConfig(),
+        general: { claude_dir: '/custom/claude', database: 'hu.db' },
+      };
+      const claudeDir = getClaudeDir(config);
+      expect(claudeDir).toBe('/custom/claude');
+    });
+  });
+});

package/tests/lib/db.test.ts

@@ -0,0 +1,230 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import Database from 'better-sqlite3';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import { initializeSchema, getSchemaVersion } from '../../src/lib/schema.ts';
+
+describe('database', () => {
+  let tempDir: string;
+  let dbPath: string;
+  let db: Database.Database;
+
+  beforeEach(() => {
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'hu-db-test-'));
+    dbPath = path.join(tempDir, 'test.db');
+    db = new Database(dbPath);
+    db.pragma('journal_mode = WAL');
+    db.pragma('foreign_keys = ON');
+  });
+
+  afterEach(() => {
+    db.close();
+    try {
+      fs.rmSync(tempDir, { recursive: true });
+    } catch {
+      // Ignore cleanup errors
+    }
+  });
+
+  describe('schema initialization', () => {
+    it('creates all required tables', () => {
+      initializeSchema(db);
+      
+      const tables = db.prepare(`
+        SELECT name FROM sqlite_master WHERE type='table' ORDER BY name
+      `).all() as Array<{ name: string }>;
+      
+      const tableNames = tables.map(t => t.name);
+      expect(tableNames).toContain('sessions');
+      expect(tableNames).toContain('messages');
+      expect(tableNames).toContain('todos');
+      expect(tableNames).toContain('tool_usage');
+      expect(tableNames).toContain('sync_state');
+      expect(tableNames).toContain('schema_version');
+    });
+
+    it('creates FTS5 virtual table', () => {
+      initializeSchema(db);
+      
+      const tables = db.prepare(`
+        SELECT name FROM sqlite_master WHERE type='table' AND name LIKE '%fts%'
+      `).all() as Array<{ name: string }>;
+      
+      expect(tables.some(t => t.name === 'messages_fts')).toBe(true);
+    });
+
+    it('tracks schema version', () => {
+      initializeSchema(db);
+      const version = getSchemaVersion(db);
+      expect(version).toBeGreaterThan(0);
+    });
+
+    it('is idempotent (can run multiple times)', () => {
+      initializeSchema(db);
+      const version1 = getSchemaVersion(db);
+      
+      initializeSchema(db);
+      const version2 = getSchemaVersion(db);
+      
+      expect(version2).toBe(version1);
+    });
+  });
+
+  describe('data operations', () => {
+    beforeEach(() => {
+      initializeSchema(db);
+    });
+
+    it('inserts and retrieves sessions', () => {
+      db.prepare(`
+        INSERT INTO sessions (id, project, started_at)
+        VALUES (?, ?, ?)
+      `).run('test-session-1', '/Users/test/project', Date.now());
+
+      const session = db.prepare('SELECT * FROM sessions WHERE id = ?')
+        .get('test-session-1') as { id: string; project: string };
+
+      expect(session.id).toBe('test-session-1');
+      expect(session.project).toBe('/Users/test/project');
+    });
+
+    it('handles unicode in content', () => {
+      const unicodeContent = '日本語テスト 🎉 مرحبا';
+      
+      db.prepare(`
+        INSERT INTO sessions (id, project, started_at)
+        VALUES (?, ?, ?)
+      `).run('unicode-session', '/test', Date.now());
+
+      db.prepare(`
+        INSERT INTO messages (id, session_id, role, content, created_at)
+        VALUES (?, ?, ?, ?, ?)
+      `).run('msg-1', 'unicode-session', 'user', unicodeContent, Date.now());
+
+      const message = db.prepare('SELECT content FROM messages WHERE id = ?')
+        .get('msg-1') as { content: string };
+
+      expect(message.content).toBe(unicodeContent);
+    });
+
+    it('handles special characters in content', () => {
+      const specialContent = 'Quotes: "hello" and \'world\'\nBackslash: C:\\path\nDollar: $HOME';
+      
+      db.prepare(`
+        INSERT INTO sessions (id, project, started_at)
+        VALUES (?, ?, ?)
+      `).run('special-session', '/test', Date.now());
+
+      db.prepare(`
+        INSERT INTO messages (id, session_id, role, content, created_at)
+        VALUES (?, ?, ?, ?, ?)
+      `).run('msg-special', 'special-session', 'user', specialContent, Date.now());
+
+      const message = db.prepare('SELECT content FROM messages WHERE id = ?')
+        .get('msg-special') as { content: string };
+
+      expect(message.content).toBe(specialContent);
+    });
+
+    it('enforces foreign key constraints', () => {
+      expect(() => {
+        db.prepare(`
+          INSERT INTO messages (id, session_id, role, content, created_at)
+          VALUES (?, ?, ?, ?, ?)
+        `).run('orphan-msg', 'nonexistent-session', 'user', 'test', Date.now());
+      }).toThrow(/FOREIGN KEY/);
+    });
+
+    it('supports transactions', () => {
+      const insertMany = db.transaction((items: Array<{ id: string; project: string }>) => {
+        for (const item of items) {
+          db.prepare(`
+            INSERT INTO sessions (id, project, started_at)
+            VALUES (?, ?, ?)
+          `).run(item.id, item.project, Date.now());
+        }
+      });
+
+      insertMany([
+        { id: 'tx-1', project: '/a' },
+        { id: 'tx-2', project: '/b' },
+        { id: 'tx-3', project: '/c' },
+      ]);
+
+      const count = db.prepare('SELECT COUNT(*) as count FROM sessions')
+        .get() as { count: number };
+
+      expect(count.count).toBe(3);
+    });
+
+    it('rolls back transaction on error', () => {
+      const insertWithError = db.transaction(() => {
+        db.prepare(`
+          INSERT INTO sessions (id, project, started_at)
+          VALUES (?, ?, ?)
+        `).run('rollback-test', '/test', Date.now());
+
+        // This will fail due to duplicate primary key
+        db.prepare(`
+          INSERT INTO sessions (id, project, started_at)
+          VALUES (?, ?, ?)
+        `).run('rollback-test', '/test2', Date.now());
+      });
+
+      expect(() => insertWithError()).toThrow();
+
+      const count = db.prepare('SELECT COUNT(*) as count FROM sessions WHERE id = ?')
+        .get('rollback-test') as { count: number };
+
+      expect(count.count).toBe(0);
+    });
+  });
+
+  describe('FTS5 search', () => {
+    beforeEach(() => {
+      initializeSchema(db);
+      
+      // Insert test data
+      db.prepare(`
+        INSERT INTO sessions (id, project, started_at)
+        VALUES (?, ?, ?)
+      `).run('fts-session', '/test', Date.now());
+
+      const messages = [
+        { id: 'fts-1', content: 'Hello world this is a test' },
+        { id: 'fts-2', content: 'Another message with different content' },
+        { id: 'fts-3', content: 'Testing unicode: 日本語 and emoji 🎉' },
+      ];
+
+      for (const msg of messages) {
+        db.prepare(`
+          INSERT INTO messages (id, session_id, role, content, created_at)
+          VALUES (?, ?, ?, ?, ?)
+        `).run(msg.id, 'fts-session', 'user', msg.content, Date.now());
+      }
+    });
+
+    it('finds messages by keyword', () => {
+      const results = db.prepare(`
+        SELECT m.* FROM messages m
+        JOIN messages_fts fts ON m.rowid = fts.rowid
+        WHERE messages_fts MATCH ?
+      `).all('hello') as Array<{ id: string }>;
+
+      expect(results.length).toBe(1);
+      expect(results[0].id).toBe('fts-1');
+    });
+
+    it('finds messages with unicode content', () => {
+      const results = db.prepare(`
+        SELECT m.* FROM messages m
+        JOIN messages_fts fts ON m.rowid = fts.rowid
+        WHERE messages_fts MATCH ?
+      `).all('日本語') as Array<{ id: string }>;
+
+      expect(results.length).toBe(1);
+      expect(results[0].id).toBe('fts-3');
+    });
+  });
+});