codigest 0.3.1__tar.gz → 0.3.2__tar.gz

{codigest-0.3.1 → codigest-0.3.2}/.github/workflows/publish.yml

@@ -19,15 +19,15 @@ jobs:
     steps:
     - uses: actions/checkout@v4
     
-    # [변경] uv 설치 (가장 빠르고 확실한 방법)
+    # uv 설치 (가장 빠르고 확실한 방법)
     - name: Install uv
       uses: astral-sh/setup-uv@v5
     
-    # [변경] Python 3.14 설정 (uv 이용)
+    # Python 3.14 설정 (uv 이용)
     - name: Set up Python
       run: uv python install 3.14
     
-    # [변경] 의존성 설치 및 빌드 (uv build 하나로 해결)
+    # 의존성 설치 및 빌드 (uv build 하나로 해결)
     - name: Build package
       run: uv build
     

{codigest-0.3.1 → codigest-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codigest
-Version: 0.3.1
+Version: 0.3.2
 Summary: Human-Centered Codebase Context Manager for LLMs
 Project-URL: Homepage, https://github.com/SJB777/codigest
 Project-URL: Repository, https://github.com/SJB777/codigest

{codigest-0.3.1 → codigest-0.3.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "codigest"
-version = "0.3.1"
+version = "0.3.2"
 description = "Human-Centered Codebase Context Manager for LLMs"
 authors = [{name = "Codigest Team", email = "sngd024@google.com"}]
 readme = "README.md"

codigest-0.3.2/src/codigest/__main__.py

@@ -0,0 +1,4 @@
+from .main import main
+
+if __name__ == "__main__":
+    main()

{codigest-0.3.1 → codigest-0.3.2}/src/codigest/commands/diff.py

@@ -12,6 +12,15 @@ console = Console()
 
 @app.callback(invoke_without_command=True)
 def handle(
+    # target 인자 추가
+    target: Path = typer.Argument(
+        Path.cwd(), 
+        help="Target directory to check diff",
+        exists=True,
+        file_okay=False,
+        dir_okay=True,
+        resolve_path=True
+    ),
     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"),
@@ -20,7 +29,7 @@ def handle(
     [Context Update] Shows changes since the last 'codigest scan'.
     Useful for updating LLM context without re-uploading everything.
     """
-    root_path = Path.cwd()
+    root_path = target
     anchor = shadow.ContextAnchor(root_path)
     
     # 1. Check Baseline Existence

{codigest-0.3.1 → codigest-0.3.2}/src/codigest/commands/digest.py

@@ -49,11 +49,7 @@ def handle(
                     
                     if summary:
                         rel_path = file_path.relative_to(root_path).as_posix()
-                        block = tags.xml(t"""
-                        <file path="{rel_path}">
-                        {summary}
-                        </file>
-                        """)
+                        block = tags.file(rel_path, summary)
                         summary_blocks.append(block)
                 except Exception:
                     continue

{codigest-0.3.1 → codigest-0.3.2}/src/codigest/commands/init.py

@@ -35,12 +35,22 @@ structure = "toon"
 
 @app.callback(invoke_without_command=True)
 def handle(
+    # target 인자 추가 (기본값: 현재 위치)
+    target: Path = typer.Argument(
+        Path.cwd(), 
+        help="Target directory to initialize",
+        exists=True,
+        file_okay=False,
+        dir_okay=True,
+        resolve_path=True
+    ),
     force: bool = typer.Option(False, "--force", "-f", help="Overwrite existing config"),
 ):
     """
     Initialize the .codigest environment and capture the initial state.
     """
-    root_path = Path.cwd()
+    root_path = target  # Typer가 이미 resolve_path=True로 절대경로 변환해줌
+    
     config_dir = root_path / ".codigest"
     config_file = config_dir / "config.toml"
     gitignore_file = root_path / ".gitignore"

{codigest-0.3.1 → codigest-0.3.2}/src/codigest/commands/scan.py

@@ -28,22 +28,52 @@ def _load_config_filters(root_path: Path):
             
     return extensions, exclude_patterns
 
+def _find_project_root(start_path: Path) -> Path:
+    """
+    .codigest 폴더나 .git 폴더가 있는 상위 디렉토리를 찾습니다.
+    못 찾으면 start_path를 반환합니다.
+    """
+    current = start_path.resolve()
+    for parent in [current] + list(current.parents):
+        if (parent / ".codigest").exists() or (parent / ".git").exists():
+            return parent
+    return start_path
+
 @app.callback(invoke_without_command=True)
 def handle(
-    target: Path = typer.Argument(Path.cwd(), help="Target directory"),
+    # targets를 리스트로 받음 (여러 폴더 지정 가능)
+    targets: list[Path] = typer.Argument(
+        None, 
+        help="Specific files or directories to scan (Scope)",
+        exists=True,
+        resolve_path=True
+    ),
     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.
+    Scans the codebase. 
+    If TARGETS provided, only scans those paths within the project.
     """
-    root_path = target.resolve()
+    # 1. 프로젝트 루트 결정 (현재 위치 기준 상위 탐색)
+    root_path = _find_project_root(Path.cwd())
+
+    # 2. Scope 설정
+    # 입력된 targets가 있으면 사용, 없으면 [root_path] 전체
+    scan_scope = targets if targets else None
+
+    # 검증: targets가 root_path 밖에 있으면 경고 (옵션)
+    if scan_scope:
+        for p in scan_scope:
+            if not p.is_relative_to(root_path):
+                console.print(f"[yellow]⚠️  Warning: {p.name} is outside project root {root_path.name}[/yellow]")
+
     artifact_dir = root_path / ".codigest"
 
     if not artifact_dir.exists():
-        console.print("[yellow]⚠️  .codigest directory missing. Running init...[/yellow]")
+        console.print(f"[yellow]⚠️  .codigest directory missing in {root_path.name}. Running init...[/yellow]")
         try:
             artifact_dir.mkdir(exist_ok=True)
         except PermissionError:
@@ -68,7 +98,12 @@ def handle(
     ):
 
         # File Discovery
-        files = scanner.scan_project(root_path, extensions, extra_ignores)
+        files = scanner.scan_project(
+            root_path, 
+            extensions, 
+            extra_ignores, 
+            include_paths=scan_scope
+        )
 
         # Pre-scan Diff Report
         if anchor.has_history():
@@ -89,11 +124,9 @@ def handle(
             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>
-                """)
+                
+
+                block = tags.file(rel_path, content)
                 file_blocks.append(block)
             except Exception:
                 continue

{codigest-0.3.1 → codigest-0.3.2}/src/codigest/commands/semdiff.py

@@ -61,38 +61,42 @@ def handle(
             # 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 = ""
+            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]   " # 내부 로직 변경
+                    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>
-                """)
+                if not new_code:
+                    file_status = " (DELETED)"
+                elif not old_code:
+                    file_status = " (NEW)"
+
+                raw_body = chr(10).join(change_lines)
+                block = tags.file(rel_path.as_posix(), raw_body, status=file_status)
                 reports.append(block)
 
         progress.update(task, completed=100)

{codigest-0.3.1 → codigest-0.3.2}/src/codigest/core/prompts.py

@@ -1,6 +1,6 @@
 """
 Prompt Management Module.
-Philosophy: Defaults are Code (t-strings), Overrides are Data (TOML).
+Templates are aligned flush-left to prevent indentation issues when injecting large code blocks.
 """
 import tomllib
 from pathlib import Path
@@ -14,102 +14,111 @@ RenderFunc = Callable[..., str]
 def _default_snapshot(project_name: str, tree_structure: str, source_code: str, instruction: str = "") -> str:
     instruction_block = ""
     if instruction:
+        safe_instruction = tags.escape_xml_value(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>
-    """)
+<user_instruction>
+{safe_instruction}
+</user_instruction>
+""")
+
+    # Note: source_code is assumed to be already formatted via tags.file()
+    return tags.dedent(f"""
+[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:
+        safe_instruction = tags.escape_xml_value(instruction)
         instruction_block = tags.dedent(f"""
-        <user_instruction>
-        {instruction}
-        </user_instruction>
-        """)
+<user_instruction>
+{safe_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}
+    # Escape raw diff content to prevent XML injection
+    safe_diff = tags.escape_xml_value(diff_content)
 
-        Focus on these modifications to update your context.
+    return tags.dedent(f"""
+[SYSTEM: CODIGEST - INCREMENTAL UPDATE]
+Here are the latest changes for the project "{project_name}".
+{context_message}.
+{instruction_block}
 
-        <git_diff>
-        {diff_content}
-        </git_diff>
-    """)
+Focus on these modifications to update your context.
+
+<git_diff>
+{safe_diff}
+</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:
+        safe_instruction = tags.escape_xml_value(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>
-    """)
+<user_instruction>
+{safe_instruction}
+</user_instruction>
+""")
+
+    return tags.dedent(f"""
+[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]
+# 4. Digest Template (codigest digest)
 def _default_digest(project_name: str, tree_structure: str, digest_content: str, instruction: str = "") -> str:
     instruction_block = ""
     if instruction:
+        safe_instruction = tags.escape_xml_value(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>
-    """)
+<user_instruction>
+{safe_instruction}
+</user_instruction>
+""")
+
+    return tags.dedent(f"""
+[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
@@ -117,7 +126,7 @@ DEFAULT_RENDERERS: Dict[str, RenderFunc] = {
     "snapshot": _default_snapshot,
     "diff": _default_diff,
     "semdiff": _default_semdiff,
-    "digest": _default_digest,  # <--- 이 부분이 누락되었을 수 있습니다.
+    "digest": _default_digest,
 }
 
 class PromptEngine:
@@ -146,6 +155,7 @@ class PromptEngine:
         # 1. Check for TOML Override (String-based)
         if key in self.overrides:
             raw_template = self.overrides[key]
+            # Safety: Automatically escape values when using user-defined templates
             safe_kwargs = {
                 k: tags.escape_xml_value(v) for k, v in kwargs.items()
             }
@@ -156,9 +166,10 @@ class PromptEngine:
 
         # 2. Use Default (Code-based t-string)
         if key in DEFAULT_RENDERERS:
+            # Default functions handle their own escaping logic internally where needed
             return DEFAULT_RENDERERS[key](**kwargs)
 
         return f"Error: Prompt template '{key}' not found."
 
 def get_engine(root_path: Path) -> PromptEngine:
-    return PromptEngine(root_path)
+    return PromptEngine(root_path)

{codigest-0.3.1 → codigest-0.3.2}/src/codigest/core/scanner.py

@@ -16,11 +16,18 @@ ALWAYS_IGNORE = [
 ]
 
 class ProjectScanner:
-    def __init__(self, root_path: Path, extensions: Optional[set[str]] = None, extra_ignores: Optional[list[str]] = None):
+    def __init__(
+            self,
+            root_path: Path,
+            extensions: Optional[set[str]] = None,
+            extra_ignores: Optional[list[str]] = None,
+            include_paths: Optional[list[Path]] = None
+            ):
         self.root_path = root_path
         self.extensions = extensions
         self.extra_ignores = extra_ignores or []
         self.ignore_spec = self._load_gitignore()
+        self.include_paths = include_paths
 
     def _load_gitignore(self) -> pathspec.PathSpec:
         """Loads .gitignore and combines with ALWAYS_IGNORE and extra_ignores."""
@@ -56,17 +63,36 @@ class ProjectScanner:
             
         return self.ignore_spec.match_file(rel_path)
 
+    def _is_included(self, entry: Path) -> bool:
+        """파일이 지정된 include_paths 범위 안에 있는지 확인"""
+        if not self.include_paths:
+            return True
+            
+        for path in self.include_paths:
+            try:
+                entry.relative_to(path)
+                return True
+            except ValueError:
+                continue
+        return False
+
     def scan(self) -> list[Path]:
         """
         Walks the directory tree and returns valid files.
         (Modernized from old core.py's stack-based approach)
         """
         valid_files = []
-        
+        start_dirs = self.include_paths if self.include_paths else [self.root_path]
         # 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]
-        
+        dirs_stack = []
+        for p in start_dirs:
+            if p.is_file():
+                if not self.is_ignored(p):
+                    valid_files.append(p)
+            elif p.is_dir():
+                dirs_stack.append(p)
+
         while dirs_stack:
             current = dirs_stack.pop()
             
@@ -83,6 +109,7 @@ class ProjectScanner:
                 
                 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:
@@ -91,9 +118,14 @@ class ProjectScanner:
                             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 sorted(list(set(valid_files)))
+
+def scan_project(
+    root_path: Path, 
+    extensions: set[str] = None, 
+    extra_ignores: list[str] = None, 
+    include_paths: list[Path] = None
+) -> list[Path]:
+    scanner = ProjectScanner(root_path, extensions, extra_ignores, include_paths)
     return scanner.scan()

codigest-0.3.2/src/codigest/core/tags.py

@@ -0,0 +1,38 @@
+"""
+Core Template Engine & XML Factory.
+Centralizes XML escaping and block generation logic.
+"""
+import html
+import textwrap
+from typing import Any
+
+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 dedent(template: str) -> str:
+    """[Plain] Removes common leading whitespace."""
+    if not isinstance(template, str):
+        template = str(template)
+    return textwrap.dedent(template.expandtabs(4)).strip()
+
+def xml(template: str) -> str:
+    """[XML] Wrapper for dedent (legacy support)."""
+    return dedent(template)
+
+# 파일 블록 생성기 (이스케이프 자동화)
+def file(path: str, content: str, status: str = "") -> str:
+    """
+    Generates a safe <file> block.
+    Automatically escapes the content to prevent XML injection.
+    """
+    safe_content = escape_xml_value(content)
+    
+    # f-string을 왼쪽 벽에 붙여 들여쓰기 문제 원천 차단
+    return f"""<file path="{path}{status}">
+{safe_content}
+</file>"""

{codigest-0.3.1 → codigest-0.3.2}/uv.lock

@@ -16,7 +16,7 @@ wheels = [
 
 [[package]]
 name = "codigest"
-version = "0.3.0"
+version = "0.3.1"
 source = { editable = "." }
 dependencies = [
     { name = "loguru" },

codigest-0.3.1/src/codigest/core/tags.py

@@ -1,75 +0,0 @@
-"""
-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)