commiter-cli 0.3.0__py3-none-any.whl

commiter/uploader.py

@@ -0,0 +1,46 @@
+"""Upload architecture JSON to commiter.dev for AI enrichment."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import urllib.request
+import urllib.error
+
+UPLOAD_URL = "https://commiter-api.up.railway.app/v1/architecture/upload"
+
+
+def upload_architecture(json_str: str, api_token: str | None = None) -> dict:
+    """POST architecture JSON to the Commiter API and return the response.
+
+    Args:
+        json_str: The raw architecture JSON string.
+        api_token: Optional JWT for authenticated enrichment.
+
+    Returns:
+        Dict with keys: snapshot_id, url, status, tier
+        Or dict with key: error
+    """
+    headers = {"Content-Type": "application/json"}
+    if api_token:
+        headers["Authorization"] = f"Bearer {api_token}"
+
+    data = json_str.encode("utf-8")
+    headers["X-Content-Hash"] = hashlib.sha256(data).hexdigest()
+
+    req = urllib.request.Request(UPLOAD_URL, data=data, headers=headers, method="POST")
+
+    try:
+        with urllib.request.urlopen(req, timeout=30) as resp:
+            return json.loads(resp.read().decode("utf-8"))
+    except urllib.error.HTTPError as e:
+        body = e.read().decode("utf-8", errors="replace")
+        try:
+            error_data = json.loads(body)
+            return {"error": error_data.get("error", f"HTTP {e.code}")}
+        except json.JSONDecodeError:
+            return {"error": f"HTTP {e.code}: {body[:200]}"}
+    except urllib.error.URLError as e:
+        return {"error": f"Connection failed: {e.reason}"}
+    except Exception as e:
+        return {"error": str(e)}

commiter/utils/env_reader.py

@@ -0,0 +1,78 @@
+"""Read .env files and resolve environment variable references."""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+# .env files to check, in priority order (later overrides earlier)
+ENV_FILES = [
+    ".env",
+    ".env.local",
+    ".env.development",
+    ".env.development.local",
+]
+
+
+def load_env_files(repo_root: str) -> dict[str, str]:
+    """Read all .env files in the repo root and return a merged dict.
+
+    Later files override earlier ones. Only reads key=value pairs,
+    ignores comments and empty lines.
+    """
+    env: dict[str, str] = {}
+    root = Path(repo_root)
+
+    for filename in ENV_FILES:
+        env_path = root / filename
+        if env_path.is_file():
+            try:
+                content = env_path.read_text(encoding="utf-8", errors="replace")
+                env.update(_parse_env_content(content))
+            except OSError:
+                continue
+
+    return env
+
+
+def _parse_env_content(content: str) -> dict[str, str]:
+    """Parse .env file content into key-value pairs."""
+    result: dict[str, str] = {}
+    for line in content.splitlines():
+        line = line.strip()
+        # Skip empty lines and comments
+        if not line or line.startswith("#"):
+            continue
+        # Handle export prefix: export VAR=value
+        if line.startswith("export "):
+            line = line[7:].strip()
+        # Split on first =
+        if "=" not in line:
+            continue
+        key, _, value = line.partition("=")
+        key = key.strip()
+        value = value.strip()
+        # Strip surrounding quotes
+        if len(value) >= 2 and value[0] == value[-1] and value[0] in ("'", '"'):
+            value = value[1:-1]
+        if key:
+            result[key] = value
+
+    return result
+
+
+def resolve_env_var(var_name: str, env: dict[str, str]) -> str | None:
+    """Resolve a variable name to its .env value.
+
+    Handles common patterns:
+      process.env.API_URL -> looks up "API_URL"
+      process.env.NEXT_PUBLIC_API_URL -> looks up "NEXT_PUBLIC_API_URL"
+      import.meta.env.VITE_API_URL -> looks up "VITE_API_URL"
+    """
+    # Strip common prefixes
+    for prefix in ("process.env.", "import.meta.env."):
+        if var_name.startswith(prefix):
+            var_name = var_name[len(prefix):]
+            break
+
+    return env.get(var_name)

commiter/utils/file_classifier.py

@@ -0,0 +1,187 @@
+"""Detect language and framework from file contents and project structure."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from commiter.models import FileClassification, FileRole
+
+# Extension to language mapping
+EXTENSION_LANG: dict[str, str] = {
+    ".py": "python",
+    ".js": "javascript",
+    ".mjs": "javascript",
+    ".cjs": "javascript",
+    ".jsx": "javascript",
+    ".ts": "typescript",
+    ".tsx": "typescript",
+    ".go": "go",
+    ".rb": "ruby",
+    ".rs": "rust",
+    ".java": "java",
+    ".kt": "kotlin",
+    ".php": "php",
+    ".cs": "csharp",
+    ".swift": "swift",
+}
+
+# Patterns that indicate test files
+TEST_PATTERNS = {
+    "test_", "_test.", ".test.", ".spec.", "__tests__", "tests/", "test/",
+    "spec/", "specs/",
+}
+
+# Config file names
+CONFIG_FILES = {
+    ".env", ".env.local", ".env.production", ".env.development",
+    "docker-compose.yml", "docker-compose.yaml", "Dockerfile",
+    "tsconfig.json", "jsconfig.json", ".eslintrc", ".prettierrc",
+    "webpack.config.js", "vite.config.ts", "vite.config.js",
+    "next.config.js", "next.config.mjs", "next.config.ts",
+    "tailwind.config.js", "tailwind.config.ts",
+    "pyproject.toml", "setup.py", "setup.cfg", "tox.ini",
+    "Makefile", "Procfile", ".gitignore", ".dockerignore",
+}
+
+# Migration directory patterns
+MIGRATION_PATTERNS = {"migrations/", "alembic/", "migrate/", "db/migrate/"}
+
+
+def classify_file(file_path: str, repo_root: str) -> FileClassification:
+    """Classify a single file by role, language, and framework hints."""
+    path = Path(file_path).resolve()
+    root = Path(repo_root).resolve()
+    try:
+        rel = str(path.relative_to(root))
+    except ValueError:
+        rel = str(path)
+    name = path.name
+    ext = path.suffix.lower()
+
+    language = EXTENSION_LANG.get(ext, ext.lstrip(".") if ext else "unknown")
+    role = _detect_role(rel, name, ext)
+    framework_hints = _detect_framework_hints(rel, name)
+
+    return FileClassification(
+        file_path=file_path,
+        role=role,
+        language=language,
+        framework_hints=framework_hints,
+    )
+
+
+def _detect_role(rel_path: str, name: str, ext: str) -> FileRole:
+    """Determine the file's role based on path and name patterns."""
+    rel_lower = rel_path.lower().replace("\\", "/")
+
+    # Config files
+    if name in CONFIG_FILES or ext in (".yml", ".yaml", ".toml", ".ini", ".cfg"):
+        return FileRole.CONFIG
+
+    # Test files
+    for pattern in TEST_PATTERNS:
+        if pattern in rel_lower:
+            return FileRole.TEST
+
+    # Migration files
+    for pattern in MIGRATION_PATTERNS:
+        if pattern in rel_lower:
+            return FileRole.MIGRATION
+
+    # Next.js conventions
+    if "pages/api/" in rel_lower or "app/" in rel_lower and "route." in name:
+        return FileRole.BACKEND
+    if "pages/" in rel_lower or ("app/" in rel_lower and "page." in name):
+        return FileRole.FRONTEND
+
+    # Common backend patterns
+    backend_indicators = ("routes/", "api/", "controllers/", "handlers/", "views/", "endpoints/", "server.")
+    for indicator in backend_indicators:
+        if indicator in rel_lower:
+            return FileRole.BACKEND
+
+    # Common frontend patterns
+    frontend_indicators = ("components/", "pages/", "src/app/", "views/", "layouts/", "hooks/")
+    for indicator in frontend_indicators:
+        if indicator in rel_lower:
+            return FileRole.FRONTEND
+
+    # Fallback by extension
+    if ext in (".py", ".go", ".rb", ".java", ".php", ".rs"):
+        return FileRole.BACKEND
+    if ext in (".jsx", ".tsx"):
+        return FileRole.FRONTEND
+
+    return FileRole.UNKNOWN
+
+
+def _detect_framework_hints(rel_path: str, name: str) -> list[str]:
+    """Detect possible framework associations from path conventions."""
+    hints = []
+    rel_path = rel_path.replace("\\", "/")
+    if "pages/api/" in rel_path or "app/" in rel_path and "route." in name:
+        hints.append("nextjs")
+    if name in ("next.config.js", "next.config.mjs", "next.config.ts"):
+        hints.append("nextjs")
+    return hints
+
+
+def detect_repo_frameworks(repo_root: str) -> list[str]:
+    """Detect which frameworks a repository uses by checking dependency manifests and imports."""
+    frameworks = []
+    root = Path(repo_root)
+
+    # Check package.json
+    pkg_json = root / "package.json"
+    if pkg_json.exists():
+        try:
+            data = json.loads(pkg_json.read_text(encoding="utf-8", errors="replace"))
+            all_deps = set(data.get("dependencies", {}).keys()) | set(data.get("devDependencies", {}).keys())
+            if "express" in all_deps:
+                frameworks.append("express")
+            if "next" in all_deps:
+                frameworks.append("nextjs")
+            if "react" in all_deps:
+                frameworks.append("react")
+            if "fastify" in all_deps:
+                frameworks.append("fastify")
+            if "hono" in all_deps:
+                frameworks.append("hono")
+            if "@prisma/client" in all_deps or "prisma" in all_deps:
+                frameworks.append("prisma")
+            if "@supabase/supabase-js" in all_deps:
+                frameworks.append("supabase-js")
+            if "drizzle-orm" in all_deps:
+                frameworks.append("drizzle")
+            if "axios" in all_deps:
+                frameworks.append("axios")
+        except (json.JSONDecodeError, OSError):
+            pass
+
+    # Check Python manifests
+    for manifest in ("requirements.txt", "pyproject.toml", "setup.cfg", "Pipfile"):
+        manifest_path = root / manifest
+        if manifest_path.exists():
+            try:
+                content = manifest_path.read_text(encoding="utf-8", errors="replace").lower()
+                if "flask" in content:
+                    frameworks.append("flask")
+                if "fastapi" in content:
+                    frameworks.append("fastapi")
+                if "django" in content:
+                    frameworks.append("django")
+                if "supabase" in content:
+                    frameworks.append("supabase-py")
+                if "sqlalchemy" in content:
+                    frameworks.append("sqlalchemy")
+            except OSError:
+                pass
+
+    # Check for Next.js by directory structure
+    if not any(f in frameworks for f in ("nextjs",)):
+        if (root / "pages").is_dir() or (root / "app").is_dir():
+            if (root / "next.config.js").exists() or (root / "next.config.mjs").exists() or (root / "next.config.ts").exists():
+                frameworks.append("nextjs")
+
+    return list(dict.fromkeys(frameworks))  # deduplicate preserving order

commiter/utils/path_helpers.py

@@ -0,0 +1,73 @@
+"""Path utilities: repo root detection, ignore patterns, file walking."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+# Directories to always skip
+IGNORE_DIRS = {
+    ".git", "node_modules", "__pycache__", ".next", ".nuxt",
+    "dist", "build", ".tox", ".venv", "venv", "env",
+    ".mypy_cache", ".pytest_cache", ".ruff_cache",
+    "vendor", "target", ".idea", ".vscode",
+    "coverage", ".nyc_output", ".turbo",
+}
+
+# File extensions to skip
+IGNORE_EXTENSIONS = {
+    ".pyc", ".pyo", ".class", ".o", ".so", ".dll",
+    ".png", ".jpg", ".jpeg", ".gif", ".svg", ".ico",
+    ".woff", ".woff2", ".ttf", ".eot",
+    ".zip", ".tar", ".gz", ".bz2",
+    ".lock", ".sum",
+    ".map",
+}
+
+# Binary / non-code files to skip by name
+IGNORE_FILES = {
+    ".DS_Store", "Thumbs.db", "package-lock.json", "yarn.lock",
+    "pnpm-lock.yaml", "poetry.lock", "Pipfile.lock",
+    "Cargo.lock", "Gemfile.lock", "composer.lock",
+}
+
+
+def walk_repo(repo_root: str, extra_excludes: list[str] | None = None) -> list[str]:
+    """Walk a repository and return all relevant file paths.
+
+    Skips directories and files in the ignore lists.
+    """
+    root = Path(repo_root)
+    if not root.is_dir():
+        return []
+
+    exclude_set = set(extra_excludes) if extra_excludes else set()
+    files: list[str] = []
+
+    for path in root.rglob("*"):
+        if not path.is_file():
+            continue
+
+        # Check if any parent directory should be skipped
+        parts = path.relative_to(root).parts
+        if any(part in IGNORE_DIRS for part in parts):
+            continue
+
+        # Check file-level ignores
+        if path.name in IGNORE_FILES:
+            continue
+        if path.suffix.lower() in IGNORE_EXTENSIONS:
+            continue
+
+        # Check extra excludes (glob-style not needed, simple substring match)
+        rel = str(path.relative_to(root))
+        if any(excl in rel for excl in exclude_set):
+            continue
+
+        files.append(str(path))
+
+    return sorted(files)
+
+
+def detect_repo_name(repo_root: str) -> str:
+    """Detect a human-friendly repository name from the root path."""
+    return Path(repo_root).name

commiter/utils/tsconfig_resolver.py

@@ -0,0 +1,281 @@
+"""Parse tsconfig.json / jsconfig.json and resolve path aliases.
+
+Supports:
+- compilerOptions.baseUrl and compilerOptions.paths
+- "extends" inheritance chains (recursive)
+- Monorepo multi-tsconfig via TSConfigRegistry
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import re
+from pathlib import Path
+
+# Extensions to try when probing for a file
+RESOLVE_EXTENSIONS = [".ts", ".tsx", ".js", ".jsx", "/index.ts", "/index.js", "/index.tsx"]
+
+# Directories to skip when scanning for tsconfig files in monorepos
+SKIP_DIRS = {
+    "node_modules", ".git", "dist", "build", ".next", ".nuxt",
+    "__pycache__", ".tox", ".venv", "venv", "coverage",
+}
+
+# Max depth for extends chains to prevent infinite loops
+MAX_EXTENDS_DEPTH = 5
+
+
+def _strip_jsonc_comments(text: str) -> str:
+    """Strip // and /* */ comments from JSONC, preserving strings.
+
+    Uses a regex that matches strings first (to skip them), then comments.
+    This prevents stripping // inside strings like "@/*": ["src/*"].
+    """
+    # Match either a double-quoted string, a single-line comment, or a block comment.
+    # Strings are captured and preserved; comments are replaced with empty string.
+    def _replacer(match: re.Match) -> str:
+        if match.group(1) is not None:
+            return match.group(1)  # preserve string
+        return ""  # remove comment
+
+    return re.sub(
+        r'("(?:[^"\\]|\\.)*")'   # group 1: double-quoted string (preserved)
+        r'|//.*?$'                # single-line comment
+        r'|/\*.*?\*/',            # block comment
+        _replacer,
+        text,
+        flags=re.MULTILINE | re.DOTALL,
+    )
+
+
+def _load_json(config_path: str) -> dict | None:
+    """Load and parse a JSONC file (tsconfig/jsconfig). Returns None on failure."""
+    try:
+        raw = Path(config_path).read_text(encoding="utf-8", errors="replace")
+        raw = _strip_jsonc_comments(raw)
+        return json.loads(raw)
+    except (json.JSONDecodeError, OSError):
+        return None
+
+
+def _resolve_extends(data: dict, config_dir: str, seen: set[str] | None = None, depth: int = 0) -> dict:
+    """Recursively follow the 'extends' field and merge parent configs.
+
+    Merge rules (matching TypeScript behavior):
+    - compilerOptions: child overrides parent per-key (shallow merge)
+    - paths: child completely replaces parent if present
+    - include/exclude: child replaces parent
+    """
+    if depth >= MAX_EXTENDS_DEPTH:
+        return data
+
+    extends_value = data.get("extends")
+    if not extends_value:
+        return data
+
+    if seen is None:
+        seen = set()
+
+    # Resolve the extends path
+    if extends_value.startswith("."):
+        # Relative path: "./tsconfig.base.json" or "../shared/tsconfig.json"
+        parent_path = os.path.normpath(os.path.join(config_dir, extends_value))
+        # TypeScript also tries appending .json if not present
+        if not parent_path.endswith(".json"):
+            if os.path.isfile(parent_path + ".json"):
+                parent_path += ".json"
+    else:
+        # Package extends like "@tsconfig/next" — skip, can't resolve without node_modules
+        return data
+
+    parent_path = os.path.abspath(parent_path)
+
+    # Guard against circular extends
+    if parent_path in seen or not os.path.isfile(parent_path):
+        return data
+
+    seen.add(parent_path)
+
+    parent_data = _load_json(parent_path)
+    if parent_data is None:
+        return data
+
+    # Recursively resolve parent's extends
+    parent_dir = os.path.dirname(parent_path)
+    parent_data = _resolve_extends(parent_data, parent_dir, seen, depth + 1)
+
+    # Merge: parent as base, child overrides
+    merged = dict(parent_data)
+
+    # Merge compilerOptions (shallow: child keys override parent keys)
+    parent_opts = merged.get("compilerOptions", {})
+    child_opts = data.get("compilerOptions", {})
+    merged_opts = dict(parent_opts)
+    merged_opts.update(child_opts)
+    merged["compilerOptions"] = merged_opts
+
+    # Top-level fields: child replaces parent entirely
+    for key in ("include", "exclude", "files", "references"):
+        if key in data:
+            merged[key] = data[key]
+
+    # Remove extends from merged result
+    merged.pop("extends", None)
+
+    return merged
+
+
+class TSConfigResolver:
+    """Resolves TypeScript/JavaScript path aliases from a single tsconfig.json.
+
+    Handles compilerOptions.baseUrl, compilerOptions.paths, and "extends" chains.
+    """
+
+    def __init__(self, repo_root: str) -> None:
+        self.repo_root = os.path.abspath(repo_root)
+        self.base_url: str | None = None
+        self.paths: dict[str, list[str]] = {}
+        self._alias_rules: list[tuple[str, list[str]]] = []
+
+        self._load()
+
+    def _load(self) -> None:
+        """Find and parse tsconfig.json or jsconfig.json."""
+        for name in ("tsconfig.json", "jsconfig.json"):
+            config_path = os.path.join(self.repo_root, name)
+            if os.path.isfile(config_path):
+                self._parse(config_path)
+                return
+
+    def _parse(self, config_path: str) -> None:
+        """Parse a tsconfig/jsconfig file, following extends if present."""
+        data = _load_json(config_path)
+        if data is None:
+            return
+
+        config_dir = os.path.dirname(os.path.abspath(config_path))
+
+        # Follow extends chain
+        if "extends" in data:
+            data = _resolve_extends(data, config_dir)
+
+        compiler_opts = data.get("compilerOptions", {})
+
+        # baseUrl is relative to the tsconfig location
+        base_url = compiler_opts.get("baseUrl")
+        if base_url:
+            self.base_url = os.path.normpath(os.path.join(config_dir, base_url))
+
+        # paths entries
+        self.paths = compiler_opts.get("paths", {})
+
+        # Build alias rules: (prefix, [replacement_dirs])
+        for pattern, replacements in self.paths.items():
+            prefix = pattern.replace("*", "")
+            resolved_replacements = []
+            for repl in replacements:
+                repl_prefix = repl.replace("*", "")
+                base = self.base_url or config_dir
+                resolved_replacements.append(os.path.normpath(os.path.join(base, repl_prefix)))
+            self._alias_rules.append((prefix, resolved_replacements))
+
+    def resolve(self, import_path: str, caller_file: str = "") -> str | None:
+        """Resolve a non-relative import path using tsconfig aliases."""
+        if import_path.startswith("."):
+            return None
+
+        for prefix, replacement_dirs in self._alias_rules:
+            if not import_path.startswith(prefix):
+                continue
+
+            suffix = import_path[len(prefix):]
+            for repl_dir in replacement_dirs:
+                candidate_base = os.path.join(repl_dir, suffix)
+                result = self._probe_file(candidate_base)
+                if result:
+                    return result
+
+        if self.base_url:
+            candidate_base = os.path.join(self.base_url, import_path)
+            result = self._probe_file(candidate_base)
+            if result:
+                return result
+
+        return None
+
+    def _probe_file(self, base_path: str) -> str | None:
+        """Try to find a file at base_path with various extensions."""
+        if os.path.isfile(base_path):
+            return os.path.abspath(base_path)
+
+        for ext in RESOLVE_EXTENSIONS:
+            candidate = base_path + ext
+            if os.path.isfile(candidate):
+                return os.path.abspath(candidate)
+
+        return None
+
+    @property
+    def has_config(self) -> bool:
+        """Whether a tsconfig/jsconfig was found and parsed."""
+        return self.base_url is not None or bool(self.paths)
+
+
+class TSConfigRegistry:
+    """Manages multiple TSConfigResolvers for monorepo support.
+
+    Finds all tsconfig.json/jsconfig.json files in the repo, creates a resolver
+    for each, and routes resolve() calls to the nearest resolver for a given file.
+
+    Drop-in replacement for TSConfigResolver — same resolve() interface.
+    """
+
+    def __init__(self, repo_root: str) -> None:
+        self.repo_root = os.path.abspath(repo_root)
+        self._resolvers: dict[str, TSConfigResolver] = {}
+        self._build()
+
+    def _build(self) -> None:
+        """Find all tsconfig/jsconfig files and create resolvers."""
+        for root, dirs, files in os.walk(self.repo_root):
+            # Skip irrelevant directories
+            dirs[:] = [d for d in dirs if d not in SKIP_DIRS]
+
+            for name in ("tsconfig.json", "jsconfig.json"):
+                if name in files:
+                    config_dir = os.path.abspath(root)
+                    self._resolvers[config_dir] = TSConfigResolver(config_dir)
+                    break  # one config per directory
+
+    def get_resolver_for_file(self, file_path: str) -> TSConfigResolver | None:
+        """Find the nearest tsconfig resolver for a given file."""
+        current = Path(os.path.abspath(file_path)).parent
+        repo = Path(self.repo_root)
+
+        while current >= repo:
+            key = str(current)
+            if key in self._resolvers:
+                return self._resolvers[key]
+            current = current.parent
+
+        return None
+
+    def resolve(self, import_path: str, caller_file: str = "") -> str | None:
+        """Resolve using the nearest tsconfig for the caller file.
+
+        Same interface as TSConfigResolver.resolve() — drop-in replacement.
+        """
+        resolver = self.get_resolver_for_file(caller_file)
+        if resolver:
+            return resolver.resolve(import_path, caller_file)
+        return None
+
+    @property
+    def has_config(self) -> bool:
+        """Whether any tsconfig/jsconfig was found."""
+        return bool(self._resolvers)
+
+    @property
+    def resolver_count(self) -> int:
+        return len(self._resolvers)