@amirdaraee/namewise 0.5.3 → 0.5.5

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

package/src/utils/ai-prompts.ts

@@ -1,76 +0,0 @@
-import { FileInfo } from '../types/index.js';
-import { getNamingInstructions, NamingConvention } from './naming-conventions.js';
-import { getTemplateInstructions, FileCategory } from './file-templates.js';
-
-export interface PromptContext {
-  content: string;
-  originalName: string;
-  namingConvention: NamingConvention;
-  category: FileCategory;
-  fileInfo?: FileInfo;
-}
-
-/**
- * Builds a standardized prompt for AI filename generation
- * This prompt is used across all AI providers (Claude, OpenAI, LMStudio, Ollama)
- */
-export function buildFileNamePrompt(context: PromptContext): string {
-  const { content, originalName, namingConvention, category, fileInfo } = context;
-  
-  const namingInstructions = getNamingInstructions(namingConvention);
-  const templateInstructions = getTemplateInstructions(category);
-  
-  // Build comprehensive context from all metadata
-  let metadataContext = '';
-  if (fileInfo) {
-    metadataContext += `File Information:
-- Original filename: ${originalName}
-- File size: ${Math.round(fileInfo.size / 1024)}KB
-- Created: ${fileInfo.createdAt.toLocaleDateString()}
-- Modified: ${fileInfo.modifiedAt.toLocaleDateString()}
-- Parent folder: ${fileInfo.parentFolder}
-- Folder path: ${fileInfo.folderPath.join(' > ')}`;
-
-    if (fileInfo.documentMetadata) {
-      const meta = fileInfo.documentMetadata;
-      metadataContext += `
-Document Properties:`;
-      if (meta.title) metadataContext += `\n- Title: ${meta.title}`;
-      if (meta.author) metadataContext += `\n- Author: ${meta.author}`;
-      if (meta.creator) metadataContext += `\n- Creator: ${meta.creator}`;
-      if (meta.subject) metadataContext += `\n- Subject: ${meta.subject}`;
-      if (meta.keywords?.length) metadataContext += `\n- Keywords: ${meta.keywords.join(', ')}`;
-      if (meta.creationDate) metadataContext += `\n- Created: ${meta.creationDate.toLocaleDateString()}`;
-      if (meta.modificationDate) metadataContext += `\n- Modified: ${meta.modificationDate.toLocaleDateString()}`;
-      if (meta.pages) metadataContext += `\n- Pages: ${meta.pages}`;
-      if (meta.wordCount) metadataContext += `\n- Word count: ${meta.wordCount}`;
-    }
-  }
-
-  return `Based on the following document information, generate a descriptive filename that captures the main topic/purpose of the document. The filename should be:
-- Descriptive and meaningful
-- Professional and clean
-- Between 3-10 words
-- ${namingInstructions}
-- ${templateInstructions}
-- Do not include file extension
-- If the document is specifically for/about a person (based on content), include their name at the beginning
-- Include dates only if they are essential to the document's identity (e.g., contracts, certificates)
-- Ignore irrelevant folder names that don't describe the document content
-- Only use letters, numbers, and appropriate separators for the naming convention
-- Focus on the document's actual content and purpose, not just metadata
-
-${metadataContext}
-
-Document content (first 2000 characters):
-${content.substring(0, 2000)}
-
-Important: If this document is specifically for or about a particular person mentioned in the content, start the filename with their name. Otherwise, focus on the document's main purpose and content.
-
-Respond with only the filename using the specified naming convention, no explanation.`;
-}
-
-/**
- * System prompt for AI models that need a separate system message
- */
-export const AI_SYSTEM_PROMPT = 'You are a helpful assistant that generates descriptive filenames based on document content. Always respond with just the filename, no explanation or additional text.';