@mc1global/opencode-jarvis 0.12.0 → 0.13.1

package/scripts/code_block_manager.py

@@ -0,0 +1,847 @@
+#!/usr/bin/env python3
+"""
+Code Block Manager - Token-Efficient Code Manipulation
+Uses Ollama local LLM for reading/writing specific code blocks.
+Claude API only used for generating the actual code changes.
+
+RAG Auto-Sync Integration:
+- Layer 1 (Proactive): Background RAG update after successful file writes
+- Layer 2 (Reactive): Filesystem check + retry on RAG search miss
+"""
+
+import sys
+import json
+import subprocess
+import re
+import ast
+import os
+from pathlib import Path
+from typing import Dict, List, Optional, Tuple
+import click
+
+PROJECT_ROOT = Path(__file__).parent.parent
+sys.path.insert(0, str(PROJECT_ROOT))
+
+# Import multi-language parser
+try:
+    from scripts.parsers.language_parsers import MultiLanguageParser, detect_language
+    MULTI_LANG_PARSER_AVAILABLE = True
+except ImportError:
+    MULTI_LANG_PARSER_AVAILABLE = False
+
+
+class CodeBlockManager:
+    """Manages extraction and updating of code blocks using Ollama with RAG auto-sync."""
+
+    def __init__(self, ollama_model: str = "llama3.2:3b", enable_rag_sync: bool = True):
+        self.ollama_model = ollama_model
+        self.ollama_base_url = "http://localhost:11434"
+        self.enable_rag_sync = enable_rag_sync
+        self.rag_cli_path = PROJECT_ROOT / "scripts" / "rag" / "rag_cli.py"
+        # Initialize multi-language parser if available
+        self.multi_lang_parser = MultiLanguageParser() if MULTI_LANG_PARSER_AVAILABLE else None
+
+    def _trigger_rag_update(self, file_path: Path) -> None:
+        """
+        Layer 1 (Proactive): Trigger background RAG update for file.
+        Non-blocking - uses subprocess.Popen to avoid blocking workflow.
+
+        Args:
+            file_path: Absolute path to file that was modified
+        """
+        if not self.enable_rag_sync:
+            return
+
+        if not file_path.exists():
+            # Don't index deleted files
+            return
+
+        try:
+            # Background process (detached, non-blocking)
+            subprocess.Popen(
+                [sys.executable, str(self.rag_cli_path), "update", str(file_path)],
+                stdout=subprocess.DEVNULL,
+                stderr=subprocess.DEVNULL,
+                start_new_session=True  # Fully detach from parent
+            )
+        except Exception as e:
+            # Log failure but don't crash (RAG sync is best-effort)
+            print(f"Warning: RAG background update failed: {e}", file=sys.stderr)
+
+    def _search_function_in_rag(
+        self,
+        file_path: Path,
+        function_name: str,
+        _retry_count: int = 0,
+        language: str = "auto"
+    ) -> Optional[str]:
+        """
+        Layer 2 (Reactive): Search for function in RAG with auto-sync fallback.
+        If not found in RAG but exists in filesystem, trigger sync and retry ONCE.
+
+        Args:
+            file_path: Path to file
+            function_name: Function to search for
+            _retry_count: Internal retry counter (prevents infinite loops)
+            language: Programming language ("auto" to detect from extension)
+
+        Returns:
+            Function code if found, None otherwise
+        """
+        # First attempt: use existing get_function method
+        result = self._get_function_direct(file_path, function_name, language=language)
+
+        # If not found and haven't retried yet
+        if result is None and _retry_count == 0:
+            # Layer 2: Check filesystem before retrying
+            if file_path.exists():
+                if self.enable_rag_sync:
+                    # Sync file to RAG (blocking, but only on miss)
+                    try:
+                        subprocess.run(
+                            [sys.executable, str(self.rag_cli_path), "update", str(file_path)],
+                            capture_output=True,
+                            timeout=30
+                        )
+                        # Retry search ONCE
+                        return self._search_function_in_rag(file_path, function_name, _retry_count=1, language=language)
+                    except Exception as e:
+                        print(f"Warning: RAG sync on miss failed: {e}", file=sys.stderr)
+
+        return result
+
+    def _get_function_direct(self, file_path: Path, function_name: str, language: str = "auto") -> Optional[str]:
+        """
+        Direct function extraction without RAG retry logic.
+        Used internally by _search_function_in_rag.
+
+        Args:
+            file_path: Path to file
+            function_name: Name of function to extract
+            language: Programming language ("auto" to detect from extension)
+        """
+        try:
+            with open(file_path, 'r') as f:
+                lines = f.readlines()
+
+            # Use auto-detection for language
+            functions = self.list_functions(file_path, language)
+            target_func = None
+            for func in functions:
+                if func["name"] == function_name:
+                    target_func = func
+                    break
+
+            if not target_func:
+                return None
+
+            start = target_func["line_start"] - 1
+            end = target_func["line_end"]
+            function_code = ''.join(lines[start:end])
+            return function_code
+        except Exception:
+            return None
+
+    def _call_ollama(self, prompt: str, system: str = "") -> str:
+        """Call Ollama API locally (zero token cost)."""
+        try:
+            payload = {
+                "model": self.ollama_model,
+                "prompt": prompt,
+                "stream": False
+            }
+            if system:
+                payload["system"] = system
+
+            result = subprocess.run(
+                ["curl", "-s", "-X", "POST",
+                 f"{self.ollama_base_url}/api/generate",
+                 "-H", "Content-Type: application/json",
+                 "-d", json.dumps(payload)],
+                capture_output=True,
+                text=True,
+                timeout=30
+            )
+
+            if result.returncode != 0:
+                return f"Error: Ollama call failed - {result.stderr}"
+
+            response = json.loads(result.stdout)
+            return response.get("response", "").strip()
+
+        except subprocess.TimeoutExpired:
+            return "Error: Ollama request timeout"
+        except Exception as e:
+            return f"Error: {e}"
+
+    def list_functions(self, file_path: Path, language: str = "auto") -> List[Dict]:
+        """
+        List all functions/methods in a file.
+
+        Priority:
+        1. Python AST (for .py files - most accurate, built-in)
+        2. Tree-sitter via MultiLanguageParser (for supported languages - fast and accurate)
+        3. Ollama fallback (for unsupported languages - slower, less accurate)
+
+        Args:
+            file_path: Path to source file
+            language: Programming language ("auto" to detect from extension)
+
+        Returns: [{"name": "func_name", "line_start": 10, "line_end": 25, "type": "function|method", "parent_class": "ClassName"}, ...]
+        """
+        # Auto-detect language from file extension
+        if language == "auto" and MULTI_LANG_PARSER_AVAILABLE:
+            language = detect_language(file_path)
+
+        # Use Python AST for Python files (most accurate)
+        if language == "python":
+            return self._list_functions_python_ast(file_path)
+
+        # Use tree-sitter based parser for other languages (fast and accurate)
+        if self.multi_lang_parser:
+            try:
+                blocks = self.multi_lang_parser.list_functions(file_path, language)
+                # Convert CodeBlock objects to dict format for backwards compatibility
+                return [
+                    {
+                        "name": block.name,
+                        "line_start": block.line_start,
+                        "line_end": block.line_end,
+                        "type": block.block_type,
+                        "parent_class": block.parent_class,
+                        "signature": block.signature
+                    }
+                    for block in blocks
+                ]
+            except Exception as e:
+                print(f"Warning: Tree-sitter parsing failed, falling back to Ollama: {e}", file=sys.stderr)
+
+        # Fallback to Ollama for unsupported languages
+        return self._list_functions_ollama(file_path, language)
+
+    def _list_functions_python_ast(self, file_path: Path) -> List[Dict]:
+        """
+        List all functions/methods using Python AST parser (fast, accurate, no token cost).
+        """
+        with open(file_path, 'r') as f:
+            content = f.read()
+            lines = content.splitlines()
+
+        try:
+            tree = ast.parse(content)
+        except SyntaxError as e:
+            print(f"Warning: Could not parse {file_path}: {e}", file=sys.stderr)
+            return []
+
+        functions = []
+
+        class FunctionVisitor(ast.NodeVisitor):
+            def visit_FunctionDef(self, node):
+                # Calculate line_end by finding next sibling or end of parent
+                line_end = node.end_lineno if hasattr(node, 'end_lineno') else node.lineno
+                functions.append({
+                    "name": node.name,
+                    "line_start": node.lineno,
+                    "line_end": line_end
+                })
+                self.generic_visit(node)
+
+            def visit_AsyncFunctionDef(self, node):
+                # Handle async functions too
+                line_end = node.end_lineno if hasattr(node, 'end_lineno') else node.lineno
+                functions.append({
+                    "name": node.name,
+                    "line_start": node.lineno,
+                    "line_end": line_end
+                })
+                self.generic_visit(node)
+
+        visitor = FunctionVisitor()
+        visitor.visit(tree)
+
+        return functions
+
+    def _list_functions_ollama(self, file_path: Path, language: str) -> List[Dict]:
+        """
+        List all functions using Ollama (fallback for non-Python languages).
+        """
+        with open(file_path, 'r') as f:
+            content = f.read()
+
+        # For large files, Ollama will timeout - warn user
+        if len(content) > 10000:
+            print(f"Warning: File is large ({len(content)} chars), Ollama may timeout", file=sys.stderr)
+
+        system = f"""You are a code analyzer. Extract all function/method definitions from code.
+Language: {language}
+
+Output ONLY valid JSON array with this format:
+[
+  {{"name": "function_name", "line_start": 1, "line_end": 10}},
+  ...
+]
+
+Rules:
+- Include class methods and standalone functions
+- line_start is where definition begins (def/function keyword)
+- line_end is where function ends (before next function or EOF)
+- No explanations, just JSON array"""
+
+        prompt = f"Analyze this {language} code and list all functions:\n\n```{language}\n{content}\n```"
+
+        response = self._call_ollama(prompt, system)
+
+        # Parse JSON response
+        try:
+            # Extract JSON from response (might have extra text)
+            json_match = re.search(r'\[.*\]', response, re.DOTALL)
+            if json_match:
+                functions = json.loads(json_match.group())
+                return functions
+            return []
+        except json.JSONDecodeError:
+            print(f"Warning: Could not parse Ollama response as JSON", file=sys.stderr)
+            return []
+
+    def get_function(
+        self,
+        file_path: Path,
+        function_name: str,
+        language: str = "auto",
+        use_rag_fallback: bool = True
+    ) -> Optional[str]:
+        """
+        Extract specific function/method code.
+
+        Args:
+            file_path: Path to file
+            function_name: Name of function to extract
+            language: Programming language ("auto" to detect from extension)
+            use_rag_fallback: Enable Layer 2 reactive sync (default: True)
+
+        Returns:
+            Function code or None if not found
+        """
+        if use_rag_fallback and self.enable_rag_sync:
+            # Use Layer 2 reactive sync
+            return self._search_function_in_rag(file_path, function_name, language=language)
+        else:
+            # Direct extraction without RAG
+            return self._get_function_direct(file_path, function_name, language=language)
+
+    def update_function(
+        self,
+        file_path: Path,
+        function_name: str,
+        new_code: str,
+        language: str = "python",
+        dry_run: bool = False
+    ) -> Dict:
+        """
+        Update specific function in file with RAG auto-sync.
+
+        Layer 1 (Proactive): Triggers background RAG update after successful write.
+
+        Returns: {"success": bool, "old_code": str, "new_code": str, "lines_changed": int}
+        """
+        with open(file_path, 'r') as f:
+            lines = f.readlines()
+
+        # Find function location
+        functions = self.list_functions(file_path, language)
+
+        target_func = None
+        for func in functions:
+            if func["name"] == function_name:
+                target_func = func
+                break
+
+        if not target_func:
+            return {
+                "success": False,
+                "error": f"Function '{function_name}' not found in {file_path}"
+            }
+
+        # Extract old code
+        start = target_func["line_start"] - 1
+        end = target_func["line_end"]
+        old_code = ''.join(lines[start:end])
+
+        # Ensure new_code has proper indentation and newline
+        if not new_code.endswith('\n'):
+            new_code += '\n'
+
+        # Replace function
+        new_lines = lines[:start] + [new_code] + lines[end:]
+
+        if not dry_run:
+            # Backup original
+            backup_path = file_path.with_suffix(file_path.suffix + '.backup')
+            with open(backup_path, 'w') as f:
+                f.writelines(lines)
+
+            # Write new content
+            with open(file_path, 'w') as f:
+                f.writelines(new_lines)
+
+            # Layer 1 (Proactive): Trigger background RAG update
+            self._trigger_rag_update(file_path)
+
+        return {
+            "success": True,
+            "old_code": old_code,
+            "new_code": new_code,
+            "lines_changed": len(new_lines) - len(lines),
+            "backup": str(backup_path) if not dry_run else None
+        }
+
+    def get_class(
+        self,
+        file_path: Path,
+        class_name: str,
+        language: str = "auto"
+    ) -> Optional[str]:
+        """
+        Extract entire class definition.
+
+        Priority:
+        1. Python AST (for .py files)
+        2. Tree-sitter via MultiLanguageParser (for supported languages)
+        3. Ollama fallback (for unsupported languages)
+
+        Args:
+            file_path: Path to source file
+            class_name: Name of class to extract
+            language: Programming language ("auto" to detect from extension)
+
+        Returns: Class code as string, or None if not found
+        """
+        # Auto-detect language from file extension
+        if language == "auto" and MULTI_LANG_PARSER_AVAILABLE:
+            language = detect_language(file_path)
+
+        if language == "python":
+            return self._get_class_python_ast(file_path, class_name)
+
+        # Use tree-sitter based parser for other languages
+        if self.multi_lang_parser:
+            try:
+                return self.multi_lang_parser.get_class(file_path, class_name, language)
+            except Exception as e:
+                print(f"Warning: Tree-sitter parsing failed, falling back to Ollama: {e}", file=sys.stderr)
+
+        return self._get_class_ollama(file_path, class_name, language)
+
+    def _get_class_python_ast(self, file_path: Path, class_name: str) -> Optional[str]:
+        """Extract class using Python AST parser."""
+        with open(file_path, 'r') as f:
+            content = f.read()
+            lines = content.splitlines()
+
+        try:
+            tree = ast.parse(content)
+        except SyntaxError as e:
+            print(f"Warning: Could not parse {file_path}: {e}", file=sys.stderr)
+            return None
+
+        class ClassFinder(ast.NodeVisitor):
+            def __init__(self):
+                self.class_node = None
+
+            def visit_ClassDef(self, node):
+                if node.name == class_name:
+                    self.class_node = node
+                else:
+                    self.generic_visit(node)
+
+        finder = ClassFinder()
+        finder.visit(tree)
+
+        if finder.class_node is None:
+            return None
+
+        # Extract class code using line numbers
+        node = finder.class_node
+        start = node.lineno - 1  # 0-indexed
+        end = node.end_lineno if hasattr(node, 'end_lineno') else start + 1
+
+        class_code = '\n'.join(lines[start:end])
+        return class_code
+
+    def _get_class_ollama(self, file_path: Path, class_name: str, language: str) -> Optional[str]:
+        """Extract class using Ollama (fallback for non-Python languages)."""
+        with open(file_path, 'r') as f:
+            content = f.read()
+
+        # Warn for large files
+        if len(content) > 10000:
+            print(f"Warning: File is large ({len(content)} chars), Ollama may timeout", file=sys.stderr)
+
+        system = f"""You are a code extractor. Extract ONLY the specified class definition.
+Language: {language}
+
+Rules:
+- Extract complete class including all methods
+- Include class definition line
+- Include all decorators
+- Include docstrings
+- Do NOT include imports or code after class
+- Output ONLY the class code, no explanations"""
+
+        prompt = f"Extract class '{class_name}' from this code:\n\n```{language}\n{content}\n```"
+
+        response = self._call_ollama(prompt, system)
+
+        # Clean up response (remove markdown if present)
+        code = response
+        if f"```{language}" in code:
+            code = code.split(f"```{language}")[1].split("```")[0].strip()
+        elif "```" in code:
+            code = code.split("```")[1].split("```")[0].strip()
+
+        return code if code else None
+
+    def list_classes(self, file_path: Path, language: str = "auto") -> List[str]:
+        """
+        List all class names in file.
+
+        Priority:
+        1. Python AST (for .py files)
+        2. Tree-sitter via MultiLanguageParser (for supported languages)
+        3. Ollama fallback (for unsupported languages)
+
+        Args:
+            file_path: Path to source file
+            language: Programming language ("auto" to detect from extension)
+
+        Returns: List of class names
+        """
+        # Auto-detect language from file extension
+        if language == "auto" and MULTI_LANG_PARSER_AVAILABLE:
+            language = detect_language(file_path)
+
+        if language == "python":
+            return self._list_classes_python_ast(file_path)
+
+        # Use tree-sitter based parser for other languages
+        if self.multi_lang_parser:
+            try:
+                blocks = self.multi_lang_parser.list_classes(file_path, language)
+                return [block.name for block in blocks]
+            except Exception as e:
+                print(f"Warning: Tree-sitter parsing failed, falling back to Ollama: {e}", file=sys.stderr)
+
+        return self._list_classes_ollama(file_path, language)
+
+    def _list_classes_python_ast(self, file_path: Path) -> List[str]:
+        """List all class names using Python AST parser."""
+        with open(file_path, 'r') as f:
+            content = f.read()
+
+        try:
+            tree = ast.parse(content)
+        except SyntaxError as e:
+            print(f"Warning: Could not parse {file_path}: {e}", file=sys.stderr)
+            return []
+
+        classes = []
+
+        class ClassVisitor(ast.NodeVisitor):
+            def visit_ClassDef(self, node):
+                classes.append(node.name)
+                self.generic_visit(node)
+
+        visitor = ClassVisitor()
+        visitor.visit(tree)
+
+        return classes
+
+    def _list_classes_ollama(self, file_path: Path, language: str) -> List[str]:
+        """List all class names using Ollama (fallback for non-Python languages)."""
+        with open(file_path, 'r') as f:
+            content = f.read()
+
+        # Warn for large files
+        if len(content) > 10000:
+            print(f"Warning: File is large ({len(content)} chars), Ollama may timeout", file=sys.stderr)
+
+        system = f"""You are a code analyzer. List all class names in the code.
+Language: {language}
+
+Output ONLY a JSON array of class names: ["ClassName1", "ClassName2", ...]
+No explanations, just JSON array."""
+
+        prompt = f"List all classes in this code:\n\n```{language}\n{content}\n```"
+
+        response = self._call_ollama(prompt, system)
+
+        try:
+            json_match = re.search(r'\[.*\]', response, re.DOTALL)
+            if json_match:
+                classes = json.loads(json_match.group())
+                return classes
+            return []
+        except json.JSONDecodeError:
+            return []
+
+    def get_imports(self, file_path: Path, language: str = "python") -> str:
+        """Extract import statements using AST (Python) or Ollama (other languages)."""
+        if language == "python":
+            return self._get_imports_python_ast(file_path)
+        else:
+            return self._get_imports_ollama(file_path, language)
+
+    def _get_imports_python_ast(self, file_path: Path) -> str:
+        """Extract import statements using Python AST parser."""
+        with open(file_path, 'r') as f:
+            content = f.read()
+            lines = content.splitlines()
+
+        try:
+            tree = ast.parse(content)
+        except SyntaxError as e:
+            print(f"Warning: Could not parse {file_path}: {e}", file=sys.stderr)
+            return ""
+
+        import_lines = []
+
+        class ImportVisitor(ast.NodeVisitor):
+            def visit_Import(self, node):
+                # Regular import: import x, y, z
+                import_lines.append((node.lineno, node.end_lineno))
+
+            def visit_ImportFrom(self, node):
+                # From import: from x import y
+                import_lines.append((node.lineno, node.end_lineno))
+
+        visitor = ImportVisitor()
+        visitor.visit(tree)
+
+        # Extract actual import lines
+        if not import_lines:
+            return ""
+
+        # Sort by line number and extract
+        import_lines.sort()
+        result = []
+        for start, end in import_lines:
+            result.extend(lines[start-1:end])
+
+        return '\n'.join(result)
+
+    def _get_imports_ollama(self, file_path: Path, language: str) -> str:
+        """Extract import statements using Ollama (fallback for non-Python languages)."""
+        with open(file_path, 'r') as f:
+            content = f.read()
+
+        # Warn for large files
+        if len(content) > 10000:
+            print(f"Warning: File is large ({len(content)} chars), Ollama may timeout", file=sys.stderr)
+
+        system = f"""Extract ONLY import statements from code.
+Language: {language}
+
+Rules:
+- Include all import lines
+- Include comments on import lines
+- Stop at first non-import line
+- Preserve order
+- Output ONLY imports, no explanations"""
+
+        prompt = f"Extract imports from this code:\n\n```{language}\n{content}\n```"
+
+        response = self._call_ollama(prompt, system)
+
+        # Clean response
+        if "```" in response:
+            response = response.split("```")[1].split("```")[0].strip()
+
+        return response
+
+
+# =============================================================================
+# CLI Commands
+# =============================================================================
+
+@click.group()
+@click.option('--disable-rag-sync', is_flag=True, help="Disable RAG auto-sync")
+@click.pass_context
+def cli(ctx, disable_rag_sync):
+    """Code Block Manager - Token-efficient code manipulation with RAG auto-sync."""
+    ctx.ensure_object(dict)
+    ctx.obj['enable_rag_sync'] = not disable_rag_sync
+
+
+@cli.command('list-functions')
+@click.argument('file_path', type=click.Path(exists=True))
+@click.option('--language', default="auto", help="Programming language (auto-detected from extension)")
+@click.option('--format', type=click.Choice(['json', 'table']), default='table')
+@click.pass_context
+def list_functions_cmd(ctx, file_path: str, language: str, format: str):
+    """List all functions/methods in a file.
+
+    Supports: Python, Kotlin, Java, JavaScript, TypeScript, Go, Swift, Rust, C, C++
+
+    Example:
+        code_block_manager.py list-functions src/myfile.py
+        code_block_manager.py list-functions app/MainActivity.kt
+    """
+    manager = CodeBlockManager(enable_rag_sync=ctx.obj['enable_rag_sync'])
+    functions = manager.list_functions(Path(file_path), language)
+
+    if format == 'json':
+        click.echo(json.dumps(functions, indent=2))
+    else:
+        if not functions:
+            click.echo("No functions found")
+            return
+
+        click.echo(f"\n📋 Found {len(functions)} functions in {file_path}:\n")
+        for func in functions:
+            lines = func['line_end'] - func['line_start'] + 1
+            click.echo(f"  • {func['name']:<30} lines {func['line_start']}-{func['line_end']} ({lines} lines)")
+
+
+@cli.command('get-function')
+@click.argument('file_path', type=click.Path(exists=True))
+@click.argument('function_name')
+@click.option('--language', default="auto", help="Programming language (auto-detected from extension)")
+@click.option('--no-rag-fallback', is_flag=True, help="Disable Layer 2 reactive sync")
+@click.pass_context
+def get_function_cmd(ctx, file_path: str, function_name: str, language: str, no_rag_fallback: bool):
+    """Extract specific function code with RAG auto-sync fallback.
+
+    Example:
+        code_block_manager.py get-function src/myfile.py validate_config
+        code_block_manager.py get-function app/MainActivity.kt onCreate
+    """
+    manager = CodeBlockManager(enable_rag_sync=ctx.obj['enable_rag_sync'])
+    code = manager.get_function(
+        Path(file_path),
+        function_name,
+        language,
+        use_rag_fallback=not no_rag_fallback
+    )
+
+    if code:
+        click.echo(code)
+    else:
+        click.echo(f"❌ Function '{function_name}' not found in {file_path}", err=True)
+        sys.exit(1)
+
+
+@cli.command('update-function')
+@click.argument('file_path', type=click.Path(exists=True))
+@click.argument('function_name')
+@click.option('--code', help="New function code (or use --stdin)")
+@click.option('--stdin', is_flag=True, help="Read new code from stdin")
+@click.option('--language', default="auto", help="Programming language (auto-detected from extension)")
+@click.option('--dry-run', is_flag=True, help="Show what would change without writing")
+@click.pass_context
+def update_function_cmd(ctx, file_path: str, function_name: str, code: str, stdin: bool, language: str, dry_run: bool):
+    """Update specific function in file with RAG auto-sync.
+
+    Layer 1 (Proactive): Automatically updates RAG index in background after write.
+
+    Examples:
+        # From argument
+        code_block_manager.py update-function src/myfile.py validate_config --code="def validate_config():\n    pass"
+
+        # From stdin
+        cat new_function.py | code_block_manager.py update-function src/myfile.py validate_config --stdin
+    """
+    if stdin:
+        new_code = sys.stdin.read()
+    elif code:
+        new_code = code
+    else:
+        click.echo("❌ Error: Provide --code or --stdin", err=True)
+        sys.exit(1)
+
+    manager = CodeBlockManager(enable_rag_sync=ctx.obj['enable_rag_sync'])
+    result = manager.update_function(Path(file_path), function_name, new_code, language, dry_run)
+
+    if not result["success"]:
+        click.echo(f"❌ {result.get('error', 'Unknown error')}", err=True)
+        sys.exit(1)
+
+    if dry_run:
+        click.echo("🔍 DRY RUN - No changes made\n")
+        click.echo("OLD CODE:")
+        click.echo(result["old_code"])
+        click.echo("\nNEW CODE:")
+        click.echo(result["new_code"])
+        click.echo(f"\nLines changed: {result['lines_changed']}")
+    else:
+        click.echo(f"✅ Updated '{function_name}' in {file_path}")
+        click.echo(f"📦 Backup: {result['backup']}")
+        click.echo(f"📊 Lines changed: {result['lines_changed']}")
+        if ctx.obj['enable_rag_sync']:
+            click.echo(f"🔄 RAG index updating in background...")
+
+
+@cli.command('list-classes')
+@click.argument('file_path', type=click.Path(exists=True))
+@click.option('--language', default="auto", help="Programming language (auto-detected from extension)")
+@click.pass_context
+def list_classes_cmd(ctx, file_path: str, language: str):
+    """List all classes in file.
+
+    Example:
+        code_block_manager.py list-classes src/myfile.py
+        code_block_manager.py list-classes app/MainActivity.kt
+    """
+    manager = CodeBlockManager(enable_rag_sync=ctx.obj['enable_rag_sync'])
+    classes = manager.list_classes(Path(file_path), language)
+
+    if classes:
+        click.echo(f"\n📦 Found {len(classes)} classes:\n")
+        for cls in classes:
+            click.echo(f"  • {cls}")
+    else:
+        click.echo("No classes found")
+
+
+@cli.command('get-class')
+@click.argument('file_path', type=click.Path(exists=True))
+@click.argument('class_name')
+@click.option('--language', default="auto", help="Programming language (auto-detected from extension)")
+@click.pass_context
+def get_class_cmd(ctx, file_path: str, class_name: str, language: str):
+    """Extract specific class code.
+
+    Example:
+        code_block_manager.py get-class src/myfile.py MyClass
+    """
+    manager = CodeBlockManager(enable_rag_sync=ctx.obj['enable_rag_sync'])
+    code = manager.get_class(Path(file_path), class_name, language)
+
+    if code:
+        click.echo(code)
+    else:
+        click.echo(f"❌ Class '{class_name}' not found in {file_path}", err=True)
+        sys.exit(1)
+
+
+@cli.command('get-imports')
+@click.argument('file_path', type=click.Path(exists=True))
+@click.option('--language', default="auto", help="Programming language (auto-detected from extension)")
+@click.pass_context
+def get_imports_cmd(ctx, file_path: str, language: str):
+    """Extract import statements.
+
+    Example:
+        code_block_manager.py get-imports src/myfile.py
+        code_block_manager.py get-imports app/MainActivity.kt
+    """
+    manager = CodeBlockManager(enable_rag_sync=ctx.obj['enable_rag_sync'])
+    imports = manager.get_imports(Path(file_path), language)
+
+    if imports:
+        click.echo(imports)
+    else:
+        click.echo("No imports found")
+
+
+if __name__ == '__main__':
+    cli(obj={})