codigest 0.3.0__py3-none-any.whl

codigest/core/shadow.py

@@ -0,0 +1,171 @@
+"""
+Context Anchor Engine.
+"""
+import shutil
+import subprocess
+import time
+from pathlib import Path
+from loguru import logger
+
+class ContextAnchor:
+    def __init__(self, root_path: Path):
+        self.root = root_path
+        self.anchor_dir = root_path / ".codigest" / "anchor"
+        self.git_dir = self.anchor_dir / ".git"
+
+    def has_history(self) -> bool:
+        """Checks if a valid anchor (git repo with commits) exists."""
+        return self.git_dir.exists() and (self.anchor_dir / ".git" / "HEAD").exists()
+
+    def _run_git(self, args: list[str], cwd: Path = None, check=True) -> str:
+        target_dir = cwd or self.anchor_dir
+        cmd = ["git"] + args
+        result = subprocess.run(
+            cmd, cwd=target_dir, capture_output=True, text=True, encoding='utf-8', errors='replace'
+        )
+        if check and result.returncode != 0:
+            logger.debug(f"Shadow Git Warning: {result.stderr}")
+        return (result.stdout or "").strip()
+
+    def update(self, source_files: list[Path]):
+        if not self.git_dir.exists():
+            self.anchor_dir.mkdir(parents=True, exist_ok=True)
+            self._run_git(["init"])
+            self._run_git(["config", "user.email", "codigest@ai"])
+            self._run_git(["config", "user.name", "Context Manager"])
+            self._run_git(["config", "core.autocrlf", "false"])
+            self._run_git(["config", "gc.auto", "0"])
+
+        for item in self.anchor_dir.iterdir():
+            if item.name == ".git":
+                continue
+            if item.is_dir():
+                shutil.rmtree(item)
+            else:
+                item.unlink()
+
+        for src in source_files:
+            if ".git" in src.parts:
+                continue
+            try:
+                rel = src.relative_to(self.root)
+                dest = self.anchor_dir / rel
+                dest.parent.mkdir(parents=True, exist_ok=True)
+                shutil.copy2(src, dest)
+            except Exception:
+                continue
+
+        self._run_git(["add", "."])
+        if self._run_git(["status", "--porcelain"]):
+            self._run_git(["commit", "-m", f"Snapshot: {int(time.time())}"])
+            logger.info("Context anchor updated.")
+
+    def get_changes(self, current_files: list[Path]) -> str:
+        if not self.git_dir.exists():
+            return ""
+
+        temp_current = self.root / ".codigest" / "temp_diff_current"
+        temp_baseline = self.root / ".codigest" / "temp_diff_baseline"
+        
+        for d in [temp_current, temp_baseline]:
+            if d.exists():
+                shutil.rmtree(d)
+            d.mkdir(parents=True)
+
+        try:
+            current_rel_paths = set()
+            for src in current_files:
+                if ".git" in src.parts:
+                    continue
+                try:
+                    rel = src.relative_to(self.root)
+                    current_rel_paths.add(rel)
+                    dest = temp_current / rel
+                    dest.parent.mkdir(parents=True, exist_ok=True)
+                    shutil.copy2(src, dest)
+                except Exception:
+                    continue
+
+            subprocess.run(
+                ["git", "--git-dir", str(self.git_dir), "--work-tree", str(temp_baseline), "checkout", "HEAD", "--", "."],
+                capture_output=True, check=False
+            )
+
+            self._prune_ignored_files(temp_baseline, current_rel_paths)
+
+            result = subprocess.run(
+                ["git", "diff", "--no-index", "--no-prefix", "temp_diff_baseline", "temp_diff_current"],
+                cwd=self.root / ".codigest",
+                capture_output=True, text=True, encoding='utf-8', errors='replace'
+            )
+            
+            diff_text = (result.stdout or "")
+            diff_text = diff_text.replace("temp_diff_baseline/", "").replace("temp_diff_current/", "")
+            return diff_text
+
+        finally:
+            for d in [temp_current, temp_baseline]:
+                if d.exists():
+                    shutil.rmtree(d)
+
+    def _prune_ignored_files(self, baseline_dir: Path, valid_rel_paths: Set[Path]):
+        for file_path in baseline_dir.rglob("*"):
+            if file_path.is_file() and ".git" not in file_path.parts:
+                try:
+                    rel_path = file_path.relative_to(baseline_dir)
+                    if rel_path in valid_rel_paths:
+                        continue
+                    
+                    real_file = self.root / rel_path
+                    if real_file.exists():
+                        file_path.unlink()
+                except Exception:
+                    continue
+
+    def get_last_update_time(self) -> str:
+        if not self.git_dir.exists():
+            return "Never"
+        try:
+            return self._run_git(["log", "-1", "--format=%cr"])
+        except:
+            return "Unknown"
+
+    def read_anchor_file(self, rel_path: Path) -> str:
+        """
+        Reads the content of a file from the Shadow Git HEAD (Baseline).
+        Used for comparing Old vs New AST.
+        """
+        if not self.git_dir.exists():
+            return ""
+        
+        # Git expects forward slashes
+        git_path = rel_path.as_posix()
+        
+        # git show HEAD:path/to/file
+        result = subprocess.run(
+            ["git", "--git-dir", str(self.git_dir), "--work-tree", str(self.anchor_dir), "show", f"HEAD:{git_path}"],
+            capture_output=True, text=True, encoding='utf-8', errors='replace'
+        )
+        
+        if result.returncode != 0:
+            # File might be new (not in anchor), return empty string
+            return ""
+            
+        return result.stdout
+
+    def get_changed_files(self, current_files: list[Path]) -> list[Path]:
+        """Returns list of paths that have text diffs (Modified/Added/Deleted)."""
+        raw_diff = self.get_changes(current_files)
+        paths = set()
+        for line in raw_diff.splitlines():
+            # diff --git a/src/main.py b/src/main.py
+            if line.startswith("diff --git"):
+                parts = line.split()
+                # Parse paths (rough parsing, robust enough for standard names)
+                # usually parts[-1] is b/path, parts[-2] is a/path
+                if len(parts) >= 4:
+                    # Clean "a/" or "b/"
+                    p = parts[-1]
+                    if p.startswith("b/") or p.startswith("a/"): p = p[2:]
+                    paths.add(self.root / p)
+        return sorted(list(paths))

codigest/core/structure.py

@@ -0,0 +1,48 @@
+from pathlib import Path
+
+def generate_toon(paths: list[Path], root_dir: Path) -> str:
+    """(Phase 2: Digest용) TOON 포맷 생성기 (Placeholder)"""
+    return "# TOON generation logic here"
+
+def generate_ascii_tree(paths: list[Path], root_dir: Path) -> str:
+    """
+    [Legacy Style] Generates a standard ASCII directory tree.
+    Ref: Ported from original codigest prototype.
+    """
+    lines = []
+    # Set for fast lookup
+    path_set = set(paths)
+    
+    def _walk(current_path: Path, prefix: str = ""):
+        try:
+            # 현재 디렉토리의 모든 항목 가져오기
+            all_items = sorted(current_path.iterdir(), key=lambda x: x.name)
+        except PermissionError:
+            return
+
+        # 필터링: 스캔된 파일이거나, 스캔된 파일을 포함하는 디렉토리여야 함
+        filtered_items = []
+        for item in all_items:
+            if item.is_file():
+                if item in path_set:
+                    filtered_items.append(item)
+            elif item.is_dir():
+                # 디렉토리 안에 유효한 파일이 하나라도 있는지 확인 (Deep Check)
+                # 성능 최적화를 위해 문자열 startswith 체크
+                item_str = str(item)
+                if any(str(p).startswith(item_str) for p in path_set):
+                    filtered_items.append(item)
+
+        count = len(filtered_items)
+        for i, item in enumerate(filtered_items):
+            is_last = (i == count - 1)
+            connector = "└── " if is_last else "├── "
+            
+            lines.append(f"{prefix}{connector}{item.name}")
+            
+            if item.is_dir():
+                extension = "    " if is_last else "│   "
+                _walk(item, prefix + extension)
+
+    _walk(root_dir)
+    return "\n".join(lines)

codigest/core/tags.py

@@ -0,0 +1,75 @@
+"""
+Core Template Engine using Python Tag Strings.
+Advanced Logic: Structure-Aware Dedent & XML Safety.
+"""
+import html
+import textwrap
+from typing import Any, Callable
+
+def _get_common_indent(parts: list[str]) -> int:
+    """Calculates minimum indentation from static template parts."""
+    min_indent = None
+    for part in parts:
+        for line in part.splitlines():
+            if not line.strip():
+                continue
+            indent = len(line) - len(line.lstrip())
+            if min_indent is None or indent < min_indent:
+                min_indent = indent
+    return min_indent or 0
+
+def _dedent_line(line: str, indent: int) -> str:
+    """
+    Safely removes indentation from a single line.
+    """
+    if not line.strip():
+        return "\n" if line.endswith("\n") else ""
+
+    if line.startswith(" " * indent):
+        return line[indent:]
+
+    return line.lstrip(" ")
+
+def escape_xml_value(value: Any) -> str:
+    """[XML] Escapes characters for XML safety."""
+    raw_value = str(value)
+    safe_value = html.escape(raw_value, quote=False)
+    if "</" in safe_value:
+        safe_value = safe_value.replace("</", "&lt;/")
+    return safe_value
+
+def no_escape(value: Any) -> str:
+    """[Plain] Returns string as-is (for dedent)."""
+    return str(value)
+
+def _render_structure_aware(template: Any, escape_fn: Callable[[Any], str]) -> str:
+    """
+    Core Logic: Dedents based on static structure, then injects processed values.
+    """
+    if isinstance(template, str):
+        return textwrap.dedent(template).strip()
+
+    static_parts = [p for p in template if isinstance(p, str)]
+    common_indent = _get_common_indent(static_parts)
+    
+    result = []
+    
+    for part in template:
+        if isinstance(part, str):
+            # Dedent static parts
+            lines = part.splitlines(keepends=True)
+            dedented_lines = [_dedent_line(line, common_indent) for line in lines]
+            result.append("".join(dedented_lines))
+        else:
+            # Inject dynamic value
+            result.append(escape_fn(part.value))
+
+    return "".join(result).lstrip()
+
+def xml(template: Any) -> str:
+    """[Python 3.14 Native Tag] XML Generator."""
+    return _render_structure_aware(template, escape_xml_value)
+
+def dedent(template: Any) -> str:
+    """[Python 3.14 Native Tag] Plain Text Generator."""
+    return _render_structure_aware(template, no_escape)

codigest/core/tokenizer.py

@@ -0,0 +1,14 @@
+"""
+Lightweight Token Estimator.
+"""
+import math
+
+def estimate_tokens(text: str) -> int:
+    """
+    Estimates token count based on character length.
+    Rule of thumb for GPT-4 (cl100k_base): ~4 characters per token.
+    This avoids heavy dependencies like tiktoken while providing a useful metric.
+    """
+    if not text:
+        return 0
+    return math.ceil(len(text) / 4)

codigest/main.py

@@ -0,0 +1,34 @@
+"""
+Entry Point with Global Error Handling
+"""
+import sys
+import typer
+from rich.console import Console
+from .commands import init, scan, tree, digest, diff, semdiff
+
+console = Console()
+
+app = typer.Typer(
+    name="codigest",
+    help="Semantic Context Manager for LLM-assisted Development",
+    add_completion=False,
+    no_args_is_help=True
+)
+
+app.add_typer(init.app, name="init")
+app.add_typer(scan.app, name="scan")
+app.add_typer(tree.app, name="tree")
+app.add_typer(digest.app, name="digest")
+app.add_typer(diff.app, name="diff")
+app.add_typer(semdiff.app, name="semdiff")
+
+def main():
+    try:
+        app()
+    except Exception as e:
+        error_msg = str(e)
+        console.print(f"[bold red]❌ Error:[/bold red] {error_msg}")
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()

codigest-0.3.0.dist-info/METADATA

@@ -0,0 +1,145 @@
+Metadata-Version: 2.4
+Name: codigest
+Version: 0.3.0
+Summary: Human-Centered Codebase Context Manager for LLMs
+Project-URL: Homepage, https://github.com/SJB777/codigest
+Project-URL: Repository, https://github.com/SJB777/codigest
+Project-URL: Issues, https://github.com/SJB777/codigest/issues
+Author-email: Codigest Team <sngd024@google.com>
+License: MIT
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Utilities
+Requires-Python: >=3.14
+Requires-Dist: loguru
+Requires-Dist: pathspec
+Requires-Dist: pyperclip
+Requires-Dist: rich
+Requires-Dist: tomli-w
+Requires-Dist: typer
+Description-Content-Type: text/markdown
+
+# Codigest
+
+Codigest is a CLI tool designed to extract, structure, and track the context of your codebase for Large Language Models (LLMs).
+
+Unlike simple copy-paste tools, Codigest employs a **Context Anchor** system (Shadow Git) to track changes locally without polluting your main version control history. It also features **Semantic Analysis** to detect structural changes in your code.
+
+## Core Philosophy
+
+* **Read-Only & Safe**: Codigest never modifies your source code. It only reads, analyzes, and formats context.
+* **Context-Aware**: Instead of dumping raw text, it structures code into XML snapshots designed for LLM comprehension.
+* **Session-Based Tracking**: It maintains an internal anchor to track "work-in-progress" changes independently of your Git commits.
+* **Python 3.14 Native**: Built using modern Python features including PEP 750 Tag Strings for safe XML generation.
+
+## Installation
+
+Requires **Python 3.14+**.
+
+```bash
+# Install via uv
+git clone https://github.com/SJB7777/codigest.git
+cd codigest
+uv tool install .
+````
+
+## Workflow & Commands
+
+### 1\. Initialization
+
+Sets up the `.codigest` directory and captures the initial baseline anchor.
+
+```bash
+codigest init
+```
+
+### 2\. Full Context Snapshot (`scan`)
+
+Scans the entire codebase and generates a structured XML snapshot.
+
+  * **Output:** `.codigest/snapshot.xml`
+  * **Use Case:** Providing the LLM with the full project context at the start of a session.
+  * **Side Effect:** Updates the internal Context Anchor to the current state.
+
+```bash
+codigest scan --m " Python 3.14 project. Do NOT use typing. List/Dict."
+```
+
+### 3\. Incremental Changes (`diff`)
+
+Tracks text-based changes between the last `scan` and the current working tree.
+
+  * **Output:** `.codigest/changes.diff`
+  * **Use Case:** "I modified 3 files. Here is exactly what changed since the last snapshot."
+  * **Note:** This is based on the internal Shadow Git, not your project's Git history.
+
+```bash
+codigest diff
+```
+
+### 4\. Semantic Analysis (`semdiff`)
+
+Analyzes **structural changes** (AST-based) rather than line-by-line text differences.
+
+  * **Output:** `.codigest/semdiff.xml`
+  * **Use Case:** "I refactored the API. Show me which functions were added, removed, or had their signatures changed."
+  * **Benefit:** Significantly reduces token usage compared to raw diffs by ignoring formatting/comment changes.
+
+```bash
+codigest semdiff
+```
+
+### 5\. Architecture Digest (`digest`)
+
+Generates a high-level outline of the project structure (Classes, Functions, Methods only).
+
+  * **Output:** `.codigest/digest.xml`
+  * **Use Case:** "Don't read the implementation details. Just understand the class hierarchy and available methods."
+
+<!-- end list -->
+
+```bash
+codigest digest
+```
+
+## Configuration
+
+You can customize behavior in `.codigest/config.toml`.
+
+```toml
+[filter]
+# Target extensions
+extensions = [".py", ".ts", ".rs", ".md", ".json"]
+
+# Exclude patterns (Gitignore syntax)
+exclude_patterns = [
+    "*.lock",
+    "tests/data/",
+    "legacy_code/"
+]
+
+[output]
+format = "xml"
+```
+
+## Architecture Details
+
+**Context Anchor (Shadow Git)**
+Codigest maintains a hidden, lightweight Git repository inside `.codigest/anchor`.
+
+  * When you run `scan`, the current state is committed to this anchor.
+  * When you run `diff`, the tool compares your working directory against this anchor.
+  * When you run `semdiff`, the tool parses the AST of the anchor version and the current version to detect logical drifts.
+
+**Safety Mechanisms**
+
+  * **structure-aware dedent:** Ensures XML tags are perfectly aligned regardless of code indentation.
+  * **Automatic Exclusion:** Self-referential files (`.codigest/`) are automatically ignored to prevent recursion loops.
+
+## License
+
+MIT License

codigest-0.3.0.dist-info/RECORD

@@ -0,0 +1,22 @@
+codigest/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+codigest/config.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+codigest/main.py,sha256=xbs8o9NFt6DjF2LtC7vyNXN-3jZjwt_N6MD9yjw892w,799
+codigest/commands/diff.py,sha256=uAJkg5vdNAeJcEJfYtM-cDxgtfm2gAqKiOGtRzXQ4JQ,2939
+codigest/commands/digest.py,sha256=LRJH6sySaHw1et8654Gr25mjfdP-PImT16zKG7fUcnI,3149
+codigest/commands/init.py,sha256=R-wTGP3bmBT2-ZMpd2KQTroY83wyOkFjDdiP-tRdq40,2771
+codigest/commands/scan.py,sha256=m6QLfFnkTI-8C4D1L7BKLZIUTPF3Xp5dOHdhtQjs6Rw,5099
+codigest/commands/semdiff.py,sha256=zRQMdpQMdhM6p9Gto8XC3tFEop-ngICYML_qQ9TaZqg,4896
+codigest/commands/tree.py,sha256=pB1k842h6u-Lt1s_J0rDYq55ffaXdczo0PiR4uAzhTg,3717
+codigest/core/git_ops.py,sha256=AAAlRR-b8DPOctARhtnzT5gqrnVjcJgPJzoKz8nEumk,2340
+codigest/core/processor.py,sha256=1VUtzvnqA_JwZ7M2p3CpwBKxffMGkGOb0wGdHOOe-cE,881
+codigest/core/prompts.py,sha256=FwbrHeFlNxcHm6KziBudFB9sL3Y6UjaLQoL3x7DKXq4,5196
+codigest/core/scanner.py,sha256=R8FIKHkvhiQb6CPpne1gtusXtMddj-28n-IRs3k0gAc,3715
+codigest/core/semdiff.py,sha256=m_fU3q4eMjl-hKdnPzvgyIqHGm25wLPoKTGkYlhemqM,6047
+codigest/core/shadow.py,sha256=NqDkJwtyE9PtI_4MNn3DgthmsmCbIE0PSOxuP9PmVWY,6493
+codigest/core/structure.py,sha256=u7qNGD-Kr1UcaBkAixkQLo2uJgfZl5qxZf-gwONe6FY,1828
+codigest/core/tags.py,sha256=BmuTkAdq79NnkKCq4QFRB24bhq0PebX6uvUx9dK8tag,2395
+codigest/core/tokenizer.py,sha256=wuhtOyU0LEHt5K2_GcJm0smxBj-gu3bf4Df6msb7W4k,378
+codigest-0.3.0.dist-info/METADATA,sha256=DJA0yvvxayUsiW8E_j9b951ck-DCrPFAba2yqK8ez-I,4649
+codigest-0.3.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+codigest-0.3.0.dist-info/entry_points.txt,sha256=0WsGyQpgl2_MxzxR_KUSmDBSbIBu4V-TL-XzgWPORcc,47
+codigest-0.3.0.dist-info/RECORD,,

codigest-0.3.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.28.0
+Root-Is-Purelib: true
+Tag: py3-none-any

codigest-0.3.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+codigest = codigest.main:app