knowlang cli support

pyproject.toml

@@ -29,6 +29,8 @@ packages = [
     { include = "knowlang", from="src" },
 ]
 
+[tool.poetry.scripts]
+knowlang = "knowlang.cli:cli_main"
 
 [tool.poetry.group.dev.dependencies]
 pytest = "^8.3.4"

src/knowlang/__main__.py

@@ -1,136 +0,0 @@
-import argparse
-import asyncio
-import sys
-from pathlib import Path
-from typing import List, Optional
-from rich.console import Console
-from rich.table import Table
-
-from knowlang.core.types import CodeChunk
-from knowlang.configs.config import AppConfig
-from knowlang.parser.factory import CodeParserFactory
-from knowlang.parser.providers.git import GitProvider
-from knowlang.parser.providers.filesystem import FilesystemProvider
-from knowlang.summarizer.summarizer import CodeSummarizer
-from knowlang.utils.fancy_log import FancyLogger
-
-LOG = FancyLogger(__name__)
-console = Console()
-
-def parse_args():
-    parser = argparse.ArgumentParser(
-        description="Know Lang Bot - Code Analysis Tool",
-        formatter_class=argparse.RawDescriptionHelpFormatter
-    )
-    
-    parser.add_argument(
-        "--config",
-        type=str,
-        help="Path to custom configuration file",
-        default=None
-    )
-    
-    parser.add_argument(
-        "--verbose", "-v",
-        action="store_true",
-        help="Enable verbose output"
-    )
-    
-    parser.add_argument(
-        "--output",
-        type=str,
-        choices=["table", "json"],
-        default="table",
-        help="Output format (default: table)"
-    )
-
-    return parser.parse_args()
-
-def create_config(config_path: Optional[str] = None) -> AppConfig:
-    """Create configuration, optionally from a file"""
-    if config_path:
-        with open(config_path, 'r') as file:
-            config_data = file.read()
-            return AppConfig.model_validate_json(config_data)
-    return AppConfig()
-
-def display_results_table(chunks : List[CodeChunk]):
-    """Display parsed chunks in a rich table"""
-    table = Table(show_header=True, header_style="bold magenta")
-    table.add_column("Type")
-    table.add_column("Name")
-    table.add_column("File")
-    table.add_column("Lines")
-    table.add_column("Parent")
-    
-    for chunk in chunks:
-        table.add_row(
-            chunk.type.value,
-            chunk.name or "N/A",
-            str(chunk.file_path),
-            f"{chunk.start_line}-{chunk.end_line}",
-            chunk.parent_name or "N/A"
-        )
-    
-    console.print(table)
-
-def display_results_json(chunks: List[CodeChunk]):
-    """Display parsed chunks as JSON"""
-    import json
-    print(json.dumps([chunk.model_dump() for chunk in chunks], indent=2))
-
-async def main():
-    args = parse_args()
-    
-    # Setup logging
-    if args.verbose:
-        LOG.setLevel("DEBUG")
-    
-    try:
-        # Load configuration
-        config = create_config(args.config)
-        # Create parser factory
-        factory = CodeParserFactory(config)
-        
-        # Determine provider
-        source_path = Path(config.db.codebase_directory)
-        if (source_path/ '.git').exists():
-            LOG.info(f"Detected Git repository at {source_path}")
-            provider = GitProvider(source_path, config)
-        else:
-            LOG.info(f"Using filesystem provider for {source_path}")
-            provider = FilesystemProvider(source_path, config)
-        
-        # Process files
-        total_chunks = []
-        with console.status("[bold green]Parsing files...") as status:
-            for idx, file_path in enumerate(provider.get_files()):
-                status.update(f"[bold yellow] Processed {idx+1} files, [bold green]processing {file_path}...\n")
-                
-                parser = factory.get_parser(file_path)
-                if parser:
-                    chunks = parser.parse_file(file_path)
-                    total_chunks.extend(chunks)
-        
-        # Display results
-        if total_chunks:
-            LOG.info(f"\nFound {len(total_chunks)} code chunks")
-            if args.output == "table":
-                display_results_table(total_chunks)
-            else:
-                display_results_json(total_chunks)
-        else:
-            LOG.warning("No code chunks found")
-        
-        summarizer = CodeSummarizer(config)
-        await summarizer.process_chunks(total_chunks)
-        
-    except Exception as e:
-        LOG.error(f"Error: {str(e)}")
-        if args.verbose:
-            import traceback
-            traceback.print_exc()
-        sys.exit(1)
-
-if __name__ == "__main__":
-    asyncio.run(main())

src/knowlang/chat_bot/__main__.py

@@ -1,24 +0,0 @@
-from knowlang.configs.config import AppConfig
-from knowlang.chat_bot.chat_graph import process_chat
-import chromadb
-import asyncio
-
-async def test_chat_processing():
-    config = AppConfig()
-    db_client = chromadb.PersistentClient(
-        path=str(config.db.persist_directory)
-    )
-    collection = db_client.get_collection(
-        name=config.db.collection_name
-    )
-    
-    result = await process_chat(
-        "How are different quantization methods implemented in the transformers library, and what are the key components required to implement a new quantization method?",
-        collection,
-        config
-    )
-    
-    print(f"Answer: {result.answer}")
-
-if __name__ == "__main__":
-    asyncio.run(test_chat_processing())

src/knowlang/cli/__init__.py

@@ -0,0 +1,40 @@
+"""CLI entry points for KnowLang."""
+import asyncio
+from typing import Optional, Sequence
+
+from knowlang.cli.parser import create_parser
+from knowlang.utils.fancy_log import FancyLogger
+
+LOG = FancyLogger(__name__)
+
+async def main(args: Optional[Sequence[str]] = None) -> int:
+    """Main CLI entry point.
+    
+    Args:
+        args: Command line arguments. If None, sys.argv[1:] is used.
+    
+    Returns:
+        Exit code (0 for success, non-zero for error)
+    """
+    parser = create_parser()
+    parsed_args = parser.parse_args(args)
+    
+    # Setup logging
+    if parsed_args.verbose:
+        LOG.setLevel("DEBUG")
+    
+    try:
+        # Execute command
+        await parsed_args.func(parsed_args)
+        return 0
+    except Exception as e:
+        LOG.error(f"Error: {str(e)}")
+        if parsed_args.verbose:
+            import traceback
+            traceback.print_exc()
+        return 1
+
+def cli_main() -> None:
+    """Entry point for CLI scripts."""
+    exit_code = asyncio.run(main())
+    exit(exit_code)

src/knowlang/cli/commands/parse.py

@@ -0,0 +1,72 @@
+"""Command implementation for parsing codebases."""
+from pathlib import Path
+from typing import Optional
+
+from knowlang.configs.config import AppConfig
+from knowlang.parser.factory import CodeParserFactory
+from knowlang.parser.providers.git import GitProvider
+from knowlang.parser.providers.filesystem import FilesystemProvider
+from knowlang.summarizer.summarizer import CodeSummarizer
+from knowlang.cli.display.formatters import get_formatter
+from knowlang.cli.display.progress import ProgressTracker
+from knowlang.utils.fancy_log import FancyLogger
+from knowlang.cli.types import ParseCommandArgs
+
+LOG = FancyLogger(__name__)
+
+def create_config(config_path: Optional[Path] = None) -> AppConfig:
+    """Create configuration from file or defaults."""
+    if config_path:
+        with open(config_path, 'r') as file:
+            config_data = file.read()
+            return AppConfig.model_validate_json(config_data)
+    return AppConfig()
+
+async def parse_command(args: ParseCommandArgs) -> None:
+    """Execute the parse command.
+    
+    Args:
+        args: Typed command line arguments
+    """
+    # Load configuration
+    config = create_config(args.config)
+    
+    # Update codebase directory in config
+    config.db.codebase_directory = str(args.path)
+    
+    # Create parser factory
+    factory = CodeParserFactory(config)
+    
+    # Determine provider
+    source_path = args.path
+    if (source_path / '.git').exists():
+        LOG.info(f"Detected Git repository at {source_path}")
+        provider = GitProvider(source_path, config)
+    else:
+        LOG.info(f"Using filesystem provider for {source_path}")
+        provider = FilesystemProvider(source_path, config)
+    
+    # Process files
+    total_chunks = []
+    progress = ProgressTracker("Parsing files...")
+    
+    with progress.progress():
+        for file_path in provider.get_files():
+            progress.update(f"processing {file_path}...")
+            
+            parser = factory.get_parser(file_path)
+            if parser:
+                chunks = parser.parse_file(file_path)
+                total_chunks.extend(chunks)
+    
+    # Display results
+    if total_chunks:
+        LOG.info(f"\nFound {len(total_chunks)} code chunks")
+        formatter = get_formatter(args.output)
+        formatter.display_chunks(total_chunks)
+    else:
+        LOG.warning("No code chunks found")
+    
+    # Process summaries
+    summarizer = CodeSummarizer(config)
+    await summarizer.process_chunks(total_chunks)

src/knowlang/cli/display/formatters.py

@@ -0,0 +1,66 @@
+"""Output formatters for CLI results."""
+from typing import List, Protocol
+import json
+from rich.console import Console
+from rich.table import Table
+
+from knowlang.core.types import CodeChunk
+
+console = Console()
+
+class OutputFormatter(Protocol):
+    """Protocol for output formatters."""
+    
+    def display_chunks(self, chunks: List[CodeChunk]) -> None:
+        """Display code chunks in the appropriate format."""
+        ...
+
+class TableFormatter:
+    """Format output as a rich table."""
+    
+    def display_chunks(self, chunks: List[CodeChunk]) -> None:
+        table = Table(show_header=True, header_style="bold magenta")
+        table.add_column("Type")
+        table.add_column("Name")
+        table.add_column("File")
+        table.add_column("Lines")
+        table.add_column("Parent")
+        
+        for chunk in chunks:
+            table.add_row(
+                chunk.type.value,
+                chunk.name or "N/A",
+                str(chunk.file_path),
+                f"{chunk.start_line}-{chunk.end_line}",
+                chunk.parent_name or "N/A"
+            )
+        
+        console.print(table)
+
+class JsonFormatter:
+    """Format output as JSON."""
+    
+    def display_chunks(self, chunks: List[CodeChunk]) -> None:
+        print(json.dumps([chunk.model_dump() for chunk in chunks], indent=2))
+
+def get_formatter(format_type: str) -> OutputFormatter:
+    """Get the appropriate formatter for the specified format.
+    
+    Args:
+        format_type: The type of formatter to use ("table" or "json")
+    
+    Returns:
+        An OutputFormatter instance
+    
+    Raises:
+        ValueError: If format_type is not recognized
+    """
+    formatters = {
+        "table": TableFormatter,
+        "json": JsonFormatter
+    }
+    
+    if format_type not in formatters:
+        raise ValueError(f"Unknown format type: {format_type}")
+    
+    return formatters[format_type]()

src/knowlang/cli/display/progress.py

@@ -0,0 +1,35 @@
+"""Progress tracking for CLI operations."""
+from contextlib import contextmanager
+from typing import Iterator
+from rich.console import Console
+
+console = Console()
+
+class ProgressTracker:
+    """Track progress of file processing."""
+    
+    def __init__(self, description: str = "Processing..."):
+        self.description = description
+        self.status = None
+        self.processed_files = 0
+    
+    @contextmanager
+    def progress(self) -> Iterator[None]:
+        """Context manager for tracking progress."""
+        with console.status(f"[bold green]{self.description}") as status:
+            self.status = status
+            yield
+            self.status = None
+    
+    def update(self, message: str) -> None:
+        """Update progress status.
+        
+        Args:
+            message: Current status message
+        """
+        if self.status:
+            self.processed_files += 1
+            self.status.update(
+                f"[bold yellow]Processed {self.processed_files} files, "
+                f"[bold green]{message}"
+            )

src/knowlang/cli/parser.py

@@ -0,0 +1,79 @@
+"""Argument parsing for KnowLang CLI."""
+import argparse
+from pathlib import Path
+from typing import Union
+
+from knowlang.cli.types import ParseCommandArgs, BaseCommandArgs
+from knowlang.cli.commands.parse import parse_command
+
+def _convert_to_args(parsed_args: argparse.Namespace) -> Union[ParseCommandArgs, BaseCommandArgs]:
+    """Convert parsed namespace to typed arguments."""
+    base_args = {
+        "verbose": parsed_args.verbose,
+        "config": parsed_args.config if hasattr(parsed_args, "config") else None
+    }
+    
+    if parsed_args.command == "parse":
+        return ParseCommandArgs(
+            **base_args,
+            path=parsed_args.path,
+            output=parsed_args.output,
+            command="parse"
+        )
+    
+    return BaseCommandArgs(**base_args)
+
+def create_parser() -> argparse.ArgumentParser:
+    """Create the main argument parser."""
+    parser = argparse.ArgumentParser(
+        description="KnowLang - Code Understanding Assistant",
+        formatter_class=argparse.RawDescriptionHelpFormatter
+    )
+    
+    # Global options
+    parser.add_argument(
+        "--verbose", "-v",
+        action="store_true",
+        help="Enable verbose output"
+    )
+    
+    parser.add_argument(
+        "--config",
+        type=Path,
+        help="Path to custom configuration file",
+        default=None
+    )
+    
+    # Subcommands
+    subparsers = parser.add_subparsers(
+        title="commands",
+        description="Available commands",
+        dest="command"
+    )
+    subparsers.required = True
+    
+    # Parse command
+    parse_parser = subparsers.add_parser(
+        "parse",
+        help="Parse and index a codebase"
+    )
+    parse_parser.add_argument(
+        "--output",
+        type=str,
+        choices=["table", "json"],
+        default="table",
+        help="Output format (default: table)"
+    )
+    parse_parser.add_argument(
+        "path",
+        type=Path,
+        help="Path to codebase directory or repository URL"
+    )
+    parse_parser.set_defaults(func=parse_command)
+    
+    return parser
+
+def parse_args() -> Union[ParseCommandArgs, BaseCommandArgs]:
+    """Parse command line arguments into typed objects."""
+    parser = create_parser()
+    return _convert_to_args(parser.parse_args())

src/knowlang/cli/types.py

@@ -0,0 +1,17 @@
+"""Type definitions for CLI arguments."""
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Literal, Optional
+
+@dataclass
+class BaseCommandArgs:
+    """Base arguments for all commands."""
+    verbose: bool
+    config: Optional[Path]
+
+@dataclass
+class ParseCommandArgs(BaseCommandArgs):
+    """Arguments for the parse command."""
+    path: Path
+    output: Literal["table", "json"]
+    command: Literal["parse"]  # for command identification