@amirdaraee/namewise 0.3.0

package/src/utils/file-templates.ts

@@ -0,0 +1,275 @@
+import { NamingConvention, FileInfo } from '../types/index.js';
+import { applyNamingConvention } from './naming-conventions.js';
+
+export type FileCategory = 'document' | 'movie' | 'music' | 'series' | 'photo' | 'book' | 'general' | 'auto';
+
+export interface TemplateOptions {
+  personalName?: string;
+  dateFormat?: 'YYYY-MM-DD' | 'YYYY' | 'YYYYMMDD' | 'none';
+  category?: FileCategory;
+}
+
+export interface FileTemplate {
+  category: FileCategory;
+  pattern: string; // e.g., "{content}-{personalName}-{date}"
+  description: string;
+  examples: string[];
+}
+
+export const FILE_TEMPLATES: Record<Exclude<FileCategory, 'auto'>, FileTemplate> = {
+  document: {
+    category: 'document',
+    pattern: '{content}-{personalName}-{date}',
+    description: 'Personal documents with name and date',
+    examples: [
+      'driving-license-amirhossein-20250213.pdf',
+      'dennemeyer-working-contract-amirhossein-20240314.pdf',
+      'university-diploma-sarah-20220615.pdf'
+    ]
+  },
+  movie: {
+    category: 'movie',
+    pattern: '{content}-{year}',
+    description: 'Movies with release year',
+    examples: [
+      'the-dark-knight-2008.mkv',
+      'inception-2010.mp4',
+      'pulp-fiction-1994.avi'
+    ]
+  },
+  music: {
+    category: 'music',
+    pattern: '{artist}-{content}',
+    description: 'Music files with artist name',
+    examples: [
+      'the-beatles-hey-jude.mp3',
+      'queen-bohemian-rhapsody.flac',
+      'pink-floyd-wish-you-were-here.wav'
+    ]
+  },
+  series: {
+    category: 'series',
+    pattern: '{content}-s{season}e{episode}',
+    description: 'TV series with season and episode',
+    examples: [
+      'breaking-bad-s01e01.mkv',
+      'game-of-thrones-s04e09.mp4',
+      'the-office-s02e01.avi'
+    ]
+  },
+  photo: {
+    category: 'photo',
+    pattern: '{content}-{personalName}-{date}',
+    description: 'Photos with personal name and date',
+    examples: [
+      'vacation-paris-john-20240715.jpg',
+      'wedding-ceremony-maria-20231009.png',
+      'birthday-party-alex-20240320.heic'
+    ]
+  },
+  book: {
+    category: 'book',
+    pattern: '{author}-{content}',
+    description: 'Books with author name',
+    examples: [
+      'george-orwell-1984.pdf',
+      'j-k-rowling-harry-potter-philosophers-stone.epub',
+      'stephen-king-the-shining.mobi'
+    ]
+  },
+  general: {
+    category: 'general',
+    pattern: '{content}',
+    description: 'General files without special formatting',
+    examples: [
+      'meeting-notes-q4-2024.txt',
+      'project-requirements.docx',
+      'financial-report.xlsx'
+    ]
+  }
+};
+
+export function categorizeFile(filePath: string, content?: string, fileInfo?: FileInfo): FileCategory {
+  const extension = getFileExtension(filePath).toLowerCase();
+  const fileName = getFileName(filePath).toLowerCase();
+  const contentLower = content?.toLowerCase() || '';
+
+  // Use metadata for enhanced categorization
+  let metadataHints: string[] = [];
+  if (fileInfo?.documentMetadata) {
+    const meta = fileInfo.documentMetadata;
+    if (meta.title) metadataHints.push(meta.title.toLowerCase());
+    if (meta.author) metadataHints.push(meta.author.toLowerCase());
+    if (meta.creator) metadataHints.push(meta.creator.toLowerCase());
+    if (meta.subject) metadataHints.push(meta.subject.toLowerCase());
+    if (meta.keywords) metadataHints.push(...meta.keywords.map(k => k.toLowerCase()));
+  }
+
+  // Use folder context for better categorization
+  let folderHints: string[] = [];
+  if (fileInfo?.folderPath) {
+    folderHints = fileInfo.folderPath.map(f => f.toLowerCase());
+  }
+  if (fileInfo?.parentFolder) {
+    folderHints.push(fileInfo.parentFolder.toLowerCase());
+  }
+
+  const allHints = [...metadataHints, ...folderHints, contentLower, fileName].join(' ');
+
+  // Document types
+  const documentExtensions = ['.pdf', '.docx', '.doc', '.txt', '.rtf'];
+  const documentKeywords = ['contract', 'agreement', 'license', 'certificate', 'diploma', 'invoice', 'receipt', 'report', 'application', 'form', 'resume', 'cv', 'letter'];
+  
+  // Media types
+  const movieExtensions = ['.mp4', '.mkv', '.avi', '.mov', '.wmv', '.flv', '.webm'];
+  const musicExtensions = ['.mp3', '.flac', '.wav', '.aac', '.ogg', '.m4a'];
+  const photoExtensions = ['.jpg', '.jpeg', '.png', '.gif', '.bmp', '.tiff', '.heic', '.webp'];
+  const bookExtensions = ['.epub', '.mobi', '.azw', '.azw3'];
+  
+  // Enhanced series detection
+  const seriesKeywords = ['s01', 's02', 's03', 's04', 's05', 'season', 'episode', 'e01', 'e02', 'e03', 'series', 'show', 'tv'];
+  
+  // Enhanced movie keywords
+  const movieKeywords = ['movie', 'film', 'cinema', '1080p', '720p', '4k', 'bluray', 'dvdrip', 'webrip'];
+  
+  // Book keywords
+  const bookKeywords = ['chapter', 'author', 'book', 'novel', 'ebook', 'isbn', 'publisher', 'edition'];
+  
+  // Music keywords  
+  const musicKeywords = ['album', 'track', 'artist', 'band', 'singer', 'song', 'music'];
+  
+  // Photo keywords
+  const photoKeywords = ['photo', 'image', 'picture', 'vacation', 'wedding', 'birthday', 'selfie', 'portrait'];
+  
+  // Folder-based hints
+  const folderMovieHints = ['movies', 'films', 'cinema', 'video'];
+  const folderSeriesHints = ['series', 'shows', 'tv', 'television'];
+  const folderMusicHints = ['music', 'audio', 'songs', 'albums'];
+  const folderPhotoHints = ['photos', 'images', 'pictures', 'gallery'];
+  const folderBookHints = ['books', 'ebooks', 'library', 'reading'];
+  const folderDocumentHints = ['documents', 'docs', 'papers', 'files'];
+
+  // Check folder context first for strong hints
+  if (folderHints.some(hint => folderSeriesHints.includes(hint))) return 'series';
+  if (folderHints.some(hint => folderMovieHints.includes(hint))) return 'movie';
+  if (folderHints.some(hint => folderMusicHints.includes(hint))) return 'music';
+  if (folderHints.some(hint => folderPhotoHints.includes(hint))) return 'photo';
+  if (folderHints.some(hint => folderBookHints.includes(hint))) return 'book';
+  if (folderHints.some(hint => folderDocumentHints.includes(hint))) return 'document';
+
+  // Check for series first (before movies)
+  if (movieExtensions.includes(extension) && (
+    seriesKeywords.some(keyword => allHints.includes(keyword))
+  )) {
+    return 'series';
+  }
+
+  // Check by extension with enhanced keyword matching
+  if (documentExtensions.includes(extension)) {
+    // Check if it's a book
+    if (bookExtensions.includes(extension) || bookKeywords.some(keyword => allHints.includes(keyword))) {
+      return 'book';
+    }
+    // Check if it's likely a personal document
+    if (documentKeywords.some(keyword => allHints.includes(keyword))) {
+      return 'document';
+    }
+    return 'document'; // Default for document extensions
+  }
+
+  // Enhanced media type detection
+  if (movieExtensions.includes(extension)) {
+    if (movieKeywords.some(keyword => allHints.includes(keyword))) {
+      return 'movie';
+    }
+    return 'movie'; // Default for movie extensions
+  }
+  
+  if (musicExtensions.includes(extension)) {
+    if (musicKeywords.some(keyword => allHints.includes(keyword))) {
+      return 'music';
+    }
+    return 'music';
+  }
+  
+  if (photoExtensions.includes(extension)) {
+    if (photoKeywords.some(keyword => allHints.includes(keyword))) {
+      return 'photo';
+    }
+    return 'photo';
+  }
+  
+  if (bookExtensions.includes(extension)) return 'book';
+
+  return 'general';
+}
+
+export function applyTemplate(
+  aiGeneratedName: string,
+  category: FileCategory,
+  templateOptions: TemplateOptions,
+  namingConvention: NamingConvention
+): string {
+  if (category === 'auto') {
+    throw new Error('Cannot apply template for "auto" category. Category should be resolved before calling applyTemplate.');
+  }
+  const template = FILE_TEMPLATES[category as Exclude<FileCategory, 'auto'>];
+  let result = template.pattern;
+
+  // Replace template variables
+  result = result.replace('{content}', aiGeneratedName);
+
+  if (templateOptions.personalName) {
+    result = result.replace('{personalName}', templateOptions.personalName);
+  }
+
+  if (templateOptions.dateFormat && templateOptions.dateFormat !== 'none') {
+    const date = formatDate(new Date(), templateOptions.dateFormat);
+    result = result.replace('{date}', date);
+  }
+
+  // Clean up any remaining unreplaced variables
+  result = result.replace(/\{[^}]+\}/g, '');
+  
+  // Clean up multiple hyphens or other separators
+  result = result.replace(/-+/g, '-').replace(/^-|-$/g, '');
+
+  // Apply naming convention
+  return applyNamingConvention(result, namingConvention);
+}
+
+function formatDate(date: Date, format: 'YYYY-MM-DD' | 'YYYY' | 'YYYYMMDD'): string {
+  const year = date.getFullYear();
+  const month = String(date.getMonth() + 1).padStart(2, '0');
+  const day = String(date.getDate()).padStart(2, '0');
+
+  switch (format) {
+    case 'YYYY-MM-DD':
+      return `${year}-${month}-${day}`;
+    case 'YYYY':
+      return `${year}`;
+    case 'YYYYMMDD':
+      return `${year}${month}${day}`;
+    default:
+      return `${year}${month}${day}`;
+  }
+}
+
+function getFileExtension(filePath: string): string {
+  const parts = filePath.split('.');
+  return parts.length > 1 ? '.' + parts[parts.length - 1] : '';
+}
+
+function getFileName(filePath: string): string {
+  const pathParts = filePath.split(/[/\\]/);
+  const fileName = pathParts[pathParts.length - 1];
+  return fileName.replace(/\.[^.]*$/, ''); // Remove extension
+}
+
+export function getTemplateInstructions(category: FileCategory): string {
+  if (category === 'auto') {
+    return 'Generate appropriate filename based on detected file type and content.';
+  }
+  const template = FILE_TEMPLATES[category as Exclude<FileCategory, 'auto'>];
+  return `Generate filename for ${category} type files. ${template.description}. Examples: ${template.examples.join(', ')}`;
+}

package/src/utils/naming-conventions.ts

@@ -0,0 +1,67 @@
+export type NamingConvention = 'kebab-case' | 'snake_case' | 'camelCase' | 'PascalCase' | 'lowercase' | 'UPPERCASE';
+
+export function applyNamingConvention(text: string, convention: NamingConvention): string {
+  // First, normalize the text by removing special characters and extra spaces
+  const normalized = text
+    .replace(/[^\w\s-]/g, '') // Remove special characters except hyphens
+    .replace(/\s+/g, ' ')      // Normalize spaces
+    .trim();
+
+  switch (convention) {
+    case 'kebab-case':
+      return normalized
+        .toLowerCase()
+        .replace(/\s+/g, '-')
+        .replace(/[_]/g, '-');
+
+    case 'snake_case':
+      return normalized
+        .toLowerCase()
+        .replace(/\s+/g, '_')
+        .replace(/[-]/g, '_');
+
+    case 'camelCase':
+      return normalized
+        .split(/[\s\-_]+/)
+        .map((word, index) => 
+          index === 0 
+            ? word.toLowerCase() 
+            : word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()
+        )
+        .join('');
+
+    case 'PascalCase':
+      return normalized
+        .split(/[\s\-_]+/)
+        .map(word => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+        .join('');
+
+    case 'lowercase':
+      return normalized
+        .toLowerCase()
+        .replace(/\s+/g, '')
+        .replace(/[-_]/g, '');
+
+    case 'UPPERCASE':
+      return normalized
+        .toUpperCase()
+        .replace(/\s+/g, '')
+        .replace(/[-_]/g, '');
+
+    default:
+      return normalized.replace(/\s+/g, '-').toLowerCase(); // Default to kebab-case
+  }
+}
+
+export function getNamingInstructions(convention: NamingConvention): string {
+  const instructions = {
+    'kebab-case': 'Use lowercase with hyphens between words (e.g., "meeting-notes-2024")',
+    'snake_case': 'Use lowercase with underscores between words (e.g., "meeting_notes_2024")', 
+    'camelCase': 'Use camelCase format starting with lowercase (e.g., "meetingNotes2024")',
+    'PascalCase': 'Use PascalCase format starting with uppercase (e.g., "MeetingNotes2024")',
+    'lowercase': 'Use single lowercase word with no separators (e.g., "meetingnotes2024")',
+    'UPPERCASE': 'Use single uppercase word with no separators (e.g., "MEETINGNOTES2024")'
+  };
+
+  return instructions[convention];
+}

package/tests/data/sample-markdown.md

@@ -0,0 +1,9 @@
+# Meeting Notes
+
+Date: 2024-03-15
+Attendees: John, Sarah, Mike
+
+## Action Items
+- Review budget proposal
+- Update project timeline
+- Schedule follow-up meeting

package/tests/data/sample-text.txt

@@ -0,0 +1,25 @@
+Project Requirements Document
+=========================
+
+Overview
+--------
+This document outlines the requirements for the new customer management system.
+
+Features
+--------
+1. User Authentication
+2. Customer Database
+3. Reporting Dashboard
+4. Data Export Functionality
+
+Technical Stack
+--------------
+- Frontend: React.js
+- Backend: Node.js
+- Database: PostgreSQL
+
+Timeline
+--------
+Development: 3 months
+Testing: 1 month
+Deployment: 2 weeks

package/tests/integration/end-to-end.test.ts

@@ -0,0 +1,209 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { promises as fs } from 'fs';
+import path from 'path';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+
+const execAsync = promisify(exec);
+
+// Mock fs operations for integration tests
+vi.mock('fs', async () => {
+  const actual = await vi.importActual('fs');
+  return {
+    ...actual,
+    promises: {
+      ...actual.promises,
+      rename: vi.fn(),
+      access: vi.fn()
+    }
+  };
+});
+
+describe('End-to-End Integration Tests', () => {
+  const testDataDir = path.join(process.cwd(), 'tests/data');
+  const cliPath = path.join(process.cwd(), 'dist/index.js');
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  describe('CLI Integration', () => {
+    it('should show help message', async () => {
+      const { stdout } = await execAsync(`node ${cliPath} --help`);
+      
+      expect(stdout).toContain('AI-powered tool to intelligently rename files based on their content');
+      expect(stdout).toContain('rename [options] <directory>');
+      expect(stdout).toContain('Commands:');
+    });
+
+    it('should show rename command help', async () => {
+      const { stdout } = await execAsync(`node ${cliPath} rename --help`);
+      
+      expect(stdout).toContain('Rename files in a directory based on their content');
+      expect(stdout).toContain('Arguments:');
+      expect(stdout).toContain('directory');
+      expect(stdout).toContain('Options:');
+      expect(stdout).toContain('-p, --provider');
+      expect(stdout).toContain('-k, --api-key');
+      expect(stdout).toContain('-c, --case');
+      expect(stdout).toContain('-t, --template');
+      expect(stdout).toContain('-n, --name');
+      expect(stdout).toContain('-d, --date');
+      expect(stdout).toContain('--dry-run');
+      expect(stdout).toContain('--max-size');
+    });
+
+    it('should show naming convention options in help', async () => {
+      const { stdout } = await execAsync(`node ${cliPath} rename --help`);
+      
+      expect(stdout).toContain('kebab-case');
+      expect(stdout).toContain('snake_case');
+      expect(stdout).toContain('camelCase');
+      expect(stdout).toContain('PascalCase');
+      expect(stdout).toContain('lowercase');
+      expect(stdout).toContain('UPPERCASE');
+    });
+
+    it('should show template category options in help', async () => {
+      const { stdout } = await execAsync(`node ${cliPath} rename --help`);
+      
+      expect(stdout).toContain('document');
+      expect(stdout).toContain('movie');
+      expect(stdout).toContain('music');
+      expect(stdout).toContain('series');
+      expect(stdout).toContain('photo');
+      expect(stdout).toContain('book');
+      expect(stdout).toContain('general');
+    });
+
+    it('should show date format options in help', async () => {
+      const { stdout } = await execAsync(`node ${cliPath} rename --help`);
+      
+      expect(stdout).toContain('YYYY-MM-DD');
+      expect(stdout).toContain('YYYY');
+      expect(stdout).toContain('YYYYMMDD');
+      expect(stdout).toContain('none');
+    });
+
+    it('should show version', async () => {
+      const { stdout } = await execAsync(`node ${cliPath} --version`);
+      
+      expect(stdout.trim()).toMatch(/^\d+\.\d+\.\d+$/);
+    });
+
+    it('should require directory argument', async () => {
+      try {
+        await execAsync(`node ${cliPath} rename`);
+        expect.fail('Should have thrown an error');
+      } catch (error: any) {
+        expect(error.stderr || error.stdout).toContain('error: missing required argument');
+      }
+    });
+
+    it('should handle non-existent directory', async () => {
+      try {
+        await execAsync(`node ${cliPath} rename /non/existent/directory --dry-run`, {
+          input: 'test-key\n'
+        });
+        expect.fail('Should have thrown an error');
+      } catch (error: any) {
+        expect(error.stderr || error.stdout).toContain('Error:');
+      }
+    });
+  });
+
+  describe('Full Workflow Integration', () => {
+    it('should process files with mock AI service (dry run)', async () => {
+      // This test would need actual AI service mocking at the CLI level
+      // For now, we'll test the structure
+      
+      const testDir = path.join(testDataDir);
+      
+      // Mock the AI service response by setting environment variables or config
+      process.env.MOCK_AI_RESPONSE = 'test-document-name';
+      
+      try {
+        // This would fail without real API key, but tests the flow
+        const command = `echo "test-key" | node ${cliPath} rename ${testDir} --dry-run --provider claude`;
+        
+        // For a real test, we'd need to mock the AI service at a higher level
+        // This is a placeholder for the integration test structure
+        expect(true).toBe(true); // Placeholder assertion
+      } catch (error) {
+        // Expected in test environment without real API key
+        expect(true).toBe(true);
+      } finally {
+        delete process.env.MOCK_AI_RESPONSE;
+      }
+    });
+  });
+
+  describe('File Processing Integration', () => {
+    it('should detect supported files correctly', async () => {
+      // Create a temporary test directory structure
+      const tempDir = path.join(process.cwd(), 'temp-test');
+      
+      try {
+        await fs.mkdir(tempDir, { recursive: true });
+        await fs.writeFile(path.join(tempDir, 'test.txt'), 'Test content');
+        await fs.writeFile(path.join(tempDir, 'test.md'), '# Test markdown');
+        await fs.writeFile(path.join(tempDir, 'unsupported.xyz'), 'Unsupported file');
+        
+        // The actual CLI would process only supported files
+        // This test validates the file detection logic
+        
+        const files = await fs.readdir(tempDir);
+        const supportedExtensions = ['.txt', '.md', '.pdf', '.docx', '.xlsx'];
+        const supportedFiles = files.filter(file => 
+          supportedExtensions.some(ext => file.endsWith(ext))
+        );
+        
+        expect(supportedFiles).toHaveLength(2);
+        expect(supportedFiles).toContain('test.txt');
+        expect(supportedFiles).toContain('test.md');
+        expect(supportedFiles).not.toContain('unsupported.xyz');
+        
+      } finally {
+        // Clean up
+        try {
+          await fs.rm(tempDir, { recursive: true, force: true });
+        } catch (error) {
+          // Ignore cleanup errors
+        }
+      }
+    });
+  });
+
+  describe('Error Handling Integration', () => {
+    it('should handle parser errors gracefully', async () => {
+      // Test that the application handles various error conditions
+      // without crashing and provides meaningful error messages
+      
+      const invalidFiles = [
+        'non-existent.pdf',
+        'empty.txt',
+        'corrupted.docx'
+      ];
+      
+      // Each of these should be handled gracefully by the application
+      // without causing the entire process to fail
+      
+      expect(invalidFiles.length).toBeGreaterThan(0); // Placeholder assertion
+    });
+
+    it('should validate configuration parameters', async () => {
+      const invalidConfigs = [
+        { maxSize: -1 },
+        { maxSize: 'invalid' },
+        { provider: 'invalid-provider' }
+      ];
+      
+      // Each invalid config should be caught and handled appropriately
+      expect(invalidConfigs.length).toBeGreaterThan(0); // Placeholder assertion
+    });
+  });
+});