src2md 0.1.0__tar.gz

src2md-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) [year] [fullname]
+
+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.

src2md-0.1.0/PKG-INFO

@@ -0,0 +1,128 @@
+Metadata-Version: 2.2
+Name: src2md
+Version: 0.1.0
+Summary: A tool to convert source code directories into Markdown documentation.
+Home-page: https://github.com/queelius/src2md
+Author: Alex Towell
+Author-email: lex@example.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pypandoc
+Requires-Dist: pathspec
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# src2md
+
+![License](https://img.shields.io/badge/license-MIT-blue.svg)
+![PyPI](https://img.shields.io/pypi/v/src2md)
+![Python Versions](https://img.shields.io/pypi/pyversions/src2md)
+
+**src2md** is a versatile tool that converts source code directories into comprehensive Markdown documentation. It scans your project structure, includes documentation files like `README.md` or `README.rst`, and embeds source code snippets with proper syntax highlighting. Ideal for generating project overviews, documentation for large codebases, or providing context to language models.
+
+## 🚀 **Features**
+
+- **Automatic Documentation Aggregation**: Collects and prioritizes documentation files (e.g., `README.md`, `README.rst`).
+- **Syntax-Highlighted Source Code**: Embeds source code files with appropriate language identifiers for Markdown.
+- **Flexible File Patterns**: Customize which files to include as documentation or source code using patterns.
+- **Ignore Hidden Files and Directories**: Automatically excludes hidden files and directories (those starting with `.`).
+- **Leverages `.gitignore`**: Respects your `.gitignore` settings to exclude unwanted files.
+- **Simple CLI Interface**: Easy-to-use command-line interface for generating documentation.
+
+## 📦 **Installation**
+
+You can install `src2md` via [PyPI](https://pypi.org/) using `pip`:
+
+```bash
+pip install src2md
+```
+
+Alternatively, install it directly from the source:
+
+```bash
+git clone https://github.com/yourusername/src2md.git
+cd src2md
+pip install .
+```
+
+## 🛠️  Usage
+Once installed, you can use src2md from the command line to generate Markdown documentation for your project.
+
+### Basic Command
+
+```bash
+src2md path/to/source -o output.md
+```
+
+- `path/to/source`: Path to your project's root directory.
+- `-o output.md`: (Optional) Specifies the output Markdown file name. Defaults to project_documentation.md.
+
+## Advanced Options
+
+- **Specify Documentation Patterns**
+
+  Include additional documentation file types.
+
+  ```bash
+  src2md path/to/source -o output.md --doc-patterns '*.md' '*.rst' '*.lark'
+  ```
+
+- **Specify Source Code Patterns**
+
+  Customize which source files to include. Use '*' to include all files.
+
+  ```bash
+  src2md path/to/source -o output.md --src-patterns '*.py' '*.js'
+  ```
+
+  To include all files as source code:
+
+  ```bash
+  src2md path/to/source -o output.md --src-patterns '*'
+  ```
+
+- **Add Additional Ignore Patterns**
+
+  Exclude specific files or directories.
+
+  ```bash
+  src2md path/to/source -o output.md --ignore-patterns '*.pyc' 'build/' 'dist/'
+  ```
+
+- **Use a Custom Ignore File**
+
+  Specify a custom ignore file.
+
+  ```bash
+  src2md path/to/source -o output.md --ignore-file .src2mdignore
+  ```
+
+- **Disable .gitignore Usage**
+
+  Do not use .gitignore for ignoring files.
+
+  ```bash
+  src2md path/to/source -o output.md --no-use-gitignore
+  ```
+
+## Full Example
+
+```bash
+src2md ./my_project -o my_project_docs.md \
+    --doc-patterns '*.md' '*.rst' '*.lark' \
+    --src-patterns '*.py' '*.cpp' '*.js' \
+    --ignore-patterns '*.pyc' 'build/' 'dist/'
+```
+
+This command generates my_project_docs.md by including all .md, .rst, and .lark documentation files, embedding .py, .cpp, and .js source files, and excluding any .pyc files and directories named build or dist.

src2md-0.1.0/README.md

@@ -0,0 +1,103 @@
+# src2md
+
+![License](https://img.shields.io/badge/license-MIT-blue.svg)
+![PyPI](https://img.shields.io/pypi/v/src2md)
+![Python Versions](https://img.shields.io/pypi/pyversions/src2md)
+
+**src2md** is a versatile tool that converts source code directories into comprehensive Markdown documentation. It scans your project structure, includes documentation files like `README.md` or `README.rst`, and embeds source code snippets with proper syntax highlighting. Ideal for generating project overviews, documentation for large codebases, or providing context to language models.
+
+## 🚀 **Features**
+
+- **Automatic Documentation Aggregation**: Collects and prioritizes documentation files (e.g., `README.md`, `README.rst`).
+- **Syntax-Highlighted Source Code**: Embeds source code files with appropriate language identifiers for Markdown.
+- **Flexible File Patterns**: Customize which files to include as documentation or source code using patterns.
+- **Ignore Hidden Files and Directories**: Automatically excludes hidden files and directories (those starting with `.`).
+- **Leverages `.gitignore`**: Respects your `.gitignore` settings to exclude unwanted files.
+- **Simple CLI Interface**: Easy-to-use command-line interface for generating documentation.
+
+## 📦 **Installation**
+
+You can install `src2md` via [PyPI](https://pypi.org/) using `pip`:
+
+```bash
+pip install src2md
+```
+
+Alternatively, install it directly from the source:
+
+```bash
+git clone https://github.com/yourusername/src2md.git
+cd src2md
+pip install .
+```
+
+## 🛠️  Usage
+Once installed, you can use src2md from the command line to generate Markdown documentation for your project.
+
+### Basic Command
+
+```bash
+src2md path/to/source -o output.md
+```
+
+- `path/to/source`: Path to your project's root directory.
+- `-o output.md`: (Optional) Specifies the output Markdown file name. Defaults to project_documentation.md.
+
+## Advanced Options
+
+- **Specify Documentation Patterns**
+
+  Include additional documentation file types.
+
+  ```bash
+  src2md path/to/source -o output.md --doc-patterns '*.md' '*.rst' '*.lark'
+  ```
+
+- **Specify Source Code Patterns**
+
+  Customize which source files to include. Use '*' to include all files.
+
+  ```bash
+  src2md path/to/source -o output.md --src-patterns '*.py' '*.js'
+  ```
+
+  To include all files as source code:
+
+  ```bash
+  src2md path/to/source -o output.md --src-patterns '*'
+  ```
+
+- **Add Additional Ignore Patterns**
+
+  Exclude specific files or directories.
+
+  ```bash
+  src2md path/to/source -o output.md --ignore-patterns '*.pyc' 'build/' 'dist/'
+  ```
+
+- **Use a Custom Ignore File**
+
+  Specify a custom ignore file.
+
+  ```bash
+  src2md path/to/source -o output.md --ignore-file .src2mdignore
+  ```
+
+- **Disable .gitignore Usage**
+
+  Do not use .gitignore for ignoring files.
+
+  ```bash
+  src2md path/to/source -o output.md --no-use-gitignore
+  ```
+
+## Full Example
+
+```bash
+src2md ./my_project -o my_project_docs.md \
+    --doc-patterns '*.md' '*.rst' '*.lark' \
+    --src-patterns '*.py' '*.cpp' '*.js' \
+    --ignore-patterns '*.pyc' 'build/' 'dist/'
+```
+
+This command generates my_project_docs.md by including all .md, .rst, and .lark documentation files, embedding .py, .cpp, and .js source files, and excluding any .pyc files and directories named build or dist.

src2md-0.1.0/setup.cfg

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

src2md-0.1.0/setup.py

@@ -0,0 +1,29 @@
+from setuptools import setup, find_packages
+
+setup(
+    name='src2md',
+    version='0.1.0',
+    author='Alex Towell',
+    author_email='lex@example.com',
+    description='A tool to convert source code directories into Markdown documentation.',
+    long_description=open('README.md').read(),
+    long_description_content_type='text/markdown',
+    url='https://github.com/queelius/src2md',
+    packages=find_packages(),
+    include_package_data=True,
+    classifiers=[
+        'Programming Language :: Python :: 3',
+        'License :: OSI Approved :: MIT License',
+        'Operating System :: OS Independent',
+    ],
+    python_requires='>=3.6',
+    install_requires=[
+        'pypandoc',
+        'pathspec',
+    ],
+    entry_points={
+        'console_scripts': [
+            'src2md=src2md.cli:main',
+        ],
+    },
+)

src2md-0.1.0/src2md/cli.py

@@ -0,0 +1,102 @@
+"""
+src2md - Source Code to Markdown
+
+A Python package to map a source code directory into a single Markdown file,
+including documentation files (e.g., README.md, README.rst), and source files
+whose filenames match specified patterns.
+
+This is primarily used to provide an LLM context about your project, which may
+be distributed over multiple file and sub-directories.
+
+Usage: src2md path/to/source -o output.md
+                            [--doc-pat PATTERN [PATTERN ...]]
+                            [--src-pat PATTERN [PATTERN ...]]
+                            [--ignore-pat PATTERN [PATTERN ...]]
+                            [--ignore-file FILE]
+
+By default, --ignore-file is set to '.src2mdignore', --doc-pat is set to ['*.md', '*.rst'],
+--src-pat is set to all the keys in the `default_langs` dictionary, and --ignore-pat is set to ['.*']
+which ignores all hidden files and directories.
+"""
+import argparse
+from pathlib import Path
+import sys
+from .utils import generate_markdown, default_langs, load_ignore_file
+
+def main():
+    """
+    Main function to parse arguments and generate the Markdown documentation.
+    """
+
+    parser = argparse.ArgumentParser(
+        description="Map a source code directory to a Markdown file."
+    )
+    parser.add_argument(
+        "path",
+        help="Path to the source directory."
+    )
+    parser.add_argument(
+        "-o", "--out",
+        default="project.md",
+        help="Output Markdown file name. Defaults to 'project.md'."
+    )
+    parser.add_argument(
+        "--doc-pat",
+        nargs='+',
+        default=['*.md', '*.rst'],
+        help="Patterns to identify documentation files (e.g., *.md, *.rst). README.* is prioritized. Defaults to ['*.md', '*.rst']."
+    )
+    parser.add_argument(
+        "--src-pat",
+        nargs='+',
+        default=[f"*{ext}" for ext in default_langs.keys()],
+        help="Whitelist patterns to identify files to include (e.g., *.py, *.cpp, *.js). Use '*' to include all files. Defaults to all the keys in `default_langs` dictionary."
+    )
+    parser.add_argument(
+        "--ignore-pat",
+        nargs='+',
+        default=['.*'],
+        help="Blacklist patterns to identify files to ignore (e.g., *.py, *.cpp, *.js). Use '*' to include all files. Defaults to ['.*'], which ignores all hidden files and directories."
+    )
+    parser.add_argument(
+        "--ignore-file",
+        default=".src2mdignore",
+        help="File with patterns to ignore (e.g., *.py, *.cpp, *.js). Defaults to '.src2mdignore'.")
+
+    args = parser.parse_args()
+
+    path = Path(args.path)
+    if not path.is_dir():
+        print(f"Error: {args.path} is not a valid directory.", file=sys.stderr)
+        sys.exit(1)
+
+    ignore_pat = load_ignore_file(path / args.ignore_file)
+    if ignore_pat:
+        args.ignore_pat.extend(ignore_pat)
+
+    # If '*' is in src_pat, adjust to include all files except those in doc_pat
+    if '*' in args.src_pat:
+        # Replace '*' with a pattern that matches all files
+        args.src_pat = ['*']
+
+    try:
+        markdown = generate_markdown(
+            args.path,
+            doc_pat=args.doc_pat,
+            src_pat=args.src_pat,
+            ignore_pat=args.ignore_pat)
+    except Exception as e:
+        print(f"An error occurred while generating documentation: {e}", file=sys.stderr)
+        sys.exit(1)
+
+    try:
+        with open(args.out, 'w', encoding='utf-8') as f:
+            f.write(markdown)
+        print(f"Documentation generated and saved to '{args.out}'")
+    except IOError as e:
+        print(f"Error writing to output file {args.out}: {e}", file=sys.stderr)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

src2md-0.1.0/src2md/utils.py

@@ -0,0 +1,255 @@
+import os
+from pathlib import Path
+import pypandoc
+import sys
+import fnmatch
+import pathspec
+
+default_langs = {
+    '.py': 'python',
+    '.cpp': 'cpp',
+    '.cxx': 'cpp',
+    '.cc': 'cpp',
+    '.c': 'c',
+    '.js': 'javascript',
+    '.java': 'java',
+    '.ts': 'typescript',
+    '.go': 'go',
+    '.rb': 'ruby',
+    '.php': 'php',
+    '.swift': 'swift',
+    '.kt': 'kotlin',
+    '.rs': 'rust',
+    '.lark': 'lark',
+    '.sh': 'bash',
+    '.bash': 'bash',
+    '.bat': 'batch',
+    '.sql': 'sql',
+    '.html': 'html',
+    '.css': 'css',
+    '.json': 'json',
+    '.xml': 'xml',
+    '.yaml': 'yaml',
+    '.yml': 'yaml',
+    '.md': 'markdown',
+    '.rst': 'markdown'
+}
+
+def convert_rst_to_md(rst_content):
+    """
+    Convert reStructuredText content to Markdown using pypandoc.
+
+    Args:
+        rst_content (str): Content in reStructuredText format.
+
+    Returns:
+        str: Converted Markdown content.
+    """
+    try:
+        md_content = pypandoc.convert_text(rst_content, 'md', format='rst')
+        return md_content
+    except (RuntimeError, OSError) as e:
+        print(f"Error converting RST to MD: {e}", file=sys.stderr)
+        return rst_content  # Fallback to original content if conversion fails
+
+def find_documentation_files(source_path, doc_patterns, already_included=None):
+    """
+    Find documentation files within the source directory based on patterns.
+
+    Args:
+        source_path (Path): Path to the source directory.
+        doc_patterns (list): List of documentation file patterns.
+        already_included (set): Set of already included documentation files.
+
+    Returns:
+        list: List of documentation file paths.
+    """
+    doc_files = []
+    for root, dirs, files in os.walk(source_path):
+        dirs[:] = [d for d in dirs if not d.startswith('.')]
+
+        for file in files:
+            if file.startswith('.'):
+                continue  # Skip hidden files
+            file_path = Path(root) / file
+            relative_path = file_path.relative_to(source_path)
+            rel_path_str = str(relative_path)
+            for pattern in doc_patterns:
+                if fnmatch.fnmatch(file.lower(), pattern.lower()):
+                    if already_included and rel_path_str in already_included:
+                        continue  # Skip if already included
+                    doc_files.append(file_path)
+                    if already_included is not None:
+                        already_included.add(rel_path_str)
+                    break  # Stop checking other patterns once matched
+    return doc_files
+
+
+def include_documentation_files(source_path, markdown_content, doc_patterns):
+    """
+    Include documentation files into the markdown content, prioritizing README.*.
+
+    Args:
+        source_path (Path): Path to the source directory.
+        markdown_content (list): List to append markdown content to.
+        doc_patterns (list): List of documentation file patterns.
+    """
+    # Prioritize README.* files
+    prioritized_patterns = ['README.*']
+    other_patterns = [pattern for pattern in doc_patterns if pattern not in prioritized_patterns]
+
+    already_included = set()
+    prioritized_docs = find_documentation_files(source_path, prioritized_patterns, already_included)
+    other_docs = find_documentation_files(source_path, other_patterns, already_included)
+
+    # Combine with prioritized docs first
+    doc_files = prioritized_docs + other_docs
+
+    if not doc_files:
+        return
+
+    markdown_content.append("## Documentation Files\n")
+    markdown_content.append("\n")
+
+    for doc_file in doc_files:
+        rel_path = doc_file.relative_to(source_path)
+        markdown_content.append(f"### {rel_path}\n")
+        markdown_content.append("\n")
+
+        try:
+            with open(doc_file, 'r', encoding='utf-8') as f:
+                content = f.read()
+        except (IOError, UnicodeDecodeError) as e:
+            print(f"Error reading documentation file {doc_file}: {e}", file=sys.stderr)
+            content = f"Error reading file: {e}"
+
+        # Convert to Markdown if .rst
+        if doc_file.suffix.lower() == '.rst':
+            content = convert_rst_to_md(content)
+
+        markdown_content.append(content)
+        markdown_content.append("\n---\n\n")
+
+
+def get_language_identifier(file_extension):
+    """
+    Map file extension to language identifier for syntax highlighting in Markdown.
+
+    Args:
+        file_extension (str): File extension (e.g., '.py').
+
+    Returns:
+        str: Language identifier (e.g., 'python').
+    """
+
+    return default_langs.get(file_extension.lower(), '')
+
+
+def generate_markdown(path, doc_pat=None, src_pat=None, ignore_pat=None):
+    """
+    Generate Markdown content from the source directory.
+
+    Args:
+        source_path (Path): Path to the source directory.
+        doc_patterns (list): List of documentation file patterns.
+        src_patterns (list): List of source file patterns.
+        ignore_patterns (list): List of patterns to ignore.
+
+    Returns:
+        str: Complete Markdown content.
+    """
+    markdown_content = []
+    path = Path(path)
+
+    # Add project name as title
+    markdown_content.append(f"# Project: {path.name}\n\n")
+
+    # Define default documentation patterns
+    if doc_pat is None:
+        doc_pat = ['*.md', '*.rst']
+
+    # Include documentation files like README.md, README.rst, etc.
+    include_documentation_files(path, markdown_content, doc_pat)
+
+    # Collect documentation file paths to exclude them from source files
+    doc_files = find_documentation_files(path, doc_pat)
+    doc_file_paths = set(str(p.relative_to(path)) for p in doc_files)
+
+    # Traverse the directory
+    for root, dirs, files in os.walk(path):
+        # Modify dirs in-place to exclude hidden directories
+        dirs[:] = [d for d in dirs if not any(fnmatch.fnmatch(d, pattern) for pattern in ignore_pat)]
+
+        # Compute relative path from source_path
+        rel_dir = Path(root).relative_to(path)
+        # Determine heading level based on directory depth
+        if rel_dir == Path('.'):
+            heading_level = 2  # ## for top-level
+        else:
+            heading_level = 2 + len(rel_dir.parts)  # Increase heading level based on depth
+
+        # Add directory heading
+        if rel_dir != Path('.'):
+            markdown_content.append(f"{'#' * heading_level} Directory: `{rel_dir}`\n\n")
+
+        for file in sorted(files):
+            #if file.startswith('.'):
+            #    continue  # Skip hidden files
+            file_path = Path(root) / file
+            rel_path = file_path.relative_to(path)
+            rel_path_str = str(rel_path)
+
+            if any(fnmatch.fnmatch(file, pattern) for pattern in ignore_pat):
+                continue  # Skip this file
+
+            if rel_path_str in doc_file_paths:
+                continue  # Skip documentation files
+
+            # Check if the file matches any source pattern
+            if not any(fnmatch.fnmatch(file, pattern) for pattern in src_pat):
+                continue
+
+            try:
+                with open(file_path, 'r', encoding='utf-8') as f:
+                    source_code = f.read()
+            except (IOError, UnicodeDecodeError) as e:
+                print(f"Error reading source file {file_path}: {e}", file=sys.stderr)
+                continue
+
+            # Determine language identifier
+            lang = get_language_identifier(file_path.suffix)
+
+            # Add source file section
+            markdown_content.append(f"### Source File: `{rel_path}`\n\n")
+
+            # Include source code
+            markdown_content.append("#### Source Code\n")
+            markdown_content.append("\n```")
+            markdown_content.append(f"{lang}\n")
+            markdown_content.append(f"{source_code}\n")
+            markdown_content.append("```\n\n")
+
+            markdown_content.append("---\n\n")
+
+    return ''.join(markdown_content)
+
+def load_ignore_file(path):
+    """
+    Load patterns to ignore from a file. A reasonable default is
+    to ignore hidden files and directories. One could also copy
+    .gitignore or .dockerignore to .src2mdignore.
+
+    Args:
+        path (Path): Path to the ignore file.
+
+    Returns:
+        list: List of patterns to ignore
+    """
+    pats = []
+    if os.path.exists(path):
+        with open(path, 'r', encoding='utf-8') as f:
+            for line in f:
+                line = line.strip()
+                if line and not line.startswith("#"):
+                    pats.append(line)
+    return pats

src2md-0.1.0/src2md.egg-info/PKG-INFO

@@ -0,0 +1,128 @@
+Metadata-Version: 2.2
+Name: src2md
+Version: 0.1.0
+Summary: A tool to convert source code directories into Markdown documentation.
+Home-page: https://github.com/queelius/src2md
+Author: Alex Towell
+Author-email: lex@example.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pypandoc
+Requires-Dist: pathspec
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# src2md
+
+![License](https://img.shields.io/badge/license-MIT-blue.svg)
+![PyPI](https://img.shields.io/pypi/v/src2md)
+![Python Versions](https://img.shields.io/pypi/pyversions/src2md)
+
+**src2md** is a versatile tool that converts source code directories into comprehensive Markdown documentation. It scans your project structure, includes documentation files like `README.md` or `README.rst`, and embeds source code snippets with proper syntax highlighting. Ideal for generating project overviews, documentation for large codebases, or providing context to language models.
+
+## 🚀 **Features**
+
+- **Automatic Documentation Aggregation**: Collects and prioritizes documentation files (e.g., `README.md`, `README.rst`).
+- **Syntax-Highlighted Source Code**: Embeds source code files with appropriate language identifiers for Markdown.
+- **Flexible File Patterns**: Customize which files to include as documentation or source code using patterns.
+- **Ignore Hidden Files and Directories**: Automatically excludes hidden files and directories (those starting with `.`).
+- **Leverages `.gitignore`**: Respects your `.gitignore` settings to exclude unwanted files.
+- **Simple CLI Interface**: Easy-to-use command-line interface for generating documentation.
+
+## 📦 **Installation**
+
+You can install `src2md` via [PyPI](https://pypi.org/) using `pip`:
+
+```bash
+pip install src2md
+```
+
+Alternatively, install it directly from the source:
+
+```bash
+git clone https://github.com/yourusername/src2md.git
+cd src2md
+pip install .
+```
+
+## 🛠️  Usage
+Once installed, you can use src2md from the command line to generate Markdown documentation for your project.
+
+### Basic Command
+
+```bash
+src2md path/to/source -o output.md
+```
+
+- `path/to/source`: Path to your project's root directory.
+- `-o output.md`: (Optional) Specifies the output Markdown file name. Defaults to project_documentation.md.
+
+## Advanced Options
+
+- **Specify Documentation Patterns**
+
+  Include additional documentation file types.
+
+  ```bash
+  src2md path/to/source -o output.md --doc-patterns '*.md' '*.rst' '*.lark'
+  ```
+
+- **Specify Source Code Patterns**
+
+  Customize which source files to include. Use '*' to include all files.
+
+  ```bash
+  src2md path/to/source -o output.md --src-patterns '*.py' '*.js'
+  ```
+
+  To include all files as source code:
+
+  ```bash
+  src2md path/to/source -o output.md --src-patterns '*'
+  ```
+
+- **Add Additional Ignore Patterns**
+
+  Exclude specific files or directories.
+
+  ```bash
+  src2md path/to/source -o output.md --ignore-patterns '*.pyc' 'build/' 'dist/'
+  ```
+
+- **Use a Custom Ignore File**
+
+  Specify a custom ignore file.
+
+  ```bash
+  src2md path/to/source -o output.md --ignore-file .src2mdignore
+  ```
+
+- **Disable .gitignore Usage**
+
+  Do not use .gitignore for ignoring files.
+
+  ```bash
+  src2md path/to/source -o output.md --no-use-gitignore
+  ```
+
+## Full Example
+
+```bash
+src2md ./my_project -o my_project_docs.md \
+    --doc-patterns '*.md' '*.rst' '*.lark' \
+    --src-patterns '*.py' '*.cpp' '*.js' \
+    --ignore-patterns '*.pyc' 'build/' 'dist/'
+```
+
+This command generates my_project_docs.md by including all .md, .rst, and .lark documentation files, embedding .py, .cpp, and .js source files, and excluding any .pyc files and directories named build or dist.

src2md-0.1.0/src2md.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+LICENSE
+README.md
+setup.py
+src2md/__init__.py
+src2md/cli.py
+src2md/utils.py
+src2md.egg-info/PKG-INFO
+src2md.egg-info/SOURCES.txt
+src2md.egg-info/dependency_links.txt
+src2md.egg-info/entry_points.txt
+src2md.egg-info/requires.txt
+src2md.egg-info/top_level.txt

src2md-0.1.0/src2md.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

src2md-0.1.0/src2md.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+src2md = src2md.cli:main

src2md-0.1.0/src2md.egg-info/requires.txt

@@ -0,0 +1,2 @@
+pypandoc
+pathspec

src2md-0.1.0/src2md.egg-info/top_level.txt

@@ -0,0 +1 @@
+src2md