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

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

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

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

@@ -214,546 +214,30 @@ def build_message_prompt(message: str, file_paths: list[str]) -> str:
 
 
 # ---------------------------------------------------------------------------
-# Domain Detection & Companion System
+# Companion System — Auto-Framing
 # ---------------------------------------------------------------------------
 
-@dataclass
-class DomainProfile:
-    """Defines a domain of expertise with persona, frameworks, and approach."""
-    id: str
-    name: str
-    keywords: list[str]
-    phrases: list[str]
-    file_indicators: list[str]  # file extensions or name patterns
-    expert_persona: str
-    thinking_frameworks: list[str]
-    key_questions: list[str]
-    structured_approach: list[str]
-    agent_hint: str  # suggested opencode agent
-
-
-DOMAIN_REGISTRY: dict[str, DomainProfile] = {}
-
-
-def _register(*profiles: DomainProfile):
-    for p in profiles:
-        DOMAIN_REGISTRY[p.id] = p
-
-
-_register(
-    DomainProfile(
-        id="architecture",
-        name="Architecture & System Design",
-        keywords=["architecture", "microservice", "monolith", "scalab", "distributed",
-                  "component", "module", "layer", "decouple", "coupling", "cohesion",
-                  "event", "queue", "broker", "gateway", "proxy", "load balancer"],
-        phrases=["system design", "event driven", "event sourcing", "service mesh",
-                 "domain driven", "hexagonal architecture", "clean architecture",
-                 "micro frontend", "message bus", "data pipeline", "cqrs"],
-        file_indicators=[".proto", ".yaml", ".yml", ".tf", ".hcl"],
-        expert_persona=(
-            "a senior distributed systems architect who has designed systems serving "
-            "millions of users. You think in terms of components, boundaries, data flow, "
-            "and failure modes. You've seen both over-engineered and under-engineered "
-            "systems and know when each approach is appropriate."
-        ),
-        thinking_frameworks=["C4 model (context, containers, components, code)",
-                             "CAP theorem", "DDD (bounded contexts, aggregates)",
-                             "CQRS/Event Sourcing trade-offs",
-                             "Twelve-Factor App principles"],
-        key_questions=["What are the key quality attributes (latency, throughput, availability)?",
-                       "Where are the domain boundaries?",
-                       "What data consistency model fits here?",
-                       "What happens when a component fails?",
-                       "How will this evolve in 6-12 months?"],
-        structured_approach=["Clarify requirements and constraints",
-                             "Identify components and their responsibilities",
-                             "Define interfaces and data flow",
-                             "Analyze trade-offs and failure modes",
-                             "Recommend with rationale"],
-        agent_hint="plan",
-    ),
-    DomainProfile(
-        id="debugging",
-        name="Debugging & Troubleshooting",
-        keywords=["bug", "error", "crash", "fail", "exception", "traceback",
-                  "stacktrace", "debug", "breakpoint", "segfault", "panic",
-                  "hang", "freeze", "corrupt", "unexpected", "wrong"],
-        phrases=["root cause", "stack trace", "doesn't work", "stopped working",
-                 "race condition", "deadlock", "memory leak", "null pointer",
-                 "off by one", "regression", "flaky test", "intermittent failure"],
-        file_indicators=[".log", ".dump", ".core"],
-        expert_persona=(
-            "a seasoned debugger who has tracked down the most elusive bugs — race "
-            "conditions, heisenbugs, memory corruption, off-by-one errors hidden for "
-            "years. You are methodical, hypothesis-driven, and never jump to conclusions."
-        ),
-        thinking_frameworks=["Five Whys (root cause analysis)",
-                             "Scientific method (hypothesize, test, refine)",
-                             "Binary search / bisection for isolating changes",
-                             "Rubber duck debugging"],
-        key_questions=["When did it start happening? What changed?",
-                       "Is it reproducible? Under what conditions?",
-                       "What are the exact symptoms vs. expected behavior?",
-                       "Have we ruled out environment differences?",
-                       "What is the minimal reproduction case?"],
-        structured_approach=["Reproduce and isolate the issue",
-                             "Form hypotheses ranked by likelihood",
-                             "Gather evidence: logs, traces, state inspection",
-                             "Narrow down via elimination",
-                             "Fix, verify, and prevent regression"],
-        agent_hint="build",
-    ),
-    DomainProfile(
-        id="performance",
-        name="Performance & Optimization",
-        keywords=["performance", "optimize", "bottleneck", "latency", "throughput",
-                  "cache", "profil", "benchmark", "slow", "fast", "speed",
-                  "memory", "cpu", "io", "bandwidth", "concurren"],
-        phrases=["cache miss", "hot path", "time complexity", "space complexity",
-                 "p99 latency", "tail latency", "garbage collection", "connection pool",
-                 "query plan", "flame graph", "load test"],
-        file_indicators=[".perf", ".prof", ".bench"],
-        expert_persona=(
-            "a performance engineer who obsesses over microseconds and memory allocations. "
-            "You profile before optimizing, know that premature optimization is the root of "
-            "all evil, and always ask 'what does the data say?' before recommending changes."
-        ),
-        thinking_frameworks=["Amdahl's Law", "Little's Law",
-                             "USE method (Utilization, Saturation, Errors)",
-                             "Roofline model", "Big-O analysis with practical constants"],
-        key_questions=["What is the actual bottleneck (CPU, memory, I/O, network)?",
-                       "Do we have profiling data or benchmarks?",
-                       "What's the target performance? Current baseline?",
-                       "What are the hot paths?",
-                       "What trade-offs are acceptable (memory vs speed, complexity vs perf)?"],
-        structured_approach=["Measure current performance with profiling/benchmarks",
-                             "Identify the bottleneck — do not guess",
-                             "Propose targeted optimizations",
-                             "Estimate impact and trade-offs",
-                             "Measure again after changes"],
-        agent_hint="build",
-    ),
-    DomainProfile(
-        id="security",
-        name="Security & Threat Modeling",
-        keywords=["security", "vulnerab", "auth", "token", "encrypt", "hash",
-                  "ssl", "tls", "cors", "csrf", "xss", "injection", "sanitiz",
-                  "permission", "privilege", "secret", "credential"],
-        phrases=["sql injection", "cross site", "threat model", "attack surface",
-                 "zero trust", "defense in depth", "least privilege",
-                 "owasp top 10", "security audit", "penetration test",
-                 "access control", "input validation"],
-        file_indicators=[".pem", ".key", ".cert", ".env"],
-        expert_persona=(
-            "a senior application security engineer who thinks like an attacker but "
-            "builds like a defender. You know the OWASP Top 10 by heart, understand "
-            "cryptographic primitives, and always consider the full threat model."
-        ),
-        thinking_frameworks=["STRIDE threat modeling",
-                             "OWASP Top 10",
-                             "Defense in depth",
-                             "Zero trust architecture",
-                             "Principle of least privilege"],
-        key_questions=["What is the threat model? Who are the adversaries?",
-                       "What data is sensitive and how is it protected?",
-                       "Where are the trust boundaries?",
-                       "What authentication and authorization model is in use?",
-                       "Are there known CVEs in dependencies?"],
-        structured_approach=["Identify assets and threat actors",
-                             "Map the attack surface",
-                             "Enumerate threats (STRIDE)",
-                             "Assess risk (likelihood x impact)",
-                             "Recommend mitigations prioritized by risk"],
-        agent_hint="plan",
-    ),
-    DomainProfile(
-        id="testing",
-        name="Testing & Quality Assurance",
-        keywords=["test", "assert", "mock", "stub", "fixture", "coverage",
-                  "spec", "suite", "expect", "verify", "tdd", "bdd"],
-        phrases=["unit test", "integration test", "end to end", "test coverage",
-                 "test driven", "edge case", "boundary condition", "test pyramid",
-                 "property based", "mutation testing", "snapshot test",
-                 "regression test"],
-        file_indicators=["_test.py", "_test.go", ".test.js", ".test.ts", ".spec.js",
-                         ".spec.ts", "_spec.rb"],
-        expert_persona=(
-            "a testing specialist who believes tests are living documentation. You "
-            "understand the test pyramid, know when to mock and when not to, and "
-            "write tests that catch real bugs without being brittle."
-        ),
-        thinking_frameworks=["Test pyramid (unit → integration → e2e)",
-                             "FIRST principles (Fast, Independent, Repeatable, Self-validating, Timely)",
-                             "Arrange-Act-Assert pattern",
-                             "Equivalence partitioning & boundary value analysis"],
-        key_questions=["What behavior are we verifying?",
-                       "What are the edge cases and boundary conditions?",
-                       "Is this a unit, integration, or e2e concern?",
-                       "What should we mock vs. use real implementations?",
-                       "How will we know if this test is catching real bugs?"],
-        structured_approach=["Identify what behavior to test",
-                             "Determine test level (unit/integration/e2e)",
-                             "Design test cases covering happy path and edge cases",
-                             "Write clear, maintainable assertions",
-                             "Review for brittleness and false confidence"],
-        agent_hint="build",
-    ),
-    DomainProfile(
-        id="devops",
-        name="DevOps & Infrastructure",
-        keywords=["deploy", "pipeline", "container", "docker", "kubernetes", "k8s",
-                  "terraform", "ansible", "helm", "ci", "cd", "infra", "cloud",
-                  "aws", "gcp", "azure", "monitoring", "alert", "observ"],
-        phrases=["ci/cd pipeline", "infrastructure as code", "blue green deployment",
-                 "canary release", "rolling update", "auto scaling",
-                 "service discovery", "container orchestration",
-                 "gitops", "platform engineering"],
-        file_indicators=[".tf", ".hcl", "Dockerfile", ".yml", ".yaml",
-                         "Jenkinsfile", ".github"],
-        expert_persona=(
-            "a senior DevOps/platform engineer who has managed production infrastructure "
-            "at scale. You think in terms of reliability, repeatability, and observability. "
-            "You know that every manual step is a future incident."
-        ),
-        thinking_frameworks=["DORA metrics (deployment frequency, lead time, MTTR, change failure rate)",
-                             "Infrastructure as Code principles",
-                             "SRE golden signals (latency, traffic, errors, saturation)",
-                             "GitOps workflow"],
-        key_questions=["What is the deployment target (cloud, on-prem, hybrid)?",
-                       "What are the reliability requirements (SLOs)?",
-                       "How do we roll back if something goes wrong?",
-                       "What observability do we have?",
-                       "What is the blast radius of a bad deploy?"],
-        structured_approach=["Assess current infrastructure and deployment process",
-                             "Identify gaps in reliability and automation",
-                             "Design pipeline and infrastructure changes",
-                             "Plan rollout with rollback strategy",
-                             "Define success metrics and alerts"],
-        agent_hint="plan",
-    ),
-    DomainProfile(
-        id="database",
-        name="Database & Data Modeling",
-        keywords=["database", "schema", "table", "column", "index", "query",
-                  "sql", "nosql", "migration", "join", "foreign key", "primary key",
-                  "transaction", "acid", "normali", "partition", "shard", "replica"],
-        phrases=["query optimization", "execution plan", "database migration",
-                 "data model", "schema design", "query plan", "n+1 query",
-                 "connection pool", "read replica", "write ahead log",
-                 "eventual consistency"],
-        file_indicators=[".sql", ".prisma", ".migration"],
-        expert_persona=(
-            "a database architect with deep expertise in both relational and NoSQL systems. "
-            "You think about data access patterns first, schema second. You've tuned queries "
-            "from minutes to milliseconds and know when denormalization is the right call."
-        ),
-        thinking_frameworks=["Normal forms (1NF through BCNF) and when to denormalize",
-                             "ACID vs BASE trade-offs",
-                             "Index design (B-tree, hash, composite, covering)",
-                             "CAP theorem applied to data stores"],
-        key_questions=["What are the primary access patterns (reads vs writes)?",
-                       "What consistency guarantees are needed?",
-                       "How much data and what growth rate?",
-                       "What are the query performance requirements?",
-                       "How will the schema evolve?"],
-        structured_approach=["Understand access patterns and data relationships",
-                             "Design schema to match access patterns",
-                             "Plan indexing strategy",
-                             "Consider partitioning/sharding needs",
-                             "Design migration path from current state"],
-        agent_hint="build",
-    ),
-    DomainProfile(
-        id="api_design",
-        name="API Design",
-        keywords=["api", "endpoint", "rest", "graphql", "grpc", "webhook",
-                  "pagination", "versioning", "rate limit", "openapi", "swagger",
-                  "request", "response", "payload", "header", "status code"],
-        phrases=["rest api", "api design", "api versioning", "breaking change",
-                 "backward compatible", "content negotiation", "hateoas",
-                 "api gateway", "graphql schema", "api contract"],
-        file_indicators=[".openapi", ".swagger", ".graphql", ".gql", ".proto"],
-        expert_persona=(
-            "a senior API designer who has built APIs used by thousands of developers. "
-            "You think about developer experience, consistency, evolvability, and "
-            "backward compatibility. You know REST deeply but aren't dogmatic about it."
-        ),
-        thinking_frameworks=["REST maturity model (Richardson)",
-                             "API-first design",
-                             "Consumer-driven contracts",
-                             "Robustness principle (be liberal in what you accept)"],
-        key_questions=["Who are the API consumers (internal, external, both)?",
-                       "What operations does the API need to support?",
-                       "How will we handle versioning and breaking changes?",
-                       "What authentication and rate limiting model?",
-                       "What error format and status code conventions?"],
-        structured_approach=["Identify resources and operations",
-                             "Design URL structure and HTTP methods",
-                             "Define request/response schemas",
-                             "Plan versioning and error handling",
-                             "Document with examples"],
-        agent_hint="plan",
-    ),
-    DomainProfile(
-        id="frontend",
-        name="Frontend & UI",
-        keywords=["react", "vue", "svelte", "angular", "component", "render",
-                  "state", "hook", "prop", "css", "style", "dom", "browser",
-                  "responsive", "animation", "accessibility", "a11y", "ssr"],
-        phrases=["server side rendering", "client side rendering", "state management",
-                 "component library", "design system", "web vitals",
-                 "progressive enhancement", "single page app", "hydration",
-                 "code splitting", "lazy loading"],
-        file_indicators=[".tsx", ".jsx", ".vue", ".svelte", ".css", ".scss", ".less"],
-        expert_persona=(
-            "a senior frontend architect who cares deeply about user experience, "
-            "accessibility, and performance. You've built design systems and know "
-            "that the best code is the code that makes users productive and happy."
-        ),
-        thinking_frameworks=["Component composition patterns",
-                             "Unidirectional data flow",
-                             "Web Core Vitals (LCP, FID, CLS)",
-                             "Progressive enhancement",
-                             "WCAG accessibility guidelines"],
-        key_questions=["What is the target user experience?",
-                       "What rendering strategy fits (SSR, CSR, ISR, SSG)?",
-                       "How will we manage state (local, global, server)?",
-                       "What are the accessibility requirements?",
-                       "What are the performance budgets?"],
-        structured_approach=["Clarify UX requirements and constraints",
-                             "Choose rendering and state management strategy",
-                             "Design component hierarchy",
-                             "Plan for accessibility and performance",
-                             "Define testing approach (visual, interaction, a11y)"],
-        agent_hint="build",
-    ),
-    DomainProfile(
-        id="algorithms",
-        name="Algorithms & Data Structures",
-        keywords=["algorithm", "complexity", "sort", "search", "graph", "tree",
-                  "heap", "hash", "array", "linked list", "stack", "queue",
-                  "recursive", "dynamic", "greedy", "backtrack"],
-        phrases=["time complexity", "space complexity", "dynamic programming",
-                 "divide and conquer", "binary search", "breadth first",
-                 "depth first", "shortest path", "minimum spanning",
-                 "sliding window", "two pointer"],
-        file_indicators=[],
-        expert_persona=(
-            "a computer scientist who loves elegant solutions and rigorous analysis. "
-            "You think in terms of invariants, complexity classes, and correctness proofs. "
-            "You know that the right data structure often matters more than the algorithm."
-        ),
-        thinking_frameworks=["Big-O analysis (time and space)",
-                             "Problem reduction (what known problem does this map to?)",
-                             "Invariant-based reasoning",
-                             "Amortized analysis"],
-        key_questions=["What are the input constraints (size, range, distribution)?",
-                       "What are the performance requirements?",
-                       "Is there a known algorithm or pattern that applies?",
-                       "Can we trade space for time (or vice versa)?",
-                       "What edge cases must we handle?"],
-        structured_approach=["Understand the problem and constraints",
-                             "Identify applicable patterns or known algorithms",
-                             "Design solution with correctness argument",
-                             "Analyze time and space complexity",
-                             "Consider optimizations and edge cases"],
-        agent_hint="build",
-    ),
-    DomainProfile(
-        id="code_quality",
-        name="Code Quality & Refactoring",
-        keywords=["refactor", "clean", "readab", "maintainab", "solid", "dry",
-                  "smell", "debt", "pattern", "antipattern", "principle",
-                  "naming", "abstraction", "duplication"],
-        phrases=["code smell", "technical debt", "design pattern", "code review",
-                 "clean code", "single responsibility", "dependency injection",
-                 "separation of concerns", "boy scout rule",
-                 "strangler fig", "legacy code"],
-        file_indicators=[],
-        expert_persona=(
-            "a pragmatic software craftsperson who values readability over cleverness. "
-            "You refactor with purpose, not for its own sake. You know that good code "
-            "is code your teammates can understand and modify with confidence."
-        ),
-        thinking_frameworks=["SOLID principles (applied pragmatically)",
-                             "Refactoring patterns (Fowler)",
-                             "Code smells catalog",
-                             "Connascence (coupling analysis)"],
-        key_questions=["What problem is the current design causing?",
-                       "Is this refactoring worth the risk and effort?",
-                       "What's the minimal change that improves the situation?",
-                       "How do we refactor safely (tests as safety net)?",
-                       "Will this be clearer to the next person reading it?"],
-        structured_approach=["Identify the pain point or code smell",
-                             "Ensure adequate test coverage before refactoring",
-                             "Apply incremental, safe transformations",
-                             "Verify behavior preservation after each step",
-                             "Review for clarity and simplicity"],
-        agent_hint="build",
-    ),
-    DomainProfile(
-        id="planning",
-        name="Project Planning & Product",
-        keywords=["plan", "roadmap", "milestone", "sprint", "epic", "story",
-                  "requirement", "scope", "prioriti", "estimate", "mvp",
-                  "feature", "deadline", "backlog", "stakeholder"],
-        phrases=["user story", "acceptance criteria", "definition of done",
-                 "minimum viable", "project plan", "technical spec",
-                 "request for comments", "design doc", "product requirement",
-                 "scope creep"],
-        file_indicators=[],
-        expert_persona=(
-            "a seasoned tech lead who bridges engineering and product. You break down "
-            "ambiguous problems into concrete, shippable increments. You know that the "
-            "best plan is one the team actually follows."
-        ),
-        thinking_frameworks=["User story mapping",
-                             "RICE prioritization (Reach, Impact, Confidence, Effort)",
-                             "MoSCoW prioritization",
-                             "Incremental delivery (thin vertical slices)"],
-        key_questions=["What is the user problem we're solving?",
-                       "What is the smallest thing we can ship to learn?",
-                       "What are the dependencies and risks?",
-                       "How will we know this succeeded?",
-                       "What can we defer without losing value?"],
-        structured_approach=["Define the problem and success criteria",
-                             "Break down into shippable increments",
-                             "Identify dependencies, risks, and unknowns",
-                             "Prioritize by value and effort",
-                             "Define first concrete next steps"],
-        agent_hint="plan",
-    ),
-    DomainProfile(
-        id="general",
-        name="General Discussion",
-        keywords=[],
-        phrases=[],
-        file_indicators=[],
-        expert_persona=(
-            "a knowledgeable senior engineer with broad experience across the stack. "
-            "You think clearly, communicate precisely, and always consider the broader "
-            "context before diving into details."
-        ),
-        thinking_frameworks=["First principles thinking",
-                             "Trade-off analysis",
-                             "Systems thinking"],
-        key_questions=["What are we trying to achieve?",
-                       "What are the constraints?",
-                       "What are the trade-offs?"],
-        structured_approach=["Understand the question and context",
-                             "Consider multiple perspectives",
-                             "Analyze trade-offs",
-                             "Provide a clear recommendation"],
-        agent_hint="plan",
-    ),
-)
-
-
-@dataclass
-class DomainDetection:
-    """Result of domain detection."""
-    primary: DomainProfile
-    confidence: int  # 0-100
-    secondary: Optional[DomainProfile] = None
-    secondary_confidence: int = 0
-
-
-def detect_domain(
-    message: str,
-    file_paths: Optional[list[str]] = None,
-) -> DomainDetection:
-    """Score message against all domains and return best match.
-
-    Scoring rules:
-    - keyword match: +1 per keyword found
-    - phrase match: +2 per phrase found  (phrases are more specific)
-    - file indicator: +1.5 per matching file extension/pattern
-    """
-    text = message.lower()
-    scores: dict[str, float] = {}
-
-    for domain_id, profile in DOMAIN_REGISTRY.items():
-        if domain_id == "general":
-            continue  # general is the fallback
-        score = 0.0
-
-        for kw in profile.keywords:
-            if kw in text:
-                score += 1
-
-        for phrase in profile.phrases:
-            if phrase in text:
-                score += 2
-
-        if file_paths:
-            for fp in file_paths:
-                fp_lower = fp.lower()
-                name_lower = Path(fp).name.lower()
-                for indicator in profile.file_indicators:
-                    ind = indicator.lower()
-                    if fp_lower.endswith(ind) or ind == name_lower or ind in fp_lower:
-                        score += 1.5
-
-        if score > 0:
-            scores[domain_id] = score
-
-    if not scores:
-        return DomainDetection(
-            primary=DOMAIN_REGISTRY["general"],
-            confidence=50,
-        )
-
-    ranked = sorted(scores.items(), key=lambda x: x[1], reverse=True)
-    best_id, best_score = ranked[0]
-
-    # Confidence: scale relative to number of matches.
-    # A score of 5+ is very confident; 1 is low.
-    confidence = min(99, int(40 + best_score * 12))
-
-    result = DomainDetection(
-        primary=DOMAIN_REGISTRY[best_id],
-        confidence=confidence,
-    )
-
-    # Cross-domain detection: secondary if >60% of primary
-    if len(ranked) > 1:
-        second_id, second_score = ranked[1]
-        if second_score >= best_score * 0.6:
-            result.secondary = DOMAIN_REGISTRY[second_id]
-            result.secondary_confidence = min(99, int(40 + second_score * 12))
-
-    return result
-
 
 def build_companion_prompt(
     message: str,
     files: Optional[list[str]] = None,
     domain_override: Optional[str] = None,
     is_followup: bool = False,
-) -> tuple[str, DomainDetection]:
-    """Assemble a domain-aware companion prompt.
+) -> str:
+    """Assemble a companion prompt that auto-detects the domain.
 
-    Returns (prompt_text, domain_detection).
+    The LLM identifies the domain and adopts an appropriate expert persona.
+    An optional *domain_override* hint biases the framing toward a specific field.
     """
-    # Detect or override domain
-    if domain_override and domain_override in DOMAIN_REGISTRY:
-        profile = DOMAIN_REGISTRY[domain_override]
-        detection = DomainDetection(primary=profile, confidence=99)
-    else:
-        detection = detect_domain(message, files)
-        profile = detection.primary
-
     # Follow-up: lightweight prompt
     if is_followup:
-        parts = [
+        return "\n".join([
             "## Continuing Our Discussion",
             "",
             message,
             "",
             "Remember: challenge assumptions, consider alternatives, be explicit about trade-offs.",
-        ]
-        return "\n".join(parts), detection
+        ])
 
     # --- Full initial prompt ---
     parts = []
@@ -767,59 +251,57 @@ def build_companion_prompt(
             parts.append(file_context)
             parts.append("")
 
-    # Cross-domain note
-    cross = ""
-    if detection.secondary:
-        cross = f" This also touches on **{detection.secondary.name}**, so weave in that perspective where relevant."
+    # Domain hint
+    domain_hint = ""
+    if domain_override:
+        domain_hint = (
+            f"\n\nNote: the user has indicated this is about **{domain_override}** — "
+            "frame your expertise accordingly."
+        )
 
-    # Discussion setup
     parts.append("## Discussion Setup")
     parts.append(
-        f"You are {profile.expert_persona}{cross}\n"
-        f"I'm bringing you a question about **{profile.name}**, "
-        "and I want us to think through it together as peers."
+        "Determine the **specific domain of expertise** this question belongs to "
+        "(e.g., distributed systems, metagenomics, compiler design, quantitative finance, "
+        "DevOps, security, database design, or any other field).\n"
+        "\n"
+        "Then adopt the persona of a **senior practitioner with deep, hands-on "
+        "experience** in that domain. You have:\n"
+        "- Years of practical experience solving real problems in this field\n"
+        "- Deep knowledge of the key frameworks, methods, and trade-offs\n"
+        "- Strong opinions loosely held — you recommend but explain why\n"
+        "\n"
+        "Briefly state what domain you identified and what expert lens you're "
+        f"applying (one line at the top is enough).{domain_hint}"
     )
     parts.append("")
 
-    # Frameworks
-    parts.append(f"### Analytical Toolkit")
-    for fw in profile.thinking_frameworks:
-        parts.append(f"- {fw}")
-    parts.append("")
-
-    # Key questions
-    parts.append("### Key Questions to Consider")
-    for q in profile.key_questions:
-        parts.append(f"- {q}")
-    parts.append("")
-
-    # Collaborative ground rules
     parts.append("## Collaborative Ground Rules")
-    parts.append("- Think out loud, share your reasoning")
+    parts.append("- Think out loud, share your reasoning step by step")
     parts.append("- Challenge questionable assumptions — including mine")
     parts.append("- Lay out trade-offs explicitly: what we gain, what we lose")
+    parts.append("- Name the key analytical frameworks or methods relevant to this domain")
     parts.append("- Propose at least one alternative I haven't considered")
     parts.append("")
 
-    # Structured approach
-    parts.append(f"## Approach")
-    for i, step in enumerate(profile.structured_approach, 1):
-        parts.append(f"{i}. {step}")
+    parts.append("## Your Approach")
+    parts.append("1. Identify the domain and the core question")
+    parts.append("2. Apply domain-specific frameworks and best practices")
+    parts.append("3. Analyze trade-offs with concrete reasoning")
+    parts.append("4. Provide a clear recommendation")
     parts.append("")
 
-    # The question
     parts.append("## The Question")
     parts.append(message)
     parts.append("")
 
-    # Synthesize
     parts.append("## Synthesize")
     parts.append("1. Your recommendation with rationale")
     parts.append("2. Key trade-offs")
     parts.append("3. Risks or blind spots")
     parts.append("4. Open questions worth exploring")
 
-    return "\n".join(parts), detection
+    return "\n".join(parts)
 
 
 # Default configuration
@@ -1118,18 +600,14 @@ Set via:
         files = (files or []) + [temp_file.name]
 
         # Build prompt: companion system unless _raw is set
-        domain_info = ""
         if _raw:
             run_prompt = build_message_prompt(message, files)
         else:
             is_followup = len(session.messages) > 1
-            run_prompt, detection = build_companion_prompt(
+            run_prompt = build_companion_prompt(
                 message, files, domain_override=domain_override,
                 is_followup=is_followup,
             )
-            domain_info = f"[Domain: {detection.primary.name}] [Confidence: {detection.confidence}%]"
-            if detection.secondary:
-                domain_info += f" [Also: {detection.secondary.name} ({detection.secondary_confidence}%)]"
 
         args = ["run", run_prompt]
 
@@ -1194,10 +672,7 @@ Set via:
         if reply or session.opencode_session_id:
             session.save(self.sessions_dir / f"{sid}.json")
 
-        response = reply or "No response received"
-        if domain_info:
-            response = f"{domain_info}\n\n{response}"
-        return response
+        return reply or "No response received"
 
     async def plan(
         self,
@@ -1492,11 +967,7 @@ async def list_tools():
                     },
                     "domain": {
                         "type": "string",
-                        "description": "Override auto-detected domain",
-                        "enum": ["architecture", "debugging", "performance", "security",
-                                 "testing", "devops", "database", "api_design",
-                                 "frontend", "algorithms", "code_quality", "planning",
-                                 "general"]
+                        "description": "Hint the domain of expertise (e.g., 'security', 'metagenomics', 'quantitative finance')"
                     }
                 },
                 "required": ["message"]

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

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

{opencode_bridge-0.2.0 → opencode_bridge-0.3.0}/skills/opencode.md

@@ -24,29 +24,18 @@ Collaborative discussion with OpenCode models (GPT-5, Claude, Gemini). Sessions
 | `/opencode set agent <name>` | Set default agent |
 | `/opencode end` | End session |
 
-## Domain Detection
-
-When you send a message via `opencode_discuss`, the system auto-detects the discussion domain and frames OpenCode as a specialized expert:
-
-| Domain | Example triggers |
-|--------|-----------------|
-| Architecture | "microservice", "system design", "event driven" |
-| Debugging | "bug", "root cause", "stack trace" |
-| Performance | "optimize", "bottleneck", "cache miss" |
-| Security | "vulnerability", "SQL injection", "OWASP" |
-| Testing | "unit test", "coverage", "TDD" |
-| DevOps | "deploy", "CI/CD pipeline", "kubernetes" |
-| Database | "schema", "query optimization", "migration" |
-| API Design | "REST API", "versioning", "endpoint" |
-| Frontend | "React", "component", "SSR", "accessibility" |
-| Algorithms | "dynamic programming", "time complexity" |
-| Code Quality | "refactor", "SOLID", "technical debt" |
-| Planning | "roadmap", "MVP", "user story" |
-| General | fallback when nothing else matches |
-
-Override detection with `domain` parameter: `opencode_discuss(message="...", domain="security")`.
-
-The response includes the detected domain and confidence: `[Domain: Architecture] [Confidence: 92%]`.
+## Auto-Framing Companion
+
+When you send a message via `opencode_discuss`, the system automatically frames OpenCode as a domain expert. Rather than relying on hardcoded domain lists, the companion prompt instructs the LLM to:
+
+1. **Self-identify the domain** from the question content
+2. **Adopt a senior practitioner persona** with deep, hands-on experience
+3. **Apply relevant analytical frameworks** for that domain
+4. **Engage collaboratively** — challenging assumptions, proposing alternatives, laying out trade-offs
+
+This works for any domain — software architecture, metagenomics, quantitative finance, linguistics, or anything else.
+
+Optionally provide a `domain` hint to steer the framing: `opencode_discuss(message="...", domain="security")`.
 
 Follow-up messages in an existing session get a lighter prompt that preserves the collaborative framing without repeating the full setup.
 
@@ -68,10 +57,9 @@ When user says `/opencode plan <task>`:
 
 When user says `/opencode ask <question>`:
 1. Call `opencode_discuss(message=<question>)`
-2. Note the detected domain in your relay
-3. Relay the response
+2. Relay the response
 
-To force a specific domain: `opencode_discuss(message=<question>, domain="security")`
+To hint a specific domain: `opencode_discuss(message=<question>, domain="security")`
 
 ### Code Review
 
@@ -119,12 +107,10 @@ Claude: Connected to OpenCode (openai/gpt-5.2-codex, plan agent). Ready.
 
 User: Should we use event sourcing for our order system?
 Claude: [calls opencode_discuss]
-       [Domain: Architecture & System Design] [Confidence: 92%]
        [OpenCode responds as a distributed systems architect]
 
 User: What about the security implications?
 Claude: [calls opencode_discuss — follow-up, lighter prompt]
-       [Domain: Security & Threat Modeling] [Confidence: 76%]
 
 User: /opencode end
 Claude: Session ended.

opencode_bridge-0.3.0/tests/test_companion.py

@@ -0,0 +1,114 @@
+"""Tests for the auto-framing companion prompt system."""
+
+from opencode_bridge.server import build_companion_prompt
+
+
+# ---------------------------------------------------------------------------
+# Initial prompt structure
+# ---------------------------------------------------------------------------
+
+class TestInitialPrompt:
+    def test_has_all_sections(self):
+        prompt = build_companion_prompt("How should we handle auth?")
+        assert "## Discussion Setup" in prompt
+        assert "## Collaborative Ground Rules" in prompt
+        assert "## Your Approach" in prompt
+        assert "## The Question" in prompt
+        assert "## Synthesize" in prompt
+
+    def test_contains_message(self):
+        msg = "Should we use event sourcing for orders?"
+        prompt = build_companion_prompt(msg)
+        assert msg in prompt
+
+    def test_instructs_domain_identification(self):
+        prompt = build_companion_prompt("How do we price a barrier option?")
+        assert "specific domain of expertise" in prompt
+        assert "senior practitioner" in prompt
+
+    def test_instructs_trade_off_analysis(self):
+        prompt = build_companion_prompt("Should we use Redis or Memcached?")
+        assert "trade-offs" in prompt.lower()
+        assert "challenge" in prompt.lower()
+
+    def test_works_for_software_topics(self):
+        prompt = build_companion_prompt("Should we use microservices or a monolith?")
+        assert "## The Question" in prompt
+        assert "microservices" in prompt
+
+    def test_works_for_science_topics(self):
+        prompt = build_companion_prompt(
+            "Should we use co-assembly or per-sample binning for ancient DNA metagenomes?"
+        )
+        assert "## The Question" in prompt
+        assert "co-assembly" in prompt
+
+    def test_works_for_finance_topics(self):
+        prompt = build_companion_prompt(
+            "How should we price a European barrier option with jump diffusion?"
+        )
+        assert "## The Question" in prompt
+        assert "barrier option" in prompt
+
+
+# ---------------------------------------------------------------------------
+# Domain override hint
+# ---------------------------------------------------------------------------
+
+class TestDomainOverride:
+    def test_override_included_in_prompt(self):
+        prompt = build_companion_prompt("Tell me about caching", domain_override="security")
+        assert "security" in prompt.lower()
+
+    def test_override_free_form(self):
+        prompt = build_companion_prompt(
+            "How do we handle this?", domain_override="metagenomics"
+        )
+        assert "metagenomics" in prompt
+
+    def test_no_override_no_hint(self):
+        prompt = build_companion_prompt("Tell me about caching")
+        assert "user has indicated" not in prompt
+
+
+# ---------------------------------------------------------------------------
+# Follow-up prompts
+# ---------------------------------------------------------------------------
+
+class TestFollowup:
+    def test_followup_is_lightweight(self):
+        full = build_companion_prompt("How should we handle auth?")
+        followup = build_companion_prompt("What about JWT?", is_followup=True)
+        assert "Continuing Our Discussion" in followup
+        assert len(followup) < len(full)
+
+    def test_followup_does_not_have_full_sections(self):
+        followup = build_companion_prompt("What about JWT?", is_followup=True)
+        assert "## Discussion Setup" not in followup
+        assert "## Your Approach" not in followup
+
+    def test_followup_contains_message(self):
+        msg = "What about JWT vs sessions?"
+        followup = build_companion_prompt(msg, is_followup=True)
+        assert msg in followup
+
+    def test_followup_has_collaborative_reminder(self):
+        followup = build_companion_prompt("What next?", is_followup=True)
+        assert "challenge assumptions" in followup
+
+
+# ---------------------------------------------------------------------------
+# File context
+# ---------------------------------------------------------------------------
+
+class TestFileContext:
+    def test_no_crash_with_files(self):
+        prompt = build_companion_prompt("Review this", files=["/tmp/test.py"])
+        assert "## The Question" in prompt
+
+    def test_temp_files_excluded_from_context(self):
+        prompt = build_companion_prompt(
+            "Review this", files=["/tmp/opencode_msg_abc.md"]
+        )
+        # Temp message files should not appear in file context
+        assert "opencode_msg" not in prompt.split("## The Question")[0]

opencode_bridge-0.2.0/tests/test_companion.py

@@ -1,267 +0,0 @@
-"""Tests for the domain detection and companion prompt system."""
-
-import pytest
-
-from opencode_bridge.server import (
-    DOMAIN_REGISTRY,
-    DomainDetection,
-    DomainProfile,
-    build_companion_prompt,
-    detect_domain,
-)
-
-
-# ---------------------------------------------------------------------------
-# Domain registry
-# ---------------------------------------------------------------------------
-
-class TestDomainRegistry:
-    def test_all_13_domains_registered(self):
-        assert len(DOMAIN_REGISTRY) == 13
-
-    def test_expected_domain_ids(self):
-        expected = {
-            "architecture", "debugging", "performance", "security",
-            "testing", "devops", "database", "api_design",
-            "frontend", "algorithms", "code_quality", "planning", "general",
-        }
-        assert set(DOMAIN_REGISTRY.keys()) == expected
-
-    def test_every_profile_has_required_fields(self):
-        for domain_id, profile in DOMAIN_REGISTRY.items():
-            assert profile.id == domain_id
-            assert profile.name
-            assert profile.expert_persona
-            assert len(profile.thinking_frameworks) >= 1
-            assert len(profile.key_questions) >= 1
-            assert len(profile.structured_approach) >= 1
-            assert profile.agent_hint in ("plan", "build", "explore", "general")
-
-    def test_general_has_no_keywords(self):
-        """General is the fallback — it should never win by keyword match."""
-        g = DOMAIN_REGISTRY["general"]
-        assert g.keywords == []
-        assert g.phrases == []
-
-
-# ---------------------------------------------------------------------------
-# Domain detection — keyword / phrase scoring
-# ---------------------------------------------------------------------------
-
-class TestDetectDomain:
-    def test_architecture(self):
-        d = detect_domain("Should we use event sourcing for our order system?")
-        assert d.primary.id == "architecture"
-
-    def test_debugging(self):
-        d = detect_domain("There's a race condition in the worker pool")
-        assert d.primary.id == "debugging"
-
-    def test_performance(self):
-        d = detect_domain("We need to optimize the hot path and reduce p99 latency")
-        assert d.primary.id == "performance"
-
-    def test_security(self):
-        d = detect_domain("How do we prevent SQL injection in the login form?")
-        assert d.primary.id == "security"
-
-    def test_testing(self):
-        d = detect_domain("We need better unit test coverage for the auth module")
-        assert d.primary.id == "testing"
-
-    def test_devops(self):
-        d = detect_domain("Let's set up a CI/CD pipeline with kubernetes")
-        assert d.primary.id == "devops"
-
-    def test_database(self):
-        d = detect_domain("Should we add an index on the orders table for this query?")
-        assert d.primary.id == "database"
-
-    def test_api_design(self):
-        d = detect_domain("How should we version our REST API endpoints?")
-        assert d.primary.id == "api_design"
-
-    def test_frontend(self):
-        d = detect_domain("Should this React component use SSR or client-side rendering?")
-        assert d.primary.id == "frontend"
-
-    def test_algorithms(self):
-        d = detect_domain("What's the time complexity of this dynamic programming solution?")
-        assert d.primary.id == "algorithms"
-
-    def test_code_quality(self):
-        d = detect_domain("This class violates single responsibility and has a lot of code smell")
-        assert d.primary.id == "code_quality"
-
-    def test_planning(self):
-        d = detect_domain("Let's define user stories and acceptance criteria for the MVP")
-        assert d.primary.id == "planning"
-
-    def test_general_fallback(self):
-        d = detect_domain("What is the meaning of life?")
-        assert d.primary.id == "general"
-        assert d.confidence == 50
-
-    def test_confidence_increases_with_more_matches(self):
-        few = detect_domain("Tell me about microservices")
-        many = detect_domain(
-            "Should we use microservices with event driven architecture, "
-            "a message bus, and domain driven design for our distributed system?"
-        )
-        assert many.confidence > few.confidence
-
-    def test_phrases_score_higher_than_keywords(self):
-        """A phrase like 'event sourcing' should beat a single keyword like 'event'."""
-        kw_only = detect_domain("event")
-        phrase = detect_domain("event sourcing")
-        assert phrase.confidence >= kw_only.confidence
-
-
-# ---------------------------------------------------------------------------
-# Cross-domain detection
-# ---------------------------------------------------------------------------
-
-class TestCrossDomain:
-    def test_secondary_domain_detected(self):
-        d = detect_domain("Optimize the database query performance and add an index")
-        assert d.secondary is not None
-        assert d.secondary.id != d.primary.id
-        assert d.secondary_confidence > 0
-
-    def test_no_secondary_when_dominant(self):
-        d = detect_domain("What is the meaning of life?")
-        assert d.secondary is None
-
-    def test_secondary_ids_are_valid(self):
-        d = detect_domain("Deploy a kubernetes cluster with monitoring and CI/CD pipeline alerts")
-        if d.secondary:
-            assert d.secondary.id in DOMAIN_REGISTRY
-
-
-# ---------------------------------------------------------------------------
-# File indicator scoring
-# ---------------------------------------------------------------------------
-
-class TestFileIndicators:
-    def test_dockerfile_triggers_devops(self):
-        d = detect_domain("How should we configure this?", file_paths=["/app/Dockerfile"])
-        assert d.primary.id == "devops"
-
-    def test_yaml_triggers_devops(self):
-        d = detect_domain("How should we set this up?", file_paths=["/app/deploy.yaml"])
-        # yaml can match devops or architecture; both have .yaml
-        assert d.primary.id in ("devops", "architecture")
-
-    def test_sql_triggers_database(self):
-        d = detect_domain("Review this file", file_paths=["/db/migration.sql"])
-        assert d.primary.id == "database"
-
-    def test_proto_triggers_architecture(self):
-        d = detect_domain("Review this", file_paths=["/api/service.proto"])
-        assert d.primary.id in ("architecture", "api_design")
-
-    def test_tsx_triggers_frontend(self):
-        d = detect_domain("Review this component", file_paths=["/src/Button.tsx"])
-        assert d.primary.id == "frontend"
-
-    def test_test_file_triggers_testing(self):
-        d = detect_domain("Check this", file_paths=["/src/auth_test.py"])
-        assert d.primary.id == "testing"
-
-    def test_multiple_files_accumulate(self):
-        d = detect_domain(
-            "Review these",
-            file_paths=["/app/Dockerfile", "/app/deploy.yaml", "/app/k8s.yml"],
-        )
-        assert d.primary.id == "devops"
-        assert d.confidence > detect_domain(
-            "Review these", file_paths=["/app/Dockerfile"]
-        ).confidence
-
-
-# ---------------------------------------------------------------------------
-# Companion prompt generation
-# ---------------------------------------------------------------------------
-
-class TestBuildCompanionPrompt:
-    def test_initial_prompt_has_all_sections(self):
-        prompt, det = build_companion_prompt("How should we handle auth?")
-        assert "## Discussion Setup" in prompt
-        assert "### Analytical Toolkit" in prompt
-        assert "### Key Questions to Consider" in prompt
-        assert "## Collaborative Ground Rules" in prompt
-        assert "## Approach" in prompt
-        assert "## The Question" in prompt
-        assert "## Synthesize" in prompt
-
-    def test_initial_prompt_contains_message(self):
-        msg = "Should we use event sourcing for orders?"
-        prompt, _ = build_companion_prompt(msg)
-        assert msg in prompt
-
-    def test_initial_prompt_contains_persona(self):
-        prompt, det = build_companion_prompt("How to prevent SQL injection?")
-        assert det.primary.expert_persona in prompt
-
-    def test_followup_is_lightweight(self):
-        full, _ = build_companion_prompt("How should we handle auth?")
-        followup, _ = build_companion_prompt("What about JWT?", is_followup=True)
-        assert "Continuing Our Discussion" in followup
-        assert len(followup) < len(full)
-
-    def test_followup_does_not_have_full_sections(self):
-        followup, _ = build_companion_prompt("What about JWT?", is_followup=True)
-        assert "## Discussion Setup" not in followup
-        assert "### Analytical Toolkit" not in followup
-
-    def test_followup_contains_message(self):
-        msg = "What about JWT vs sessions?"
-        followup, _ = build_companion_prompt(msg, is_followup=True)
-        assert msg in followup
-
-    def test_domain_override(self):
-        prompt, det = build_companion_prompt("Tell me about caching", domain_override="security")
-        assert det.primary.id == "security"
-        assert det.confidence == 99
-
-    def test_invalid_domain_override_falls_back_to_detection(self):
-        prompt, det = build_companion_prompt(
-            "Optimize the query", domain_override="nonexistent_domain"
-        )
-        # Should fall back to auto-detection, not crash
-        assert det.primary.id != "nonexistent_domain"
-        assert det.primary.id in DOMAIN_REGISTRY
-
-    def test_file_context_included(self):
-        prompt, _ = build_companion_prompt(
-            "Review this", files=["/tmp/test.py"]
-        )
-        # File context section is only added if file exists; just ensure no crash
-        assert "## The Question" in prompt
-
-    def test_cross_domain_note_in_prompt(self):
-        prompt, det = build_companion_prompt(
-            "Optimize the database query performance and add an index"
-        )
-        if det.secondary:
-            assert "also touches on" in prompt.lower()
-
-
-# ---------------------------------------------------------------------------
-# DomainDetection dataclass
-# ---------------------------------------------------------------------------
-
-class TestDomainDetection:
-    def test_confidence_range(self):
-        for msg in [
-            "event sourcing microservices",
-            "debug this bug",
-            "What is life?",
-        ]:
-            d = detect_domain(msg)
-            assert 0 <= d.confidence <= 100
-
-    def test_secondary_confidence_less_than_or_equal_primary(self):
-        d = detect_domain("Optimize the database query and add an index")
-        if d.secondary:
-            assert d.secondary_confidence <= d.confidence