@amirdaraee/namewise 0.5.2 → 0.5.4

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

package/src/services/lmstudio-service.ts

@@ -1,161 +0,0 @@
-import { AIProvider, FileInfo } from '../types/index.js';
-import { buildFileNamePrompt, AI_SYSTEM_PROMPT } from '../utils/ai-prompts.js';
-import { NamingConvention } from '../utils/naming-conventions.js';
-import { FileCategory } from '../utils/file-templates.js';
-
-interface OpenAICompatibleResponse {
-  choices: Array<{
-    message: {
-      content: string;
-      role: string;
-    };
-    finish_reason: string;
-  }>;
-  usage?: {
-    prompt_tokens: number;
-    completion_tokens: number;
-    total_tokens: number;
-  };
-}
-
-interface OpenAIMessage {
-  role: 'system' | 'user' | 'assistant';
-  content: string;
-}
-
-interface ModelInfo {
-  id: string;
-  object: string;
-  created: number;
-  owned_by: string;
-}
-
-export class LMStudioService implements AIProvider {
-  name = 'LMStudio';
-  private baseUrl: string;
-  private model: string;
-
-  constructor(
-    baseUrl = 'http://localhost:1234',
-    model = 'local-model'
-  ) {
-    this.baseUrl = baseUrl;
-    this.model = model;
-  }
-
-  async generateFileName(
-    content: string, 
-    originalName: string, 
-    namingConvention = 'kebab-case', 
-    category = 'general',
-    fileInfo?: FileInfo
-  ): Promise<string> {
-    try {
-      // Check if this is a scanned PDF image
-      const isScannedPDF = content.startsWith('[SCANNED_PDF_IMAGE]:');
-      
-      if (isScannedPDF) {
-        // LM Studio has limited vision support, so we'll fall back to using the original filename
-        console.log('⚠️ Scanned PDF detected but LMStudio has limited vision support. Using original filename.');
-        return this.sanitizeFilename(originalName);
-      }
-      
-      const prompt = this.buildPrompt(content, originalName, namingConvention, category, fileInfo);
-      
-      const response = await this.makeRequest('/v1/chat/completions', {
-        model: this.model,
-        messages: [
-          {
-            role: 'system',
-            content: AI_SYSTEM_PROMPT
-          },
-          {
-            role: 'user',
-            content: prompt
-          }
-        ] as OpenAIMessage[],
-        temperature: 0.3,
-        max_tokens: 100,
-        stream: false
-      });
-
-      if (response.choices?.[0]?.message?.content) {
-        return this.sanitizeFilename(response.choices[0].message.content);
-      } else {
-        throw new Error('No response content from LMStudio');
-      }
-    } catch (error) {
-      console.error('LMStudio API error:', error);
-      throw new Error(`LMStudio service failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
-    }
-  }
-
-  private buildPrompt(
-    content: string, 
-    originalName: string, 
-    namingConvention: string, 
-    category: string,
-    fileInfo?: FileInfo
-  ): string {
-    return buildFileNamePrompt({
-      content,
-      originalName,
-      namingConvention: namingConvention as NamingConvention,
-      category: category as FileCategory,
-      fileInfo
-    });
-  }
-
-  private sanitizeFilename(filename: string): string {
-    return filename
-      .trim()
-      .replace(/^["']|["']$/g, '') // Remove quotes
-      .replace(/\.(txt|pdf|docx?|xlsx?|md|rtf)$/i, '') // Remove extensions
-      .replace(/[<>:"/\\|?*]/g, '-') // Replace invalid characters
-      .replace(/\s+/g, '-') // Replace spaces with hyphens
-      .toLowerCase();
-  }
-
-  private async makeRequest(endpoint: string, payload: any): Promise<OpenAICompatibleResponse> {
-    const url = `${this.baseUrl}${endpoint}`;
-    
-    const response = await fetch(url, {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-      },
-      body: JSON.stringify(payload),
-    });
-
-    if (!response.ok) {
-      const errorText = await response.text();
-      throw new Error(`LMStudio API request failed: ${response.status} ${response.statusText} - ${errorText}`);
-    }
-
-    const data = await response.json();
-    return data as OpenAICompatibleResponse;
-  }
-
-  // Method to check if LMStudio service is available
-  async isAvailable(): Promise<boolean> {
-    try {
-      const response = await fetch(`${this.baseUrl}/v1/models`);
-      return response.ok;
-    } catch {
-      return false;
-    }
-  }
-
-  // Method to list available models
-  async listModels(): Promise<string[]> {
-    try {
-      const response = await fetch(`${this.baseUrl}/v1/models`);
-      if (!response.ok) return [];
-      
-      const data = await response.json();
-      return data.data?.map((model: ModelInfo) => model.id) || [];
-    } catch {
-      return [];
-    }
-  }
-}

package/src/services/ollama-service.ts

@@ -1,191 +0,0 @@
-import { AIProvider, FileInfo } from '../types/index.js';
-import { buildFileNamePrompt, AI_SYSTEM_PROMPT } from '../utils/ai-prompts.js';
-import { NamingConvention } from '../utils/naming-conventions.js';
-import { FileCategory } from '../utils/file-templates.js';
-
-interface OllamaResponse {
-  model: string;
-  response?: string; // For /api/generate
-  message?: {        // For /api/chat
-    content: string;
-    role: string;
-  };
-  done: boolean;
-}
-
-interface OllamaChatMessage {
-  role: 'system' | 'user' | 'assistant';
-  content: string;
-  images?: string[]; // For vision models
-}
-
-export class OllamaService implements AIProvider {
-  name = 'Ollama';
-  private baseUrl: string;
-  private model: string;
-
-  constructor(
-    baseUrl = 'http://localhost:11434',
-    model = 'llama3.1'
-  ) {
-    this.baseUrl = baseUrl;
-    this.model = model;
-  }
-
-  async generateFileName(
-    content: string, 
-    originalName: string, 
-    namingConvention = 'kebab-case', 
-    category = 'general',
-    fileInfo?: FileInfo
-  ): Promise<string> {
-    try {
-      // Check if this is a scanned PDF image
-      const isScannedPDF = content.startsWith('[SCANNED_PDF_IMAGE]:');
-      
-      let response;
-      
-      if (isScannedPDF) {
-        // Extract base64 image data and use a vision model
-        const imageBase64 = content.replace('[SCANNED_PDF_IMAGE]:', '');
-        const imageData = imageBase64.split(',')[1]; // Remove data:image/format;base64, prefix
-        
-        const prompt = this.buildPrompt(
-          '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, 
-          category, 
-          fileInfo
-        );
-        
-        // Use LLaVA model for vision capabilities
-        const visionModel = this.getVisionModel();
-        
-        response = await this.makeRequest('/api/chat', {
-          model: visionModel,
-          messages: [
-            {
-              role: 'system',
-              content: AI_SYSTEM_PROMPT
-            },
-            {
-              role: 'user',
-              content: prompt,
-              images: [imageData]
-            }
-          ] as OllamaChatMessage[],
-          stream: false
-        });
-      } else {
-        // Standard text processing
-        const prompt = this.buildPrompt(content, originalName, namingConvention, category, fileInfo);
-        
-        response = await this.makeRequest('/api/chat', {
-          model: this.model,
-          messages: [
-            {
-              role: 'system',
-              content: AI_SYSTEM_PROMPT
-            },
-            {
-              role: 'user',
-              content: prompt
-            }
-          ] as OllamaChatMessage[],
-          stream: false
-        });
-      }
-
-      if (response.message?.content) {
-        return this.sanitizeFilename(response.message.content);
-      } else {
-        throw new Error('No response content from Ollama');
-      }
-    } catch (error) {
-      console.error('Ollama API error:', error);
-      throw new Error(`Ollama service failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
-    }
-  }
-
-  private buildPrompt(
-    content: string, 
-    originalName: string, 
-    namingConvention: string, 
-    category: string,
-    fileInfo?: FileInfo
-  ): string {
-    return buildFileNamePrompt({
-      content,
-      originalName,
-      namingConvention: namingConvention as NamingConvention,
-      category: category as FileCategory,
-      fileInfo
-    });
-  }
-
-  private getVisionModel(): string {
-    // Try to use a vision-capable model, fallback to default if not specified
-    const visionModels = ['llava', 'llava:7b', 'llava:13b', 'llava:34b', 'llama3.2-vision', 'qwen2-vl'];
-    
-    // If the current model is already a vision model, use it
-    if (visionModels.some(vm => this.model.toLowerCase().includes(vm.split(':')[0]))) {
-      return this.model;
-    }
-    
-    // Otherwise, default to llava (most common vision model in Ollama)
-    return 'llava';
-  }
-
-  private sanitizeFilename(filename: string): string {
-    return filename
-      .trim()
-      .replace(/^["']|["']$/g, '') // Remove quotes
-      .replace(/\.(txt|pdf|docx?|xlsx?|md|rtf)$/i, '') // Remove extensions
-      .replace(/[<>:"/\\|?*]/g, '-') // Replace invalid characters
-      .replace(/\s+/g, '-') // Replace spaces with hyphens
-      .toLowerCase();
-  }
-
-  private async makeRequest(endpoint: string, payload: any): Promise<OllamaResponse> {
-    const url = `${this.baseUrl}${endpoint}`;
-    
-    const response = await fetch(url, {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-      },
-      body: JSON.stringify(payload),
-    });
-
-    if (!response.ok) {
-      const errorText = await response.text();
-      throw new Error(`Ollama API request failed: ${response.status} ${response.statusText} - ${errorText}`);
-    }
-
-    const data = await response.json();
-    return data as OllamaResponse;
-  }
-
-  // Method to check if Ollama service is available
-  async isAvailable(): Promise<boolean> {
-    try {
-      const response = await fetch(`${this.baseUrl}/api/tags`);
-      return response.ok;
-    } catch {
-      return false;
-    }
-  }
-
-  // Method to list available models
-  async listModels(): Promise<string[]> {
-    try {
-      const response = await fetch(`${this.baseUrl}/api/tags`);
-      if (!response.ok) return [];
-      
-      const data = await response.json();
-      return data.models?.map((model: any) => model.name) || [];
-    } catch {
-      return [];
-    }
-  }
-}

package/src/services/openai-service.ts

@@ -1,117 +0,0 @@
-import OpenAI from 'openai';
-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 OpenAIService implements AIProvider {
-  name = 'OpenAI';
-  private client: OpenAI;
-
-  constructor(apiKey: string) {
-    this.client = new OpenAI({
-      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.chat.completions.create({
-          model: 'gpt-4o', // Use GPT-4 with vision capabilities
-          messages: [
-            {
-              role: 'user',
-              content: [
-                {
-                  type: 'text',
-                  text: prompt
-                },
-                {
-                  type: 'image_url',
-                  image_url: {
-                    url: imageBase64
-                  }
-                }
-              ]
-            }
-          ],
-          max_tokens: 100,
-          temperature: 0.3
-        });
-      } else {
-        // Standard text processing
-        const prompt = buildFileNamePrompt({
-          content,
-          originalName,
-          namingConvention: convention,
-          category: fileCategory,
-          fileInfo
-        });
-
-        response = await this.client.chat.completions.create({
-          model: 'gpt-3.5-turbo',
-          messages: [
-            {
-              role: 'user',
-              content: prompt
-            }
-          ],
-          max_tokens: 100,
-          temperature: 0.3
-        });
-      }
-
-      const suggestedName = response.choices[0]?.message?.content?.trim() || 'untitled-document';
-      
-      // Clean and validate the suggested name
-      return this.sanitizeFileName(suggestedName, convention);
-    } catch (error) {
-      console.error('OpenAI API error:', error);
-      throw new Error(`Failed to generate filename with OpenAI: ${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/types/index.ts

@@ -1,76 +0,0 @@
-export interface DocumentMetadata {
-  title?: string;
-  author?: string;
-  creator?: string;
-  subject?: string;
-  keywords?: string[];
-  creationDate?: Date;
-  modificationDate?: Date;
-  pages?: number;
-  wordCount?: number;
-}
-
-export interface FileInfo {
-  path: string;
-  name: string;
-  extension: string;
-  size: number;
-  content?: string;
-  // File system metadata
-  createdAt: Date;
-  modifiedAt: Date;
-  accessedAt: Date;
-  // Context metadata  
-  parentFolder: string;
-  folderPath: string[];
-  // Document metadata (extracted from file contents)
-  documentMetadata?: DocumentMetadata;
-}
-
-export interface RenameResult {
-  originalPath: string;
-  newPath: string;
-  suggestedName: string;
-  success: boolean;
-  error?: string;
-}
-
-export interface AIProvider {
-  name: string;
-  generateFileName: (content: string, originalName: string, namingConvention?: string, category?: string, fileInfo?: FileInfo) => Promise<string>;
-}
-
-export type NamingConvention = 'kebab-case' | 'snake_case' | 'camelCase' | 'PascalCase' | 'lowercase' | 'UPPERCASE';
-export type FileCategory = 'document' | 'movie' | 'music' | 'series' | 'photo' | 'book' | 'general' | 'auto';
-export type DateFormat = 'YYYY-MM-DD' | 'YYYY' | 'YYYYMMDD' | 'none';
-
-export interface TemplateOptions {
-  category: FileCategory;
-  personalName?: string;
-  dateFormat: DateFormat;
-}
-
-export interface Config {
-  aiProvider: 'claude' | 'openai' | 'ollama' | 'lmstudio';
-  apiKey?: string; // Optional for local providers
-  maxFileSize: number;
-  supportedExtensions: string[];
-  dryRun: boolean;
-  namingConvention: NamingConvention;
-  templateOptions: TemplateOptions;
-  // Local LLM specific options
-  localLLMConfig?: {
-    baseUrl?: string;
-    model?: string;
-  };
-}
-
-export interface ParseResult {
-  content: string;
-  metadata?: DocumentMetadata;
-}
-
-export interface DocumentParser {
-  supports: (filePath: string) => boolean;
-  parse: (filePath: string) => Promise<ParseResult>;
-}

package/src/types/pdf-extraction.d.ts

@@ -1,7 +0,0 @@
-declare module 'pdf-extraction' {
-  function extract(buffer: Buffer, options?: any): Promise<{
-    text?: string;
-    pages?: any[];
-  }>;
-  export = extract;
-}