gh-here 1.0.1 → 1.0.4

package/tests/draftManager.test.js

@@ -0,0 +1,241 @@
+// Tests for DraftManager utility
+// Run with: node tests/draftManager.test.js
+
+// Mock localStorage for testing
+class MockLocalStorage {
+  constructor() {
+    this.store = {};
+  }
+
+  getItem(key) {
+    return this.store.hasOwnProperty(key) ? this.store[key] : null;
+  }
+
+  setItem(key, value) {
+    this.store[key] = String(value);
+  }
+
+  removeItem(key) {
+    delete this.store[key];
+  }
+
+  clear() {
+    this.store = {};
+  }
+
+  key(index) {
+    const keys = Object.keys(this.store);
+    return keys[index] || null;
+  }
+
+  get length() {
+    return Object.keys(this.store).length;
+  }
+}
+
+// Create testable version of DraftManager with injected storage
+function createDraftManager(storage) {
+  return {
+    STORAGE_PREFIX: 'gh-here-draft-',
+    
+    saveDraft(filePath, content) {
+      storage.setItem(`${this.STORAGE_PREFIX}${filePath}`, content);
+    },
+    
+    loadDraft(filePath) {
+      return storage.getItem(`${this.STORAGE_PREFIX}${filePath}`);
+    },
+    
+    clearDraft(filePath) {
+      storage.removeItem(`${this.STORAGE_PREFIX}${filePath}`);
+    },
+    
+    hasDraftChanges(filePath, originalContent) {
+      const draft = this.loadDraft(filePath);
+      return draft !== null && draft !== originalContent;
+    },
+    
+    getAllDrafts() {
+      const drafts = {};
+      for (let i = 0; i < storage.length; i++) {
+        const key = storage.key(i);
+        if (key && key.startsWith(this.STORAGE_PREFIX)) {
+          const filePath = key.replace(this.STORAGE_PREFIX, '');
+          drafts[filePath] = storage.getItem(key);
+        }
+      }
+      return drafts;
+    }
+  };
+}
+
+// Simple test framework
+function test(name, fn) {
+  try {
+    fn();
+    console.log(`✅ ${name}`);
+  } catch (error) {
+    console.log(`❌ ${name}: ${error.message}`);
+  }
+}
+
+function assertEqual(actual, expected, message = '') {
+  if (actual !== expected) {
+    throw new Error(`Expected "${expected}" but got "${actual}". ${message}`);
+  }
+}
+
+function assertNull(actual, message = '') {
+  if (actual !== null) {
+    throw new Error(`Expected null but got "${actual}". ${message}`);
+  }
+}
+
+function assertTrue(actual, message = '') {
+  if (!actual) {
+    throw new Error(`Expected truthy but got "${actual}". ${message}`);
+  }
+}
+
+function assertFalse(actual, message = '') {
+  if (actual) {
+    throw new Error(`Expected falsy but got "${actual}". ${message}`);
+  }
+}
+
+// Test cases
+console.log('🧪 Testing Draft Manager\n');
+
+test('saves and loads drafts correctly', () => {
+  const storage = new MockLocalStorage();
+  const draftManager = createDraftManager(storage);
+  
+  const filePath = '/src/app.js';
+  const content = 'console.log("hello world");';
+  
+  // Initially no draft
+  assertNull(draftManager.loadDraft(filePath));
+  
+  // Save draft
+  draftManager.saveDraft(filePath, content);
+  
+  // Load draft
+  assertEqual(draftManager.loadDraft(filePath), content);
+});
+
+test('clears drafts correctly', () => {
+  const storage = new MockLocalStorage();
+  const draftManager = createDraftManager(storage);
+  
+  const filePath = '/src/app.js';
+  const content = 'console.log("test");';
+  
+  // Save and verify
+  draftManager.saveDraft(filePath, content);
+  assertEqual(draftManager.loadDraft(filePath), content);
+  
+  // Clear and verify
+  draftManager.clearDraft(filePath);
+  assertNull(draftManager.loadDraft(filePath));
+});
+
+test('detects draft changes correctly', () => {
+  const storage = new MockLocalStorage();
+  const draftManager = createDraftManager(storage);
+  
+  const filePath = '/src/app.js';
+  const originalContent = 'const x = 1;';
+  const draftContent = 'const x = 2;';
+  
+  // No draft initially
+  assertFalse(draftManager.hasDraftChanges(filePath, originalContent));
+  
+  // Save draft with different content
+  draftManager.saveDraft(filePath, draftContent);
+  assertTrue(draftManager.hasDraftChanges(filePath, originalContent));
+  
+  // Save draft with same content
+  draftManager.saveDraft(filePath, originalContent);
+  assertFalse(draftManager.hasDraftChanges(filePath, originalContent));
+});
+
+test('gets all drafts correctly', () => {
+  const storage = new MockLocalStorage();
+  const draftManager = createDraftManager(storage);
+  
+  // Add some non-draft items to storage
+  storage.setItem('other-key', 'other-value');
+  
+  // Add drafts
+  draftManager.saveDraft('/src/app.js', 'app content');
+  draftManager.saveDraft('/src/utils.js', 'utils content');
+  draftManager.saveDraft('/README.md', 'readme content');
+  
+  const allDrafts = draftManager.getAllDrafts();
+  
+  // Should only return draft items
+  assertEqual(Object.keys(allDrafts).length, 3);
+  assertEqual(allDrafts['/src/app.js'], 'app content');
+  assertEqual(allDrafts['/src/utils.js'], 'utils content');
+  assertEqual(allDrafts['/README.md'], 'readme content');
+  
+  // Should not include non-draft items
+  assertEqual(allDrafts['other-key'], undefined);
+});
+
+test('handles multiple drafts independently', () => {
+  const storage = new MockLocalStorage();
+  const draftManager = createDraftManager(storage);
+  
+  const file1 = '/src/app.js';
+  const file2 = '/src/utils.js';
+  const content1 = 'app content';
+  const content2 = 'utils content';
+  
+  // Save drafts for different files
+  draftManager.saveDraft(file1, content1);
+  draftManager.saveDraft(file2, content2);
+  
+  // Each file has its own draft
+  assertEqual(draftManager.loadDraft(file1), content1);
+  assertEqual(draftManager.loadDraft(file2), content2);
+  
+  // Clear one draft, other remains
+  draftManager.clearDraft(file1);
+  assertNull(draftManager.loadDraft(file1));
+  assertEqual(draftManager.loadDraft(file2), content2);
+});
+
+test('uses correct storage prefix', () => {
+  const storage = new MockLocalStorage();
+  const draftManager = createDraftManager(storage);
+  
+  const filePath = '/src/app.js';
+  const content = 'test content';
+  
+  draftManager.saveDraft(filePath, content);
+  
+  // Check that correct key is used in storage
+  const expectedKey = 'gh-here-draft-/src/app.js';
+  assertEqual(storage.getItem(expectedKey), content);
+  
+  // Verify storage length
+  assertEqual(storage.length, 1);
+});
+
+test('handles empty content correctly', () => {
+  const storage = new MockLocalStorage();
+  const draftManager = createDraftManager(storage);
+  
+  const filePath = '/empty.js';
+  const emptyContent = '';
+  
+  draftManager.saveDraft(filePath, emptyContent);
+  assertEqual(draftManager.loadDraft(filePath), ''); // localStorage stores empty string as empty string
+  
+  // Empty content should be detected as different from non-empty
+  assertTrue(draftManager.hasDraftChanges(filePath, 'non-empty'), 'Empty draft should be different from non-empty original');
+  assertFalse(draftManager.hasDraftChanges(filePath, ''));
+});
+
+console.log('\n🎉 Draft Manager tests complete!');

package/tests/httpService.test.js

@@ -0,0 +1,268 @@
+// Tests for HTTP Service abstraction
+// Run with: node tests/httpService.test.js
+
+// Simple mock implementation for jest.fn()
+function jest_fn() {
+  const calls = [];
+  const mockFn = (...args) => {
+    calls.push(args);
+    return mockFn._returnValue;
+  };
+  mockFn.mock = { calls };
+  mockFn.mockResolvedValue = (value) => {
+    mockFn._returnValue = Promise.resolve(value);
+    return mockFn;
+  };
+  return mockFn;
+}
+
+// Replace jest with our simple implementation
+const jest = { fn: jest_fn };
+
+// Mock fetch for testing
+class MockResponse {
+  constructor(data, options = {}) {
+    this._data = data;
+    this.ok = options.ok !== false;
+    this.status = options.status || (this.ok ? 200 : 500);
+    this.statusText = options.statusText || (this.ok ? 'OK' : 'Internal Server Error');
+  }
+
+  async json() {
+    return this._data;
+  }
+
+  async text() {
+    return typeof this._data === 'string' ? this._data : JSON.stringify(this._data);
+  }
+}
+
+// Mock fetch implementation
+function createMockFetch(responseData, options = {}) {
+  return jest.fn().mockResolvedValue(new MockResponse(responseData, options));
+}
+
+// HTTP Service abstraction - pure functions, easily testable
+function createHttpService(fetchFn = fetch) {
+  return {
+    // File operations
+    async getFileContent(filePath) {
+      const response = await fetchFn(`/api/file-content?path=${encodeURIComponent(filePath)}`);
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+      }
+      return response.text();
+    },
+
+    async saveFile(filePath, content) {
+      const response = await fetchFn('/api/save-file', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ path: filePath, content })
+      });
+      return response.json();
+    },
+
+    async createFile(path, filename) {
+      const response = await fetchFn('/api/create-file', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ path, filename })
+      });
+      return response.json();
+    },
+
+    async deleteFile(path) {
+      const response = await fetchFn('/api/delete', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ path })
+      });
+      return response.json();
+    },
+
+    async renameFile(oldPath, newPath) {
+      const response = await fetchFn('/api/rename', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ oldPath, newPath })
+      });
+      return response.json();
+    },
+
+    // Folder operations
+    async createFolder(path, foldername) {
+      const response = await fetchFn('/api/create-folder', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ path, foldername })
+      });
+      return response.json();
+    },
+
+    // Git operations
+    async getGitStatus(currentPath) {
+      const response = await fetchFn(`/api/git-status?currentPath=${encodeURIComponent(currentPath)}`);
+      return response.json();
+    },
+
+    async getGitDiff(filePath) {
+      const response = await fetchFn(`/api/git-diff?path=${encodeURIComponent(filePath)}`);
+      return response.json();
+    },
+
+    async commitSelectedFiles(files, message) {
+      const response = await fetchFn('/api/git-commit-selected', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ files, message })
+      });
+      return response.json();
+    }
+  };
+}
+
+// Simple test framework (since we don't have a real test runner)
+function test(name, fn) {
+  try {
+    fn();
+    console.log(`✅ ${name}`);
+  } catch (error) {
+    console.log(`❌ ${name}: ${error.message}`);
+  }
+}
+
+function assertEqual(actual, expected, message = '') {
+  if (actual !== expected) {
+    throw new Error(`Expected "${expected}" but got "${actual}". ${message}`);
+  }
+}
+
+function assertDeepEqual(actual, expected, message = '') {
+  const actualStr = JSON.stringify(actual);
+  const expectedStr = JSON.stringify(expected);
+  if (actualStr !== expectedStr) {
+    throw new Error(`Expected ${expectedStr} but got ${actualStr}. ${message}`);
+  }
+}
+
+// Test cases
+console.log('🧪 Testing HTTP Service\n');
+
+test('gets file content correctly', async () => {
+  const mockFetch = jest.fn().mockResolvedValue(new MockResponse('file content'));
+  const httpService = createHttpService(mockFetch);
+  
+  const content = await httpService.getFileContent('src/app.js');
+  assertEqual(content, 'file content');
+  assertEqual(mockFetch.mock.calls[0][0], '/api/file-content?path=src%2Fapp.js');
+});
+
+test('saves file with correct parameters', async () => {
+  const mockFetch = jest.fn().mockResolvedValue(new MockResponse({ success: true }));
+  const httpService = createHttpService(mockFetch);
+  
+  const result = await httpService.saveFile('src/app.js', 'new content');
+  assertDeepEqual(result, { success: true });
+  
+  const [url, options] = mockFetch.mock.calls[0];
+  assertEqual(url, '/api/save-file');
+  assertEqual(options.method, 'POST');
+  assertDeepEqual(JSON.parse(options.body), { path: 'src/app.js', content: 'new content' });
+});
+
+test('creates file with correct parameters', async () => {
+  const mockFetch = jest.fn().mockResolvedValue(new MockResponse({ success: true }));
+  const httpService = createHttpService(mockFetch);
+  
+  const result = await httpService.createFile('src', 'newfile.js');
+  assertDeepEqual(result, { success: true });
+  
+  const [url, options] = mockFetch.mock.calls[0];
+  assertEqual(url, '/api/create-file');
+  assertDeepEqual(JSON.parse(options.body), { path: 'src', filename: 'newfile.js' });
+});
+
+test('deletes file with correct parameters', async () => {
+  const mockFetch = jest.fn().mockResolvedValue(new MockResponse({ success: true }));
+  const httpService = createHttpService(mockFetch);
+  
+  const result = await httpService.deleteFile('src/oldfile.js');
+  assertDeepEqual(result, { success: true });
+  
+  const [url, options] = mockFetch.mock.calls[0];
+  assertEqual(url, '/api/delete');
+  assertDeepEqual(JSON.parse(options.body), { path: 'src/oldfile.js' });
+});
+
+test('renames file with correct parameters', async () => {
+  const mockFetch = jest.fn().mockResolvedValue(new MockResponse({ success: true }));
+  const httpService = createHttpService(mockFetch);
+  
+  const result = await httpService.renameFile('src/old.js', 'src/new.js');
+  assertDeepEqual(result, { success: true });
+  
+  const [url, options] = mockFetch.mock.calls[0];
+  assertEqual(url, '/api/rename');
+  assertDeepEqual(JSON.parse(options.body), { oldPath: 'src/old.js', newPath: 'src/new.js' });
+});
+
+test('creates folder with correct parameters', async () => {
+  const mockFetch = jest.fn().mockResolvedValue(new MockResponse({ success: true }));
+  const httpService = createHttpService(mockFetch);
+  
+  const result = await httpService.createFolder('src', 'components');
+  assertDeepEqual(result, { success: true });
+  
+  const [url, options] = mockFetch.mock.calls[0];
+  assertEqual(url, '/api/create-folder');
+  assertDeepEqual(JSON.parse(options.body), { path: 'src', foldername: 'components' });
+});
+
+test('gets git status with correct parameters', async () => {
+  const mockFetch = jest.fn().mockResolvedValue(new MockResponse({ files: [] }));
+  const httpService = createHttpService(mockFetch);
+  
+  const result = await httpService.getGitStatus('src');
+  assertDeepEqual(result, { files: [] });
+  
+  assertEqual(mockFetch.mock.calls[0][0], '/api/git-status?currentPath=src');
+});
+
+test('gets git diff with correct parameters', async () => {
+  const mockFetch = jest.fn().mockResolvedValue(new MockResponse({ diff: 'diff content' }));
+  const httpService = createHttpService(mockFetch);
+  
+  const result = await httpService.getGitDiff('src/app.js');
+  assertDeepEqual(result, { diff: 'diff content' });
+  
+  assertEqual(mockFetch.mock.calls[0][0], '/api/git-diff?path=src%2Fapp.js');
+});
+
+test('commits selected files with correct parameters', async () => {
+  const mockFetch = jest.fn().mockResolvedValue(new MockResponse({ success: true }));
+  const httpService = createHttpService(mockFetch);
+  
+  const files = ['src/app.js', 'src/utils.js'];
+  const message = 'Fix bugs';
+  const result = await httpService.commitSelectedFiles(files, message);
+  assertDeepEqual(result, { success: true });
+  
+  const [url, options] = mockFetch.mock.calls[0];
+  assertEqual(url, '/api/git-commit-selected');
+  assertDeepEqual(JSON.parse(options.body), { files, message });
+});
+
+test('handles HTTP errors correctly', async () => {
+  const mockFetch = jest.fn().mockResolvedValue(new MockResponse('Not found', { ok: false, status: 404, statusText: 'Not Found' }));
+  const httpService = createHttpService(mockFetch);
+  
+  try {
+    await httpService.getFileContent('nonexistent.js');
+    throw new Error('Should have thrown an error');
+  } catch (error) {
+    assertEqual(error.message, 'HTTP 404: Not Found');
+  }
+});
+
+console.log('\n🎉 HTTP Service tests complete!');

package/tests/languageDetection.test.js

@@ -0,0 +1,145 @@
+// Simple unit tests for language detection
+// Run with: node tests/languageDetection.test.js
+
+// Import the function (in a real setup, you'd use proper modules)
+// For now, we'll copy the function to test it standalone
+
+function getLanguageFromExtension(filename) {
+  const ext = filename.split('.').pop().toLowerCase();
+  const languageMap = {
+    // JavaScript family
+    'js': 'javascript',
+    'mjs': 'javascript', 
+    'jsx': 'javascript',
+    'ts': 'typescript',
+    'tsx': 'typescript',
+    
+    // Web languages
+    'html': 'html',
+    'htm': 'html',
+    'css': 'css',
+    'scss': 'scss',
+    'sass': 'sass',
+    'less': 'less',
+    
+    // Data formats
+    'json': 'json',
+    'xml': 'xml',
+    'yaml': 'yaml',
+    'yml': 'yaml',
+    
+    // Programming languages
+    'py': 'python',
+    'java': 'java',
+    'go': 'go',
+    'rs': 'rust',
+    'php': 'php',
+    'rb': 'ruby',
+    'swift': 'swift',
+    'kt': 'kotlin',
+    'dart': 'dart',
+    
+    // Systems languages
+    'c': 'c',
+    'cpp': 'cpp',
+    'cc': 'cpp',
+    'cxx': 'cpp',
+    'h': 'c',
+    'hpp': 'cpp',
+    
+    // Shell and scripts
+    'sh': 'shell',
+    'bash': 'shell',
+    'zsh': 'shell',
+    'fish': 'shell',
+    'ps1': 'powershell',
+    
+    // Other languages
+    'sql': 'sql',
+    'r': 'r',
+    'scala': 'scala',
+    'clj': 'clojure',
+    'lua': 'lua',
+    'pl': 'perl',
+    'groovy': 'groovy',
+    
+    // Config and text
+    'md': 'markdown',
+    'txt': 'plaintext',
+    'log': 'plaintext'
+  };
+  
+  // Special filename handling
+  const basename = filename.toLowerCase();
+  if (basename === 'dockerfile' || basename.startsWith('dockerfile.')) return 'dockerfile';
+  if (basename === 'makefile') return 'makefile';
+  if (basename.startsWith('.env')) return 'dotenv';
+  if (basename === 'package.json' || basename === 'composer.json') return 'json';
+  
+  return languageMap[ext] || 'plaintext';
+}
+
+// Simple test framework
+function test(name, fn) {
+  try {
+    fn();
+    console.log(`✅ ${name}`);
+  } catch (error) {
+    console.log(`❌ ${name}: ${error.message}`);
+  }
+}
+
+function assertEqual(actual, expected, message = '') {
+  if (actual !== expected) {
+    throw new Error(`Expected "${expected}" but got "${actual}". ${message}`);
+  }
+}
+
+// Test cases
+console.log('🧪 Testing Language Detection Function\n');
+
+test('detects JavaScript files', () => {
+  assertEqual(getLanguageFromExtension('app.js'), 'javascript');
+  assertEqual(getLanguageFromExtension('module.mjs'), 'javascript');
+  assertEqual(getLanguageFromExtension('Component.jsx'), 'javascript');
+});
+
+test('detects TypeScript files', () => {
+  assertEqual(getLanguageFromExtension('main.ts'), 'typescript');
+  assertEqual(getLanguageFromExtension('Component.tsx'), 'typescript');
+});
+
+test('detects web languages', () => {
+  assertEqual(getLanguageFromExtension('index.html'), 'html');
+  assertEqual(getLanguageFromExtension('styles.css'), 'css');
+  assertEqual(getLanguageFromExtension('styles.scss'), 'scss');
+});
+
+test('detects programming languages', () => {
+  assertEqual(getLanguageFromExtension('script.py'), 'python');
+  assertEqual(getLanguageFromExtension('Main.java'), 'java');
+  assertEqual(getLanguageFromExtension('main.go'), 'go');
+  assertEqual(getLanguageFromExtension('lib.rs'), 'rust');
+});
+
+test('detects special filenames', () => {
+  assertEqual(getLanguageFromExtension('Dockerfile'), 'dockerfile');
+  assertEqual(getLanguageFromExtension('dockerfile.prod'), 'dockerfile');
+  assertEqual(getLanguageFromExtension('Makefile'), 'makefile');
+  assertEqual(getLanguageFromExtension('.env'), 'dotenv');
+  assertEqual(getLanguageFromExtension('.env.local'), 'dotenv');
+  assertEqual(getLanguageFromExtension('package.json'), 'json');
+});
+
+test('defaults to plaintext for unknown extensions', () => {
+  assertEqual(getLanguageFromExtension('file.unknown'), 'plaintext');
+  assertEqual(getLanguageFromExtension('README'), 'plaintext');
+  assertEqual(getLanguageFromExtension('file.xyz'), 'plaintext');
+});
+
+test('handles files without extensions', () => {
+  assertEqual(getLanguageFromExtension('README'), 'plaintext');
+  assertEqual(getLanguageFromExtension('LICENSE'), 'plaintext');
+});
+
+console.log('\n🎉 Language detection tests complete!');