# F13 — Split a Fat Module ## Proposed Module Structure ``` src/ ├── file-manager/ │ ├── index.js # Barrel exports (public API) │ ├── utils/ │ │ ├── file-io.js # File I/O utilities │ │ └── file-validation.js # File validation utilities │ ├── operations/ │ │ └── undo-operations.js # Undo-capable file operations │ ├── git/ │ │ └── git-operations.js # Git integration │ └── templates/ │ └── template-loader.js # Template system └── package.json # Updated dependencies (if any) ``` --- ## 1. `src/file-manager/utils/file-io.js` **Functions:** `readFile(path)`, `writeFile(path, content)`, `deleteFile(path)`, `listDirectory(path)` ```javascript // src/file-manager/utils/file-io.js /** * Read the contents of a file. * @param {string} path - Path to the file * @returns {Promise} File contents */ async function readFile(path) { // Implementation... } /** * Write content to a file. * @param {string} path - Path to the file * @param {string} content - Content to write * @returns {Promise} */ async function writeFile(path, content) { // Implementation... } /** * Delete a file. * @param {string} path - Path to the file * @returns {Promise} */ async function deleteFile(path) { // Implementation... } /** * List files in a directory. * @param {string} path - Path to the directory * @returns {Promise} Array of file paths */ async function listDirectory(path) { // Implementation... } module.exports = { readFile, writeFile, deleteFile, listDirectory, }; ``` --- ## 2. `src/file-manager/utils/file-validation.js` **Functions:** `validateFilePath(path)`, `isWithinWorkspace(path)`, `sanitizeFileName(name)`, `getExtension(file)` ```javascript // src/file-manager/utils/file-validation.js /** * Validate a file path for security and correctness. * @param {string} path - Path to validate * @returns {boolean} True if valid */ function validateFilePath(path) { // Implementation... } /** * Check if a path is within the workspace directory. * @param {string} path - Path to check * @returns {boolean} True if within workspace */ function isWithinWorkspace(path) { // Implementation... } /** * Sanitize a filename to prevent path traversal and special chars. * @param {string} name - Filename to sanitize * @returns {string} Sanitized filename */ function sanitizeFileName(name) { // Implementation... } /** * Get the extension of a file. * @param {string} file - File path or name * @returns {string} File extension (including dot) */ function getExtension(file) { // Implementation... } module.exports = { validateFilePath, isWithinWorkspace, sanitizeFileName, getExtension, }; ``` --- ## 3. `src/file-manager/operations/undo-operations.js` **Functions:** `safeWrite(path, content)`, `undoWrite(path)`, `getBackups()`, `clearBackups()` ```javascript // src/file-manager/operations/undo-operations.js const fs = require('fs').promises; const path = require('path'); const { writeFile, readFile } = require('../utils/file-io'); const { sanitizeFileName } = require('../utils/file-validation'); // Backup directory path const BACKUP_DIR = path.join(__dirname, '../../backups'); /** * Safely write a file with automatic backup. * @param {string} path - Path to the file * @param {string} content - Content to write * @returns {Promise} */ async function safeWrite(path, content) { // Implementation with backup creation... } /** * Undo a previous write operation by restoring from backup. * @param {string} path - Path of file to restore * @returns {Promise} */ async function undoWrite(path) { // Implementation... } /** * Get all backup files. * @returns {string[]} Array of backup file paths */ function getBackups() { // Implementation... } /** * Clear all backup files. * @returns {Promise} */ async function clearBackups() { // Implementation... } module.exports = { safeWrite, undoWrite, getBackups, clearBackups, }; ``` --- ## 4. `src/file-manager/git/git-operations.js` **Functions:** `stageFile(path)`, `commitChanges(message)`, `getDiff(path)`, `getBranch()` ```javascript // src/file-manager/git/git-operations.js const { exec } = require('child_process'); const { promisify } = require('util'); const { readFile } = require('../utils/file-io'); const { validateFilePath, isWithinWorkspace } = require('../utils/file-validation'); const execAsync = promisify(exec); /** * Stage a file for commit. * @param {string} path - Path to the file * @returns {Promise} */ async function stageFile(path) { // Implementation... } /** * Commit staged changes with a message. * @param {string} message - Commit message * @returns {Promise} */ async function commitChanges(message) { // Implementation... } /** * Get the diff of a file. * @param {string} path - Path to the file * @returns {Promise} Diff output */ async function getDiff(path) { // Implementation... } /** * Get the current git branch. * @returns {Promise} Branch name */ async function getBranch() { // Implementation... } module.exports = { stageFile, commitChanges, getDiff, getBranch, }; ``` --- ## 5. `src/file-manager/templates/template-loader.js` **Functions:** `loadTemplate(name)`, `applyTemplate(template, vars)`, `listTemplates()` ```javascript // src/file-manager/templates/template-loader.js const fs = require('fs').promises; const path = require('path'); const { readFile } = require('../utils/file-io'); const { sanitizeFileName } = require('../utils/file-validation'); /** * Load a template by name. * @param {string} name - Template name * @returns {Promise} Template content */ async function loadTemplate(name) { // Implementation... } /** * Apply variables to a template. * @param {string} template - Template content * @param {Object} vars - Variables to substitute * @returns {string} Rendered template */ function applyTemplate(template, vars) { // Implementation... } /** * List all available templates. * @returns {Promise} Array of template names */ async function listTemplates() { // Implementation... } module.exports = { loadTemplate, applyTemplate, listTemplates, }; ``` --- ## 6. `src/file-manager/index.js` (Public API Barrel) **Purpose:** Re-exports all modules for convenient importing ```javascript // src/file-manager/index.js // Utils const { readFile, writeFile, deleteFile, listDirectory } = require('./utils/file-io'); const { validateFilePath, isWithinWorkspace, sanitizeFileName, getExtension, } = require('./utils/file-validation'); // Operations const { safeWrite, undoWrite, getBackups, clearBackups } = require('./operations/undo-operations'); // Git const { stageFile, commitChanges, getDiff, getBranch } = require('./git/git-operations'); // Templates const { loadTemplate, applyTemplate, listTemplates } = require('./templates/template-loader'); // Public API module.exports = { // File I/O readFile, writeFile, deleteFile, listDirectory, // Validation validateFilePath, isWithinWorkspace, sanitizeFileName, getExtension, // Undo Operations safeWrite, undoWrite, getBackups, clearBackups, // Git Operations stageFile, commitChanges, getDiff, getBranch, // Templates loadTemplate, applyTemplate, listTemplates, }; ``` --- ## Import/Require Relationships ``` ┌─────────────────────────────────────────────────────────────────────┐ │ src/file-manager/index.js │ │ (Barrel - Public API) │ └─────────────────────────────────────────────────────────────────────┘ │ ┌───────────────────────────┼───────────────────────────┐ │ │ │ ▼ ▼ ▼ ┌───────────────────┐ ┌───────────────────┐ ┌───────────────────┐ │ utils/ │ │ operations/ │ │ git/ │ │ file-io.js │ │ undo-ops.js │ │ git-ops.js │ └───────────────────┘ └───────────────────┘ └───────────────────┘ │ │ │ └───────────────────────────┴───────────────────────────┘ │ ▼ ┌─────────────────────┐ │ utils/ │ │ file-validation.js │ └─────────────────────┘ │ ▼ ┌───────────────────────┐ │ templates/ │ │ template-loader.js │ └───────────────────────┘ ``` --- ## Benefits of This Refactoring 1. **Single Responsibility Principle** — Each module has one clear purpose (I/O, validation, undo, Git, templates), making code easier to understand and modify. 2. **Improved Testability** — Individual functions can be tested in isolation without needing the entire file-manager context, making unit tests faster and more reliable. 3. **Better Code Organization** — Related functions are grouped together, making it easier to navigate the codebase and find what you need. 4. **Reduced Cognitive Load** — Developers only need to understand one module at a time, not a monolithic 400+ line file. 5. **Flexible Importing** — Consumers can import only what they need: ```javascript // Instead of loading everything: const fm = require('./file-manager'); // They can import specific modules: const { readFile, writeFile } = require('./file-manager/utils/file-io'); ``` 6. **Easier Maintenance** — Bug fixes and feature additions are isolated to specific modules, reducing the risk of unintended side effects. 7. **Better Collaboration** — Multiple developers can work on different modules simultaneously without stepping on each other's toes. --- ## Usage Example ```javascript // Consumer usage - simple and clean: const fileManager = require('./file-manager'); // Or import specific modules: const { readFile, writeFile, safeWrite } = require('./file-manager'); const { stageFile, commitChanges } = require('./file-manager/git/git-operations'); const { loadTemplate, applyTemplate } = require('./file-manager/templates/template-loader'); ```

DELGMark Results Dashboard

Model Records

Evaluation Detail (%)