@amirdaraee/namewise 0.5.3 → 0.5.5

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;
-  }
-}

package/src/services/file-renamer.ts

@@ -1,141 +0,0 @@
-import { promises as fs } from 'fs';
-import path from 'path';
-import { FileInfo, Config, RenameResult, AIProvider } from '../types/index.js';
-import { DocumentParserFactory } from '../parsers/factory.js';
-import { categorizeFile, applyTemplate } from '../utils/file-templates.js';
-
-export class FileRenamer {
-  constructor(
-    private parserFactory: DocumentParserFactory,
-    private aiService: AIProvider,
-    private config: Config
-  ) {}
-
-  async renameFiles(files: FileInfo[]): Promise<RenameResult[]> {
-    const results: RenameResult[] = [];
-    let lastProgressLength = 0;
-
-    for (let i = 0; i < files.length; i++) {
-      const file = files[i];
-      
-      // Create progress message with better formatting
-      const progressBar = `[${i + 1}/${files.length}]`;
-      const truncatedName = file.name.length > 50 ? file.name.substring(0, 47) + '...' : file.name;
-      const progressMessage = `🔄 Processing ${progressBar} ${truncatedName}`;
-      
-      // Clear the previous line completely by using the actual length
-      const clearLine = '\r' + ' '.repeat(Math.max(lastProgressLength, progressMessage.length)) + '\r';
-      process.stdout.write(clearLine + progressMessage);
-      
-      // Store the length for next iteration
-      lastProgressLength = progressMessage.length;
-      
-      try {
-        const result = await this.renameFile(file);
-        results.push(result);
-      } catch (error) {
-        results.push({
-          originalPath: file.path,
-          newPath: file.path,
-          suggestedName: file.name,
-          success: false,
-          error: error instanceof Error ? error.message : 'Unknown error'
-        });
-      }
-    }
-
-    // Clear the final processing line completely and show completion
-    const clearFinal = '\r' + ' '.repeat(lastProgressLength) + '\r';
-    if (files.length > 0) {
-      const successCount = results.filter(r => r.success).length;
-      const completionMessage = `✅ Processed ${files.length} file${files.length === 1 ? '' : 's'} (${successCount} successful)`;
-      process.stdout.write(clearFinal + completionMessage + '\n');
-    } else {
-      process.stdout.write(clearFinal);
-    }
-
-    return results;
-  }
-
-  private async renameFile(file: FileInfo): Promise<RenameResult> {
-    // Check file size
-    if (file.size > this.config.maxFileSize) {
-      throw new Error(`File size (${Math.round(file.size / 1024 / 1024)}MB) exceeds maximum allowed size (${Math.round(this.config.maxFileSize / 1024 / 1024)}MB)`);
-    }
-
-    // Get appropriate parser
-    const parser = this.parserFactory.getParser(file.path);
-    if (!parser) {
-      throw new Error(`No parser available for file type: ${file.extension}`);
-    }
-
-    // Extract content and metadata
-    const parseResult = await parser.parse(file.path);
-    const content = parseResult.content;
-    if (!content || content.trim().length === 0) {
-      throw new Error('No content could be extracted from the file');
-    }
-    
-    // Update file info with extracted document metadata
-    file.documentMetadata = parseResult.metadata;
-
-    // Determine file category (use configured category or auto-categorize)
-    const fileCategory = this.config.templateOptions.category === 'auto' 
-      ? categorizeFile(file.path, content, file)
-      : this.config.templateOptions.category;
-
-    // Generate core filename using AI with all available metadata
-    const coreFileName = await this.aiService.generateFileName(
-      content, 
-      file.name, 
-      this.config.namingConvention, 
-      fileCategory,
-      file // Pass the entire file info with all metadata
-    );
-    if (!coreFileName || coreFileName.trim().length === 0) {
-      throw new Error('AI service failed to generate a filename');
-    }
-
-    // Apply template to include personal info, dates, etc.
-    const templatedName = applyTemplate(
-      coreFileName,
-      fileCategory,
-      this.config.templateOptions,
-      this.config.namingConvention
-    );
-
-    // Create new filename with original extension
-    const newFileName = `${templatedName}${file.extension}`;
-    const newPath = path.join(path.dirname(file.path), newFileName);
-
-    // Check if new filename would conflict with existing file
-    if (newPath !== file.path) {
-      await this.checkForConflicts(newPath);
-    }
-
-    // Perform the rename (or simulate if dry run)
-    if (!this.config.dryRun && newPath !== file.path) {
-      await fs.rename(file.path, newPath);
-    }
-
-    return {
-      originalPath: file.path,
-      newPath,
-      suggestedName: newFileName,
-      success: true
-    };
-  }
-
-  private async checkForConflicts(newPath: string): Promise<void> {
-    try {
-      await fs.access(newPath);
-      // If we reach here, the file exists
-      throw new Error(`Target filename already exists: ${path.basename(newPath)}`);
-    } catch (error) {
-      // If the error is ENOENT (file doesn't exist), that's what we want
-      if ((error as NodeJS.ErrnoException).code !== 'ENOENT') {
-        throw error;
-      }
-    }
-  }
-}