codetoprompt 0.1.0__tar.gz

codetoprompt-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Yash Bhaskar
+
+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. 

codetoprompt-0.1.0/MANIFEST.in

@@ -0,0 +1,3 @@
+include README.md
+include LICENSE
+include pyproject.toml 

codetoprompt-0.1.0/PKG-INFO

@@ -0,0 +1,111 @@
+Metadata-Version: 2.4
+Name: codetoprompt
+Version: 0.1.0
+Summary: Convert your codebase into a single LLM prompt
+Author-email: Yash Bhaskar <yash9439@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/yash9439/codetoprompt
+Project-URL: Documentation, https://github.com/yash9439/codetoprompt#readme
+Project-URL: Repository, https://github.com/yash9439/codetoprompt
+Project-URL: Issues, https://github.com/yash9439/codetoprompt/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Operating System :: OS Independent
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Software Development :: Version Control :: Git
+Classifier: Topic :: Text Processing :: General
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pygit2>=1.12.0
+Requires-Dist: tiktoken>=0.5.0
+Requires-Dist: pyperclip>=1.8.2
+Requires-Dist: jinja2>=3.1.0
+Requires-Dist: pathspec>=0.11.0
+Requires-Dist: rich>=13.0.0
+Requires-Dist: typing-extensions>=4.0.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: black>=23.0.0; extra == "dev"
+Requires-Dist: isort>=5.0.0; extra == "dev"
+Requires-Dist: mypy>=1.0.0; extra == "dev"
+Requires-Dist: flake8>=6.0.0; extra == "dev"
+Dynamic: license-file
+
+# CodeToPrompt
+
+Convert your codebase into a single LLM prompt!
+
+## Installation
+
+```bash
+# Install the Python package
+pip install codetoprompt
+
+# System Dependencies
+# For clipboard support on Linux:
+# - X11: Install xclip
+#   sudo apt-get install xclip  # Debian/Ubuntu
+#   sudo dnf install xclip      # Fedora
+#   sudo pacman -S xclip        # Arch Linux
+# - Wayland: Install wl-clipboard
+#   sudo apt-get install wl-clipboard  # Debian/Ubuntu
+#   sudo dnf install wl-clipboard      # Fedora
+#   sudo pacman -S wl-clipboard        # Arch Linux
+```
+
+## Quick Start
+
+```bash
+# Basic usage
+codetoprompt /path/to/your/codebase
+
+# Save to file
+codetoprompt /path/to/your/codebase --output prompt.txt
+
+# Include specific file patterns
+codetoprompt /path/to/your/codebase --include "*.py,*.js"
+
+# Exclude specific file patterns
+codetoprompt /path/to/your/codebase --exclude "*.pyc,__pycache__"
+```
+
+## Features
+
+- **Automatic Code Processing**: Convert codebases of any size into readable, formatted prompts
+- **Smart Filtering**: Include/exclude files using glob patterns and respect `.gitignore` rules
+- **Flexible Templating**: Customize prompts with Jinja2 templates for different use cases
+- **Token Tracking**: Track token usage to stay within LLM context limits
+- **Git Integration**: Include diffs, logs, and branch comparisons in your prompts
+- **Developer Experience**: Automatic clipboard copy, line numbers, and file organization options
+
+## Python API
+
+```python
+from codetoprompt import CodeToPrompt
+
+# Initialize the processor
+processor = CodeToPrompt(
+    root_dir="/path/to/your/codebase",
+    include_patterns=["*.py", "*.js"],
+    exclude_patterns=["*.pyc", "__pycache__"]
+)
+
+# Generate the prompt
+prompt = processor.generate_prompt()
+
+# Save to file
+processor.save_to_file("prompt.txt")
+
+# Get token count
+token_count = processor.get_token_count()
+```
+
+## License
+
+MIT License - see LICENSE file for details 

codetoprompt-0.1.0/README.md

@@ -0,0 +1,72 @@
+# CodeToPrompt
+
+Convert your codebase into a single LLM prompt!
+
+## Installation
+
+```bash
+# Install the Python package
+pip install codetoprompt
+
+# System Dependencies
+# For clipboard support on Linux:
+# - X11: Install xclip
+#   sudo apt-get install xclip  # Debian/Ubuntu
+#   sudo dnf install xclip      # Fedora
+#   sudo pacman -S xclip        # Arch Linux
+# - Wayland: Install wl-clipboard
+#   sudo apt-get install wl-clipboard  # Debian/Ubuntu
+#   sudo dnf install wl-clipboard      # Fedora
+#   sudo pacman -S wl-clipboard        # Arch Linux
+```
+
+## Quick Start
+
+```bash
+# Basic usage
+codetoprompt /path/to/your/codebase
+
+# Save to file
+codetoprompt /path/to/your/codebase --output prompt.txt
+
+# Include specific file patterns
+codetoprompt /path/to/your/codebase --include "*.py,*.js"
+
+# Exclude specific file patterns
+codetoprompt /path/to/your/codebase --exclude "*.pyc,__pycache__"
+```
+
+## Features
+
+- **Automatic Code Processing**: Convert codebases of any size into readable, formatted prompts
+- **Smart Filtering**: Include/exclude files using glob patterns and respect `.gitignore` rules
+- **Flexible Templating**: Customize prompts with Jinja2 templates for different use cases
+- **Token Tracking**: Track token usage to stay within LLM context limits
+- **Git Integration**: Include diffs, logs, and branch comparisons in your prompts
+- **Developer Experience**: Automatic clipboard copy, line numbers, and file organization options
+
+## Python API
+
+```python
+from codetoprompt import CodeToPrompt
+
+# Initialize the processor
+processor = CodeToPrompt(
+    root_dir="/path/to/your/codebase",
+    include_patterns=["*.py", "*.js"],
+    exclude_patterns=["*.pyc", "__pycache__"]
+)
+
+# Generate the prompt
+prompt = processor.generate_prompt()
+
+# Save to file
+processor.save_to_file("prompt.txt")
+
+# Get token count
+token_count = processor.get_token_count()
+```
+
+## License
+
+MIT License - see LICENSE file for details 

codetoprompt-0.1.0/codetoprompt/__init__.py

@@ -0,0 +1,4 @@
+from .core import CodeToPrompt
+from .version import __version__
+
+__all__ = ['CodeToPrompt', '__version__'] 

codetoprompt-0.1.0/codetoprompt/cli.py

@@ -0,0 +1,119 @@
+import argparse
+from pathlib import Path
+from rich.console import Console
+from rich.panel import Panel
+from rich.progress import Progress, SpinnerColumn, TextColumn, BarColumn, TimeElapsedColumn
+from rich import print as rprint
+from .core import CodeToPrompt
+
+def main():
+    parser = argparse.ArgumentParser(description="Convert your codebase into a single LLM prompt")
+    parser.add_argument("root_dir", help="Root directory of the codebase")
+    parser.add_argument("--output", "-o", help="Output file path")
+    parser.add_argument("--include", "-i", help="Comma-separated list of file patterns to include")
+    parser.add_argument("--exclude", "-e", help="Comma-separated list of file patterns to exclude")
+    parser.add_argument("--no-gitignore", action="store_true", help="Don't respect .gitignore rules")
+    parser.add_argument("--no-line-numbers", action="store_true", help="Don't show line numbers")
+    parser.add_argument("--max-tokens", type=int, help="Maximum number of tokens in the prompt")
+    parser.add_argument("--no-copy", action="store_true", help="Don't copy prompt to clipboard")
+    
+    args = parser.parse_args()
+    console = Console()
+    
+    try:
+        # Validate root directory
+        root_dir = Path(args.root_dir)
+        if not root_dir.exists():
+            console.print(f"[red]Error: Directory '{args.root_dir}' does not exist[/red]")
+            return 1
+        if not root_dir.is_dir():
+            console.print(f"[red]Error: '{args.root_dir}' is not a directory[/red]")
+            return 1
+            
+        # Process include/exclude patterns
+        include_patterns = args.include.split(",") if args.include else None
+        exclude_patterns = args.exclude.split(",") if args.exclude else None
+        
+        # Print configuration
+        console.print(Panel.fit(
+            f"[bold]Configuration:[/bold]\n"
+            f"Root Directory: {root_dir}\n"
+            f"Include Patterns: {include_patterns or ['*']}\n"
+            f"Exclude Patterns: {exclude_patterns or []}\n"
+            f"Respect .gitignore: {not args.no_gitignore}\n"
+            f"Show Line Numbers: {not args.no_line_numbers}\n"
+            f"Max Tokens: {args.max_tokens or 'Unlimited'}\n"
+            f"Copy to Clipboard: {not args.no_copy}",
+            title="CodeToPrompt",
+            border_style="blue"
+        ))
+        
+        # Initialize processor
+        processor = CodeToPrompt(
+            root_dir=str(root_dir),
+            include_patterns=include_patterns,
+            exclude_patterns=exclude_patterns,
+            respect_gitignore=not args.no_gitignore,
+            show_line_numbers=not args.no_line_numbers,
+            max_tokens=args.max_tokens
+        )
+        
+        # Check clipboard requirements before starting progress bars
+        clipboard_success = False
+        if not args.no_copy:
+            clipboard_success = processor.copy_to_clipboard()
+        
+        with Progress(
+            SpinnerColumn(),
+            TextColumn("[progress.description]{task.description}"),
+            BarColumn(),
+            TimeElapsedColumn(),
+            console=console,
+        ) as progress:
+            # Add all tasks upfront
+            git_task = progress.add_task("Getting git information...", total=None)
+            tree_task = progress.add_task("Building file tree...", total=None)
+            files_task = progress.add_task("Finding files...", total=None)
+            process_task = progress.add_task("Processing files...", total=None)
+            save_task = progress.add_task("Saving to file...", total=None) if args.output else None
+            
+            # Generate prompt
+            prompt = processor.generate_prompt()
+            
+            # Update progress for completed tasks
+            progress.update(git_task, completed=True)
+            progress.update(tree_task, completed=True)
+            progress.update(files_task, completed=True)
+            progress.update(process_task, completed=True)
+            
+            # # Print the generated prompt to the console
+            # console.print("\n[bold]Generated Prompt:[/bold]\n")
+            # console.print(prompt)
+            
+            # Save to file if specified
+            if args.output:
+                processor.save_to_file(args.output)
+                progress.update(save_task, completed=True)
+                console.print(f"[green]✓ Prompt saved to {args.output}[/green]")
+            
+        # Print summary
+        console.print(Panel.fit(
+            f"[bold]Summary:[/bold]\n"
+            f"Total Tokens: {len(processor.tokenizer.encode(prompt)):,}\n"
+            f"Output File: {args.output or 'None'}\n"
+            f"Copied to Clipboard: {'Yes' if clipboard_success else 'No'}",
+            title="Processing Complete",
+            border_style="green"
+        ))
+        
+    except KeyboardInterrupt:
+        console.print("\n[yellow]Operation cancelled by user[/yellow]")
+        return 1
+    except Exception as e:
+        console.print(f"[red]Error: {str(e)}[/red]")
+        return 1
+        
+    return 0
+
+if __name__ == "__main__":
+    exit(main()) 

codetoprompt-0.1.0/codetoprompt/core.py

@@ -0,0 +1,210 @@
+import os
+import pygit2
+import tiktoken
+import pyperclip
+from pathlib import Path
+from typing import List, Optional, Set
+from pathspec import PathSpec
+from pathspec.patterns import GitWildMatchPattern
+from rich.console import Console
+from rich.tree import Tree
+from rich.progress import Progress, SpinnerColumn, TextColumn, BarColumn, TimeElapsedColumn
+from concurrent.futures import ThreadPoolExecutor
+import threading
+import platform
+import subprocess
+
+class CodeToPrompt:
+    def __init__(
+        self,
+        root_dir: str,
+        include_patterns: Optional[List[str]] = None,
+        exclude_patterns: Optional[List[str]] = None,
+        respect_gitignore: bool = True,
+        show_line_numbers: bool = True,
+        max_tokens: Optional[int] = None,
+    ):
+        self.root_dir = Path(root_dir).resolve()
+        self.include_patterns = include_patterns or ["*"]
+        self.exclude_patterns = exclude_patterns or []
+        self.respect_gitignore = respect_gitignore
+        self.show_line_numbers = show_line_numbers
+        self.max_tokens = max_tokens
+        self.console = Console()
+        
+        # Initialize git repository if exists
+        try:
+            self.repo = pygit2.Repository(str(self.root_dir))
+        except pygit2.GitError:
+            self.repo = None
+            
+        # Initialize tokenizer
+        self.tokenizer = tiktoken.get_encoding("cl100k_base")
+        
+        # Initialize pathspec for gitignore
+        if self.respect_gitignore and self.repo:
+            gitignore_path = self.root_dir / ".gitignore"
+            if gitignore_path.exists():
+                with open(gitignore_path) as f:
+                    self.gitignore = PathSpec.from_lines(GitWildMatchPattern, f)
+            else:
+                self.gitignore = None
+        else:
+            self.gitignore = None
+
+    def _check_clipboard_requirements(self) -> bool:
+        """Check if clipboard requirements are met."""
+        if platform.system() == "Linux":
+            try:
+                # Check if xclip is installed
+                subprocess.run(["which", "xclip"], check=True, capture_output=True)
+                return True
+            except subprocess.CalledProcessError:
+                self.console.print("\n[yellow]⚠️  Clipboard functionality is disabled because xclip is not installed.[/yellow]")
+                self.console.print("\n[yellow]To enable clipboard support, run this command:[/yellow]")
+                self.console.print("\n[bold cyan]sudo apt-get install xclip[/bold cyan]")
+                self.console.print("\n[yellow]After installing xclip, run codetoprompt again to use clipboard functionality.[/yellow]\n")
+                return False
+        return True
+
+    def _should_include_file(self, file_path: Path) -> bool:
+        """Check if a file should be included based on patterns and gitignore."""
+        rel_path = file_path.relative_to(self.root_dir)
+        
+        # Check include patterns
+        if not any(rel_path.match(pattern) for pattern in self.include_patterns):
+            return False
+            
+        # Check exclude patterns
+        if any(rel_path.match(pattern) for pattern in self.exclude_patterns):
+            return False
+            
+        # Check gitignore
+        if self.gitignore and self.gitignore.match_file(str(rel_path)):
+            return False
+            
+        return True
+
+    def _get_file_content(self, file_path: Path) -> str:
+        """Read and format file content with optional line numbers."""
+        try:
+            with open(file_path, 'r', encoding='utf-8') as f:
+                content = f.read()
+                
+            if self.show_line_numbers:
+                lines = content.splitlines()
+                numbered_lines = [f"{i+1:4d} | {line}" for i, line in enumerate(lines)]
+                return "\n".join(numbered_lines)
+            return content
+        except Exception as e:
+            return f"Error reading file: {str(e)}"
+
+    def _get_git_info(self) -> str:
+        """Get git repository information."""
+        if not self.repo:
+            return ""
+            
+        info = []
+        try:
+            head = self.repo.head
+            info.append(f"Current branch: {head.name}")
+            info.append(f"Latest commit: {head.target.hex}")
+            info.append(f"Author: {head.peel().author.name} <{head.peel().author.email}>")
+            info.append(f"Date: {head.peel().author.time}")
+            info.append(f"Message: {head.peel().message.strip()}")
+        except Exception as e:
+            info.append(f"Error getting git info: {str(e)}")
+            
+        return "\n".join(info)
+
+    def _process_file(self, file_path: Path) -> tuple:
+        """Process a single file and return its content."""
+        rel_path = file_path.relative_to(self.root_dir)
+        content = self._get_file_content(file_path)
+        return (rel_path, content)
+
+    def generate_prompt(self, progress: Optional[Progress] = None) -> str:
+        """Generate the prompt from the codebase."""
+        prompt_parts = []
+        
+        # Add git information if available
+        git_info = self._get_git_info()
+        if git_info:
+            prompt_parts.append("=== Git Repository Information ===")
+            prompt_parts.append(git_info)
+            prompt_parts.append("")
+            
+        # Add file tree
+        prompt_parts.append("=== File Structure ===")
+        tree = Tree("📁 " + str(self.root_dir.name))
+        self._build_tree(self.root_dir, tree)
+        # Convert tree to string using rich's console
+        console = Console(width=100)  # Set a reasonable width
+        with console.capture() as capture:
+            console.print(tree)
+        prompt_parts.append(capture.get())
+        prompt_parts.append("")
+            
+        # Get all files
+        files = list(self._get_files())
+            
+        # Process files in parallel
+        prompt_parts.append("=== File Contents ===")
+            
+        with ThreadPoolExecutor() as executor:
+            for rel_path, content in executor.map(self._process_file, files):
+                prompt_parts.append(f"\n=== {rel_path} ===")
+                prompt_parts.append(content)
+            
+        prompt = "\n".join(prompt_parts)
+        
+        # Check token limit
+        if self.max_tokens:
+            tokens = self.tokenizer.encode(prompt)
+            if len(tokens) > self.max_tokens:
+                self.console.print(f"[yellow]Warning: Prompt exceeds {self.max_tokens} tokens[/yellow]")
+                
+        return prompt
+
+    def _build_tree(self, path: Path, tree: Tree) -> None:
+        """Build a tree representation of the codebase."""
+        for item in sorted(path.iterdir()):
+            if item.is_dir():
+                if self._should_include_file(item):
+                    branch = tree.add(f"📁 {item.name}")
+                    self._build_tree(item, branch)
+            else:
+                if self._should_include_file(item):
+                    tree.add(f"📄 {item.name}")
+
+    def _get_files(self) -> Set[Path]:
+        """Get all files that should be included in the prompt."""
+        files = set()
+        for pattern in self.include_patterns:
+            files.update(self.root_dir.glob(f"**/{pattern}"))
+        return {f for f in files if f.is_file() and self._should_include_file(f)}
+
+    def save_to_file(self, output_path: str) -> None:
+        """Save the generated prompt to a file."""
+        prompt = self.generate_prompt()
+        with open(output_path, 'w', encoding='utf-8') as f:
+            f.write(prompt)
+
+    def copy_to_clipboard(self) -> bool:
+        """Copy the generated prompt to clipboard. Returns True if successful."""
+        # Check clipboard requirements first, before any progress bars
+        if not self._check_clipboard_requirements():
+            return False
+            
+        prompt = self.generate_prompt()
+        try:
+            pyperclip.copy(prompt)
+            return True
+        except Exception as e:
+            self.console.print(f"[red]Error copying to clipboard: {str(e)}[/red]")
+            return False
+
+    def get_token_count(self) -> int:
+        """Get the number of tokens in the generated prompt."""
+        prompt = self.generate_prompt()
+        return len(self.tokenizer.encode(prompt)) 

codetoprompt-0.1.0/codetoprompt/version.py

@@ -0,0 +1 @@
+__version__ = "0.1.0" 

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

@@ -0,0 +1,111 @@
+Metadata-Version: 2.4
+Name: codetoprompt
+Version: 0.1.0
+Summary: Convert your codebase into a single LLM prompt
+Author-email: Yash Bhaskar <yash9439@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/yash9439/codetoprompt
+Project-URL: Documentation, https://github.com/yash9439/codetoprompt#readme
+Project-URL: Repository, https://github.com/yash9439/codetoprompt
+Project-URL: Issues, https://github.com/yash9439/codetoprompt/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Operating System :: OS Independent
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Software Development :: Version Control :: Git
+Classifier: Topic :: Text Processing :: General
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pygit2>=1.12.0
+Requires-Dist: tiktoken>=0.5.0
+Requires-Dist: pyperclip>=1.8.2
+Requires-Dist: jinja2>=3.1.0
+Requires-Dist: pathspec>=0.11.0
+Requires-Dist: rich>=13.0.0
+Requires-Dist: typing-extensions>=4.0.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: black>=23.0.0; extra == "dev"
+Requires-Dist: isort>=5.0.0; extra == "dev"
+Requires-Dist: mypy>=1.0.0; extra == "dev"
+Requires-Dist: flake8>=6.0.0; extra == "dev"
+Dynamic: license-file
+
+# CodeToPrompt
+
+Convert your codebase into a single LLM prompt!
+
+## Installation
+
+```bash
+# Install the Python package
+pip install codetoprompt
+
+# System Dependencies
+# For clipboard support on Linux:
+# - X11: Install xclip
+#   sudo apt-get install xclip  # Debian/Ubuntu
+#   sudo dnf install xclip      # Fedora
+#   sudo pacman -S xclip        # Arch Linux
+# - Wayland: Install wl-clipboard
+#   sudo apt-get install wl-clipboard  # Debian/Ubuntu
+#   sudo dnf install wl-clipboard      # Fedora
+#   sudo pacman -S wl-clipboard        # Arch Linux
+```
+
+## Quick Start
+
+```bash
+# Basic usage
+codetoprompt /path/to/your/codebase
+
+# Save to file
+codetoprompt /path/to/your/codebase --output prompt.txt
+
+# Include specific file patterns
+codetoprompt /path/to/your/codebase --include "*.py,*.js"
+
+# Exclude specific file patterns
+codetoprompt /path/to/your/codebase --exclude "*.pyc,__pycache__"
+```
+
+## Features
+
+- **Automatic Code Processing**: Convert codebases of any size into readable, formatted prompts
+- **Smart Filtering**: Include/exclude files using glob patterns and respect `.gitignore` rules
+- **Flexible Templating**: Customize prompts with Jinja2 templates for different use cases
+- **Token Tracking**: Track token usage to stay within LLM context limits
+- **Git Integration**: Include diffs, logs, and branch comparisons in your prompts
+- **Developer Experience**: Automatic clipboard copy, line numbers, and file organization options
+
+## Python API
+
+```python
+from codetoprompt import CodeToPrompt
+
+# Initialize the processor
+processor = CodeToPrompt(
+    root_dir="/path/to/your/codebase",
+    include_patterns=["*.py", "*.js"],
+    exclude_patterns=["*.pyc", "__pycache__"]
+)
+
+# Generate the prompt
+prompt = processor.generate_prompt()
+
+# Save to file
+processor.save_to_file("prompt.txt")
+
+# Get token count
+token_count = processor.get_token_count()
+```
+
+## License
+
+MIT License - see LICENSE file for details 

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

@@ -0,0 +1,16 @@
+LICENSE
+MANIFEST.in
+README.md
+pyproject.toml
+codetoprompt/__init__.py
+codetoprompt/cli.py
+codetoprompt/core.py
+codetoprompt/version.py
+codetoprompt.egg-info/PKG-INFO
+codetoprompt.egg-info/SOURCES.txt
+codetoprompt.egg-info/dependency_links.txt
+codetoprompt.egg-info/entry_points.txt
+codetoprompt.egg-info/requires.txt
+codetoprompt.egg-info/top_level.txt
+tests/test_cli.py
+tests/test_core.py

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

@@ -0,0 +1 @@
+

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

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

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

@@ -0,0 +1,14 @@
+pygit2>=1.12.0
+tiktoken>=0.5.0
+pyperclip>=1.8.2
+jinja2>=3.1.0
+pathspec>=0.11.0
+rich>=13.0.0
+typing-extensions>=4.0.0
+
+[dev]
+pytest>=7.0.0
+black>=23.0.0
+isort>=5.0.0
+mypy>=1.0.0
+flake8>=6.0.0

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

@@ -0,0 +1 @@
+codetoprompt

codetoprompt-0.1.0/pyproject.toml

@@ -0,0 +1,54 @@
+[build-system]
+requires = ["setuptools>=65.0.0", "wheel>=0.40.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "codetoprompt"
+version = "0.1.0"
+description = "Convert your codebase into a single LLM prompt"
+readme = "README.md"
+requires-python = ">=3.8"
+license = "MIT"
+authors = [
+    { name = "Yash Bhaskar", email = "yash9439@gmail.com" }
+]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Operating System :: OS Independent",
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Topic :: Software Development :: Version Control :: Git",
+    "Topic :: Text Processing :: General",
+]
+dependencies = [
+    "pygit2>=1.12.0",
+    "tiktoken>=0.5.0",
+    "pyperclip>=1.8.2",
+    "jinja2>=3.1.0",
+    "pathspec>=0.11.0",
+    "rich>=13.0.0",
+    "typing-extensions>=4.0.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.0.0",
+    "black>=23.0.0",
+    "isort>=5.0.0",
+    "mypy>=1.0.0",
+    "flake8>=6.0.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/yash9439/codetoprompt"
+Documentation = "https://github.com/yash9439/codetoprompt#readme"
+Repository = "https://github.com/yash9439/codetoprompt"
+Issues = "https://github.com/yash9439/codetoprompt/issues"
+
+[project.scripts]
+codetoprompt = "codetoprompt.cli:main" 

codetoprompt-0.1.0/setup.cfg

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

codetoprompt-0.1.0/tests/test_cli.py

@@ -0,0 +1,94 @@
+"""Tests for the CLI functionality of codetoprompt."""
+import os
+import tempfile
+from pathlib import Path
+
+import pytest
+from codetoprompt.cli import main
+
+@pytest.fixture
+def temp_dir():
+    """Create a temporary directory with some test files."""
+    with tempfile.TemporaryDirectory() as tmpdir:
+        # Create some test files
+        test_dir = Path(tmpdir)
+        (test_dir / "test1.py").write_text("print('hello')\n")
+        (test_dir / "test2.py").write_text("def test():\n    pass\n")
+        (test_dir / "test3.txt").write_text("Some text\n")
+        yield test_dir
+
+def test_cli_basic_usage(temp_dir, capsys):
+    """Test basic CLI usage."""
+    # Mock sys.argv
+    import sys
+    sys.argv = ["codetoprompt", str(temp_dir)]
+    
+    # Run CLI
+    result = main()
+    assert result == 0
+    
+    # Check output
+    captured = capsys.readouterr()
+    assert "Configuration" in captured.out
+    assert "Processing Complete" in captured.out
+    assert "Total Tokens" in captured.out
+
+def test_cli_with_output(temp_dir, capsys):
+    """Test CLI with output file."""
+    output_file = temp_dir / "output.txt"
+    
+    # Mock sys.argv
+    import sys
+    sys.argv = ["codetoprompt", str(temp_dir), "--output", str(output_file)]
+    
+    # Run CLI
+    result = main()
+    assert result == 0
+    
+    # Check output file
+    assert output_file.exists()
+    content = output_file.read_text()
+    assert "test1.py" in content
+    assert "test2.py" in content
+
+def test_cli_with_patterns(temp_dir, capsys):
+    """Test CLI with include/exclude patterns."""
+    # Mock sys.argv
+    import sys
+    sys.argv = [
+        "codetoprompt",
+        str(temp_dir),
+        "--include", "*.py",
+        "--exclude", "test2.py"
+    ]
+    
+    # Run CLI
+    result = main()
+    assert result == 0
+    
+    # Check output
+    captured = capsys.readouterr()
+    output = captured.out
+    # Only check the 'Generated Prompt' section
+    if "Generated Prompt:" in output:
+        prompt_section = output.split("Generated Prompt:", 1)[1]
+    else:
+        prompt_section = output
+    assert "test1.py" in prompt_section
+    assert "test2.py" not in prompt_section
+    assert "test3.txt" not in prompt_section
+
+def test_cli_invalid_directory(capsys):
+    """Test CLI with invalid directory."""
+    # Mock sys.argv
+    import sys
+    sys.argv = ["codetoprompt", "/nonexistent/directory"]
+    
+    # Run CLI
+    result = main()
+    assert result == 1
+    
+    # Check error message
+    captured = capsys.readouterr()
+    assert "Error" in captured.out
+    assert "does not exist" in captured.out 

codetoprompt-0.1.0/tests/test_core.py

@@ -0,0 +1,63 @@
+"""Tests for the core functionality of codetoprompt."""
+import os
+import tempfile
+from pathlib import Path
+
+import pytest
+from codetoprompt import CodeToPrompt
+
+@pytest.fixture
+def temp_dir():
+    """Create a temporary directory with some test files."""
+    with tempfile.TemporaryDirectory() as tmpdir:
+        # Create some test files
+        test_dir = Path(tmpdir)
+        (test_dir / "test1.py").write_text("print('hello')\n")
+        (test_dir / "test2.py").write_text("def test():\n    pass\n")
+        (test_dir / "test3.txt").write_text("Some text\n")
+        yield test_dir
+
+def test_initialization(temp_dir):
+    """Test CodeToPrompt initialization."""
+    processor = CodeToPrompt(str(temp_dir))
+    assert processor.root_dir == temp_dir
+    assert processor.include_patterns == ["*"]
+    assert processor.exclude_patterns == []
+    assert processor.respect_gitignore is True
+    assert processor.show_line_numbers is True
+
+def test_file_inclusion(temp_dir):
+    """Test file inclusion patterns."""
+    processor = CodeToPrompt(
+        str(temp_dir),
+        include_patterns=["*.py"],
+        exclude_patterns=["test2.py"]
+    )
+    files = list(processor._get_files())
+    assert len(files) == 1
+    assert files[0].name == "test1.py"
+
+def test_generate_prompt(temp_dir):
+    """Test prompt generation."""
+    processor = CodeToPrompt(str(temp_dir))
+    prompt = processor.generate_prompt()
+    assert "test1.py" in prompt
+    assert "test2.py" in prompt
+    assert "test3.txt" in prompt
+    assert "print('hello')" in prompt
+
+def test_token_count(temp_dir):
+    """Test token counting."""
+    processor = CodeToPrompt(str(temp_dir))
+    count = processor.get_token_count()
+    assert count > 0
+
+def test_save_to_file(temp_dir):
+    """Test saving prompt to file."""
+    processor = CodeToPrompt(str(temp_dir))
+    output_file = temp_dir / "output.txt"
+    processor.save_to_file(str(output_file))
+    assert output_file.exists()
+    content = output_file.read_text()
+    assert "test1.py" in content
+    assert "test2.py" in content