continuum-code 0.2.0__py3-none-any.whl

continuum/__init__.py

@@ -0,0 +1,8 @@
+"""Continuum: rule engine so coding agents obey repo rules."""
+
+from importlib.metadata import version as _version
+
+try:
+    __version__ = _version("continuum-code")
+except Exception:
+    __version__ = "0.2.0"

continuum/change_summary.py

@@ -0,0 +1,416 @@
+"""Build ChangeSummary from git diff or from an agent plan."""
+
+from __future__ import annotations
+
+import fnmatch
+import json
+import re
+import subprocess
+from pathlib import Path
+from typing import Any
+
+import yaml
+from pydantic import BaseModel, Field
+
+# Path globs for which we scan diff content for command-like strings (DAGs, scripts, CI, Dockerfile)
+COMMAND_SENSITIVE_GLOBS = [
+    "dags/**/*.py",
+    "**/*.sh",
+    "Makefile",
+    "makefile",
+    ".github/workflows/**/*.yml",
+    ".github/workflows/**/*.yaml",
+    "Dockerfile",
+    "**/Dockerfile*",
+]
+
+
+class DiffStats(BaseModel):
+    """Optional diff statistics."""
+
+    files: int = 0
+    insertions: int = 0
+    deletions: int = 0
+
+
+class ChangeSummary(BaseModel):
+    """Minimal v0.1 input for the evaluator: what changed."""
+
+    paths_changed: list[str] = Field(default_factory=list)
+    deps_added: list[str] = Field(default_factory=list)
+    deps_removed: list[str] = Field(default_factory=list)
+    commands_requested: list[str] | None = None
+    diff_stats: DiffStats | None = None
+    diff_content: str | None = None  # Unified diff for pattern bans (from_git sets when paths_changed)
+
+
+def from_plan(plan: dict[str, Any]) -> ChangeSummary:
+    """Build ChangeSummary from an agent plan (paths, deps, commands). No git."""
+    paths = plan.get("paths_changed") or plan.get("paths") or []
+    deps_added = plan.get("deps_added") or []
+    deps_removed = plan.get("deps_removed") or []
+    commands = plan.get("commands_requested") or plan.get("commands")
+    if not isinstance(paths, list):
+        paths = [paths] if paths else []
+    if not isinstance(deps_added, list):
+        deps_added = [deps_added] if deps_added else []
+    if not isinstance(deps_removed, list):
+        deps_removed = [deps_removed] if deps_removed else []
+    if commands is not None and not isinstance(commands, list):
+        commands = [commands] if commands else []
+    return ChangeSummary(
+        paths_changed=[str(p) for p in paths],
+        deps_added=[str(d) for d in deps_added],
+        deps_removed=[str(d) for d in deps_removed],
+        commands_requested=commands,
+    )
+
+
+def from_git(
+    repo_root: str | Path,
+    base_ref: str | None = None,
+    head_ref: str = "HEAD",
+    staged_only: bool = False,
+) -> ChangeSummary:
+    """Build ChangeSummary from git diff and dependency file changes."""
+    repo_root = Path(repo_root)
+    paths_changed = _git_changed_paths(repo_root, base_ref, head_ref, staged_only)
+    deps_added, deps_removed = _deps_diff(repo_root, base_ref, head_ref)
+    stats = _git_diff_stats(repo_root, base_ref, head_ref, staged_only)
+    diff_content = (
+        _git_diff_unified(repo_root, base_ref, head_ref, staged_only, paths_changed)
+        if paths_changed
+        else ""
+    )
+    commands = _commands_from_diff(
+        repo_root, base_ref, head_ref, staged_only, paths_changed, diff_text=diff_content or None
+    )
+    return ChangeSummary(
+        paths_changed=paths_changed,
+        deps_added=deps_added,
+        deps_removed=deps_removed,
+        commands_requested=commands if commands else None,
+        diff_stats=stats,
+        diff_content=diff_content or None,
+    )
+
+
+def _run_git(repo_root: Path, *args: str) -> str:
+    cmd = ["git", "-C", str(repo_root), *args]
+    try:
+        return subprocess.run(cmd, capture_output=True, text=True, timeout=30).stdout.strip()
+    except (subprocess.SubprocessError, FileNotFoundError):
+        return ""
+
+
+def _git_changed_paths(
+    repo_root: Path,
+    base_ref: str | None,
+    head_ref: str,
+    staged_only: bool,
+) -> list[str]:
+    if staged_only:
+        out = _run_git(repo_root, "diff", "--name-only", "--cached")
+    elif base_ref:
+        out = _run_git(repo_root, "diff", "--name-only", base_ref, head_ref)
+    else:
+        out = _run_git(repo_root, "diff", "--name-only", head_ref)
+    if not out:
+        return []
+    return [p.strip() for p in out.splitlines() if p.strip()]
+
+
+def _path_matches_glob(path: str, pattern: str) -> bool:
+    """True if path matches glob pattern (supports **)."""
+    path = path.replace("\\", "/")
+    pattern = pattern.replace("\\", "/")
+    if "**" not in pattern:
+        return fnmatch.fnmatch(path, pattern)
+    parts = pattern.split("**")
+    if len(parts) == 1:
+        return fnmatch.fnmatch(path, pattern)
+    start = parts[0].rstrip("/")
+    end = parts[-1].lstrip("/")
+    if start and not path.startswith(start if start.endswith("/") else start + "/"):
+        if not path.startswith(start):
+            return False
+    if end:
+        # end may be "*.py" or "/*.py" - require path to match the suffix as fnmatch
+        if not fnmatch.fnmatch(path, "*" + end if end.startswith("/") else "*" + end):
+            return False
+    return True
+
+
+def _is_command_sensitive_path(path: str) -> bool:
+    return any(_path_matches_glob(path, g) for g in COMMAND_SENSITIVE_GLOBS)
+
+
+def _git_diff_unified(
+    repo_root: Path,
+    base_ref: str | None,
+    head_ref: str,
+    staged_only: bool,
+    paths: list[str] | None = None,
+) -> str:
+    """Return unified diff for the given refs, optionally limited to paths."""
+    args = ["diff", "-U0"]
+    if staged_only:
+        args.append("--cached")
+    if base_ref:
+        args.extend([base_ref, head_ref])
+    else:
+        args.append(head_ref)
+    if paths:
+        args.append("--")
+        args.extend(paths)
+    return _run_git(repo_root, *args) or ""
+
+
+def _extract_commands_from_line(line: str) -> list[str]:
+    """Heuristic: extract command-like strings (dbt, airflow, aws, gcloud, or quoted commands)."""
+    found: list[str] = []
+    # Strip leading + and spaces from diff line
+    line = line.strip()
+    if line.startswith("+"):
+        line = line[1:].strip()
+    # Known prefixes: capture token after prefix (e.g. dbt run --full-refresh)
+    for prefix in ("dbt ", "airflow ", "aws ", "gcloud "):
+        for m in re.finditer(re.escape(prefix) + r"([^\s\"']+(?:\s+[^\s\"']+)*)", line):
+            cmd = (prefix + m.group(1)).strip()
+            if len(cmd) < 200:  # bound length
+                found.append(cmd)
+    # Quoted strings that look like commands (e.g. "dbt run --full-refresh", 'airflow dags backfill')
+    for quote in ('"', "'"):
+        pattern = quote + r"([^" + quote + r"]*?(?:dbt|airflow|aws|gcloud)[^" + quote + r"]*?)" + quote
+        for m in re.finditer(pattern, line):
+            cmd = m.group(1).strip()
+            if 0 < len(cmd) < 200:
+                found.append(cmd)
+    return found
+
+
+def _commands_from_diff(
+    repo_root: Path,
+    base_ref: str | None,
+    head_ref: str,
+    staged_only: bool,
+    paths_changed: list[str],
+    diff_text: str | None = None,
+) -> list[str]:
+    """Extract command-like strings from unified diff of command-sensitive paths."""
+    sensitive = [p for p in paths_changed if _is_command_sensitive_path(p)]
+    if not sensitive:
+        return []
+    diff = diff_text or _git_diff_unified(repo_root, base_ref, head_ref, staged_only, sensitive)
+    if not diff or not diff.strip():
+        return []
+    commands: list[str] = []
+    current_file: str | None = None
+    for line in diff.splitlines():
+        if line.startswith("--- ") or line.startswith("+++ "):
+            if line.startswith("+++ "):
+                # +++ a/dags/foo.py -> dags/foo.py
+                current_file = line[4:].strip().lstrip("a/b/")
+            continue
+        if line.startswith("+") and current_file and _is_command_sensitive_path(current_file):
+            commands.extend(_extract_commands_from_line(line))
+    return list(dict.fromkeys(commands))
+
+
+def _git_diff_stats(
+    repo_root: Path,
+    base_ref: str | None,
+    head_ref: str,
+    staged_only: bool,
+) -> DiffStats | None:
+    if staged_only:
+        out = _run_git(repo_root, "diff", "--cached", "--shortstat")
+    elif base_ref:
+        out = _run_git(repo_root, "diff", "--shortstat", base_ref, head_ref)
+    else:
+        out = _run_git(repo_root, "diff", "--shortstat", head_ref)
+    if not out:
+        return None
+    # " 2 files changed, 3 insertions(+), 1 deletion(-)"
+    m = re.search(r"(\d+)\s+files?\s+changed", out)
+    files = int(m.group(1)) if m else 0
+    m = re.search(r"(\d+)\s+insertion", out)
+    insertions = int(m.group(1)) if m else 0
+    m = re.search(r"(\d+)\s+deletion", out)
+    deletions = int(m.group(1)) if m else 0
+    return DiffStats(files=files, insertions=insertions, deletions=deletions)
+
+
+def _deps_diff(repo_root: Path, base_ref: str | None, head_ref: str) -> tuple[list[str], list[str]]:
+    """Detect added/removed deps by comparing lock/requirements between refs."""
+    # Get file content at head and base
+    def read_at(ref: str, path: str) -> str:
+        if ref == "HEAD" or not ref:
+            p = repo_root / path
+            return p.read_text(encoding="utf-8", errors="ignore") if p.exists() else ""
+        return _run_git(repo_root, "show", f"{ref}:{path}") or ""
+
+    added: list[str] = []
+    removed: list[str] = []
+    base = base_ref or "HEAD^"
+
+    # Python: requirements.txt, pyproject.toml, poetry.lock, uv.lock
+    for path in ("requirements.txt", "requirements-base.txt", "pyproject.toml"):
+        head_content = read_at(head_ref, path)
+        base_content = read_at(base, path) if base_ref else ""
+        if not head_content and not base_content:
+            continue
+        head_deps = _parse_python_deps(head_content, path)
+        base_deps = _parse_python_deps(base_content, path)
+        added.extend(n for n in head_deps if n not in base_deps)
+        removed.extend(n for n in base_deps if n not in head_deps)
+
+    for path in ("poetry.lock", "uv.lock"):
+        head_content = read_at(head_ref, path)
+        base_content = read_at(base, path) if base_ref else ""
+        if not head_content and not base_content:
+            continue
+        head_deps = _parse_lock_toml_deps(head_content)
+        base_deps = _parse_lock_toml_deps(base_content)
+        added.extend(n for n in head_deps if n not in base_deps)
+        removed.extend(n for n in base_deps if n not in head_deps)
+
+    # Node: package.json (declared deps)
+    head_pkg = read_at(head_ref, "package.json")
+    base_pkg = read_at(base, "package.json") if base_ref else ""
+    if head_pkg or base_pkg:
+        head_deps = _parse_package_json_deps(head_pkg)
+        base_deps = _parse_package_json_deps(base_pkg)
+        added.extend(n for n in head_deps if n not in base_deps)
+        removed.extend(n for n in base_deps if n not in head_deps)
+
+    # Node: lockfiles (resolved deps)
+    for path in ("package-lock.json", "pnpm-lock.yaml", "yarn.lock"):
+        head_content = read_at(head_ref, path)
+        base_content = read_at(base, path) if base_ref else ""
+        if not head_content and not base_content:
+            continue
+        if path == "package-lock.json":
+            head_deps = _parse_package_lock_json(head_content)
+            base_deps = _parse_package_lock_json(base_content)
+        elif path == "pnpm-lock.yaml":
+            head_deps = _parse_pnpm_lock(head_content)
+            base_deps = _parse_pnpm_lock(base_content)
+        else:
+            head_deps = _parse_yarn_lock(head_content)
+            base_deps = _parse_yarn_lock(base_content)
+        added.extend(n for n in head_deps if n not in base_deps)
+        removed.extend(n for n in base_deps if n not in head_deps)
+
+    return (list(dict.fromkeys(added)), list(dict.fromkeys(removed)))
+
+
+def _parse_python_deps(content: str, path: str) -> list[str]:
+    """Extract package names from requirements.txt or pyproject.toml."""
+    names: list[str] = []
+    if "pyproject.toml" in path:
+        # [project] dependencies = ["foo>=1", "bar"]
+        in_deps = False
+        for line in content.splitlines():
+            if line.strip().startswith("dependencies") and "=" in line:
+                in_deps = True
+                rest = line.split("=", 1)[1].strip()
+                if rest.startswith("["):
+                    for part in re.split(r"[\"'\s,]+", rest.strip("[]")):
+                        if part and not part.startswith("{"):
+                            names.append(_normalize_pypi_name(part))
+                continue
+            if in_deps and "]" in line:
+                break
+            if in_deps and line.strip():
+                names.append(_normalize_pypi_name(line.strip().strip('"').strip("'")))
+        return names
+    # requirements.txt: foo==1.0, foo[ext], -r other.txt
+    for line in content.splitlines():
+        line = line.split("#")[0].strip()
+        if not line or line.startswith("-") or line.startswith("["):
+            continue
+        name = re.split(r"[\s\[=<>]", line)[0]
+        if name:
+            names.append(_normalize_pypi_name(name))
+    return names
+
+
+def _normalize_pypi_name(name: str) -> str:
+    return name.lower().replace("_", "-")
+
+
+def _parse_lock_toml_deps(content: str) -> list[str]:
+    """Extract package names from poetry.lock or uv.lock (TOML with [[package]] or [package])."""
+    names: list[str] = []
+    # Match name = "pkg" or name = 'pkg' (Poetry/uv use this inside package sections)
+    for m in re.finditer(r'name\s*=\s*["\']([^"\']+)["\']', content):
+        names.append(_normalize_pypi_name(m.group(1)))
+    return names
+
+
+def _parse_package_lock_json(content: str) -> list[str]:
+    """Extract dependency names from package-lock.json (v1: dependencies keys; v2+: packages keys)."""
+    if not content.strip():
+        return []
+    try:
+        data = json.loads(content)
+        names: list[str] = []
+        deps = data.get("dependencies") or {}
+        names.extend(str(k) for k in deps)
+        # v2+ lockfile has "packages" with keys like "node_modules/foo" or "node_modules/bar@1.0"
+        packages = data.get("packages") or {}
+        for key in packages:
+            if key == "":
+                continue
+            # "node_modules/name" or "node_modules/name@version"
+            part = key.replace("node_modules/", "").split("@")[0]
+            if part:
+                names.append(part)
+        return list(dict.fromkeys(names))
+    except Exception:
+        return []
+
+
+def _parse_pnpm_lock(content: str) -> list[str]:
+    """Extract package names from pnpm-lock.yaml (packages: 'name@version': ...)."""
+    if not content.strip():
+        return []
+    try:
+        data = yaml.safe_load(content)
+        if not data or not isinstance(data, dict):
+            return []
+        names: list[str] = []
+        packages = data.get("packages") or {}
+        for key in packages:
+            # key can be "registry.npmjs.org/lodash@4.17.21" or "lodash@4.17.21"
+            part = key.split("/")[-1].split("@")[0]
+            if part and not part.startswith("."):
+                names.append(part)
+        return names
+    except Exception:
+        return []
+
+
+def _parse_yarn_lock(content: str) -> list[str]:
+    """Extract package names from yarn.lock (optional "name@version": or name@version:)."""
+    names: list[str] = []
+    # Lines like: "lodash@4.17.21": or lodash@^4.0.0:
+    for m in re.finditer(r'^["]?([^@"\s]+)@', content, re.MULTILINE):
+        name = m.group(1)
+        if name and not name.startswith("http"):
+            names.append(name)
+    return list(dict.fromkeys(names))
+
+
+def _parse_package_json_deps(content: str) -> list[str]:
+    """Extract dependency names from package.json (dependencies + devDependencies)."""
+    if not content.strip():
+        return []
+    try:
+        data = json.loads(content)
+        deps = list(data.get("dependencies") or {})
+        deps += list(data.get("devDependencies") or {})
+        return deps
+    except Exception:
+        return []