@prism-d1/cli 1.0.84 → 1.0.86

package/dist/assets/coding-agent/config.py

@@ -0,0 +1,338 @@
+"""Configuration and project-type detection for the PRISM coding agent.
+
+Resolution order for verification commands:
+  1. .coding-agent/config.json in the target repo (written by
+     `prism-cli bootstrapper install-coding-agent`)
+  2. Marker-file auto-detection (package.json -> npm test, etc.)
+  3. Nothing -- the agent is told to report fixes as UNVERIFIED rather than
+     silently skipping verification.
+"""
+
+from __future__ import annotations
+
+import json
+import re
+import subprocess
+from dataclasses import dataclass, field
+from pathlib import Path
+
+CONFIG_DIR = ".coding-agent"
+CONFIG_FILE = "config.json"
+
+# (marker file, test command, build command, project label, mise tool name)
+#
+# The mise tool name is what goes into .tool-versions. mise normalises aliases
+# (nodejs -> node, golang -> go), but the canonical name is used so the file
+# matches what `mise ls` reports back and a reader is not left wondering whether
+# two spellings mean two things.
+DETECTORS: list[tuple[str, str, str | None, str, str | None]] = [
+    ("package.json", "npm test", "npm run build", "node", "node"),
+    ("pyproject.toml", "pytest", None, "python", "python"),
+    ("setup.py", "pytest", None, "python", "python"),
+    ("Cargo.toml", "cargo test", "cargo build", "rust", "rust"),
+    ("go.mod", "go test ./...", "go build ./...", "go", "go"),
+    ("pom.xml", "mvn -q test", "mvn -q compile", "java-maven", "java"),
+    ("build.gradle", "./gradlew test", "./gradlew build", "java-gradle", "java"),
+    ("build.gradle.kts", "./gradlew test", "./gradlew build", "java-gradle", "java"),
+    ("composer.json", "vendor/bin/phpunit", None, "php", "php"),
+    ("Gemfile", "bundle exec rspec", None, "ruby", "ruby"),
+    ("Makefile", "make test", "make", "make", None),
+]
+
+TOOL_VERSIONS_FILE = ".tool-versions"
+
+# Version files mise already understands. If a repo has one of these, it has
+# already stated its intent and writing .tool-versions alongside it would create
+# two answers to one question -- so detection reports the file instead.
+IDIOMATIC_VERSION_FILES = {
+    "node": (".nvmrc", ".node-version"),
+    "python": (".python-version",),
+    "ruby": (".ruby-version",),
+    "java": (".java-version",),
+    "rust": ("rust-toolchain", "rust-toolchain.toml"),
+    "go": (".go-version",),
+}
+
+# How to ask a locally installed toolchain what version it is. Used only as a
+# fallback, and only with fixed argv -- no value from the repository reaches a
+# command line here.
+_LOCAL_VERSION_PROBES: dict[str, tuple[list[str], str]] = {
+    "node": (["node", "--version"], r"v?(\d+\.\d+\.\d+)"),
+    "python": (["python3", "--version"], r"(\d+\.\d+\.\d+)"),
+    "rust": (["rustc", "--version"], r"(\d+\.\d+\.\d+)"),
+    "go": (["go", "version"], r"go(\d+\.\d+(?:\.\d+)?)"),
+    "java": (["java", "-version"], r"(?:version \")?(\d+)(?:\.|\")"),
+    "ruby": (["ruby", "--version"], r"(\d+\.\d+\.\d+)"),
+}
+
+# A verification command must be a single invocation. Chaining, substitution and
+# redirection are rejected: they turn a config value into arbitrary shell. If a
+# project genuinely needs a chain, it belongs in a script that we then call.
+_FORBIDDEN = re.compile(r"[;&|`\n\r]|\$\(|>\s|<\s")
+
+
+class ConfigError(ValueError):
+    """Raised when a configured command is not a safe single invocation."""
+
+
+def validate_command(command: str, label: str) -> str:
+    """Reject shell metacharacters in a configured command.
+
+    The agent executes these through its shell tool, so a chained command would
+    widen the agent's capability well beyond "run the tests".
+    """
+    command = command.strip()
+    if not command:
+        return ""
+    if _FORBIDDEN.search(command):
+        raise ConfigError(
+            f"{label} must be a single command without shell operators "
+            f"(; && || | ` $() > <). Got: {command!r}. "
+            f"Put multi-step logic in a script and reference the script instead."
+        )
+    return command
+
+
+@dataclass
+class AgentConfig:
+    """Resolved settings for one agent run against one repository."""
+
+    repo_path: Path
+    test_command: str = ""
+    build_command: str = ""
+    lint_command: str = ""
+    agent_email: str = "prism-agent@example.com"
+    agent_name: str = "PRISM Coding Agent"
+    max_attempts: int = 3
+    model_id: str = "us.anthropic.claude-sonnet-4-5-20250929-v1:0"
+    region: str = "us-west-2"
+    project_type: str = "unknown"
+    source: str = "detected"  # "config" | "detected" | "none"
+    allowed_paths: list[str] = field(default_factory=list)
+
+    @property
+    def can_verify(self) -> bool:
+        """True when a fix can be validated by running something."""
+        return bool(self.test_command)
+
+
+def detect_project(repo_path: Path) -> tuple[str, str | None, str]:
+    """Return (test_command, build_command, project_type) from marker files."""
+    for marker, test_cmd, build_cmd, label, _tool in DETECTORS:
+        if (repo_path / marker).exists():
+            return test_cmd, build_cmd, label
+    return "", None, "unknown"
+
+
+def mise_tool_for(project_type: str) -> str | None:
+    """The mise tool name for a project type, if it has one."""
+    for _marker, _t, _b, label, tool in DETECTORS:
+        if label == project_type:
+            return tool
+    return None
+
+
+def _manifest_version(repo_path: Path, tool: str) -> str:
+    """Read the version the repository itself declares, if it declares one.
+
+    Preferred over the locally installed toolchain: a manifest states intent,
+    whereas whatever happens to be on the machine running the installer is an
+    accident of that machine. Only unambiguous single-version declarations are
+    used -- a range like ">=18" says what is tolerated, not what to pin, and
+    guessing a point release from it would be inventing information.
+    """
+    def read(name: str) -> str:
+        path = repo_path / name
+        try:
+            return path.read_text(encoding="utf-8") if path.is_file() else ""
+        except (OSError, UnicodeDecodeError):
+            return ""
+
+    if tool == "go":
+        # go.mod's `go` directive is a real pin and always exact enough to use.
+        match = re.search(r"^go\s+(\d+\.\d+(?:\.\d+)?)\s*$", read("go.mod"), re.M)
+        if match:
+            return match.group(1)
+
+    if tool == "node":
+        raw = read("package.json")
+        if raw:
+            try:
+                engines = json.loads(raw).get("engines") or {}
+            except json.JSONDecodeError:
+                engines = {}
+            spec = str(engines.get("node") or "").strip()
+            # Only an exact pin. "^22.1.0" and ">=18" are ranges, and resolving
+            # them here would duplicate npm's semver logic badly.
+            if re.fullmatch(r"\d+\.\d+\.\d+", spec):
+                return spec
+
+    if tool == "rust":
+        match = re.search(r'channel\s*=\s*"([^"]+)"', read("rust-toolchain.toml"))
+        if match:
+            return match.group(1)
+
+    if tool == "ruby":
+        match = re.search(r"^\s*ruby\s+[\"'](\d+\.\d+\.\d+)[\"']", read("Gemfile"), re.M)
+        if match:
+            return match.group(1)
+
+    return ""
+
+
+def _local_version(tool: str) -> str:
+    """Ask the locally installed toolchain its version.
+
+    A fallback, and a deliberately weak one -- it records what the machine
+    running the installer happens to have. That is still far better than nothing,
+    because the alternative is a repository with no pin at all, where the harness
+    installs whatever is newest and a passing suite today can fail tomorrow for
+    reasons unrelated to any change in the repository.
+    """
+    probe = _LOCAL_VERSION_PROBES.get(tool)
+    if not probe:
+        return ""
+    argv, pattern = probe
+    try:
+        proc = subprocess.run(argv, capture_output=True, text=True, timeout=15, check=False)
+    except (OSError, subprocess.SubprocessError):
+        return ""
+    # java -version writes to stderr; others to stdout.
+    match = re.search(pattern, (proc.stdout or "") + (proc.stderr or ""))
+    return match.group(1) if match else ""
+
+
+def detect_tool_version(repo_path: Path, project_type: str) -> dict[str, str]:
+    """Work out what to pin in .tool-versions, and say where the answer came from.
+
+    Returns tool, version and source, where source is one of:
+
+      existing   .tool-versions is already present -- nothing to do
+      idiomatic  the repo has .nvmrc or similar, which mise reads directly
+      manifest   the repo declares an exact version (go.mod, engines, Gemfile)
+      local      taken from the toolchain installed on this machine
+      none       no version could be established, so nothing should be written
+
+    `none` is a real outcome, not a failure to handle. Writing a pin that was
+    guessed would be worse than leaving the repo unpinned: it would look
+    deliberate and reviewed when it was neither.
+    """
+    tool = mise_tool_for(project_type)
+    if not tool:
+        return {"tool": "", "version": "", "source": "none"}
+
+    if (repo_path / TOOL_VERSIONS_FILE).is_file():
+        return {"tool": tool, "version": "", "source": "existing"}
+
+    for name in IDIOMATIC_VERSION_FILES.get(tool, ()):
+        if (repo_path / name).is_file():
+            return {"tool": tool, "version": "", "source": "idiomatic", "file": name}
+
+    version = _manifest_version(repo_path, tool)
+    if version:
+        return {"tool": tool, "version": version, "source": "manifest"}
+
+    version = _local_version(tool)
+    if version:
+        return {"tool": tool, "version": version, "source": "local"}
+
+    return {"tool": tool, "version": "", "source": "none"}
+
+
+def load_config(repo_path: Path, **overrides: object) -> AgentConfig:
+    """Build an AgentConfig for `repo_path`.
+
+    Explicit keyword overrides (from CLI flags) win over the config file, which
+    wins over auto-detection. Empty-string overrides are meaningful: they mean
+    "this project has no such command", not "fall back to detection".
+    """
+    repo_path = repo_path.resolve()
+    if not repo_path.is_dir():
+        raise ConfigError(f"Not a directory: {repo_path}")
+
+    cfg = AgentConfig(repo_path=repo_path)
+
+    config_path = repo_path / CONFIG_DIR / CONFIG_FILE
+    if config_path.exists():
+        try:
+            data = json.loads(config_path.read_text())
+        except json.JSONDecodeError as exc:
+            raise ConfigError(f"{config_path} is not valid JSON: {exc}") from exc
+        cfg.source = "config"
+        cfg.test_command = str(data.get("test_command") or "")
+        cfg.build_command = str(data.get("build_command") or "")
+        cfg.lint_command = str(data.get("lint_command") or "")
+        cfg.agent_email = str(data.get("agent_email") or cfg.agent_email)
+        cfg.agent_name = str(data.get("agent_name") or cfg.agent_name)
+        cfg.max_attempts = int(data.get("max_attempts") or cfg.max_attempts)
+        cfg.model_id = str(data.get("model_id") or cfg.model_id)
+        cfg.region = str(data.get("region") or cfg.region)
+        cfg.project_type = str(data.get("detected_project_type") or "unknown")
+        cfg.allowed_paths = list(data.get("allowed_paths") or [])
+    else:
+        test_cmd, build_cmd, label = detect_project(repo_path)
+        cfg.test_command = test_cmd
+        cfg.build_command = build_cmd or ""
+        cfg.project_type = label
+        cfg.source = "detected" if test_cmd else "none"
+
+    for key, value in overrides.items():
+        if value is None:
+            continue
+        if not hasattr(cfg, key):
+            raise ConfigError(f"Unknown config override: {key}")
+        setattr(cfg, key, value)
+
+    cfg.test_command = validate_command(cfg.test_command, "test_command")
+    cfg.build_command = validate_command(cfg.build_command, "build_command")
+    cfg.lint_command = validate_command(cfg.lint_command, "lint_command")
+
+    if cfg.max_attempts < 1:
+        raise ConfigError("max_attempts must be at least 1")
+
+    return cfg
+
+
+def _detect_as_json(repo_path: Path) -> str:
+    """Serialize detection results for a non-Python caller.
+
+    `prism-cli bootstrapper install-coding-agent` needs the same project-type
+    defaults the agent would derive, to offer them at the prompt. It shells out
+    to this rather than carrying a second copy of DETECTORS in TypeScript --
+    two tables would drift, and the symptom would be an installer that offers
+    `npm test` for a repo the agent then runs `pytest` against.
+    """
+    test_cmd, build_cmd, label = detect_project(repo_path)
+    existing = repo_path / CONFIG_DIR / CONFIG_FILE
+    return json.dumps(
+        {
+            "test_command": test_cmd,
+            "build_command": build_cmd or "",
+            "project_type": label,
+            "config_exists": existing.exists(),
+            "toolchain": detect_tool_version(repo_path, label),
+        }
+    )
+
+
+if __name__ == "__main__":
+    import argparse
+    import sys
+
+    parser = argparse.ArgumentParser(description="Inspect PRISM coding agent configuration.")
+    parser.add_argument("--detect", metavar="REPO", help="Print detection results for REPO as JSON")
+    parser.add_argument("--show", metavar="REPO", help="Print the fully resolved config for REPO")
+    args = parser.parse_args()
+
+    try:
+        if args.detect:
+            print(_detect_as_json(Path(args.detect)))
+        elif args.show:
+            resolved = load_config(Path(args.show))
+            print(json.dumps({k: str(v) for k, v in vars(resolved).items()}, indent=2))
+        else:
+            parser.print_help()
+            sys.exit(2)
+    except ConfigError as exc:
+        print(f"error: {exc}", file=sys.stderr)
+        sys.exit(1)

package/dist/assets/coding-agent/deploy/Dockerfile

@@ -0,0 +1,86 @@
+# PRISM coding agent — single harness environment for every toolchain.
+#
+# One harness instead of one per language. The reason is a hard limit: an
+# AgentCore Runtime image may not exceed 2 GB and that quota is not adjustable,
+# while the official language images total ~9.3 GB (rust:1 alone is 1.65 GB, or
+# 83% of the budget). A fat image is arithmetically impossible.
+#
+# So this image ships a version *manager* rather than versions. The toolchain is
+# installed at session start with InvokeAgentRuntimeCommand -- no model
+# reasoning, no tokens -- reading the target repository's own version files.
+# AWS documents this path: "The base environment includes Python and bash. For
+# tools like git, node, or other runtimes, install them at session start."
+#
+# It also closes the version matrix. node@18 and node@22 stop being two
+# harnesses and become a line in the repo's .tool-versions, which suits an
+# architecture where the repository already describes itself.
+#
+# Build (must be arm64 -- the harness rejects anything else):
+#   docker buildx build --platform linux/arm64 -t prism-coding-agent:dev .
+#
+# The harness overrides ENTRYPOINT and CMD to keep the container alive as an
+# environment, so neither is set here. Installed software, filesystem and
+# environment variables are what carry over.
+
+FROM python:3.12-slim
+
+# Pinned rather than floated: a harness image that silently changes its tool
+# manager between builds makes an agent regression untraceable.
+ARG MISE_VERSION=v2026.8.11
+ARG TARGETARCH
+
+# git is the one non-negotiable addition -- an agent that cannot branch, diff or
+# produce a patch is not a coding agent, and neither the harness base nor the
+# slim Python image carries it.
+#
+# build-essential is here because it is load-bearing rather than convenient:
+# node-gyp needs a compiler for native modules, and rustc needs a linker. Omit
+# it and the failures appear later, inside the agent's own test run, where they
+# read as the agent's fault.
+RUN apt-get update && apt-get install -y --no-install-recommends \
+        git \
+        ca-certificates \
+        curl \
+        xz-utils \
+        unzip \
+        pkg-config \
+        build-essential \
+    && rm -rf /var/lib/apt/lists/*
+
+# mise resolves per directory, which is what makes a multi-language monorepo
+# work: the Node web app and the Python service each get their own versions with
+# no routing decision made outside the repository.
+#
+# TARGETARCH is Docker's vocabulary (amd64/arm64); mise publishes x64/arm64.
+# Mapping between them is not cosmetic -- a build that assumes they match
+# succeeds on arm64 and fails with a bare curl exit 22 on x86, which is a
+# confusing way to discover a naming mismatch.
+RUN set -eux; \
+    case "${TARGETARCH:-arm64}" in \
+      amd64|x86_64) arch=x64 ;; \
+      arm64|aarch64) arch=arm64 ;; \
+      *) echo "unsupported TARGETARCH: ${TARGETARCH}" >&2; exit 1 ;; \
+    esac; \
+    url="https://github.com/jdx/mise/releases/download/${MISE_VERSION}/mise-${MISE_VERSION}-linux-${arch}.tar.gz"; \
+    curl -fsSL "$url" -o /tmp/mise.tar.gz; \
+    tar -xzf /tmp/mise.tar.gz -C /tmp; \
+    install -m 0755 /tmp/mise/bin/mise /usr/local/bin/mise; \
+    rm -rf /tmp/mise /tmp/mise.tar.gz; \
+    mise --version
+
+# Toolchains land outside $HOME so an EFS mount can be pointed here to cache
+# them across sessions. Without that mount every run reinstalls, which is the
+# main cost of this design; with it, the second run of any version is instant.
+ENV MISE_DATA_DIR=/opt/mise \
+    MISE_CACHE_DIR=/opt/mise/cache \
+    PATH=/opt/mise/shims:/usr/local/bin:$PATH
+
+# Trust configs from anywhere. mise otherwise refuses to read a .tool-versions
+# it has not been told to trust, and in a disposable microVM cloning an
+# arbitrary repository there is no prior trust to establish -- the isolation
+# boundary is the VM, not the config file.
+ENV MISE_TRUSTED_CONFIG_PATHS=/ \
+    MISE_YES=1
+
+RUN mkdir -p /opt/mise /workspace
+WORKDIR /workspace

package/dist/assets/coding-agent/deploy/create_harness.py

@@ -0,0 +1,144 @@
+#!/usr/bin/env python3
+"""Create or update the AgentCore harness, and wait for it to reach READY.
+
+Called by deploy-harness.sh. A separate file rather than an inline heredoc so the
+error handling is readable and so it can be run on its own against an existing
+image.
+
+The AWS CLI has no create-harness -- verified on 2.36.19, where the harness
+operations are absent from `aws bedrock-agentcore-control help` while boto3 exposes
+them. That gap is how an earlier version of this project came to call
+InvokeAgentRuntime instead of InvokeHarness: the CLI was the reference, and the CLI
+does not know harnesses exist.
+
+Configuration arrives through the environment rather than argv so the shell caller
+does not have to quote a model id or an ARN.
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+import time
+
+import boto3
+from botocore.exceptions import ClientError
+
+READY_TIMEOUT_SECONDS = 300
+POLL_SECONDS = 5
+
+
+def env(name: str, default: str = "") -> str:
+    value = os.environ.get(name, default)
+    if not value:
+        sys.exit(f"{name} is required")
+    return value
+
+
+def find_existing(client, name: str) -> str | None:
+    """Return the harness id for `name`, or None.
+
+    Matched on name because that is what the caller controls; the id carries a
+    generated suffix (PrismCodingAgent-XC93iEIa7W) that nobody can predict, so
+    re-running the deploy would otherwise create a second harness every time.
+    """
+    paginator_token = None
+    while True:
+        kwargs = {"nextToken": paginator_token} if paginator_token else {}
+        page = client.list_harnesses(**kwargs)
+        for harness in page.get("harnesses", []):
+            if harness.get("harnessName") == name:
+                return harness["harnessId"]
+        paginator_token = page.get("nextToken")
+        if not paginator_token:
+            return None
+
+
+def describe(client, harness_id: str) -> dict:
+    """Fetch one harness, unwrapping the response envelope.
+
+    `get_harness` returns the object nested under a `harness` key, while
+    `list_harnesses` returns flat objects in `harnesses`. Reading `status` off the
+    top level of a get_harness response therefore yields None forever: the wait
+    below span its full timeout and then reported failure on a harness that had
+    been READY the whole time. The same mistake also made `maxIterations` look
+    unset on a harness that had it set to 40.
+    """
+    return client.get_harness(harnessId=harness_id).get("harness", {})
+
+
+def wait_ready(client, harness_id: str) -> None:
+    deadline = time.monotonic() + READY_TIMEOUT_SECONDS
+    last = ""
+    while time.monotonic() < deadline:
+        status = describe(client, harness_id).get("status", "")
+        if status == "READY":
+            return
+        if status in {"CREATE_FAILED", "UPDATE_FAILED", "FAILED"}:
+            sys.exit(f"harness {harness_id} reached {status}")
+        if status != last:
+            print(f"    status {status or 'unknown'}", file=sys.stderr)
+            last = status
+        time.sleep(POLL_SECONDS)
+    sys.exit(f"harness {harness_id} did not reach READY within "
+             f"{READY_TIMEOUT_SECONDS}s (last status {last or 'unknown'})")
+
+
+def main() -> int:
+    region = env("AGENTCORE_REGION")
+    name = env("AGENTCORE_NAME")
+    image = env("AGENTCORE_IMAGE")
+    role = env("AGENTCORE_ROLE")
+    model = env("AGENTCORE_MODEL")
+    max_iterations = int(env("AGENTCORE_MAX_ITERATIONS", "100"))
+    timeout_seconds = int(env("AGENTCORE_TIMEOUT", "1800"))
+
+    client = boto3.client("bedrock-agentcore-control", region_name=region)
+
+    spec = {
+        "model": {
+            "bedrockModelConfig": {
+                "modelId": model,
+                "maxTokens": 8192,
+                # Zero, because the task is to reproduce a defect and fix it, not
+                # to be inventive about what the defect might be.
+                "temperature": 0.0,
+            }
+        },
+        "environmentArtifact": {"containerConfiguration": {"containerUri": image}},
+        "executionRoleArn": role,
+        "maxIterations": max_iterations,
+        "timeoutSeconds": timeout_seconds,
+    }
+
+    existing = find_existing(client, name)
+    try:
+        if existing:
+            print(f"    updating {existing}", file=sys.stderr)
+            client.update_harness(harnessId=existing, **spec)
+            harness_id = existing
+        else:
+            print(f"    creating {name}", file=sys.stderr)
+            created = client.create_harness(harnessName=name, **spec)
+            harness_id = created["harnessId"]
+    except ClientError as exc:
+        code = exc.response.get("Error", {}).get("Code", "")
+        message = exc.response.get("Error", {}).get("Message", str(exc))
+        if code == "AccessDeniedException":
+            sys.exit(f"{code}: {message}\n"
+                     f"  The calling identity needs bedrock-agentcore:CreateHarness /\n"
+                     f"  UpdateHarness / ListHarnesses, and iam:PassRole for {role}.")
+        sys.exit(f"{code}: {message}")
+
+    wait_ready(client, harness_id)
+
+    # The invocable ARN is the harness ARN. Its DEFAULT endpoint also exists and is
+    # READY, and passing that endpoint ARN to InvokeHarness is rejected -- worth
+    # stating because the endpoint being present makes it look like the right thing
+    # to use.
+    print(describe(client, harness_id)["arn"])
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())