@amirdaraee/namewise 0.5.2 → 0.5.4

package/src/cli/rename.ts

@@ -1,171 +0,0 @@
-import { promises as fs } from 'fs';
-import path from 'path';
-import inquirer from 'inquirer';
-import { FileInfo, Config, RenameResult, FileCategory, DateFormat } from '../types/index.js';
-import { DocumentParserFactory } from '../parsers/factory.js';
-import { AIServiceFactory } from '../services/ai-factory.js';
-import { FileRenamer } from '../services/file-renamer.js';
-
-export async function renameFiles(directory: string, options: any): Promise<void> {
-  try {
-    // Validate directory exists
-    const stats = await fs.stat(directory);
-    if (!stats.isDirectory()) {
-      throw new Error(`${directory} is not a directory`);
-    }
-
-    // Get API key for cloud providers only
-    let apiKey = options.apiKey;
-    const requiresApiKey = ['claude', 'openai'].includes(options.provider);
-    
-    if (requiresApiKey && !apiKey) {
-      // Check environment variables first
-      if (options.provider === 'claude' && process.env.CLAUDE_API_KEY) {
-        apiKey = process.env.CLAUDE_API_KEY;
-      } else if (options.provider === 'openai' && process.env.OPENAI_API_KEY) {
-        apiKey = process.env.OPENAI_API_KEY;
-      } else {
-        const keyPrompt = await inquirer.prompt([
-          {
-            type: 'password',
-            name: 'apiKey',
-            message: `Enter your ${options.provider} API key:`,
-            mask: '*'
-          }
-        ]);
-        apiKey = keyPrompt.apiKey;
-      }
-    }
-
-    // Create config
-    const config: Config = {
-      aiProvider: options.provider,
-      apiKey,
-      maxFileSize: parseInt(options.maxSize) * 1024 * 1024, // Convert MB to bytes
-      supportedExtensions: ['.pdf', '.docx', '.doc', '.xlsx', '.xls', '.txt'],
-      dryRun: options.dryRun,
-      namingConvention: options.case,
-      templateOptions: {
-        category: options.template as FileCategory,
-        personalName: options.name,
-        dateFormat: options.date as DateFormat
-      },
-      // Local LLM specific configuration
-      localLLMConfig: {
-        baseUrl: options.baseUrl,
-        model: options.model
-      }
-    };
-
-    // Initialize services
-    const parserFactory = new DocumentParserFactory(config);
-    const aiService = AIServiceFactory.create(config.aiProvider, apiKey, config.localLLMConfig);
-    const fileRenamer = new FileRenamer(parserFactory, aiService, config);
-
-    // Get files to process
-    const files = await getFilesToProcess(directory, config.supportedExtensions);
-    
-    if (files.length === 0) {
-      console.log('No supported files found in the directory.');
-      return;
-    }
-
-    console.log(`Found ${files.length} files to process:`);
-    files.forEach(file => console.log(`  - ${file.name}`));
-
-    // Confirm before processing
-    if (!config.dryRun) {
-      const confirm = await inquirer.prompt([
-        {
-          type: 'confirm',
-          name: 'proceed',
-          message: 'Do you want to proceed with renaming these files?',
-          default: false
-        }
-      ]);
-
-      if (!confirm.proceed) {
-        console.log('Operation cancelled.');
-        return;
-      }
-    }
-
-    // Process files
-    console.log('\nProcessing files...');
-    const results = await fileRenamer.renameFiles(files);
-
-    // Display results
-    displayResults(results, config.dryRun);
-
-  } catch (error) {
-    console.error('Error:', error instanceof Error ? error.message : 'Unknown error');
-    process.exit(1);
-  }
-}
-
-async function getFilesToProcess(directory: string, supportedExtensions: string[]): Promise<FileInfo[]> {
-  const files: FileInfo[] = [];
-  const entries = await fs.readdir(directory, { withFileTypes: true });
-
-  for (const entry of entries) {
-    if (entry.isFile()) {
-      const filePath = path.join(directory, entry.name);
-      const extension = path.extname(entry.name).toLowerCase();
-      
-      if (supportedExtensions.includes(extension)) {
-        const stats = await fs.stat(filePath);
-        
-        // Extract folder context
-        const parentFolder = path.basename(directory);
-        const fullPath = path.resolve(filePath);
-        const folderPath = path.dirname(fullPath).split(path.sep).filter(p => p);
-        
-        files.push({
-          path: filePath,
-          name: entry.name,
-          extension,
-          size: stats.size,
-          // File system metadata
-          createdAt: stats.birthtime,
-          modifiedAt: stats.mtime,
-          accessedAt: stats.atime,
-          // Context metadata
-          parentFolder,
-          folderPath: folderPath.slice(-3), // Last 3 folder levels for context
-          // Document metadata will be populated by parsers
-          documentMetadata: undefined
-        });
-      }
-    }
-  }
-
-  return files;
-}
-
-function displayResults(results: RenameResult[], dryRun: boolean): void {
-  const successful = results.filter(r => r.success);
-  const failed = results.filter(r => !r.success);
-
-  console.log(`\n${dryRun ? 'Preview' : 'Results'}:`);
-  console.log(`✅ ${successful.length} files ${dryRun ? 'would be' : 'successfully'} renamed`);
-  
-  if (failed.length > 0) {
-    console.log(`❌ ${failed.length} files failed`);
-  }
-
-  console.log('\nDetails:');
-  results.forEach(result => {
-    const status = result.success ? '✅' : '❌';
-    const originalName = path.basename(result.originalPath);
-    const newName = path.basename(result.newPath);
-    
-    if (result.success) {
-      console.log(`${status} ${originalName} → ${newName}`);
-    } else {
-      console.log(`${status} ${originalName} (failed)`);
-      if (result.error) {
-        console.log(`   Error: ${result.error}`);
-      }
-    }
-  });
-}

package/src/index.ts

@@ -1,54 +0,0 @@
-#!/usr/bin/env node
-
-import { program } from 'commander';
-import { setupCommands } from './cli/commands.js';
-
-async function main() {
-  program
-    .name('namewise')
-    .description('🤖 AI-powered CLI tool that intelligently renames files based on their content using Claude or OpenAI')
-    .version('0.3.1')
-    .addHelpText('after', `
-
-📋 Supported File Types:
-  PDF, DOCX/DOC, XLSX/XLS, TXT, MD, RTF
-
-🎯 File Templates:
-  • general    - Simple descriptive names (default)
-  • document   - Personal docs with name/date: contract-john-20241205.pdf
-  • movie      - Movies with year: the-matrix-1999.mkv
-  • series     - TV shows: breaking-bad-s01e01.mkv
-  • music      - Music with artist: the-beatles-hey-jude.mp3
-  • photo      - Photos with context: vacation-paris-john-20241205.jpg
-  • book       - Books with author: george-orwell-1984.pdf
-  • auto       - AI auto-detects best template
-
-🔧 Naming Conventions:
-  kebab-case, snake_case, camelCase, PascalCase, lowercase, UPPERCASE
-
-💡 Quick Examples:
-  # Basic usage (dry run first - recommended!)
-  namewise rename ./documents --dry-run
-
-  # With Claude AI and specific template
-  namewise rename ./documents --provider claude --template document --name "john"
-
-  # Movies with auto-detection
-  namewise rename ./movies --template auto --case kebab-case
-
-  # OpenAI with custom settings
-  namewise rename ./files --provider openai --api-key your-key --max-size 20
-
-🔑 API Keys:
-  Set environment variables: CLAUDE_API_KEY or OPENAI_API_KEY
-  Or provide via --api-key flag
-
-📖 More info: https://github.com/amirdaraee/namewise#readme
-`);
-
-  setupCommands(program);
-  
-  await program.parseAsync(process.argv);
-}
-
-main().catch(console.error);

package/src/parsers/excel-parser.ts

@@ -1,66 +0,0 @@
-import path from 'path';
-import Excel from 'exceljs';
-import { DocumentParser, ParseResult, DocumentMetadata } from '../types/index.js';
-
-export class ExcelParser implements DocumentParser {
-  supports(filePath: string): boolean {
-    const ext = path.extname(filePath).toLowerCase();
-    return ext === '.xlsx' || ext === '.xls';
-  }
-
-  async parse(filePath: string): Promise<ParseResult> {
-    try {
-      const workbook = new Excel.Workbook();
-      await workbook.xlsx.readFile(filePath);
-      
-      const sheets: string[] = [];
-      const metadata: DocumentMetadata = {};
-
-      // Extract content from each worksheet
-      workbook.eachSheet((worksheet) => {
-        const sheetName = worksheet.name;
-        const rows: string[] = [];
-        
-        worksheet.eachRow((row) => {
-          const rowData: string[] = [];
-          row.eachCell((cell) => {
-            // Get cell value as string
-            const cellValue = cell.value?.toString() || '';
-            if (cellValue) {
-              rowData.push(cellValue);
-            }
-          });
-          if (rowData.length > 0) {
-            rows.push(rowData.join(','));
-          }
-        });
-        
-        if (rows.length > 0) {
-          sheets.push(`Sheet: ${sheetName}\n${rows.join('\n')}`);
-        }
-      });
-
-      const content = sheets.join('\n\n').trim();
-      
-      // Extract metadata from workbook properties
-      if (workbook.properties) {
-        const props = workbook.properties as any; // ExcelJS properties typing may vary
-        metadata.title = props.title || props.core?.title;
-        metadata.author = props.creator || props.core?.creator;
-        metadata.subject = props.subject || props.core?.subject;
-        metadata.keywords = props.keywords ? [props.keywords] : undefined;
-        metadata.creationDate = props.created || props.core?.created;
-        metadata.modificationDate = props.modified || props.core?.modified;
-      }
-      
-      // Estimate word count from content
-      if (content) {
-        metadata.wordCount = content.split(/\s+/).filter(word => word.length > 0).length;
-      }
-
-      return { content, metadata };
-    } catch (error) {
-      throw new Error(`Failed to parse Excel file: ${error instanceof Error ? error.message : 'Unknown error'}`);
-    }
-  }
-}

package/src/parsers/factory.ts

@@ -1,38 +0,0 @@
-import { DocumentParser, Config } from '../types/index.js';
-import { PDFParser } from './pdf-parser.js';
-import { WordParser } from './word-parser.js';
-import { ExcelParser } from './excel-parser.js';
-import { TextParser } from './text-parser.js';
-
-export class DocumentParserFactory {
-  private parsers: DocumentParser[];
-  
-  constructor(config?: Config) {
-    this.parsers = [
-      new PDFParser(),
-      new WordParser(),
-      new ExcelParser(),
-      new TextParser()
-    ];
-  }
-
-  getParser(filePath: string): DocumentParser | null {
-    return this.parsers.find(parser => parser.supports(filePath)) || null;
-  }
-
-  getSupportedExtensions(): string[] {
-    const extensions = new Set<string>();
-    
-    // Add known extensions based on parser implementations
-    extensions.add('.pdf');
-    extensions.add('.docx');
-    extensions.add('.doc');
-    extensions.add('.xlsx');
-    extensions.add('.xls');
-    extensions.add('.txt');
-    extensions.add('.md');
-    extensions.add('.rtf');
-    
-    return Array.from(extensions);
-  }
-}

package/src/parsers/pdf-parser.ts

@@ -1,99 +0,0 @@
-import fs from 'fs';
-import path from 'path';
-import { DocumentParser, ParseResult, DocumentMetadata } from '../types/index.js';
-import { PDFToImageConverter } from '../utils/pdf-to-image.js';
-
-export class PDFParser implements DocumentParser {
-  constructor() {
-    // No constructor parameters needed anymore
-  }
-
-  supports(filePath: string): boolean {
-    return path.extname(filePath).toLowerCase() === '.pdf';
-  }
-
-  async parse(filePath: string): Promise<ParseResult> {
-    try {
-      // Dynamic import for pdf-extraction (default export)
-      const pdfExtraction = await import('pdf-extraction');
-      const extract = pdfExtraction.default;
-      
-      const dataBuffer = fs.readFileSync(filePath);
-      const data = await extract(dataBuffer, {});
-      
-      let content = data.text?.trim() || '';
-      
-      // Check if this is a scanned PDF and convert to image for AI analysis
-      if (PDFToImageConverter.isScannedPDF(content)) {
-        try {
-          console.log('🔍 Detected scanned PDF, converting to image for AI analysis...');
-          const imageBase64 = await PDFToImageConverter.convertFirstPageToBase64(dataBuffer);
-          
-          // Store the image data as a special marker for the AI service to detect
-          content = `[SCANNED_PDF_IMAGE]:${imageBase64}`;
-          console.log('✅ PDF converted to image successfully');
-        } catch (conversionError) {
-          console.warn('⚠️ PDF to image conversion failed:', conversionError instanceof Error ? conversionError.message : 'Unknown error');
-          console.log('💡 PDF-poppler requires system dependencies. Falling back to empty content.');
-          // Continue with empty content - AI services will handle this gracefully
-        }
-      }
-      
-      // Extract PDF metadata if available
-      const metadata: DocumentMetadata = {};
-      
-      // Cast data to any to access potentially existing metadata properties
-      const pdfData = data as any;
-      
-      if (pdfData.meta) {
-        if (pdfData.meta.info) {
-          metadata.title = pdfData.meta.info.Title;
-          metadata.author = pdfData.meta.info.Author;
-          metadata.creator = pdfData.meta.info.Creator;
-          metadata.subject = pdfData.meta.info.Subject;
-          
-          // Parse dates if available
-          if (pdfData.meta.info.CreationDate) {
-            metadata.creationDate = this.parseDate(pdfData.meta.info.CreationDate);
-          }
-          if (pdfData.meta.info.ModDate) {
-            metadata.modificationDate = this.parseDate(pdfData.meta.info.ModDate);
-          }
-        }
-        
-        if (pdfData.numpages) {
-          metadata.pages = pdfData.numpages;
-        }
-      }
-      
-      // Estimate word count from text content
-      if (content) {
-        metadata.wordCount = content.split(/\s+/).filter(word => word.length > 0).length;
-      }
-      
-      return { content, metadata };
-    } catch (error) {
-      throw new Error(`Failed to parse PDF file: ${error instanceof Error ? error.message : 'Unknown error'}`);
-    }
-  }
-
-  private parseDate(dateStr: string): Date | undefined {
-    try {
-      // PDF dates are in format: D:YYYYMMDDHHmmSSOHH'mm or D:YYYYMMDDHHMMSS
-      if (dateStr.startsWith('D:')) {
-        const datepart = dateStr.slice(2, 16); // YYYYMMDDHHMMSS
-        const year = parseInt(datepart.slice(0, 4));
-        const month = parseInt(datepart.slice(4, 6)) - 1; // Month is 0-based
-        const day = parseInt(datepart.slice(6, 8));
-        const hour = parseInt(datepart.slice(8, 10) || '0');
-        const minute = parseInt(datepart.slice(10, 12) || '0');
-        const second = parseInt(datepart.slice(12, 14) || '0');
-        
-        return new Date(year, month, day, hour, minute, second);
-      }
-      return new Date(dateStr);
-    } catch {
-      return undefined;
-    }
-  }
-}

package/src/parsers/text-parser.ts

@@ -1,43 +0,0 @@
-import fs from 'fs';
-import path from 'path';
-import { DocumentParser, ParseResult, DocumentMetadata } from '../types/index.js';
-
-export class TextParser implements DocumentParser {
-  supports(filePath: string): boolean {
-    const ext = path.extname(filePath).toLowerCase();
-    return ext === '.txt' || ext === '.md' || ext === '.rtf';
-  }
-
-  async parse(filePath: string): Promise<ParseResult> {
-    try {
-      const content = fs.readFileSync(filePath, 'utf-8').trim();
-      const metadata: DocumentMetadata = {};
-      
-      // Extract basic metadata from content
-      const lines = content.split('\n').filter(line => line.trim());
-      
-      if (lines.length > 0) {
-        // For markdown files, look for title in first heading
-        if (path.extname(filePath).toLowerCase() === '.md') {
-          const firstLine = lines[0];
-          if (firstLine.startsWith('# ')) {
-            metadata.title = firstLine.substring(2).trim();
-          }
-        } else {
-          // For other text files, use first non-empty line as potential title
-          const firstNonEmptyLine = lines[0];
-          if (firstNonEmptyLine.length < 100 && !firstNonEmptyLine.endsWith('.')) {
-            metadata.title = firstNonEmptyLine.trim();
-          }
-        }
-        
-        // Word count
-        metadata.wordCount = content.split(/\s+/).filter(word => word.length > 0).length;
-      }
-
-      return { content, metadata };
-    } catch (error) {
-      throw new Error(`Failed to parse text file: ${error instanceof Error ? error.message : 'Unknown error'}`);
-    }
-  }
-}

package/src/parsers/word-parser.ts

@@ -1,50 +0,0 @@
-import fs from 'fs';
-import path from 'path';
-import mammoth from 'mammoth';
-import { DocumentParser, ParseResult, DocumentMetadata } from '../types/index.js';
-
-export class WordParser implements DocumentParser {
-  supports(filePath: string): boolean {
-    const ext = path.extname(filePath).toLowerCase();
-    return ext === '.docx' || ext === '.doc';
-  }
-
-  async parse(filePath: string): Promise<ParseResult> {
-    try {
-      const buffer = fs.readFileSync(filePath);
-      
-      // Extract text content
-      const textResult = await mammoth.extractRawText({ buffer });
-      const content = textResult.value.trim();
-      
-      // Extract metadata
-      const metadata: DocumentMetadata = {};
-      
-      // Estimate word count
-      if (content) {
-        metadata.wordCount = content.split(/\s+/).filter(word => word.length > 0).length;
-      }
-      
-      // Try to extract document properties for .docx files
-      if (path.extname(filePath).toLowerCase() === '.docx') {
-        try {
-          // For DOCX files, we could parse document.xml for metadata
-          // For now, we'll use basic analysis of the content
-          const lines = content.split('\n');
-          const firstNonEmptyLine = lines.find(line => line.trim().length > 0);
-          
-          // If the first line looks like a title (short and not a sentence)
-          if (firstNonEmptyLine && firstNonEmptyLine.length < 100 && !firstNonEmptyLine.endsWith('.')) {
-            metadata.title = firstNonEmptyLine.trim();
-          }
-        } catch {
-          // Ignore metadata extraction errors
-        }
-      }
-      
-      return { content, metadata };
-    } catch (error) {
-      throw new Error(`Failed to parse Word document: ${error instanceof Error ? error.message : 'Unknown error'}`);
-    }
-  }
-}

package/src/services/ai-factory.ts

@@ -1,39 +0,0 @@
-import { AIProvider } from '../types/index.js';
-import { ClaudeService } from './claude-service.js';
-import { OpenAIService } from './openai-service.js';
-import { OllamaService } from './ollama-service.js';
-import { LMStudioService } from './lmstudio-service.js';
-
-interface LocalLLMConfig {
-  baseUrl?: string;
-  model?: string;
-}
-
-export class AIServiceFactory {
-  static create(
-    provider: 'claude' | 'openai' | 'ollama' | 'lmstudio', 
-    apiKey?: string,
-    localLLMConfig?: LocalLLMConfig
-  ): AIProvider {
-    switch (provider) {
-      case 'claude':
-        if (!apiKey) throw new Error('API key is required for Claude provider');
-        return new ClaudeService(apiKey);
-      case 'openai':
-        if (!apiKey) throw new Error('API key is required for OpenAI provider');
-        return new OpenAIService(apiKey);
-      case 'ollama':
-        return new OllamaService(
-          localLLMConfig?.baseUrl || 'http://localhost:11434',
-          localLLMConfig?.model || 'llama3.1'
-        );
-      case 'lmstudio':
-        return new LMStudioService(
-          localLLMConfig?.baseUrl || 'http://localhost:1234',
-          localLLMConfig?.model || 'local-model'
-        );
-      default:
-        throw new Error(`Unsupported AI provider: ${provider}`);
-    }
-  }
-}

package/src/services/claude-service.ts

@@ -1,119 +0,0 @@
-import Anthropic from '@anthropic-ai/sdk';
-import { AIProvider, FileInfo } from '../types/index.js';
-import { applyNamingConvention, NamingConvention } from '../utils/naming-conventions.js';
-import { FileCategory } from '../utils/file-templates.js';
-import { buildFileNamePrompt } from '../utils/ai-prompts.js';
-
-export class ClaudeService implements AIProvider {
-  name = 'Claude';
-  private client: Anthropic;
-
-  constructor(apiKey: string) {
-    this.client = new Anthropic({
-      apiKey: apiKey
-    });
-  }
-
-  async generateFileName(content: string, originalName: string, namingConvention: string = 'kebab-case', category: string = 'general', fileInfo?: FileInfo): Promise<string> {
-    const convention = namingConvention as NamingConvention;
-    const fileCategory = category as FileCategory;
-    
-    // Check if this is a scanned PDF image
-    const isScannedPDF = content.startsWith('[SCANNED_PDF_IMAGE]:');
-    
-    try {
-      let response;
-      
-      if (isScannedPDF) {
-        // Extract base64 image data
-        const imageBase64 = content.replace('[SCANNED_PDF_IMAGE]:', '');
-        
-        const prompt = buildFileNamePrompt({
-          content: 'This is a scanned PDF document converted to an image. Please analyze the image and extract the main content to generate an appropriate filename.',
-          originalName,
-          namingConvention: convention,
-          category: fileCategory,
-          fileInfo
-        });
-
-        response = await this.client.messages.create({
-          model: 'claude-sonnet-4-5-20250929', // Use Claude Sonnet 4.5 for vision capabilities
-          max_tokens: 100,
-          messages: [
-            {
-              role: 'user',
-              content: [
-                {
-                  type: 'text',
-                  text: prompt
-                },
-                {
-                  type: 'image',
-                  source: {
-                    type: 'base64',
-                    media_type: imageBase64.startsWith('data:image/png') ? 'image/png' : 'image/jpeg',
-                    data: imageBase64.split(',')[1] // Remove data:image/format;base64, prefix
-                  }
-                }
-              ]
-            }
-          ]
-        });
-      } else {
-        // Standard text processing
-        const prompt = buildFileNamePrompt({
-          content,
-          originalName,
-          namingConvention: convention,
-          category: fileCategory,
-          fileInfo
-        });
-
-        response = await this.client.messages.create({
-          model: 'claude-3-haiku-20240307',
-          max_tokens: 100,
-          messages: [
-            {
-              role: 'user',
-              content: prompt
-            }
-          ]
-        });
-      }
-
-      const suggestedName = response.content[0].type === 'text' 
-        ? response.content[0].text.trim()
-        : 'untitled-document';
-
-      // Apply naming convention and clean the suggested name
-      return this.sanitizeFileName(suggestedName, convention);
-    } catch (error) {
-      console.error('Claude API error:', error);
-      throw new Error(`Failed to generate filename with Claude: ${error instanceof Error ? error.message : 'Unknown error'}`);
-    }
-  }
-
-  private sanitizeFileName(name: string, convention: NamingConvention): string {
-    // Remove any potential file extensions from the suggestion
-    const nameWithoutExt = name.replace(/\.[^/.]+$/, '');
-    
-    // Apply the naming convention
-    let cleaned = applyNamingConvention(nameWithoutExt, convention);
-
-    // Ensure it's not empty and not too long
-    if (!cleaned) {
-      cleaned = applyNamingConvention('untitled document', convention);
-    } else if (cleaned.length > 100) {
-      // Truncate while preserving naming convention structure
-      cleaned = cleaned.substring(0, 100);
-      // Clean up any broken separators at the end
-      if (convention === 'kebab-case') {
-        cleaned = cleaned.replace(/-[^-]*$/, '');
-      } else if (convention === 'snake_case') {
-        cleaned = cleaned.replace(/_[^_]*$/, '');
-      }
-    }
-
-    return cleaned;
-  }
-}