project-brain-cli 1.0.0__py3-none-any.whl

project_brain/cli_ui.py

@@ -0,0 +1,69 @@
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+from rich.text import Text
+from rich.panel import Panel
+
+console = Console()
+
+
+def section(title: str):
+    console.rule(f"[bold cyan]{title}")
+
+
+def success(message: str, next_step: str | None = None):
+    console.print(f"[bold green]✅ {message}[/bold green]")
+
+    if next_step:
+        console.print(
+            Panel(
+                f"[bold]Next:[/bold]\n{next_step}",
+                border_style="cyan",
+            )
+        )
+
+
+def error(message: str, suggestion: str | None = None):
+    console.print(f"[bold red]❌ {message}[/bold red]")
+
+    if suggestion:
+        console.print(
+            Panel(
+                suggestion,
+                title="Try",
+                border_style="yellow",
+            )
+        )
+
+
+def info(message: str):
+    console.print(f"[cyan]ℹ {message}[/cyan]")
+
+
+def key_value_table(title: str, rows: list[tuple[str, str]]):
+    table = Table(title=title)
+
+    table.add_column("Field", style="cyan")
+    table.add_column("Value", style="white")
+
+    for k, v in rows:
+        table.add_row(k, v)
+
+    console.print(table)
+
+def doctor_panel(title: str, rows: list[tuple[str, str, str]]):
+    table = Table(title=title)
+
+    table.add_column("Check", style="cyan")
+    table.add_column("Status")
+    table.add_column("Details", style="white")
+
+    for check, status, detail in rows:
+        table.add_row(check, status, detail)
+
+    console.print(
+        Panel(
+            table,
+            border_style="cyan",
+        )
+    )

project_brain/core/analyzer.py

@@ -0,0 +1,134 @@
+import ast
+import hashlib
+from datetime import datetime
+from pathlib import Path
+
+from project_brain.core.logger import log_error
+
+
+def sha256_file(path: Path) -> str:
+    hasher = hashlib.sha256()
+    try:
+        with path.open("rb") as f:
+            for chunk in iter(lambda: f.read(8192), b""):
+                hasher.update(chunk)
+        return hasher.hexdigest()
+    except Exception as e:
+        log_error(f"Function failed: {str(e)}")
+        return ""
+
+
+def analyze_python_file(path: Path, rel_path: str):
+    functions = []
+    classes = []
+    
+    try:
+        source = path.read_text(encoding="utf-8")
+        tree = ast.parse(source)
+    except Exception as e:
+        log_error(f"Function failed: {str(e)}")
+        return functions, classes
+
+    for node in ast.walk(tree):
+        if isinstance(node, ast.FunctionDef):
+            functions.append({
+                "name": node.name,
+                "arguments": [arg.arg for arg in node.args.args],
+                "line": node.lineno,
+                "file": rel_path
+            })
+
+        elif isinstance(node, ast.ClassDef):
+            classes.append({
+                "name": node.name,
+                "line": node.lineno,
+                "file": rel_path
+            })
+
+    return functions, classes
+
+
+def should_skip(path: Path, ignore_patterns):
+    if not ignore_patterns:
+        return False
+
+    path_parts = set(path.parts)
+
+    for pattern in ignore_patterns:
+        pattern = pattern.strip().rstrip("/")
+
+        # 1. Directory match (exact)
+        if pattern in path_parts:
+            return True
+
+        # 2. Extension match (*.pyc etc.)
+        if pattern.startswith("*."):
+            if path.name.endswith(pattern[1:]):
+                return True
+
+    return False
+
+
+def is_binary(path: Path):
+    try:
+        with open(path, 'rb') as f:
+            return b'\0' in f.read(1024)
+    except:
+        return True
+
+
+def analyze_project(root_path: Path, ignore_patterns=None, include_tests=False):
+    if ignore_patterns is None:
+        ignore_patterns = []
+    root_path = root_path.resolve()
+
+    files_data = []
+    functions = []
+    classes = []
+    files_path = []
+
+    for path in root_path.rglob("*"):
+        if path.is_dir():
+            continue
+
+        if should_skip(path, ignore_patterns):
+            continue
+        
+        if is_binary(path):
+            continue
+        
+        if not include_tests and "test" in path.name.lower():
+            continue
+        # files_path.append(path)
+        try:
+            rel_path = str(path.relative_to(root_path))
+            stat = path.stat()
+
+            file_info = {
+                "path": rel_path,
+                "size": stat.st_size,
+                "modified": datetime.fromtimestamp(stat.st_mtime).isoformat(),
+                "sha256": sha256_file(path)
+            }
+
+            files_data.append(file_info)
+            files_path.append(rel_path)
+
+            if path.suffix == ".py":
+                fn, cls = analyze_python_file(path, rel_path)
+                functions.extend(fn)
+                classes.extend(cls)
+
+        except Exception as e:
+            log_error(f"Function failed: {str(e)}")
+            continue  # skip unreadable files safely
+
+    return {
+        "project": {
+            "root": str(root_path),
+            "total_files": len(files_data)
+        },
+        "files": files_data,
+        "functions": functions,
+        "classes": classes,
+    }, files_path

project_brain/core/config_loader.py

@@ -0,0 +1,193 @@
+import copy
+from pathlib import Path
+
+import yaml
+
+from project_brain.core.logger import log_warning
+
+DEFAULT_CONFIG = {
+    "version": "1.0",
+    "llm": {
+        "provider": "none",
+        "model": "",
+        "timeout_sec": 60,
+    },
+    "analysis": {
+        "depth": "fast",
+        "include_tests": False,
+        "ignore": [
+            ".brain/",
+            ".git/",
+            "node_modules/",
+            "venv/",
+            ".venv/",
+            "__pycache__/",
+            "env/",
+            ".env/",
+            "*.egg-info/",
+            "tests/",
+            "test/",
+        ],
+    },
+    "diff": {
+        "mode": "function",
+    },
+    "export": {
+        "full_code": {
+            "include_tests": False,
+            "max_file_size_kb": 200,
+        },
+        "manual_add": {
+            "allow_duplicates": True,
+        },
+        "changes": {
+            "mode": "function",
+            "include_context": True,
+            "output_path": ".brain/exports/code_changes.txt",
+        },
+        "ignore": [
+            ".brain/",
+            ".git/",
+            "node_modules/",
+            "venv/",
+            ".venv/",
+            "__pycache__/",
+            "env/",
+            ".env/",
+            "*.egg-info/",
+            "tests/",
+            "test/",
+        ],
+    },
+    "explain": {
+        "level": "detailed",
+        "include_risks": True,
+    },
+    "output": {
+        "format": "text",
+    },
+}
+
+
+def merge(default, user):
+    result = copy.deepcopy(default)
+
+    for k, v in (user or {}).items():
+        if isinstance(v, dict) and k in result:
+            result[k] = merge(result[k], v)
+        else:
+            result[k] = v
+
+    return result
+
+
+# -----------------------------
+# Validation Helpers
+# -----------------------------
+def _warn(path: str, value, default):
+    log_warning(f"Invalid value for {path}='{value}', using default='{default}'")
+
+
+def _validate_enum(config, path, allowed, default):
+    keys = path.split(".")
+    node = config
+    for k in keys[:-1]:
+        node = node.get(k, {})
+    last = keys[-1]
+
+    value = node.get(last)
+
+    if value not in allowed:
+        _warn(path, value, default)
+        node[last] = default
+
+
+def _validate_int_positive(config, path, default):
+    keys = path.split(".")
+    node = config
+    for k in keys[:-1]:
+        node = node.get(k, {})
+    last = keys[-1]
+
+    value = node.get(last)
+
+    if not isinstance(value, int) or value <= 0:
+        _warn(path, value, default)
+        node[last] = default
+
+
+# -----------------------------
+# Main Validation
+# -----------------------------
+def validate_config(config: dict) -> dict:
+    safe = merge(DEFAULT_CONFIG, config or {})
+
+    _validate_enum(
+        safe,
+        "llm.provider",
+        ["none", "openai", "ollama", "gemini", "huggingface"],
+        DEFAULT_CONFIG["llm"]["provider"],
+    )
+
+    _validate_enum(
+        safe,
+        "diff.mode",
+        ["function", "file"],
+        DEFAULT_CONFIG["diff"]["mode"],
+    )
+
+    _validate_enum(
+        safe,
+        "export.changes.mode",
+        ["function", "file"],
+        DEFAULT_CONFIG["export"]["changes"]["mode"],
+    )
+
+    _validate_enum(
+        safe,
+        "analysis.depth",
+        ["fast", "full"],
+        DEFAULT_CONFIG["analysis"]["depth"],
+    )
+
+    _validate_enum(
+        safe,
+        "output.format",
+        ["text", "json", "markdown"],
+        DEFAULT_CONFIG["output"]["format"],
+    )
+
+    _validate_int_positive(
+        safe,
+        "llm.timeout_sec",
+        DEFAULT_CONFIG["llm"]["timeout_sec"],
+    )
+
+    return safe
+
+
+# -----------------------------
+# Load Config
+# -----------------------------
+def load_config(root: Path) -> dict:
+    path = root / "brain.yaml"
+
+    if not path.exists():
+        return DEFAULT_CONFIG
+
+    try:
+        raw = yaml.safe_load(path.read_text()) or {}
+    except Exception as e:
+        log_warning(f"Failed to parse YAML: {str(e)}")
+        return DEFAULT_CONFIG
+
+    try:
+        merged = merge(DEFAULT_CONFIG, raw)
+        return validate_config(merged)
+    except Exception as e:
+        log_warning(f"Validation failed: {str(e)}")
+        return DEFAULT_CONFIG
+
+
+def dump_config(config: dict) -> str:
+    return yaml.dump(config, sort_keys=False)

project_brain/core/differ.py

@@ -0,0 +1,160 @@
+import ast
+import subprocess
+from pathlib import Path
+
+from project_brain.core.logger import log_error
+
+
+# -----------------------------
+# Git Utilities (SAFE)
+# -----------------------------
+def run_git_command(args: list[str], cwd: Path) -> str | None:
+    try:
+        result = subprocess.run(
+            ["git"] + args,
+            cwd=cwd,
+            capture_output=True,
+            text=True,
+            encoding="utf-8",  # 🔥 CRITICAL FIX
+            errors="ignore",  # 🔥 PREVENT CRASH
+            check=True,
+        )
+        return result.stdout.strip()
+    except subprocess.CalledProcessError:
+        return None
+    except Exception as e:
+        log_error(f"Function failed: {str(e)}")
+        return None
+
+
+def is_git_repo(path: Path) -> bool:
+    result = run_git_command(["rev-parse", "--is-inside-work-tree"], path)
+    return result == "true"
+
+
+# -----------------------------
+# Diff Parsing
+# -----------------------------
+def parse_name_status(output: str):
+    added, modified, deleted = [], [], []
+
+    for line in output.splitlines():
+        if not line.strip():
+            continue
+
+        parts = line.split(maxsplit=1)
+        if len(parts) != 2:
+            continue  # 🔥 safe guard
+
+        status, file = parts
+
+        if status == "A":
+            added.append(file)
+        elif status == "M":
+            modified.append(file)
+        elif status == "D":
+            deleted.append(file)
+
+    return added, modified, deleted
+
+
+# -----------------------------
+# File Content Retrieval
+# -----------------------------
+def get_file_from_ref(ref: str, file: str, cwd: Path) -> str | None:
+    return run_git_command(["show", f"{ref}:{file}"], cwd)
+
+
+# -----------------------------
+# AST Function Extraction
+# -----------------------------
+def extract_functions(source: str):
+    """
+    Returns dict:
+    {
+        "function_name": "function_source_code"
+    }
+    """
+    functions = {}
+
+    try:
+        tree = ast.parse(source)
+    except Exception:
+        return functions  # 🔥 invalid python safety
+
+    for node in ast.walk(tree):
+        if isinstance(node, ast.FunctionDef):
+            try:
+                code = ast.get_source_segment(source, node) or ""
+            except Exception:
+                code = ""
+
+            functions[node.name] = code
+
+    return functions
+
+
+# -----------------------------
+# Function Diff Logic
+# -----------------------------
+def diff_functions(old_src: str, new_src: str):
+    old_funcs = extract_functions(old_src or "")
+    new_funcs = extract_functions(new_src or "")
+
+    old_set = set(old_funcs.keys())
+    new_set = set(new_funcs.keys())
+
+    added = sorted(new_set - old_set)
+    removed = sorted(old_set - new_set)
+    modified = sorted(
+        [fn for fn in old_set & new_set if old_funcs.get(fn) != new_funcs.get(fn)]
+    )  # simple heuristic
+
+    return added, removed, modified
+
+
+# -----------------------------
+# Main Diff Engine
+# -----------------------------
+def compute_diff(from_ref: str, to_ref: str, root: Path):
+    diff_output = run_git_command(
+        ["log", "--name-status", "--pretty=format:", f"{from_ref}..{to_ref}"], root
+    )
+
+    if diff_output is None:
+        raise RuntimeError("Git command failed")
+
+    if diff_output.strip() == "":
+        return {"added": [], "modified": [], "deleted": [], "function_diffs": []}
+
+    added, modified, deleted = parse_name_status(diff_output)
+
+    function_diffs = []
+
+    for file in modified:
+        if not file.endswith(".py"):
+            continue
+
+        old_src = get_file_from_ref(from_ref, file, root)
+        new_src = get_file_from_ref(to_ref, file, root)
+
+        if old_src is None or new_src is None:
+            continue
+
+        fn_added, fn_removed, fn_modified = diff_functions(old_src, new_src)
+
+        function_diffs.append(
+            {
+                "file": file,
+                "added": fn_added,
+                "removed": fn_removed,
+                "modified": fn_modified,
+            }
+        )
+
+    return {
+        "added": added,
+        "modified": modified,
+        "deleted": deleted,
+        "function_diffs": function_diffs,
+    }

project_brain/core/doctor.py

@@ -0,0 +1,29 @@
+from pathlib import Path
+
+from project_brain.core.doctor_checks.analysis import run_analysis_checks
+from project_brain.core.doctor_checks.environment import run_environment_checks
+from project_brain.core.doctor_checks.exports import run_export_checks
+from project_brain.core.doctor_checks.llm import run_llm_checks
+from project_brain.core.doctor_checks.repository import run_repository_checks
+
+
+def run_doctor(root: Path):
+    checks = []
+
+    checks.extend(run_environment_checks(root))
+    checks.extend(run_repository_checks(root))
+    checks.extend(run_analysis_checks(root))
+    checks.extend(run_export_checks(root))
+    checks.extend(run_llm_checks(root))
+
+    failures = [c for c in checks if c.status == "fail"]
+    warnings = [c for c in checks if c.status == "warn"]
+
+    if failures:
+        status = "NOT READY"
+    elif warnings:
+        status = "PARTIAL"
+    else:
+        status = "READY"
+
+    return checks, status

project_brain/core/doctor_checks/analysis.py

@@ -0,0 +1,110 @@
+import json
+from datetime import datetime
+from pathlib import Path
+
+from project_brain.core.doctor_checks.models import DoctorCheck
+
+
+def run_analysis_checks(root: Path):
+    checks = []
+
+    brain_dir = root / ".brain"
+
+    if brain_dir.exists():
+        checks.append(
+            DoctorCheck(
+                "Analysis",
+                "Initialization",
+                "pass",
+                ".brain directory exists",
+            )
+        )
+    else:
+        checks.append(
+            DoctorCheck(
+                "Analysis",
+                "Initialization",
+                "fail",
+                "Project not initialized",
+                "Run:\nbrain project init",
+            )
+        )
+        return checks
+
+    data_path = brain_dir / "data.json"
+
+    if not data_path.exists():
+        checks.append(
+            DoctorCheck(
+                "Analysis",
+                "Analysis",
+                "fail",
+                "Analysis missing",
+                "Run:\nbrain project analyze .",
+            )
+        )
+        return checks
+
+    checks.append(
+        DoctorCheck(
+            "Analysis",
+            "Analysis",
+            "pass",
+            "data.json exists",
+        )
+    )
+
+    try:
+        data = json.loads(data_path.read_text())
+
+        total_files = data.get("project", {}).get("total_files", 0)
+
+        checks.append(
+            DoctorCheck(
+                "Analysis",
+                "Analyzed Files",
+                "info",
+                str(total_files),
+            )
+        )
+
+        modified = datetime.fromtimestamp(
+            data_path.stat().st_mtime
+        )
+
+        age_hours = (
+            datetime.now() - modified
+        ).total_seconds() / 3600
+
+        if age_hours > 24:
+            checks.append(
+                DoctorCheck(
+                    "Analysis",
+                    "Freshness",
+                    "warn",
+                    "Analysis may be stale",
+                    "Run:\nbrain project analyze .",
+                )
+            )
+        else:
+            checks.append(
+                DoctorCheck(
+                    "Analysis",
+                    "Freshness",
+                    "pass",
+                    "Analysis is recent",
+                )
+            )
+
+    except Exception:
+        checks.append(
+            DoctorCheck(
+                "Analysis",
+                "Integrity",
+                "fail",
+                "Invalid data.json",
+                "Re-run analysis",
+            )
+        )
+
+    return checks