@himamshus06/git-auto 1.3.5 → 1.3.7

package/package.json

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

package/src/tree.js

@@ -1,9 +1,6 @@
 const fs = require('node:fs');
 const path = require('node:path');
 
-/**
- * Custom error for tree parsing failures
- */
 class TreeParseError extends Error {
     constructor(message, line) {
         super(line ? `Line ${line}: ${message}` : message);
@@ -11,206 +8,88 @@ class TreeParseError extends Error {
     }
 }
 
-/**
- * Parse a visual directory tree.
- *
- * Supported format:
- *
- * my-project/
- * ├── src/
- * │   ├── index.js
- * │   └── utils.js
- * ├── public/
- * │   └── index.html
- * └── package.json
- */
+// Every character that can appear in a branch-drawing prefix, unicode or ascii style.
+// Note the U+2500 box-drawing horizontal (─) — NOT an ascii hyphen (-). Real tree
+// output (and most pasted trees) uses U+2500, which is why the old regex silently
+// failed to strip prefixes correctly.
+const PREFIX_CHARS = /[│├└|+`\-─\s]/;
+const CONNECTOR_CHARS = new Set(['├', '└', '+', '`']);
+
 function parseTree(text) {
     if (!text || text.trim() === '') {
         throw new TreeParseError('No tree provided');
     }
-
-    const lines = text
-        .split(/\r?\n/)
-        .filter(line => line.trim() !== '');
-
-    const result = [];
+    const lines = text.split('\n').filter(line => line.trim() !== '');
     const stack = [];
+    const result = [];
 
     for (let i = 0; i < lines.length; i++) {
         const line = lines[i];
         const lineNum = i + 1;
 
-        let name;
-        let depth;
-
-        // --------------------------------------------------
-        // ROOT
-        // --------------------------------------------------
-
-        if (i === 0) {
-            name = line.trim();
-            depth = 0;
+        // Find the connector character (├ / └ / ascii + / `), if any.
+        let connectorIdx = -1;
+        for (let c = 0; c < line.length; c++) {
+            if (CONNECTOR_CHARS.has(line[c])) { connectorIdx = c; break; }
         }
 
-        // --------------------------------------------------
-        // 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 indentation = match[1];
-            name = match[2].trim();
-
-            /*
-             * Every 4 characters of indentation
-             * represents one level.
-             *
-             * ├── src/              depth 1
-             * │   ├── index.js      depth 2
-             * │   │   └── x.js      depth 3
-             */
-
-            depth = indentation.length / 4 + 1;
-        }
-
-        if (!name) {
-            throw new TreeParseError(
-                'Empty file/directory name',
-                lineNum
-            );
+        let depth, rest;
+        if (connectorIdx === -1) {
+            // No connector at all -> this is the root line itself.
+            depth = 0;
+            rest = line.trim();
+        } else {
+            const prefix = line.slice(0, connectorIdx);
+            // Each ancestor level draws a fixed 4-char block ("│   " or "    ").
+            // +1 because having a connector at all means "at least one level below root".
+            depth = Math.round(prefix.length / 4) + 1;
+            rest = line.slice(connectorIdx);
         }
 
-        // --------------------------------------------------
-        // 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();
-        }
+        // Strip any remaining connector/line-drawing/space characters to get the name.
+        let name = rest.replace(new RegExp(`^${PREFIX_CHARS.source}+`), '').trim();
+        // Strip a trailing inline comment ("  # explanation"), if present.
+        name = name.replace(/\s+#.*$/, '').trim();
+        if (!name) continue;
 
-        /*
-         * Make sure we aren't jumping over a level.
-         */
         if (depth > stack.length) {
             throw new TreeParseError(
-                `Invalid nesting at depth ${depth}`,
-                lineNum
+                `Nesting depth jump detected (from ${stack.length} to ${depth})`, lineNum
             );
         }
 
-        // --------------------------------------------------
-        // FILE / DIRECTORY
-        // --------------------------------------------------
+        while (stack.length > depth) stack.pop();
 
-        const isDirectory = name.endsWith('/');
-
-        const cleanName = name.replace(/\/$/, '');
-
-        // --------------------------------------------------
-        // PATH
-        // --------------------------------------------------
+        const isDirectory = name.endsWith('/') || (!name.includes('.') && !name.startsWith('.'));
+        const cleanName = isDirectory ? name.replace(/\/$/, '') : name;
 
         stack.push(cleanName);
-
         const fullPath = path.join(...stack);
 
-        result.push({
-            name: cleanName,
-            depth,
-            isDirectory,
-            fullPath
-        });
+        result.push({ name: cleanName, depth, isDirectory, fullPath });
     }
-
     return result;
 }
 
-/**
- * Create files and directories from parsed tree.
- */
 async function parseAndCreateTree(text) {
     const created = [];
     const errors = [];
-
-    let treeStructure;
-
-    try {
-        treeStructure = parseTree(text);
-    } catch (err) {
-        if (err instanceof TreeParseError) {
-            throw err;
-        }
-
-        throw new Error(`Unexpected parsing error: ${err.message}`);
-    }
+    const treeStructure = parseTree(text); // let TreeParseError propagate to caller
 
     for (const item of treeStructure) {
         try {
             if (item.isDirectory) {
-                fs.mkdirSync(item.fullPath, {
-                    recursive: true
-                });
+                fs.mkdirSync(item.fullPath, { recursive: true });
             } else {
-                const parentDir = path.dirname(item.fullPath);
-
-                fs.mkdirSync(parentDir, {
-                    recursive: true
-                });
-
+                fs.mkdirSync(path.dirname(item.fullPath), { recursive: true });
                 fs.writeFileSync(item.fullPath, '');
             }
-
             created.push(item.fullPath);
         } catch (err) {
-            errors.push(
-                `Failed to create ${item.fullPath}: ${err.message}`
-            );
+            errors.push(`Failed to create ${item.fullPath}: ${err.message}`);
         }
     }
-
-    return {
-        created,
-        errors
-    };
+    return { created, errors };
 }
 
-module.exports = {
-    parseTree,
-    parseAndCreateTree,
-    TreeParseError
-};
+module.exports = { parseAndCreateTree, parseTree, TreeParseError };