@himamshus06/git-auto 1.3.4 → 1.3.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@himamshus06/git-auto",
-  "version": "1.3.4",
+  "version": "1.3.6",
   "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,202 +8,86 @@ class TreeParseError extends Error {
     }
 }
 
-/**
- * Parse a visual directory tree into structured items.
- */
+// 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;
 
-        const parsed = parseLine(line);
-
-        if (!parsed) {
-            throw new TreeParseError(
-                `Unable to parse tree line: "${line}"`,
-                lineNum
-            );
+        // 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; }
         }
 
-        const { name, depth } = parsed;
-
-        // Root must be depth 0
-        if (i === 0 && depth !== 0) {
-            throw new TreeParseError(
-                'Root item must have depth 0',
-                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);
         }
 
-        // Prevent impossible jumps
+        // Strip any remaining connector/line-drawing/space characters to get the name.
+        const name = rest.replace(new RegExp(`^${PREFIX_CHARS.source}+`), '').trim();
+        if (!name) continue;
+
         if (depth > stack.length) {
             throw new TreeParseError(
-                `Nesting depth jump detected`,
-                lineNum
+                `Nesting depth jump detected (from ${stack.length} to ${depth})`, lineNum
             );
         }
 
-        // Remove anything deeper than the current item
-        while (stack.length > depth) {
-            stack.pop();
-        }
-
-        // Detect directory/file
-        const isDirectory = detectDirectory(name);
+        while (stack.length > depth) stack.pop();
 
-        const cleanName = isDirectory
-            ? name.replace(/\/$/, '')
-            : name;
+        const isDirectory = name.endsWith('/') || (!name.includes('.') && !name.startsWith('.'));
+        const cleanName = isDirectory ? name.replace(/\/$/, '') : name;
 
-        // Add current item to stack
         stack.push(cleanName);
-
         const fullPath = path.join(...stack);
 
-        result.push({
-            name: cleanName,
-            depth,
-            isDirectory,
-            fullPath
-        });
+        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}`
-                );
+    const treeStructure = parseTree(text); // let TreeParseError propagate to caller
+
+    for (const item of treeStructure) {
+        try {
+            if (item.isDirectory) {
+                fs.mkdirSync(item.fullPath, { recursive: true });
+            } else {
+                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}`);
         }
-    } catch (err) {
-        if (err instanceof TreeParseError) {
-            throw err;
-        }
-
-        throw new Error(`Unexpected error: ${err.message}`);
     }
-
-    return {
-        created,
-        errors
-    };
+    return { created, errors };
 }
 
-module.exports = {
-    parseAndCreateTree,
-    parseTree,
-    TreeParseError
-};
+module.exports = { parseAndCreateTree, parseTree, TreeParseError };