crosscheck-ai 1.0.0__tar.gz

crosscheck_ai-1.0.0/LICENSE

@@ -0,0 +1,14 @@
+Copyright (c) 2026-2027 Steddy Nova Srl. All Rights Reserved.
+
+PROPRIETARY SOFTWARE LICENSE
+
+This software and associated documentation files (the "Software") are the
+exclusive property of Steddy Nova Srl. Unauthorized copying, distribution,
+modification, or use of this Software, in whole or in part, is strictly
+prohibited without prior written consent from Steddy Nova Srl.
+
+The Software is provided "AS IS", without warranty of any kind, express or
+implied. In no event shall Steddy Nova Srl be liable for any claim, damages,
+or other liability arising from the use of the Software.
+
+For licensing inquiries: info@yuyai.pro

crosscheck_ai-1.0.0/PKG-INFO

@@ -0,0 +1,96 @@
+Metadata-Version: 2.4
+Name: crosscheck-ai
+Version: 1.0.0
+Summary: AI Dev Team -- multi-agent coding pipeline where Claude codes and other models advise, debug, review, and plan. Built on OpenRouter.
+Author-email: Steddy Nova Srl <info@yuyai.pro>
+License: Proprietary
+Project-URL: Homepage, https://github.com/Nomadu27/crosscheck-ai
+Project-URL: Repository, https://github.com/Nomadu27/crosscheck-ai
+Project-URL: Issues, https://github.com/Nomadu27/crosscheck-ai/issues
+Keywords: ai,llm,review,openrouter,multi-agent,code-review,insaits,observer
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: Other/Proprietary License
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Quality Assurance
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: click>=8.1
+Requires-Dist: rich>=13.0
+Requires-Dist: httpx>=0.27
+Requires-Dist: pydantic>=2.0
+Requires-Dist: questionary>=2.0
+Requires-Dist: watchdog>=4.0
+Requires-Dist: python-dotenv>=1.0
+Provides-Extra: monitor
+Requires-Dist: insa-its>=1.0; extra == "monitor"
+Provides-Extra: webhook
+Requires-Dist: fastapi>=0.110; extra == "webhook"
+Requires-Dist: uvicorn>=0.29; extra == "webhook"
+Provides-Extra: dashboard
+Requires-Dist: fastapi>=0.110; extra == "dashboard"
+Requires-Dist: uvicorn>=0.29; extra == "dashboard"
+Provides-Extra: policy
+Requires-Dist: pyyaml>=6.0; extra == "policy"
+Provides-Extra: local
+Provides-Extra: all
+Requires-Dist: insa-its>=1.0; extra == "all"
+Requires-Dist: fastapi>=0.110; extra == "all"
+Requires-Dist: uvicorn>=0.29; extra == "all"
+Requires-Dist: pyyaml>=6.0; extra == "all"
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.23; extra == "dev"
+Requires-Dist: pytest-mock>=3.14; extra == "dev"
+Requires-Dist: ruff>=0.4; extra == "dev"
+Requires-Dist: mypy>=1.10; extra == "dev"
+Dynamic: license-file
+
+# crosscheck-ai
+
+**AI Dev Team** — multi-agent coding pipeline where Claude codes and other models advise, debug, review, and plan.
+
+Built on OpenRouter. 31 verified models. 229 tests passing.
+
+## Features
+
+- **AI Dev Team**: Claude writes code, GPT-5 architects, DeepSeek debugs, Grok scans security, Gemini analyzes flow
+- **Group Chat UI**: Talk to all agents at once via web-based dialog panel
+- **Code Review**: Multi-agent review with dual-supervisor voting
+- **Observer Mode**: Watch external coding sessions, flag bugs in real-time
+- **@Mentions**: Route tasks to specific agents (`@coder fix line 45`, `@security scan for vulns`)
+- **20+ Languages**: Auto-detect user language, respond in same language
+
+## Install
+
+```bash
+pip install crosscheck-ai
+```
+
+## Quick Start
+
+```bash
+export CROSSCHECK_API_KEY=sk-or-...
+
+# Launch AI Dev Team
+crosscheck team -t "Add authentication" -f app.py
+
+# Open Group Chat UI
+crosscheck chat --port 8080
+
+# Code review
+crosscheck review mycode.py
+
+# Observer mode
+crosscheck observe watch ./src
+```
+
+## License
+
+Copyright (c) 2026-2027 Steddy Nova Srl. All Rights Reserved.
+
+Contact: info@yuyai.pro

crosscheck_ai-1.0.0/README.md

@@ -0,0 +1,44 @@
+# crosscheck-ai
+
+**AI Dev Team** — multi-agent coding pipeline where Claude codes and other models advise, debug, review, and plan.
+
+Built on OpenRouter. 31 verified models. 229 tests passing.
+
+## Features
+
+- **AI Dev Team**: Claude writes code, GPT-5 architects, DeepSeek debugs, Grok scans security, Gemini analyzes flow
+- **Group Chat UI**: Talk to all agents at once via web-based dialog panel
+- **Code Review**: Multi-agent review with dual-supervisor voting
+- **Observer Mode**: Watch external coding sessions, flag bugs in real-time
+- **@Mentions**: Route tasks to specific agents (`@coder fix line 45`, `@security scan for vulns`)
+- **20+ Languages**: Auto-detect user language, respond in same language
+
+## Install
+
+```bash
+pip install crosscheck-ai
+```
+
+## Quick Start
+
+```bash
+export CROSSCHECK_API_KEY=sk-or-...
+
+# Launch AI Dev Team
+crosscheck team -t "Add authentication" -f app.py
+
+# Open Group Chat UI
+crosscheck chat --port 8080
+
+# Code review
+crosscheck review mycode.py
+
+# Observer mode
+crosscheck observe watch ./src
+```
+
+## License
+
+Copyright (c) 2026-2027 Steddy Nova Srl. All Rights Reserved.
+
+Contact: info@yuyai.pro

crosscheck_ai-1.0.0/crosscheck/__init__.py

@@ -0,0 +1,34 @@
+"""
+crosscheck-ai -- Multi-agent AI review & coding pipeline via OpenRouter.
+"""
+__version__ = "0.3.0"
+
+from crosscheck.agents.supervisor import SupervisorAgent, DecomposeResult, SynthesisResult
+from crosscheck.agents.analyzer import AnalyzerPool, AnalyzerReport
+from crosscheck.agents.coder import CoderAgent
+from crosscheck.core import MultiAgentSession, SessionResult, Round
+from crosscheck.config import CrosscheckConfig, load_config
+from crosscheck.models import Mode, Task, Tier, ModelSpec, REGISTRY
+from crosscheck.monitor import CrosscheckMonitor, NoOpMonitor, AnomalyEvent
+from crosscheck.observer import ObserverSession, ObserverResult, ObserverFlag, FolderWatcher
+from crosscheck.client import OpenRouterClient
+
+__all__ = [
+    "__version__",
+    # Agents
+    "SupervisorAgent", "DecomposeResult", "SynthesisResult",
+    "AnalyzerPool", "AnalyzerReport",
+    "CoderAgent",
+    # Core
+    "MultiAgentSession", "SessionResult", "Round",
+    # Config
+    "CrosscheckConfig", "load_config",
+    # Models
+    "Mode", "Task", "Tier", "ModelSpec", "REGISTRY",
+    # Monitor
+    "CrosscheckMonitor", "NoOpMonitor", "AnomalyEvent",
+    # Observer
+    "ObserverSession", "ObserverResult", "ObserverFlag", "FolderWatcher",
+    # Client
+    "OpenRouterClient",
+]

crosscheck_ai-1.0.0/crosscheck/__main__.py

@@ -0,0 +1,5 @@
+"""Allow running crosscheck as: python -m crosscheck"""
+from crosscheck.cli import cli
+
+if __name__ == "__main__":
+    cli()

crosscheck_ai-1.0.0/crosscheck/agents/__init__.py

@@ -0,0 +1,17 @@
+"""
+crosscheck.agents
+-----------------
+Agent subpackage: supervisor, analyzer, coder.
+"""
+from crosscheck.agents.supervisor import SupervisorAgent, DecomposeResult, SynthesisResult
+from crosscheck.agents.analyzer import AnalyzerPool, AnalyzerReport
+from crosscheck.agents.coder import CoderAgent
+
+__all__ = [
+    "SupervisorAgent",
+    "DecomposeResult",
+    "SynthesisResult",
+    "AnalyzerPool",
+    "AnalyzerReport",
+    "CoderAgent",
+]

crosscheck_ai-1.0.0/crosscheck/agents/analyzer.py

@@ -0,0 +1,156 @@
+"""
+crosscheck.agents.analyzer
+---------------------------
+Analyzer agent pool — runs 3-4 models in parallel, each probing a different
+angle of the content. Results are structured AnalyzerReport objects.
+
+Each analyzer gets a specific task from the Supervisor's decomposition.
+If a model errors, it returns an ERROR report rather than crashing the session.
+Prior round feedback is passed in so analyzers can see if their issues were fixed.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import json
+from dataclasses import dataclass, field
+from typing import Optional
+
+from crosscheck.client  import OpenRouterClient
+from crosscheck.prompts import ANALYZER_SYSTEM, analyzer_prompt
+
+
+@dataclass
+class AnalyzerReport:
+    model_id:          str
+    angle:             str
+    score:             float
+    verdict:           str          # "PASS" | "ISSUES_FOUND" | "ERROR"
+    issues:            list[dict]   # [{severity, location, description, fix}]
+    positive_findings: list[str]
+    summary:           str
+    raw:               dict = field(default_factory=dict)
+    error:             Optional[str] = None
+
+
+class AnalyzerPool:
+    """Runs N analyzer models in parallel, one task per model."""
+
+    def __init__(
+        self,
+        client:  OpenRouterClient,
+        models:  list[str],
+    ):
+        if not models:
+            raise ValueError("AnalyzerPool requires at least one model ID.")
+        self.client = client
+        self.models = models
+
+    async def analyze(
+        self,
+        content:       str,
+        tasks:         list[dict],        # from Supervisor.decompose()
+        round_num:     int,
+        prior_reports: Optional[list[AnalyzerReport]] = None,
+    ) -> list[AnalyzerReport]:
+        """
+        Run all analyzers in parallel.
+        Models are paired to tasks by index (cycling if more models than tasks).
+        Returns one AnalyzerReport per model — errors are caught individually.
+        """
+        pairs: list[tuple[str, dict, str]] = []
+        for i, model in enumerate(self.models):
+            task  = tasks[i % len(tasks)] if tasks else {"angle": "General", "instruction": "Analyze thoroughly."}
+            prior = ""
+            if prior_reports:
+                prev = next((r for r in prior_reports if r.model_id == model), None)
+                if prev and prev.issues:
+                    prior = (
+                        f"Prior round score: {prev.score}/10. "
+                        f"Prior issues: {json.dumps(prev.issues[:5])}"
+                    )
+            pairs.append((model, task, prior))
+
+        results = await asyncio.gather(
+            *[self._single(model, task, content, round_num, prior)
+              for model, task, prior in pairs],
+            return_exceptions=True,
+        )
+
+        reports: list[AnalyzerReport] = []
+        for i, result in enumerate(results):
+            model_id = pairs[i][0]
+            angle    = pairs[i][1].get("angle", f"Angle {i + 1}")
+            if isinstance(result, Exception):
+                reports.append(AnalyzerReport(
+                    model_id=model_id, angle=angle,
+                    score=0.0, verdict="ERROR",
+                    issues=[], positive_findings=[],
+                    summary="Analyzer failed to respond.",
+                    error=str(result),
+                ))
+            else:
+                reports.append(result)
+
+        return reports
+
+    async def _single(
+        self,
+        model:     str,
+        task:      dict,
+        content:   str,
+        round_num: int,
+        prior:     str,
+    ) -> AnalyzerReport:
+        angle       = task.get("angle",       "General")
+        instruction = task.get("instruction", "Analyze the content thoroughly.")
+
+        prompt = analyzer_prompt(
+            angle          = angle,
+            instruction    = instruction,
+            content        = content,
+            round_num      = round_num,
+            prior_feedback = prior,
+        )
+
+        raw = await self.client.chat(
+            model       = model,
+            messages    = [
+                {"role": "system", "content": ANALYZER_SYSTEM},
+                {"role": "user",   "content": prompt},
+            ],
+            temperature = 0.2,
+            json_mode   = True,
+        )
+
+        parsed = self._parse(raw, model)
+        return AnalyzerReport(
+            model_id          = model,
+            angle             = parsed.get("angle", angle),
+            score             = float(parsed.get("score", 0)),
+            verdict           = parsed.get("verdict", "ISSUES_FOUND"),
+            issues            = parsed.get("issues", []),
+            positive_findings = parsed.get("positive_findings", []),
+            summary           = parsed.get("summary", ""),
+            raw               = parsed,
+        )
+
+    @staticmethod
+    def _parse(raw: str, model: str) -> dict:
+        try:
+            return json.loads(raw)
+        except json.JSONDecodeError:
+            cleaned = (
+                raw.strip()
+                   .removeprefix("```json")
+                   .removeprefix("```")
+                   .removesuffix("```")
+                   .strip()
+            )
+            try:
+                return json.loads(cleaned)
+            except Exception as e:
+                raise ValueError(
+                    f"Analyzer {model}: JSON parse failed — {e}\n"
+                    f"Raw (first 300 chars): {raw[:300]}"
+                )

crosscheck_ai-1.0.0/crosscheck/agents/coder.py

@@ -0,0 +1,84 @@
+"""
+crosscheck.agents.coder
+------------------------
+Coder agent — the final implementer in the pipeline.
+
+DESIGN: Any OpenRouter model can be Coder. The user chooses via
+--interactive, --coder flag, or named profile. Anthropic is the
+default in presets but is NOT enforced. DeepSeek, Grok, Kimi, etc.
+are all valid choices.
+
+The coder receives the original content, supervisor instructions,
+and all critical/major issues, then returns the complete revised content.
+"""
+
+from __future__ import annotations
+
+from crosscheck.client  import OpenRouterClient
+from crosscheck.models  import Task
+from crosscheck.prompts import CODER_SYSTEM, coder_prompt
+
+
+class CoderAgent:
+    """Wraps any single model as the Coder. No model-ID restrictions."""
+
+    def __init__(
+        self,
+        client: OpenRouterClient,
+        model:  str,
+        task:   Task,
+    ):
+        if not model:
+            raise ValueError("CoderAgent requires a non-empty model ID.")
+        self.client = client
+        self.model  = model
+        self.task   = task
+
+    async def revise(
+        self,
+        content:      str,
+        instructions: str,
+        issues:       list[dict],
+        round_num:    int,
+        max_tokens:   int = 8192,
+    ) -> str:
+        """
+        Produce a complete revised version of `content` resolving all `issues`.
+        Returns raw revised content — no JSON, no preamble.
+        """
+        prompt = coder_prompt(
+            task         = self.task,
+            content      = content,
+            instructions = instructions,
+            issues       = self._format_issues(issues),
+            round_num    = round_num,
+        )
+
+        revised = await self.client.chat(
+            model       = self.model,
+            messages    = [
+                {"role": "system", "content": CODER_SYSTEM},
+                {"role": "user",   "content": prompt},
+            ],
+            max_tokens  = max_tokens,
+            temperature = 0.2,
+            json_mode   = False,   # raw content output, never JSON
+        )
+
+        return revised.strip()
+
+    @staticmethod
+    def _format_issues(issues: list[dict]) -> str:
+        if not issues:
+            return "No specific issues flagged — improve overall quality and clarity."
+        lines = []
+        for i, issue in enumerate(issues, 1):
+            sev  = issue.get("severity", "major").upper()
+            loc  = issue.get("location", "")
+            desc = issue.get("description", "")
+            fix  = issue.get("fix", "")
+            loc_str = f" [{loc}]" if loc else ""
+            lines.append(f"{i}. [{sev}]{loc_str} {desc}")
+            if fix:
+                lines.append(f"   → Fix: {fix}")
+        return "\n".join(lines)

crosscheck_ai-1.0.0/crosscheck/agents/supervisor.py

@@ -0,0 +1,205 @@
+"""
+crosscheck.agents.supervisor
+-----------------------------
+Supervisor agent — orchestrates the session, decomposes tasks, synthesizes
+analyzer reports, and makes APPROVED / REVISE decisions.
+
+DUAL SUPERVISOR VOTING (when 2 models configured):
+  Both run independently on every synthesis call. Rules:
+  - Both APPROVED → APPROVED (unanimous)
+  - Both REVISE   → REVISE   (unanimous)
+  - Disagreement + both scores ≥ 8.5 → APPROVED (near-perfect exception)
+  - Disagreement + any score < 8.5   → REVISE   (conservative, safe default)
+  Critical issues and coder instructions are merged from both.
+  consensus=False is recorded in the result for visibility.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import json
+from dataclasses import dataclass, field
+from typing import Optional
+
+from crosscheck.client  import OpenRouterClient
+from crosscheck.models  import Task
+from crosscheck.prompts import (
+    SUPERVISOR_SYSTEM,
+    supervisor_decompose,
+    supervisor_synthesize,
+)
+
+
+@dataclass
+class DecomposeResult:
+    session_goal:   str
+    analyzer_tasks: list[dict]   # [{id, angle, instruction}]
+
+
+@dataclass
+class SynthesisResult:
+    verdict:            str            # "APPROVED" | "REVISE"
+    overall_score:      float
+    summary:            str
+    critical_issues:    list[str]
+    coder_instructions: str
+    approved_aspects:   list[str]
+    raw:                dict = field(default_factory=dict)
+    supervisor_votes:   list[str] = field(default_factory=list)
+    consensus:          bool = True
+
+
+class SupervisorAgent:
+    """
+    Wraps 1 or 2 supervisor models.
+    With 2 models, both synthesize in parallel and votes are reconciled.
+    Any OpenRouter model ID is accepted — no restrictions.
+    """
+
+    def __init__(
+        self,
+        client:     OpenRouterClient,
+        models:     list[str],
+        task:       Task,
+        max_rounds: int,
+    ):
+        if not models:
+            raise ValueError("SupervisorAgent requires at least one model ID.")
+        self.client     = client
+        self.models     = models[:2]   # hard cap at 2
+        self.task       = task
+        self.max_rounds = max_rounds
+
+    # ── Public API ───────────────────────────────────────────────────────
+
+    async def decompose(self, content: str, round_num: int) -> DecomposeResult:
+        """Primary supervisor decomposes the content into per-analyzer tasks."""
+        prompt = supervisor_decompose(self.task, content, round_num, self.max_rounds)
+        raw    = await self._call(self.models[0], prompt)
+        parsed = self._parse_json(raw, "decompose")
+        return DecomposeResult(
+            session_goal   = parsed.get("session_goal", ""),
+            analyzer_tasks = parsed.get("analyzer_tasks", []),
+        )
+
+    async def synthesize(
+        self,
+        analyzer_reports: list[dict],
+        round_num:        int,
+    ) -> SynthesisResult:
+        """
+        Synthesize analyzer reports into a final verdict.
+        Single supervisor: straightforward.
+        Dual supervisor: both run in parallel, votes reconciled.
+        """
+        reports_text = json.dumps(analyzer_reports, indent=2)
+        prompt       = supervisor_synthesize(reports_text, round_num)
+
+        if len(self.models) == 1:
+            return await self._single_synthesis(self.models[0], prompt)
+
+        # Dual: parallel execution
+        r1, r2 = await asyncio.gather(
+            self._single_synthesis(self.models[0], prompt),
+            self._single_synthesis(self.models[1], prompt),
+        )
+        return self._reconcile(r1, r2)
+
+    # ── Private ───────────────────────────────────────────────────────────
+
+    async def _single_synthesis(self, model: str, prompt: str) -> SynthesisResult:
+        raw    = await self._call(model, prompt)
+        parsed = self._parse_json(raw, f"synthesize[{model.split('/')[-1]}]")
+        return SynthesisResult(
+            verdict            = parsed.get("verdict", "REVISE"),
+            overall_score      = float(parsed.get("overall_score", 0)),
+            summary            = parsed.get("summary", ""),
+            critical_issues    = parsed.get("critical_issues", []),
+            coder_instructions = parsed.get("coder_instructions", ""),
+            approved_aspects   = parsed.get("approved_aspects", []),
+            raw                = parsed,
+            supervisor_votes   = [parsed.get("verdict", "REVISE")],
+            consensus          = True,
+        )
+
+    @staticmethod
+    def _reconcile(r1: SynthesisResult, r2: SynthesisResult) -> SynthesisResult:
+        """Reconcile two supervisor verdicts. Conservative: REVISE wins on split."""
+        votes = [r1.verdict, r2.verdict]
+
+        if r1.verdict == r2.verdict:
+            # Unanimous — easy
+            final_verdict = r1.verdict
+            consensus     = True
+        else:
+            # Split vote
+            both_high = r1.overall_score >= 8.5 and r2.overall_score >= 8.5
+            if both_high:
+                # Both nearly perfect — allow APPROVED despite split
+                final_verdict = "APPROVED"
+            else:
+                # Safe default: if in doubt, revise
+                final_verdict = "REVISE"
+            consensus = False
+
+        # Use the higher-scoring result as primary for narrative fields
+        primary   = r1 if r1.overall_score >= r2.overall_score else r2
+        secondary = r2 if primary is r1 else r1
+
+        # Deduplicated merge of critical issues
+        merged_issues = list(dict.fromkeys(
+            primary.critical_issues + secondary.critical_issues
+        ))
+
+        # Merge coder instructions (append secondary only when relevant)
+        merged_instructions = primary.coder_instructions
+        if final_verdict == "REVISE" and secondary.coder_instructions:
+            merged_instructions = (
+                f"{primary.coder_instructions}\n\n"
+                f"[Supervisor 2 additions]\n{secondary.coder_instructions}"
+            ).strip()
+
+        return SynthesisResult(
+            verdict            = final_verdict,
+            overall_score      = round((r1.overall_score + r2.overall_score) / 2, 1),
+            summary            = primary.summary,
+            critical_issues    = merged_issues,
+            coder_instructions = merged_instructions,
+            approved_aspects   = list(dict.fromkeys(
+                primary.approved_aspects + secondary.approved_aspects
+            )),
+            raw              = {"supervisor_1": r1.raw, "supervisor_2": r2.raw},
+            supervisor_votes = votes,
+            consensus        = consensus,
+        )
+
+    async def _call(self, model: str, user_prompt: str) -> str:
+        return await self.client.chat(
+            model       = model,
+            messages    = [
+                {"role": "system", "content": SUPERVISOR_SYSTEM},
+                {"role": "user",   "content": user_prompt},
+            ],
+            temperature = 0.2,
+            json_mode   = True,
+        )
+
+    @staticmethod
+    def _parse_json(raw: str, context: str) -> dict:
+        try:
+            return json.loads(raw)
+        except json.JSONDecodeError:
+            cleaned = (
+                raw.strip()
+                   .removeprefix("```json")
+                   .removeprefix("```")
+                   .removesuffix("```")
+                   .strip()
+            )
+            try:
+                return json.loads(cleaned)
+            except Exception as e:
+                raise ValueError(
+                    f"Supervisor {context}: JSON parse failed — {e}\n"
+                    f"Raw (first 400 chars): {raw[:400]}"
+                )