codedd-cli 0.1.0__py3-none-any.whl

codedd_cli/models/audit.py

@@ -0,0 +1,32 @@
+"""Data models for audit entities returned by the CLI API."""
+
+from dataclasses import dataclass, field
+from typing import Optional
+
+
+@dataclass(frozen=True)
+class Audit:
+    """A single-repository audit."""
+
+    audit_uuid: str
+    audit_name: str
+    audit_status: str
+    audit_type: str = "single"
+    ai_synthesis: Optional[str] = None
+    repo_url: str = ""
+    number_files: int = 0
+    lines_of_code: int = 0
+
+
+@dataclass(frozen=True)
+class GroupAudit:
+    """A group audit (portfolio / multi-repo)."""
+
+    audit_uuid: str
+    audit_name: str
+    audit_status: str
+    audit_type: str = "group"
+    ai_synthesis: Optional[str] = None
+    number_of_sub_audits: int = 0
+    number_files: int = 0
+    lines_of_code: int = 0

codedd_cli/models/local_directory.py

@@ -0,0 +1,26 @@
+"""Data model for a validated local directory added to an audit scope."""
+
+from dataclasses import dataclass
+from typing import Optional
+
+
+@dataclass
+class LocalDirectory:
+    """
+    Represents a validated local Git repository directory.
+
+    Attributes:
+        path:        Absolute path to the directory.
+        repo_name:   Short name derived from the directory basename.
+        branch:      Currently checked-out branch (or HEAD ref).
+        commit_hash: Short hash of the current HEAD commit.
+        is_valid:    Whether all validation checks passed.
+        error:       Validation error message (empty when valid).
+    """
+
+    path: str
+    repo_name: str = ""
+    branch: str = ""
+    commit_hash: str = ""
+    is_valid: bool = False
+    error: str = ""

codedd_cli/scanner/__init__.py

@@ -0,0 +1,18 @@
+"""
+Local repository scanner — walks directories, classifies files, and counts LoC.
+
+This package runs **entirely on the user's machine**.  No source code or file
+contents are ever sent to CodeDD; only the resulting metadata (file paths,
+types, and line counts) is transmitted via the API.
+"""
+
+from codedd_cli.scanner.file_classifier import get_file_type, should_exclude_file
+from codedd_cli.scanner.line_counter import count_lines
+from codedd_cli.scanner.file_walker import scan_repository
+
+__all__ = [
+    "get_file_type",
+    "should_exclude_file",
+    "count_lines",
+    "scan_repository",
+]

codedd_cli/scanner/file_classifier.py

@@ -0,0 +1,247 @@
+"""
+File type classification for the local scanner.
+
+Mirrors the server-side ``file_extensions.py`` logic so that the metadata
+produced locally matches exactly what the CodeDD platform expects.
+
+Categories:
+    Source Code, Configuration, Documentation, Data File,
+    Binary, Media, Archive, System, Security, Other
+"""
+
+import os
+
+# ---------------------------------------------------------------------------
+# Extension sets — kept in sync with the server-side definitions
+# ---------------------------------------------------------------------------
+
+CONFIGURATION_FILES = {
+    '.yaml', '.yml', '.ini', '__init__.py', '.env', '.conf', '.config', '.cfg',
+    '.properties', '.prefs', '.props', '.toml', '.cnf', '.json',
+    '.dist', '.opt', '.plist', '.reg', '.settings', '.editorconfig',
+    '.htaccess', '.htpasswd', '.npmrc', '.nvmrc', '.bowerrc',
+    '.eslintrc', '.prettierrc', '.stylelintrc', '.babelrc',
+    '.eslintignore', '.prettierignore', '.dockerignore', '.gitignore',
+    '.env.local', '.env.development', '.env.production', '.env.test',
+    'Dockerfile', 'docker-compose.yml', 'Makefile', 'CMakeLists.txt',
+    'webpack.config.js', 'rollup.config.js', 'vite.config.js', 'snowpack.config.js',
+    'tsconfig.json', 'package.json', 'composer.json', 'project.json',
+    'angular.json', 'nx.json', 'lerna.json', 'rush.json',
+    '.travis.yml', '.gitlab-ci.yml', '.github/workflows', 'Jenkinsfile',
+    'azure-pipelines.yml', '.circleci/config.yml', 'bitbucket-pipelines.yml',
+    'buildkite.yml', 'appveyor.yml', 'cloudbuild.yaml', 'codeship-services.yml',
+    'setup.cfg', 'pyproject.toml', 'requirements.txt', 'Pipfile',
+    'tox.ini', 'pytest.ini', '.coveragerc', '.flake8', 'poetry.lock',
+    'conda.yaml', 'environment.yml', 'setup.py', 'MANIFEST.in',
+    'docker-compose.override.yml', 'docker-compose.prod.yml', 'docker-compose.dev.yml',
+    'kubernetes.yaml', 'helm.yaml', 'values.yaml', 'Chart.yaml', 'kustomization.yaml',
+    'terraform.tfvars', 'terragrunt.hcl', 'serverless.yml', 'cloudformation.yaml',
+    'pulumi.yaml', 'ansible.cfg', 'inventory.yml', 'playbook.yml',
+    '.browserslistrc', '.postcssrc', '.cssnanorc', '.stylelintignore',
+    'tailwind.config.js', 'next.config.js', 'nuxt.config.js', 'svelte.config.js',
+    'remix.config.js', 'astro.config.mjs', '.parcelrc', 'gatsby-config.js',
+    'gunicorn.conf.py', 'uwsgi.ini', 'nginx.conf', 'apache2.conf',
+    'php.ini', 'my.cnf', 'postgresql.conf', 'redis.conf', 'supervisord.conf',
+    'pm2.config.js', 'nodemon.json', 'nest-cli.json', 'vercel.json',
+    '.nycrc', '.mocharc', '.jestrc', 'karma.conf.js', 'cypress.json',
+    'playwright.config.js', 'sonar-project.properties', '.yamllint',
+    'vitest.config.js', 'ava.config.js', 'wallaby.js', 'jasmine.json',
+    '.vscode/settings.json', '.vscode/launch.json', '.idea/workspace.xml',
+    '.eclipse/org.eclipse.jdt.core.prefs', '.netbeans/project.properties',
+}
+
+SOURCE_CODE_FILES = {
+    '.js', '.jsx', '.ts', '.tsx', '.vue', '.svelte', '.php', '.html', '.htm',
+    '.css', '.scss', '.sass', '.less', '.styl', '.wasm', '.mjs', '.cjs',
+    '.astro', '.mdx', '.razor', '.cshtml', '.jsp', '.asp', '.aspx',
+    '.php4', '.php5', '.phtml', '.ctp', '.module', '.inc.php',
+    '.d.ts', '.js.map', '.mts', '.cts', '.jsx.map', '.tsx.map',
+    '.es6', '.es', '.iife.js', '.umd.js', '.amd.js', '.esm.js',
+    '.py', '.java', '.cpp', '.cc', '.cxx', '.hpp', '.c', '.h', '.cs', '.fs',
+    '.go', '.rs', '.rb', '.rake', '.swift', '.kt', '.kts', '.scala', '.sc',
+    '.clj', '.cljs', '.cljc', '.erl', '.ex', '.exs', '.hs', '.lhs', '.lua',
+    '.pl', '.pm', '.t', '.r', '.rmd', '.jl', '.dart', '.groovy', '.tcl',
+    '.nim', '.cr', '.ml', '.re', '.res', '.elm', '.zig', '.v', '.gleam',
+    '.hx', '.ceylon', '.idr', '.purs', '.dhall', '.bal', '.rkt', '.io',
+    '.sh', '.bash', '.zsh', '.fish', '.bat', '.cmd', '.ps1', '.psm1',
+    '.vbs', '.vba', '.awk', '.sed', '.ksh', '.csh', '.tcsh', '.nu',
+    '.erb', '.haml', '.slim', '.pug', '.jade', '.jinja', '.jinja2',
+    '.mustache', '.handlebars', '.hbs', '.twig', '.liquid', '.njk',
+    '.blade.php', '.volt', '.latte', '.smarty', '.plates', '.tpl',
+    '.sql', '.hql', '.cypher', '.graphql', '.gql', '.proto', '.thrift',
+    '.cmake', '.gradle', '.m4', '.am', '.in', '.ac', '.f90', '.f95', '.f03',
+    '.m', '.mm', '.xib', '.storyboard',
+    '.gd', '.unity', '.unityproj', '.prefab', '.mat', '.shader',
+    '.hlsl', '.cg', '.fx', '.fxh', '.usf', '.ush',
+    '.ipynb', '.sage', '.sce', '.sci', '.stan', '.do',
+    '.sps', '.sas', '.mlx', '.mplstyle',
+    '.py3', '.pyx', '.pxd', '.pxi', '.rpy', '.rpym', '.rviz',
+    '.asm', '.s', '.nasm', '.gas', '.lst', '.mac',
+    '.vh', '.vhd', '.vhdl', '.sv', '.svh', '.svi',
+    '.mli', '.fsi', '.fsx', '.fsscript',
+    '.scm', '.ss', '.rktl', '.odin', '.d', '.di',
+    '.mod.c', '.dts', '.dtsi',
+    '.prisma', '.sdl', '.openapi', '.swagger', '.raml', '.wsdl',
+    '.wsf',
+}
+
+DOCUMENTATION_FILES = {
+    '.md', '.markdown', '.txt', '.rtf', '.rst', '.asciidoc', '.adoc',
+    '.tex', '.latex', '.wiki', '.org', '.pod', '.rdoc', '.textile',
+    '.creole', '.mediawiki', '.dokuwiki', '.asc', '.man', '.mdwn',
+    '.doc', '.docx', '.odt', '.pages', '.wpd', '.wps',
+    '.pdf', '.xps', '.oxps', '.epub', '.mobi',
+    '.ppt', '.pptx', '.key', '.odp', '.pps', '.ppsx',
+    '.xls', '.xlsx', '.numbers', '.ods', '.csv', '.tsv',
+    '.drawio', '.vsdx', '.vsd', '.dgml', '.dgm',
+    'CHANGELOG', 'CONTRIBUTING', 'AUTHORS', 'MAINTAINERS',
+    'SECURITY', 'SUPPORT', 'THANKS', 'UPGRADING', 'VERSION',
+}
+
+DATA_FILES = {
+    '.json', '.xml', '.yaml', '.yml', '.csv', '.tsv', '.xlsx', '.xls',
+    '.parquet', '.orc', '.avro', '.arrow', '.feather', '.jsonl', '.ndjson',
+    '.db', '.sqlite', '.sqlite3', '.mdb', '.accdb', '.dbf', '.fdb',
+    '.rdb', '.pdb', '.odb', '.mdf', '.ldf', '.frm', '.ibd',
+    '.hdf', '.h5', '.fits', '.nc', '.cdf', '.grib',
+    '.shp', '.shx', '.kml', '.kmz', '.gpx', '.osm', '.geojson',
+    '.pb', '.pbtxt', '.ckpt', '.tflite', '.onnx',
+    '.pt', '.pth', '.safetensors', '.npy', '.npz',
+}
+
+BINARY_FILES = {
+    '.exe', '.msi', '.app', '.dmg', '.pkg', '.deb', '.rpm',
+    '.apk', '.ipa', '.dll', '.so', '.dylib', '.a', '.lib',
+    '.jar', '.war', '.ear', '.aar', '.gem',
+    '.whl', '.egg', '.pyd', '.pyo', '.pyc',
+    '.obj', '.o', '.ko', '.class', '.dex',
+    '.ilk', '.exp', '.pch',
+}
+
+MEDIA_FILES = {
+    '.jpg', '.jpeg', '.png', '.gif', '.bmp', '.tiff', '.tif',
+    '.webp', '.heic', '.heif', '.raw', '.psd', '.ico', '.icns', '.avif',
+    '.svg', '.eps', '.ai',
+    '.mp3', '.wav', '.flac', '.m4a', '.aac', '.ogg', '.wma', '.opus',
+    '.mp4', '.mkv', '.avi', '.mov', '.wmv', '.flv', '.webm', '.m4v',
+    '.fbx', '.3ds', '.blend', '.stl', '.dae', '.dwg', '.dxf',
+    '.glb', '.gltf', '.usdz',
+}
+
+ARCHIVE_FILES = {
+    '.zip', '.rar', '.7z', '.tar', '.gz', '.bz2', '.xz',
+    '.tgz', '.tbz2', '.txz', '.cab', '.iso',
+    '.bak', '.backup', '.bkp',
+}
+
+SYSTEM_FILES = {
+    '.tmp', '.temp', '.swp', '.swo', '.swn',
+    '.cache', '.part', '.crdownload',
+    '.log', '.logs', '.out', '.err',
+    '.dump', '.dmp', '.crash', '.core',
+    '.lnk', '.url', '.pid', '.lock', '.sock',
+}
+
+SECURITY_FILES = {
+    '.key', '.pem', '.crt', '.cer', '.der', '.p12', '.pfx',
+    '.p7b', '.p7c', '.keystore', '.jks', '.truststore',
+    '.csr', '.pub', '.gpg', '.asc',
+    '.htpasswd', '.netrc', '.pgpass',
+    '.secrets', '.credentials', '.kdbx', '.vault',
+}
+
+# Directories always excluded from scanning
+EXCLUDED_DIRECTORIES = {
+    '.git', '__pycache__', 'node_modules', '.venv', 'venv', 'env',
+    '.tox', '.mypy_cache', '.pytest_cache', '.ruff_cache',
+    '.next', '.nuxt', 'dist', 'build', '.build',
+    'target', 'out', 'bin', '.gradle', '.mvn',
+    '.idea', '.vscode', '.vs',
+    'vendor', 'bower_components',
+    '.terraform', '.serverless',
+    'coverage', '.nyc_output', 'htmlcov',
+    '.eggs', '*.egg-info',
+}
+
+
+def get_file_extension(file_path: str) -> str:
+    """Extract the file extension from a path (lowercase)."""
+    return os.path.splitext(file_path)[1].lower()
+
+
+def get_file_type(file_path: str) -> str:
+    """
+    Determine the type of file based on its extension or filename.
+
+    Returns one of: 'Source Code', 'Configuration', 'Documentation',
+    'Data File', 'Binary', 'Media', 'Archive', 'System', 'Security', 'Other'.
+    """
+    filename = os.path.basename(file_path)
+
+    # Check complete filename first (e.g. "Dockerfile", "Makefile")
+    if filename in CONFIGURATION_FILES:
+        return 'Configuration'
+    if filename in DOCUMENTATION_FILES:
+        return 'Documentation'
+
+    # Try the last extension (handles compound like .d.ts)
+    parts = filename.split('.')
+    if len(parts) > 1:
+        last_ext = f'.{parts[-1]}'
+        for ext_set, label in _EXTENSION_ORDER:
+            if last_ext in ext_set:
+                return label
+
+    # Fall back to os.path.splitext
+    extension = get_file_extension(file_path)
+    for ext_set, label in _EXTENSION_ORDER:
+        if extension in ext_set:
+            return label
+
+    return 'Other'
+
+
+# Lookup order (source code first to match server behaviour)
+_EXTENSION_ORDER = [
+    (SOURCE_CODE_FILES, 'Source Code'),
+    (CONFIGURATION_FILES, 'Configuration'),
+    (DOCUMENTATION_FILES, 'Documentation'),
+    (DATA_FILES, 'Data File'),
+    (BINARY_FILES, 'Binary'),
+    (MEDIA_FILES, 'Media'),
+    (ARCHIVE_FILES, 'Archive'),
+    (SYSTEM_FILES, 'System'),
+    (SECURITY_FILES, 'Security'),
+]
+
+
+def should_exclude_file(file_path: str) -> bool:
+    """
+    Return True if a file should be excluded from LoC counting.
+
+    Excluded: files inside .git directories, configuration files, and
+    non-source categories (docs, data, binary, media, archives, system, security).
+    """
+    # Anything inside a .git directory
+    parts = file_path.replace('\\', '/').split('/')
+    if '.git' in parts:
+        return True
+
+    filename = os.path.basename(file_path)
+    if filename in CONFIGURATION_FILES:
+        return True
+
+    extension = get_file_extension(file_path)
+    return extension in _EXCLUDED_EXTENSIONS
+
+
+def should_exclude_directory(dir_name: str) -> bool:
+    """Return True if a directory should be skipped entirely during scanning."""
+    return dir_name in EXCLUDED_DIRECTORIES
+
+
+# Pre-computed set of extensions excluded from LoC counting
+_EXCLUDED_EXTENSIONS = (
+    DOCUMENTATION_FILES | DATA_FILES | BINARY_FILES |
+    MEDIA_FILES | ARCHIVE_FILES | SYSTEM_FILES | SECURITY_FILES
+)

codedd_cli/scanner/file_walker.py

@@ -0,0 +1,207 @@
+"""
+Local repository scanner.
+
+Walks a Git repository directory, classifies each file, counts lines of code,
+and produces a structured metadata payload ready for submission to the CodeDD API.
+
+**No file contents are included** — only paths, types, and line counts.
+"""
+
+import logging
+import os
+import subprocess
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Dict, List, Optional, Tuple
+
+from codedd_cli.scanner.file_classifier import (
+    get_file_type,
+    should_exclude_directory,
+    should_exclude_file,
+)
+from codedd_cli.scanner.line_counter import count_lines
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class FileMetadata:
+    """Metadata for a single scanned file (no content)."""
+    relative_path: str
+    file_type: str
+    lines_of_code: int
+    lines_of_doc: int
+    selected_for_audit: bool = True
+
+
+@dataclass
+class FolderMetadata:
+    """Aggregated metadata for a folder."""
+    relative_path: str
+    lines_of_code: int = 0
+    file_count: int = 0
+
+
+@dataclass
+class ScanResult:
+    """Complete scan result for a single repository directory."""
+    root_path: str
+    repo_name: str
+    branch: str
+    commit_hash: str
+    files: List[FileMetadata] = field(default_factory=list)
+    folders: List[FolderMetadata] = field(default_factory=list)
+    total_files: int = 0
+    total_lines_of_code: int = 0
+    total_lines_of_doc: int = 0
+    errors: List[str] = field(default_factory=list)
+
+    def to_dict(self) -> dict:
+        """Serialise to a plain dict suitable for JSON encoding."""
+        return {
+            "root_path": self.root_path,
+            "repo_name": self.repo_name,
+            "branch": self.branch,
+            "commit_hash": self.commit_hash,
+            "total_files": self.total_files,
+            "total_lines_of_code": self.total_lines_of_code,
+            "total_lines_of_doc": self.total_lines_of_doc,
+            "files": [
+                {
+                    "relative_path": f.relative_path,
+                    "file_type": f.file_type,
+                    "lines_of_code": f.lines_of_code,
+                    "lines_of_doc": f.lines_of_doc,
+                    "selected_for_audit": f.selected_for_audit,
+                }
+                for f in self.files
+            ],
+            "folders": [
+                {
+                    "relative_path": fd.relative_path,
+                    "lines_of_code": fd.lines_of_code,
+                    "file_count": fd.file_count,
+                }
+                for fd in self.folders
+            ],
+            "errors": self.errors,
+        }
+
+
+def _git_info(repo_path: str) -> Tuple[str, str]:
+    """Return (branch, short_commit_hash) for a repo, or empty strings on error."""
+    try:
+        branch = subprocess.run(
+            ["git", "rev-parse", "--abbrev-ref", "HEAD"],
+            cwd=repo_path, capture_output=True, text=True, timeout=10,
+        ).stdout.strip()
+
+        commit = subprocess.run(
+            ["git", "rev-parse", "--short", "HEAD"],
+            cwd=repo_path, capture_output=True, text=True, timeout=10,
+        ).stdout.strip()
+
+        return branch, commit
+    except Exception:
+        return "", ""
+
+
+def scan_repository(
+    root_path: str,
+    progress_callback: Optional[callable] = None,
+) -> ScanResult:
+    """
+    Walk *root_path*, classify every file, and count lines of code.
+
+    Args:
+        root_path:         Absolute path to the repository root.
+        progress_callback: Optional callable(current, total, file_path) invoked
+                           for each file processed.  Useful for Rich progress bars.
+
+    Returns:
+        A ``ScanResult`` containing all file and folder metadata.
+    """
+    root = Path(root_path).resolve()
+    repo_name = root.name
+    branch, commit = _git_info(str(root))
+
+    result = ScanResult(
+        root_path=str(root),
+        repo_name=repo_name,
+        branch=branch,
+        commit_hash=commit,
+    )
+
+    # Phase 1: collect all eligible file paths
+    file_paths: List[str] = []
+    for dirpath, dirnames, filenames in os.walk(str(root)):
+        # Filter out excluded directories in-place so os.walk skips them
+        dirnames[:] = [
+            d for d in dirnames
+            if not should_exclude_directory(d)
+        ]
+        for fname in filenames:
+            full_path = os.path.join(dirpath, fname)
+            # Skip symlinks
+            if os.path.islink(full_path):
+                continue
+            file_paths.append(full_path)
+
+    total_files = len(file_paths)
+    folder_aggregates: Dict[str, FolderMetadata] = {}
+
+    # Phase 2: classify and count
+    for idx, full_path in enumerate(file_paths):
+        try:
+            rel_path = os.path.relpath(full_path, start=str(root)).replace("\\", "/")
+            file_type = get_file_type(full_path)
+
+            # Count LoC (returns (0, 0) for excluded files)
+            loc, doc = count_lines(full_path)
+
+            fm = FileMetadata(
+                relative_path=rel_path,
+                file_type=file_type,
+                lines_of_code=loc,
+                lines_of_doc=doc,
+                selected_for_audit=(not should_exclude_file(full_path) and loc > 0),
+            )
+            result.files.append(fm)
+
+            if fm.selected_for_audit:
+                result.total_files += 1
+                result.total_lines_of_code += loc
+                result.total_lines_of_doc += doc
+
+            # Aggregate into parent folder and ensure all ancestor folders exist.
+            # The server-side import (import_file_list.py) discovers ALL directories
+            # via os.scandir.  The CLI must produce the same set so the folder
+            # hierarchy can be reconstructed on the server when building TypeDB
+            # directory_content relations (folder → parent_folder → root).
+            parent_rel = os.path.dirname(rel_path).replace("\\", "/")
+            if parent_rel and parent_rel != ".":
+                # Direct parent gets LoC / file_count
+                if parent_rel not in folder_aggregates:
+                    folder_aggregates[parent_rel] = FolderMetadata(relative_path=parent_rel)
+                folder_aggregates[parent_rel].lines_of_code += loc
+                folder_aggregates[parent_rel].file_count += 1
+
+                # Ensure every ancestor folder exists (with 0 direct metrics)
+                ancestor = os.path.dirname(parent_rel).replace("\\", "/")
+                while ancestor and ancestor != ".":
+                    if ancestor not in folder_aggregates:
+                        folder_aggregates[ancestor] = FolderMetadata(relative_path=ancestor)
+                    ancestor = os.path.dirname(ancestor).replace("\\", "/")
+
+            if progress_callback:
+                progress_callback(idx + 1, total_files, rel_path)
+
+        except Exception as exc:
+            error_msg = f"Error scanning {full_path}: {exc}"
+            logger.warning(error_msg)
+            result.errors.append(error_msg)
+
+    # Build sorted folder list
+    result.folders = sorted(folder_aggregates.values(), key=lambda f: f.relative_path)
+
+    return result

codedd_cli/scanner/line_counter.py

@@ -0,0 +1,75 @@
+"""
+Local line-of-code counter.
+
+Counts non-empty lines of code and comment/doc lines for a single file.
+This is a pure-Python implementation that mirrors the server-side
+``get_code_and_doc_lines`` fallback logic — no external ``linecounter``
+binary is required.
+"""
+
+import os
+from typing import Tuple
+
+from codedd_cli.scanner.file_classifier import (
+    get_file_type,
+    should_exclude_file,
+)
+
+# File types eligible for LoC counting
+_COUNTABLE_TYPES = frozenset({
+    'Source Code', 'Configuration', 'Documentation',
+    'System', 'Security', 'Other',
+})
+
+# Single-line comment prefixes by convention
+_COMMENT_PREFIXES = ('#', '//', '/*', '*', '*/', '--', ';', '%', 'REM ')
+
+# Maximum file size (in bytes) to attempt reading — skip very large binaries
+_MAX_FILE_SIZE = 50 * 1024 * 1024  # 50 MB
+
+
+def count_lines(file_path: str) -> Tuple[int, int]:
+    """
+    Count lines of code and lines of documentation/comments in *file_path*.
+
+    Args:
+        file_path: Absolute path to the file.
+
+    Returns:
+        Tuple of (lines_of_code, lines_of_doc).
+        Returns ``(0, 0)`` for excluded or unreadable files.
+    """
+    if should_exclude_file(file_path):
+        return 0, 0
+
+    file_type = get_file_type(file_path)
+    if file_type not in _COUNTABLE_TYPES:
+        return 0, 0
+
+    # Safety: skip extremely large files
+    try:
+        size = os.path.getsize(file_path)
+        if size > _MAX_FILE_SIZE:
+            return 0, 0
+    except OSError:
+        return 0, 0
+
+    try:
+        with open(file_path, 'r', encoding='utf-8', errors='replace') as fh:
+            lines = fh.readlines()
+    except (OSError, PermissionError):
+        return 1, 0  # Minimum fallback
+
+    non_empty = 0
+    comment_lines = 0
+
+    for line in lines:
+        stripped = line.strip()
+        if not stripped:
+            continue
+        non_empty += 1
+        if stripped.startswith(_COMMENT_PREFIXES):
+            comment_lines += 1
+
+    code_lines = max(non_empty - comment_lines, 1) if non_empty > 0 else 0
+    return code_lines, comment_lines

codedd_cli/utils/__init__.py

@@ -0,0 +1 @@
+