@amirdaraee/namewise 0.3.0

package/src/parsers/factory.ts

@@ -0,0 +1,34 @@
+import { DocumentParser } 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[] = [
+    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

@@ -0,0 +1,78 @@
+import fs from 'fs';
+import path from 'path';
+import { DocumentParser, ParseResult, DocumentMetadata } from '../types/index.js';
+
+export class PDFParser implements DocumentParser {
+  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, {});
+      
+      const content = data.text?.trim() || '';
+      
+      // 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

@@ -0,0 +1,43 @@
+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

@@ -0,0 +1,50 @@
+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

@@ -0,0 +1,16 @@
+import { AIProvider } from '../types/index.js';
+import { ClaudeService } from './claude-service.js';
+import { OpenAIService } from './openai-service.js';
+
+export class AIServiceFactory {
+  static create(provider: 'claude' | 'openai', apiKey: string): AIProvider {
+    switch (provider) {
+      case 'claude':
+        return new ClaudeService(apiKey);
+      case 'openai':
+        return new OpenAIService(apiKey);
+      default:
+        throw new Error(`Unsupported AI provider: ${provider}`);
+    }
+  }
+}

package/src/services/claude-service.ts

@@ -0,0 +1,114 @@
+import Anthropic from '@anthropic-ai/sdk';
+import { AIProvider, FileInfo } from '../types/index.js';
+import { applyNamingConvention, getNamingInstructions, NamingConvention } from '../utils/naming-conventions.js';
+import { getTemplateInstructions, FileCategory } from '../utils/file-templates.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;
+    const namingInstructions = getNamingInstructions(convention);
+    const templateInstructions = getTemplateInstructions(fileCategory);
+    
+    // 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}`;
+      }
+    }
+
+    const prompt = `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-8 words
+- ${namingInstructions}
+- ${templateInstructions}
+- Do not include file extension
+- Do not include personal names, dates, or template variables - just the core content description
+- Only use letters, numbers, and appropriate separators for the naming convention
+- Use all available context (metadata, folder context, document properties) to create the most accurate filename
+
+${metadataContext}
+
+Document content (first 2000 characters):
+${content.substring(0, 2000)}
+
+Respond with only the core filename (without personal info or dates) using the specified naming convention, no explanation.`;
+
+    try {
+      const 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

@@ -0,0 +1,123 @@
+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[] = [];
+
+    for (let i = 0; i < files.length; i++) {
+      const file = files[i];
+      // Use \r to overwrite the same line, show progress counter
+      process.stdout.write(`\rProcessing: ${file.name}... (${i + 1}/${files.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 processing line and move to next line
+    process.stdout.write('\r' + ' '.repeat(80) + '\r');
+
+    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/openai-service.ts

@@ -0,0 +1,113 @@
+import OpenAI from 'openai';
+import { AIProvider, FileInfo } from '../types/index.js';
+import { applyNamingConvention, getNamingInstructions, NamingConvention } from '../utils/naming-conventions.js';
+import { getTemplateInstructions, FileCategory } from '../utils/file-templates.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;
+    const namingInstructions = getNamingInstructions(convention);
+    const templateInstructions = getTemplateInstructions(fileCategory);
+    
+    // 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}`;
+      }
+    }
+
+    const prompt = `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-8 words
+- ${namingInstructions}
+- ${templateInstructions}
+- Do not include file extension
+- Do not include personal names, dates, or template variables - just the core content description
+- Only use letters, numbers, and appropriate separators for the naming convention
+- Use all available context (metadata, folder context, document properties) to create the most accurate filename
+
+${metadataContext}
+
+Document content (first 2000 characters):
+${content.substring(0, 2000)}
+
+Respond with only the core filename (without personal info or dates) using the specified naming convention, no explanation.`;
+
+    try {
+      const 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

@@ -0,0 +1,71 @@
+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';
+  apiKey: string;
+  maxFileSize: number;
+  supportedExtensions: string[];
+  dryRun: boolean;
+  namingConvention: NamingConvention;
+  templateOptions: TemplateOptions;
+}
+
+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

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