party-continuum 0.1.0__tar.gz

party_continuum-0.1.0/PKG-INFO

@@ -0,0 +1,27 @@
+Metadata-Version: 2.4
+Name: party-continuum
+Version: 0.1.0
+Summary: Static change impact of a checkout: what depends on a symbol, how far a change reaches, which tests to run
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+
+# continuum
+
+Static change impact of the git checkout in the current directory, for Python
+and TypeScript/JavaScript. Continuum never runs tests; it tells you which to run.
+
+```bash
+pip install party-continuum        # or: brew install maitai-inc/continuum/continuum
+
+continuum dependents src/app/billing.py::charge   # before editing: what uses it
+continuum impact                                  # after editing: how far it reaches
+continuum tests --explain                         # before pushing: which tests, and why
+```
+
+It compares the working tree with its merge-base with the default branch
+(`--base <ref>` / `--head <commit>` to choose). Every command takes `--json`.
+Suites and test commands can be pinned in a `continuum.toml` at the checkout root.
+
+Requirements: Python 3.11+ and git. TypeScript also needs `node` and the
+repository's `typescript` package installed (`npm ci`), or `CONTINUUM_TYPESCRIPT_DIR`.
+No network access or credentials: everything is computed from the local checkout.

party_continuum-0.1.0/README.md

@@ -0,0 +1,20 @@
+# continuum
+
+Static change impact of the git checkout in the current directory, for Python
+and TypeScript/JavaScript. Continuum never runs tests; it tells you which to run.
+
+```bash
+pip install party-continuum        # or: brew install maitai-inc/continuum/continuum
+
+continuum dependents src/app/billing.py::charge   # before editing: what uses it
+continuum impact                                  # after editing: how far it reaches
+continuum tests --explain                         # before pushing: which tests, and why
+```
+
+It compares the working tree with its merge-base with the default branch
+(`--base <ref>` / `--head <commit>` to choose). Every command takes `--json`.
+Suites and test commands can be pinned in a `continuum.toml` at the checkout root.
+
+Requirements: Python 3.11+ and git. TypeScript also needs `node` and the
+repository's `typescript` package installed (`npm ci`), or `CONTINUUM_TYPESCRIPT_DIR`.
+No network access or credentials: everything is computed from the local checkout.

party_continuum-0.1.0/party_continuum/__init__.py

@@ -0,0 +1,3 @@
+"""Continuum change-impact CLI."""
+
+__version__ = "0.1.0"

party_continuum-0.1.0/party_continuum/applicability.py

@@ -0,0 +1,52 @@
+"""Evidence used to distinguish executable changes from file membership.
+
+Source bytes retain their ordinary digest for storage/exploration. Selection has
+an additional module-initialization fingerprint: editing a deferred function
+body changes that callable, not every consumer of its containing module.
+"""
+
+import ast
+import copy
+from pathlib import PurePosixPath
+
+from .config import digest
+
+
+def fingerprint(node):
+    return node.get("selection_digest", node.get("digest", node))
+
+
+class Initialization(ast.NodeTransformer):
+    def generic_visit(self, node):
+        node = copy.copy(node)
+        for field, value in ast.iter_fields(node):
+            if isinstance(value, list):
+                setattr(node, field, list(value))
+        return super().generic_visit(node)
+
+    def visit_FunctionDef(self, node):
+        result = copy.copy(node)
+        # Defaults, annotations and decorators execute at definition time. The
+        # body executes on invocation and has its own independently changed root.
+        result.body = [ast.Pass()]
+        return result
+
+    visit_AsyncFunctionDef = visit_FunctionDef
+
+
+def initialization_digest(tree):
+    return digest(ast.dump(Initialization().visit(tree), include_attributes=False))
+
+
+def source_roots(files, config):
+    if "source_roots" in config:
+        return config["source_roots"]
+    roots = {""}
+    for path in files:
+        if not path.endswith("/__init__.py"):
+            continue
+        package = PurePosixPath(path).parent
+        if str(package.parent / "__init__.py") not in files:
+            parent = str(package.parent)
+            roots.add("" if parent == "." else parent)
+    return sorted(roots)

party_continuum-0.1.0/party_continuum/build_metrics.py

@@ -0,0 +1,72 @@
+"""Coarse build resource counters; no graph contents or validation authority."""
+
+import math
+import time
+
+try:
+    import resource
+except ImportError:  # Parallel compilation also supports non-POSIX hosts.
+    resource = None
+
+
+FIELDS = (
+    "cpu_seconds",
+    "user_cpu_seconds",
+    "system_cpu_seconds",
+    "input_blocks",
+    "output_blocks",
+    "major_faults",
+    "voluntary_switches",
+    "involuntary_switches",
+)
+PHASE_FIELDS = tuple(
+    phase + "_" + prefix + key
+    for phase in ("compilation", "resolution")
+    for prefix in (("", "reaped_child_") if phase == "compilation" else ("",))
+    for key in FIELDS
+)
+
+
+def usage():
+    values = {"cpu_seconds": time.process_time()}
+    if resource is not None:
+        for prefix, who in (
+            ("", resource.RUSAGE_SELF),
+            ("reaped_child_", resource.RUSAGE_CHILDREN),
+        ):
+            row = resource.getrusage(who)
+            values.update(
+                {
+                    prefix + "cpu_seconds": row.ru_utime + row.ru_stime,
+                    prefix + "user_cpu_seconds": row.ru_utime,
+                    prefix + "system_cpu_seconds": row.ru_stime,
+                    prefix + "input_blocks": row.ru_inblock,
+                    prefix + "output_blocks": row.ru_oublock,
+                    prefix + "major_faults": row.ru_majflt,
+                    prefix + "voluntary_switches": row.ru_nvcsw,
+                    prefix + "involuntary_switches": row.ru_nivcsw,
+                }
+            )
+    return values
+
+
+def delta(before, after, phase):
+    # Compilation's pool has joined before sampling, so RUSAGE_CHILDREN includes
+    # those compilers. Resolution excludes children: the independent clean tree
+    # may be running concurrently, and must report its own resource counters.
+    return {
+        phase + "_" + key: after[key] - before[key]
+        for key in before.keys() & after.keys()
+        if phase == "compilation" or not key.startswith("reaped_child_")
+    }
+
+
+def clean_metrics(stats):
+    values = {}
+    for key in PHASE_FIELDS:
+        if key in stats:
+            value = stats[key]
+            if type(value) not in (int, float) or not math.isfinite(value) or value < 0:
+                raise ValueError("invalid_build_resource_metric")
+            values["clean_" + key] = value
+    return values

party_continuum-0.1.0/party_continuum/calls.py

@@ -0,0 +1,86 @@
+"""Conservative argument-to-parameter links for statically named Python callables.
+
+Call contexts share parameter bindings: multiple call sites deliberately form a
+union. Star expansion, descriptors and external callables retain uncertainty.
+"""
+
+from collections import defaultdict
+
+from .resolution import TerminalResolver
+
+
+def connect_calls(documents, nodes, edges, edge, gap):
+    outgoing = defaultdict(list)
+    relations = {"binding", "definition", "import_binding", "import_member", "alias_value"}
+    pairs = (
+        edges.relation_pairs(relations)
+        if hasattr(edges, "relation_pairs")
+        else (
+            (item["source"], item["target"])
+            for item in edges.values()
+            if item.get("relation") in relations
+        )
+    )
+    for source, target in pairs:
+        outgoing[source].append(target)
+    parameters = {}
+    calls = []
+    for path, (facts, ids, bindings, module, references) in documents.items():
+        children = defaultdict(list)
+        for item in facts["syntax"]:
+            children[item["parent"]].append(item)
+        for item in facts["syntax"]:
+            if item["type"] in {"FunctionDef", "AsyncFunctionDef", "Lambda"}:
+                params = []
+                for child in children[item["id"]]:
+                    if child["type"] == "arg":
+                        symbol = bindings.get((item["id"], child["arg"]))
+                        if symbol:
+                            params.append((child["arg"], symbol, child["field"]))
+                positional = [p for p in params if p[2] in {"args", "posonlyargs"}]
+                keywords = defaultdict(list)
+                for name, symbol, kind in params:
+                    if kind != "posonlyargs":
+                        keywords[name].append(symbol)
+                parameters[ids[item["id"]]] = positional, keywords
+            if item["type"] == "Call":
+                calls.append((path, item, children, ids))
+    resolver = TerminalResolver(outgoing, parameters)
+    for path, call, children, ids in calls:
+        callee = next((n for n in children[call["id"]] if n["field"] == "func"), None)
+        if not callee:
+            continue
+        targets = resolver.resolve(ids[callee["id"]])
+        arguments = [n for n in children[call["id"]] if n["field"] == "args"]
+        keywords = [n for n in children[call["id"]] if n["field"] == "keywords"]
+        for target in targets:
+            edge(ids[call["id"]], target, "calls", resolution="potential")
+            positional, named = parameters[target]
+            for parameter, argument in zip(positional, arguments):
+                if argument["type"] == "Starred":
+                    gap(path, ids[argument["id"]], "expanded_argument_binding")
+                    break
+                edge(
+                    parameter[1],
+                    ids[argument["id"]],
+                    "argument_value",
+                    resolution="potential",
+                    call=ids[call["id"]],
+                )
+            for keyword in keywords:
+                if not keyword.get("arg"):
+                    gap(path, ids[keyword["id"]], "expanded_argument_binding")
+                    continue
+                for symbol in named.get(keyword["arg"], ()):
+                    edge(
+                        symbol,
+                        ids[keyword["id"]],
+                        "argument_value",
+                        resolution="potential",
+                        call=ids[call["id"]],
+                    )
+    return {
+        "call_resolution_requests": resolver.requests,
+        "call_resolution_cache_hits": resolver.hits,
+        "call_resolution_nodes": len(resolver.results),
+    }

party_continuum-0.1.0/party_continuum/config.py

@@ -0,0 +1,194 @@
+"""Explicit operator-provisioned grants; webhook payloads cannot create tenants."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+from dataclasses import dataclass, field
+from pathlib import Path
+
+_CANONICAL_ENCODER = json.JSONEncoder(sort_keys=True, separators=(",", ":"), ensure_ascii=True)
+# "all" reconciles the default branch, open PR heads and merge-queue refs and
+# schedules PR/merge-group event commits. "default_branch" limits automatic
+# processing to the repository's current default branch: other refs and PR or
+# merge-group events are retained as deliveries but never indexed.
+TRACKED_REFS = frozenset({"all", "default_branch"})
+INVENTORY_KEYS = frozenset(
+    {"api_token_env", "webhook_secret_env", "analyzer_config", "tracked_refs"}
+)
+
+
+def canonical(value):
+    return _CANONICAL_ENCODER.encode(value)
+
+
+def digest(value):
+    return hashlib.sha256(canonical(value).encode()).hexdigest()
+
+
+@dataclass(frozen=True)
+class Repository:
+    tenant: str
+    installation: int
+    repository: int
+    name: str
+    api_token_env: str
+    webhook_secret_env: str
+    github_token_env: str = ""
+    local_git: str = ""
+    default_branch: str = "main"
+    analyzer_config: dict = field(default_factory=dict)
+    tracked_refs: str = "all"
+
+    def __post_init__(self):
+        if self.tracked_refs not in TRACKED_REFS:
+            raise ValueError("invalid_tracked_refs")
+
+    @property
+    def default_branch_only(self):
+        return self.tracked_refs == "default_branch"
+
+    @property
+    def scope(self):
+        return canonical([self.tenant, self.installation, self.repository])
+
+    @property
+    def config_digest(self):
+        return digest(self.analyzer_config)
+
+
+@dataclass
+class Settings:
+    database: str
+    repositories: list[Repository]
+    app_id: str = ""
+    private_key_env: str = "CONTINUUM_GITHUB_PRIVATE_KEY"
+    reconcile_seconds: int = 60
+    lease_seconds: int = 300
+    max_attempts: int = 5
+    archive_directory: str = ""
+    compile_workers: int = 0
+    overlap_validation: bool = False
+    index_workers: int = 0
+    native_publication_budget_bytes: int = 8 * 1024**3
+    # Whole-tree source admission limits for a single commit. The defaults match
+    # the historical provider constants; large repositories raise them explicitly.
+    source_bytes_limit: int = 50 * 1024 * 1024
+    source_files_limit: int = 10000
+    # Dedicated-App inventory grants (PostgreSQL `continuum_repositories`, kept
+    # current by the scheduled inventory sync). Enabled rows become repository
+    # grants sharing this credential pair, analyzer configuration and ref policy,
+    # so webhook admission, worker scope and dashboard history use one scope key.
+    inventory: dict | None = None
+
+    def grants(self, store=None):
+        """Authoritative repository grants for the current operation.
+
+        Static `repositories` always apply. With `inventory` configured, enabled
+        inventory rows are read on every call, so newly granted repositories are
+        admitted and removed or suspended access stops admitting work without a
+        restart. Static grants take precedence over an inventory row for the
+        same repository ID.
+        """
+        result = list(self.repositories)
+        if not self.inventory or store is None:
+            return result
+        with store.connect() as db:
+            rows = db.execute(
+                "SELECT scope,repository,installation,name FROM continuum_repositories "
+                "WHERE enabled ORDER BY repository"
+            ).fetchall()
+        known = {repo.repository for repo in result}
+        for row in rows:
+            tenant, installation, repository = json.loads(row["scope"])
+            if row["repository"] in known or (installation, repository) != (
+                row["installation"],
+                row["repository"],
+            ):
+                continue  # A static grant wins; an inconsistent row never becomes authority.
+            result.append(
+                Repository(
+                    tenant,
+                    installation,
+                    repository,
+                    row["name"],
+                    self.inventory["api_token_env"],
+                    self.inventory["webhook_secret_env"],
+                    analyzer_config=dict(self.inventory.get("analyzer_config", {})),
+                    tracked_refs=self.inventory.get("tracked_refs", "default_branch"),
+                )
+            )
+        return result
+
+    @classmethod
+    def load(cls):
+        raw = json.loads(Path(os.environ["CONTINUUM_CONFIG"]).read_text())
+        if os.environ.get("CONTINUUM_DATABASE_URL"):
+            raw["database"] = os.environ["CONTINUUM_DATABASE_URL"]
+        if os.environ.get("CONTINUUM_APP_ID"):
+            raw["app_id"] = os.environ[
+                "CONTINUUM_APP_ID"
+            ]  # keeps the App identity out of config files
+        raw["repositories"] = [Repository(**r) for r in raw["repositories"]]
+        settings = cls(**raw)
+        if settings.inventory is not None:
+            inventory = settings.inventory
+            if (
+                not isinstance(inventory, dict)
+                or set(inventory) - INVENTORY_KEYS
+                or not {"api_token_env", "webhook_secret_env"} <= set(inventory)
+                or not all(
+                    isinstance(inventory[key], str) and inventory[key]
+                    for key in ("api_token_env", "webhook_secret_env")
+                )
+                or not isinstance(inventory.get("analyzer_config", {}), dict)
+                or inventory.get("tracked_refs", "default_branch") not in TRACKED_REFS
+            ):
+                raise ValueError("invalid_inventory_configuration")
+            if not settings.database.startswith(("postgresql://", "postgres://")):
+                raise ValueError("inventory_grants_require_postgres")
+            if not os.environ.get(inventory["api_token_env"]) or not os.environ.get(
+                inventory["webhook_secret_env"]
+            ):
+                raise ValueError("configured API and webhook credentials must be present")
+            if os.environ.get(inventory["api_token_env"]) in {
+                os.environ.get(r.api_token_env) for r in settings.repositories
+            }:
+                raise ValueError("each repository requires a distinct API credential")
+        if settings.archive_directory and not settings.database.startswith(
+            ("postgresql://", "postgres://")
+        ):
+            raise ValueError("native_archive_requires_postgres")
+        if type(settings.compile_workers) is not int or not 0 <= settings.compile_workers <= 8:
+            raise ValueError("invalid_compile_workers")
+        if settings.compile_workers and not settings.archive_directory:
+            raise ValueError("parallel_compile_requires_native_archive")
+        if type(settings.index_workers) is not int or not 0 <= settings.index_workers <= 8:
+            raise ValueError("invalid_index_workers")
+        if settings.index_workers and not settings.archive_directory:
+            raise ValueError("parallel_indexes_require_native_archive")
+        if type(settings.overlap_validation) is not bool or (
+            settings.overlap_validation and not settings.compile_workers
+        ):
+            raise ValueError("overlap_validation_requires_parallel_compile")
+        if settings.native_publication_budget_bytes < 1:
+            raise ValueError("native_publication_budget_must_be_positive")
+        for name in ("source_bytes_limit", "source_files_limit"):
+            value = getattr(settings, name)
+            if type(value) is not int or value < 1:
+                raise ValueError("invalid_" + name)
+        ids = [r.repository for r in settings.repositories]
+        if len(ids) != len(set(ids)):
+            raise ValueError("repository IDs must have one tenant owner")
+        if min(settings.reconcile_seconds, settings.lease_seconds, settings.max_attempts) < 1:
+            raise ValueError("worker intervals must be positive")
+        api_credentials = [os.environ.get(r.api_token_env, "") for r in settings.repositories]
+        if len(api_credentials) != len(set(api_credentials)):
+            raise ValueError("each repository requires a distinct API credential")
+        for repo in settings.repositories:
+            if not os.environ.get(repo.api_token_env) or not os.environ.get(
+                repo.webhook_secret_env
+            ):
+                raise ValueError("configured API and webhook credentials must be present")
+        return settings