opencode-bridge 0.3.0__tar.gz → 0.4.1__tar.gz

{opencode_bridge-0.3.0 → opencode_bridge-0.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: opencode-bridge
-Version: 0.3.0
+Version: 0.4.1
 Summary: MCP server for continuous OpenCode discussion sessions
 Project-URL: Repository, https://github.com/genomewalker/opencode-bridge
 Author: Antonio Fernandez-Guerra

{opencode_bridge-0.3.0 → opencode_bridge-0.4.1}/opencode_bridge/server.py

@@ -16,6 +16,7 @@ Configuration:
 """
 
 import os
+import re
 import json
 import asyncio
 import shutil
@@ -35,6 +36,13 @@ SMALL_FILE = 500        # lines
 MEDIUM_FILE = 1500      # lines
 LARGE_FILE = 5000       # lines
 
+# Chunked processing thresholds
+CHUNK_THRESHOLD = 2000   # lines — files above this get chunked
+CHUNK_SIZE = 800         # lines per chunk
+CHUNK_OVERLAP = 20       # overlap between adjacent chunks
+MAX_PARALLEL_CHUNKS = 6  # concurrency limit
+MAX_TOTAL_CHUNKS = 20    # safety cap
+
 # Language detection by extension
 LANG_MAP = {
     ".py": "Python", ".js": "JavaScript", ".ts": "TypeScript", ".tsx": "TypeScript/React",
@@ -304,6 +312,174 @@ def build_companion_prompt(
     return "\n".join(parts)
 
 
+# ---------------------------------------------------------------------------
+# Chunked Processing — map-reduce for large files
+# ---------------------------------------------------------------------------
+
+# Regex for natural code boundaries (language-agnostic)
+_BOUNDARY_RE = re.compile(
+    r"^(?:\s*$"                     # blank line
+    r"|(?:def |class |function |func |fn |pub fn |impl |module |package )"  # definitions
+    r"|(?:})\s*$"                   # closing brace on its own line
+    r"|(?://|#|/\*|\*/).{0,80}$"   # comment lines
+    r")",
+    re.MULTILINE,
+)
+
+
+def chunk_file(
+    filepath: str,
+    chunk_size: int = CHUNK_SIZE,
+    overlap: int = CHUNK_OVERLAP,
+) -> list[dict]:
+    """Split a file into overlapping chunks with boundary snapping.
+
+    Returns a list of dicts with keys:
+        chunk_index, total_chunks, start_line, end_line, content, filepath
+    """
+    p = Path(filepath)
+    try:
+        lines = p.read_text(errors="replace").splitlines(keepends=True)
+    except Exception:
+        return []
+
+    total = len(lines)
+    if total == 0:
+        return []
+    if total <= chunk_size:
+        return [{
+            "chunk_index": 0,
+            "total_chunks": 1,
+            "start_line": 1,
+            "end_line": total,
+            "content": "".join(lines),
+            "filepath": str(p),
+        }]
+
+    chunks: list[dict] = []
+    pos = 0
+    while pos < total:
+        end = min(pos + chunk_size, total)
+
+        # Snap to a natural boundary within ±50 lines of the cut point
+        if end < total:
+            best = end
+            scan_start = max(end - 50, pos + chunk_size // 2)
+            scan_end = min(end + 50, total)
+            for i in range(scan_start, scan_end):
+                if _BOUNDARY_RE.match(lines[i]):
+                    best = i + 1  # include the boundary line in this chunk
+                    break
+            end = best
+
+        chunk_content = "".join(lines[pos:end])
+        chunks.append({
+            "chunk_index": len(chunks),
+            "total_chunks": -1,  # filled in below
+            "start_line": pos + 1,  # 1-indexed
+            "end_line": end,
+            "content": chunk_content,
+            "filepath": str(p),
+        })
+
+        # Advance: overlap with previous chunk, but stop if we've reached the end
+        if end >= total:
+            break
+        pos = max(end - overlap, pos + 1)
+
+    # Fill in total_chunks
+    for c in chunks:
+        c["total_chunks"] = len(chunks)
+
+    return chunks
+
+
+def build_chunk_prompt(
+    user_prompt: str,
+    chunk_info: dict,
+    file_info: dict,
+    mode: str = "discuss",
+) -> str:
+    """Build a focused prompt for analyzing a single file chunk."""
+    name = file_info.get("name", Path(chunk_info["filepath"]).name)
+    language = file_info.get("language", "Unknown")
+    total_lines = file_info.get("lines", "?")
+    idx = chunk_info["chunk_index"] + 1
+    total = chunk_info["total_chunks"]
+    start = chunk_info["start_line"]
+    end = chunk_info["end_line"]
+
+    parts = [
+        f"You are analyzing **chunk {idx} of {total}** from `{name}` "
+        f"({language}, {total_lines} total lines).",
+        f"This chunk covers **lines {start}–{end}**.",
+        "",
+        "## Task",
+        user_prompt,
+        "",
+        "## Instructions",
+        "- Focus ONLY on the code in this chunk",
+        "- Note any references to code that might exist outside this chunk",
+        "- Be concise — your output will be combined with analyses of other chunks",
+        "- Include line numbers for any issues found",
+    ]
+
+    if mode == "review":
+        parts.append("- Categorize findings as: bug, security, design, performance, or style")
+
+    return "\n".join(parts)
+
+
+def build_synthesis_prompt(
+    user_prompt: str,
+    chunk_results: list[dict],
+    file_infos: list[dict],
+    mode: str = "discuss",
+) -> str:
+    """Build a prompt that merges chunk analyses into one coherent response."""
+    file_desc = ", ".join(
+        f"`{i.get('name', '?')}` ({i.get('lines', '?')} lines)"
+        for i in file_infos
+    )
+    n = len(chunk_results)
+
+    parts = [
+        f"You analyzed a large file in **{n} chunks**. "
+        "Synthesize the chunk analyses below into one coherent response.",
+        "",
+        "## Original Request",
+        user_prompt,
+        "",
+        "## Files Analyzed",
+        file_desc,
+        "",
+        "## Chunk Analyses",
+    ]
+
+    for cr in sorted(chunk_results, key=lambda c: c.get("chunk_index", 0)):
+        idx = cr.get("chunk_index", 0) + 1
+        fp = Path(cr.get("file", "")).name
+        response = cr.get("response", "[analysis failed]")
+        if cr.get("error"):
+            response = f"[analysis failed: {cr['error']}]"
+        parts.append(f"\n### Chunk {idx} — `{fp}`")
+        parts.append(response)
+
+    parts.extend([
+        "",
+        "## Instructions",
+        "- Combine findings and remove duplicates (chunks overlap slightly)",
+        "- Organize by importance, not by chunk order",
+        "- Preserve line number references from the original analyses",
+        "- Provide an overall assessment at the top",
+    ])
+
+    if mode == "review":
+        parts.append("- Group findings by category: bugs, security, design, performance, style")
+
+    return "\n".join(parts)
+
+
 # Default configuration
 DEFAULT_MODEL = "openai/gpt-5.2-codex"
 DEFAULT_AGENT = "plan"
@@ -470,6 +646,182 @@ class OpenCodeBridge:
         except Exception as e:
             return f"Error: {e}", 1
 
+    @staticmethod
+    def _parse_opencode_response(output: str) -> tuple[str, Optional[str]]:
+        """Parse JSON-lines output from opencode CLI.
+
+        Returns (reply_text, session_id).
+        """
+        reply_parts: list[str] = []
+        session_id: Optional[str] = None
+        for line in output.split("\n"):
+            if not line:
+                continue
+            try:
+                event = json.loads(line)
+                if not session_id and "sessionID" in event:
+                    session_id = event["sessionID"]
+                if event.get("type") == "text":
+                    text = event.get("part", {}).get("text", "")
+                    if text:
+                        reply_parts.append(text)
+            except json.JSONDecodeError:
+                continue
+        return "".join(reply_parts), session_id
+
+    async def _run_chunk(
+        self,
+        chunk_info: dict,
+        file_info: dict,
+        user_prompt: str,
+        session: "Session",
+        mode: str = "discuss",
+    ) -> dict:
+        """Process a single file chunk through OpenCode (stateless)."""
+        result = {
+            "chunk_index": chunk_info["chunk_index"],
+            "file": chunk_info["filepath"],
+            "response": "",
+            "error": None,
+        }
+
+        # Write chunk to a temp file preserving the original extension
+        ext = Path(chunk_info["filepath"]).suffix or ".txt"
+        tmp = None
+        try:
+            tmp = tempfile.NamedTemporaryFile(
+                mode="w", suffix=ext, delete=False, prefix="opencode_chunk_"
+            )
+            tmp.write(chunk_info["content"])
+            tmp.close()
+
+            prompt = build_chunk_prompt(user_prompt, chunk_info, file_info, mode)
+
+            args = [
+                "run", prompt,
+                "--model", session.model,
+                "--agent", session.agent,
+                "--file", tmp.name,
+                "--format", "json",
+            ]
+            if session.variant:
+                args.extend(["--variant", session.variant])
+
+            output, code = await self._run_opencode(*args, timeout=300)
+
+            if code != 0:
+                result["error"] = output[:500]
+                return result
+
+            reply, _ = self._parse_opencode_response(output)
+            result["response"] = reply or "[no response]"
+
+        except Exception as e:
+            result["error"] = str(e)
+        finally:
+            if tmp:
+                try:
+                    os.unlink(tmp.name)
+                except OSError:
+                    pass
+        return result
+
+    async def _run_chunked(
+        self,
+        user_prompt: str,
+        files: list[str],
+        session: "Session",
+        mode: str = "discuss",
+    ) -> str:
+        """Map-reduce orchestrator: chunk large files, process in parallel, synthesize."""
+        small_files: list[str] = []
+        all_chunks: list[tuple[dict, dict]] = []  # (chunk_info, file_info)
+
+        for f in files:
+            info = get_file_info(f)
+            line_count = info.get("lines", 0)
+            if line_count > CHUNK_THRESHOLD:
+                chunks = chunk_file(f, CHUNK_SIZE, CHUNK_OVERLAP)
+                for c in chunks:
+                    all_chunks.append((c, info))
+            else:
+                small_files.append(f)
+
+        # Safety: if too many chunks, increase chunk size and re-chunk
+        if len(all_chunks) > MAX_TOTAL_CHUNKS:
+            all_chunks = []
+            bigger = CHUNK_SIZE * 2
+            for f in files:
+                info = get_file_info(f)
+                if info.get("lines", 0) > CHUNK_THRESHOLD:
+                    chunks = chunk_file(f, bigger, CHUNK_OVERLAP)
+                    for c in chunks:
+                        all_chunks.append((c, info))
+                # small_files already collected above
+
+        if not all_chunks:
+            return "No chunks to process."
+
+        # --- Map phase: run chunks in parallel ---
+        sem = asyncio.Semaphore(MAX_PARALLEL_CHUNKS)
+
+        async def _limited(chunk_info: dict, file_info: dict) -> dict:
+            async with sem:
+                return await self._run_chunk(chunk_info, file_info, user_prompt, session, mode)
+
+        tasks = [_limited(ci, fi) for ci, fi in all_chunks]
+        chunk_results: list[dict] = await asyncio.gather(*tasks)
+
+        # Check failure rate
+        failed = sum(1 for cr in chunk_results if cr.get("error"))
+        if failed > len(chunk_results) / 2:
+            return (
+                f"Chunked analysis failed: {failed}/{len(chunk_results)} chunks errored. "
+                "Try with a smaller file or increase the chunk size."
+            )
+
+        # --- Reduce phase: synthesize ---
+        file_infos = []
+        seen_paths: set[str] = set()
+        for _, fi in all_chunks:
+            fp = fi.get("path", "")
+            if fp not in seen_paths:
+                seen_paths.add(fp)
+                file_infos.append(fi)
+
+        synthesis_prompt = build_synthesis_prompt(user_prompt, chunk_results, file_infos, mode)
+
+        # Attach small files for reference context (not the large ones)
+        args = [
+            "run", synthesis_prompt,
+            "--model", session.model,
+            "--agent", session.agent,
+            "--format", "json",
+        ]
+        if session.variant:
+            args.extend(["--variant", session.variant])
+        for sf in small_files:
+            args.extend(["--file", sf])
+
+        # Longer timeout for synthesis
+        output, code = await self._run_opencode(*args, timeout=600)
+
+        if code != 0:
+            # Fallback: concatenate raw chunk results
+            parts = ["*Synthesis failed — showing raw chunk analyses:*\n"]
+            for cr in sorted(chunk_results, key=lambda c: c.get("chunk_index", 0)):
+                idx = cr.get("chunk_index", 0) + 1
+                fp = Path(cr.get("file", "")).name
+                parts.append(f"\n### Chunk {idx} — `{fp}`")
+                if cr.get("error"):
+                    parts.append(f"[error: {cr['error']}]")
+                else:
+                    parts.append(cr.get("response", "[no response]"))
+            return "\n".join(parts)
+
+        reply, _ = self._parse_opencode_response(output)
+        return reply or "No response from synthesis."
+
     async def list_models(self, provider: Optional[str] = None) -> str:
         """List available models from OpenCode."""
         args = ["models"]
@@ -599,6 +951,27 @@ Set via:
         temp_file.close()
         files = (files or []) + [temp_file.name]
 
+        # --- Chunking gate: large user files get map-reduce processing ---
+        user_files = [f for f in files if not Path(f).name.startswith("opencode_msg_")]
+        needs_chunking = any(
+            get_file_info(f).get("lines", 0) > CHUNK_THRESHOLD
+            for f in user_files
+        )
+
+        if needs_chunking:
+            reply = await self._run_chunked(message, user_files, session, mode="discuss")
+            # Cleanup temp file
+            try:
+                os.unlink(temp_file.name)
+            except OSError:
+                pass
+            if reply:
+                session.add_message("assistant", reply)
+                session.save(self.sessions_dir / f"{sid}.json")
+            return reply or "No response received"
+
+        # --- Normal (non-chunked) path ---
+
         # Build prompt: companion system unless _raw is set
         if _raw:
             run_prompt = build_message_prompt(message, files)
@@ -631,7 +1004,6 @@ Set via:
         args.extend(["--format", "json"])
 
         # Scale timeout based on attached file size
-        user_files = [f for f in files if not Path(f).name.startswith("opencode_msg_")]
         total_lines = sum(get_file_info(f).get("lines", 0) for f in user_files)
         # Base 300s, +60s per 1000 lines above threshold, capped at 900s
         timeout = min(900, 300 + max(0, (total_lines - MEDIUM_FILE) * 60 // 1000))
@@ -649,22 +1021,10 @@ Set via:
             return f"Error: {output}"
 
         # Parse JSON events for session ID and text
-        reply_parts = []
-        for line in output.split("\n"):
-            if not line:
-                continue
-            try:
-                event = json.loads(line)
-                if not session.opencode_session_id and "sessionID" in event:
-                    session.opencode_session_id = event["sessionID"]
-                if event.get("type") == "text":
-                    text = event.get("part", {}).get("text", "")
-                    if text:
-                        reply_parts.append(text)
-            except json.JSONDecodeError:
-                continue
+        reply, new_session_id = self._parse_opencode_response(output)
+        if new_session_id and not session.opencode_session_id:
+            session.opencode_session_id = new_session_id
 
-        reply = "".join(reply_parts)
         if reply:
             session.add_message("assistant", reply)
 
@@ -737,10 +1097,16 @@ Set via:
             files = file_paths
             file_infos = [get_file_info(f) for f in file_paths]
             file_infos = [i for i in file_infos if i]
+            total_lines = sum(i.get("lines", 0) for i in file_infos)
+
+            # Chunking gate for large reviews
+            if total_lines > CHUNK_THRESHOLD:
+                prompt = build_review_prompt(file_infos, focus)
+                return await self._run_chunked(prompt, file_paths, self.sessions[sid], mode="review")
+
             prompt = build_review_prompt(file_infos, focus)
 
             # Increase timeout for large files
-            total_lines = sum(i.get("lines", 0) for i in file_infos)
             if total_lines > LARGE_FILE:
                 # Use variant=high for large reviews if not already high+
                 session = self.sessions[sid]

{opencode_bridge-0.3.0 → opencode_bridge-0.4.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "opencode-bridge"
-version = "0.3.0"
+version = "0.4.1"
 description = "MCP server for continuous OpenCode discussion sessions"
 readme = "README.md"
 license = "MIT"

opencode_bridge-0.4.1/tests/test_chunking.py

@@ -0,0 +1,630 @@
+"""Tests for chunked subagent processing of large files."""
+
+import json
+import tempfile
+import textwrap
+from pathlib import Path
+from unittest.mock import AsyncMock, patch
+
+import pytest
+
+from opencode_bridge.server import (
+    CHUNK_OVERLAP,
+    CHUNK_SIZE,
+    CHUNK_THRESHOLD,
+    MAX_TOTAL_CHUNKS,
+    OpenCodeBridge,
+    build_chunk_prompt,
+    build_synthesis_prompt,
+    chunk_file,
+    get_file_info,
+    _file_info_cache,
+)
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+def _make_file(lines: int, *, with_boundaries: bool = False) -> str:
+    """Create a temp file with the given number of lines. Returns its path."""
+    tmp = tempfile.NamedTemporaryFile(
+        mode="w", suffix=".py", delete=False, prefix="test_chunk_"
+    )
+    for i in range(1, lines + 1):
+        if with_boundaries and i % 200 == 0:
+            tmp.write(f"\ndef function_{i}():\n")
+        else:
+            tmp.write(f"# line {i}\n")
+    tmp.close()
+    return tmp.name
+
+
+# ---------------------------------------------------------------------------
+# chunk_file
+# ---------------------------------------------------------------------------
+
+class TestChunkFile:
+    def test_small_file_single_chunk(self):
+        path = _make_file(100)
+        chunks = chunk_file(path, chunk_size=CHUNK_SIZE)
+        assert len(chunks) == 1
+        assert chunks[0]["chunk_index"] == 0
+        assert chunks[0]["total_chunks"] == 1
+        assert chunks[0]["start_line"] == 1
+        assert chunks[0]["end_line"] == 100
+
+    def test_large_file_multiple_chunks(self):
+        path = _make_file(2500)
+        chunks = chunk_file(path, chunk_size=800, overlap=20)
+        assert len(chunks) > 1
+        # All chunks should reference the same file
+        for c in chunks:
+            assert c["filepath"] == path
+            assert c["total_chunks"] == len(chunks)
+
+    def test_chunks_cover_full_file(self):
+        path = _make_file(3000)
+        chunks = chunk_file(path, chunk_size=800, overlap=20)
+        # First chunk starts at line 1
+        assert chunks[0]["start_line"] == 1
+        # Last chunk ends at the file's last line
+        assert chunks[-1]["end_line"] == 3000
+
+    def test_chunk_overlap(self):
+        path = _make_file(2000)
+        chunks = chunk_file(path, chunk_size=800, overlap=20)
+        for i in range(1, len(chunks)):
+            prev_end = chunks[i - 1]["end_line"]
+            cur_start = chunks[i]["start_line"]
+            # The start of the next chunk should overlap with the end of the previous
+            assert cur_start <= prev_end, (
+                f"Chunk {i} starts at {cur_start} but previous ends at {prev_end}"
+            )
+
+    def test_boundary_snapping(self):
+        """Chunks should prefer cutting near function definitions."""
+        path = _make_file(2000, with_boundaries=True)
+        chunks = chunk_file(path, chunk_size=800, overlap=20)
+        # With boundaries every 200 lines, cuts should snap near those points
+        assert len(chunks) >= 2
+
+    def test_chunk_indices_sequential(self):
+        path = _make_file(3000)
+        chunks = chunk_file(path, chunk_size=800, overlap=20)
+        for i, c in enumerate(chunks):
+            assert c["chunk_index"] == i
+
+    def test_empty_file(self):
+        tmp = tempfile.NamedTemporaryFile(
+            mode="w", suffix=".py", delete=False, prefix="test_empty_"
+        )
+        tmp.close()
+        chunks = chunk_file(tmp.name)
+        assert chunks == []
+
+    def test_nonexistent_file(self):
+        chunks = chunk_file("/nonexistent/file.py")
+        assert chunks == []
+
+    def test_content_preserved(self):
+        path = _make_file(100)
+        chunks = chunk_file(path, chunk_size=800)
+        original = Path(path).read_text()
+        assert chunks[0]["content"] == original
+
+
+# ---------------------------------------------------------------------------
+# build_chunk_prompt
+# ---------------------------------------------------------------------------
+
+class TestBuildChunkPrompt:
+    def test_includes_chunk_metadata(self):
+        chunk_info = {
+            "chunk_index": 2,
+            "total_chunks": 5,
+            "start_line": 1601,
+            "end_line": 2400,
+            "content": "...",
+            "filepath": "/tmp/test.py",
+        }
+        file_info = {"name": "test.py", "language": "Python", "lines": 5000}
+        prompt = build_chunk_prompt("Review this code", chunk_info, file_info)
+        assert "chunk 3 of 5" in prompt
+        assert "lines 1601" in prompt
+        assert "2400" in prompt
+        assert "test.py" in prompt
+        assert "Python" in prompt
+        assert "5000" in prompt
+
+    def test_includes_user_prompt(self):
+        chunk_info = {
+            "chunk_index": 0, "total_chunks": 1,
+            "start_line": 1, "end_line": 100,
+            "content": "...", "filepath": "/tmp/x.py",
+        }
+        file_info = {"name": "x.py", "language": "Python", "lines": 100}
+        prompt = build_chunk_prompt("Find security bugs", chunk_info, file_info)
+        assert "Find security bugs" in prompt
+
+    def test_review_mode_adds_categories(self):
+        chunk_info = {
+            "chunk_index": 0, "total_chunks": 1,
+            "start_line": 1, "end_line": 100,
+            "content": "...", "filepath": "/tmp/x.py",
+        }
+        file_info = {"name": "x.py", "language": "Python", "lines": 100}
+        prompt = build_chunk_prompt("Review", chunk_info, file_info, mode="review")
+        assert "bug" in prompt.lower()
+        assert "security" in prompt.lower()
+
+    def test_discuss_mode_no_categories(self):
+        chunk_info = {
+            "chunk_index": 0, "total_chunks": 1,
+            "start_line": 1, "end_line": 100,
+            "content": "...", "filepath": "/tmp/x.py",
+        }
+        file_info = {"name": "x.py", "language": "Python", "lines": 100}
+        prompt = build_chunk_prompt("Explain this", chunk_info, file_info, mode="discuss")
+        assert "Categorize findings" not in prompt
+
+
+# ---------------------------------------------------------------------------
+# build_synthesis_prompt
+# ---------------------------------------------------------------------------
+
+class TestBuildSynthesisPrompt:
+    def test_includes_all_chunk_responses(self):
+        results = [
+            {"chunk_index": 0, "file": "/tmp/a.py", "response": "Found bug on line 10", "error": None},
+            {"chunk_index": 1, "file": "/tmp/a.py", "response": "Performance issue at line 900", "error": None},
+        ]
+        file_infos = [{"name": "a.py", "lines": 2000}]
+        prompt = build_synthesis_prompt("Review code", results, file_infos)
+        assert "Found bug on line 10" in prompt
+        assert "Performance issue at line 900" in prompt
+        assert "Chunk 1" in prompt
+        assert "Chunk 2" in prompt
+
+    def test_marks_failed_chunks(self):
+        results = [
+            {"chunk_index": 0, "file": "/tmp/a.py", "response": "OK", "error": None},
+            {"chunk_index": 1, "file": "/tmp/a.py", "response": "", "error": "timeout"},
+        ]
+        file_infos = [{"name": "a.py", "lines": 2000}]
+        prompt = build_synthesis_prompt("Review", results, file_infos)
+        assert "analysis failed" in prompt
+        assert "timeout" in prompt
+
+    def test_includes_original_request(self):
+        results = [{"chunk_index": 0, "file": "/tmp/a.py", "response": "OK", "error": None}]
+        file_infos = [{"name": "a.py", "lines": 100}]
+        prompt = build_synthesis_prompt("Find SQL injections", results, file_infos)
+        assert "Find SQL injections" in prompt
+
+    def test_review_mode_adds_grouping(self):
+        results = [{"chunk_index": 0, "file": "/tmp/a.py", "response": "OK", "error": None}]
+        file_infos = [{"name": "a.py", "lines": 100}]
+        prompt = build_synthesis_prompt("Review", results, file_infos, mode="review")
+        assert "Group findings by category" in prompt
+
+
+# ---------------------------------------------------------------------------
+# _parse_opencode_response
+# ---------------------------------------------------------------------------
+
+class TestParseOpenCodeResponse:
+    def test_extracts_text_and_session_id(self):
+        lines = [
+            json.dumps({"sessionID": "sess-123"}),
+            json.dumps({"type": "text", "part": {"text": "Hello "}}),
+            json.dumps({"type": "text", "part": {"text": "World"}}),
+        ]
+        output = "\n".join(lines)
+        text, sid = OpenCodeBridge._parse_opencode_response(output)
+        assert text == "Hello World"
+        assert sid == "sess-123"
+
+    def test_no_session_id(self):
+        lines = [
+            json.dumps({"type": "text", "part": {"text": "Just text"}}),
+        ]
+        output = "\n".join(lines)
+        text, sid = OpenCodeBridge._parse_opencode_response(output)
+        assert text == "Just text"
+        assert sid is None
+
+    def test_skips_invalid_json(self):
+        output = "not json\n" + json.dumps({"type": "text", "part": {"text": "OK"}})
+        text, sid = OpenCodeBridge._parse_opencode_response(output)
+        assert text == "OK"
+
+    def test_empty_output(self):
+        text, sid = OpenCodeBridge._parse_opencode_response("")
+        assert text == ""
+        assert sid is None
+
+
+# ---------------------------------------------------------------------------
+# Integration: chunking gate in send_message / review_code
+# ---------------------------------------------------------------------------
+
+def _mock_opencode_response(text: str, session_id: str = "mock-sess") -> str:
+    """Build a mock JSON-lines response from opencode."""
+    lines = [
+        json.dumps({"sessionID": session_id}),
+        json.dumps({"type": "text", "part": {"text": text}}),
+    ]
+    return "\n".join(lines)
+
+
+@pytest.fixture
+def bridge():
+    b = OpenCodeBridge()
+    return b
+
+
+class TestChunkingGateIntegration:
+    @pytest.mark.anyio
+    async def test_small_file_bypasses_chunking(self, bridge, tmp_path):
+        """Files under CHUNK_THRESHOLD should NOT trigger chunking."""
+        small = tmp_path / "small.py"
+        small.write_text("\n".join(f"# line {i}" for i in range(500)))
+
+        await bridge.start_session("test-small")
+
+        with patch.object(bridge, "_run_opencode", new_callable=AsyncMock) as mock_run:
+            mock_run.return_value = (_mock_opencode_response("review done"), 0)
+            with patch.object(bridge, "_run_chunked", new_callable=AsyncMock) as mock_chunked:
+                result = await bridge.send_message(
+                    "Review this", files=[str(small)]
+                )
+                mock_chunked.assert_not_called()
+                assert "review done" in result
+
+    @pytest.mark.anyio
+    async def test_large_file_triggers_chunking(self, bridge, tmp_path):
+        """Files over CHUNK_THRESHOLD should trigger _run_chunked."""
+        large = tmp_path / "large.py"
+        large.write_text("\n".join(f"# line {i}" for i in range(CHUNK_THRESHOLD + 100)))
+
+        await bridge.start_session("test-large")
+
+        with patch.object(bridge, "_run_chunked", new_callable=AsyncMock) as mock_chunked:
+            mock_chunked.return_value = "chunked analysis done"
+            result = await bridge.send_message(
+                "Review this", files=[str(large)]
+            )
+            mock_chunked.assert_called_once()
+            assert "chunked analysis done" in result
+
+    @pytest.mark.anyio
+    async def test_review_code_large_file_triggers_chunking(self, bridge, tmp_path):
+        """review_code should also route large files through chunking."""
+        large = tmp_path / "big.py"
+        large.write_text("\n".join(f"# line {i}" for i in range(CHUNK_THRESHOLD + 100)))
+
+        await bridge.start_session("test-review-large")
+
+        with patch.object(bridge, "_run_chunked", new_callable=AsyncMock) as mock_chunked:
+            mock_chunked.return_value = "chunked review done"
+            result = await bridge.review_code(str(large))
+            mock_chunked.assert_called_once()
+            assert "chunked review done" in result
+
+    @pytest.mark.anyio
+    async def test_review_code_small_file_no_chunking(self, bridge, tmp_path):
+        """Small files in review_code should not trigger chunking."""
+        small = tmp_path / "tiny.py"
+        small.write_text("\n".join(f"# line {i}" for i in range(200)))
+
+        await bridge.start_session("test-review-small")
+
+        with patch.object(bridge, "_run_opencode", new_callable=AsyncMock) as mock_run:
+            mock_run.return_value = (_mock_opencode_response("looks good"), 0)
+            with patch.object(bridge, "_run_chunked", new_callable=AsyncMock) as mock_chunked:
+                result = await bridge.review_code(str(small))
+                mock_chunked.assert_not_called()
+
+
+# ---------------------------------------------------------------------------
+# Integration: _run_chunked map-reduce
+# ---------------------------------------------------------------------------
+
+class TestRunChunked:
+    @pytest.mark.anyio
+    async def test_successful_chunked_processing(self, bridge, tmp_path):
+        """Full map-reduce pipeline with mocked _run_opencode."""
+        large = tmp_path / "big.py"
+        large.write_text("\n".join(f"# line {i}" for i in range(2500)))
+
+        await bridge.start_session("test-chunked")
+        session = bridge.sessions["test-chunked"]
+
+        call_count = 0
+
+        async def mock_run(*args, timeout=300):
+            nonlocal call_count
+            call_count += 1
+            # Chunk calls return chunk analysis; synthesis call returns final
+            return (_mock_opencode_response(f"analysis-{call_count}"), 0)
+
+        with patch.object(bridge, "_run_opencode", side_effect=mock_run):
+            result = await bridge._run_chunked(
+                "Review this code", [str(large)], session, mode="review"
+            )
+
+        # Should have made multiple calls (chunks + synthesis)
+        assert call_count > 2
+        assert result  # non-empty
+
+    @pytest.mark.anyio
+    async def test_majority_failure_returns_error(self, bridge, tmp_path):
+        """If >50% of chunks fail, return an error message."""
+        large = tmp_path / "big.py"
+        large.write_text("\n".join(f"# line {i}" for i in range(2500)))
+
+        await bridge.start_session("test-fail")
+        session = bridge.sessions["test-fail"]
+
+        # All calls fail
+        async def mock_fail(*args, timeout=300):
+            return ("error: context_length_exceeded", 1)
+
+        with patch.object(bridge, "_run_opencode", side_effect=mock_fail):
+            result = await bridge._run_chunked(
+                "Review", [str(large)], session
+            )
+
+        assert "failed" in result.lower()
+
+    @pytest.mark.anyio
+    async def test_synthesis_failure_falls_back(self, bridge, tmp_path):
+        """If synthesis fails, fall back to concatenated chunk results."""
+        large = tmp_path / "big.py"
+        large.write_text("\n".join(f"# line {i}" for i in range(2500)))
+
+        await bridge.start_session("test-fallback")
+        session = bridge.sessions["test-fallback"]
+
+        chunks = chunk_file(str(large), CHUNK_SIZE, CHUNK_OVERLAP)
+        num_chunks = len(chunks)
+
+        # Track calls to distinguish chunk calls from synthesis call.
+        # Chunk calls have a --file arg pointing to a temp chunk file;
+        # the synthesis call does NOT attach a chunk temp file.
+        async def mock_run(*args, timeout=300):
+            # The synthesis prompt includes "Synthesize" — detect it
+            prompt_arg = args[1] if len(args) > 1 else ""
+            if "Synthesize" in prompt_arg or "Chunk Analyses" in prompt_arg:
+                return ("synthesis error", 1)
+            return (_mock_opencode_response("chunk-ok"), 0)
+
+        with patch.object(bridge, "_run_opencode", side_effect=mock_run):
+            result = await bridge._run_chunked(
+                "Review", [str(large)], session
+            )
+
+        # Should contain raw chunk results as fallback
+        assert "Synthesis failed" in result
+        assert "chunk-ok" in result
+
+    @pytest.mark.anyio
+    async def test_partial_chunk_failure_still_synthesizes(self, bridge, tmp_path):
+        """If some chunks fail but not majority, synthesis should still run."""
+        large = tmp_path / "big.py"
+        large.write_text("\n".join(f"# line {i}" for i in range(2500)))
+
+        await bridge.start_session("test-partial")
+        session = bridge.sessions["test-partial"]
+
+        first_call_done = False
+
+        async def mock_run(*args, timeout=300):
+            nonlocal first_call_done
+            prompt_arg = args[1] if len(args) > 1 else ""
+            # Synthesis call — always succeed
+            if "Synthesize" in prompt_arg or "Chunk Analyses" in prompt_arg:
+                return (_mock_opencode_response("synthesized"), 0)
+            # Fail just the first chunk call
+            if not first_call_done:
+                first_call_done = True
+                return ("error", 1)
+            return (_mock_opencode_response("chunk-ok"), 0)
+
+        with patch.object(bridge, "_run_opencode", side_effect=mock_run):
+            result = await bridge._run_chunked(
+                "Review", [str(large)], session
+            )
+
+        # Should have gotten a synthesis result (not a total failure)
+        assert "synthesized" in result or "chunk-ok" in result
+
+
+# ---------------------------------------------------------------------------
+# Edge cases
+# ---------------------------------------------------------------------------
+
+class TestChunkEdgeCases:
+    def test_exactly_at_threshold(self):
+        """A file with exactly CHUNK_THRESHOLD lines should produce one chunk."""
+        path = _make_file(CHUNK_THRESHOLD)
+        chunks = chunk_file(path, chunk_size=CHUNK_SIZE)
+        # CHUNK_THRESHOLD (2000) > CHUNK_SIZE (800) → should produce multiple chunks
+        assert len(chunks) > 1
+
+    def test_one_line_over_threshold(self):
+        """CHUNK_THRESHOLD+1 lines should chunk properly."""
+        path = _make_file(CHUNK_THRESHOLD + 1)
+        chunks = chunk_file(path, chunk_size=CHUNK_SIZE)
+        assert len(chunks) > 1
+        assert chunks[-1]["end_line"] == CHUNK_THRESHOLD + 1
+
+    def test_single_line_file(self):
+        tmp = tempfile.NamedTemporaryFile(
+            mode="w", suffix=".py", delete=False, prefix="test_one_"
+        )
+        tmp.write("x = 1\n")
+        tmp.close()
+        chunks = chunk_file(tmp.name)
+        assert len(chunks) == 1
+        assert chunks[0]["start_line"] == 1
+        assert chunks[0]["end_line"] == 1
+
+    def test_very_large_file_chunk_count(self):
+        """A huge file should produce a reasonable number of chunks."""
+        path = _make_file(10000)
+        chunks = chunk_file(path, chunk_size=800, overlap=20)
+        # ~14 chunks (boundary snapping may reduce effective chunk size)
+        assert 10 <= len(chunks) <= 25
+
+    def test_binary_file_does_not_crash(self):
+        """Binary file with replacement errors should not crash."""
+        tmp = tempfile.NamedTemporaryFile(
+            mode="wb", suffix=".bin", delete=False, prefix="test_bin_"
+        )
+        tmp.write(b"\x00\xff" * 5000 + b"\n" * 100)
+        tmp.close()
+        chunks = chunk_file(tmp.name)
+        # Should produce something without crashing
+        assert isinstance(chunks, list)
+
+    def test_file_info_cache_not_stale(self, tmp_path):
+        """get_file_info cache shouldn't interfere with chunk decisions."""
+        f = tmp_path / "grow.py"
+        f.write_text("\n".join(f"# {i}" for i in range(100)))
+        info1 = get_file_info(str(f))
+        assert info1["lines"] == 100
+
+        # Clear cache so re-read picks up new size
+        _file_info_cache.pop(str(f.resolve()), None)
+
+        f.write_text("\n".join(f"# {i}" for i in range(3000)))
+        info2 = get_file_info(str(f))
+        assert info2["lines"] == 3000
+
+    def test_chunk_content_has_correct_lines(self):
+        """Verify each chunk's content actually matches its line range."""
+        path = _make_file(2000)
+        all_lines = Path(path).read_text().splitlines(keepends=True)
+        chunks = chunk_file(path, chunk_size=800, overlap=20)
+        for c in chunks:
+            start = c["start_line"] - 1  # 0-indexed
+            end = c["end_line"]
+            expected = "".join(all_lines[start:end])
+            assert c["content"] == expected, (
+                f"Chunk {c['chunk_index']} content mismatch: "
+                f"lines {c['start_line']}-{c['end_line']}"
+            )
+
+    def test_no_content_loss_across_chunks(self):
+        """Union of all chunk line ranges should cover every line in the file."""
+        path = _make_file(3000)
+        chunks = chunk_file(path, chunk_size=800, overlap=20)
+        covered = set()
+        for c in chunks:
+            for line in range(c["start_line"], c["end_line"] + 1):
+                covered.add(line)
+        assert covered == set(range(1, 3001))
+
+
+class TestChunkGateBoundary:
+    """Test the exact boundary where chunking kicks in."""
+
+    @pytest.mark.anyio
+    async def test_file_at_threshold_no_chunking_in_send(self, bridge, tmp_path):
+        """File with exactly CHUNK_THRESHOLD lines should NOT trigger chunking
+        in send_message (gate is strictly >)."""
+        f = tmp_path / "exact.py"
+        f.write_text("\n".join(f"# {i}" for i in range(CHUNK_THRESHOLD)))
+
+        await bridge.start_session("test-exact")
+
+        with patch.object(bridge, "_run_opencode", new_callable=AsyncMock) as mock_run:
+            mock_run.return_value = (_mock_opencode_response("normal"), 0)
+            with patch.object(bridge, "_run_chunked", new_callable=AsyncMock) as mock_chunked:
+                result = await bridge.send_message("Review", files=[str(f)])
+                mock_chunked.assert_not_called()
+                assert "normal" in result
+
+    @pytest.mark.anyio
+    async def test_file_one_over_threshold_triggers_chunking(self, bridge, tmp_path):
+        """File with CHUNK_THRESHOLD+1 lines SHOULD trigger chunking."""
+        f = tmp_path / "over.py"
+        f.write_text("\n".join(f"# {i}" for i in range(CHUNK_THRESHOLD + 1)))
+
+        await bridge.start_session("test-over")
+
+        with patch.object(bridge, "_run_chunked", new_callable=AsyncMock) as mock_chunked:
+            mock_chunked.return_value = "chunked"
+            result = await bridge.send_message("Review", files=[str(f)])
+            mock_chunked.assert_called_once()
+
+    @pytest.mark.anyio
+    async def test_multiple_small_files_no_chunking(self, bridge, tmp_path):
+        """Multiple small files (each under threshold) should NOT trigger chunking,
+        even if total lines exceed threshold."""
+        f1 = tmp_path / "a.py"
+        f2 = tmp_path / "b.py"
+        f1.write_text("\n".join(f"# {i}" for i in range(1500)))
+        f2.write_text("\n".join(f"# {i}" for i in range(1500)))
+
+        await bridge.start_session("test-multi-small")
+
+        with patch.object(bridge, "_run_opencode", new_callable=AsyncMock) as mock_run:
+            mock_run.return_value = (_mock_opencode_response("ok"), 0)
+            with patch.object(bridge, "_run_chunked", new_callable=AsyncMock) as mock_chunked:
+                result = await bridge.send_message(
+                    "Review", files=[str(f1), str(f2)]
+                )
+                mock_chunked.assert_not_called()
+
+    @pytest.mark.anyio
+    async def test_mix_small_and_large_triggers_chunking(self, bridge, tmp_path):
+        """If ANY file exceeds threshold, chunking should trigger."""
+        small = tmp_path / "small.py"
+        large = tmp_path / "large.py"
+        small.write_text("\n".join(f"# {i}" for i in range(100)))
+        large.write_text("\n".join(f"# {i}" for i in range(CHUNK_THRESHOLD + 1)))
+
+        await bridge.start_session("test-mix")
+
+        with patch.object(bridge, "_run_chunked", new_callable=AsyncMock) as mock_chunked:
+            mock_chunked.return_value = "chunked"
+            result = await bridge.send_message(
+                "Review", files=[str(small), str(large)]
+            )
+            mock_chunked.assert_called_once()
+
+
+class TestRunChunkedSmallFilesPassthrough:
+    """Verify small files are passed to synthesis call as context."""
+
+    @pytest.mark.anyio
+    async def test_small_files_attached_to_synthesis(self, bridge, tmp_path):
+        small = tmp_path / "helper.py"
+        large = tmp_path / "main.py"
+        small.write_text("\n".join(f"# {i}" for i in range(100)))
+        large.write_text("\n".join(f"# {i}" for i in range(2500)))
+
+        await bridge.start_session("test-passthrough")
+        session = bridge.sessions["test-passthrough"]
+
+        synthesis_args = []
+
+        async def mock_run(*args, timeout=300):
+            prompt_arg = args[1] if len(args) > 1 else ""
+            if "Synthesize" in prompt_arg or "Chunk Analyses" in prompt_arg:
+                synthesis_args.extend(args)
+                return (_mock_opencode_response("final"), 0)
+            return (_mock_opencode_response("chunk-ok"), 0)
+
+        with patch.object(bridge, "_run_opencode", side_effect=mock_run):
+            result = await bridge._run_chunked(
+                "Review", [str(small), str(large)], session
+            )
+
+        # The synthesis call should have --file pointing to the small file
+        assert str(small) in synthesis_args, (
+            f"Small file not passed to synthesis. Args: {synthesis_args}"
+        )