codigest 0.3.0__py3-none-any.whl

codigest/commands/diff.py

@@ -0,0 +1,84 @@
+import typer
+import pyperclip
+from pathlib import Path
+from rich.console import Console
+from rich.progress import Progress, SpinnerColumn, TextColumn
+
+from ..core import scanner, prompts, shadow
+from .scan import _load_config_filters 
+
+app = typer.Typer()
+console = Console()
+
+@app.callback(invoke_without_command=True)
+def handle(
+    copy: bool = typer.Option(True, help="Auto-copy to clipboard"),
+    save: bool = typer.Option(True, help="Save to .codigest/changes.diff"),
+    message: str = typer.Option("", "--message", "-m", help="Add specific instruction context"),
+):
+    """
+    [Context Update] Shows changes since the last 'codigest scan'.
+    Useful for updating LLM context without re-uploading everything.
+    """
+    root_path = Path.cwd()
+    anchor = shadow.ContextAnchor(root_path)
+    
+    # 1. Check Baseline Existence
+    last_update = anchor.get_last_update_time()
+    if last_update == "Never":
+        console.print("[yellow]⚠️  No scan history found.[/yellow]")
+        console.print("   Run [bold cyan]codigest scan[/bold cyan] first to establish a baseline.")
+        raise typer.Exit(1)
+
+    console.print(f"[dim]Checking changes since last scan ({last_update})...[/dim]")
+
+    # 2. Calculate Diff
+    with Progress(
+        SpinnerColumn(),
+        TextColumn("[bold blue]Analyzing changes...[/bold blue]"),
+        transient=True,
+        console=console
+    ) as progress:
+        task = progress.add_task("diff", total=None)
+        
+        # Load same filters as scan
+        extensions, extra_ignores = _load_config_filters(root_path)
+        
+        # Get current valid files (Working Tree)
+        current_files = scanner.scan_project(root_path, extensions, extra_ignores)
+        
+        # Compare Working Tree vs Anchor
+        diff_content = anchor.get_changes(current_files)
+        
+        progress.update(task, completed=100)
+
+    if not diff_content.strip():
+        console.print("[green]✨ No changes detected since last scan.[/green]")
+        return
+
+    # 3. Render
+    prompt_engine = prompts.get_engine(root_path)
+    try:
+        formatted_diff = prompt_engine.render(
+            "diff",
+            project_name=root_path.name,
+            context_message=f"Changes since last scan ({last_update})",
+            diff_content=diff_content,
+            instruction=message
+        )
+    except Exception:
+        # Fallback if template fails
+        formatted_diff = f"<diff>\n{diff_content}\n</diff>"
+
+    # 4. Output
+    console.print(f"[bold green]✔ Changes Detected![/bold green] ({len(formatted_diff)} chars)")
+    
+    if copy:
+        pyperclip.copy(formatted_diff)
+        console.print("[dim]📋 Copied to clipboard[/dim]")
+
+    if save:
+        out_path = root_path / ".codigest" / "changes.diff"
+        out_path.parent.mkdir(exist_ok=True)
+        out_path.write_text(formatted_diff, encoding="utf-8")
+        console.print(f"[dim]💾 Saved to {out_path}[/dim]")

codigest/commands/digest.py

@@ -0,0 +1,88 @@
+import typer
+import pyperclip
+from pathlib import Path
+from rich.console import Console
+from rich.progress import Progress, SpinnerColumn, TextColumn
+
+from ..core import scanner, structure, prompts, semdiff, tags, tokenizer
+
+# Reuse config loader
+from .scan import _load_config_filters 
+
+app = typer.Typer()
+console = Console()
+
+@app.callback(invoke_without_command=True)
+def handle(
+    target: Path = typer.Argument(Path.cwd(), help="Target directory"),
+    copy: bool = typer.Option(True, help="Auto-copy to clipboard"),
+    save: bool = typer.Option(True, help="Save to .codigest/digest.xml"),
+    message: str = typer.Option("", "--message", "-m", help="Add specific instruction"),
+):
+    """
+    [Architectural View] Summarizes the codebase structure (Classes/Functions only).
+    """
+    root_path = target.resolve()
+    
+    prompt_engine = prompts.get_engine(root_path)
+    extensions, extra_ignores = _load_config_filters(root_path)
+
+    with Progress(
+        SpinnerColumn(),
+        TextColumn("[bold blue]Digesting Architecture...[/bold blue]"),
+        transient=True,
+        console=console
+    ) as progress:
+        
+        task = progress.add_task("digest", total=None)
+        
+        files = scanner.scan_project(root_path, extensions, extra_ignores)
+        tree_str = structure.generate_ascii_tree(files, root_path)
+
+        summary_blocks = []
+        for file_path in files:
+            # Only summarize Python files via AST
+            if file_path.suffix in (".py", ".pyi"):
+                try:
+                    content = file_path.read_text(encoding="utf-8")
+                    summary = semdiff.summarize(content)
+                    
+                    if summary:
+                        rel_path = file_path.relative_to(root_path).as_posix()
+                        block = tags.xml(t"""
+                        <file path="{rel_path}">
+                        {summary}
+                        </file>
+                        """)
+                        summary_blocks.append(block)
+                except Exception:
+                    continue
+
+        summary_blob = "\n".join(summary_blocks)
+        
+        try:
+            digest_content = prompt_engine.render(
+                "digest",
+                project_name=root_path.name,
+                tree_structure=tree_str,
+                digest_content=summary_blob,
+                instruction=message
+            )
+        except Exception as e:
+            console.print(f"[red]❌ Rendering Failed:[/red] {e}")
+            raise typer.Exit(1)
+            
+        progress.update(task, completed=100)
+
+    token_count = tokenizer.estimate_tokens(digest_content)
+    console.print(f"[bold green]✔ Digest Generated![/bold green] ([bold cyan]~{token_count:,} Tokens[/bold cyan])")
+    
+    if copy:
+        pyperclip.copy(digest_content)
+        console.print("[dim]📋 Copied to clipboard[/dim]")
+    
+    if save:
+        out_path = root_path / ".codigest" / "digest.xml"
+        out_path.parent.mkdir(exist_ok=True)
+        out_path.write_text(digest_content, encoding="utf-8")
+        console.print(f"[dim]💾 Saved to {out_path}[/dim]")

codigest/commands/init.py

@@ -0,0 +1,87 @@
+import typer
+from pathlib import Path
+from rich.console import Console
+from rich.panel import Panel
+
+from ..core import scanner, shadow
+
+app = typer.Typer()
+console = Console()
+
+DEFAULT_CONFIG = """# Codigest Configuration File
+[project]
+description = "Auto-generated context configuration"
+
+[filter]
+max_file_size_kb = 100 
+extensions = [
+    ".py", ".pyi",
+    ".ts", ".tsx", ".js", ".jsx",
+    ".json", ".html", ".css",
+    ".md", ".toml", ".yaml", ".yml", ".xml"
+]
+exclude_patterns = [
+    "*.lock",
+    "dist/",
+    "build/",
+    "node_modules/",
+    "__pycache__/"
+]
+
+[output]
+format = "xml"
+structure = "toon"
+"""
+
+@app.callback(invoke_without_command=True)
+def handle(
+    force: bool = typer.Option(False, "--force", "-f", help="Overwrite existing config"),
+):
+    """
+    Initialize the .codigest environment and capture the initial state.
+    """
+    root_path = Path.cwd()
+    config_dir = root_path / ".codigest"
+    config_file = config_dir / "config.toml"
+    gitignore_file = root_path / ".gitignore"
+
+    console.print(Panel(f"[bold blue]Initializing Codigest[/bold blue]\n📂 Location: {root_path}", expand=False))
+
+    # 1. Config Setup (기존 로직)
+    if not config_dir.exists():
+        config_dir.mkdir()
+        console.print("  [green]✔[/green] Created [bold].codigest/[/bold] directory")
+    
+    if not config_file.exists() or force:
+        config_file.write_text(DEFAULT_CONFIG, encoding="utf-8")
+        console.print("  [green]✔[/green] Created [bold]config.toml[/bold]")
+    else:
+        console.print("  [yellow]![/yellow] Config exists. Use --force to overwrite.")
+
+    _update_gitignore(gitignore_file)
+
+    # 2. [NEW] Initial Anchoring (Shadow Git)
+    #    "프로그램 시작 시에도 Anchor 하나 잡고 시작"
+    console.print("\n[dim]Creating initial context anchor...[/dim]")
+    try:
+        # Default scan settings for initialization
+        files = scanner.scan_project(root_path) 
+        anchor = shadow.ContextAnchor(root_path)
+        anchor.update(files)
+        console.print("  [green]✔[/green] Baseline snapshot captured.")
+    except Exception as e:
+        console.print(f"  [red]⚠️ Failed to create initial anchor: {e}[/red]")
+
+    console.print("\n[bold green]✨ Ready to digest![/bold green]") 
+    console.print("Try running: [cyan]codigest diff[/cyan] to see changes from now on.")
+
+def _update_gitignore(path: Path):
+    entry = ".codigest/"
+    if not path.exists():
+        path.write_text(f"# Git Ignore\n{entry}\n", encoding="utf-8")
+        return
+    
+    if entry not in path.read_text(encoding="utf-8"):
+        with path.open("a", encoding="utf-8") as f:
+            f.write(f"\n{entry}\n")
+        console.print("  [green]✔[/green] Added [bold].codigest/[/bold] to .gitignore")

codigest/commands/scan.py

@@ -0,0 +1,142 @@
+import typer
+import tomllib
+from pathlib import Path
+from rich.console import Console
+from rich.progress import Progress, SpinnerColumn, TextColumn
+
+from ..core import scanner, structure, tags, prompts, processor, shadow, tokenizer
+
+app = typer.Typer()
+console = Console()
+
+def _load_config_filters(root_path: Path):
+    config_path = root_path / ".codigest" / "config.toml"
+    extensions = None
+    exclude_patterns = []
+    
+    if config_path.exists():
+        try:
+            with open(config_path, "rb") as f:
+                data = tomllib.load(f)
+                filters = data.get("filter", {})
+                ext_list = filters.get("extensions", [])
+                if ext_list:
+                    extensions = set(ext_list)
+                exclude_patterns = filters.get("exclude_patterns", [])
+        except Exception:
+            pass 
+            
+    return extensions, exclude_patterns
+
+@app.callback(invoke_without_command=True)
+def handle(
+    target: Path = typer.Argument(Path.cwd(), help="Target directory"),
+    output: str = typer.Option("snapshot.xml", help="Output filename inside .codigest/"),
+    all: bool = typer.Option(False, "--all", "-a", help="Ignore config filters"),
+    message: str = typer.Option("", "--message", "-m", help="Add specific instruction"),
+    line_numbers: bool = typer.Option(False, "--lines", "-l", help="Add line numbers to code blocks"),
+):
+    """
+    [Legacy Mode] Scans the codebase using the PromptEngine.
+    """
+    root_path = target.resolve()
+    artifact_dir = root_path / ".codigest"
+
+    if not artifact_dir.exists():
+        console.print("[yellow]⚠️  .codigest directory missing. Running init...[/yellow]")
+        try:
+            artifact_dir.mkdir(exist_ok=True)
+        except PermissionError:
+            console.print(f"[red]❌ Error: Cannot create .codigest at {root_path}[/red]")
+            raise typer.Exit(1)
+
+    output_path = artifact_dir / output
+
+    # Initialize Engines
+    prompt_engine = prompts.get_engine(root_path)
+    anchor = shadow.ContextAnchor(root_path)
+
+    extensions, extra_ignores = (None, [])
+    if not all:
+        extensions, extra_ignores = _load_config_filters(root_path)
+
+    with Progress(
+        SpinnerColumn(),
+        TextColumn("[bold blue]Scanning Project...[/bold blue]"),
+        transient=True,
+        console=console
+    ):
+
+        # File Discovery
+        files = scanner.scan_project(root_path, extensions, extra_ignores)
+
+        # Pre-scan Diff Report
+        if anchor.has_history():
+            try:
+                diff_content = anchor.get_changes(files)
+                if diff_content.strip():
+                    pre_diff_path = artifact_dir / "previous_changes.diff"
+                    pre_diff_path.write_text(diff_content, encoding="utf-8")
+            except Exception:
+                pass
+
+        # Structure Generation
+        tree_str = structure.generate_ascii_tree(files, root_path)
+
+        # Content Processing
+        file_blocks = []
+        for file_path in files:
+            rel_path = file_path.relative_to(root_path).as_posix()
+            try:
+                content = processor.read_file_content(file_path, add_line_numbers=line_numbers)
+                block = tags.xml(t"""
+                    <file path="{rel_path}">
+                    {content}
+                    </file>
+                """)
+                file_blocks.append(block)
+            except Exception:
+                continue
+
+        source_code_blob = "\n\n".join(file_blocks)
+
+        # Final Assembly
+        try:
+            snapshot_content = prompt_engine.render(
+                "snapshot",
+                project_name=root_path.name,
+                tree_structure=tree_str,
+                source_code=source_code_blob,
+                instruction=message
+            )
+        except Exception as e:
+            console.print(f"[red]❌ Template Rendering Failed:[/red] {e}")
+            raise typer.Exit(1)
+
+    # Update Anchor
+    try:
+        anchor.update(files)
+    except Exception as e:
+        console.print(f"[yellow]⚠️  Warning: Failed to update context anchor: {e}[/yellow]")
+
+    # Save to Disk
+    try:
+        output_path.write_text(snapshot_content, encoding="utf-8")
+
+        size_kb = len(snapshot_content) / 1024
+        token_count = tokenizer.estimate_tokens(snapshot_content)
+        
+        # Report
+        console.print("[bold green]✔ Snapshot Saved![/bold green]")
+        console.print(f"  📄 Path: [underline]{output_path}[/underline]")
+        console.print(f"  📊 Size: {size_kb:.1f} KB | [bold cyan]~{token_count:,} Tokens[/bold cyan]")
+        console.print(f"  📂 Files: {len(files)}")
+        
+        if anchor.has_history():
+            pre_diff_path = artifact_dir / "previous_changes.diff"
+            if pre_diff_path.exists() and pre_diff_path.stat().st_size > 0:
+                console.print(f"  [dim]ℹ️  Changes before this scan saved to: {pre_diff_path.name}[/dim]")
+
+    except Exception as e:
+        console.print(f"[bold red]❌ Save Failed:[/bold red] {e}")
+        raise typer.Exit(1)

codigest/commands/semdiff.py

@@ -0,0 +1,131 @@
+import typer
+import pyperclip
+from pathlib import Path
+from rich.console import Console
+from rich.progress import Progress, SpinnerColumn, TextColumn
+
+from ..core import scanner, prompts, shadow, semdiff, tags, tokenizer
+
+# Reuse config loader
+from .scan import _load_config_filters 
+
+app = typer.Typer()
+console = Console()
+
+@app.callback(invoke_without_command=True)
+def handle(
+    target: Path = typer.Argument(Path.cwd(), help="Target directory"),
+    copy: bool = typer.Option(True, help="Auto-copy to clipboard"),
+    save: bool = typer.Option(True, help="Save to .codigest/semdiff.xml"),
+    message: str = typer.Option("", "--message", "-m", help="Add specific instruction"),
+):
+    """
+    [Advanced] Generates a Semantic Diff (AST-based) report.
+    Shows ADDED/REMOVED/MODIFIED functions & classes instead of raw text lines.
+    """
+    root_path = target.resolve()
+    anchor = shadow.ContextAnchor(root_path)
+
+    last_update = anchor.get_last_update_time()
+    if last_update == "Never":
+        console.print("[yellow]⚠️  No scan history found. Run [bold]codigest scan[/bold] first.[/yellow]")
+        raise typer.Exit(1)
+
+    console.print(f"[dim]Analyzing structural changes since ({last_update})...[/dim]")
+
+    reports = []
+
+    with Progress(
+        SpinnerColumn(),
+        TextColumn("[bold blue]Parsing AST...[/bold blue]"),
+        transient=True,
+        console=console
+    ) as progress:
+        task = progress.add_task("semdiff", total=None)
+
+        # 1. Scan files
+        extensions, extra_ignores = _load_config_filters(root_path)
+        current_files = scanner.scan_project(root_path, extensions, extra_ignores)
+
+        changed_files_paths = anchor.get_changed_files(list(current_files))
+
+        target_files = []
+        for p in changed_files_paths:
+            if p.suffix in (".py", ".pyi"):
+                target_files.append(p)
+
+        # 2. Compare Each File
+        for file_path in target_files:
+            rel_path = file_path.relative_to(root_path)
+            
+            # Read Content (Handle Missing Files for Deletion)
+            try:
+                new_code = file_path.read_text(encoding="utf-8") if file_path.exists() else ""
+            except: new_code = ""
+                
+            old_code = anchor.read_anchor_file(rel_path)
+            
+            # Case: File Added (No old code) -> All symbols ADDED
+            # Case: File Deleted (No new code) -> All symbols REMOVED
+            # Case: Modified -> Semantic Compare
+            
+            changes = semdiff.compare(old_code, new_code)
+            
+            if changes:
+                change_lines = []
+                for ch in changes:
+                    if ch.change_type == "ADDED": icon = "➕ [ADDED]   "
+                    elif ch.change_type == "REMOVED": icon = "➖ [REMOVED] "
+                    elif ch.change_type == "MODIFIED": icon = "⚠️ [SIGNATURE]" # 중요: 시그니처 변경
+                    else: icon = "✏️ [LOGIC]   " # 내부 로직 변경
+                        
+                    detail = f" :: {ch.details}" if ch.details else ""
+                    line = f"{icon} {ch.symbol.type} {ch.symbol.name}{ch.symbol.signature}{detail}"
+                    change_lines.append(line)
+                
+                # File Deleted Tagging
+                file_status = ""
+                if not new_code: file_status = " (DELETED)"
+                elif not old_code: file_status = " (NEW)"
+
+                block = tags.xml(t"""
+                <file path="{rel_path.as_posix()}{file_status}">
+                {chr(10).join(change_lines)}
+                </file>
+                """)
+                reports.append(block)
+
+        progress.update(task, completed=100)
+
+    if not reports:
+        console.print("[green]✨ No structural (AST) changes detected.[/green]")
+        return
+
+    # Render
+    report_content = "\n".join(reports)
+    prompt_engine = prompts.get_engine(root_path)
+
+    try:
+        final_output = prompt_engine.render(
+            "semdiff",
+            project_name=root_path.name,
+            context_message=f"Structural changes since {last_update}",
+            semdiff_content=report_content,
+            instruction=message
+        )
+    except Exception as e:
+        console.print(f"[red]❌ Template Error:[/red] {e}")
+        raise typer.Exit(1)
+
+    token_count = tokenizer.estimate_tokens(final_output)
+    console.print(f"[bold green]✔ SemDiff Generated![/bold green] ([bold cyan]~{token_count:,} Tokens[/bold cyan])")
+    
+    if copy:
+        pyperclip.copy(final_output)
+        console.print("[dim]📋 Copied to clipboard[/dim]")
+    
+    if save:
+        out_path = root_path / ".codigest" / "semdiff.xml"
+        out_path.parent.mkdir(exist_ok=True)
+        out_path.write_text(final_output, encoding="utf-8")
+        console.print(f"[dim]💾 Saved to {out_path}[/dim]")

codigest/commands/tree.py

@@ -0,0 +1,110 @@
+import typer
+import tomllib
+from pathlib import Path
+from typing import Optional
+from rich.console import Console
+from rich.tree import Tree
+from rich.text import Text
+from rich.filesize import decimal
+
+from ..core.scanner import scan_project
+
+app = typer.Typer()
+console = Console()
+
+def _load_extensions_from_config(root_path: Path) -> Optional[set[str]]:
+    """Attempts to load target extensions from .codigest/config.toml"""
+    config_path = root_path / ".codigest" / "config.toml"
+    if not config_path.exists():
+        return None
+    try:
+        with open(config_path, "rb") as f:
+            data = tomllib.load(f)
+            exts = data.get("filter", {}).get("extensions", [])
+            return set(exts) if exts else None
+    except Exception:
+        return None
+
+def _build_rich_tree(root_path: Path, files: list[Path]) -> Tree:
+    """Converts a flat list of Paths into a visual Rich Tree."""
+    tree = Tree(
+        f":open_file_folder: [bold blue]{root_path.name}[/bold blue]",
+        guide_style="bold bright_black",
+    )
+    dir_nodes = {root_path: tree}
+
+    for path in files:
+        relative = path.relative_to(root_path)
+        parts = relative.parts
+        current_node = tree
+        current_path = root_path
+        
+        for part in parts[:-1]:
+            current_path = current_path / part
+            if current_path not in dir_nodes:
+                dir_nodes[current_path] = current_node.add(f":folder: [bold cyan]{part}[/bold cyan]")
+            current_node = dir_nodes[current_path]
+        
+        stat = path.stat()
+        size_str = decimal(stat.st_size)
+        filename = parts[-1]
+        
+        # Icon logic
+        icon, style = "📄", "white"
+        if filename.endswith(".py"):
+            icon, style = "🐍", "green"
+        elif filename.endswith((".js", ".ts", ".tsx")):
+            icon, style = "📜", "yellow"
+        elif filename.endswith((".html", ".css")):
+            icon, style = "🌐", "magenta"
+        elif filename.endswith((".json", ".toml", ".yaml")):
+            icon, style = "⚙️", "blue"
+        elif filename.endswith(".md"):
+            icon, style = "📝", "cyan"
+
+        label = Text(f"{icon} {filename}", style=style)
+        label.append(f" ({size_str})", style="dim")
+        current_node.add(label)
+
+    return tree
+
+@app.callback(invoke_without_command=True)
+def handle(
+    target: Path = typer.Argument(Path.cwd(), help="Target directory"),
+    all: bool = typer.Option(False, "--all", "-a", help="Ignore config filters"),
+):
+    """
+    [Visual] Print the project directory tree (Respects .gitignore).
+    """
+    if not target.exists():
+        console.print(f"[red]❌ Error: Path '{target}' does not exist.[/red]")
+        raise typer.Exit(code=1)
+
+    root_path = target.resolve()
+    
+    # 1. Determine Filters
+    extensions = None
+    if not all:
+        extensions = _load_extensions_from_config(root_path)
+        filter_status = f"[dim]Filter: {len(extensions)} extensions from config[/dim]" if extensions else "[dim]Filter: Default safelist[/dim]"
+    else:
+        filter_status = "[bold yellow]Filter: ALL (Gitignore only)[/bold yellow]"
+
+    console.print(f"[bold]🔍 Scanning:[/bold] {root_path}")
+    console.print(filter_status)
+
+    # 2. Scan
+    try:
+        files = scan_project(root_path, extensions)
+    except Exception as e:
+        console.print(f"[red]❌ Scan failed:[/red] {e}")
+        raise typer.Exit(code=1)
+
+    if not files:
+        console.print("[yellow]⚠️ No matching files found.[/yellow]")
+        return
+
+    # 3. Visualize
+    tree_viz = _build_rich_tree(root_path, files)
+    console.print(tree_viz)
+    console.print(f"\n[dim]Found {len(files)} files.[/dim]")