verd 0.1.0__tar.gz

verd-0.1.0/PKG-INFO

@@ -0,0 +1,12 @@
+Metadata-Version: 2.4
+Name: verd
+Version: 0.1.0
+Summary: Multi-LLM debate CLI for confident answers
+Requires-Python: >=3.11
+Requires-Dist: openai>=1.0.0
+Requires-Dist: rich>=13.0.0
+Requires-Dist: python-dotenv>=1.0.0
+Requires-Dist: mcp>=1.0.0
+Provides-Extra: slack
+Requires-Dist: slack-bolt>=1.18.0; extra == "slack"
+Requires-Dist: httpx>=0.27.0; extra == "slack"

verd-0.1.0/README.md

@@ -0,0 +1,210 @@
+# verd
+
+Multi-LLM debate for confident answers. Takes any content + a question, runs it through multiple AI models in a structured multi-round debate, and returns a confidence-weighted verdict with strengths, issues, and fixes.
+
+Instead of asking one AI "are you sure?", verd spawns multiple models from different families, has them challenge each other across rounds, then a stronger judge synthesizes the final verdict.
+
+## Install
+
+```bash
+pip install verd
+```
+
+## Setup
+
+verd works with any OpenAI-compatible API. Pick one:
+
+### Option 1: OpenRouter (easiest, all models, one key)
+
+Sign up at [openrouter.ai](https://openrouter.ai), get an API key, then:
+
+```bash
+export OPENAI_API_KEY=sk-or-...
+export OPENAI_BASE_URL=https://openrouter.ai/api/v1
+```
+
+### Option 2: Direct OpenAI
+
+```bash
+export OPENAI_API_KEY=sk-...
+export OPENAI_BASE_URL=https://api.openai.com/v1
+```
+
+Note: only OpenAI models will work. Edit `verd/models.py` to use only OpenAI models.
+
+### Option 3: LiteLLM proxy (use native keys from any provider)
+
+If you have API keys from multiple providers (Anthropic, Google, OpenAI, etc.):
+
+```bash
+pip install litellm
+litellm --config litellm_config.yaml  # starts local proxy on port 4000
+```
+
+Example `litellm_config.yaml`:
+```yaml
+model_list:
+  - model_name: claude-sonnet-4-6
+    litellm_params:
+      model: anthropic/claude-sonnet-4-20250514
+      api_key: sk-ant-...
+  - model_name: gpt-5-mini
+    litellm_params:
+      model: openai/gpt-5-mini
+      api_key: sk-...
+  - model_name: gemini-2.5-flash
+    litellm_params:
+      model: gemini/gemini-2.5-flash
+      api_key: AIza...
+```
+
+Then point verd at it:
+```bash
+export OPENAI_API_KEY=sk-anything
+export OPENAI_BASE_URL=http://localhost:4000/v1
+```
+
+### Option 4: Any OpenAI-compatible provider
+
+Azure OpenAI, Together, Groq, Fireworks, etc. — just set the base URL and API key.
+
+### Save to .env
+
+Or create a `.env` file in your working directory:
+```bash
+cp .env.example .env
+# edit with your keys
+```
+
+### Custom models
+
+Edit `verd/models.py` to match whatever models your provider supports. The default config uses models available through LiteLLM proxies and OpenRouter.
+
+## Usage
+
+```bash
+# Auto-scan current directory
+cd backend && verd "is this production-ready?"
+
+# Single file
+verd "is this JWT implementation secure?" -f auth.py
+
+# Multiple files
+verd "any issues?" -f auth.py middleware.py routes.py
+
+# Directory
+verd "is this codebase sound?" -d src/ --ext .py
+
+# Inline question
+verdl "is O(n^2) acceptable for n=1000?"
+
+# Git diffs
+verd "are these changes safe?" -g              # unstaged
+verd "ready to commit?" -gs                    # staged
+verdh "should we merge this?" -gb main         # branch diff
+
+# Pipe
+cat auth.py | verd "is this secure?"
+
+# Quiet mode (verdict only, no transcript)
+verd "any bugs?" -f app.py -q
+
+# JSON output
+verd "any bugs?" -f app.py --json
+```
+
+## Modes
+
+| Command | Models | Rounds | Speed | Cost |
+|---------|--------|--------|-------|------|
+| `verdl` | 2 | 1 | ~10s | ~$0.01 |
+| `verd` | 4 | 2 | ~30s | ~$0.05 |
+| `verdh` | 5 + web search | 3 | ~70s | ~$0.30 |
+
+## Flags
+
+```
+claim                  the question to evaluate (required)
+
+Content input (pick one, or auto-scans current dir):
+  -c, --context TEXT     inline content string
+  -f FILE [FILE ...]     one or more files
+  -d [DIR]               directory (default: current dir)
+  -g, --git              unstaged git diff
+  -gs, --git-staged      staged git diff
+  -gb, --git-branch REF  git diff REF...HEAD
+
+Directory filters:
+  --ext EXT [EXT ...]    filter by extension (.py .ts)
+  --exclude PATTERN      glob pattern to exclude (test_*)
+
+Output:
+  -q, --quiet            hide debate transcript, show only verdict
+  --json                 raw JSON output
+  --timeout SECONDS      override timeout per model call
+  --version              show version
+```
+
+## Exit Codes
+
+- `0` — PASS
+- `1` — FAIL
+- `2` — UNCERTAIN
+
+Useful for scripting: `verd "are tests passing?" -f test.py && deploy`
+
+## MCP — Claude Code / Cursor
+
+Add to `~/.claude.json` or `~/.cursor/mcp.json`:
+
+```json
+{
+  "mcpServers": {
+    "verd": {
+      "command": "verd-mcp",
+      "env": {
+        "OPENAI_API_KEY": "your-key",
+        "OPENAI_BASE_URL": "https://openrouter.ai/api/v1"
+      }
+    }
+  }
+}
+```
+
+Then use `verd`, `verdl`, or `verdh` as tools directly in chat.
+
+## Slack
+
+Install with Slack dependencies:
+
+```bash
+pip install verd[slack]
+```
+
+Create a Slack app with Socket Mode, add bot scopes (`app_mentions:read`, `channels:history`, `chat:write`, `reactions:write`, `im:history`, `im:write`, `users:read`), then:
+
+```bash
+export SLACK_BOT_TOKEN=xoxb-...
+export SLACK_APP_TOKEN=xapp-...
+export SLACK_SIGNING_SECRET=...
+verd-slack
+```
+
+Usage in Slack:
+- `@verd what do you think?` — reads thread/channel context, debates, replies
+- `@verd deep is this secure?` — uses verdh (5 models + web search)
+- `@verd quick is this right?` — uses verdl (fast)
+- `@verd last 50 what's the consensus?` — reads last 50 messages
+- `/verd should we use Kafka?` — slash command with progress updates
+- `/verdl is this correct?` — quick slash command
+- `/verdh any security issues?` — deep slash command
+
+## How it works
+
+1. Your question + content gets sent to multiple AI models in parallel
+2. Each model gives its independent assessment (PASS/FAIL/UNCERTAIN)
+3. Models see each other's responses and cross-examine for 1-3 rounds
+4. A stronger judge model synthesizes the debate into a final verdict
+5. You get: verdict, confidence %, strengths, issues, and actionable fixes
+
+The key insight: different models catch different things. Claude spots security issues GPT misses. Gemini catches logic errors DeepSeek overlooks. The debate format forces them to challenge each other rather than just agreeing.

verd-0.1.0/pyproject.toml

@@ -0,0 +1,28 @@
+[build-system]
+requires = ["setuptools"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "verd"
+version = "0.1.0"
+description = "Multi-LLM debate CLI for confident answers"
+requires-python = ">=3.11"
+dependencies = [
+    "openai>=1.0.0",
+    "rich>=13.0.0",
+    "python-dotenv>=1.0.0",
+    "mcp>=1.0.0",
+]
+
+[project.optional-dependencies]
+slack = [
+    "slack-bolt>=1.18.0",
+    "httpx>=0.27.0",
+]
+
+[project.scripts]
+verd      = "verd.__main__:main_default"
+verdl     = "verd.__main__:main_light"
+verdh     = "verd.__main__:main_heavy"
+verd-mcp  = "verd.mcp_server:main"
+verd-slack = "verd.slack_bot:main"

verd-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

verd-0.1.0/verd/__main__.py

@@ -0,0 +1,141 @@
+import argparse
+import asyncio
+import json
+import sys
+
+from verd.config import VERSION
+from verd.context import build_context
+from verd.engine import run_debate
+from verd.output import print_result, StatusDisplay
+
+
+def make_parser():
+    parser = argparse.ArgumentParser(
+        description="Multi-LLM debate for confident answers"
+    )
+    parser.add_argument("--version", action="version", version=f"verd {VERSION}")
+    parser.add_argument("claim", help="The claim or question to evaluate")
+
+    # Content input — pick one
+    content = parser.add_argument_group("content input")
+    content.add_argument("-c", "--context", help="Inline content string")
+    content.add_argument(
+        "-f", "--file", nargs="+", metavar="FILE",
+        help="One or more files to evaluate",
+    )
+    content.add_argument(
+        "-d", "--dir", nargs="?", const="", default=None, metavar="DIR",
+        help="Read all files in a directory (default: current dir)",
+    )
+    content.add_argument(
+        "-g", "--git", action="store_true",
+        help="Use unstaged git diff as content",
+    )
+    content.add_argument(
+        "-gs", "--git-staged", action="store_true",
+        help="Use staged git diff as content",
+    )
+    content.add_argument(
+        "-gb", "--git-branch", metavar="REF",
+        help="Use git diff REF...HEAD as content (e.g. main)",
+    )
+
+    # Filters for -d
+    filters = parser.add_argument_group("directory filters (use with -d)")
+    filters.add_argument(
+        "-a", "--all", action="store_true",
+        help="Scan all files, skip smart selection (for full codebase reviews)",
+    )
+    filters.add_argument(
+        "--ext", nargs="+", metavar="EXT",
+        help="Filter by extension (e.g. --ext .py .ts)",
+    )
+    filters.add_argument(
+        "--exclude", nargs="+", metavar="PATTERN",
+        help="Glob patterns to exclude (e.g. --exclude 'test_*' '*.spec.*')",
+    )
+
+    # Output
+    parser.add_argument(
+        "-q", "--quiet", action="store_true",
+        help="Hide debate transcript, show only verdict",
+    )
+    parser.add_argument(
+        "--json", dest="json_output", action="store_true",
+        help="Output raw JSON",
+    )
+    parser.add_argument(
+        "--timeout", type=int, default=None,
+        help="Override timeout per model call (seconds)",
+    )
+    return parser
+
+
+def run(mode: str):
+    parser = make_parser()
+    args = parser.parse_args()
+    content, claim, files = build_context(args)
+
+    if not content and not claim:
+        parser.print_help()
+        sys.exit(1)
+
+    # --all flag: skip smart file selection, send everything
+    if getattr(args, 'all', False) and files is not None:
+        from verd.context import files_to_content, MAX_CONTENT_CHARS
+        total_chars = sum(len(text) for _, text, _ in files)
+        content = files_to_content(files)
+        if total_chars > MAX_CONTENT_CHARS:
+            skipped = total_chars - MAX_CONTENT_CHARS
+            print(
+                f"\n⚠  {len(files)} files totaling {total_chars // 1000}K chars — "
+                f"truncated to {MAX_CONTENT_CHARS // 1000}K ({skipped // 1000}K chars lost).\n"
+                f"   Some files were cut off. For better results, drop -a and let\n"
+                f"   the smart selector pick relevant files, or narrow with --ext / -f.\n",
+                file=sys.stderr,
+            )
+        else:
+            print(f"scanning all {len(files)} files ({total_chars // 1000}K chars)", file=sys.stderr)
+        files = None  # don't run selector
+
+    status = StatusDisplay()
+    try:
+        result = asyncio.run(
+            run_debate(
+                content,
+                claim,
+                mode,
+                timeout_override=args.timeout,
+                status_display=status,
+                files=files,
+                verbose=not args.quiet,
+            )
+        )
+    finally:
+        status.stop()
+
+    if args.json_output:
+        print(json.dumps(result, indent=2, default=str))
+    else:
+        print_result(result)
+
+    # Exit codes: 0=PASS, 1=FAIL, 2=UNCERTAIN
+    verdict = result.get("verdict", "UNCERTAIN")
+    exit_codes = {"PASS": 0, "FAIL": 1, "UNCERTAIN": 2}
+    sys.exit(exit_codes.get(verdict, 2))
+
+
+def main_light():
+    run("verdl")
+
+
+def main_default():
+    run("verd")
+
+
+def main_heavy():
+    run("verdh")
+
+
+if __name__ == "__main__":
+    main_default()

verd-0.1.0/verd/config.py

@@ -0,0 +1,68 @@
+import os
+from openai import AsyncOpenAI
+from dotenv import load_dotenv
+
+load_dotenv()
+
+VERSION = "0.1.0"
+
+# Token budgets — reasoning models use these for thinking + output combined
+# Keep high enough that reasoning models don't run out of thinking space
+DEBATER_MAX_TOKENS = {
+    "verdl": 2048,   # fast, concise
+    "verd": 4096,    # balanced
+    "verdh": 4096,   # deep analysis
+}
+JUDGE_MAX_TOKENS = 8192
+
+TIMEOUTS = {
+    "verdl": 30,
+    "verd": 45,
+    "verdh": 90,
+}
+
+JSON_MODE_MODELS = {
+    "o3", "o3-mini", "o4-mini", "gpt-4.1", "gpt-5-mini", "gpt-5", "gpt-5.4"
+}
+
+# Pricing per 1M tokens (input, output) in USD
+MODEL_PRICING = {
+    "gpt-4.1":                  (2.00, 8.00),
+    "gpt-5-mini":               (0.25, 2.00),
+    "gpt-5.4":                  (2.50, 15.00),
+    "claude-sonnet-4-6":        (3.00, 15.00),
+    "claude-opus-4-6":          (5.00, 25.00),
+    "gemini-2.5-flash":         (0.30, 2.50),
+    "gemini-3.1-pro-preview":   (2.00, 12.00),
+    "deepseek-r1":              (1.35, 5.40),
+    "sonar-pro":                (3.00, 15.00),
+    "o3":                       (2.00, 8.00),
+    "o4-mini":                  (1.10, 4.40),
+}
+
+
+def estimate_cost(model: str, prompt_tokens: int, completion_tokens: int) -> float:
+    """Estimate cost in USD for a model call."""
+    input_price, output_price = MODEL_PRICING.get(model, (5.00, 15.00))
+    return (prompt_tokens * input_price + completion_tokens * output_price) / 1_000_000
+
+
+_client = None
+
+
+def get_client() -> AsyncOpenAI:
+    """Lazy client init — only validates env vars on first actual API call."""
+    global _client
+    if _client is None:
+        api_key = os.getenv("OPENAI_API_KEY")
+        base_url = os.getenv("OPENAI_BASE_URL")
+        if not api_key:
+            raise EnvironmentError(
+                "OPENAI_API_KEY is not set. Add it to your .env file or export it."
+            )
+        if not base_url:
+            raise EnvironmentError(
+                "OPENAI_BASE_URL is not set. Add it to your .env file or export it."
+            )
+        _client = AsyncOpenAI(api_key=api_key, base_url=base_url)
+    return _client

verd-0.1.0/verd/context.py

@@ -0,0 +1,153 @@
+import fnmatch
+import subprocess
+import sys
+from pathlib import Path
+
+# Dirs/files to always skip
+_SKIP_DIRS = {
+    "__pycache__", ".git", ".venv", "venv", "node_modules",
+    ".tox", ".mypy_cache", ".pytest_cache", "dist", "build",
+    ".egg-info", ".eggs",
+}
+_SKIP_FILES = {
+    ".DS_Store", "Thumbs.db", ".env", ".env.local",
+}
+
+MAX_CONTENT_CHARS = 200_000  # ~50k tokens, safe for most models
+
+# Code extensions we care about
+_CODE_EXTENSIONS = {
+    ".py", ".js", ".ts", ".tsx", ".jsx", ".go", ".rs", ".rb", ".java",
+    ".kt", ".swift", ".c", ".cpp", ".h", ".hpp", ".cs", ".php",
+    ".scala", ".ex", ".exs", ".clj", ".lua", ".r", ".sql", ".sh",
+    ".yaml", ".yml", ".toml", ".json", ".tf", ".hcl",
+}
+
+
+def _is_valid_path(p: Path) -> bool:
+    if any(part in _SKIP_DIRS for part in p.parts):
+        return False
+    if p.name in _SKIP_FILES or p.name.startswith("."):
+        return False
+    return True
+
+
+def _read_file(path: Path) -> str | None:
+    """Read file content, return None on failure."""
+    try:
+        return path.read_text()
+    except (UnicodeDecodeError, PermissionError):
+        return None
+
+
+def _collect_files(
+    dir_path: Path,
+    extensions: list[str] | None,
+    excludes: list[str] | None,
+) -> list[tuple[Path, str, str]]:
+    """Collect files from directory. Returns list of (relative_path, content, extension).
+
+    Auto-detects extensions if None.
+    """
+    if extensions is None:
+        counts: dict[str, int] = {}
+        for p in dir_path.rglob("*"):
+            if not p.is_file() or not _is_valid_path(p):
+                continue
+            if p.suffix in _CODE_EXTENSIONS:
+                counts[p.suffix] = counts.get(p.suffix, 0) + 1
+        if not counts:
+            return []
+        extensions = sorted(counts, key=counts.get, reverse=True)
+        pass  # auto-detected extensions
+
+    files = []
+    for p in sorted(dir_path.rglob("*")):
+        if not p.is_file() or not _is_valid_path(p):
+            continue
+        if extensions and p.suffix not in extensions:
+            continue
+        if excludes and any(fnmatch.fnmatch(p.name, pat) for pat in excludes):
+            continue
+
+        text = _read_file(p)
+        if text is None:
+            continue
+
+        rel = p.relative_to(dir_path)
+        files.append((rel, text, p.suffix))
+
+    return files
+
+
+def files_to_content(files: list[tuple[Path, str, str]]) -> str:
+    """Convert file list to concatenated content string with headers."""
+    parts = []
+    total = 0
+    for path, text, _ext in files:
+        chunk = f"--- {path} ---\n{text}\n"
+        total += len(chunk)
+        if total > MAX_CONTENT_CHARS:
+            parts.append(f"\n[truncated at {MAX_CONTENT_CHARS // 1000}k chars]\n")
+            break
+        parts.append(chunk)
+    return "\n".join(parts)
+
+
+def _run_git(cmd: list[str]) -> str:
+    result = subprocess.run(cmd, capture_output=True, text=True)
+    if result.returncode != 0:
+        raise RuntimeError(f"git failed: {result.stderr.strip()}")
+    return result.stdout
+
+
+def build_context(args) -> tuple[str, str, list[tuple[Path, str, str]] | None]:
+    """Returns (content, claim, files_or_none).
+
+    When files is not None, content selection can be applied before debate.
+    When files is None, content is already final (user picked it explicitly).
+    """
+    content = ""
+    files = None
+
+    if args.dir is not None:
+        dir_path = Path(args.dir) if args.dir else Path(".")
+        exts = args.ext or None
+        excludes = args.exclude or None
+        files = _collect_files(dir_path, exts, excludes)
+        content = files_to_content(files)
+    elif args.file:
+        parts = []
+        for f in args.file:
+            p = Path(f)
+            if not p.exists():
+                print(f"warning: {f} not found, skipping", file=sys.stderr)
+                continue
+            text = _read_file(p)
+            if text is not None:
+                parts.append(f"--- {p.name} ---\n{text}\n")
+        content = "\n".join(parts)
+    elif args.git:
+        content = _run_git(["git", "diff"])
+    elif args.git_staged:
+        content = _run_git(["git", "diff", "--staged"])
+    elif args.git_branch:
+        content = _run_git(["git", "diff", f"{args.git_branch}...HEAD"])
+    elif args.context:
+        content = args.context
+    elif not sys.stdin.isatty():
+        content = sys.stdin.read()
+    else:
+        # No content flag — auto-scan current directory
+        cwd = Path(".")
+        files = _collect_files(cwd, None, None)
+        if files:
+            content = files_to_content(files)
+
+    content = content.strip()
+
+    if len(content) > MAX_CONTENT_CHARS:
+        content = content[:MAX_CONTENT_CHARS] + f"\n[truncated at {MAX_CONTENT_CHARS // 1000}k chars]"
+        print(f"warning: content truncated to {MAX_CONTENT_CHARS // 1000}k chars", file=sys.stderr)
+
+    return content, args.claim.strip(), files