ai-dev-cli-tools 0.5.0a1__py3-none-any.whl

ai_dev_tools/detectors/project.py

@@ -0,0 +1,189 @@
+from __future__ import annotations
+
+import json
+import re
+import tomllib
+from pathlib import Path
+
+from ai_dev_tools.config import load_settings
+from ai_dev_tools.detectors.runtime import detect_runtime_requirements
+from ai_dev_tools.detectors.workspaces import detect_workspaces
+from ai_dev_tools.models.report import Report
+from ai_dev_tools.reporters.writer import write_json, write_markdown
+
+SIGNALS = {
+    "pyproject.toml": "python",
+    "requirements.txt": "python",
+    "Pipfile": "python",
+    "package.json": "javascript",
+    "pnpm-lock.yaml": "javascript",
+    "yarn.lock": "javascript",
+    "pom.xml": "java",
+    "build.gradle": "java",
+    "build.gradle.kts": "java",
+    "Cargo.toml": "rust",
+    "composer.json": "php",
+    "Dockerfile": "docker",
+    "compose.yaml": "docker",
+    "docker-compose.yml": "docker",
+    "Makefile": "make",
+}
+FRAMEWORK_HINTS = {
+    "django": "Django",
+    "flask": "Flask",
+    "fastapi": "FastAPI",
+    "react": "React",
+    "next": "Next.js",
+    "vue": "Vue",
+    "svelte": "Svelte",
+    "express": "Express",
+    "spring-boot": "Spring Boot",
+    "laravel": "Laravel",
+}
+
+
+def scan_project(project_root: Path) -> Report:
+    settings = load_settings(project_root)
+    report = Report(command="scan", project_root=settings.project_root)
+    files = {path.name: path for path in settings.project_root.iterdir() if path.is_file()}
+    scripts = _detect_scripts(settings.project_root)
+    dependencies = _dependency_names(settings.project_root)
+    workspaces = detect_workspaces(settings.project_root)
+    runtime_requirements = detect_runtime_requirements(settings.project_root)
+    report.summary = {
+        "project_name": settings.project_name or settings.project_root.name,
+        "languages": sorted({language for name, language in SIGNALS.items() if name in files}),
+        "frameworks": sorted(
+            {label for dep, label in FRAMEWORK_HINTS.items() if dep in dependencies}
+        ),
+        "package_managers": _detect_package_managers(files),
+        "entrypoints": _entrypoints(settings.project_root, scripts),
+        "tests": _matching_scripts(scripts, ("test", "pytest", "phpunit")),
+        "lint": _matching_scripts(scripts, ("lint", "ruff", "eslint", "checkstyle", "clippy")),
+        "formatter": _matching_scripts(
+            scripts, ("format", "fmt", "black", "prettier", "php-cs-fixer")
+        ),
+        "type_checker": _matching_scripts(scripts, ("type", "mypy", "tsc", "phpstan")),
+        "run": _matching_scripts(scripts, ("start", "dev", "serve", "run")),
+        "ci": sorted(
+            str(path.relative_to(settings.project_root))
+            for path in (settings.project_root / ".github" / "workflows").glob("*.y*ml")
+        ),
+        "docker": any(
+            name in files for name in ("Dockerfile", "compose.yaml", "docker-compose.yml")
+        ),
+        "env_example_variables": _env_examples(settings.project_root),
+        "config_files": sorted(name for name in files if name in SIGNALS or name.startswith(".")),
+        "config_warnings": settings.warnings,
+        "runtime_requirements": [requirement.to_dict() for requirement in runtime_requirements],
+        "workspaces": [workspace.to_dict() for workspace in workspaces],
+        "workspace_count": len(workspaces),
+    }
+    report.finish()
+    write_markdown(report, settings.reports_directory / "project-scan.md")
+    write_json(report, settings.reports_directory / "project-scan.json")
+    return report
+
+
+def _detect_package_managers(files: dict[str, Path]) -> list[str]:
+    pairs = [
+        ("pyproject.toml", "pip/pyproject"),
+        ("requirements.txt", "pip"),
+        ("package.json", "npm"),
+        ("pnpm-lock.yaml", "pnpm"),
+        ("yarn.lock", "yarn"),
+        ("pom.xml", "maven"),
+        ("Cargo.toml", "cargo"),
+        ("composer.json", "composer"),
+    ]
+    managers = [manager for filename, manager in pairs if filename in files]
+    if "build.gradle" in files or "build.gradle.kts" in files:
+        managers.append("gradle")
+    return managers
+
+
+def _detect_scripts(root: Path) -> dict[str, str]:
+    scripts: dict[str, str] = {}
+    package_json = root / "package.json"
+    if package_json.exists():
+        try:
+            package = json.loads(package_json.read_text(encoding="utf-8"))
+            scripts.update({f"npm:{k}": str(v) for k, v in package.get("scripts", {}).items()})
+        except json.JSONDecodeError:
+            pass
+    pyproject = root / "pyproject.toml"
+    if pyproject.exists():
+        try:
+            data = tomllib.loads(pyproject.read_text(encoding="utf-8"))
+            scripts.update(
+                {
+                    f"python:{k}": str(v)
+                    for k, v in data.get("project", {}).get("scripts", {}).items()
+                }
+            )
+        except tomllib.TOMLDecodeError:
+            pass
+    makefile = root / "Makefile"
+    if makefile.exists():
+        for line in makefile.read_text(encoding="utf-8", errors="replace").splitlines():
+            match = re.match(r"^([A-Za-z0-9_.-]+):", line)
+            if match:
+                scripts[f"make:{match.group(1)}"] = f"make {match.group(1)}"
+    return scripts
+
+
+def _dependency_names(root: Path) -> set[str]:
+    names: set[str] = set()
+    package_json = root / "package.json"
+    if package_json.exists():
+        try:
+            package = json.loads(package_json.read_text(encoding="utf-8"))
+            names.update(package.get("dependencies", {}))
+            names.update(package.get("devDependencies", {}))
+        except json.JSONDecodeError:
+            pass
+    pyproject = root / "pyproject.toml"
+    if pyproject.exists():
+        try:
+            data = tomllib.loads(pyproject.read_text(encoding="utf-8"))
+            for dep in data.get("project", {}).get("dependencies", []):
+                names.add(str(dep).split("[", 1)[0].split("=", 1)[0].lower())
+            for deps in data.get("project", {}).get("optional-dependencies", {}).values():
+                for dep in deps:
+                    names.add(str(dep).split("[", 1)[0].split("=", 1)[0].lower())
+        except tomllib.TOMLDecodeError:
+            pass
+    return names
+
+
+def _env_examples(root: Path) -> list[str]:
+    variables: set[str] = set()
+    for path in root.glob(".env*"):
+        if path.name == ".env":
+            continue
+        for line in path.read_text(encoding="utf-8", errors="replace").splitlines():
+            if "=" in line and not line.lstrip().startswith("#"):
+                variables.add(line.split("=", 1)[0].strip())
+    return sorted(variables)
+
+
+def _matching_scripts(scripts: dict[str, str], needles: tuple[str, ...]) -> dict[str, str]:
+    return {
+        key: value
+        for key, value in scripts.items()
+        if any(n in f"{key} {value}".lower() for n in needles)
+    }
+
+
+def _entrypoints(root: Path, scripts: dict[str, str]) -> list[str]:
+    found = [
+        name
+        for name in ("main.py", "app.py", "src/main.py", "index.js", "src/index.ts", "src/main.rs")
+        if (root / name).exists()
+    ]
+    found.extend(
+        f"script:{name}"
+        for name in scripts
+        if any(token in name for token in ("start", "dev", "run"))
+    )
+    return sorted(found)

ai_dev_tools/detectors/repository_map.py

@@ -0,0 +1,129 @@
+from __future__ import annotations
+
+import fnmatch
+from pathlib import Path
+
+from ai_dev_tools.config import load_settings
+from ai_dev_tools.models.report import Report
+from ai_dev_tools.reporters.writer import write_json, write_markdown
+
+IMPORTANT_NAMES = {
+    "pyproject.toml",
+    "package.json",
+    "Cargo.toml",
+    "composer.json",
+    "pom.xml",
+    "build.gradle",
+    "Dockerfile",
+    "compose.yaml",
+    "docker-compose.yml",
+    "Makefile",
+    "README.md",
+    "LICENSE",
+}
+BINARY_EXTENSIONS = {
+    ".png",
+    ".jpg",
+    ".jpeg",
+    ".gif",
+    ".ico",
+    ".pdf",
+    ".zip",
+    ".exe",
+    ".dll",
+    ".so",
+    ".dylib",
+}
+GENERATED_PATTERNS = ("*.min.js", "*.lock", "package-lock.json", "coverage.xml")
+
+
+def map_repository(project_root: Path, max_files: int = 500, max_depth: int = 6) -> Report:
+    settings = load_settings(project_root)
+    ignores = settings.ignore_paths | _gitignore_patterns(settings.project_root)
+    files: list[Path] = []
+    dirs: set[str] = set()
+    generated: list[str] = []
+    for path in settings.project_root.rglob("*"):
+        rel = path.relative_to(settings.project_root)
+        if len(rel.parts) > max_depth or _ignored(rel, ignores) or _is_binary(path):
+            continue
+        if path.is_dir():
+            dirs.add(str(rel))
+            continue
+        files.append(path)
+        if any(fnmatch.fnmatch(path.name, pattern) for pattern in GENERATED_PATTERNS):
+            generated.append(str(rel))
+    important = [
+        str(p.relative_to(settings.project_root))
+        for p in files
+        if p.name in IMPORTANT_NAMES or ".github/workflows" in p.as_posix()
+    ]
+    tests = [
+        str(p.relative_to(settings.project_root))
+        for p in files
+        if "test" in p.name.lower() or "tests" in p.parts
+    ]
+    docs = [
+        str(p.relative_to(settings.project_root))
+        for p in files
+        if p.suffix.lower() in {".md", ".rst"} or "docs" in p.parts
+    ]
+    report = Report(command="map", project_root=settings.project_root)
+    truncated = len(files) > max_files
+    report.summary = {
+        "directories": sorted(dirs)[:max_files],
+        "important_files": sorted(important)[:max_files],
+        "tests": sorted(tests)[:max_files],
+        "ci_workflows": sorted(
+            p for p in important if p.replace("\\", "/").startswith(".github/workflows/")
+        ),
+        "documentation": sorted(docs)[:max_files],
+        "generated_or_lock_files": sorted(generated)[:max_files],
+        "omitted_patterns": sorted(ignores),
+        "file_count_scanned": len(files),
+        "max_files": max_files,
+        "max_depth": max_depth,
+        "truncated": truncated,
+        "large_files": _large_files(settings.project_root, files),
+    }
+    report.finish()
+    write_markdown(report, settings.reports_directory / "repository-map.md")
+    write_json(report, settings.reports_directory / "repository-map.json")
+    return report
+
+
+def _gitignore_patterns(root: Path) -> set[str]:
+    path = root / ".gitignore"
+    if not path.exists():
+        return set()
+    return {
+        line.strip().rstrip("/")
+        for line in path.read_text(encoding="utf-8", errors="replace").splitlines()
+        if line.strip() and not line.startswith("#")
+    }
+
+
+def _ignored(rel: Path, patterns: set[str]) -> bool:
+    parts = set(rel.parts)
+    text = rel.as_posix()
+    normalized_patterns = {pattern.replace("\\", "/") for pattern in patterns}
+    return any(
+        pattern in parts
+        or text == pattern
+        or text.startswith(f"{pattern}/")
+        or fnmatch.fnmatch(text, pattern)
+        or fnmatch.fnmatch(rel.name, pattern)
+        for pattern in normalized_patterns
+    )
+
+
+def _is_binary(path: Path) -> bool:
+    return path.is_file() and path.suffix.lower() in BINARY_EXTENSIONS
+
+
+def _large_files(root: Path, files: list[Path]) -> list[str]:
+    return [
+        str(path.relative_to(root))
+        for path in files
+        if path.exists() and path.is_file() and path.stat().st_size > 1_000_000
+    ][:50]

ai_dev_tools/detectors/runtime.py

@@ -0,0 +1,190 @@
+from __future__ import annotations
+
+import json
+import re
+import tomllib
+from pathlib import Path
+
+from ai_dev_tools.models.workspace import RuntimeRequirement
+
+_VERSION = re.compile(r"\d+(?:\.\d+){0,3}")
+
+
+def detect_runtime_requirements(root: Path) -> list[RuntimeRequirement]:
+    requirements: list[RuntimeRequirement] = []
+    pyproject = _toml(root / "pyproject.toml")
+    project = pyproject.get("project", {})
+    if isinstance(project, dict) and isinstance(project.get("requires-python"), str):
+        requirements.append(
+            RuntimeRequirement("python", project["requires-python"], "pyproject.toml")
+        )
+    python_version = _first_line(root / ".python-version")
+    if python_version:
+        requirements.append(RuntimeRequirement("python", python_version, ".python-version"))
+
+    package = _json(root / "package.json")
+    engines = package.get("engines", {})
+    if isinstance(engines, dict) and isinstance(engines.get("node"), str):
+        requirements.append(RuntimeRequirement("node", engines["node"], "package.json"))
+    nvmrc = _first_line(root / ".nvmrc")
+    if nvmrc:
+        requirements.append(RuntimeRequirement("node", nvmrc, ".nvmrc"))
+
+    rust_toolchain = _toml(root / "rust-toolchain.toml")
+    toolchain = rust_toolchain.get("toolchain", {})
+    if isinstance(toolchain, dict) and isinstance(toolchain.get("channel"), str):
+        requirements.append(RuntimeRequirement("rust", toolchain["channel"], "rust-toolchain.toml"))
+    elif channel := _first_line(root / "rust-toolchain"):
+        requirements.append(RuntimeRequirement("rust", channel, "rust-toolchain"))
+
+    composer = _json(root / "composer.json")
+    composer_require = composer.get("require", {})
+    if isinstance(composer_require, dict) and isinstance(composer_require.get("php"), str):
+        requirements.append(RuntimeRequirement("php", composer_require["php"], "composer.json"))
+
+    pom_text = _text(root / "pom.xml")
+    java_constraint = _first_match(
+        pom_text,
+        (
+            r"<maven\.compiler\.release>\s*([^<]+)",
+            r"<maven\.compiler\.source>\s*([^<]+)",
+            r"<java\.version>\s*([^<]+)",
+        ),
+    )
+    if java_constraint:
+        requirements.append(RuntimeRequirement("java", java_constraint, "pom.xml"))
+
+    gradle_text = _text(root / "build.gradle") + "\n" + _text(root / "build.gradle.kts")
+    gradle_java = _first_match(
+        gradle_text,
+        (
+            r"(?:sourceCompatibility|languageVersion)\s*[=:]?\s*(?:JavaVersion\.VERSION_)?([0-9_\.]+)",
+        ),
+    )
+    if gradle_java:
+        requirements.append(
+            RuntimeRequirement("java", gradle_java.replace("_", "."), "Gradle configuration")
+        )
+    return _deduplicate(requirements)
+
+
+def evaluate_requirement(
+    requirement: RuntimeRequirement, detected_version: str | None
+) -> dict[str, str | None]:
+    if detected_version is None:
+        return {
+            **requirement.to_dict(),
+            "detected": None,
+            "status": "missing",
+        }
+    detected = _version_tuple(detected_version)
+    if detected is None:
+        return {
+            **requirement.to_dict(),
+            "detected": detected_version,
+            "status": "unknown",
+        }
+    compatible = _matches_constraint(detected, requirement.constraint)
+    return {
+        **requirement.to_dict(),
+        "detected": detected_version,
+        "status": "compatible" if compatible else "incompatible",
+    }
+
+
+def _matches_constraint(version: tuple[int, ...], constraint: str) -> bool:
+    normalized = constraint.strip().lower().removeprefix("v")
+    if normalized in {"stable", "nightly", "beta", "*", "latest"}:
+        return True
+    alternatives = [item.strip() for item in normalized.split("||")]
+    return any(_matches_all(version, alternative) for alternative in alternatives)
+
+
+def _matches_all(version: tuple[int, ...], constraint: str) -> bool:
+    parts = [item for item in re.split(r"\s*,\s*|\s+", constraint) if item]
+    if not parts:
+        return True
+    for part in parts:
+        match = re.match(r"(>=|<=|==|=|>|<|\^|~)?\s*v?(\d+(?:\.\d+){0,3})", part)
+        if match is None:
+            continue
+        operator = match.group(1) or "=="
+        expected = _version_tuple(match.group(2))
+        if expected is None:
+            continue
+        left, right = _padded(version, expected)
+        if operator in {"=", "=="} and left[: len(expected)] != right[: len(expected)]:
+            return False
+        if operator == ">=" and left < right:
+            return False
+        if operator == "<=" and left > right:
+            return False
+        if operator == ">" and left <= right:
+            return False
+        if operator == "<" and left >= right:
+            return False
+        if operator == "^":
+            upper = (right[0] + 1, *([0] * (len(right) - 1)))
+            if left < right or left >= upper:
+                return False
+        if operator == "~":
+            upper = (right[0], (right[1] if len(right) > 1 else 0) + 1, 0, 0)
+            upper = upper[: len(right)]
+            if left < right or left >= upper:
+                return False
+    return True
+
+
+def _padded(
+    left: tuple[int, ...], right: tuple[int, ...]
+) -> tuple[tuple[int, ...], tuple[int, ...]]:
+    size = max(len(left), len(right), 3)
+    return left + (0,) * (size - len(left)), right + (0,) * (size - len(right))
+
+
+def _version_tuple(value: str) -> tuple[int, ...] | None:
+    match = _VERSION.search(value)
+    return tuple(int(item) for item in match.group(0).split(".")) if match else None
+
+
+def _deduplicate(items: list[RuntimeRequirement]) -> list[RuntimeRequirement]:
+    found: dict[tuple[str, str, str], RuntimeRequirement] = {}
+    for item in items:
+        found[(item.runtime, item.constraint, item.source)] = item
+    return list(found.values())
+
+
+def _first_match(text: str, patterns: tuple[str, ...]) -> str | None:
+    for pattern in patterns:
+        if match := re.search(pattern, text):
+            return match.group(1).strip()
+    return None
+
+
+def _first_line(path: Path) -> str | None:
+    text = _text(path).strip()
+    return text.splitlines()[0].strip() if text else None
+
+
+def _text(path: Path) -> str:
+    try:
+        return path.read_text(encoding="utf-8", errors="replace")
+    except OSError:
+        return ""
+
+
+def _toml(path: Path) -> dict[str, object]:
+    try:
+        with path.open("rb") as handle:
+            value = tomllib.load(handle)
+            return value if isinstance(value, dict) else {}
+    except (OSError, tomllib.TOMLDecodeError):
+        return {}
+
+
+def _json(path: Path) -> dict[str, object]:
+    try:
+        value = json.loads(path.read_text(encoding="utf-8"))
+        return value if isinstance(value, dict) else {}
+    except (OSError, json.JSONDecodeError):
+        return {}