codebookx 3.0.0__py3-none-any.whl

codebookx/engine/graph.py

@@ -0,0 +1,144 @@
+import sqlite3
+from pathlib import Path
+from typing import Optional
+
+class KnowledgeGraph:
+    def __init__(self, db_path: str):
+        self.db_path = db_path
+        self._init_db()
+
+    def _get_conn(self):
+        conn = sqlite3.connect(self.db_path)
+        conn.execute("PRAGMA foreign_keys = ON")
+        return conn
+
+    def _init_db(self):
+        with self._get_conn() as conn:
+            conn.execute("PRAGMA journal_mode = WAL")
+            conn.execute("""
+                CREATE TABLE IF NOT EXISTS files (
+                    id INTEGER PRIMARY KEY,
+                    path TEXT UNIQUE,
+                    hash TEXT
+                )
+            """)
+            conn.execute("""
+                CREATE TABLE IF NOT EXISTS symbols (
+                    id INTEGER PRIMARY KEY,
+                    file_id INTEGER,
+                    name TEXT,
+                    type TEXT,
+                    start_line INTEGER,
+                    end_line INTEGER,
+                    code TEXT,
+                    FOREIGN KEY(file_id) REFERENCES files(id) ON DELETE CASCADE
+                )
+            """)
+            conn.execute("""
+                CREATE TABLE IF NOT EXISTS relations (
+                    id INTEGER PRIMARY KEY,
+                    from_id INTEGER,
+                    to_id INTEGER,
+                    type TEXT, -- CALLS, IMPORTS, CONTAINS
+                    FOREIGN KEY(from_id) REFERENCES symbols(id) ON DELETE CASCADE,
+                    FOREIGN KEY(to_id) REFERENCES symbols(id) ON DELETE CASCADE
+                )
+            """)
+
+    def get_file_hash(self, path: str) -> Optional[str]:
+        with self._get_conn() as conn:
+            res = conn.execute("SELECT hash FROM files WHERE path=?", (path,)).fetchone()
+            return res[0] if res else None
+
+    def clear_file_symbols(self, file_id: int):
+        with self._get_conn() as conn:
+            conn.execute("DELETE FROM symbols WHERE file_id=?", (file_id,))
+
+    def add_file(self, path: str, file_hash: str) -> int:
+        with self._get_conn() as conn:
+            cursor = conn.execute(
+                "INSERT INTO files (path, hash) VALUES (?, ?) ON CONFLICT(path) DO UPDATE SET hash=excluded.hash", 
+                (path, file_hash)
+            )
+            # Fetch the id for the path
+            return conn.execute("SELECT id FROM files WHERE path=?", (path,)).fetchone()[0]
+
+    def add_symbol(self, file_id: int, name: str, sym_type: str, start: int, end: int, code: str) -> int:
+        with self._get_conn() as conn:
+            cursor = conn.execute(
+                "INSERT INTO symbols (file_id, name, type, start_line, end_line, code) VALUES (?, ?, ?, ?, ?, ?)",
+                (file_id, name, sym_type, start, end, code)
+            )
+            return cursor.lastrowid
+
+    def add_relation(self, from_id: int, to_id: int, rel_type: str):
+        with self._get_conn() as conn:
+            conn.execute(
+                "INSERT INTO relations (from_id, to_id, type) VALUES (?, ?, ?)",
+                (from_id, to_id, rel_type)
+            )
+
+    def get_all_symbol_context(self) -> str:
+        with self._get_conn() as conn:
+            rows = conn.execute("""
+                SELECT s.name, s.type, f.path, s.code
+                FROM symbols s
+                JOIN files f ON s.file_id = f.id
+                ORDER BY f.path, s.name
+            """).fetchall()
+        parts = []
+        for name, sym_type, path, code in rows:
+            parts.append(f"{sym_type}: {name} ({path})")
+            if code:
+                parts.append(f"  ```\n{code[:500]}\n  ```")
+        return "\n".join(parts)
+
+    def get_symbol_context_for_question(self, question: str, top_n: int = 30) -> str:
+        stop_words = {"the", "a", "an", "is", "are", "was", "were", "be", "been",
+                      "being", "have", "has", "had", "do", "does", "did", "will",
+                      "would", "could", "should", "may", "might", "how", "what",
+                      "when", "where", "why", "which", "who", "this", "that",
+                      "these", "those", "it", "its", "in", "on", "at", "to",
+                      "for", "of", "with", "by", "from", "and", "or", "not",
+                      "please", "tell", "me", "about", "work", "explain"}
+        tokens = set(
+            t.lower().rstrip("?.!,;:") for t in question.split()
+            if t.lower().rstrip("?.!,;:") not in stop_words
+            and len(t.rstrip("?.!,;:")) > 1
+        )
+        with self._get_conn() as conn:
+            rows = conn.execute("""
+                SELECT s.name, s.type, f.path, s.code
+                FROM symbols s
+                JOIN files f ON s.file_id = f.id
+                ORDER BY s.name
+            """).fetchall()
+        scored = []
+        for name, sym_type, path, code in rows:
+            name_lower = name.lower()
+            score = sum(1 for t in tokens if t in name_lower)
+            if score > 0:
+                scored.append((score, sym_type, name, path, code))
+        scored.sort(key=lambda x: -x[0])
+        parts = []
+        for _, sym_type, name, path, code in scored[:top_n]:
+            parts.append(f"{sym_type}: {name} ({path})")
+            if code:
+                parts.append(f"  ```\n{code[:500]}\n  ```")
+        return "\n".join(parts)
+
+    def get_symbol_id_by_name(self, name: str) -> Optional[int]:
+        with self._get_conn() as conn:
+            res = conn.execute(
+                "SELECT id FROM symbols WHERE name=? LIMIT 1", (name,)
+            ).fetchone()
+            return res[0] if res else None
+
+    def get_symbol_ids_by_file(self, file_path: str) -> list[int]:
+        with self._get_conn() as conn:
+            rows = conn.execute("""
+                SELECT s.id FROM symbols s
+                JOIN files f ON s.file_id = f.id
+                WHERE f.path=?
+            """, (file_path,)).fetchall()
+            return [r[0] for r in rows]

codebookx/engine/indexer.py

@@ -0,0 +1,127 @@
+import hashlib
+from pathlib import Path
+from typing import List, Dict, Any
+from .graph import KnowledgeGraph
+from .parser import extract_snippets, extract_python_relations, resolve_relative_imports, extract_ts_relations, resolve_ts_relative_imports
+from .vendor.claude_mem_lite import generate_code_skeleton
+
+class Indexer:
+    def __init__(self, root_path: str, db_path: str):
+        self.root = Path(root_path).resolve()
+        self.kg = KnowledgeGraph(db_path)
+        self.skip_dirs = {".git", "node_modules", "__pycache__", "dist", "build"}
+
+    def get_file_hash(self, file_path: Path) -> str:
+        """Calculate SHA-256 hash of file content."""
+        hasher = hashlib.sha256()
+        with open(file_path, "rb") as f:
+            for chunk in iter(lambda: f.read(4096), b""):
+                hasher.update(chunk)
+        return hasher.hexdigest()
+
+    def index(self, force: bool = False):
+        """Run the multi-phase indexing pipeline."""
+        print(f"🔍 Indexing {self.root}...")
+        
+        # Phase 1: Discovery
+        files = self._discover_files()
+        
+        # Phase 2: Parsing & Ingestion
+        for file_path in files:
+            rel_path = str(file_path.relative_to(self.root))
+            file_hash = self.get_file_hash(file_path)
+            
+            # Check if file changed or force re-index
+            existing_hash = self.kg.get_file_hash(rel_path)
+            if not force and existing_hash == file_hash:
+                continue
+            
+            # TODO: Replace with RETURNING id when SQLite minimum version allows
+            file_id = self.kg.add_file(rel_path, file_hash)
+            self.kg.clear_file_symbols(file_id)
+            
+            # Use core extraction for now (Phase 1 legacy)
+            source = file_path.read_text(errors="ignore")
+            snippets = extract_snippets(file_path, source)
+            
+            # P1.1: Skeleton fallback for non-Python/JS languages
+            if not snippets and file_path.suffix in (".go", ".rs", ".java", ".cpp", ".cs"):
+                skeleton = generate_code_skeleton(file_path)
+                if skeleton:
+                    snippets = [{
+                        "name": file_path.stem,
+                        "start": 1,
+                        "end": skeleton.count("\n") + 1,
+                        "code": skeleton,
+                        "type": "module",
+                    }]
+            
+            # Map FQN to DB ID for relations
+            symbol_ids = {}
+            for snip in snippets:
+                sym_id = self.kg.add_symbol(
+                    file_id, 
+                    snip["name"], 
+                    snip["type"], 
+                    snip["start"], 
+                    snip["end"], 
+                    snip["code"]
+                )
+                symbol_ids[snip["name"]] = sym_id
+                
+                # Wire relations if parent exists
+                parent_name = snip.get("parent")
+                if parent_name and parent_name in symbol_ids:
+                    self.kg.add_relation(symbol_ids[parent_name], sym_id, "CONTAINS")
+
+        # Phase 3: Two-pass post-processing for CALLS/IMPORTS (Python + JS/TS)
+        ts_extensions = {".ts", ".tsx", ".js", ".jsx"}
+        py_files = [f for f in files if f.suffix == ".py"]
+        ts_files = [f for f in files if f.suffix in ts_extensions]
+        lang_files = [
+            (py_files, extract_python_relations, resolve_relative_imports),
+            (ts_files, extract_ts_relations, resolve_ts_relative_imports),
+        ]
+
+        if py_files or ts_files:
+            print("  Resolving CALLS/IMPORTS...")
+
+            # Pass 1: Build map of all symbol names -> id across all languages
+            all_symbols = {}
+            for file_path in py_files + ts_files:
+                source = file_path.read_text(errors="ignore")
+                snippets = extract_snippets(file_path, source)
+                for snip in snippets:
+                    sid = self.kg.get_symbol_id_by_name(snip["name"])
+                    if sid:
+                        all_symbols[snip["name"]] = sid
+
+            # Pass 2: Extract + resolve + wire relations per language
+            for file_list, extract_fn, resolve_fn in lang_files:
+                for file_path in file_list:
+                    source = file_path.read_text(errors="ignore")
+                    rels = extract_fn(source)
+                    rels = resolve_fn(file_path, rels)
+                    for rel in rels:
+                        target_name = rel["target"]
+                        bare_name = target_name.split(".")[-1]
+                        resolved = all_symbols.get(target_name) or all_symbols.get(bare_name)
+                        if resolved:
+                            from_ids = self.kg.get_symbol_ids_by_file(
+                                str(file_path.relative_to(self.root))
+                            )
+                            for fid in from_ids:
+                                self.kg.add_relation(fid, resolved, rel["type"])
+
+        print(f"✅ Indexing complete. Knowledge Graph updated.")
+
+    def _discover_files(self) -> List[Path]:
+        import os
+        files = []
+        for root, dirs, filenames in os.walk(self.root):
+            dirs[:] = [d for d in dirs if d not in self.skip_dirs]
+            for f in filenames:
+                file_path = Path(root) / f
+                if file_path.suffix in (".py", ".ts", ".tsx", ".js", ".jsx", ".go", ".rs", ".java", ".cpp", ".cs"):
+                    files.append(file_path)
+        return files

codebookx/engine/parser.py

@@ -0,0 +1,337 @@
+import ast
+import re
+from pathlib import Path
+
+def extract_python_functions(source: str) -> list[dict]:
+    snippets = []
+    try:
+        tree = ast.parse(source)
+        lines = source.splitlines()
+        
+        def traverse(node, parent_name=None):
+            for child in ast.iter_child_nodes(node):
+                if isinstance(child, (ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef)):
+                    fqn = f"{parent_name}.{child.name}" if parent_name else child.name
+                    start = child.lineno - 1
+                    end = child.end_lineno
+                    snippets.append({
+                        "name": fqn,
+                        "start": child.lineno,
+                        "end": child.end_lineno,
+                        "code": "\n".join(lines[start:end]),
+                        "type": "class" if isinstance(child, ast.ClassDef) else "function",
+                        "parent": parent_name
+                    })
+                    # Recurse into the scope of this class/function
+                    traverse(child, fqn)
+                else:
+                    # Generic traversal for non-scope nodes (If, Try, With, etc.)
+                    # Recurse without changing scope
+                    traverse(child, parent_name)
+                    
+        traverse(tree)
+    except SyntaxError: pass
+    return snippets
+
+def extract_python_relations(source: str) -> list[dict]:
+    """Extract CALLS and IMPORTS from Python AST.
+    Returns list of {type, target, line, level} dicts."""
+    relations = []
+    try:
+        tree = ast.parse(source)
+        for node in ast.walk(tree):
+            if isinstance(node, (ast.Import, ast.ImportFrom)):
+                names = node.names
+                if isinstance(node, ast.Import):
+                    for alias in names:
+                        relations.append({"type": "IMPORTS", "target": alias.name, "line": node.lineno, "level": 0})
+                else:  # ImportFrom
+                    module = node.module or ""
+                    rel_level = getattr(node, 'level', 0)
+                    for alias in names:
+                        full_name = f"{module}.{alias.name}" if module else alias.name
+                        relations.append({"type": "IMPORTS", "target": full_name, "line": node.lineno, "level": rel_level})
+            elif isinstance(node, ast.Call):
+                if isinstance(node.func, ast.Name):
+                    relations.append({"type": "CALLS", "target": node.func.id, "line": node.lineno})
+                elif isinstance(node.func, ast.Attribute):
+                    # e.g., obj.method() → target = "method"
+                    relations.append({"type": "CALLS", "target": node.func.attr, "line": node.lineno})
+    except (SyntaxError, Exception):
+        pass
+    return relations
+
+def resolve_relative_imports(file_path: Path, rels: list[dict]) -> list[dict]:
+    """
+    Resolves relative imports (level > 0) to absolute dotted module paths 
+    by walking up the package tree.
+    """
+    resolved_rels = []
+    for rel in rels:
+        if rel["type"] != "IMPORTS" or rel.get("level", 0) == 0:
+            resolved_rels.append(rel)
+            continue
+
+        level = rel["level"]
+        target = rel["target"]
+        
+        # Determine package base directory
+        # level 1 = same dir, level 2 = parent dir, etc.
+        base_dir = file_path.parent
+        for _ in range(level - 1):
+            if base_dir.parent == base_dir: # Reached root
+                break
+            base_dir = base_dir.parent
+
+        # Discover package prefix by walking UP from base_dir as long as __init__.py exists
+        prefix_parts = []
+        walk_dir = base_dir
+        while (walk_dir / "__init__.py").exists():
+            prefix_parts.insert(0, walk_dir.name)
+            if walk_dir.parent == walk_dir:
+                break
+            walk_dir = walk_dir.parent
+            
+        # Build resolved target
+        target_parts = target.split(".")
+        resolved_name = ".".join(prefix_parts + target_parts)
+        
+        new_rel = rel.copy()
+        new_rel["target"] = resolved_name
+        new_rel["level"] = 0 # Now absolute
+        resolved_rels.append(new_rel)
+        
+    return resolved_rels
+
+def extract_ts_relations(source: str) -> list[dict]:
+    """
+    Extract ES module imports and exports from JS/TS source.
+    Uses a state machine to ignore matches inside strings and comments.
+    """
+    relations = []
+    lines = source.splitlines()
+    
+    # Combined regex for:
+    # 1. import/export ... from './path'
+    # 2. import('./path') [dynamic]
+    # 3. import './path' [side-effect]
+    import_re = re.compile(
+        r"""(?:import|export)\s+.*?from\s+['"](\.\.?\/[^'"]+)['"]"""
+        r"""|import\s*\(\s*['"](\.\.?\/[^'"]+)['"]\s*\)"""
+        r"""|import\s+['"](\.\.?\/[^'"]+)['"]"""
+    )
+
+    in_string = False
+    string_char = None
+    in_block_comment = False
+
+    for i, line in enumerate(lines):
+        line_no = i + 1
+        j = 0
+        code_on_line = []
+        
+        # Simple per-line state machine to strip comments
+        while j < len(line):
+            char = line[j]
+            
+            # Block comments
+            if not in_string and not in_block_comment and char == '/' and j + 1 < len(line) and line[j+1] == '*':
+                in_block_comment = True
+                j += 2; continue
+            if in_block_comment and char == '*' and j + 1 < len(line) and line[j+1] == '/':
+                in_block_comment = False
+                j += 2; continue
+            
+            if in_block_comment:
+                j += 1; continue
+                
+            # Line comments
+            if not in_string and char == '/' and j + 1 < len(line) and line[j+1] == '/':
+                break # Skip rest of line
+                
+            # String boundary tracking (but keep the chars)
+            if char in ("'", '"', '`'):
+                if not in_string:
+                    in_string = True
+                    string_char = char
+                elif string_char == char:
+                    in_string = False
+                    string_char = None
+            
+            code_on_line.append(char)
+            j += 1
+            
+        clean_code = "".join(code_on_line)
+        
+        # Heuristic to avoid matching imports inside string assignments
+        # e.g., const s = "import { X } from './mod'";
+        if "=" in clean_code and clean_code.find("=") < clean_code.find("import"):
+            # If it's a dynamic import assignment like 'const p = import("./mod")', 
+            # we might want to keep it, but for v1, skipping is safer than false positives.
+            continue
+
+        for match in import_re.finditer(clean_code):
+            path = next(g for g in match.groups() if g is not None)
+            
+            # Level calculation: ./ -> 1, ../ -> 2, ../../ -> 3
+            if path.startswith('./'):
+                level = 1
+            else:
+                # Count non-empty ".." parts in the path
+                level = len([p for p in path.split('/') if p == '..']) + 1
+                
+            relations.append({
+                "type": "IMPORTS",
+                "target": path,
+                "line": line_no,
+                "level": level
+            })
+            
+    return relations
+
+def resolve_ts_relative_imports(file_path: Path, rels: list[dict]) -> list[dict]:
+    """
+    Resolves relative JS/TS imports to absolute dotted module paths 
+    using Node.js-style extension probing (.ts, .tsx, .js, .jsx).
+    """
+    EXTENSIONS = ['.ts', '.tsx', '.js', '.jsx']
+    INDEX_FILES = [f'index{e}' for e in EXTENSIONS]
+    resolved_rels = []
+
+    for rel in rels:
+        if rel["type"] != "IMPORTS" or rel.get("level", 0) == 0:
+            resolved_rels.append(rel)
+            continue
+
+        level = rel["level"]
+        target = rel["target"]
+        
+        # Base directory from level
+        base = file_path.parent
+        for _ in range(level - 1):
+            if base.parent == base: break
+            base = base.parent
+            
+        # Strip leading dots and slashes: "../../utils/mod" -> "utils/mod"
+        rel_module = re.sub(r'^\.+(?:\/|$)', '', target)
+        candidate = base / rel_module
+        
+        # Extension probing
+        found = None
+        # 1. Try file extensions directly
+        for ext in EXTENSIONS:
+            if candidate.with_suffix(ext).exists():
+                found = candidate.with_suffix(ext)
+                break
+        
+        # 2. Try directory index files
+        if not found and candidate.is_dir():
+            for idx in INDEX_FILES:
+                if (candidate / idx).exists():
+                    found = candidate / idx
+                    break
+                    
+        if found:
+            # Discover package prefix by walking up as long as source files exist in the dir
+            prefix_parts = []
+            walk_dir = base
+            while walk_dir.name and walk_dir.parent != walk_dir:
+                # Check if directory has any JS/TS files in it
+                try:
+                    has_source = any(f.suffix in EXTENSIONS for f in walk_dir.iterdir() if f.is_file())
+                except (PermissionError, FileNotFoundError):
+                    has_source = False
+                
+                if not has_source:
+                    break
+                prefix_parts.insert(0, walk_dir.name)
+                walk_dir = walk_dir.parent
+            
+            # Build resolved dotted path
+            module_parts = rel_module.split("/")
+            resolved_name = ".".join(prefix_parts + module_parts)
+            
+            new_rel = rel.copy()
+            new_rel["target"] = resolved_name
+            new_rel["level"] = 0 # Now absolute
+            resolved_rels.append(new_rel)
+        else:
+            # Graceful fallback: return as level 0 absolute-ish
+            new_rel = rel.copy()
+            new_rel["level"] = 0
+            resolved_rels.append(new_rel)
+            
+    return resolved_rels
+
+def extract_ts_functions(source: str) -> list[dict]:
+    snippets = []
+    lines = source.splitlines()
+    pattern = re.compile(
+        r"^(?:export\s+)?(?:default\s+)?(?:async\s+)?(?:"
+        r"function\s*\*?\s+(\w+)"
+        r"|class\s+(\w+)"
+        r"|const\s+(\w+)\s*=\s*(?:async\s+)?(?:\([^)]*\)|[^=]+)=>"
+        r"|(?!(?:if|for|while|switch|catch)\b)(\w+)\s*\([^)]*\)\s*\{"
+        r")",
+        re.MULTILINE,
+    )
+    
+    for match in pattern.finditer(source):
+        name = next(g for g in match.groups() if g is not None)
+        start_line = source[: match.start()].count("\n")
+        
+        # Forward Depth State Machine
+        depth = 0
+        end_line = start_line
+        in_string = False
+        string_char = None
+        started = False
+        
+        for i in range(start_line, min(start_line + 500, len(lines))):
+            line = lines[i]
+            j = 0
+            while j < len(line):
+                char = line[j]
+                
+                # Handle comments
+                if not in_string and char == '/' and j + 1 < len(line) and line[j+1] == '/':
+                    break # Skip rest of line
+                    
+                # Handle strings/templates
+                if char in ("'", '"', '`'):
+                    if not in_string:
+                        in_string = True
+                        string_char = char
+                    elif string_char == char:
+                        in_string = False
+                        string_char = None
+                
+                if not in_string:
+                    if char == '{':
+                        depth += 1
+                        started = True
+                    elif char == '}':
+                        depth -= 1
+                
+                if started and depth == 0:
+                    end_line = i + 1
+                    break
+                j += 1
+            if started and depth == 0:
+                break
+        
+        snippets.append({
+            "name": name,
+            "start": start_line + 1,
+            "end": end_line,
+            "code": "\n".join(lines[start_line:end_line]),
+            "type": "function"
+        })
+    return snippets
+
+def extract_snippets(file_path: Path, source: str) -> list[dict]:
+    if file_path.suffix == ".py":
+        return extract_python_functions(source)
+    elif file_path.suffix in (".js", ".ts", ".jsx", ".tsx"):
+        return extract_ts_functions(source)
+    return []

codebookx/engine/vendor/claude_mem_lite.py

@@ -0,0 +1,39 @@
+import ast
+from pathlib import Path
+
+def generate_code_skeleton(file_path: Path) -> str:
+    """Generate a compact skeleton of a file (functions and classes only)."""
+    if not file_path.exists():
+        return ""
+    
+    source = file_path.read_text(errors="ignore")
+    skeleton = [f"File: {file_path.name}"]
+    
+    try:
+        if file_path.suffix == ".py":
+            tree = ast.parse(source)
+            for node in tree.body:
+                if isinstance(node, ast.ClassDef):
+                    skeleton.append(f"  Class: {node.name}")
+                    for subnode in node.body:
+                        if isinstance(subnode, (ast.FunctionDef, ast.AsyncFunctionDef)):
+                            skeleton.append(f"    Method: {subnode.name}")
+                        elif isinstance(subnode, ast.ClassDef):
+                            skeleton.append(f"    Nested Class: {subnode.name}")
+                elif isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+                    skeleton.append(f"  Function: {node.name}")
+        elif file_path.suffix in (".ts", ".tsx", ".js", ".jsx"):
+            # Simple regex-based skeleton for JS/TS
+            import re
+            patterns = [
+                r"export\s+(?:async\s+)?function\s+(\w+)",
+                r"export\s+class\s+(\w+)",
+                r"export\s+const\s+(\w+)\s*=",
+            ]
+            for pattern in patterns:
+                for match in re.finditer(pattern, source):
+                    skeleton.append(f"  Symbol: {match.group(1)}")
+    except Exception as e:
+        print(f"Skeleton generation error: {e}")
+        
+    return "\n".join(skeleton)

codebookx/engine/vendor/repomix_lite.py

@@ -0,0 +1,30 @@
+import os
+from pathlib import Path
+from typing import List
+
+def pack_repo(root_path: Path, include_extensions: List[str] = None) -> str:
+    """Pack the repository into a single text block, respecting some ignores."""
+    if include_extensions is None:
+        include_extensions = [".py", ".ts", ".tsx", ".js", ".jsx", ".md", ".txt"]
+    
+    skip_dirs = {".git", "node_modules", "__pycache__", "dist", "build"}
+    packed_output = []
+    
+    for root, dirs, files in os.walk(root_path):
+        # Filter directories in-place to skip them
+        dirs[:] = [d for d in dirs if d not in skip_dirs]
+        
+        for file in files:
+            file_path = Path(root) / file
+            if file_path.suffix.lower() in include_extensions:
+                try:
+                    rel_path = file_path.relative_to(root_path)
+                    content = file_path.read_text(errors="ignore")
+                    
+                    packed_output.append(f"--- BEGIN FILE: {rel_path} ---")
+                    packed_output.append(content)
+                    packed_output.append(f"--- END FILE: {rel_path} ---\n")
+                except Exception:
+                    continue
+                    
+    return "\n".join(packed_output)