codigest 0.3.0__py3-none-any.whl

codigest/core/git_ops.py

@@ -0,0 +1,73 @@
+"""
+Git Operations.
+Retains the 'Untracked File' detection logic from the prototype.
+"""
+import subprocess
+from pathlib import Path
+from loguru import logger
+
+def is_git_repo(root_path: Path) -> bool:
+    return (root_path / ".git").exists()
+
+def get_smart_diff(root_path: Path) -> str:
+    """
+    Fetches git diff AND content of untracked (new) files.
+    """
+    if not is_git_repo(root_path):
+        return "Warning: Not a git repository."
+
+    try:
+        # 1. Standard Git Diff (Staged + Unstaged)
+        diff_output = subprocess.check_output(
+            ["git", "diff", "HEAD"], 
+            cwd=root_path, 
+            text=True, 
+            encoding='utf-8',
+            stderr=subprocess.DEVNULL 
+        )
+        
+        # 2. Untracked Files (The 'Killer Feature' from prototype)
+        untracked_files = subprocess.check_output(
+            ["git", "ls-files", "--others", "--exclude-standard"],
+            cwd=root_path,
+            text=True,
+            encoding='utf-8',
+            stderr=subprocess.DEVNULL
+        ).splitlines()
+        
+        full_output = diff_output
+        new_files_content = []
+
+        for f in untracked_files:
+            file_path = root_path / f
+            if not file_path.is_file(): 
+                continue
+
+            try:
+                # Basic binary check (skip if cannot decode)
+                content = file_path.read_text(encoding='utf-8')
+                line_count = len(content.splitlines())
+                
+                # Manually construct a Diff Header
+                header = (
+                    f"diff --git a/{f} b/{f}\n"
+                    f"new file mode 100644\n"
+                    f"--- /dev/null\n"
+                    f"+++ b/{f}\n"
+                    f"@@ -0,0 +1,{line_count} @@\n"
+                    f"{content}\n"
+                )
+                new_files_content.append(header)
+                
+            except UnicodeDecodeError:
+                logger.debug(f"Skipping binary untracked file: {f}")
+                continue
+
+        if new_files_content:
+            full_output += "\n# Untracked (New) Source Files:\n" + "".join(new_files_content)
+
+        return full_output.strip()
+
+    except subprocess.CalledProcessError as e:
+        logger.error(f"Git command failed: {e}")
+        return "Error: Failed to run git diff."

codigest/core/processor.py

@@ -0,0 +1,31 @@
+from pathlib import Path
+from loguru import logger
+
+
+def read_file_content(path: Path, add_line_numbers: bool = True) -> str:
+    """
+    Reads file content safely. Returns an error message string if binary/unreadable.
+    """
+    try:
+        content = path.read_text(encoding="utf-8")
+        
+        if not add_line_numbers:
+            return content
+            
+        lines = content.splitlines()
+        if not lines:
+            return ""
+
+        # 라인 넘버 패딩 계산 (100줄이면 3칸 확보)
+        width = len(str(len(lines)))
+        
+        return "\n".join(
+            f"{i+1:>{width}}: {line}" 
+            for i, line in enumerate(lines)
+        )
+        
+    except UnicodeDecodeError:
+        return "<<Binary or Non-UTF8 Content>>"
+    except Exception as e:
+        logger.warning(f"Error reading {path}: {e}")
+        return f"<<Error: {e}>>"

codigest/core/prompts.py

@@ -0,0 +1,164 @@
+"""
+Prompt Management Module.
+Philosophy: Defaults are Code (t-strings), Overrides are Data (TOML).
+"""
+import tomllib
+from pathlib import Path
+from typing import Callable, Dict
+from . import tags
+
+# RenderFunction takes keyword arguments and returns a processed string
+RenderFunc = Callable[..., str]
+
+# 1. Snapshot Template (codigest scan)
+def _default_snapshot(project_name: str, tree_structure: str, source_code: str, instruction: str = "") -> str:
+    instruction_block = ""
+    if instruction:
+        instruction_block = tags.dedent(f"""
+        <user_instruction>
+        {instruction}
+        </user_instruction>
+        """)
+
+    return tags.dedent(t"""
+        [SYSTEM: CODIGEST - INITIAL CONTEXT]
+        You are an expert AI developer. I am providing the full context of a project named "{project_name}".
+        Please digest this structure and code to build your internal mental model.
+        {instruction_block}
+
+        <project_root>
+        {project_name}
+        </project_root>
+
+        <project_structure>
+        {tree_structure}
+        </project_structure>
+
+        <source_code>
+        {source_code}
+        </source_code>
+    """)
+
+# 2. Diff Template (codigest diff)
+def _default_diff(project_name: str, context_message: str, diff_content: str, instruction: str = "") -> str:
+    instruction_block = ""
+    if instruction:
+        instruction_block = tags.dedent(f"""
+        <user_instruction>
+        {instruction}
+        </user_instruction>
+        """)
+
+    return tags.dedent(t"""
+        [SYSTEM: CODIGEST - INCREMENTAL UPDATE]
+        Here are the latest changes for the project "{project_name}".
+        {context_message}.
+        {instruction_block}
+
+        Focus on these modifications to update your context.
+
+        <git_diff>
+        {diff_content}
+        </git_diff>
+    """)
+
+# 3. SemDiff Template (codigest semdiff)
+def _default_semdiff(project_name: str, context_message: str, semdiff_content: str, instruction: str = "") -> str:
+    instruction_block = ""
+    if instruction:
+        instruction_block = tags.dedent(f"""
+        <user_instruction>
+        {instruction}
+        </user_instruction>
+        """)
+
+    return tags.dedent(t"""
+        [SYSTEM: CODIGEST - SEMANTIC ANALYSIS]
+        Structural changes detected in "{project_name}".
+        {context_message}.
+        {instruction_block}
+
+        This report focuses on High-Level Architecture changes (Classes, Functions, Signatures).
+        
+        <semantic_diff>
+        {semdiff_content}
+        </semantic_diff>
+    """)
+
+# 4. Digest Template (codigest digest) - [Missing Part Fix]
+def _default_digest(project_name: str, tree_structure: str, digest_content: str, instruction: str = "") -> str:
+    instruction_block = ""
+    if instruction:
+        instruction_block = tags.dedent(f"""
+        <user_instruction>
+        {instruction}
+        </user_instruction>
+        """)
+
+    return tags.dedent(t"""
+        [SYSTEM: CODIGEST - ARCHITECTURE DIGEST]
+        Here is the high-level architecture of "{project_name}".
+        This contains ONLY definitions (Classes, Functions), no implementation details.
+        Use this to understand the project structure and relationships.
+        {instruction_block}
+
+        <project_structure>
+        {tree_structure}
+        </project_structure>
+
+        <code_digest>
+        {digest_content}
+        </code_digest>
+    """)
+
+# Registry of default implementations
+# Ensure ALL keys correspond to prompt_engine.render calls
+DEFAULT_RENDERERS: Dict[str, RenderFunc] = {
+    "snapshot": _default_snapshot,
+    "diff": _default_diff,
+    "semdiff": _default_semdiff,
+    "digest": _default_digest,  # <--- 이 부분이 누락되었을 수 있습니다.
+}
+
+class PromptEngine:
+    def __init__(self, root_path: Path):
+        self.root_path = root_path
+        self.overrides = self._load_overrides()
+
+    def _load_overrides(self) -> Dict[str, str]:
+        """Loads raw template strings from .codigest/prompts.toml"""
+        prompt_file = self.root_path / ".codigest" / "prompts.toml"
+        if not prompt_file.exists():
+            return {}
+        
+        try:
+            with open(prompt_file, "rb") as f:
+                data = tomllib.load(f)
+                return data.get("prompts", {})
+        except Exception:
+            return {}
+
+    def render(self, key: str, **kwargs) -> str:
+        """
+        Renders a prompt by key.
+        Priority: TOML Override > Default t-string Function
+        """
+        # 1. Check for TOML Override (String-based)
+        if key in self.overrides:
+            raw_template = self.overrides[key]
+            safe_kwargs = {
+                k: tags.escape_xml_value(v) for k, v in kwargs.items()
+            }
+            try:
+                return raw_template.format(**safe_kwargs)
+            except KeyError as e:
+                return f"Error rendering template '{key}': Missing argument {e}"
+
+        # 2. Use Default (Code-based t-string)
+        if key in DEFAULT_RENDERERS:
+            return DEFAULT_RENDERERS[key](**kwargs)
+
+        return f"Error: Prompt template '{key}' not found."
+
+def get_engine(root_path: Path) -> PromptEngine:
+    return PromptEngine(root_path)

codigest/core/scanner.py

@@ -0,0 +1,99 @@
+"""
+Core File System Scanner.
+"""
+import pathspec
+from pathlib import Path
+from typing import Optional
+from loguru import logger
+
+# Default "Safe" ignores
+ALWAYS_IGNORE = [
+    ".git/", ".codigest/",
+    ".venv/", "venv/", "env/",
+    "__pycache__/", "node_modules/",
+    ".idea/", ".vscode/",
+    "*.pyc", "*.DS_Store"
+]
+
+class ProjectScanner:
+    def __init__(self, root_path: Path, extensions: Optional[set[str]] = None, extra_ignores: Optional[list[str]] = None):
+        self.root_path = root_path
+        self.extensions = extensions
+        self.extra_ignores = extra_ignores or []
+        self.ignore_spec = self._load_gitignore()
+
+    def _load_gitignore(self) -> pathspec.PathSpec:
+        """Loads .gitignore and combines with ALWAYS_IGNORE and extra_ignores."""
+        patterns = list(ALWAYS_IGNORE)
+        
+        # Add config-based ignores
+        if self.extra_ignores:
+            patterns.extend(self.extra_ignores)
+
+        gitignore_path = self.root_path / ".gitignore"
+        if gitignore_path.exists():
+            try:
+                with open(gitignore_path, "r", encoding="utf-8") as f:
+                    user_patterns = [
+                        line.strip() for line in f 
+                        if line.strip() and not line.startswith("#")
+                    ]
+                    patterns.extend(user_patterns)
+            except Exception as e:
+                logger.warning(f"Failed to read .gitignore: {e}")
+                
+        return pathspec.PathSpec.from_lines("gitwildmatch", patterns)
+
+    def is_ignored(self, path: Path) -> bool:
+        """Checks if a path matches the ignore patterns."""
+        try:
+            # pathspec requires relative paths (e.g., "src/main.py")
+            rel_path = path.relative_to(self.root_path).as_posix()
+            if path.is_dir():
+                rel_path += "/"
+        except ValueError:
+            return False
+            
+        return self.ignore_spec.match_file(rel_path)
+
+    def scan(self) -> list[Path]:
+        """
+        Walks the directory tree and returns valid files.
+        (Modernized from old core.py's stack-based approach)
+        """
+        valid_files = []
+        
+        # Use rglob for simplicity, but we must manually filter dirs to respect gitignore
+        # For better performance on large repos, we use a manual walk similar to the old code
+        dirs_stack = [self.root_path]
+        
+        while dirs_stack:
+            current = dirs_stack.pop()
+            
+            try:
+                # Sort for deterministic output (LLMs like order)
+                entries = sorted(current.iterdir(), key=lambda x: x.name)
+            except PermissionError:
+                logger.debug(f"Permission denied: {current}")
+                continue
+                
+            for entry in entries:
+                if self.is_ignored(entry):
+                    continue
+                
+                if entry.is_dir():
+                    dirs_stack.append(entry)
+                elif entry.is_file():
+                    # Extension Filter Check
+                    if self.extensions and entry.suffix.lower() not in self.extensions:
+                        # Allow specific config files even if extension doesn't match
+                        if entry.name not in {".gitignore", "Dockerfile", "pyproject.toml"}:
+                            continue
+                            
+                    valid_files.append(entry)
+                    
+        return sorted(valid_files)
+
+def scan_project(root_path: Path, extensions: set[str] = None, extra_ignores: list[str] = None) -> list[Path]:
+    scanner = ProjectScanner(root_path, extensions, extra_ignores)
+    return scanner.scan()

codigest/core/semdiff.py

@@ -0,0 +1,175 @@
+"""
+Semantic Difference Engine (Spec 0.1 Compliant).
+Tracks: Functions, Classes, Methods, Global Variables.
+Detects: Signature Changes AND Logic Body Changes.
+"""
+import ast
+import hashlib
+from dataclasses import dataclass
+from typing import Dict, List, Optional, Any
+
+@dataclass
+class SymbolInfo:
+    name: str
+    type: str  # 'function', 'class', 'variable', ...
+    signature: str
+    content_hash: str # For logic change detection
+    docstring: Optional[str] = None
+
+@dataclass
+class SemanticChange:
+    change_type: str  # 'ADDED', 'REMOVED', 'MODIFIED', 'LOGIC_CHANGED'
+    symbol: SymbolInfo
+    details: str = ""
+
+class CodeParser(ast.NodeVisitor):
+    def __init__(self):
+        self.symbols: Dict[str, SymbolInfo] = {}
+        self.current_class = None
+
+    def _get_hash(self, node: ast.AST) -> str:
+        """Normalized hash of the node body (ignoring formatting/comments implicitly by unparse)."""
+        try:
+            # ast.unparse returns standardized code string
+            normalized_code = ast.unparse(node)
+            return hashlib.md5(normalized_code.encode('utf-8')).hexdigest()
+        except Exception:
+            return ""
+
+    def _get_signature(self, node) -> str:
+        """Reconstructs signature."""
+        if hasattr(node, 'args'):
+            try:
+                return f"({ast.unparse(node.args)})"
+            except: pass
+        return ""
+
+    def visit_FunctionDef(self, node):
+        self._visit_func(node, "function")
+
+    def visit_AsyncFunctionDef(self, node):
+        self._visit_func(node, "async_function")
+
+    def _visit_func(self, node, type_label):
+        name = node.name
+        if self.current_class:
+            name = f"{self.current_class}.{name}"
+            type_label = "method"
+        
+        self.symbols[name] = SymbolInfo(
+            name=name,
+            type=type_label,
+            signature=self._get_signature(node),
+            content_hash=self._get_hash(node), # Hash entire function body
+            docstring=ast.get_docstring(node)
+        )
+
+    def visit_ClassDef(self, node):
+        prev_class = self.current_class
+        self.current_class = node.name
+        
+        bases = [ast.unparse(b) for b in node.bases]
+        base_str = f"({', '.join(bases)})" if bases else ""
+        
+        self.symbols[node.name] = SymbolInfo(
+            name=node.name,
+            type="class",
+            signature=base_str,
+            content_hash=self._get_hash(node), # Hash class structure
+            docstring=ast.get_docstring(node)
+        )
+        
+        self.generic_visit(node)
+        self.current_class = prev_class
+
+    def visit_Assign(self, node):
+        # Only track global variables (no indent)
+        if self.current_class is None:
+            for target in node.targets:
+                if isinstance(target, ast.Name):
+                    name = target.id
+                    # Try to infer value type/content roughly
+                    try:
+                        val_str = ast.unparse(node.value)
+                        # Truncate long values
+                        if len(val_str) > 50: val_str = val_str[:47] + "..."
+                        sig = f" = {val_str}"
+                    except:
+                        sig = " = ..."
+                        
+                    self.symbols[name] = SymbolInfo(
+                        name=name,
+                        type="variable",
+                        signature=sig,
+                        content_hash=self._get_hash(node)
+                    )
+    
+    # Python 3.6+ Annotated Assignment (x: int = 1)
+    def visit_AnnAssign(self, node):
+        if self.current_class is None and isinstance(node.target, ast.Name):
+            name = node.target.id
+            try:
+                type_hint = ast.unparse(node.annotation)
+                val_str = f" = {ast.unparse(node.value)}" if node.value else ""
+                sig = f": {type_hint}{val_str}"
+            except:
+                sig = ": ..."
+                
+            self.symbols[name] = SymbolInfo(
+                name=name,
+                type="variable",
+                signature=sig,
+                content_hash=self._get_hash(node)
+            )
+
+def parse_code(code: str) -> Dict[str, SymbolInfo]:
+    if not code: return {}
+    try:
+        tree = ast.parse(code)
+        parser = CodeParser()
+        parser.visit(tree)
+        return parser.symbols
+    except SyntaxError:
+        return {} 
+
+def compare(old_code: str, new_code: str) -> List[SemanticChange]:
+    old_syms = parse_code(old_code)
+    new_syms = parse_code(new_code)
+    
+    changes = []
+    all_keys = set(old_syms.keys()) | set(new_syms.keys())
+    
+    for key in sorted(all_keys):
+        if key not in old_syms:
+            changes.append(SemanticChange("ADDED", new_syms[key]))
+        elif key not in new_syms:
+            changes.append(SemanticChange("REMOVED", old_syms[key]))
+        else:
+            old, new = old_syms[key], new_syms[key]
+            
+            # 1. Signature Change? (API Breakage)
+            if old.signature != new.signature:
+                detail = f"{old.signature} -> {new.signature}"
+                changes.append(SemanticChange("MODIFIED", new, detail))
+            
+            # 2. Logic Change? (Internal Implementation)
+            # Only check if signature didn't change (to avoid double reporting)
+            elif old.content_hash != new.content_hash:
+                changes.append(SemanticChange("LOGIC_CHANGED", new, "Implementation changed"))
+            
+    return changes
+
+def summarize(code: str) -> str:
+    symbols = parse_code(code)
+    if not symbols: return ""
+    
+    lines = []
+    for name, sym in sorted(symbols.items()):
+        if sym.type == "class": icon = "📦"
+        elif sym.type == "method": icon = "  ƒ"
+        elif sym.type == "async_function": icon = "⚡"
+        elif sym.type == "variable": icon = "🔹"
+        else: icon = "ƒ"
+        
+        lines.append(f"{icon} {sym.type} {sym.name}{sym.signature}")
+    return "\n".join(lines)