@singhaman21/cleansweep 1.0.0

package/src/utils/fileUtils.ts

@@ -0,0 +1,218 @@
+/**
+ * File utility functions for cleansweep
+ * Handles file system operations and pattern matching
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import { glob } from 'glob';
+
+/**
+ * Checks if a given path should be excluded based on exclusion patterns
+ * @param filePath - Path to check
+ * @param excludePatterns - Array of exclusion patterns
+ * @returns true if should be excluded, false otherwise
+ */
+export function shouldExclude(filePath: string, excludePatterns: string[]): boolean {
+  for (const pattern of excludePatterns) {
+    // Check if path contains the pattern or basename matches
+    if (filePath.includes(pattern) || path.basename(filePath) === pattern) {
+      return true;
+    }
+  }
+  return false;
+}
+
+/**
+ * Finds files matching a pattern with optional depth limit
+ * @param pattern - Glob pattern to match
+ * @param maxDepth - Maximum depth to search (optional)
+ * @param currentDir - Current directory to search in
+ * @returns Array of matching file paths
+ */
+export async function findFiles(
+  pattern: string,
+  maxDepth?: number,
+  currentDir: string = process.cwd()
+): Promise<string[]> {
+  const options: any = {
+    cwd: currentDir,
+    absolute: false,
+    nodir: true
+  };
+
+  if (maxDepth !== undefined) {
+    options.maxDepth = maxDepth;
+  }
+
+  try {
+    const files = await glob(pattern, options);
+    return files.map(file => path.relative(process.cwd(), path.resolve(currentDir, file)));
+  } catch (error) {
+    return [];
+  }
+}
+
+/**
+ * Finds directories matching a pattern with optional depth limit
+ * @param pattern - Glob pattern to match
+ * @param maxDepth - Maximum depth to search (optional)
+ * @param currentDir - Current directory to search in
+ * @returns Array of matching directory paths
+ */
+export async function findDirectories(
+  pattern: string,
+  maxDepth?: number,
+  currentDir: string = process.cwd()
+): Promise<string[]> {
+  const directories: string[] = [];
+
+  /**
+   * Recursively search for directories
+   */
+  function searchDir(dir: string, currentDepth: number = 0): void {
+    if (maxDepth !== undefined && currentDepth > maxDepth) {
+      return;
+    }
+
+    try {
+      const entries = fs.readdirSync(dir, { withFileTypes: true });
+
+      for (const entry of entries) {
+        const fullPath = path.join(dir, entry.name);
+        const relativePath = path.relative(process.cwd(), fullPath);
+
+        if (entry.isDirectory()) {
+          // Check if directory name matches pattern
+          if (matchesPattern(entry.name, pattern)) {
+            directories.push(relativePath);
+          }
+          // Recursively search subdirectories
+          searchDir(fullPath, currentDepth + 1);
+        }
+      }
+    } catch (error) {
+      // Skip directories we can't read
+      return;
+    }
+  }
+
+  searchDir(currentDir);
+  return directories;
+}
+
+/**
+ * Finds both files and directories matching a pattern
+ * @param pattern - Glob pattern to match
+ * @param maxDepth - Maximum depth to search (optional)
+ * @param currentDir - Current directory to search in
+ * @returns Array of matching paths
+ */
+export async function findItems(
+  pattern: string,
+  maxDepth?: number,
+  currentDir: string = process.cwd()
+): Promise<string[]> {
+  const items: string[] = [];
+
+  /**
+   * Recursively search for items
+   */
+  function searchDir(dir: string, currentDepth: number = 0): void {
+    if (maxDepth !== undefined && currentDepth > maxDepth) {
+      return;
+    }
+
+    try {
+      const entries = fs.readdirSync(dir, { withFileTypes: true });
+
+      for (const entry of entries) {
+        const fullPath = path.join(dir, entry.name);
+        const relativePath = path.relative(process.cwd(), fullPath);
+
+        // Check if name matches pattern
+        if (matchesPattern(entry.name, pattern)) {
+          items.push(relativePath);
+        }
+
+        // Recursively search subdirectories
+        if (entry.isDirectory()) {
+          searchDir(fullPath, currentDepth + 1);
+        }
+      }
+    } catch (error) {
+      // Skip directories we can't read
+      return;
+    }
+  }
+
+  searchDir(currentDir);
+  return items;
+}
+
+/**
+ * Simple pattern matching (converts glob to regex-like matching)
+ * @param name - Name to check
+ * @param pattern - Pattern to match against
+ * @returns true if matches, false otherwise
+ */
+function matchesPattern(name: string, pattern: string): boolean {
+  // Convert glob pattern to regex
+  const regexPattern = pattern
+    .replace(/\*/g, '.*')
+    .replace(/\?/g, '.');
+  const regex = new RegExp(`^${regexPattern}$`);
+  return regex.test(name);
+}
+
+/**
+ * Deletes a file or directory
+ * @param itemPath - Path to the item to delete
+ * @returns true if successful, false otherwise
+ */
+export function deleteItem(itemPath: string): boolean {
+  try {
+    const fullPath = path.resolve(itemPath);
+    const stat = fs.statSync(fullPath);
+
+    if (stat.isDirectory()) {
+      fs.rmSync(fullPath, { recursive: true, force: true });
+      return true;
+    } else if (stat.isFile()) {
+      fs.unlinkSync(fullPath);
+      return true;
+    }
+    return false;
+  } catch (error) {
+    return false;
+  }
+}
+
+/**
+ * Checks if a path exists and is a file
+ * @param itemPath - Path to check
+ * @returns true if exists and is a file
+ */
+export function isFile(itemPath: string): boolean {
+  try {
+    const stat = fs.statSync(itemPath);
+    return stat.isFile();
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Checks if a path exists and is a directory
+ * @param itemPath - Path to check
+ * @returns true if exists and is a directory
+ */
+export function isDirectory(itemPath: string): boolean {
+  try {
+    const stat = fs.statSync(itemPath);
+    return stat.isDirectory();
+  } catch {
+    return false;
+  }
+}
+

package/src/utils/logger.ts

@@ -0,0 +1,91 @@
+/**
+ * Logger utility for cleansweep
+ * Handles logging to console and log files with timestamps
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import { LogLevel, OutputFormat } from '../types';
+
+export class Logger {
+  private logFile?: string;
+  private outputFormat: OutputFormat;
+
+  constructor(logFile?: string, outputFormat: OutputFormat = 'plain') {
+    this.logFile = logFile;
+    this.outputFormat = outputFormat;
+  }
+
+  /**
+   * Logs a message with timestamp to both console and log file (if specified)
+   * @param message - Message to log
+   * @param level - Log level (INFO, WARNING, ERROR)
+   */
+  log(message: string, level: LogLevel = 'INFO'): void {
+    const timestamp = new Date().toISOString().replace('T', ' ').slice(0, 19);
+    const formattedMessage = `[${timestamp}] [${level}] ${message}`;
+
+    // Print to console
+    if (this.outputFormat === 'json') {
+      const jsonMessage = JSON.stringify({
+        timestamp,
+        level,
+        message
+      });
+      console.log(jsonMessage);
+    } else {
+      console.log(formattedMessage);
+    }
+
+    // Write to log file if specified
+    if (this.logFile) {
+      try {
+        fs.appendFileSync(this.logFile, formattedMessage + '\n');
+      } catch (error) {
+        console.error(`Failed to write to log file: ${error}`);
+      }
+    }
+  }
+
+  /**
+   * Initializes the log file with header information
+   * @param config - Configuration object with all settings
+   */
+  initializeLogFile(config: {
+    dryRun: boolean;
+    interactive: boolean;
+    force: boolean;
+    filesPattern?: string;
+    foldersPattern?: string;
+    typesPattern?: string;
+    excludePatterns: string[];
+    maxDepth?: number;
+  }): void {
+    if (!this.logFile) return;
+
+    try {
+      const header = [
+        '==========================================',
+        `Deletion Log - ${new Date().toISOString().replace('T', ' ').slice(0, 19)}`,
+        '==========================================',
+        `Dry Run: ${config.dryRun}`,
+        `Interactive: ${config.interactive}`,
+        `Force: ${config.force}`,
+        ...(config.filesPattern ? [`Files Pattern: ${config.filesPattern}`] : []),
+        ...(config.foldersPattern ? [`Folders Pattern: ${config.foldersPattern}`] : []),
+        ...(config.typesPattern ? [`Types Pattern: ${config.typesPattern}`] : []),
+        ...(config.excludePatterns.length > 0
+          ? [`Exclude Patterns: ${config.excludePatterns.join(', ')}`]
+          : []),
+        ...(config.maxDepth ? [`Max Depth: ${config.maxDepth}`] : []),
+        '==========================================',
+        ''
+      ].join('\n');
+
+      fs.writeFileSync(this.logFile, header);
+    } catch (error) {
+      console.error(`Failed to initialize log file: ${error}`);
+    }
+  }
+}
+

package/src/utils/prompts.ts

@@ -0,0 +1,54 @@
+/**
+ * Interactive prompt utilities for cleansweep
+ * Handles user confirmation prompts
+ */
+
+import * as readline from 'readline';
+
+/**
+ * Creates a readline interface for user input
+ */
+function createReadlineInterface(): readline.Interface {
+  return readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+}
+
+/**
+ * Prompts the user for confirmation before deleting an item
+ * @param item - Path of the item to delete
+ * @param force - If true, always returns true without prompting
+ * @returns Promise that resolves to true if confirmed, false otherwise
+ */
+export function confirmDeletion(item: string, force: boolean = false): Promise<boolean> {
+  return new Promise((resolve) => {
+    if (force) {
+      resolve(true);
+      return;
+    }
+
+    const rl = createReadlineInterface();
+    rl.question(`Delete '${item}'? [y/N]: `, (answer) => {
+      rl.close();
+      const response = answer.trim().toLowerCase();
+      resolve(response === 'y' || response === 'yes');
+    });
+  });
+}
+
+/**
+ * Prompts the user to proceed with deletion after preview
+ * @returns Promise that resolves to true if confirmed, false otherwise
+ */
+export function confirmProceed(): Promise<boolean> {
+  return new Promise((resolve) => {
+    const rl = createReadlineInterface();
+    rl.question('Proceed with deletion? [y/N]: ', (answer) => {
+      rl.close();
+      const response = answer.trim().toLowerCase();
+      resolve(response === 'y' || response === 'yes');
+    });
+  });
+}
+

package/tsconfig.json

@@ -0,0 +1,21 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "commonjs",
+    "lib": ["ES2020"],
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "moduleResolution": "node"
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}
+