@himamshus06/git-auto 1.3.2 → 1.3.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@himamshus06/git-auto",
-  "version": "1.3.2",
+  "version": "1.3.4",
   "description": "",
   "main": "src/index.js",
   "bin": {

package/src/tree.js

@@ -2,70 +2,211 @@ const fs = require('node:fs');
 const path = require('node:path');
 
 /**
- * Parses a visual directory tree and creates the corresponding directories.
- * @param {string} text - The visual directory tree string.
- * @returns {Promise<{created: string[], errors: string[]}>}
+ * Custom error for tree parsing failures
  */
-async function parseAndCreateTree(text) {
+class TreeParseError extends Error {
+    constructor(message, line) {
+        super(line ? `Line ${line}: ${message}` : message);
+        this.name = 'TreeParseError';
+    }
+}
+
+/**
+ * Parse a visual directory tree into structured items.
+ */
+function parseTree(text) {
     if (!text || text.trim() === '') {
-        throw new Error('No tree provided');
+        throw new TreeParseError('No tree provided');
     }
 
-    const lines = text.split('\n').filter(line => line.trim() !== '');
+    const lines = text
+        .split(/\r?\n/)
+        .filter(line => line.trim() !== '');
+
+    const result = [];
     const stack = [];
-    const created = [];
-    const errors = [];
 
-    for (const line of lines) {
-        // 1. Determine depth
-        // We find the first character that isn't a tree symbol or whitespace
-        const match = line.match(/^([│\s├└]*)(.*)$/);
-        if (!match) continue;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const lineNum = i + 1;
 
-        const prefix = match[1];
-        let name = match[2].trim();
+        const parsed = parseLine(line);
+
+        if (!parsed) {
+            throw new TreeParseError(
+                `Unable to parse tree line: "${line}"`,
+                lineNum
+            );
+        }
 
-        if (!name) continue;
+        const { name, depth } = parsed;
 
-        // Depth is determined by the number of 4-character blocks in the prefix.
-        // For most visual trees, each level of nesting is 4 characters (e.g., "│   " or "├── ").
-        // We strip the final tree symbol (├ or └) from the length if it's there.
-        const effectivePrefixLength = prefix.endsWith('├') || prefix.endsWith('└')
-            ? prefix.length - 1
-            : prefix.length;
-        const depth = Math.floor(effectivePrefixLength / 4);
+        // Root must be depth 0
+        if (i === 0 && depth !== 0) {
+            throw new TreeParseError(
+                'Root item must have depth 0',
+                lineNum
+            );
+        }
+
+        // Prevent impossible jumps
+        if (depth > stack.length) {
+            throw new TreeParseError(
+                `Nesting depth jump detected`,
+                lineNum
+            );
+        }
 
-        // 2. Adjust stack to current depth
+        // Remove anything deeper than the current item
         while (stack.length > depth) {
             stack.pop();
         }
 
-        // 3. Clean name (remove trailing slash for directory creation)
-        const isDirectory = name.endsWith('/') || !name.includes('.');
-        const cleanName = isDirectory ? name.replace(/\/$/, '') : name;
+        // Detect directory/file
+        const isDirectory = detectDirectory(name);
 
+        const cleanName = isDirectory
+            ? name.replace(/\/$/, '')
+            : name;
+
+        // Add current item to stack
         stack.push(cleanName);
 
-        // 4. Form full path
         const fullPath = path.join(...stack);
-        try {
-            if (isDirectory) {
-                fs.mkdirSync(fullPath, { recursive: true });
-            } else {
-                // Ensure parent directory exists
-                const parentDir = path.dirname(fullPath);
-                fs.mkdirSync(parentDir, { recursive: true });
-                fs.writeFileSync(fullPath, ''); // Create empty file
+
+        result.push({
+            name: cleanName,
+            depth,
+            isDirectory,
+            fullPath
+        });
+    }
+
+    return result;
+}
+
+/**
+ * Parse one line of a tree.
+ */
+function parseLine(line) {
+    // Root:
+    // project/
+    if (!/^[│|├└+`]/.test(line)) {
+        return {
+            name: line.trim(),
+            depth: 0
+        };
+    }
+
+    /*
+     * Match tree indentation.
+     *
+     * Examples:
+     *
+     * ├── src/
+     * └── package.json
+     *
+     * │   ├── components/
+     * │   └── App.jsx
+     *
+     * │   │   └── Button.jsx
+     */
+
+    const match = line.match(/^((?:│   |    )*)(?:├── |└── |\+-- |`-- )(.*)$/);
+
+    if (!match) {
+        return null;
+    }
+
+    const indentation = match[1];
+    const name = match[2].trim();
+
+    // Every 4-character indentation block = one level.
+    const depth = indentation.length / 4 + 1;
+
+    return {
+        name,
+        depth
+    };
+}
+
+/**
+ * Determine whether an item is a directory.
+ *
+ * Best case: directories end with /.
+ *
+ * For trees that don't include /, this falls back to
+ * extension-based detection.
+ */
+function detectDirectory(name) {
+    // Explicit directory marker
+    if (name.endsWith('/')) {
+        return true;
+    }
+
+    // Hidden files like .gitignore are files
+    if (name.startsWith('.')) {
+        return false;
+    }
+
+    // Files with extensions are files
+    if (path.extname(name) !== '') {
+        return false;
+    }
+
+    // Otherwise assume directory
+    return true;
+}
+
+/**
+ * Parse tree and create files/directories.
+ */
+async function parseAndCreateTree(text) {
+    const created = [];
+    const errors = [];
+
+    try {
+        const treeStructure = parseTree(text);
+
+        for (const item of treeStructure) {
+            try {
+                if (item.isDirectory) {
+                    fs.mkdirSync(item.fullPath, {
+                        recursive: true
+                    });
+                } else {
+                    const parentDir = path.dirname(item.fullPath);
+
+                    fs.mkdirSync(parentDir, {
+                        recursive: true
+                    });
+
+                    fs.writeFileSync(item.fullPath, '');
+                }
+
+                created.push(item.fullPath);
+            } catch (err) {
+                errors.push(
+                    `Failed to create ${item.fullPath}: ${err.message}`
+                );
             }
-            created.push(fullPath);
-        } catch (err) {
-            errors.push(`Failed to create ${fullPath}: ${err.message}`);
         }
+    } catch (err) {
+        if (err instanceof TreeParseError) {
+            throw err;
+        }
+
+        throw new Error(`Unexpected error: ${err.message}`);
     }
 
-    return { created, errors };
+    return {
+        created,
+        errors
+    };
 }
 
 module.exports = {
-    parseAndCreateTree
-};
+    parseAndCreateTree,
+    parseTree,
+    TreeParseError
+};