@himamshus06/git-auto 1.3.3 → 1.3.5

package/package.json

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

package/src/tree.js

@@ -12,73 +12,141 @@ class TreeParseError extends Error {
 }
 
 /**
- * Symbols used to define tree structures
- */
-const SYMBOLS = {
-    unicode: {
-        vertical: '│',
-        branch: '├',
-        leaf: '└',
-        space: ' '
-    },
-    ascii: {
-        vertical: '|',
-        branch: '+',
-        leaf: '`',
-        space: ' '
-    }
-};
-
-/**
- * Parses a visual tree string into a structured array of items.
+ * Parse a visual directory tree.
+ *
+ * Supported format:
  *
- * @param {string} text - The visual directory tree string.
- * @returns {Array<{name: string, depth: number, isDirectory: boolean, fullPath: string}>}
- * @throws {TreeParseError}
+ * my-project/
+ * ├── src/
+ * │   ├── index.js
+ * │   └── utils.js
+ * ├── public/
+ * │   └── index.html
+ * └── package.json
  */
 function parseTree(text) {
     if (!text || text.trim() === '') {
         throw new TreeParseError('No tree provided');
     }
 
-    const lines = text.split('\n').filter(line => line.trim() !== '');
-    const stack = [];
+    const lines = text
+        .split(/\r?\n/)
+        .filter(line => line.trim() !== '');
+
     const result = [];
-    let currentDepth = -1;
+    const stack = [];
 
     for (let i = 0; i < lines.length; i++) {
         const line = lines[i];
         const lineNum = i + 1;
 
-        // Regex to split prefix symbols/spaces from the actual name
-        const match = line.match(/^([│\s├└| \+`-]*) (.*)$/) || line.match(/^([│\s├└| \+`-]*)(.*)$/);
-        if (!match) continue;
+        let name;
+        let depth;
+
+        // --------------------------------------------------
+        // ROOT
+        // --------------------------------------------------
+
+        if (i === 0) {
+            name = line.trim();
+            depth = 0;
+        }
+
+        // --------------------------------------------------
+        // CHILD
+        // --------------------------------------------------
+
+        else {
+            /*
+             * Match:
+             *
+             * ├── src/
+             * └── package.json
+             *
+             * │   ├── index.js
+             * │   └── utils.js
+             *
+             * │   │   └── Button.jsx
+             */
+
+            const match = line.match(
+                /^((?:│   |    )*)(?:├── |└── |\+-- |`-- )(.*)$/
+            );
+
+            if (!match) {
+                throw new TreeParseError(
+                    `Could not parse line: "${line}"`,
+                    lineNum
+                );
+            }
 
-        const prefix = match[1];
-        let name = match[2].trim();
+            const indentation = match[1];
+            name = match[2].trim();
 
-        if (!name) continue;
+            /*
+             * Every 4 characters of indentation
+             * represents one level.
+             *
+             * ├── src/              depth 1
+             * │   ├── index.js      depth 2
+             * │   │   └── x.js      depth 3
+             */
 
-        // Calculate depth based on "indentation units"
-        // A unit is typically 4 characters (symbol + 3 spaces) or similar.
-        // We count how many vertical bars or space blocks exist before the branch symbol.
-        const depth = calculateDepth(prefix);
+            depth = indentation.length / 4 + 1;
+        }
 
-        // Logical Validation: Continuity Check
-        if (depth > currentDepth + 1) {
-            throw new TreeParseError(`Nesting depth jump detected (from ${currentDepth + 1} to ${depth})`, lineNum);
+        if (!name) {
+            throw new TreeParseError(
+                'Empty file/directory name',
+                lineNum
+            );
         }
 
-        // Adjust stack to current depth
+        // --------------------------------------------------
+        // STACK
+        // --------------------------------------------------
+
+        /*
+         * If we're moving back up the tree,
+         * remove deeper entries.
+         *
+         * Example:
+         *
+         * │   ├── index.js
+         * │   └── utils.js
+         *
+         * When utils.js is processed, index.js
+         * must be removed from the stack.
+         */
+
         while (stack.length > depth) {
             stack.pop();
         }
 
-        // Reliable Type Detection
-        const isDirectory = name.endsWith('/') || (!name.includes('.') && !name.startsWith('.'));
-        const cleanName = isDirectory ? name.replace(/\/$/, '') : name;
+        /*
+         * Make sure we aren't jumping over a level.
+         */
+        if (depth > stack.length) {
+            throw new TreeParseError(
+                `Invalid nesting at depth ${depth}`,
+                lineNum
+            );
+        }
+
+        // --------------------------------------------------
+        // FILE / DIRECTORY
+        // --------------------------------------------------
+
+        const isDirectory = name.endsWith('/');
+
+        const cleanName = name.replace(/\/$/, '');
+
+        // --------------------------------------------------
+        // PATH
+        // --------------------------------------------------
 
         stack.push(cleanName);
+
         const fullPath = path.join(...stack);
 
         result.push({
@@ -87,91 +155,62 @@ function parseTree(text) {
             isDirectory,
             fullPath
         });
-
-        currentDepth = depth;
     }
 
     return result;
 }
 
 /**
- * Determines the depth of a line based on its prefix.
- * Supports both Unicode and ASCII styles.
- *
- * @param {string} prefix
- * @returns {number}
- */
-function calculateDepth(prefix) {
-    if (!prefix) return 0;
-
-    // Standard visual trees use blocks of 4 characters per level (e.g., "│   " or "    ")
-    // We count these blocks.
-    let depth = 0;
-    let i = 0;
-    while (i < prefix.length) {
-        // Check if we've reached the terminal branch symbol (├ or └ or + or `)
-        if (prefix[i] === SYMBOLS.unicode.branch || prefix[i] === SYMBOLS.unicode.leaf ||
-            prefix[i] === SYMBOLS.ascii.branch || prefix[i] === SYMBOLS.ascii.leaf) {
-            break;
-        }
-
-        // Increment depth for every "unit" of indentation
-        // We assume a unit is 4 characters wide in most common formats
-        depth++;
-        i += 4;
-    }
-
-    // Because we increment depth for every 4-char block,
-    // we need to handle cases where the prefix is shorter than a full block.
-    // A more robust way is to count actual vertical markers.
-    const markers = (prefix.match(/[│|]/g) || []).length;
-
-    // Heuristic: If we have markers, that's our depth.
-    // Otherwise, we use the space-based block count.
-    if (markers > 0) return markers;
-
-    return Math.floor(prefix.length / 4);
-}
-
-/**
- * Parses a visual directory tree and creates the corresponding directories/files.
- *
- * @param {string} text - The visual directory tree string.
- * @returns {Promise<{created: string[], errors: string[]}>}
+ * Create files and directories from parsed tree.
  */
 async function parseAndCreateTree(text) {
     const created = [];
     const errors = [];
 
+    let treeStructure;
+
     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}`);
-            }
-        }
+        treeStructure = parseTree(text);
     } catch (err) {
         if (err instanceof TreeParseError) {
-            throw err; // Rethrow parsing errors for the CLI to handle
+            throw err;
         }
-        throw new Error(`Unexpected error: ${err.message}`);
+
+        throw new Error(`Unexpected parsing error: ${err.message}`);
     }
 
-    return { created, errors };
+    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}`
+            );
+        }
+    }
+
+    return {
+        created,
+        errors
+    };
 }
 
 module.exports = {
-    parseAndCreateTree,
     parseTree,
+    parseAndCreateTree,
     TreeParseError
-};
+};