code-explore 0.1.0__py3-none-any.whl

code_explore/__init__.py

@@ -0,0 +1,3 @@
+"""Code Explore - Personal developer knowledge base."""
+
+__version__ = "0.1.0"

code_explore/analyzer/__init__.py

@@ -0,0 +1,13 @@
+"""Code analysis - languages, metrics, dependencies, patterns."""
+
+from code_explore.analyzer.dependencies import detect_dependencies
+from code_explore.analyzer.language import detect_languages
+from code_explore.analyzer.metrics import calculate_metrics
+from code_explore.analyzer.patterns import detect_patterns
+
+__all__ = [
+    "detect_dependencies",
+    "detect_languages",
+    "calculate_metrics",
+    "detect_patterns",
+]

code_explore/analyzer/dependencies.py

@@ -0,0 +1,328 @@
+"""Parse dependency files to extract project dependencies."""
+
+import json
+import re
+from pathlib import Path
+
+from code_explore.models import DependencyInfo
+
+
+def _read_file(path: Path) -> str:
+    try:
+        return path.read_text(encoding="utf-8", errors="replace")
+    except OSError:
+        return ""
+
+
+def _parse_package_json(path: Path) -> list[DependencyInfo]:
+    content = _read_file(path)
+    if not content:
+        return []
+    try:
+        data = json.loads(content)
+    except (json.JSONDecodeError, ValueError):
+        return []
+
+    deps: list[DependencyInfo] = []
+    for name, version in (data.get("dependencies") or {}).items():
+        deps.append(DependencyInfo(name=name, version=version, dev=False, source="package.json"))
+    for name, version in (data.get("devDependencies") or {}).items():
+        deps.append(DependencyInfo(name=name, version=version, dev=True, source="package.json"))
+    return deps
+
+
+def _parse_requirements_txt(path: Path) -> list[DependencyInfo]:
+    content = _read_file(path)
+    if not content:
+        return []
+
+    deps: list[DependencyInfo] = []
+    for line in content.splitlines():
+        line = line.strip()
+        if not line or line.startswith("#") or line.startswith("-"):
+            continue
+        match = re.match(r"^([A-Za-z0-9_][A-Za-z0-9._-]*)\s*(?:([><=!~]+.*))?", line)
+        if match:
+            name = match.group(1)
+            version = match.group(2)
+            if version:
+                version = version.strip()
+            deps.append(DependencyInfo(
+                name=name, version=version or None, dev=False, source=path.name,
+            ))
+    return deps
+
+
+def _parse_pyproject_toml(path: Path) -> list[DependencyInfo]:
+    content = _read_file(path)
+    if not content:
+        return []
+
+    deps: list[DependencyInfo] = []
+
+    in_deps = False
+    in_dev_deps = False
+    for line in content.splitlines():
+        stripped = line.strip()
+
+        if stripped.startswith("["):
+            in_deps = stripped in (
+                "[project]",
+                "[tool.poetry.dependencies]",
+            )
+            in_dev_deps = stripped in (
+                "[tool.poetry.dev-dependencies]",
+                "[tool.poetry.group.dev.dependencies]",
+            )
+            if stripped == "[project]":
+                in_deps = False
+            continue
+
+        if stripped == "dependencies = [":
+            in_deps = True
+            continue
+
+        if in_deps and stripped.startswith("]"):
+            in_deps = False
+            continue
+
+        if in_deps:
+            match = re.match(r'"([A-Za-z0-9_][A-Za-z0-9._-]*)\s*(?:([><=!~]+[^"]*))?"', stripped)
+            if match:
+                deps.append(DependencyInfo(
+                    name=match.group(1),
+                    version=match.group(2) or None,
+                    dev=False,
+                    source="pyproject.toml",
+                ))
+                continue
+
+            toml_match = re.match(
+                r'([A-Za-z0-9_][A-Za-z0-9._-]*)\s*=\s*["\{]([^"}\n]*)', stripped,
+            )
+            if toml_match:
+                name = toml_match.group(1)
+                if name == "python":
+                    continue
+                version_str = toml_match.group(2).strip().rstrip('"')
+                deps.append(DependencyInfo(
+                    name=name,
+                    version=version_str or None,
+                    dev=in_dev_deps,
+                    source="pyproject.toml",
+                ))
+
+        if in_dev_deps:
+            toml_match = re.match(
+                r'([A-Za-z0-9_][A-Za-z0-9._-]*)\s*=\s*["\{]([^"}\n]*)', stripped,
+            )
+            if toml_match:
+                name = toml_match.group(1)
+                if name == "python":
+                    continue
+                version_str = toml_match.group(2).strip().rstrip('"')
+                deps.append(DependencyInfo(
+                    name=name,
+                    version=version_str or None,
+                    dev=True,
+                    source="pyproject.toml",
+                ))
+
+    return deps
+
+
+def _parse_setup_py(path: Path) -> list[DependencyInfo]:
+    content = _read_file(path)
+    if not content:
+        return []
+
+    deps: list[DependencyInfo] = []
+    for match in re.finditer(r"install_requires\s*=\s*\[(.*?)]", content, re.DOTALL):
+        block = match.group(1)
+        for pkg in re.findall(r"['\"]([A-Za-z0-9_][A-Za-z0-9._-]*(?:\s*[><=!~]+[^'\"]*)?)['\"]", block):
+            parts = re.match(r"([A-Za-z0-9_][A-Za-z0-9._-]*)\s*(.*)", pkg)
+            if parts:
+                deps.append(DependencyInfo(
+                    name=parts.group(1),
+                    version=parts.group(2).strip() or None,
+                    dev=False,
+                    source="setup.py",
+                ))
+    return deps
+
+
+def _parse_cargo_toml(path: Path) -> list[DependencyInfo]:
+    content = _read_file(path)
+    if not content:
+        return []
+
+    deps: list[DependencyInfo] = []
+    in_deps = False
+    in_dev_deps = False
+
+    for line in content.splitlines():
+        stripped = line.strip()
+        if stripped.startswith("["):
+            in_deps = stripped == "[dependencies]"
+            in_dev_deps = stripped in ("[dev-dependencies]", "[build-dependencies]")
+            continue
+
+        if in_deps or in_dev_deps:
+            match = re.match(r'([A-Za-z0-9_][A-Za-z0-9_-]*)\s*=\s*"([^"]*)"', stripped)
+            if match:
+                deps.append(DependencyInfo(
+                    name=match.group(1),
+                    version=match.group(2),
+                    dev=in_dev_deps,
+                    source="Cargo.toml",
+                ))
+                continue
+            match = re.match(r'([A-Za-z0-9_][A-Za-z0-9_-]*)\s*=\s*\{.*?version\s*=\s*"([^"]*)"', stripped)
+            if match:
+                deps.append(DependencyInfo(
+                    name=match.group(1),
+                    version=match.group(2),
+                    dev=in_dev_deps,
+                    source="Cargo.toml",
+                ))
+
+    return deps
+
+
+def _parse_go_mod(path: Path) -> list[DependencyInfo]:
+    content = _read_file(path)
+    if not content:
+        return []
+
+    deps: list[DependencyInfo] = []
+    in_require = False
+
+    for line in content.splitlines():
+        stripped = line.strip()
+        if stripped.startswith("require ("):
+            in_require = True
+            continue
+        if stripped == ")":
+            in_require = False
+            continue
+        if stripped.startswith("require "):
+            parts = stripped[len("require "):].strip().split()
+            if len(parts) >= 2:
+                deps.append(DependencyInfo(
+                    name=parts[0], version=parts[1], dev=False, source="go.mod",
+                ))
+            continue
+        if in_require:
+            parts = stripped.split()
+            if len(parts) >= 2 and not parts[0].startswith("//"):
+                deps.append(DependencyInfo(
+                    name=parts[0], version=parts[1], dev=False, source="go.mod",
+                ))
+
+    return deps
+
+
+def _parse_pom_xml(path: Path) -> list[DependencyInfo]:
+    content = _read_file(path)
+    if not content:
+        return []
+
+    deps: list[DependencyInfo] = []
+    for match in re.finditer(
+        r"<dependency>\s*"
+        r"<groupId>([^<]+)</groupId>\s*"
+        r"<artifactId>([^<]+)</artifactId>\s*"
+        r"(?:<version>([^<]+)</version>)?",
+        content,
+    ):
+        group_id = match.group(1).strip()
+        artifact_id = match.group(2).strip()
+        version = match.group(3).strip() if match.group(3) else None
+        scope_match = re.search(r"<scope>([^<]+)</scope>", content[match.start():match.start() + 500])
+        is_dev = scope_match and scope_match.group(1).strip() in ("test", "provided")
+        deps.append(DependencyInfo(
+            name=f"{group_id}:{artifact_id}",
+            version=version,
+            dev=bool(is_dev),
+            source="pom.xml",
+        ))
+
+    return deps
+
+
+def _parse_gemfile(path: Path) -> list[DependencyInfo]:
+    content = _read_file(path)
+    if not content:
+        return []
+
+    deps: list[DependencyInfo] = []
+    in_dev_group = False
+
+    for line in content.splitlines():
+        stripped = line.strip()
+        if stripped.startswith("group :development") or stripped.startswith("group :test"):
+            in_dev_group = True
+            continue
+        if stripped == "end" and in_dev_group:
+            in_dev_group = False
+            continue
+
+        match = re.match(r"gem\s+['\"]([^'\"]+)['\"](?:\s*,\s*['\"]([^'\"]*)['\"])?", stripped)
+        if match:
+            deps.append(DependencyInfo(
+                name=match.group(1),
+                version=match.group(2) or None,
+                dev=in_dev_group,
+                source="Gemfile",
+            ))
+
+    return deps
+
+
+def _parse_composer_json(path: Path) -> list[DependencyInfo]:
+    content = _read_file(path)
+    if not content:
+        return []
+    try:
+        data = json.loads(content)
+    except (json.JSONDecodeError, ValueError):
+        return []
+
+    deps: list[DependencyInfo] = []
+    for name, version in (data.get("require") or {}).items():
+        if name == "php" or name.startswith("ext-"):
+            continue
+        deps.append(DependencyInfo(name=name, version=version, dev=False, source="composer.json"))
+    for name, version in (data.get("require-dev") or {}).items():
+        deps.append(DependencyInfo(name=name, version=version, dev=True, source="composer.json"))
+    return deps
+
+
+_PARSERS: dict[str, callable] = {
+    "package.json": _parse_package_json,
+    "requirements.txt": _parse_requirements_txt,
+    "requirements-dev.txt": _parse_requirements_txt,
+    "requirements_dev.txt": _parse_requirements_txt,
+    "pyproject.toml": _parse_pyproject_toml,
+    "setup.py": _parse_setup_py,
+    "Cargo.toml": _parse_cargo_toml,
+    "go.mod": _parse_go_mod,
+    "pom.xml": _parse_pom_xml,
+    "Gemfile": _parse_gemfile,
+    "composer.json": _parse_composer_json,
+}
+
+
+def detect_dependencies(project_path: str | Path) -> list[DependencyInfo]:
+    root = Path(project_path)
+    if not root.is_dir():
+        return []
+
+    all_deps: list[DependencyInfo] = []
+
+    for filename, parser in _PARSERS.items():
+        dep_file = root / filename
+        if dep_file.is_file():
+            all_deps.extend(parser(dep_file))
+
+    return all_deps

code_explore/analyzer/language.py

@@ -0,0 +1,240 @@
+"""Detect programming languages in a project directory."""
+
+from pathlib import Path
+
+from code_explore.models import LanguageInfo
+
+EXTENSION_MAP: dict[str, str] = {
+    ".py": "Python",
+    ".pyw": "Python",
+    ".pyi": "Python",
+    ".pyx": "Python",
+    ".js": "JavaScript",
+    ".mjs": "JavaScript",
+    ".cjs": "JavaScript",
+    ".jsx": "JavaScript",
+    ".ts": "TypeScript",
+    ".tsx": "TypeScript",
+    ".mts": "TypeScript",
+    ".cts": "TypeScript",
+    ".java": "Java",
+    ".kt": "Kotlin",
+    ".kts": "Kotlin",
+    ".scala": "Scala",
+    ".groovy": "Groovy",
+    ".gradle": "Groovy",
+    ".c": "C",
+    ".h": "C",
+    ".cpp": "C++",
+    ".cc": "C++",
+    ".cxx": "C++",
+    ".hpp": "C++",
+    ".hh": "C++",
+    ".hxx": "C++",
+    ".cs": "C#",
+    ".fs": "F#",
+    ".fsx": "F#",
+    ".vb": "Visual Basic",
+    ".go": "Go",
+    ".rs": "Rust",
+    ".rb": "Ruby",
+    ".erb": "Ruby",
+    ".rake": "Ruby",
+    ".php": "PHP",
+    ".swift": "Swift",
+    ".m": "Objective-C",
+    ".mm": "Objective-C",
+    ".r": "R",
+    ".R": "R",
+    ".rmd": "R",
+    ".jl": "Julia",
+    ".lua": "Lua",
+    ".pl": "Perl",
+    ".pm": "Perl",
+    ".ex": "Elixir",
+    ".exs": "Elixir",
+    ".erl": "Erlang",
+    ".hrl": "Erlang",
+    ".hs": "Haskell",
+    ".lhs": "Haskell",
+    ".ml": "OCaml",
+    ".mli": "OCaml",
+    ".clj": "Clojure",
+    ".cljs": "Clojure",
+    ".cljc": "Clojure",
+    ".dart": "Dart",
+    ".zig": "Zig",
+    ".nim": "Nim",
+    ".v": "V",
+    ".d": "D",
+    ".pas": "Pascal",
+    ".pp": "Pascal",
+    ".f90": "Fortran",
+    ".f95": "Fortran",
+    ".f03": "Fortran",
+    ".f": "Fortran",
+    ".for": "Fortran",
+    ".asm": "Assembly",
+    ".s": "Assembly",
+    ".sh": "Shell",
+    ".bash": "Shell",
+    ".zsh": "Shell",
+    ".fish": "Shell",
+    ".ps1": "PowerShell",
+    ".psm1": "PowerShell",
+    ".bat": "Batch",
+    ".cmd": "Batch",
+    ".html": "HTML",
+    ".htm": "HTML",
+    ".css": "CSS",
+    ".scss": "SCSS",
+    ".sass": "Sass",
+    ".less": "Less",
+    ".styl": "Stylus",
+    ".vue": "Vue",
+    ".svelte": "Svelte",
+    ".sql": "SQL",
+    ".graphql": "GraphQL",
+    ".gql": "GraphQL",
+    ".proto": "Protocol Buffers",
+    ".yaml": "YAML",
+    ".yml": "YAML",
+    ".json": "JSON",
+    ".xml": "XML",
+    ".toml": "TOML",
+    ".ini": "INI",
+    ".cfg": "INI",
+    ".md": "Markdown",
+    ".rst": "reStructuredText",
+    ".tex": "LaTeX",
+    ".tf": "Terraform",
+    ".hcl": "HCL",
+    ".sol": "Solidity",
+    ".vy": "Vyper",
+    ".wasm": "WebAssembly",
+    ".wat": "WebAssembly",
+    ".dockerfile": "Dockerfile",
+    ".cmake": "CMake",
+    ".makefile": "Makefile",
+    ".mk": "Makefile",
+}
+
+SKIP_DIRS: set[str] = {
+    "node_modules", ".git", ".svn", ".hg", "__pycache__", ".mypy_cache",
+    ".pytest_cache", ".tox", ".nox", ".venv", "venv", "env", ".env",
+    "dist", "build", "out", "target", ".next", ".nuxt", ".output",
+    "vendor", "third_party", "3rdparty", ".gradle", ".idea", ".vscode",
+    ".vs", "bin", "obj", ".cache", ".parcel-cache", "coverage",
+    ".nyc_output", ".terraform", ".eggs", "*.egg-info",
+}
+
+GENERATED_PATTERNS: set[str] = {
+    ".min.js", ".min.css", ".bundle.js", ".chunk.js",
+    ".Designer.cs", ".generated.cs", ".g.cs", ".g.i.cs",
+    ".pb.go", ".pb.cc", ".pb.h", "_pb2.py", "_pb2_grpc.py",
+    ".d.ts",
+}
+
+BINARY_EXTENSIONS: set[str] = {
+    ".png", ".jpg", ".jpeg", ".gif", ".bmp", ".ico", ".svg", ".webp",
+    ".mp3", ".mp4", ".wav", ".avi", ".mov", ".mkv", ".flac",
+    ".zip", ".tar", ".gz", ".bz2", ".xz", ".rar", ".7z",
+    ".exe", ".dll", ".so", ".dylib", ".a", ".o", ".obj",
+    ".class", ".jar", ".war", ".ear",
+    ".pyc", ".pyo", ".whl",
+    ".pdf", ".doc", ".docx", ".xls", ".xlsx", ".ppt", ".pptx",
+    ".ttf", ".otf", ".woff", ".woff2", ".eot",
+    ".db", ".sqlite", ".sqlite3",
+    ".lock",
+}
+
+
+def _is_generated(filename: str) -> bool:
+    lower = filename.lower()
+    return any(lower.endswith(pat) for pat in GENERATED_PATTERNS)
+
+
+def _is_binary(ext: str) -> bool:
+    return ext.lower() in BINARY_EXTENSIONS
+
+
+def _count_lines(path: Path) -> int:
+    try:
+        return sum(1 for _ in path.open("r", encoding="utf-8", errors="replace"))
+    except (OSError, ValueError):
+        return 0
+
+
+def _should_skip_dir(name: str) -> bool:
+    return name in SKIP_DIRS or name.startswith(".")
+
+
+def _get_language(path: Path) -> str | None:
+    name_lower = path.name.lower()
+    if name_lower == "dockerfile" or name_lower.startswith("dockerfile."):
+        return "Dockerfile"
+    if name_lower == "makefile" or name_lower == "gnumakefile":
+        return "Makefile"
+    if name_lower == "cmakelists.txt":
+        return "CMake"
+    if name_lower == "jenkinsfile":
+        return "Groovy"
+    if name_lower == "vagrantfile":
+        return "Ruby"
+    if name_lower == "rakefile":
+        return "Ruby"
+    if name_lower == "gemfile":
+        return "Ruby"
+
+    ext = path.suffix
+    if not ext:
+        return None
+    return EXTENSION_MAP.get(ext) or EXTENSION_MAP.get(ext.lower())
+
+
+def detect_languages(project_path: str | Path) -> tuple[list[LanguageInfo], str | None]:
+    root = Path(project_path)
+    if not root.is_dir():
+        return [], None
+
+    stats: dict[str, dict[str, int]] = {}
+
+    for item in root.rglob("*"):
+        if not item.is_file():
+            continue
+
+        rel_parts = item.relative_to(root).parts
+        if any(_should_skip_dir(p) for p in rel_parts[:-1]):
+            continue
+
+        if _is_binary(item.suffix):
+            continue
+
+        if _is_generated(item.name):
+            continue
+
+        language = _get_language(item)
+        if language is None:
+            continue
+
+        lines = _count_lines(item)
+        if language not in stats:
+            stats[language] = {"files": 0, "lines": 0}
+        stats[language]["files"] += 1
+        stats[language]["lines"] += lines
+
+    total_lines = sum(s["lines"] for s in stats.values())
+
+    results = [
+        LanguageInfo(
+            name=lang,
+            files=data["files"],
+            lines=data["lines"],
+            percentage=round((data["lines"] / total_lines * 100) if total_lines > 0 else 0, 1),
+        )
+        for lang, data in stats.items()
+    ]
+    results.sort(key=lambda x: x.lines, reverse=True)
+
+    primary = results[0].name if results else None
+    return results, primary