@amirdaraee/namewise 0.3.0

package/tests/integration/workflow.test.ts

@@ -0,0 +1,336 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { promises as fs } from 'fs';
+import path from 'path';
+import { DocumentParserFactory } from '../../src/parsers/factory.js';
+import { FileRenamer } from '../../src/services/file-renamer.js';
+import { MockAIService } from '../mocks/mock-ai-service.js';
+import { Config, FileInfo } from '../../src/types/index.js';
+
+// Mock file system operations
+vi.mock('fs', async () => {
+  const actual = await vi.importActual('fs');
+  return {
+    ...actual,
+    promises: {
+      ...actual.promises,
+      rename: vi.fn(),
+      access: vi.fn(),
+      stat: vi.fn(),
+      readdir: vi.fn()
+    }
+  };
+});
+
+describe('Workflow Integration Tests', () => {
+  let mockAIService: MockAIService;
+  let parserFactory: DocumentParserFactory;
+  let fileRenamer: FileRenamer;
+  let config: Config;
+  const testDataDir = path.join(process.cwd(), 'tests/data');
+
+  beforeEach(() => {
+    mockAIService = new MockAIService();
+    parserFactory = new DocumentParserFactory();
+    config = {
+      aiProvider: 'claude',
+      apiKey: 'test-key',
+      maxFileSize: 10 * 1024 * 1024,
+      supportedExtensions: ['.txt', '.pdf', '.docx', '.xlsx', '.md'],
+      dryRun: false,
+      namingConvention: 'kebab-case',
+      templateOptions: {
+        category: 'general',
+        personalName: undefined,
+        dateFormat: 'none'
+      }
+    };
+
+    fileRenamer = new FileRenamer(parserFactory, mockAIService, config);
+    
+    vi.clearAllMocks();
+    mockAIService.resetCallCount();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  describe('Complete File Processing Workflow', () => {
+    it('should process mixed file types successfully', async () => {
+      const testFiles: FileInfo[] = [
+        {
+          path: path.join(testDataDir, 'sample-text.txt'),
+          name: 'sample-text.txt',
+          extension: '.txt',
+          size: 1000
+        },
+        {
+          path: path.join(testDataDir, 'sample-markdown.md'),
+          name: 'sample-markdown.md',
+          extension: '.md',
+          size: 500
+        }
+      ];
+
+      // Mock successful file operations
+      vi.mocked(fs.access).mockRejectedValue({ code: 'ENOENT' });
+      vi.mocked(fs.rename).mockResolvedValue(undefined);
+
+      // Set up different AI responses for different content types
+      mockAIService.setMockResponse('default', 'project-requirements-document');
+      mockAIService.setMockResponse('meeting', 'team-meeting-notes-march-2024');
+
+      const results = await fileRenamer.renameFiles(testFiles);
+
+      expect(results).toHaveLength(2);
+      expect(results.every(r => r.success)).toBe(true);
+      expect(mockAIService.getCallCount()).toBe(2);
+      expect(fs.rename).toHaveBeenCalledTimes(2);
+
+      // Verify different filenames were generated
+      expect(results[0].suggestedName).toContain('project-requirements-document');
+      expect(results[1].suggestedName).toContain('team-meeting-notes');
+    });
+
+    it('should handle mixed success and failure scenarios', async () => {
+      const testFiles: FileInfo[] = [
+        {
+          path: path.join(testDataDir, 'sample-text.txt'),
+          name: 'sample-text.txt',
+          extension: '.txt',
+          size: 1000
+        },
+        {
+          path: path.join(testDataDir, 'large-file.txt'),
+          name: 'large-file.txt',
+          extension: '.txt',
+          size: 20 * 1024 * 1024 // Exceeds limit
+        },
+        {
+          path: path.join(testDataDir, 'empty-file.txt'),
+          name: 'empty-file.txt',
+          extension: '.txt',
+          size: 0
+        }
+      ];
+
+      vi.mocked(fs.access).mockRejectedValue({ code: 'ENOENT' });
+      vi.mocked(fs.rename).mockResolvedValue(undefined);
+
+      const results = await fileRenamer.renameFiles(testFiles);
+
+      expect(results).toHaveLength(3);
+      expect(results[0].success).toBe(true);  // Normal file
+      expect(results[1].success).toBe(false); // Too large
+      expect(results[2].success).toBe(false); // Empty file
+
+      expect(results[1].error).toContain('File size');
+      expect(results[2].error).toContain('No content could be extracted');
+
+      // Only the successful file should trigger AI call and rename
+      expect(mockAIService.getCallCount()).toBe(1);
+      expect(fs.rename).toHaveBeenCalledOnce();
+    });
+
+    it('should respect dry-run mode across all files', async () => {
+      config.dryRun = true;
+      fileRenamer = new FileRenamer(parserFactory, mockAIService, config);
+
+      const testFiles: FileInfo[] = [
+        {
+          path: path.join(testDataDir, 'sample-text.txt'),
+          name: 'sample-text.txt',
+          extension: '.txt',
+          size: 1000
+        },
+        {
+          path: path.join(testDataDir, 'sample-markdown.md'),
+          name: 'sample-markdown.md',
+          extension: '.md',
+          size: 500
+        }
+      ];
+
+      vi.mocked(fs.access).mockRejectedValue({ code: 'ENOENT' });
+
+      const results = await fileRenamer.renameFiles(testFiles);
+
+      expect(results).toHaveLength(2);
+      expect(results.every(r => r.success)).toBe(true);
+      expect(mockAIService.getCallCount()).toBe(2); // AI should still be called
+      expect(fs.rename).not.toHaveBeenCalled(); // But no actual renaming
+    });
+
+    it('should handle file conflicts appropriately', async () => {
+      const testFiles: FileInfo[] = [
+        {
+          path: path.join(testDataDir, 'sample-text.txt'),
+          name: 'sample-text.txt',
+          extension: '.txt',
+          size: 1000
+        }
+      ];
+
+      // Simulate that the target filename already exists
+      vi.mocked(fs.access).mockResolvedValue(undefined);
+
+      const results = await fileRenamer.renameFiles(testFiles);
+
+      expect(results).toHaveLength(1);
+      expect(results[0].success).toBe(false);
+      expect(results[0].error).toContain('Target filename already exists');
+      
+      // AI should still be called, but no renaming should occur
+      expect(mockAIService.getCallCount()).toBe(1);
+      expect(fs.rename).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('Parser Integration', () => {
+    it('should use correct parser for each file type', async () => {
+      const testFiles: FileInfo[] = [
+        {
+          path: path.join(testDataDir, 'sample-text.txt'),
+          name: 'sample-text.txt',
+          extension: '.txt',
+          size: 1000
+        },
+        {
+          path: path.join(testDataDir, 'sample-pdf.pdf'),
+          name: 'sample-pdf.pdf',
+          extension: '.pdf',
+          size: 2000
+        }
+      ];
+
+      vi.mocked(fs.access).mockRejectedValue({ code: 'ENOENT' });
+      vi.mocked(fs.rename).mockResolvedValue(undefined);
+
+      const results = await fileRenamer.renameFiles(testFiles);
+
+      expect(results).toHaveLength(2);
+      expect(results.every(r => r.success)).toBe(true);
+
+      // Both files should be processed successfully using their respective parsers
+      expect(mockAIService.getCallCount()).toBe(2);
+      expect(fs.rename).toHaveBeenCalledTimes(2);
+    });
+
+    it('should reject unsupported file types', async () => {
+      const testFiles: FileInfo[] = [
+        {
+          path: path.join(testDataDir, 'unsupported.xyz'),
+          name: 'unsupported.xyz',
+          extension: '.xyz',
+          size: 1000
+        }
+      ];
+
+      const results = await fileRenamer.renameFiles(testFiles);
+
+      expect(results).toHaveLength(1);
+      expect(results[0].success).toBe(false);
+      expect(results[0].error).toContain('No parser available');
+      
+      expect(mockAIService.getCallCount()).toBe(0);
+      expect(fs.rename).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('AI Service Integration', () => {
+    it('should handle AI service failures gracefully', async () => {
+      mockAIService.setShouldFail(true);
+
+      const testFiles: FileInfo[] = [
+        {
+          path: path.join(testDataDir, 'sample-text.txt'),
+          name: 'sample-text.txt',
+          extension: '.txt',
+          size: 1000
+        }
+      ];
+
+      const results = await fileRenamer.renameFiles(testFiles);
+
+      expect(results).toHaveLength(1);
+      expect(results[0].success).toBe(false);
+      expect(results[0].error).toContain('Mock AI service failed');
+      
+      expect(mockAIService.getCallCount()).toBe(1);
+      expect(fs.rename).not.toHaveBeenCalled();
+    });
+
+    it('should generate contextually appropriate filenames', async () => {
+      const testFiles: FileInfo[] = [
+        {
+          path: path.join(testDataDir, 'sample-text.txt'),
+          name: 'sample-text.txt',
+          extension: '.txt',
+          size: 1000
+        },
+        {
+          path: path.join(testDataDir, 'sample-markdown.md'),
+          name: 'sample-markdown.md',
+          extension: '.md',
+          size: 500
+        }
+      ];
+
+      vi.mocked(fs.access).mockRejectedValue({ code: 'ENOENT' });
+      vi.mocked(fs.rename).mockResolvedValue(undefined);
+
+      const results = await fileRenamer.renameFiles(testFiles);
+
+      expect(results).toHaveLength(2);
+      expect(results.every(r => r.success)).toBe(true);
+
+      // Verify that different content generates different filenames
+      expect(results[0].suggestedName).not.toBe(results[1].suggestedName);
+      
+      // Filenames should reflect content
+      expect(results[0].suggestedName).toContain('project-requirements-document');
+      expect(results[1].suggestedName).toContain('team-meeting-notes');
+    });
+  });
+
+  describe('Error Recovery and Resilience', () => {
+    it('should continue processing after individual file failures', async () => {
+      const testFiles: FileInfo[] = [
+        {
+          path: path.join(testDataDir, 'sample-text.txt'),
+          name: 'sample-text.txt',
+          extension: '.txt',
+          size: 1000
+        },
+        {
+          path: path.join(testDataDir, 'non-existent.txt'),
+          name: 'non-existent.txt',
+          extension: '.txt',
+          size: 1000
+        },
+        {
+          path: path.join(testDataDir, 'sample-markdown.md'),
+          name: 'sample-markdown.md',
+          extension: '.md',
+          size: 500
+        }
+      ];
+
+      vi.mocked(fs.access).mockRejectedValue({ code: 'ENOENT' });
+      vi.mocked(fs.rename).mockResolvedValue(undefined);
+
+      const results = await fileRenamer.renameFiles(testFiles);
+
+      expect(results).toHaveLength(3);
+      expect(results[0].success).toBe(true);  // First file succeeds
+      expect(results[1].success).toBe(false); // Second file fails
+      expect(results[2].success).toBe(true);  // Third file still processes
+
+      expect(results[1].error).toContain('Failed to parse text file');
+      
+      // Two successful files should generate AI calls and renames
+      expect(mockAIService.getCallCount()).toBe(2);
+      expect(fs.rename).toHaveBeenCalledTimes(2);
+    });
+  });
+});

package/tests/mocks/mock-ai-service.ts

@@ -0,0 +1,58 @@
+import { AIProvider } from '../../src/types/index.js';
+
+export class MockAIService implements AIProvider {
+  name = 'MockAI';
+  private mockResponses: Map<string, string> = new Map();
+  private shouldFail = false;
+  private callCount = 0;
+
+  constructor() {
+    // Default mock responses
+    this.mockResponses.set('default', 'project-requirements-document');
+    this.mockResponses.set('meeting', 'team-meeting-notes-march-2024');
+    this.mockResponses.set('report', 'quarterly-sales-report-q1-2024');
+  }
+
+  setMockResponse(key: string, response: string): void {
+    this.mockResponses.set(key, response);
+  }
+
+  setShouldFail(shouldFail: boolean): void {
+    this.shouldFail = shouldFail;
+  }
+
+  getCallCount(): number {
+    return this.callCount;
+  }
+
+  resetCallCount(): void {
+    this.callCount = 0;
+  }
+
+  async generateFileName(content: string, originalName: string, namingConvention?: string, category?: string): Promise<string> {
+    this.callCount++;
+
+    if (this.shouldFail) {
+      throw new Error('Mock AI service failed');
+    }
+
+    // Simple logic to return different responses based on content
+    const contentLower = content.toLowerCase();
+    
+    if (contentLower.includes('meeting') || contentLower.includes('attendees')) {
+      return this.mockResponses.get('meeting') || 'meeting-notes';
+    }
+    
+    if (contentLower.includes('requirements') || contentLower.includes('project')) {
+      return this.mockResponses.get('default') || 'project-document';
+    }
+    
+    if (contentLower.includes('report') || contentLower.includes('sales')) {
+      return this.mockResponses.get('report') || 'business-report';
+    }
+
+    // Fallback to a generic name based on original filename
+    const baseName = originalName.replace(/\.[^/.]+$/, '');
+    return `renamed-${baseName}`;
+  }
+}

package/tests/unit/cli/commands.test.ts

@@ -0,0 +1,163 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { Command } from 'commander';
+import { setupCommands } from '../../../src/cli/commands.js';
+
+// Mock the rename function to avoid actual execution
+vi.mock('../../../src/cli/rename.js', () => ({
+  renameFiles: vi.fn()
+}));
+
+describe('CLI Commands', () => {
+  let program: Command;
+
+  beforeEach(() => {
+    program = new Command();
+    vi.clearAllMocks();
+  });
+
+  describe('setupCommands()', () => {
+    it('should set up rename command', () => {
+      setupCommands(program);
+      
+      const renameCommand = program.commands.find(cmd => cmd.name() === 'rename');
+      expect(renameCommand).toBeDefined();
+      expect(renameCommand?.description()).toBe('Rename files in a directory based on their content');
+    });
+
+    it('should configure rename command with correct arguments', () => {
+      setupCommands(program);
+      
+      const renameCommand = program.commands.find(cmd => cmd.name() === 'rename');
+      expect(renameCommand).toBeDefined();
+      expect(renameCommand?.description()).toContain('Rename files in a directory');
+    });
+
+    it('should configure rename command with correct options', () => {
+      setupCommands(program);
+      
+      const renameCommand = program.commands.find(cmd => cmd.name() === 'rename');
+      expect(renameCommand).toBeDefined();
+      
+      const options = renameCommand?.options;
+      expect(options).toBeDefined();
+      
+      // Check provider option
+      const providerOption = options?.find(opt => opt.long === '--provider');
+      expect(providerOption).toBeDefined();
+      expect(providerOption?.description).toBe('AI provider (claude|openai)');
+      expect(providerOption?.defaultValue).toBe('claude');
+
+      // Check api-key option
+      const apiKeyOption = options?.find(opt => opt.long === '--api-key');
+      expect(apiKeyOption).toBeDefined();
+      expect(apiKeyOption?.description).toBe('API key for the AI provider');
+
+      // Check dry-run option
+      const dryRunOption = options?.find(opt => opt.long === '--dry-run');
+      expect(dryRunOption).toBeDefined();
+      expect(dryRunOption?.description).toBe('Preview changes without renaming files');
+      expect(dryRunOption?.defaultValue).toBe(false);
+
+      // Check max-size option
+      const maxSizeOption = options?.find(opt => opt.long === '--max-size');
+      expect(maxSizeOption).toBeDefined();
+      expect(maxSizeOption?.description).toBe('Maximum file size in MB');
+      expect(maxSizeOption?.defaultValue).toBe('10');
+    });
+
+    it('should have short option aliases', () => {
+      setupCommands(program);
+      
+      const renameCommand = program.commands.find(cmd => cmd.name() === 'rename');
+      const options = renameCommand?.options;
+      
+      // Check provider has -p alias
+      const providerOption = options?.find(opt => opt.long === '--provider');
+      expect(providerOption?.short).toBe('-p');
+
+      // Check api-key has -k alias
+      const apiKeyOption = options?.find(opt => opt.long === '--api-key');
+      expect(apiKeyOption?.short).toBe('-k');
+    });
+  });
+
+  describe('Command parsing', () => {
+    it('should parse directory argument correctly', async () => {
+      const { renameFiles } = await import('../../../src/cli/rename.js');
+      
+      setupCommands(program);
+      
+      await program.parseAsync(['node', 'test', 'rename', '/test/directory'], { from: 'node' });
+      
+      expect(renameFiles).toHaveBeenCalledWith('/test/directory', expect.any(Object));
+    });
+
+    it('should parse options correctly', async () => {
+      const { renameFiles } = await import('../../../src/cli/rename.js');
+      
+      setupCommands(program);
+      
+      await program.parseAsync([
+        'node', 'test', 'rename', '/test/directory',
+        '--provider', 'openai',
+        '--api-key', 'test-key',
+        '--dry-run',
+        '--max-size', '20'
+      ], { from: 'node' });
+      
+      expect(renameFiles).toHaveBeenCalledWith('/test/directory', {
+        provider: 'openai',
+        apiKey: 'test-key',
+        dryRun: true,
+        maxSize: '20',
+        case: 'kebab-case',
+        template: 'general',
+        name: undefined,
+        date: 'none'
+      });
+    });
+
+    it('should use default values for options', async () => {
+      const { renameFiles } = await import('../../../src/cli/rename.js');
+      
+      setupCommands(program);
+      
+      await program.parseAsync(['node', 'test', 'rename', '/test/directory'], { from: 'node' });
+      
+      const callArgs = vi.mocked(renameFiles).mock.calls[0];
+      expect(callArgs[1]).toEqual({
+        provider: 'claude',
+        apiKey: undefined,
+        dryRun: false,
+        maxSize: '10',
+        case: 'kebab-case',
+        template: 'general',
+        name: undefined,
+        date: 'none'
+      });
+    });
+
+    it('should handle short option aliases', async () => {
+      const { renameFiles } = await import('../../../src/cli/rename.js');
+      
+      setupCommands(program);
+      
+      await program.parseAsync([
+        'node', 'test', 'rename', '/test/directory',
+        '-p', 'openai',
+        '-k', 'test-key'
+      ], { from: 'node' });
+      
+      expect(renameFiles).toHaveBeenCalledWith('/test/directory', {
+        provider: 'openai',
+        apiKey: 'test-key',
+        dryRun: false,
+        maxSize: '10',
+        case: 'kebab-case',
+        template: 'general',
+        name: undefined,
+        date: 'none'
+      });
+    });
+  });
+});

package/tests/unit/parsers/factory.test.ts

@@ -0,0 +1,100 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { DocumentParserFactory } from '../../../src/parsers/factory.js';
+
+describe('DocumentParserFactory', () => {
+  let factory: DocumentParserFactory;
+
+  beforeEach(() => {
+    factory = new DocumentParserFactory();
+  });
+
+  describe('getParser()', () => {
+    it('should return PDFParser for PDF files', () => {
+      const parser = factory.getParser('test.pdf');
+      expect(parser).toBeDefined();
+      expect(parser?.supports('test.pdf')).toBe(true);
+    });
+
+    it('should return WordParser for Word documents', () => {
+      const parser1 = factory.getParser('test.docx');
+      const parser2 = factory.getParser('test.doc');
+      
+      expect(parser1).toBeDefined();
+      expect(parser2).toBeDefined();
+      expect(parser1?.supports('test.docx')).toBe(true);
+      expect(parser2?.supports('test.doc')).toBe(true);
+    });
+
+    it('should return ExcelParser for Excel files', () => {
+      const parser1 = factory.getParser('test.xlsx');
+      const parser2 = factory.getParser('test.xls');
+      
+      expect(parser1).toBeDefined();
+      expect(parser2).toBeDefined();
+      expect(parser1?.supports('test.xlsx')).toBe(true);
+      expect(parser2?.supports('test.xls')).toBe(true);
+    });
+
+    it('should return TextParser for text files', () => {
+      const parser1 = factory.getParser('test.txt');
+      const parser2 = factory.getParser('test.md');
+      const parser3 = factory.getParser('test.rtf');
+      
+      expect(parser1).toBeDefined();
+      expect(parser2).toBeDefined();
+      expect(parser3).toBeDefined();
+      expect(parser1?.supports('test.txt')).toBe(true);
+      expect(parser2?.supports('test.md')).toBe(true);
+      expect(parser3?.supports('test.rtf')).toBe(true);
+    });
+
+    it('should return null for unsupported file types', () => {
+      const parser1 = factory.getParser('test.png');
+      const parser2 = factory.getParser('test.jpg');
+      const parser3 = factory.getParser('test.mp4');
+      const parser4 = factory.getParser('test.zip');
+      
+      expect(parser1).toBeNull();
+      expect(parser2).toBeNull();
+      expect(parser3).toBeNull();
+      expect(parser4).toBeNull();
+    });
+
+    it('should be case insensitive', () => {
+      const parser1 = factory.getParser('test.PDF');
+      const parser2 = factory.getParser('test.DOCX');
+      const parser3 = factory.getParser('test.TXT');
+      
+      expect(parser1).toBeDefined();
+      expect(parser2).toBeDefined();
+      expect(parser3).toBeDefined();
+    });
+  });
+
+  describe('getSupportedExtensions()', () => {
+    it('should return all supported extensions', () => {
+      const extensions = factory.getSupportedExtensions();
+      
+      expect(extensions).toContain('.pdf');
+      expect(extensions).toContain('.docx');
+      expect(extensions).toContain('.doc');
+      expect(extensions).toContain('.xlsx');
+      expect(extensions).toContain('.xls');
+      expect(extensions).toContain('.txt');
+      expect(extensions).toContain('.md');
+      expect(extensions).toContain('.rtf');
+    });
+
+    it('should return unique extensions', () => {
+      const extensions = factory.getSupportedExtensions();
+      const uniqueExtensions = [...new Set(extensions)];
+      
+      expect(extensions.length).toBe(uniqueExtensions.length);
+    });
+
+    it('should include at least 8 extensions', () => {
+      const extensions = factory.getSupportedExtensions();
+      expect(extensions.length).toBeGreaterThanOrEqual(8);
+    });
+  });
+});