foldermaker 1.0.0__tar.gz

foldermaker-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 LetWeDo.freedev.app
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

foldermaker-1.0.0/PKG-INFO

@@ -0,0 +1,274 @@
+Metadata-Version: 2.4
+Name: foldermaker
+Version: 1.0.0
+Summary: Create folders and files automatically from AI-generated text folder trees.
+Author: Aniruddha Singh
+License: MIT
+Keywords: folder,tree,scaffold,project-generator,ai
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# FolderMaker
+
+**FolderMaker** is a free and open-source Python library that creates complete project folder and file structures from a text tree copied from AI assistant.
+
+Instead of manually creating every folder and file, paste the AI-generated structure into a `.txt` file and run one Python command. FolderForge will create the full structure automatically.
+
+## Features
+
+- Creates folders and files from an AI-generated text tree
+- Supports nested folders and files
+- Understands tree symbols such as `│`, `├──`, and `└──`
+- Supports Windows paths such as `D:\MY_AGENT\`
+- Detects folders with trailing `\` or `/`
+- Detects files such as `main.py`, `README.md`, and `Modelfile`
+- Creates empty folders such as `logs\`, `workspace\`, and `venv\`
+- Includes a dry-run mode to preview the result
+- No external dependencies
+- MIT licensed
+
+## Installation
+
+### Install from source
+
+1. Download or clone this repository.
+
+```powershell
+git clone [https://github.com/your-username/foldermaker.git]
+cd foldermaker
+```
+
+2. Install the library:
+
+```powershell
+pip install foldermaker.
+```
+### 1. Create a structure file
+
+Create a file named `structure.txt`.
+
+Paste your AI-generated folder tree into it exactly as shown by the AI assistant.
+
+Example:
+
+```text
+D:\MY_AGENT\
+│
+├── Modelfile
+├── main.py
+├── config\
+│   └── settings.py
+│
+├── core\
+│   ├── ollama_client.py
+│   ├── agent.py
+│   ├── planner.py
+│   └── tool_executor.py
+│
+├── tools\
+│   ├── web_search.py
+│   ├── browser.py
+│   ├── file_manager.py
+│   └── code_executor.py
+│
+├── memory\
+│   ├── database.py
+│   ├── long_term_memory.py
+│   └── feedback.py
+│
+├── knowledge\
+│   └── document_reader.py
+│
+├── task_manager\
+│   └── queue.py
+│
+├── logs\
+├── generated_tools\
+├── workspace\
+└── venv\
+```
+
+### 2. Create a Python runner file
+
+Create a file named `main.py`:
+
+```python
+import foldermaker
+
+folderforge.build(
+    structure_file="structure.txt",
+    output_dir=r"D:\MY_AGENT"
+)
+```
+
+### 3. Run the script
+
+```powershell
+python main.py
+```
+
+FolderMaker will create this structure:
+
+```text
+D:\MY_AGENT\
+├── Modelfile
+├── main.py
+├── config\settings.py
+├── core\ollama_client.py
+├── core\agent.py
+├── core\planner.py
+├── core\tool_executor.py
+├── tools\web_search.py
+├── tools\browser.py
+├── tools\file_manager.py
+├── tools\code_executor.py
+├── memory\database.py
+├── memory\long_term_memory.py
+├── memory\feedback.py
+├── knowledge\document_reader.py
+├── task_manager\queue.py
+├── logs\
+├── generated_tools\
+├── workspace\
+└── venv\
+```
+
+## Command-Line Usage
+
+After installing FolderForge, you can also use it from the terminal:
+
+```powershell
+foldermaker structure.txt -o D:\MY_AGENT
+```
+
+To preview what will be created without creating anything:
+
+```powershell
+foldermaker structure.txt -o D:\MY_AGENT --dry-run
+```
+
+## Python API
+
+### Create from a `.txt` file
+
+```python
+import foldermaker
+
+folderforge.build(
+    structure_file="structure.txt",
+    output_dir=r"D:\MY_AGENT"
+)
+```
+
+### Create from tree text directly
+
+```python
+import foldermaker
+
+tree = """
+D:\MY_AGENT\
+│
+├── main.py
+├── config\
+│   └── settings.py
+├── core\
+│   ├── agent.py
+│   └── planner.py
+"""
+
+foldermaker.build_from_text(
+    tree_text=tree,
+    output_dir=r"D:\MY_AGENT"
+)
+```
+
+### Preview without creating files
+
+```python
+import foldermaker
+
+folderforge.build(
+    structure_file="structure.txt",
+    output_dir=r"D:\MY_AGENT",
+    dry_run=True
+)
+```
+
+## Folder and File Detection
+
+FolderForge uses these rules:
+
+| Example | Created as | Reason |
+|---|---|---|
+| `config\` | Folder | Ends with `\` |
+| `tools/` | Folder | Ends with `/` |
+| `main.py` | File | Has a file extension |
+| `README.md` | File | Has a file extension |
+| `Modelfile` | File | Has no children |
+| `logs\` | Folder | Ends with `\` |
+| `core` | Folder | Has child files or folders |
+
+## Supported Tree Formats
+
+FolderForge supports common AI-generated tree formats, including:
+
+```text
+project/
+├── main.py
+├── config/
+│   └── settings.py
+└── core/
+    ├── agent.py
+    └── planner.py
+```
+
+And Windows-style trees:
+
+```text
+D:\MY_AGENT\
+│
+├── main.py
+├── config\
+│   └── settings.py
+└── core\
+    ├── agent.py
+    └── planner.py
+```
+
+## Project Structure
+
+```text
+folderforge/
+├── folderforge/
+│   ├── __init__.py
+│   ├── parser.py
+│   └── builder.py
+├── structure.txt
+├── generate_project.py
+├── README.md
+├── LICENSE
+└── pyproject.toml
+```
+
+## Safety Notes
+
+- FolderMaker creates empty files only; it does not generate file contents.
+- Existing files are not overwritten.
+- Existing folders are reused safely.
+- Use `dry_run=True` first if you are unsure where the structure will be created.
+
+## Contributing
+
+Contributions are welcome.
+
+1. Fork the repository
+2. Create a new branch
+3. Make your changes
+4. Add examples or tests if possible
+5. Submit a pull request
+
+## License
+
+This project is released under the MIT License. See the [`LICENSE`](LICENSE) file for details.

foldermaker-1.0.0/README.md

@@ -0,0 +1,262 @@
+# FolderMaker
+
+**FolderMaker** is a free and open-source Python library that creates complete project folder and file structures from a text tree copied from AI assistant.
+
+Instead of manually creating every folder and file, paste the AI-generated structure into a `.txt` file and run one Python command. FolderForge will create the full structure automatically.
+
+## Features
+
+- Creates folders and files from an AI-generated text tree
+- Supports nested folders and files
+- Understands tree symbols such as `│`, `├──`, and `└──`
+- Supports Windows paths such as `D:\MY_AGENT\`
+- Detects folders with trailing `\` or `/`
+- Detects files such as `main.py`, `README.md`, and `Modelfile`
+- Creates empty folders such as `logs\`, `workspace\`, and `venv\`
+- Includes a dry-run mode to preview the result
+- No external dependencies
+- MIT licensed
+
+## Installation
+
+### Install from source
+
+1. Download or clone this repository.
+
+```powershell
+git clone [https://github.com/your-username/foldermaker.git]
+cd foldermaker
+```
+
+2. Install the library:
+
+```powershell
+pip install foldermaker.
+```
+### 1. Create a structure file
+
+Create a file named `structure.txt`.
+
+Paste your AI-generated folder tree into it exactly as shown by the AI assistant.
+
+Example:
+
+```text
+D:\MY_AGENT\
+│
+├── Modelfile
+├── main.py
+├── config\
+│   └── settings.py
+│
+├── core\
+│   ├── ollama_client.py
+│   ├── agent.py
+│   ├── planner.py
+│   └── tool_executor.py
+│
+├── tools\
+│   ├── web_search.py
+│   ├── browser.py
+│   ├── file_manager.py
+│   └── code_executor.py
+│
+├── memory\
+│   ├── database.py
+│   ├── long_term_memory.py
+│   └── feedback.py
+│
+├── knowledge\
+│   └── document_reader.py
+│
+├── task_manager\
+│   └── queue.py
+│
+├── logs\
+├── generated_tools\
+├── workspace\
+└── venv\
+```
+
+### 2. Create a Python runner file
+
+Create a file named `main.py`:
+
+```python
+import foldermaker
+
+folderforge.build(
+    structure_file="structure.txt",
+    output_dir=r"D:\MY_AGENT"
+)
+```
+
+### 3. Run the script
+
+```powershell
+python main.py
+```
+
+FolderMaker will create this structure:
+
+```text
+D:\MY_AGENT\
+├── Modelfile
+├── main.py
+├── config\settings.py
+├── core\ollama_client.py
+├── core\agent.py
+├── core\planner.py
+├── core\tool_executor.py
+├── tools\web_search.py
+├── tools\browser.py
+├── tools\file_manager.py
+├── tools\code_executor.py
+├── memory\database.py
+├── memory\long_term_memory.py
+├── memory\feedback.py
+├── knowledge\document_reader.py
+├── task_manager\queue.py
+├── logs\
+├── generated_tools\
+├── workspace\
+└── venv\
+```
+
+## Command-Line Usage
+
+After installing FolderForge, you can also use it from the terminal:
+
+```powershell
+foldermaker structure.txt -o D:\MY_AGENT
+```
+
+To preview what will be created without creating anything:
+
+```powershell
+foldermaker structure.txt -o D:\MY_AGENT --dry-run
+```
+
+## Python API
+
+### Create from a `.txt` file
+
+```python
+import foldermaker
+
+folderforge.build(
+    structure_file="structure.txt",
+    output_dir=r"D:\MY_AGENT"
+)
+```
+
+### Create from tree text directly
+
+```python
+import foldermaker
+
+tree = """
+D:\MY_AGENT\
+│
+├── main.py
+├── config\
+│   └── settings.py
+├── core\
+│   ├── agent.py
+│   └── planner.py
+"""
+
+foldermaker.build_from_text(
+    tree_text=tree,
+    output_dir=r"D:\MY_AGENT"
+)
+```
+
+### Preview without creating files
+
+```python
+import foldermaker
+
+folderforge.build(
+    structure_file="structure.txt",
+    output_dir=r"D:\MY_AGENT",
+    dry_run=True
+)
+```
+
+## Folder and File Detection
+
+FolderForge uses these rules:
+
+| Example | Created as | Reason |
+|---|---|---|
+| `config\` | Folder | Ends with `\` |
+| `tools/` | Folder | Ends with `/` |
+| `main.py` | File | Has a file extension |
+| `README.md` | File | Has a file extension |
+| `Modelfile` | File | Has no children |
+| `logs\` | Folder | Ends with `\` |
+| `core` | Folder | Has child files or folders |
+
+## Supported Tree Formats
+
+FolderForge supports common AI-generated tree formats, including:
+
+```text
+project/
+├── main.py
+├── config/
+│   └── settings.py
+└── core/
+    ├── agent.py
+    └── planner.py
+```
+
+And Windows-style trees:
+
+```text
+D:\MY_AGENT\
+│
+├── main.py
+├── config\
+│   └── settings.py
+└── core\
+    ├── agent.py
+    └── planner.py
+```
+
+## Project Structure
+
+```text
+folderforge/
+├── folderforge/
+│   ├── __init__.py
+│   ├── parser.py
+│   └── builder.py
+├── structure.txt
+├── generate_project.py
+├── README.md
+├── LICENSE
+└── pyproject.toml
+```
+
+## Safety Notes
+
+- FolderMaker creates empty files only; it does not generate file contents.
+- Existing files are not overwritten.
+- Existing folders are reused safely.
+- Use `dry_run=True` first if you are unsure where the structure will be created.
+
+## Contributing
+
+Contributions are welcome.
+
+1. Fork the repository
+2. Create a new branch
+3. Make your changes
+4. Add examples or tests if possible
+5. Submit a pull request
+
+## License
+
+This project is released under the MIT License. See the [`LICENSE`](LICENSE) file for details.

foldermaker-1.0.0/foldermaker/__init__.py

@@ -0,0 +1,16 @@
+"""
+folderforge
+
+Create folders and files automatically from an AI-generated
+text folder-tree structure.
+
+Example:
+    import folderforge
+    folderforge.build("structure.txt")
+
+"""
+
+from .builder import build, build_from_text
+
+__version__ = "1.0.0"
+__all__ = ["build", "build_from_text"]

foldermaker-1.0.0/foldermaker/builder.py

@@ -0,0 +1,122 @@
+from pathlib import Path
+
+from .parser import parse_tree
+
+
+def build_from_text(
+    tree_text: str,
+    output_dir: str | Path = ".",
+    dry_run: bool = False,
+) -> list[str]:
+    output_path = Path(output_dir).expanduser().resolve()
+    nodes = parse_tree(tree_text)
+
+    created: list[str] = []
+    node_map = {node.name: node for node in nodes}
+
+    for node in nodes:
+        relative_path = _get_relative_path(node, node_map)
+        target = output_path / relative_path
+
+        if node.is_folder:
+            _create_folder(target, dry_run, created)
+        else:
+            _create_file(target, dry_run, created)
+
+    return created
+
+
+def build(
+    structure_file: str | Path,
+    output_dir: str | Path = ".",
+    dry_run: bool = False,
+) -> list[str]:
+    """
+    Reads a .txt file containing a folder tree and creates it.
+
+    Example:
+        import folderforge
+        folderforge.build("structure.txt", output_dir="D:/MY_AGENT")
+    """
+    structure_path = Path(structure_file).expanduser().resolve()
+
+    if not structure_path.exists():
+        raise FileNotFoundError(f"Structure file not found: {structure_path}")
+
+    tree_text = structure_path.read_text(encoding="utf-8")
+    return build_from_text(tree_text, output_dir=output_dir, dry_run=dry_run)
+
+
+def _get_relative_path(node, node_map) -> Path:
+    """
+    Builds the full relative path, such as:
+    core/ollama_client.py
+    """
+    parts = [node.name]
+    current = node
+
+    while current.parent:
+        parent = node_map.get(current.parent)
+
+        if parent is None:
+            break
+
+        parts.append(parent.name)
+        current = parent
+
+    return Path(*reversed(parts))
+
+
+def _create_folder(path: Path, dry_run: bool, created: list[str]) -> None:
+    if dry_run:
+        print(f"[DRY RUN] Would create folder: {path}")
+        created.append(str(path))
+        return
+
+    path.mkdir(parents=True, exist_ok=True)
+    print(f"Created folder: {path}")
+    created.append(str(path))
+
+
+def _create_file(path: Path, dry_run: bool, created: list[str]) -> None:
+    if dry_run:
+        print(f"[DRY RUN] Would create file: {path}")
+        created.append(str(path))
+        return
+
+    path.parent.mkdir(parents=True, exist_ok=True)
+
+    if not path.exists():
+        path.touch()
+        print(f"Created file: {path}")
+    else:
+        print(f"File already exists: {path}")
+
+    created.append(str(path))
+
+
+def cli():
+    import argparse
+
+    parser = argparse.ArgumentParser(
+        description="Create folders and files from a text folder-tree structure."
+    )
+    parser.add_argument("structure_file", help="Path to the .txt tree file")
+    parser.add_argument(
+        "-o", "--output",
+        default=".",
+        help="Output directory where the structure will be created"
+    )
+    parser.add_argument(
+        "--dry-run",
+        action="store_true",
+        help="Show what would be created without creating anything"
+    )
+
+    args = parser.parse_args()
+
+    build(
+        structure_file=args.structure_file,
+        output_dir=args.output,
+        dry_run=args.dry_run,
+    )

foldermaker-1.0.0/foldermaker/parser.py

@@ -0,0 +1,117 @@
+import re
+from dataclasses import dataclass, field
+from pathlib import PureWindowsPath, PurePosixPath
+
+
+TREE_NAME_PATTERN = re.compile(r"(?:├──|└──|--)\s*(.+)$")
+CLEAN_NAME_PATTERN = re.compile(r"[\u2500-\u257F│├└─]")
+
+
+@dataclass
+class Node:
+    name: str
+    depth: int
+    parent: str | None = None
+    is_folder: bool = False
+    children: list["Node"] = field(default_factory=list)
+
+
+def _get_indent_depth(prefix: str) -> int:
+    """
+    Calculates nesting depth from the space before a file/folder name.
+
+    Examples:
+        "│   "       -> depth 1
+        "│   ├── "   -> depth 1
+        "│   │   "   -> depth 2
+    """
+    cleaned = CLEAN_NAME_PATTERN.sub(" ", prefix)
+    cleaned = cleaned.replace("\t", "    ")
+
+    leading_spaces = len(cleaned) - len(cleaned.lstrip(" "))
+    return leading_spaces // 4
+
+
+def _extract_name(line: str) -> tuple[str, int]:
+    """
+    Returns (name, depth) from one tree line.
+    """
+    match = TREE_NAME_PATTERN.search(line)
+
+    if match:
+        name = match.group(1).strip()
+        prefix = line[: match.start()]
+    else:
+        name = line.strip()
+        prefix = ""
+
+    if not name:
+        raise ValueError(f"Could not find a folder or file name in line: {line!r}")
+
+    depth = _get_indent_depth(prefix)
+    return name, depth
+
+
+def _is_folder(name: str, has_children: bool) -> bool:
+    """
+    Folder detection rules:
+
+    1. `config\\` or `config/` is always a folder.
+    2. `script.py`, `README.md`, `image.png` are files.
+    3. Names without an extension are folders if they have children.
+       This correctly treats `Modelfile` as a file and `logs\\` as a folder.
+    """
+    if name.endswith("\\") or name.endswith("/"):
+        return True
+
+    if "." in PureWindowsPath(name).name or "." in PurePosixPath(name).name:
+        return False
+
+    return has_children
+
+
+def parse_tree(text: str) -> list[Node]:
+    """
+    Converts tree text into a list of nested Node objects.
+    """
+    lines = [line.rstrip() for line in text.splitlines()]
+    lines = [line for line in lines if line.strip()]
+
+    if not lines:
+        raise ValueError("The structure file is empty.")
+
+    nodes: list[Node] = []
+    stack: list[Node] = []
+
+    for line in lines:
+        name, depth = _extract_name(line)
+
+        
+        clean_name = name.rstrip("\\/").strip()
+
+        if not clean_name:
+            continue
+
+        node = Node(
+            name=clean_name,
+            depth=depth,
+        )
+
+        
+        while stack and stack[-1].depth >= depth:
+            stack.pop()
+
+        if stack:
+            node.parent = stack[-1].name
+            stack[-1].children.append(node)
+        else:
+            
+            node.parent = None
+
+        stack.append(node)
+        nodes.append(node)
+
+    for node in nodes:
+        node.is_folder = _is_folder(node.name, bool(node.children))
+
+    return nodes

foldermaker-1.0.0/foldermaker.egg-info/PKG-INFO

@@ -0,0 +1,274 @@
+Metadata-Version: 2.4
+Name: foldermaker
+Version: 1.0.0
+Summary: Create folders and files automatically from AI-generated text folder trees.
+Author: Aniruddha Singh
+License: MIT
+Keywords: folder,tree,scaffold,project-generator,ai
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# FolderMaker
+
+**FolderMaker** is a free and open-source Python library that creates complete project folder and file structures from a text tree copied from AI assistant.
+
+Instead of manually creating every folder and file, paste the AI-generated structure into a `.txt` file and run one Python command. FolderForge will create the full structure automatically.
+
+## Features
+
+- Creates folders and files from an AI-generated text tree
+- Supports nested folders and files
+- Understands tree symbols such as `│`, `├──`, and `└──`
+- Supports Windows paths such as `D:\MY_AGENT\`
+- Detects folders with trailing `\` or `/`
+- Detects files such as `main.py`, `README.md`, and `Modelfile`
+- Creates empty folders such as `logs\`, `workspace\`, and `venv\`
+- Includes a dry-run mode to preview the result
+- No external dependencies
+- MIT licensed
+
+## Installation
+
+### Install from source
+
+1. Download or clone this repository.
+
+```powershell
+git clone [https://github.com/your-username/foldermaker.git]
+cd foldermaker
+```
+
+2. Install the library:
+
+```powershell
+pip install foldermaker.
+```
+### 1. Create a structure file
+
+Create a file named `structure.txt`.
+
+Paste your AI-generated folder tree into it exactly as shown by the AI assistant.
+
+Example:
+
+```text
+D:\MY_AGENT\
+│
+├── Modelfile
+├── main.py
+├── config\
+│   └── settings.py
+│
+├── core\
+│   ├── ollama_client.py
+│   ├── agent.py
+│   ├── planner.py
+│   └── tool_executor.py
+│
+├── tools\
+│   ├── web_search.py
+│   ├── browser.py
+│   ├── file_manager.py
+│   └── code_executor.py
+│
+├── memory\
+│   ├── database.py
+│   ├── long_term_memory.py
+│   └── feedback.py
+│
+├── knowledge\
+│   └── document_reader.py
+│
+├── task_manager\
+│   └── queue.py
+│
+├── logs\
+├── generated_tools\
+├── workspace\
+└── venv\
+```
+
+### 2. Create a Python runner file
+
+Create a file named `main.py`:
+
+```python
+import foldermaker
+
+folderforge.build(
+    structure_file="structure.txt",
+    output_dir=r"D:\MY_AGENT"
+)
+```
+
+### 3. Run the script
+
+```powershell
+python main.py
+```
+
+FolderMaker will create this structure:
+
+```text
+D:\MY_AGENT\
+├── Modelfile
+├── main.py
+├── config\settings.py
+├── core\ollama_client.py
+├── core\agent.py
+├── core\planner.py
+├── core\tool_executor.py
+├── tools\web_search.py
+├── tools\browser.py
+├── tools\file_manager.py
+├── tools\code_executor.py
+├── memory\database.py
+├── memory\long_term_memory.py
+├── memory\feedback.py
+├── knowledge\document_reader.py
+├── task_manager\queue.py
+├── logs\
+├── generated_tools\
+├── workspace\
+└── venv\
+```
+
+## Command-Line Usage
+
+After installing FolderForge, you can also use it from the terminal:
+
+```powershell
+foldermaker structure.txt -o D:\MY_AGENT
+```
+
+To preview what will be created without creating anything:
+
+```powershell
+foldermaker structure.txt -o D:\MY_AGENT --dry-run
+```
+
+## Python API
+
+### Create from a `.txt` file
+
+```python
+import foldermaker
+
+folderforge.build(
+    structure_file="structure.txt",
+    output_dir=r"D:\MY_AGENT"
+)
+```
+
+### Create from tree text directly
+
+```python
+import foldermaker
+
+tree = """
+D:\MY_AGENT\
+│
+├── main.py
+├── config\
+│   └── settings.py
+├── core\
+│   ├── agent.py
+│   └── planner.py
+"""
+
+foldermaker.build_from_text(
+    tree_text=tree,
+    output_dir=r"D:\MY_AGENT"
+)
+```
+
+### Preview without creating files
+
+```python
+import foldermaker
+
+folderforge.build(
+    structure_file="structure.txt",
+    output_dir=r"D:\MY_AGENT",
+    dry_run=True
+)
+```
+
+## Folder and File Detection
+
+FolderForge uses these rules:
+
+| Example | Created as | Reason |
+|---|---|---|
+| `config\` | Folder | Ends with `\` |
+| `tools/` | Folder | Ends with `/` |
+| `main.py` | File | Has a file extension |
+| `README.md` | File | Has a file extension |
+| `Modelfile` | File | Has no children |
+| `logs\` | Folder | Ends with `\` |
+| `core` | Folder | Has child files or folders |
+
+## Supported Tree Formats
+
+FolderForge supports common AI-generated tree formats, including:
+
+```text
+project/
+├── main.py
+├── config/
+│   └── settings.py
+└── core/
+    ├── agent.py
+    └── planner.py
+```
+
+And Windows-style trees:
+
+```text
+D:\MY_AGENT\
+│
+├── main.py
+├── config\
+│   └── settings.py
+└── core\
+    ├── agent.py
+    └── planner.py
+```
+
+## Project Structure
+
+```text
+folderforge/
+├── folderforge/
+│   ├── __init__.py
+│   ├── parser.py
+│   └── builder.py
+├── structure.txt
+├── generate_project.py
+├── README.md
+├── LICENSE
+└── pyproject.toml
+```
+
+## Safety Notes
+
+- FolderMaker creates empty files only; it does not generate file contents.
+- Existing files are not overwritten.
+- Existing folders are reused safely.
+- Use `dry_run=True` first if you are unsure where the structure will be created.
+
+## Contributing
+
+Contributions are welcome.
+
+1. Fork the repository
+2. Create a new branch
+3. Make your changes
+4. Add examples or tests if possible
+5. Submit a pull request
+
+## License
+
+This project is released under the MIT License. See the [`LICENSE`](LICENSE) file for details.

foldermaker-1.0.0/foldermaker.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+LICENSE
+README.md
+pyproject.toml
+foldermaker/__init__.py
+foldermaker/builder.py
+foldermaker/parser.py
+foldermaker.egg-info/PKG-INFO
+foldermaker.egg-info/SOURCES.txt
+foldermaker.egg-info/dependency_links.txt
+foldermaker.egg-info/entry_points.txt
+foldermaker.egg-info/top_level.txt

foldermaker-1.0.0/foldermaker.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

foldermaker-1.0.0/foldermaker.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+folderforge = foldermaker.builder:cli

foldermaker-1.0.0/foldermaker.egg-info/top_level.txt

@@ -0,0 +1 @@
+foldermaker

foldermaker-1.0.0/pyproject.toml

@@ -0,0 +1,21 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "foldermaker"
+version = "1.0.0"
+description = "Create folders and files automatically from AI-generated text folder trees."
+readme = "README.md"
+license = { text = "MIT" }
+authors = [
+    { name = "Aniruddha Singh" }
+]
+requires-python = ">=3.9"
+keywords = ["folder", "tree", "scaffold", "project-generator", "ai"]
+
+[project.scripts]
+folderforge = "foldermaker.builder:cli"
+
+[tool.setuptools.packages.find]
+include = ["foldermaker*"]

foldermaker-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+