codescope-cli 1.0.0__tar.gz

codescope_cli-1.0.0/PKG-INFO

@@ -0,0 +1,7 @@
+Metadata-Version: 2.4
+Name: codescope-cli
+Version: 1.0.0
+Summary: CLI tool to analyze, inspect and visualize codebases
+Author: Aditya Seswani
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown

codescope_cli-1.0.0/codebase_analyzer/analyzer/complexity.py

@@ -0,0 +1,42 @@
+import os
+
+
+def compute_complexity(files, folders):
+    """
+    Compute simple structural complexity metrics for the project.
+    """
+
+    line_counts = []
+    folder_counts = {}
+
+    for file in files:
+        try:
+            with open(file, encoding="utf-8") as f:
+                lines = len(f.readlines())
+                line_counts.append(lines)
+        except:
+            continue
+
+        # count files per directory
+        folder = os.path.dirname(file)
+        folder_counts[folder] = folder_counts.get(folder, 0) + 1
+
+    total_files = len(line_counts)
+
+    avg_lines = sum(line_counts) // total_files if total_files else 0
+    max_lines = max(line_counts) if line_counts else 0
+
+    # deepest nesting
+    max_depth = max(file.count(os.sep) for file in files) if files else 0
+
+    # largest directory
+    largest_dir = max(folder_counts.items(), key=lambda x: x[1])[0] if folder_counts else ""
+    largest_dir_count = max(folder_counts.values()) if folder_counts else 0
+
+    return {
+        "avg_lines_per_file": avg_lines,
+        "max_file_lines": max_lines,
+        "max_depth": max_depth,
+        "largest_directory": largest_dir,
+        "largest_directory_files": largest_dir_count,
+    }

codescope_cli-1.0.0/codebase_analyzer/analyzer/duplicates.py

@@ -0,0 +1,37 @@
+import hashlib
+
+
+def file_hash(path):
+    """
+    Compute hash of file contents (fast + reliable).
+    """
+    h = hashlib.md5()
+
+    try:
+        with open(path, "rb") as f:
+            while chunk := f.read(8192):
+                h.update(chunk)
+    except:
+        return None
+
+    return h.hexdigest()
+
+
+def find_duplicates(files):
+    """
+    Group files that have identical content.
+    Returns list of lists.
+    """
+
+    hashes = {}
+
+    for f in files:
+        h = file_hash(f)
+        if not h:
+            continue
+
+        hashes.setdefault(h, []).append(f)
+
+    duplicates = [group for group in hashes.values() if len(group) > 1]
+
+    return duplicates

codescope_cli-1.0.0/codebase_analyzer/analyzer/empty_finder.py

@@ -0,0 +1,30 @@
+from codebase_analyzer.constants import SMALL_FILE_LINE_LIMIT
+
+def find_empty_and_small_files(files, min_lines=SMALL_FILE_LINE_LIMIT):
+
+    """
+    Finds empty files and very small files.
+
+    Parameters:
+    - files: list of file paths
+    - min_lines: minimum number of lines to be considered non-small
+    """
+
+    empty_files = []
+    small_files = []
+
+    for file_path in files:
+        try:
+            with open(file_path, "r", encoding="utf-8", errors="ignore") as file:
+                lines = file.readlines()
+                line_count = len(lines)
+
+                if line_count == 0:
+                    empty_files.append(file_path)
+                elif line_count < min_lines:
+                    small_files.append((file_path, line_count))
+        except:
+            # Skip files that cannot be read
+            pass
+
+    return empty_files, small_files

codescope_cli-1.0.0/codebase_analyzer/analyzer/file_stats.py

@@ -0,0 +1,31 @@
+
+import os
+
+
+def get_file_and_folder_count(files, folders):
+    """
+    Returns total number of files and folders.
+    """
+    total_files = len(files)
+    total_folders = len(folders)
+    return total_files, total_folders
+
+
+def get_largest_files(files, top_n=5):
+    """
+    Returns top N largest files by size.
+    """
+    file_sizes = []
+
+    for file_path in files:
+        try:
+            size = os.path.getsize(file_path)
+            file_sizes.append((file_path, size))
+        except:
+            # Skip files that cannot be accessed
+            pass
+
+    # Sort files by size (largest first)
+    file_sizes.sort(key=lambda x: x[1], reverse=True)
+
+    return file_sizes[:top_n]

codescope_cli-1.0.0/codebase_analyzer/analyzer/language_detector.py

@@ -0,0 +1,39 @@
+import os
+
+
+EXTENSION_LANGUAGE_MAP = {
+    ".py": "Python",
+    ".js": "JavaScript",
+    ".java": "Java",
+    ".c": "C",
+    ".cpp": "C++",
+    ".html": "HTML",
+    ".css": "CSS",
+    ".md": "Markdown",
+    ".txt": "Text"
+}
+
+
+def detect_languages(files):
+    """
+    Detects programming languages based on file extensions.
+    Returns a dictionary with language counts.
+    """
+
+    language_count = {}
+
+    for file_path in files:
+        _, ext = os.path.splitext(file_path)
+        ext = ext.lower()
+
+        if ext in EXTENSION_LANGUAGE_MAP:
+            language = EXTENSION_LANGUAGE_MAP[ext]
+        else:
+            language = "Other"
+
+        if language in language_count:
+            language_count[language] += 1
+        else:
+            language_count[language] = 1
+
+    return language_count

codescope_cli-1.0.0/codebase_analyzer/analyzer/line_counter.py

@@ -0,0 +1,22 @@
+def count_lines(files):
+    """
+    Counts total, empty, and non-empty lines in the given files.
+    """
+
+    total_lines = 0
+    empty_lines = 0
+
+    for file_path in files:
+        try:
+            with open(file_path, "r", encoding="utf-8", errors="ignore") as file:
+                for line in file:
+                    total_lines += 1
+                    if line.strip() == "":
+                        empty_lines += 1
+        except:
+            # Skip files that cannot be read
+            pass
+
+    code_lines = total_lines - empty_lines
+
+    return total_lines, empty_lines, code_lines

codescope_cli-1.0.0/codebase_analyzer/analyzer/pretty_output.py

@@ -0,0 +1,47 @@
+def print_summary(data, verbose=False):
+    total_lang = sum(data["languages"].values())
+
+    top_langs = sorted(
+        data["languages"].items(),
+        key=lambda x: -x[1]
+    )[:3]
+
+    lang_str = " ".join(
+        f"{k}({int(v/total_lang*100)}%)"
+        for k, v in top_langs if total_lang
+    )
+
+    print("\n════════ Codebase Analyzer ════════\n")
+
+    print(
+        f"Files: {data['total_files']} | "
+        f"Folders: {data['total_folders']} | "
+        f"Lines: {data['total_lines']}"
+    )
+
+    print(f"Languages: {lang_str}")
+
+    complexity = data.get("complexity", {})
+    if complexity:
+        print(
+            f"Complexity: Avg {complexity['avg_lines_per_file']} lines/file | "
+            f"Depth {complexity['max_depth']}"
+        )
+
+    duplicates = data.get("duplicates", [])
+    print(f"Duplicates: {len(duplicates)} group(s)")
+
+    dead = data.get("dead_files", [])
+    print(f"Dead files: {len(dead)}")
+
+    # 🔥 detailed only if verbose
+    if verbose:
+        print("\n--- Duplicate Details ---")
+        for group in duplicates:
+            for f in group:
+                print(" ", f)
+            print()
+
+        print("\n--- Dead Files ---")
+        for f in dead:
+            print(" ", f)

codescope_cli-1.0.0/codebase_analyzer/analyzer/scanner.py

@@ -0,0 +1,34 @@
+
+import os
+
+EXCLUDED_FOLDERS = [
+    ".git",
+    "__pycache__",
+    "venv",
+    "env",
+    "node_modules"
+]
+
+
+def scan_project(project_path):
+    """
+    Scans a project folder and returns:
+    - list of file paths
+    - list of directory paths
+    """
+
+    files = []
+    directories = []
+
+    for root, dirs, filenames in os.walk(project_path):
+
+        # remove excluded folders so os.walk doesn't go inside them
+        dirs[:] = [d for d in dirs if d not in EXCLUDED_FOLDERS]
+
+        for d in dirs:
+            directories.append(os.path.join(root, d))
+
+        for file in filenames:
+            files.append(os.path.join(root, file))
+
+    return files, directories

codescope_cli-1.0.0/codebase_analyzer/cli/args.py

@@ -0,0 +1,38 @@
+import argparse
+
+
+def get_cli_args():
+    parser = argparse.ArgumentParser(
+        description="Codebase Analyzer Tool"
+    )
+
+    parser.add_argument(
+        "path",
+        help="Path of the project to analyze"
+    )
+
+    parser.add_argument(
+        "--report",
+        help="Generate analysis report to a text file",
+        default=None
+    )
+    parser.add_argument(
+    "--html",
+    type=str,
+    help="Generate HTML report at specified path"
+    )
+    parser.add_argument(
+    "--graph",
+    type=str,
+    help="Generate dependency graph (.dot file)"
+    )   
+    parser.add_argument(
+    "--verbose",
+    action="store_true",
+    help="Show detailed output"
+    )
+
+
+
+
+    return parser.parse_args()

codescope_cli-1.0.0/codebase_analyzer/cli/commands.py

@@ -0,0 +1,53 @@
+from codebase_analyzer.analyzer.scanner import scan_project
+from codebase_analyzer.analyzer.file_stats import get_file_and_folder_count, get_largest_files
+from codebase_analyzer.analyzer.line_counter import count_lines
+from codebase_analyzer.analyzer.language_detector import detect_languages
+from codebase_analyzer.analyzer.empty_finder import find_empty_and_small_files
+from codebase_analyzer.reports.reports import write_report
+from codebase_analyzer.analyzer.pretty_output import print_summary
+from codebase_analyzer.analyzer.complexity import compute_complexity
+from codebase_analyzer.analyzer.duplicates import find_duplicates
+def run_analysis(project_path, report_path=None, html_path=None,graph_path=None,verbose=False):
+    files, folders = scan_project(project_path)
+    total_files, total_folders = get_file_and_folder_count(files, folders)
+    total_lines, empty_lines, code_lines = count_lines(files)
+    languages = detect_languages(files)
+    empty_files, small_files = find_empty_and_small_files(files)
+    largest_files = get_largest_files(files)
+    complexity = compute_complexity(files, folders)
+    duplicates = find_duplicates(files)
+    data = {
+        "total_files": total_files,
+        "total_folders": total_folders,
+        "total_lines": total_lines,
+        "empty_lines": empty_lines,
+        "code_lines": code_lines,
+        "languages": languages,
+        "largest_files": largest_files,
+        "empty_files": empty_files,
+        "small_files": small_files,
+        "duplicates": duplicates,
+        "complexity": complexity,
+        "duplicates": duplicates
+    }
+    print_summary(data,verbose)
+    data["complexity"] = compute_complexity(files, folders)
+
+
+
+    if report_path:
+        write_report(report_path, data)
+        print("\nText report generated at:", report_path)
+
+    from codebase_analyzer.reports.html_report import write_html_report
+
+    html_path = html_path or "analysis_report.html"
+    write_html_report(html_path, data)
+    print("\nHTML report generated at:", html_path)
+
+    from codebase_analyzer.reports.dependency_graph import write_dependency_graph
+
+    graph_path = graph_path or "dependency_graph.png"
+    write_dependency_graph(graph_path, files)
+    print("\nDependency graph generated at:", graph_path)
+

codescope_cli-1.0.0/codebase_analyzer/constants.py

@@ -0,0 +1,14 @@
+# Folders to skip while scanning
+EXCLUDED_FOLDERS = [
+    ".git",
+    "__pycache__",
+    "venv",
+    "env",
+    "node_modules"
+]
+
+# Small file threshold
+SMALL_FILE_LINE_LIMIT = 5
+
+# Largest files to display
+TOP_LARGEST_FILES = 5

codescope_cli-1.0.0/codebase_analyzer/main.py

@@ -0,0 +1,10 @@
+from codebase_analyzer.cli.args import get_cli_args
+from codebase_analyzer.cli.commands import run_analysis
+
+def main():
+    args = get_cli_args()
+    run_analysis(args.path, args.report,args.html,args.graph,args.verbose)
+
+
+if __name__ == "__main__":
+    main()

codescope_cli-1.0.0/codebase_analyzer/reports/dependency_graph.py

@@ -0,0 +1,57 @@
+import os
+import ast
+import subprocess
+def extract_imports(file_path):
+    """Extract imported modules from a Python file using AST."""
+    imports = set()
+    try:
+        with open(file_path, "r", encoding="utf-8") as f:
+            tree = ast.parse(f.read())
+        for node in ast.walk(tree):
+            if isinstance(node, ast.Import):
+                for alias in node.names:
+                    imports.add(alias.name.split(".")[0])
+            elif isinstance(node, ast.ImportFrom):
+                if node.module:
+                    imports.add(node.module.split(".")[0])
+    except Exception:
+        pass  
+    return imports
+def write_dependency_graph(output_path, files):
+    dot_path = output_path.replace(".png", ".dot")
+    py_files = [f for f in files if f.endswith(".py")]
+    edges = []
+    for file in py_files:
+        module_name = os.path.splitext(os.path.basename(file))[0]
+        imports = extract_imports(file)
+        for imp in imports:
+            edges.append((module_name, imp))
+    with open(dot_path, "w", encoding="utf-8") as f:
+        f.write("digraph CodebaseDependencies {\n")
+        f.write("rankdir=LR;\n")
+        f.write('node [shape=box, style="filled,rounded", fontname="Arial"];\n\n')
+
+        project_modules = {
+            os.path.splitext(os.path.basename(f))[0]
+            for f in py_files
+        }
+
+        external_modules = set(dst for _, dst in edges if dst not in project_modules)
+
+        # ✅ FIRST: define project nodes (blue)
+        for module in project_modules:
+            f.write(f'"{module}" [fillcolor="#4F81BD", fontcolor="white"];\n')
+
+        # ✅ SECOND: define external nodes (gray)
+        for module in external_modules:
+            f.write(f'"{module}" [fillcolor="#D3D3D3", fontcolor="black"];\n')
+
+        f.write("\n")
+
+        # ✅ LAST: draw edges
+        for src, dst in edges:
+            f.write(f'"{src}" -> "{dst}";\n')
+
+        f.write("}\n")
+
+    subprocess.run(["dot", "-Tpng", dot_path, "-o", output_path], check=False)

codescope_cli-1.0.0/codebase_analyzer/reports/html_report.py

@@ -0,0 +1,169 @@
+import json
+import webbrowser
+import os
+def write_html_report(path, data):
+    languages = data["languages"]
+    labels = list(languages.keys())
+    values = list(languages.values())
+    complexity = data.get("complexity", {})
+    duplicates = data.get("duplicates", [])
+    dead_files = data.get("dead_files", [])
+    largest_files = data.get("largest_files", [])
+    html_content = f"""
+<!DOCTYPE html>
+<html>
+<head>
+    <title>Codebase Analysis Report</title>
+    <script src="https://cdn.jsdelivr.net/npm/chart.js"></script>
+    <style>
+    body {{
+        font-family: Arial, sans-serif;
+        margin: 30px;
+        background: #0f172a;
+        color: #e2e8f0;
+    }}
+    h1 {{
+        text-align: center;
+        color: #38bdf8;
+    }}
+    h2 {{
+        margin-bottom: 10px;
+        color: #60a5fa;
+    }}
+    .grid {{
+        display: grid;
+        grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
+        gap: 15px;
+        margin-bottom: 25px;
+    }}
+    .card {{
+        background: #1e293b;
+        padding: 20px;
+        border-radius: 12px;
+        box-shadow: 0 4px 12px rgba(0,0,0,0.4);
+        transition: transform 0.2s ease;
+    }}
+    .card:hover {{
+        transform: translateY(-4px);
+    }}
+    table {{
+        width: 100%;
+        border-collapse: collapse;
+        margin-top: 10px;
+    }}
+    th {{
+        text-align: left;
+        padding: 10px;
+        font-size: 14px;
+        color: #93c5fd;
+        border-bottom: 1px solid #334155;
+    }}
+    td {{
+        padding: 8px;
+        border-bottom: 1px solid #334155;
+        font-size: 13px;
+        color: #cbd5e1;
+    }}
+    tr:hover {{
+        background: #273449;
+    }}
+    ul {{
+        padding-left: 20px;
+    }}
+    li {{
+        margin-bottom: 6px;
+    }}
+    .chart-container {{
+        width: 420px;
+        height: 420px;
+        margin: auto;
+    }}
+</style>
+</head>
+<body>
+<h1>Codebase Analysis Dashboard</h1>
+<!-- SUMMARY CARDS -->
+<div class="grid">
+    <div class="card"><b>Files</b><br>{data['total_files']}</div>
+    <div class="card"><b>Folders</b><br>{data['total_folders']}</div>
+    <div class="card"><b>Total Lines</b><br>{data['total_lines']}</div>
+    <div class="card"><b>Code Lines</b><br>{data['code_lines']}</div>
+</div>
+<!-- LANGUAGE CHART -->
+<div class="card">
+    <h2>Language Distribution</h2>
+    <div class="chart-container">
+        <canvas id="langChart"></canvas>
+    </div>
+</div>
+<!-- COMPLEXITY -->
+<div class="card">
+<h2>Complexity Metrics</h2>
+<ul>
+<li>Average lines per file: {complexity.get('avg_lines_per_file',0)}</li>
+<li>Largest file: {complexity.get('max_file_lines',0)} lines</li>
+<li>Max depth: {complexity.get('max_depth',0)}</li>
+<li>Largest directory files: {complexity.get('largest_directory_files',0)}</li>
+</ul>
+</div>
+<!-- LARGEST FILES -->
+<div class="card">
+<h2>Largest Files</h2>
+<table>
+<tr><th>File</th><th>Size</th></tr>
+{''.join(f"<tr><td>{f}</td><td>{s}</td></tr>" for f,s in largest_files)}
+</table>
+</div>
+<!-- DUPLICATES -->
+<div class="card">
+<h2>Duplicate Files ({len(duplicates)} groups)</h2>
+<table>
+<tr><th>Group</th><th>Files</th></tr>
+{''.join(f"<tr><td>{i+1}</td><td>{'<br>'.join(g)}</td></tr>" for i,g in enumerate(duplicates))}
+</table>
+</div>
+<!-- DEAD FILES -->
+<div class="card">
+<h2>Dead Files ({len(dead_files)})</h2>
+<table>
+{''.join(f"<tr><td>{f}</td></tr>" for f in dead_files)}
+</table>
+</div>
+<script>
+const ctx = document.getElementById('langChart');
+new Chart(ctx, {{
+    type: 'pie',
+    data: {{
+        labels: {json.dumps(labels)},
+        datasets: [{{
+            data: {json.dumps(values)},
+            backgroundColor: [
+                "#38bdf8",
+                "#6366f1",
+                "#f59e0b",
+                "#ef4444",
+                "#10b981",
+                "#a855f7",
+                "#f472b6"
+            ],
+            borderColor: "#0f172a"
+        }}]
+    }},
+    options: {{
+        maintainAspectRatio: false,
+        plugins: {{
+            legend: {{
+                labels: {{
+                    color: "#e2e8f0"
+                }}
+            }}
+        }}
+    }}
+}});
+</script>
+</body>
+</html>
+"""
+    with open(path, "w", encoding="utf-8") as f:
+        f.write(html_content)
+    webbrowser.open("file://" + os.path.abspath(path))

codescope_cli-1.0.0/codebase_analyzer/reports/reports.py

@@ -0,0 +1,28 @@
+def write_report(report_path, data):
+    with open(report_path, "w", encoding="utf-8") as file:
+        file.write("CODEBASE ANALYSIS REPORT\n")
+        file.write("=" * 30 + "\n\n")
+
+        file.write(f"Total files: {data['total_files']}\n")
+        file.write(f"Total folders: {data['total_folders']}\n\n")
+
+        file.write("Line Statistics:\n")
+        file.write(f"  Total lines: {data['total_lines']}\n")
+        file.write(f"  Empty lines: {data['empty_lines']}\n")
+        file.write(f"  Code lines: {data['code_lines']}\n\n")
+
+        file.write("Languages Used:\n")
+        for lang, count in data["languages"].items():
+            file.write(f"  {lang}: {count}\n")
+
+        file.write("\nLargest Files:\n")
+        for path, size in data["largest_files"]:
+            file.write(f"  {path} - {size} bytes\n")
+
+        file.write("\nEmpty Files:\n")
+        for path in data["empty_files"]:
+            file.write(f"  {path}\n")
+
+        file.write("\nSmall Files:\n")
+        for path, lines in data["small_files"]:
+            file.write(f"  {path} ({lines} lines)\n")

codescope_cli-1.0.0/codescope_cli.egg-info/PKG-INFO

@@ -0,0 +1,7 @@
+Metadata-Version: 2.4
+Name: codescope-cli
+Version: 1.0.0
+Summary: CLI tool to analyze, inspect and visualize codebases
+Author: Aditya Seswani
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown

codescope_cli-1.0.0/codescope_cli.egg-info/SOURCES.txt

@@ -0,0 +1,25 @@
+pyproject.toml
+codebase_analyzer/constants.py
+codebase_analyzer/main.py
+codebase_analyzer/utils.py
+codebase_analyzer/analyzer/__init__.py
+codebase_analyzer/analyzer/complexity.py
+codebase_analyzer/analyzer/duplicates.py
+codebase_analyzer/analyzer/empty_finder.py
+codebase_analyzer/analyzer/file_stats.py
+codebase_analyzer/analyzer/language_detector.py
+codebase_analyzer/analyzer/line_counter.py
+codebase_analyzer/analyzer/pretty_output.py
+codebase_analyzer/analyzer/scanner.py
+codebase_analyzer/cli/__init__.py
+codebase_analyzer/cli/args.py
+codebase_analyzer/cli/commands.py
+codebase_analyzer/reports/__init__.py
+codebase_analyzer/reports/dependency_graph.py
+codebase_analyzer/reports/html_report.py
+codebase_analyzer/reports/reports.py
+codescope_cli.egg-info/PKG-INFO
+codescope_cli.egg-info/SOURCES.txt
+codescope_cli.egg-info/dependency_links.txt
+codescope_cli.egg-info/entry_points.txt
+codescope_cli.egg-info/top_level.txt

codescope_cli-1.0.0/codescope_cli.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

codescope_cli-1.0.0/codescope_cli.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+codescope = codebase_analyzer.main:main

codescope_cli-1.0.0/codescope_cli.egg-info/top_level.txt

@@ -0,0 +1,2 @@
+codebase_analyzer
+dist

codescope_cli-1.0.0/pyproject.toml

@@ -0,0 +1,19 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "codescope-cli"
+version = "1.0.0"
+description = "CLI tool to analyze, inspect and visualize codebases"
+readme = "README.md"
+requires-python = ">=3.8"
+authors = [
+    { name = "Aditya Seswani" }
+]
+
+[project.scripts]
+codescope = "codebase_analyzer.main:main"
+
+[tool.setuptools.packages.find]
+where = ["."]

codescope_cli-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+