cortexcode 0.5.0__py3-none-any.whl → 0.6.0__py3-none-any.whl

cortexcode/advanced_analysis/__init__.py

@@ -0,0 +1,17 @@
+"""Advanced analysis modules."""
+
+from cortexcode.advanced_analysis.advanced_analysis_cycles import find_circular_dependencies
+from cortexcode.advanced_analysis.advanced_analysis_docs import generate_docs_summary
+from cortexcode.advanced_analysis.advanced_analysis_duplicates import find_duplicates
+from cortexcode.advanced_analysis.advanced_analysis_endpoints import find_api_endpoints
+from cortexcode.advanced_analysis.advanced_analysis_search import search_symbols_by_semantics
+from cortexcode.advanced_analysis.advanced_analysis_security import scan_security_issues
+
+__all__ = [
+    "find_circular_dependencies",
+    "generate_docs_summary",
+    "find_duplicates",
+    "find_api_endpoints",
+    "search_symbols_by_semantics",
+    "scan_security_issues",
+]

cortexcode/advanced_analysis/advanced_analysis.py

@@ -0,0 +1,19 @@
+"""Advanced code analysis — duplication, security, circular deps, API endpoints, doc generation."""
+
+from cortexcode.advanced_analysis_cycles import detect_circular_deps
+from cortexcode.advanced_analysis_docs import generate_api_docs
+from cortexcode.advanced_analysis_duplicates import detect_duplicates
+from cortexcode.advanced_analysis_endpoints import extract_endpoints
+from cortexcode.advanced_analysis_search import fuzzy_search, regex_search
+from cortexcode.advanced_analysis_security import security_scan
+
+
+__all__ = [
+    "fuzzy_search",
+    "regex_search",
+    "detect_duplicates",
+    "security_scan",
+    "detect_circular_deps",
+    "extract_endpoints",
+    "generate_api_docs",
+]

cortexcode/advanced_analysis/advanced_analysis_cycles.py

@@ -0,0 +1,67 @@
+from typing import Any
+
+
+def detect_circular_deps(index: dict) -> list[dict[str, Any]]:
+    """Detect circular dependencies in file imports and call graph."""
+    results = []
+
+    file_deps = index.get("file_dependencies", {})
+    file_cycles = _find_cycles(file_deps)
+    for cycle in file_cycles:
+        results.append({
+            "type": "file_import",
+            "cycle": cycle,
+            "length": len(cycle),
+            "severity": "high" if len(cycle) <= 2 else "medium",
+        })
+
+    call_graph = index.get("call_graph", {})
+    symbol_cycles = _find_cycles(call_graph)
+    for cycle in symbol_cycles:
+        if len(cycle) <= 5:
+            results.append({
+                "type": "call_cycle",
+                "cycle": cycle,
+                "length": len(cycle),
+                "severity": "medium" if len(cycle) <= 2 else "low",
+            })
+
+    results.sort(key=lambda x: x["length"])
+    return results
+
+
+def _find_cycles(graph: dict[str, list]) -> list[list[str]]:
+    """Find all cycles in a directed graph using DFS."""
+    cycles = []
+    visited = set()
+    path = []
+    path_set = set()
+
+    def dfs(node: str):
+        if node in path_set:
+            idx = path.index(node)
+            cycle = path[idx:] + [node]
+            min_idx = cycle.index(min(cycle[:-1]))
+            normalized = cycle[min_idx:-1] + cycle[:min_idx] + [cycle[min_idx]]
+            if normalized not in cycles:
+                cycles.append(normalized)
+            return
+
+        if node in visited:
+            return
+
+        visited.add(node)
+        path.append(node)
+        path_set.add(node)
+
+        for neighbor in graph.get(node, []):
+            if neighbor in graph:
+                dfs(neighbor)
+
+        path.pop()
+        path_set.discard(node)
+
+    for node in graph:
+        dfs(node)
+
+    return cycles

cortexcode/advanced_analysis/advanced_analysis_docs.py

@@ -0,0 +1,126 @@
+from pathlib import Path
+from typing import Any
+
+
+def generate_api_docs(index: dict, project_root: str | None = None) -> dict[str, Any]:
+    """Generate API documentation from function signatures and docstrings."""
+    files = index.get("files", {})
+    root = Path(project_root) if project_root else None
+
+    modules: list[dict] = []
+
+    for rel_path, file_data in files.items():
+        if not isinstance(file_data, dict):
+            continue
+
+        symbols = file_data.get("symbols", [])
+        if not symbols:
+            continue
+
+        source_lines = None
+        if root:
+            try:
+                source_lines = (root / rel_path).read_text(encoding="utf-8").split("\n")
+            except (OSError, UnicodeDecodeError):
+                pass
+
+        classes = []
+        functions = []
+
+        for sym in symbols:
+            name = sym.get("name", "")
+            sym_type = sym.get("type", "")
+            line = sym.get("line", 0)
+            params = sym.get("params", [])
+            doc = sym.get("doc", "")
+
+            if not doc and source_lines and line > 0:
+                doc = _extract_docstring(source_lines, line - 1)
+
+            entry = {
+                "name": name,
+                "type": sym_type,
+                "line": line,
+                "params": params,
+                "doc": doc or "",
+                "calls": sym.get("calls", []),
+                "framework": sym.get("framework"),
+            }
+
+            if sym_type == "class":
+                classes.append(entry)
+            elif sym_type in ("function", "method"):
+                functions.append(entry)
+
+        if classes or functions:
+            modules.append({
+                "file": rel_path,
+                "classes": classes,
+                "functions": functions,
+                "imports": file_data.get("imports", []),
+            })
+
+    total_documented = sum(
+        1 for module in modules
+        for item in module["functions"] + module["classes"]
+        if item["doc"]
+    )
+    total_symbols = sum(
+        len(module["functions"]) + len(module["classes"])
+        for module in modules
+    )
+
+    return {
+        "modules": modules,
+        "total_modules": len(modules),
+        "total_symbols": total_symbols,
+        "documented": total_documented,
+        "undocumented": total_symbols - total_documented,
+        "coverage_pct": round(total_documented / max(total_symbols, 1) * 100, 1),
+    }
+
+
+def _extract_docstring(lines: list[str], start_idx: int) -> str:
+    """Extract docstring from the line after a function/class definition."""
+    for line_index in range(start_idx + 1, min(start_idx + 5, len(lines))):
+        stripped = lines[line_index].strip()
+        if not stripped:
+            continue
+
+        if stripped.startswith('"""') or stripped.startswith("'''"):
+            quote = stripped[:3]
+            if stripped.endswith(quote) and len(stripped) > 6:
+                return stripped[3:-3].strip()
+            doc_lines = [stripped[3:]]
+            for doc_line_index in range(line_index + 1, min(line_index + 20, len(lines))):
+                line = lines[doc_line_index].strip()
+                if line.endswith(quote):
+                    doc_lines.append(line[:-3])
+                    return "\n".join(doc_lines).strip()
+                doc_lines.append(line)
+            break
+
+        if stripped.startswith("/**"):
+            doc_lines = []
+            for doc_line_index in range(line_index, min(line_index + 20, len(lines))):
+                line = lines[doc_line_index].strip()
+                if line.endswith("*/"):
+                    line = line[:-2].strip()
+                    if line.startswith("/**"):
+                        line = line[3:].strip()
+                    elif line.startswith("*"):
+                        line = line[1:].strip()
+                    if line:
+                        doc_lines.append(line)
+                    return "\n".join(doc_lines).strip()
+                if line.startswith("/**"):
+                    line = line[3:].strip()
+                elif line.startswith("*"):
+                    line = line[1:].strip()
+                if line:
+                    doc_lines.append(line)
+            break
+
+        break
+
+    return ""

cortexcode/advanced_analysis/advanced_analysis_duplicates.py

@@ -0,0 +1,158 @@
+import hashlib
+import re
+from difflib import SequenceMatcher
+from pathlib import Path
+from typing import Any
+
+
+def detect_duplicates(index: dict, project_root: str | None = None, min_lines: int = 5) -> list[dict[str, Any]]:
+    """Find duplicate or very similar code blocks.
+    
+    Compares function bodies by normalizing whitespace and variable names,
+    then computing similarity scores.
+    """
+    files = index.get("files", {})
+    root = Path(project_root) if project_root else None
+
+    functions: list[dict] = []
+    for rel_path, file_data in files.items():
+        if not isinstance(file_data, dict):
+            continue
+
+        source_lines = None
+        if root:
+            try:
+                source_lines = (root / rel_path).read_text(encoding="utf-8").split("\n")
+            except (OSError, UnicodeDecodeError):
+                continue
+
+        if not source_lines:
+            continue
+
+        for sym in file_data.get("symbols", []):
+            if sym.get("type") not in ("function", "method"):
+                continue
+
+            line = sym.get("line", 0)
+            if line <= 0:
+                continue
+
+            body = _extract_function_body(source_lines, line - 1)
+            if len(body.split("\n")) < min_lines:
+                continue
+
+            normalized = _normalize_code(body)
+            functions.append({
+                "name": sym.get("name", ""),
+                "file": rel_path,
+                "line": line,
+                "body": body,
+                "normalized": normalized,
+                "hash": hashlib.md5(normalized.encode()).hexdigest(),
+            })
+
+    hash_groups: dict[str, list] = {}
+    for func in functions:
+        func_hash = func["hash"]
+        if func_hash not in hash_groups:
+            hash_groups[func_hash] = []
+        hash_groups[func_hash].append(func)
+
+    duplicates = []
+    seen_pairs = set()
+
+    for func_hash, group in hash_groups.items():
+        if len(group) > 1:
+            duplicates.append({
+                "type": "exact",
+                "similarity": 1.0,
+                "functions": [
+                    {"name": func["name"], "file": func["file"], "line": func["line"]}
+                    for func in group
+                ],
+                "lines": len(group[0]["body"].split("\n")),
+            })
+            for func in group:
+                seen_pairs.add((func["file"], func["line"]))
+
+    for index_position, first_func in enumerate(functions):
+        if (first_func["file"], first_func["line"]) in seen_pairs:
+            continue
+        for second_func in functions[index_position + 1:]:
+            if (second_func["file"], second_func["line"]) in seen_pairs:
+                continue
+            if first_func["hash"] == second_func["hash"]:
+                continue
+
+            similarity = SequenceMatcher(None, first_func["normalized"], second_func["normalized"]).ratio()
+            if similarity > 0.8:
+                duplicates.append({
+                    "type": "near",
+                    "similarity": round(similarity, 3),
+                    "functions": [
+                        {"name": first_func["name"], "file": first_func["file"], "line": first_func["line"]},
+                        {"name": second_func["name"], "file": second_func["file"], "line": second_func["line"]},
+                    ],
+                    "lines": max(
+                        len(first_func["body"].split("\n")),
+                        len(second_func["body"].split("\n")),
+                    ),
+                })
+
+    duplicates.sort(key=lambda x: x["similarity"], reverse=True)
+    return duplicates
+
+
+def _extract_function_body(lines: list[str], start_idx: int) -> str:
+    """Extract function body from source lines."""
+    if start_idx >= len(lines):
+        return ""
+
+    start_line = lines[start_idx]
+    start_indent = len(start_line) - len(start_line.lstrip())
+    indent_based = "def " in start_line or start_line.strip().endswith(":")
+
+    body = [lines[start_idx]]
+    brace_depth = 0
+
+    for line_index in range(start_idx + 1, min(start_idx + 300, len(lines))):
+        line = lines[line_index]
+        stripped = line.strip()
+
+        if not stripped:
+            body.append(line)
+            continue
+
+        if indent_based:
+            current_indent = len(line) - len(line.lstrip())
+            if current_indent <= start_indent and stripped and not stripped.startswith((")", "]", "}")):
+                break
+        else:
+            brace_depth += stripped.count("{") - stripped.count("}")
+            if brace_depth <= 0 and len(body) > 1:
+                body.append(line)
+                break
+
+        body.append(line)
+
+    return "\n".join(body)
+
+
+def _normalize_code(code: str) -> str:
+    """Normalize code for comparison — remove comments, normalize whitespace, replace identifiers."""
+    lines = []
+    for line in code.split("\n"):
+        stripped = line.strip()
+        if stripped.startswith("#") or stripped.startswith("//"):
+            continue
+        stripped = re.sub(r'#.*$', '', stripped)
+        stripped = re.sub(r'//.*$', '', stripped)
+        stripped = stripped.strip()
+        if stripped:
+            lines.append(stripped)
+
+    result = "\n".join(lines)
+    result = re.sub(r'"[^"]*"', '"STR"', result)
+    result = re.sub(r"'[^']*'", "'STR'", result)
+    result = re.sub(r'\b\d+\b', 'NUM', result)
+    return result

cortexcode/advanced_analysis/advanced_analysis_endpoints.py

@@ -0,0 +1,205 @@
+import re
+from pathlib import Path
+from typing import Any
+
+
+ENDPOINT_PATTERNS = [
+    (r'(?:app|router)\.(get|post|put|delete|patch|all|use)\s*\(\s*["\']([^"\']+)', "express"),
+    (r'@(?:app|blueprint|bp)\.(route|get|post|put|delete|patch)\s*\(\s*["\']([^"\']+)', "flask"),
+    (r'path\s*\(\s*["\']([^"\']+)["\']', "django"),
+    (r'@(?:app|router)\.(get|post|put|delete|patch)\s*\(\s*["\']([^"\']+)', "fastapi"),
+    (r'export\s+(?:async\s+)?function\s+(GET|POST|PUT|DELETE|PATCH)\s*\(', "nextjs"),
+    (r'@(?:Get|Post|Put|Delete|Patch|Request)Mapping\s*\(\s*(?:value\s*=\s*)?["\']([^"\']+)', "spring"),
+    (r'(?:Handle|HandleFunc)\s*\(\s*["\']([^"\']+)', "go-http"),
+    (r'(?:get|post|put|patch|delete)\s+["\']([^"\']+)', "rails"),
+]
+
+
+def extract_endpoints(index: dict, project_root: str | None = None) -> dict[str, Any]:
+    """Extract API endpoints from source code."""
+    root = Path(project_root) if project_root else None
+    files = index.get("files", {})
+
+    endpoints: list[dict] = []
+    seen = set()
+
+    for rel_path, file_data in files.items():
+        if not isinstance(file_data, dict):
+            continue
+
+        source = None
+        if root:
+            try:
+                source = (root / rel_path).read_text(encoding="utf-8", errors="ignore")
+            except OSError:
+                continue
+
+        if not source:
+            continue
+
+        if _is_nextjs_route(rel_path):
+            methods = re.findall(
+                r'export\s+(?:async\s+)?function\s+(GET|POST|PUT|DELETE|PATCH|HEAD|OPTIONS)\s*\(',
+                source,
+            )
+            route_path = _nextjs_file_to_route(rel_path)
+            for method in methods:
+                key = (method.upper(), route_path, rel_path)
+                if key not in seen:
+                    seen.add(key)
+                    endpoints.append({
+                        "method": method.upper(),
+                        "path": route_path,
+                        "file": rel_path,
+                        "framework": "nextjs",
+                    })
+            continue
+
+        lines = source.split("\n")
+
+        if _is_nextjs_route(rel_path):
+            continue
+
+        for line_num, line in enumerate(lines, 1):
+            stripped = line.strip()
+
+            if not stripped or stripped.startswith("#") or stripped.startswith("//"):
+                continue
+
+            if stripped.startswith("app.") or stripped.startswith("router."):
+                match = re.search(r'\.(get|post|put|delete|patch|all|use)\s*\(\s*["\']([^"\']+)', line)
+                if match:
+                    method = match.group(1).upper()
+                    path = match.group(2)
+                    key = (method, path, rel_path)
+                    if key not in seen:
+                        seen.add(key)
+                        endpoints.append({
+                            "method": method,
+                            "path": path,
+                            "file": rel_path,
+                            "line": line_num,
+                            "framework": "express",
+                        })
+                    continue
+
+            if stripped.startswith("@"):
+                match = re.search(r'@(?:app|blueprint|bp)\.(route|get|post|put|delete|patch)\s*\(\s*["\']([^"\']+)', line)
+                if match:
+                    method = match.group(1).upper()
+                    if method == "ROUTE":
+                        method = "GET"
+                    path = match.group(2)
+                    key = (method, path, rel_path)
+                    if key not in seen:
+                        seen.add(key)
+                        endpoints.append({
+                            "method": method,
+                            "path": path,
+                            "file": rel_path,
+                            "line": line_num,
+                            "framework": "flask",
+                        })
+                    continue
+
+                if "path(" in stripped:
+                    match = re.search(r'path\s*\(\s*["\']([^"\']+)["\']', line)
+                    if match:
+                        path = match.group(1)
+                        key = ("GET", path, rel_path)
+                        if key not in seen:
+                            seen.add(key)
+                            endpoints.append({
+                                "method": "GET",
+                                "path": path,
+                                "file": rel_path,
+                                "line": line_num,
+                                "framework": "django",
+                            })
+                    continue
+
+                match = re.search(r'@(Get|Post|Put|Delete|Patch|Request)Mapping\s*\(\s*(?:value\s*=\s*)?["\']([^"\']+)', line)
+                if match:
+                    method = match.group(1)
+                    if method == "Request":
+                        method = "GET"
+                    path = match.group(2)
+                    key = (method, path, rel_path)
+                    if key not in seen:
+                        seen.add(key)
+                        endpoints.append({
+                            "method": method,
+                            "path": path,
+                            "file": rel_path,
+                            "line": line_num,
+                            "framework": "spring",
+                        })
+                    continue
+
+    seen = set()
+    unique = []
+    for endpoint in endpoints:
+        key = (endpoint["method"], endpoint["path"], endpoint["file"])
+        if key not in seen:
+            seen.add(key)
+            unique.append(endpoint)
+
+    unique.sort(key=lambda x: (x["path"], x["method"]))
+
+    return {
+        "count": len(unique),
+        "endpoints": unique,
+        "frameworks": list(set(endpoint["framework"] for endpoint in unique)),
+    }
+
+
+def _is_nextjs_route(path: str) -> bool:
+    """Check if a file is a Next.js API/app route."""
+    normalized = path.replace("\\", "/")
+    return (
+        ("/api/" in normalized and "route." in normalized)
+        or ("/app/" in normalized and "route." in normalized)
+    )
+
+
+def _is_inside_string(lines: list[str], line_idx: int) -> bool:
+    """Check if a line is inside a string literal."""
+    if line_idx < 0 or line_idx >= len(lines):
+        return False
+
+    quote_count = 0
+    in_string = False
+    current_quote = None
+
+    for current_index in range(line_idx + 1):
+        line = lines[current_index]
+        for char in line:
+            if char in ('"', "'", '`') and (current_index != line_idx or True):
+                if not in_string:
+                    in_string = True
+                    current_quote = char
+                    quote_count = 1
+                elif char == current_quote:
+                    if current_index == line_idx and line.index(char) > 0 and line[line.index(char) - 1] == '\\':
+                        continue
+                    quote_count += 1
+                    if quote_count % 2 == 0:
+                        in_string = False
+                        current_quote = None
+
+    return in_string
+
+
+def _nextjs_file_to_route(path: str) -> str:
+    """Convert Next.js file path to route path."""
+    normalized = path.replace("\\", "/")
+    match = re.search(r'(?:src/)?app(/.*)/route\.(?:ts|js|tsx|jsx)', normalized)
+    if match:
+        return match.group(1)
+    match = re.search(r'pages(/.*?)\.(?:ts|js|tsx|jsx)', normalized)
+    if match:
+        route = match.group(1)
+        if route.endswith("/index"):
+            route = route[:-6] or "/"
+        return route
+    return normalized

cortexcode/advanced_analysis/advanced_analysis_search.py

@@ -0,0 +1,85 @@
+import re
+from difflib import SequenceMatcher
+from typing import Any
+
+
+def fuzzy_search(index: dict, query: str, threshold: float = 0.5, limit: int = 20) -> list[dict[str, Any]]:
+    """Fuzzy search for symbols — finds approximate matches.
+    
+    Uses substring matching, case-insensitive matching, and sequence similarity.
+    """
+    query_lower = query.lower()
+    files = index.get("files", {})
+    results = []
+
+    for rel_path, file_data in files.items():
+        if not isinstance(file_data, dict):
+            continue
+        for sym in file_data.get("symbols", []):
+            name = sym.get("name", "")
+            name_lower = name.lower()
+
+            if query_lower in name_lower:
+                score = 1.0 if query_lower == name_lower else 0.9
+            else:
+                score = SequenceMatcher(None, query_lower, name_lower).ratio()
+
+                initials = _extract_initials(name)
+                if query_lower in initials.lower():
+                    score = max(score, 0.75)
+
+                if all(word in name_lower for word in query_lower.split()):
+                    score = max(score, 0.8)
+
+            if score >= threshold:
+                results.append({
+                    "name": name,
+                    "type": sym.get("type"),
+                    "file": rel_path,
+                    "line": sym.get("line"),
+                    "params": sym.get("params", []),
+                    "doc": sym.get("doc"),
+                    "score": round(score, 3),
+                })
+
+    results.sort(key=lambda x: x["score"], reverse=True)
+    return results[:limit]
+
+
+def regex_search(index: dict, pattern: str, sym_type: str | None = None, limit: int = 20) -> list[dict[str, Any]]:
+    """Search symbols using regex pattern."""
+    try:
+        regex = re.compile(pattern, re.IGNORECASE)
+    except re.error as e:
+        return [{"error": f"Invalid regex: {e}"}]
+
+    files = index.get("files", {})
+    results = []
+
+    for rel_path, file_data in files.items():
+        if not isinstance(file_data, dict):
+            continue
+        for sym in file_data.get("symbols", []):
+            name = sym.get("name", "")
+            if regex.search(name):
+                if sym_type and sym.get("type") != sym_type:
+                    continue
+                results.append({
+                    "name": name,
+                    "type": sym.get("type"),
+                    "file": rel_path,
+                    "line": sym.get("line"),
+                    "params": sym.get("params", []),
+                    "doc": sym.get("doc"),
+                })
+
+    return results[:limit]
+
+
+def _extract_initials(name: str) -> str:
+    """Extract initials from camelCase/PascalCase/snake_case name."""
+    initials = re.findall(r'[A-Z]', name)
+    if initials:
+        return ''.join(initials)
+    parts = name.split('_')
+    return ''.join(part[0] for part in parts if part)