@amirdaraee/namewise 0.5.2 → 0.5.4

package/tests/unit/parsers/pdf-parser.test.ts

@@ -1,63 +0,0 @@
-import { describe, it, expect, beforeEach } from 'vitest';
-import { PDFParser } from '../../../src/parsers/pdf-parser.js';
-import path from 'path';
-
-describe('PDFParser', () => {
-  let parser: PDFParser;
-  const testDataDir = path.join(process.cwd(), 'tests/data');
-
-  beforeEach(() => {
-    parser = new PDFParser();
-  });
-
-  describe('supports()', () => {
-    it('should support .pdf files', () => {
-      expect(parser.supports('test.pdf')).toBe(true);
-    });
-
-    it('should not support other file types', () => {
-      expect(parser.supports('test.txt')).toBe(false);
-      expect(parser.supports('test.docx')).toBe(false);
-      expect(parser.supports('test.xlsx')).toBe(false);
-      expect(parser.supports('test.md')).toBe(false);
-    });
-
-    it('should be case insensitive', () => {
-      expect(parser.supports('test.PDF')).toBe(true);
-      expect(parser.supports('test.Pdf')).toBe(true);
-    });
-  });
-
-  describe('parse()', () => {
-    it('should parse PDF file content correctly', async () => {
-      const filePath = path.join(testDataDir, 'sample-pdf.pdf');
-      const result = await parser.parse(filePath);
-
-      expect(result.content.length).toBeGreaterThan(0);
-      expect(typeof result.content).toBe('string');
-      expect(result.metadata).toBeDefined();
-      // Check for some expected content from the test PDF
-      expect(result.content.toLowerCase()).toMatch(/trace|type|specialization|dynamic|languages/);
-    });
-
-    it('should throw error for non-existent files', async () => {
-      const filePath = path.join(testDataDir, 'non-existent.pdf');
-      
-      await expect(parser.parse(filePath)).rejects.toThrow('Failed to parse PDF file');
-    });
-
-    it('should throw error for invalid PDF files', async () => {
-      const filePath = path.join(testDataDir, 'sample-text.txt'); // Not a PDF
-      
-      await expect(parser.parse(filePath)).rejects.toThrow('Failed to parse PDF file');
-    });
-
-    it('should trim whitespace from extracted content', async () => {
-      const filePath = path.join(testDataDir, 'sample-pdf.pdf');
-      const result = await parser.parse(filePath);
-
-      expect(result.content).not.toMatch(/^\s/);
-      expect(result.content).not.toMatch(/\s$/);
-    });
-  });
-});

package/tests/unit/parsers/text-parser.test.ts

@@ -1,85 +0,0 @@
-import { describe, it, expect, beforeEach } from 'vitest';
-import { TextParser } from '../../../src/parsers/text-parser.js';
-import path from 'path';
-
-describe('TextParser', () => {
-  let parser: TextParser;
-  const testDataDir = path.join(process.cwd(), 'tests/data');
-
-  beforeEach(() => {
-    parser = new TextParser();
-  });
-
-  describe('supports()', () => {
-    it('should support .txt files', () => {
-      expect(parser.supports('test.txt')).toBe(true);
-    });
-
-    it('should support .md files', () => {
-      expect(parser.supports('test.md')).toBe(true);
-    });
-
-    it('should support .rtf files', () => {
-      expect(parser.supports('test.rtf')).toBe(true);
-    });
-
-    it('should not support other file types', () => {
-      expect(parser.supports('test.pdf')).toBe(false);
-      expect(parser.supports('test.docx')).toBe(false);
-      expect(parser.supports('test.xlsx')).toBe(false);
-      expect(parser.supports('test.png')).toBe(false);
-    });
-
-    it('should be case insensitive', () => {
-      expect(parser.supports('test.TXT')).toBe(true);
-      expect(parser.supports('test.MD')).toBe(true);
-      expect(parser.supports('test.RTF')).toBe(true);
-    });
-  });
-
-  describe('parse()', () => {
-    it('should parse text file content correctly', async () => {
-      const filePath = path.join(testDataDir, 'sample-text.txt');
-      const result = await parser.parse(filePath);
-
-      expect(result.content).toContain('Project Requirements Document');
-      expect(result.content).toContain('customer management system');
-      expect(result.content).toContain('React.js');
-      expect(result.content.length).toBeGreaterThan(0);
-      expect(result.metadata).toBeDefined();
-    });
-
-    it('should parse markdown file content correctly', async () => {
-      const filePath = path.join(testDataDir, 'sample-markdown.md');
-      const result = await parser.parse(filePath);
-
-      expect(result.content).toContain('Meeting Notes');
-      expect(result.content).toContain('Action Items');
-      expect(result.content).toContain('John, Sarah, Mike');
-      expect(result.content.length).toBeGreaterThan(0);
-      expect(result.metadata).toBeDefined();
-    });
-
-    it('should handle empty files', async () => {
-      const filePath = path.join(testDataDir, 'empty-file.txt');
-      const result = await parser.parse(filePath);
-
-      expect(result.content).toBe('');
-      expect(result.metadata).toBeDefined();
-    });
-
-    it('should throw error for non-existent files', async () => {
-      const filePath = path.join(testDataDir, 'non-existent.txt');
-      
-      await expect(parser.parse(filePath)).rejects.toThrow('Failed to parse text file');
-    });
-
-    it('should trim whitespace from content', async () => {
-      const filePath = path.join(testDataDir, 'sample-text.txt');
-      const result = await parser.parse(filePath);
-
-      expect(result.content).not.toMatch(/^\s/);
-      expect(result.content).not.toMatch(/\s$/);
-    });
-  });
-});

package/tests/unit/services/ai-factory.test.ts

@@ -1,85 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { AIServiceFactory } from '../../../src/services/ai-factory.js';
-
-describe('AIServiceFactory', () => {
-  describe('create()', () => {
-    it('should create ClaudeService for claude provider', () => {
-      const service = AIServiceFactory.create('claude', 'test-api-key');
-      
-      expect(service).toBeDefined();
-      expect(service.name).toBe('Claude');
-      expect(typeof service.generateFileName).toBe('function');
-    });
-
-    it('should create OpenAIService for openai provider', () => {
-      const service = AIServiceFactory.create('openai', 'test-api-key');
-      
-      expect(service).toBeDefined();
-      expect(service.name).toBe('OpenAI');
-      expect(typeof service.generateFileName).toBe('function');
-    });
-
-    it('should create OllamaService for ollama provider', () => {
-      const service = AIServiceFactory.create('ollama');
-      
-      expect(service).toBeDefined();
-      expect(service.name).toBe('Ollama');
-      expect(typeof service.generateFileName).toBe('function');
-    });
-
-    it('should create LMStudioService for lmstudio provider', () => {
-      const service = AIServiceFactory.create('lmstudio');
-      
-      expect(service).toBeDefined();
-      expect(service.name).toBe('LMStudio');
-      expect(typeof service.generateFileName).toBe('function');
-    });
-
-    it('should create Ollama service with custom config', () => {
-      const service = AIServiceFactory.create('ollama', undefined, {
-        baseUrl: 'http://custom:8080',
-        model: 'custom-model'
-      });
-      
-      expect(service).toBeDefined();
-      expect(service.name).toBe('Ollama');
-    });
-
-    it('should create LMStudio service with custom config', () => {
-      const service = AIServiceFactory.create('lmstudio', undefined, {
-        baseUrl: 'http://custom:9000',
-        model: 'custom-model'
-      });
-      
-      expect(service).toBeDefined();
-      expect(service.name).toBe('LMStudio');
-    });
-
-    it('should throw error for unsupported provider', () => {
-      expect(() => {
-        AIServiceFactory.create('unsupported' as any, 'test-api-key');
-      }).toThrow('Unsupported AI provider: unsupported');
-    });
-
-    it('should require API key for Claude provider', () => {
-      expect(() => {
-        AIServiceFactory.create('claude');
-      }).toThrow('API key is required for Claude provider');
-    });
-
-    it('should require API key for OpenAI provider', () => {
-      expect(() => {
-        AIServiceFactory.create('openai');
-      }).toThrow('API key is required for OpenAI provider');
-    });
-
-    it('should pass API key to created cloud services', () => {
-      const claudeService = AIServiceFactory.create('claude', 'claude-key');
-      const openaiService = AIServiceFactory.create('openai', 'openai-key');
-      
-      // Services should be created without throwing errors
-      expect(claudeService).toBeDefined();
-      expect(openaiService).toBeDefined();
-    });
-  });
-});

package/tests/unit/services/claude-service.test.ts

@@ -1,188 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { ClaudeService } from '../../../src/services/claude-service.js';
-
-// Mock the Anthropic SDK
-vi.mock('@anthropic-ai/sdk', () => {
-  const MockAnthropic = vi.fn().mockImplementation(() => ({
-    messages: {
-      create: vi.fn()
-    }
-  }));
-  return {
-    default: MockAnthropic
-  };
-});
-
-describe('ClaudeService', () => {
-  let service: ClaudeService;
-  let mockClient: any;
-
-  beforeEach(() => {
-    service = new ClaudeService('test-api-key');
-    mockClient = (service as any).client;
-  });
-
-  describe('Basic Properties', () => {
-    it('should have correct name', () => {
-      expect(service.name).toBe('Claude');
-    });
-
-    it('should initialize with API key', () => {
-      expect(service).toBeDefined();
-    });
-  });
-
-  describe('generateFileName() with different naming conventions', () => {
-    const sampleContent = 'This is a project requirements document for Q4 2024 planning meeting.';
-    const originalName = 'document1.pdf';
-
-    beforeEach(() => {
-      mockClient.messages.create.mockResolvedValue({
-        content: [{ type: 'text', text: 'project requirements document q4 2024' }]
-      });
-    });
-
-    it('should generate filename with kebab-case convention (default)', async () => {
-      const result = await service.generateFileName(sampleContent, originalName);
-      
-      expect(mockClient.messages.create).toHaveBeenCalledWith(
-        expect.objectContaining({
-          model: 'claude-3-haiku-20240307',
-          messages: [expect.objectContaining({
-            role: 'user',
-            content: expect.stringContaining('Use lowercase with hyphens between words')
-          })]
-        })
-      );
-      
-      expect(result).toBe('project-requirements-document-q4-2024');
-    });
-
-    it('should generate filename with snake_case convention', async () => {
-      const result = await service.generateFileName(sampleContent, originalName, 'snake_case');
-      
-      expect(mockClient.messages.create).toHaveBeenCalledWith(
-        expect.objectContaining({
-          messages: [expect.objectContaining({
-            content: expect.stringContaining('Use lowercase with underscores between words')
-          })]
-        })
-      );
-      
-      expect(result).toBe('project_requirements_document_q4_2024');
-    });
-
-    it('should generate filename with camelCase convention', async () => {
-      mockClient.messages.create.mockResolvedValue({
-        content: [{ type: 'text', text: 'project requirements document q4 2024' }]
-      });
-
-      const result = await service.generateFileName(sampleContent, originalName, 'camelCase');
-      
-      expect(mockClient.messages.create).toHaveBeenCalledWith(
-        expect.objectContaining({
-          messages: [expect.objectContaining({
-            content: expect.stringContaining('Use camelCase format starting with lowercase')
-          })]
-        })
-      );
-      
-      expect(result).toBe('projectRequirementsDocumentQ42024');
-    });
-
-    it('should generate filename with PascalCase convention', async () => {
-      const result = await service.generateFileName(sampleContent, originalName, 'PascalCase');
-      
-      expect(mockClient.messages.create).toHaveBeenCalledWith(
-        expect.objectContaining({
-          messages: [expect.objectContaining({
-            content: expect.stringContaining('Use PascalCase format starting with uppercase')
-          })]
-        })
-      );
-      
-      expect(result).toBe('ProjectRequirementsDocumentQ42024');
-    });
-
-    it('should include original filename and content in prompt', async () => {
-      await service.generateFileName(sampleContent, originalName, 'kebab-case');
-      
-      const call = mockClient.messages.create.mock.calls[0][0];
-      expect(call.messages[0].content).toContain(sampleContent.substring(0, 2000));
-      expect(call.messages[0].content).toContain('Document content (first 2000 characters)');
-    });
-
-    it('should truncate long content to 2000 characters', async () => {
-      const longContent = 'a'.repeat(3000);
-      await service.generateFileName(longContent, originalName);
-      
-      const call = mockClient.messages.create.mock.calls[0][0];
-      const contentInPrompt = call.messages[0].content;
-      // Should only contain first 2000 characters
-      expect(contentInPrompt).toContain('a'.repeat(2000));
-      expect(contentInPrompt).not.toContain('a'.repeat(2001));
-    });
-  });
-
-  describe('Error Handling', () => {
-    it('should handle API errors gracefully', async () => {
-      mockClient.messages.create.mockRejectedValue(new Error('API Error'));
-      
-      await expect(service.generateFileName('content', 'file.txt')).rejects.toThrow(
-        'Failed to generate filename with Claude: API Error'
-      );
-    });
-
-    it('should handle non-text response content', async () => {
-      mockClient.messages.create.mockResolvedValue({
-        content: [{ type: 'image', text: null }]
-      });
-      
-      const result = await service.generateFileName('content', 'file.txt');
-      expect(result).toBe('untitled-document');
-    });
-
-    it('should handle empty response', async () => {
-      mockClient.messages.create.mockResolvedValue({
-        content: [{ type: 'text', text: '   ' }]
-      });
-      
-      const result = await service.generateFileName('content', 'file.txt');
-      expect(result).toBe('untitled-document');
-    });
-  });
-
-  describe('Filename Sanitization', () => {
-    beforeEach(() => {
-      mockClient.messages.create.mockResolvedValue({
-        content: [{ type: 'text', text: 'Test File@#$ Name.pdf' }]
-      });
-    });
-
-    it('should remove file extensions from AI suggestions', async () => {
-      const result = await service.generateFileName('content', 'original.txt', 'kebab-case');
-      expect(result).toBe('test-file-name');
-    });
-
-    it('should handle very long filenames', async () => {
-      mockClient.messages.create.mockResolvedValue({
-        content: [{ type: 'text', text: 'a'.repeat(150) }]
-      });
-      
-      const result = await service.generateFileName('content', 'file.txt', 'kebab-case');
-      expect(result.length).toBeLessThanOrEqual(100);
-    });
-
-    it('should preserve naming convention when truncating', async () => {
-      mockClient.messages.create.mockResolvedValue({
-        content: [{ type: 'text', text: 'very long filename that should be truncated properly' }]
-      });
-      
-      const kebabResult = await service.generateFileName('content', 'file.txt', 'kebab-case');
-      expect(kebabResult).not.toMatch(/-$/); // Should not end with hyphen
-      
-      const snakeResult = await service.generateFileName('content', 'file.txt', 'snake_case');
-      expect(snakeResult).not.toMatch(/_$/); // Should not end with underscore
-    });
-  });
-});