cortexcode 0.5.0__tar.gz → 0.6.0__tar.gz

{cortexcode-0.5.0 → cortexcode-0.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cortexcode
-Version: 0.5.0
+Version: 0.6.0
 Summary: Lightweight code indexing for AI assistants — save 90%+ tokens with structured context
 Author-email: Naveen <naveen_joshi07@outlook.com>
 License: MIT
@@ -34,12 +34,17 @@ Requires-Dist: tree-sitter-c-sharp>=0.23.0
 Requires-Dist: click>=8.1.0
 Requires-Dist: watchdog>=4.0.0
 Requires-Dist: rich>=13.0.0
+Requires-Dist: pyyaml>=6.0.0
 Provides-Extra: dev
 Requires-Dist: pytest>=8.0.0; extra == "dev"
 Requires-Dist: pytest-cov>=4.1.0; extra == "dev"
 Requires-Dist: ruff>=0.3.0; extra == "dev"
 Provides-Extra: ai
 Requires-Dist: tiktoken>=0.7.0; extra == "ai"
+Requires-Dist: openai>=1.0.0; extra == "ai"
+Requires-Dist: anthropic>=0.18.0; extra == "ai"
+Requires-Dist: google-generativeai>=0.4.0; extra == "ai"
+Requires-Dist: requests>=2.31.0; extra == "ai"
 Provides-Extra: mobile
 Requires-Dist: tree-sitter-kotlin>=0.1.0; extra == "mobile"
 Requires-Dist: tree-sitter-swift>=0.6.0; extra == "mobile"
@@ -172,6 +177,27 @@ Generate a full interactive documentation site with:
 cortexcode docs --open
 ```
 
+### CodeWiki — AI-Powered Documentation Site
+
+Generate a multi-page **CodeWiki** documentation site powered by AI (Gemini, OpenAI, Anthropic, or Ollama):
+
+```bash
+cortexcode wiki                    # Generate with default AI provider
+cortexcode wiki --provider google  # Use Gemini
+cortexcode wiki --open             # Generate and open in browser
+cortexcode wiki --no-modules       # Skip per-module pages (faster)
+```
+
+**Features:**
+- **AI-generated pages** — Overview, Architecture, Code Flows, API Reference, Concepts Guide
+- **Per-module docs** — Each Python/JS file gets AI-generated documentation
+- **Mermaid diagrams** — Auto-generated flow diagrams
+- **Concept mapping** — Maps technical concepts to symbols and files
+- **Concept search** — Ask "how does authentication work?" and get grounded answers
+- **Token tracking** — See exactly how many tokens each page used
+
+**Output:** `.cortexcode/wiki/index.html` — Open directly or serve locally.
+
 ### Incremental Indexing
 
 Only re-index files that changed since last run:
@@ -225,6 +251,8 @@ npm install && npm run compile
 | `cortexcode watch` | Auto-reindex on file changes |
 | `cortexcode mcp` | Start MCP server for AI agent integration |
 | `cortexcode lsp` | Start Language Server Protocol server |
+| `cortexcode wiki` | Generate CodeWiki documentation site with AI |
+| `cortexcode ask` | Ask a natural language question about the codebase |
 
 ## How AI Agents Use This
 

{cortexcode-0.5.0 → cortexcode-0.6.0}/README.md

@@ -125,6 +125,27 @@ Generate a full interactive documentation site with:
 cortexcode docs --open
 ```
 
+### CodeWiki — AI-Powered Documentation Site
+
+Generate a multi-page **CodeWiki** documentation site powered by AI (Gemini, OpenAI, Anthropic, or Ollama):
+
+```bash
+cortexcode wiki                    # Generate with default AI provider
+cortexcode wiki --provider google  # Use Gemini
+cortexcode wiki --open             # Generate and open in browser
+cortexcode wiki --no-modules       # Skip per-module pages (faster)
+```
+
+**Features:**
+- **AI-generated pages** — Overview, Architecture, Code Flows, API Reference, Concepts Guide
+- **Per-module docs** — Each Python/JS file gets AI-generated documentation
+- **Mermaid diagrams** — Auto-generated flow diagrams
+- **Concept mapping** — Maps technical concepts to symbols and files
+- **Concept search** — Ask "how does authentication work?" and get grounded answers
+- **Token tracking** — See exactly how many tokens each page used
+
+**Output:** `.cortexcode/wiki/index.html` — Open directly or serve locally.
+
 ### Incremental Indexing
 
 Only re-index files that changed since last run:
@@ -178,6 +199,8 @@ npm install && npm run compile
 | `cortexcode watch` | Auto-reindex on file changes |
 | `cortexcode mcp` | Start MCP server for AI agent integration |
 | `cortexcode lsp` | Start Language Server Protocol server |
+| `cortexcode wiki` | Generate CodeWiki documentation site with AI |
+| `cortexcode ask` | Ask a natural language question about the codebase |
 
 ## How AI Agents Use This
 

cortexcode-0.6.0/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-0.6.0/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-0.6.0/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-0.6.0/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-0.6.0/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