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

project_brain/core/explainer_file.py

@@ -0,0 +1,136 @@
+import ast
+from pathlib import Path
+import os
+
+from project_brain.core.config_loader import load_config
+from project_brain.core.logger import log_error
+from project_brain.llm.provider import call_llm
+
+
+def extract_file_structure(source: str):
+    functions = []
+    classes = []
+
+    try:
+        tree = ast.parse(source)
+    except Exception:
+        return functions, classes
+
+    for node in ast.walk(tree):
+        if isinstance(node, ast.FunctionDef):
+            functions.append(node.name)
+        elif isinstance(node, ast.ClassDef):
+            classes.append(node.name)
+
+    return functions, classes
+
+
+def extract_function(source: str, func_name: str):
+    try:
+        tree = ast.parse(source)
+    except Exception as e:
+        log_error(f"Function failed: {str(e)}")
+        return None
+
+    lines = source.splitlines()
+
+    for node in ast.walk(tree):
+        if isinstance(node, ast.FunctionDef) and node.name == func_name:
+            start = node.lineno - 1
+            end = getattr(node, "end_lineno", start + 1)
+            code = "\n".join(lines[start:end])
+
+            return {
+                "name": node.name,
+                "args": [arg.arg for arg in node.args.args],
+                "line": node.lineno,
+                "code": code
+            }
+
+    return None
+
+
+def explain_file(root: Path, file_path: str):
+    config = load_config(root)
+    provider = config["llm"]["provider"]
+    model = config["llm"]["model"]
+    api_key = ""
+
+    path = root / file_path
+    if not path.exists():
+        log_error(f"File not found: {file_path}")
+        return "❌ File not found"
+
+    try:
+        source = path.read_text(encoding="utf-8", errors="ignore")
+    except Exception as e:
+        log_error(f"Unable to read file: {file_path} - {str(e)}")
+        return "❌ Unable to read file"
+
+    functions, classes = extract_file_structure(source)
+
+    if provider == "none":
+        lines = []
+        lines.append(f"File: {file_path}\n")
+        lines.append("Summary:")
+        lines.append(f"- Functions: {len(functions)}")
+        lines.append(f"- Classes: {len(classes)}\n")
+
+        lines.append("Functions:\n")
+        for fn in functions:
+            lines.append(f"* {fn}")
+
+        return "\n".join(lines)
+
+    prompt = f"""
+Explain this file: purpose, main components, data flow, key risks.
+
+{source}
+""".strip()
+
+    response = call_llm(provider, model, prompt, api_key)
+
+    return f"File: {file_path}\n\nSummary:\n{response['output'].strip()}"
+
+
+def explain_function(root: Path, file_path: str, func_name: str):
+    config = load_config(root)
+    provider = config["llm"]["provider"]
+    model = config["llm"]["model"]
+    api_key = ""
+    include_risks = config.get("explain", {}).get("include_risks", True)
+
+    path = root / file_path
+    if not path.exists():
+        log_error(f"File not found: {file_path}")
+        return "❌ File not found"
+
+    try:
+        source = path.read_text(encoding="utf-8", errors="ignore")
+    except Exception as e:
+        log_error(f"Unable to read file: {file_path} - {str(e)}")
+        return "❌ Unable to read file"
+
+    fn = extract_function(source, func_name)
+    if not fn:
+        log_error(f"Function not found: {func_name} in {file_path}")
+        return "❌ Function not found"
+
+    if provider == "none":
+        lines = []
+        lines.append(f"Function: {fn['name']}\n")
+        lines.append(f"Args: {', '.join(fn['args'])}")
+        lines.append(f"Line: {fn['line']}")
+        return "\n".join(lines)
+
+    risk_part = ", edge cases, risks" if include_risks else ""
+
+    prompt = f"""
+Explain this function: purpose, inputs, outputs, logic{risk_part}.
+
+{fn['code']}
+""".strip()
+
+    response = call_llm(provider, model, prompt, api_key)
+
+    return f"Function: {fn['name']}\n\n{response['output'].strip()}"

project_brain/core/exporter.py

@@ -0,0 +1,340 @@
+import ast
+import hashlib
+from pathlib import Path
+
+from project_brain.core.config_loader import load_config
+from project_brain.core.differ import compute_diff, get_file_from_ref
+from project_brain.core.logger import log_error
+
+
+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_test_file(path: Path):
+    name = path.name.lower()
+    return (
+        name.startswith("test_") or
+        name.endswith("_test.py") or
+        "tests" in path.parts
+    )
+
+
+
+def _read_existing_entries(output_path: Path):
+    if not output_path.exists():
+        return set()
+
+    existing = set()
+    try:
+        with output_path.open("r", encoding="utf-8", errors="ignore") as f:
+            for line in f:
+                if line.startswith("=== FILE:"):
+                    parts = line.strip().split("=== FILE:")[-1].strip()
+                    file_name = parts.replace("===", "").strip()
+                    file_name = file_name.replace("(MANUAL ADD)", "").strip()
+                    existing.add(file_name)
+    except Exception as e:
+        log_error(f"Function failed: {str(e)}")
+        pass
+
+    return existing
+
+
+def _append_file(out, rel_path: str, content: str, manual: bool):
+    tag = " (MANUAL ADD)" if manual else ""
+    out.write(f"=== FILE: {rel_path}{tag} ===\n")
+    out.write(content)
+    out.write("\n\n")
+
+
+def export_full_code(root: Path):
+    config = load_config(root)
+
+    export_cfg = config.get("export", {}).get("full_code", {})
+    include_tests = export_cfg.get("include_tests", False)
+    max_kb = export_cfg.get("max_file_size_kb", 200)
+    ignore_paths = config.get("export", {}).get("ignore", [])
+
+    export_dir = root / ".brain" / "exports"
+    export_dir.mkdir(parents=True, exist_ok=True)
+
+    output_path = export_dir / "full_code.txt"
+
+    files_exported = 0
+    file_paths = []
+
+    with output_path.open("w", encoding="utf-8") as out:
+
+        for path in root.rglob("*"):
+            if path.is_dir():
+                continue
+
+            if should_skip(path, ignore_paths):
+                continue
+
+            if not include_tests and is_test_file(path):
+                continue
+
+            try:
+                size_kb = path.stat().st_size / 1024
+                if size_kb > max_kb:
+                    continue
+
+                rel_path = str(path.relative_to(root))
+
+                content = path.read_text(encoding="utf-8", errors="ignore")
+
+                out.write(f"=== FILE: {rel_path} ===\n")
+                out.write(content)
+                out.write("\n\n")
+
+                files_exported += 1
+                file_paths.append(rel_path)
+
+            except Exception:
+                continue  # skip unreadable safely
+
+    return files_exported, output_path, file_paths
+
+
+def add_code_file(root: Path, target: Path):
+    config = load_config(root)
+    max_kb = config["export"]["full_code"]["max_file_size_kb"]
+    allow_dup = config["export"]["manual_add"]["allow_duplicates"]
+    ingore_paths = config.get("export", {}).get("ignore", [])
+
+    export_dir = root / ".brain" / "exports"
+    export_dir.mkdir(parents=True, exist_ok=True)
+
+    output_path = export_dir / "full_code.txt"
+
+    if not target.exists():
+        return 0, output_path, "❌ File not found"
+
+    if should_skip(target, ingore_paths):
+        return 0, output_path, "⚠ Skipped (ignored path)"
+
+    existing = _read_existing_entries(output_path) if not allow_dup else set()
+
+    try:
+        size_kb = target.stat().st_size / 1024
+        if size_kb > max_kb:
+            return 0, output_path, "⚠ Skipped (file too large)"
+
+        rel_path = str(target.resolve().relative_to(root))
+
+        if not allow_dup and rel_path in existing:
+            return 0, output_path, "⚠ Skipped (duplicate)"
+
+        content = target.read_text(encoding="utf-8", errors="ignore")
+
+        with output_path.open("a", encoding="utf-8") as out:
+            _append_file(out, rel_path, content, manual=True)
+
+        return 1, output_path, None
+
+    except Exception:
+        return 0, output_path, "⚠ Skipped (unreadable)"
+
+
+def add_code_dir(root: Path, target: Path):
+    config = load_config(root)
+    max_kb = config["export"]["full_code"]["max_file_size_kb"]
+    allow_dup = config["export"]["manual_add"]["allow_duplicates"]
+    ignore_paths = config.get("export", {}).get("ignore", [])
+
+    export_dir = root / ".brain" / "exports"
+    export_dir.mkdir(parents=True, exist_ok=True)
+
+    output_path = export_dir / "full_code.txt"
+
+    if not target.exists():
+        return 0, output_path, "❌ Directory not found"
+
+    existing = _read_existing_entries(output_path) if not allow_dup else set()
+
+    count = 0
+
+    with output_path.open("a", encoding="utf-8") as out:
+        for path in target.rglob("*"):
+            if path.is_dir():
+                continue
+
+            if should_skip(path, ignore_paths):
+                continue
+
+            try:
+                size_kb = path.stat().st_size / 1024
+                if size_kb > max_kb:
+                    continue
+
+                rel_path = str(path.resolve().relative_to(root))
+
+                if not allow_dup and rel_path in existing:
+                    continue
+
+                content = path.read_text(encoding="utf-8", errors="ignore")
+
+                _append_file(out, rel_path, content, manual=True)
+                count += 1
+
+            except Exception:
+                continue
+
+    return count, output_path, None
+
+
+def _extract_functions_with_code(source: str):
+    result = {}
+
+    try:
+        tree = ast.parse(source)
+    except Exception:
+        return result
+
+    lines = source.splitlines()
+
+    for node in ast.walk(tree):
+        if isinstance(node, ast.FunctionDef):
+            start = node.lineno - 1
+            end = getattr(node, "end_lineno", start + 1)
+
+            code = "\n".join(lines[start:end])
+            body_hash = hashlib.sha256(code.encode()).hexdigest()
+
+            result[node.name] = {
+                "code": code,
+                "hash": body_hash,
+                "line": node.lineno
+            }
+
+    return result
+
+
+def export_code_changes(root: Path, from_ref: str, to_ref: str):
+    config = load_config(root)
+    changes_cfg = config.get("export", {}).get("changes", {})
+
+    mode = changes_cfg.get("mode", "function")
+    include_context = changes_cfg.get("include_context", True)
+
+    export_dir = root / ".brain" / "exports"
+    export_dir.mkdir(parents=True, exist_ok=True)
+
+    output_path = export_dir / "code_changes.txt"
+
+    diff = compute_diff(from_ref, to_ref, root)
+    if not diff:
+        return 0, output_path
+
+    files_processed = 0
+
+    with output_path.open("w", encoding="utf-8") as out:
+
+        # ADDED FILES
+        for file in diff["added"]:
+            new_src = get_file_from_ref(to_ref, file, root)
+            if not new_src:
+                continue
+
+            out.write(f"=== FILE: {file} (ADDED) ===\n")
+            out.write(new_src)
+            out.write("\n\n")
+
+            files_processed += 1
+
+        # DELETED FILES
+        for file in diff["deleted"]:
+            old_src = get_file_from_ref(from_ref, file, root)
+            if not old_src:
+                continue
+
+            out.write(f"=== FILE: {file} (DELETED) ===\n")
+            out.write(old_src)
+            out.write("\n\n")
+
+            files_processed += 1
+
+        # MODIFIED FILES
+        for file in diff["modified"]:
+            if not file.endswith(".py"):
+                out.write(f"=== FILE: {file} (MODIFIED - NON PY) ===\n")
+                out.write("Changes not analyzed.\n\n")
+                files_processed += 1
+                continue
+
+            old_src = get_file_from_ref(from_ref, file, root)
+            new_src = get_file_from_ref(to_ref, file, root)
+
+            if not old_src or not new_src:
+                continue
+
+            if mode == "file":
+                out.write(f"=== FILE: {file} (MODIFIED) ===\n")
+                out.write("OLD:\n")
+                out.write(old_src)
+                out.write("\n\nNEW:\n")
+                out.write(new_src)
+                out.write("\n\n")
+                files_processed += 1
+                continue
+
+            old_funcs = _extract_functions_with_code(old_src)
+            new_funcs = _extract_functions_with_code(new_src)
+
+            all_funcs = set(old_funcs) | set(new_funcs)
+
+            out.write(f"=== FILE: {file} ===\n\n")
+
+            for fn in all_funcs:
+                old_f = old_funcs.get(fn)
+                new_f = new_funcs.get(fn)
+
+                if old_f and not new_f:
+                    out.write(f"--- FUNCTION: {fn} (REMOVED) ---\n")
+                    if include_context:
+                        out.write(f"# line: {old_f['line']}\n")
+                    out.write("OLD:\n")
+                    out.write(old_f["code"])
+                    out.write("\n\n")
+
+                elif new_f and not old_f:
+                    out.write(f"--- FUNCTION: {fn} (ADDED) ---\n")
+                    if include_context:
+                        out.write(f"# line: {new_f['line']}\n")
+                    out.write("NEW:\n")
+                    out.write(new_f["code"])
+                    out.write("\n\n")
+
+                elif old_f and new_f:
+                    if old_f["hash"] != new_f["hash"]:
+                        out.write(f"--- FUNCTION: {fn} (UPDATED) ---\n")
+                        if include_context:
+                            out.write(f"# old line: {old_f['line']}, new line: {new_f['line']}\n")
+                        out.write("OLD:\n")
+                        out.write(old_f["code"])
+                        out.write("\n\nNEW:\n")
+                        out.write(new_f["code"])
+                        out.write("\n\n")
+
+            files_processed += 1
+
+    return files_processed, output_path

project_brain/core/logger.py

@@ -0,0 +1,31 @@
+from datetime import datetime
+from pathlib import Path
+
+LOG_FILE = Path(".brain") / "logs.txt"
+
+
+def _write(level: str, message: str):
+    timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    formatted = f"[{timestamp}] [{level}] {message}"
+
+    try:
+        LOG_FILE.parent.mkdir(parents=True, exist_ok=True)
+        with LOG_FILE.open("a", encoding="utf-8") as f:
+            f.write(formatted + "\n")
+    except Exception:
+        # fallback: never crash logging
+        print(formatted)
+
+
+def log_info(message: str):
+    _write("INFO", message)
+
+
+def log_warning(message: str):
+    _write("WARNING", message)
+    print(f"[WARNING] {message}")  # keep visible
+
+
+def log_error(message: str):
+    _write("ERROR", message)
+    print(f"[ERROR] {message}")  # keep visible

project_brain/core/results.py

@@ -0,0 +1,163 @@
+from collections import defaultdict
+
+
+def generate_html(results):
+
+    grouped = defaultdict(list)
+    for item in results:
+        grouped[item["file"]].append(item)
+
+    sections = ""
+
+    for file, items in grouped.items():
+        rows = ""
+
+        for item in items:
+            risk = item["risk"] or "unknown"
+
+            if "high" in risk.lower():
+                risk_class = "risk-high"
+            elif "medium" in risk.lower():
+                risk_class = "risk-medium"
+            else:
+                risk_class = "risk-low"
+
+            rows += f"""
+            <div class="function-card">
+                <div class="fn-header">
+                    <span class="fn-name">{item['function']}</span>
+                    <span class="badge {risk_class}">{risk}</span>
+                </div>
+
+                <div class="section">
+                    <b>Change</b>
+                    <p>{item['change']}</p>
+                </div>
+
+                <div class="section">
+                    <b>Impact</b>
+                    <p>{item['impact']}</p>
+                </div>
+
+                <div class="section">
+                    <b>Risk</b>
+                    <p>{item['risk']}</p>
+                </div>
+            </div>
+            """
+
+        sections += f"""
+        <div class="file-block">
+            <div class="file-header" onclick="toggle(this)">
+                📂 {file}
+            </div>
+            <div class="file-content">
+                {rows}
+            </div>
+        </div>
+        """
+
+    return f"""
+<html>
+<head>
+<meta charset="UTF-8">
+<title>Project Brain Report</title>
+
+<style>
+body {{
+    font-family: Inter, Arial;
+    background: #0f172a;
+    color: #e2e8f0;
+    padding: 20px;
+}}
+
+h1 {{
+    color: #38bdf8;
+    margin-bottom: 20px;
+}}
+
+.file-block {{
+    margin-bottom: 20px;
+    border: 1px solid #334155;
+    border-radius: 10px;
+    overflow: hidden;
+}}
+
+.file-header {{
+    background: #1e293b;
+    padding: 12px;
+    cursor: pointer;
+    font-weight: bold;
+}}
+
+.file-content {{
+    display: none;
+    padding: 15px;
+}}
+
+.function-card {{
+    background: #020617;
+    border: 1px solid #334155;
+    border-radius: 8px;
+    padding: 12px;
+    margin-bottom: 12px;
+}}
+
+.fn-header {{
+    display: flex;
+    justify-content: space-between;
+    margin-bottom: 10px;
+}}
+
+.fn-name {{
+    font-weight: bold;
+    color: #22c55e;
+}}
+
+.section {{
+    margin-bottom: 8px;
+}}
+
+.section p {{
+    margin: 4px 0;
+    color: #cbd5f5;
+}}
+
+.badge {{
+    padding: 4px 8px;
+    border-radius: 6px;
+    font-size: 12px;
+}}
+
+.risk-high {{
+    background: #dc2626;
+}}
+
+.risk-medium {{
+    background: #f59e0b;
+}}
+
+.risk-low {{
+    background: #16a34a;
+}}
+</style>
+
+<script>
+function toggle(el) {{
+    let content = el.nextElementSibling;
+    content.style.display =
+        content.style.display === "block" ? "none" : "block";
+}}
+</script>
+
+</head>
+
+<body>
+
+<h1>🧠 Project Brain - Diff Analysis</h1>
+
+{sections}
+
+</body>
+</html>
+"""