ai-push-hooks 0.2.1 → 0.3.0

package/src/ai_push_hooks/executors/{llm.py → ask.py}

@@ -17,11 +17,16 @@ from ..paths import (
     write_text_no_follow,
 )
 from ..types import HookError, RuntimeContext, StepConfig
-from .exec import ensure_dir, extract_pr_url, resolve_storage_path, run_command
+from .exec import ensure_dir, resolve_storage_path, run_command
 
 OPENCODE_READ_ONLY_AGENT = "ai-push-hooks-readonly"
 OPENCODE_APPLY_AGENT = "ai-push-hooks-apply"
 OPENCODE_AGENT_POLICIES = frozenset({"read-only", "apply"})
+# A sentinel keeps the legacy helper's implicit flat-config behavior while
+# allowing the runner boundary to explicitly pass ``None`` and omit optional
+# OpenCode flags.
+_DEFAULT_MODEL = object()
+_DEFAULT_VARIANT = object()
 PROVIDER_ENV_PREFIXES = (
     "ANTHROPIC_",
     "AWS_",
@@ -270,11 +275,11 @@ def export_opencode_session_json(
     return True
 
 
-def delete_opencode_session(context: RuntimeContext, session_id: str) -> None:
+def delete_opencode_session(context: RuntimeContext, session_id: str) -> bool:
     with tempfile.TemporaryDirectory(
         prefix="ai-push-hooks-session-delete-"
     ) as temporary_directory:
-        run_command(
+        completed = run_command(
             [
                 context.opencode_executable or resolve_opencode_executable(),
                 "session",
@@ -288,6 +293,7 @@ def delete_opencode_session(context: RuntimeContext, session_id: str) -> None:
             env=opencode_isolation_env(context, non_agent_opencode_config(), "session-delete"),
             inherit_env=False,
         )
+    return completed.returncode == 0
 
 
 def finalize_opencode_session(context: RuntimeContext, stage_name: str, session_id: str | None) -> None:
@@ -334,6 +340,7 @@ def build_opencode_security_config(
     allow_paths: tuple[str, ...] = (),
     *,
     non_vcs_working_directory: pathlib.Path | None = None,
+    project_read_root: pathlib.Path | None = None,
 ) -> tuple[str, dict[str, Any]]:
     permissions: dict[str, Any] = {
         "*": "deny",
@@ -351,6 +358,7 @@ def build_opencode_security_config(
         "skill": "deny",
         "todowrite": "deny",
         "question": "deny",
+        "doom_loop": "deny",
     }
     if agent_policy == "read-only":
         agent_name = OPENCODE_READ_ONLY_AGENT
@@ -395,6 +403,31 @@ def build_opencode_security_config(
     else:
         raise HookError(f"Unsupported OpenCode agent policy: {agent_policy}")
 
+    if project_read_root is not None:
+        # OpenCode's file permission matcher uses paths relative to its
+        # filesystem worktree.  A real Git checkout is already rooted at the
+        # requested worktree, so absolute filesystem-root-relative patterns
+        # would never match README.md-style tool paths.  A non-VCS projection
+        # is treated as a filesystem worktree rooted at `/`, so qualify those
+        # patterns with the projection's absolute prefix.
+        root = project_read_root.resolve(strict=False)
+        if (root / ".git").exists():
+            rooted_permissions: str | dict[str, str] = "allow"
+        else:
+            anchor = pathlib.Path(root.anchor)
+            prefix = root.relative_to(anchor).as_posix()
+            rooted_permissions = {
+                "*": "deny",
+                prefix: "allow",
+                f"{prefix}/**": "allow",
+            }
+        for tool in ("read", "list", "glob", "grep"):
+            permissions[tool] = (
+                dict(rooted_permissions)
+                if isinstance(rooted_permissions, dict)
+                else rooted_permissions
+            )
+
     return agent_name, {
         "$schema": "https://opencode.ai/config.json",
         "plugin": [],
@@ -446,6 +479,9 @@ def call_opencode(
     attempt: int | None = None,
     total_attempts: int | None = None,
     existing_session_id: str | None = None,
+    model: str | None | object = _DEFAULT_MODEL,
+    variant: str | None | object = _DEFAULT_VARIANT,
+    project_access: str = "artifacts",
 ) -> OpenCodeRunResult:
     """Run OpenCode with a policy-specific isolated working directory.
 
@@ -461,6 +497,10 @@ def call_opencode(
         raise HookError("OpenCode apply agent requires an isolated staging directory")
     if agent == "read-only" and allow_paths:
         raise HookError("OpenCode read-only agent does not accept write paths")
+    if project_access not in {"artifacts", "project"}:
+        raise HookError(f"Unsupported OpenCode project access: {project_access}")
+    if project_access == "project" and working_directory is None:
+        raise HookError("OpenCode project access requires an explicit working directory")
 
     validated_files = validate_opencode_attachments(context, files)
     if working_directory is None:
@@ -482,9 +522,18 @@ def call_opencode(
         non_vcs_working_directory=(
             resolved_working_directory if agent == "apply" else None
         ),
+        project_read_root=(
+            resolved_working_directory if project_access == "project" else None
+        ),
     )
     executable = context.opencode_executable or resolve_opencode_executable()
-    context.logger.llm_call(stage_name, purpose, context.config.llm.model, attempt, total_attempts)
+    effective_model = (
+        context.config.llm.model if model is _DEFAULT_MODEL else model
+    )
+    effective_variant = (
+        context.config.llm.variant if variant is _DEFAULT_VARIANT else variant
+    )
+    context.logger.llm_call(stage_name, purpose, effective_model or "", attempt, total_attempts)
     isolated_env = opencode_isolation_env(context, security_config, stage_name)
     cmd = [
         executable,
@@ -494,11 +543,11 @@ def call_opencode(
         "--pure",
         "--format",
         "json",
-        "--model",
-        context.config.llm.model,
     ]
-    if context.config.llm.variant:
-        cmd.extend(["--variant", context.config.llm.variant])
+    if effective_model:
+        cmd.extend(["--model", effective_model])
+    if effective_variant:
+        cmd.extend(["--variant", effective_variant])
     if existing_session_id:
         cmd.extend(["--session", existing_session_id])
     else:
@@ -529,8 +578,11 @@ def call_opencode(
     session_id, text_output = parse_opencode_json_run_output(completed.stdout or "")
     stdout = completed.stdout or ""
     stderr = completed.stderr or ""
-    if context.config.logging.print_llm_output and stdout.strip():
-        print(stdout)
+    if context.config.logging.print_llm_output and text_output:
+        # Print normalized assistant text only.  OpenCode's JSONL stream can
+        # contain provider diagnostics and tool payloads which must not become
+        # an accidental credential/prompt log.
+        print(text_output)
     return OpenCodeRunResult(
         output_text=text_output if text_output else stdout.strip(),
         session_id=session_id or existing_session_id,
@@ -540,85 +592,156 @@ def call_opencode(
     )
 
 
-def run_llm_step(
+def _safe_invalid_output(invocation: Any, output: str) -> str:
+    from .runners.contracts import request_sensitive_diagnostics
+
+    request = invocation.request
+    return request_sensitive_diagnostics(request, output, max_chars=400, env=os.environ)
+
+
+def run_ask_step(
     context: RuntimeContext,
     step: StepConfig,
     prompt: str,
     input_paths: list[pathlib.Path],
     stage_name: str,
 ) -> Any:
+    from .runner_workflow import _finalize_invocation, _invoke_runner, _named_error
+    from ..config import resolve_runner_profile
+
     total_attempts = context.config.llm.json_max_retries + 1
-    session_id: str | None = None
     prompt_text = prompt
     last_error = ""
     last_output = ""
     wants_json = bool(step.schema)
     expects_json_array = step.schema in {"string_array", "docs_issue_array"}
-    for attempt in range(1, total_attempts + 1):
-        try:
-            result = call_opencode(
+    session_id: str | None = None
+    resume_session = False
+    selected_profile = step.runner or context.config.llm.runner
+    try:
+        profile = resolve_runner_profile(context.config, step)
+    except Exception as exc:  # noqa: BLE001
+        raise _named_error(selected_profile, "unknown", stage_name, exc) from exc
+    retained_invocation = None
+
+    # Artifact-only analysis must retain its historical empty scratch cwd;
+    # project-aware analysis gets the actual checkout root so the adapter can
+    # provide the selected runner's project-read behavior.
+    if profile.project_access == "project":
+        working_directory = context.repo_root.resolve(strict=True)
+        temporary_directory = None
+    else:
+        temporary_directory = tempfile.TemporaryDirectory(prefix="ai-push-hooks-ask-")
+        working_directory = pathlib.Path(temporary_directory.name).resolve(strict=True)
+
+    try:
+        for attempt in range(1, total_attempts + 1):
+            invocation = _invoke_runner(
                 context,
-                stage_name=stage_name,
-                purpose=f"{step.type}:{step.id}",
-                prompt=prompt_text,
-                files=input_paths,
-                agent="read-only",
+                step,
+                prompt_text,
+                input_paths,
+                stage_name,
+                working_directory=working_directory,
+                session_id=session_id,
+                resume_session=resume_session,
                 attempt=attempt,
                 total_attempts=total_attempts,
-                existing_session_id=session_id,
+                prior_invocation=retained_invocation,
             )
-        except Exception:  # noqa: BLE001
-            finalize_opencode_session(context, stage_name, session_id)
-            raise
-        session_id = result.session_id
-        if result.return_code != 0:
-            finalize_opencode_session(context, stage_name, session_id)
-            details = result.stderr.strip() or result.stdout.strip() or f"exit code {result.return_code}"
-            raise HookError(f"OpenCode command failed: {details}")
-        try:
-            if not wants_json:
-                payload = result.output_text
-            else:
-                if expects_json_array:
-                    payload = extract_json_array(result.output_text)
+            retained_invocation = None
+            result = invocation.result
+            try:
+                if not wants_json:
+                    payload = result.final_text
                 else:
-                    payload = extract_json_object(result.output_text)
-                payload = validate_schema(step.schema, payload)
-        except HookError as exc:
-            last_error = str(exc)
-            last_output = result.output_text
-            if attempt >= total_attempts:
-                finalize_opencode_session(context, stage_name, session_id)
-                raise HookError(
-                    f"Model failed to return valid JSON for {stage_name}: "
-                    f"{last_error}. {last_output[:400]}"
-                ) from exc
-            snippet = last_output[: context.config.llm.invalid_json_feedback_max_chars]
-            if expects_json_array:
-                suffix = "Return ONLY valid JSON array."
-            else:
-                suffix = "Return ONLY valid JSON object."
-            prompt_text = (
-                prompt
-                + "\n\nIMPORTANT: Your previous response was invalid JSON and could not be parsed.\n"
-                + f"Parse error: {last_error}\n"
-                + suffix
-                + "\nPrevious invalid output:\n```text\n"
-                + snippet
-                + "\n```"
-            )
-            if context.config.llm.json_retry_new_session:
-                finalize_opencode_session(context, stage_name, session_id)
-                session_id = None
-            pr_url = extract_pr_url(last_output)
-            if pr_url:
-                context.logger.info(
-                    "llm.invalid_json_pr_url_hint",
-                    "Detected PR URL in invalid JSON output",
-                    stage_name=stage_name,
-                    url=pr_url,
+                    if expects_json_array:
+                        payload = extract_json_array(result.final_text)
+                    else:
+                        payload = extract_json_object(result.final_text)
+                    payload = validate_schema(step.schema, payload)
+            except HookError as exc:
+                last_error = str(exc)
+                last_output = result.final_text
+                if attempt >= total_attempts:
+                    _finalize_invocation(context, invocation, failed=True)
+                    safe_error = _safe_invalid_output(invocation, last_error)
+                    raise HookError(
+                        f"Runner profile `{profile.name}` ({profile.type}) failed at stage "
+                        f"`{stage_name}`: invalid JSON: {safe_error}. "
+                        f"{_safe_invalid_output(invocation, last_output)}"
+                    ) from exc
+
+                snippet = last_output[: context.config.llm.invalid_json_feedback_max_chars]
+                suffix = (
+                    "Return ONLY valid JSON array."
+                    if expects_json_array
+                    else "Return ONLY valid JSON object."
                 )
-            continue
-        finalize_opencode_session(context, stage_name, session_id)
-        return payload
-    raise HookError(f"Model failed to return valid JSON for {stage_name}")  # pragma: no cover
+                prompt_text = (
+                    prompt
+                    + "\n\nIMPORTANT: Your previous response was invalid JSON and could not be parsed.\n"
+                    + f"Parse error: {last_error}\n"
+                    + suffix
+                    + "\nPrevious invalid output:\n```text\n"
+                    + snippet
+                    + "\n```"
+                )
+
+                session = result.session
+                can_resume = bool(
+                    getattr(getattr(invocation.runner, "capabilities", None), "supports_resume", False)
+                    and session is not None
+                    and session.session_id
+                    and session.resumable
+                )
+                if context.config.llm.json_retry_new_session or not can_resume:
+                    if not session or not session.session_id:
+                        retry_reason = "session absent"
+                    elif context.config.llm.json_retry_new_session:
+                        retry_reason = "fresh session configured"
+                    else:
+                        retry_reason = "runner does not support resume"
+                    retry_message = "Retrying with a fresh runner invocation."
+                    if retry_reason == "runner does not support resume":
+                        retry_message = (
+                            "Retrying with a fresh runner invocation; unsupported session reuse."
+                        )
+                    elif retry_reason == "session absent":
+                        retry_message = (
+                            "Retrying with a fresh runner invocation; no reusable session was captured."
+                        )
+                    context.logger.status(
+                        "llm.retry_fresh_session",
+                        retry_message,
+                        stage_name=stage_name,
+                        runner_profile=profile.name,
+                        runner_type=profile.type,
+                        reason=retry_reason,
+                    )
+                    _finalize_invocation(context, invocation, failed=True)
+                    session_id = None
+                    resume_session = False
+                else:
+                    # Keep the exact captured session ID.  Do not invent a
+                    # provider-specific resume command for completion output.
+                    session_id = session.session_id
+                    resume_session = True
+                    retained_invocation = invocation
+                    # The invocation itself completed, although its response
+                    # failed downstream validation; report truthful metadata
+                    # before reusing the retained session.
+                    from .runner_workflow import _completion
+
+                    _completion(context, invocation, failed=True)
+                continue
+
+            _finalize_invocation(context, invocation, failed=False)
+            return payload
+        raise HookError(
+            f"Runner profile `{profile.name}` ({profile.type}) failed at stage `{stage_name}`: "
+            "model did not return a valid result"
+        )  # pragma: no cover
+    finally:
+        if temporary_directory is not None:
+            temporary_directory.cleanup()