bridgekit 0.3.7__tar.gz → 0.3.9__tar.gz

{bridgekit-0.3.7 → bridgekit-0.3.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bridgekit
-Version: 0.3.7
+Version: 0.3.9
 Summary: AI tools that make you a better data scientist, not a redundant one.
 License: MIT
 Project-URL: Homepage, https://usebridgekit.com
@@ -136,6 +136,9 @@ onboarding users to reporting as a growth lever.
 """
 
 print(evaluate(text))
+
+# Override for longer analyses
+print(evaluate(text, max_tokens=2048))
 ```
 
 **Output:**
@@ -190,6 +193,9 @@ Supports `.txt`, `.md`, `.pdf`, `.docx`, `.pptx`, and `.ipynb` files.
 from bridgekit import ask
 
 print(ask("what drove churn in Q3?", source="reports/"))
+
+# Override for longer responses
+print(ask("what drove churn in Q3?", source="reports/", max_tokens=2048))
 ```
 
 **From raw text:**
@@ -234,7 +240,7 @@ print(plan(
 ))
 ```
 
-`data_description` and `goal` are optional — the more context you provide, the more tailored the recommendation.
+`data_description`, `goal`, and `max_tokens` are optional — the more context you provide, the more tailored the recommendation.
 
 **`goal` examples:** `"causal inference"`, `"prediction"`, `"segmentation"`, `"hypothesis testing"`, `"exploration"`
 
@@ -297,6 +303,9 @@ print(redteam(text))
 # Or specify a stakeholder
 print(redteam(text, stakeholder="VP of Engineering"))
 print(redteam(text, stakeholder="VP of Marketing"))
+
+# Override for longer responses
+print(redteam(text, max_tokens=2048))
 ```
 
 Same writeup, different attack angles:
@@ -387,6 +396,72 @@ willing to commit to — and what's your confidence interval on that estimate?"
 
 ---
 
+## Tool #5: Compare
+
+Run the same tool through two providers and see both outputs side by side. Useful for evaluating which model works best for your use case — as a one-liner.
+
+```python
+from bridgekit import compare
+
+text = """
+I analyzed 90 days of user behavior data to understand what drives subscription
+upgrades. Users who engaged with the reporting feature within their first week
+were 3x more likely to upgrade within 30 days. I recommend we prioritize
+onboarding users to reporting as a growth lever.
+"""
+
+# Compare evaluate across Anthropic and OpenAI (default)
+print(compare(text, tool="evaluate"))
+
+# Compare plan across two providers
+print(compare("Did our onboarding flow reduce churn?", tool="plan"))
+
+# Compare redteam with a specific stakeholder
+print(compare(text, tool="redteam", stakeholder="VP of Finance"))
+
+# Override models for each provider
+print(compare(text, model_a="claude-haiku-4-5-20251001", model_b="gpt-4-turbo"))
+
+# Compare two specific providers
+print(compare(text, providers=["anthropic", "gemini"]))
+```
+
+**Parameters:**
+- `tool` - which tool to run: `"evaluate"`, `"plan"`, or `"redteam"` (defaults to `"evaluate"`)
+- `providers` - list of exactly two providers to compare (defaults to `["anthropic", "openai"]`)
+- `model_a`, `model_b` - optional model overrides for the first and second provider
+- `**kwargs` - additional arguments passed through to the underlying tool (e.g. `max_tokens`, `stakeholder`, `data_description`)
+
+**Output:**
+```
+BRIDGEKIT COMPARE: EVALUATE
+─────────────────────────────────────────
+
+ANTHROPIC  claude-opus-4-8
+─────────────────────────────────────────
+BRIDGEKIT ANALYSIS REVIEW
+─────────────────────────────────────────
+
+1. CLARITY
+✅ STRONG — Clean and jargon-free.
+
+...
+
+OPENAI  gpt-4o
+─────────────────────────────────────────
+BRIDGEKIT ANALYSIS REVIEW
+─────────────────────────────────────────
+
+1. CLARITY
+⚠️  NEEDS WORK — The phrase "engagement feature" needs more context.
+
+...
+```
+
+Both providers are called in parallel, so the total wait time is the slower of the two — not the sum.
+
+---
+
 ## Multi-Provider Support
 
 Bridgekit now supports multiple AI providers so you're not locked into one API. You can use Anthropic, OpenAI, or Google Gemini models with any tool.
@@ -414,7 +489,7 @@ Bridgekit automatically detects the provider from model names:
 - Models starting with "gemini" → Google Gemini
 
 **Default models by provider:**
-- Anthropic: `claude-3-5-sonnet-20241022`
+- Anthropic: `claude-opus-4-8`
 - OpenAI: `gpt-4o`
 - Gemini: `gemini-1.5-pro`
 

{bridgekit-0.3.7 → bridgekit-0.3.9}/README.md

@@ -104,6 +104,9 @@ onboarding users to reporting as a growth lever.
 """
 
 print(evaluate(text))
+
+# Override for longer analyses
+print(evaluate(text, max_tokens=2048))
 ```
 
 **Output:**
@@ -158,6 +161,9 @@ Supports `.txt`, `.md`, `.pdf`, `.docx`, `.pptx`, and `.ipynb` files.
 from bridgekit import ask
 
 print(ask("what drove churn in Q3?", source="reports/"))
+
+# Override for longer responses
+print(ask("what drove churn in Q3?", source="reports/", max_tokens=2048))
 ```
 
 **From raw text:**
@@ -202,7 +208,7 @@ print(plan(
 ))
 ```
 
-`data_description` and `goal` are optional — the more context you provide, the more tailored the recommendation.
+`data_description`, `goal`, and `max_tokens` are optional — the more context you provide, the more tailored the recommendation.
 
 **`goal` examples:** `"causal inference"`, `"prediction"`, `"segmentation"`, `"hypothesis testing"`, `"exploration"`
 
@@ -265,6 +271,9 @@ print(redteam(text))
 # Or specify a stakeholder
 print(redteam(text, stakeholder="VP of Engineering"))
 print(redteam(text, stakeholder="VP of Marketing"))
+
+# Override for longer responses
+print(redteam(text, max_tokens=2048))
 ```
 
 Same writeup, different attack angles:
@@ -355,6 +364,72 @@ willing to commit to — and what's your confidence interval on that estimate?"
 
 ---
 
+## Tool #5: Compare
+
+Run the same tool through two providers and see both outputs side by side. Useful for evaluating which model works best for your use case — as a one-liner.
+
+```python
+from bridgekit import compare
+
+text = """
+I analyzed 90 days of user behavior data to understand what drives subscription
+upgrades. Users who engaged with the reporting feature within their first week
+were 3x more likely to upgrade within 30 days. I recommend we prioritize
+onboarding users to reporting as a growth lever.
+"""
+
+# Compare evaluate across Anthropic and OpenAI (default)
+print(compare(text, tool="evaluate"))
+
+# Compare plan across two providers
+print(compare("Did our onboarding flow reduce churn?", tool="plan"))
+
+# Compare redteam with a specific stakeholder
+print(compare(text, tool="redteam", stakeholder="VP of Finance"))
+
+# Override models for each provider
+print(compare(text, model_a="claude-haiku-4-5-20251001", model_b="gpt-4-turbo"))
+
+# Compare two specific providers
+print(compare(text, providers=["anthropic", "gemini"]))
+```
+
+**Parameters:**
+- `tool` - which tool to run: `"evaluate"`, `"plan"`, or `"redteam"` (defaults to `"evaluate"`)
+- `providers` - list of exactly two providers to compare (defaults to `["anthropic", "openai"]`)
+- `model_a`, `model_b` - optional model overrides for the first and second provider
+- `**kwargs` - additional arguments passed through to the underlying tool (e.g. `max_tokens`, `stakeholder`, `data_description`)
+
+**Output:**
+```
+BRIDGEKIT COMPARE: EVALUATE
+─────────────────────────────────────────
+
+ANTHROPIC  claude-opus-4-8
+─────────────────────────────────────────
+BRIDGEKIT ANALYSIS REVIEW
+─────────────────────────────────────────
+
+1. CLARITY
+✅ STRONG — Clean and jargon-free.
+
+...
+
+OPENAI  gpt-4o
+─────────────────────────────────────────
+BRIDGEKIT ANALYSIS REVIEW
+─────────────────────────────────────────
+
+1. CLARITY
+⚠️  NEEDS WORK — The phrase "engagement feature" needs more context.
+
+...
+```
+
+Both providers are called in parallel, so the total wait time is the slower of the two — not the sum.
+
+---
+
 ## Multi-Provider Support
 
 Bridgekit now supports multiple AI providers so you're not locked into one API. You can use Anthropic, OpenAI, or Google Gemini models with any tool.
@@ -382,7 +457,7 @@ Bridgekit automatically detects the provider from model names:
 - Models starting with "gemini" → Google Gemini
 
 **Default models by provider:**
-- Anthropic: `claude-3-5-sonnet-20241022`
+- Anthropic: `claude-opus-4-8`
 - OpenAI: `gpt-4o`
 - Gemini: `gemini-1.5-pro`
 

{bridgekit-0.3.7 → bridgekit-0.3.9}/bridgekit/__init__.py

@@ -2,6 +2,7 @@ from .reviewer import evaluate
 from .search import ask
 from .planner import plan
 from .redteam import redteam
+from .compare import compare
 
-__version__ = "0.3.7"
-__all__ = ["evaluate", "ask", "plan", "redteam"]
+__version__ = "0.3.9"
+__all__ = ["evaluate", "ask", "plan", "redteam", "compare"]

{bridgekit-0.3.7 → bridgekit-0.3.9}/bridgekit/cli.py

@@ -9,7 +9,7 @@ from .search import ask
 
 def _add_provider_args(parser: argparse.ArgumentParser) -> None:
     parser.add_argument("--provider", help='AI provider: "anthropic", "openai", or "gemini"')
-    parser.add_argument("--model", help="Specific model to use (e.g. claude-opus-4-6, gpt-4o)")
+    parser.add_argument("--model", help="Specific model to use (e.g. claude-opus-4-8, gpt-4o)")
 
 
 def _cmd_plan(args: argparse.Namespace) -> None:

bridgekit-0.3.9/bridgekit/compare.py

@@ -0,0 +1,128 @@
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from .config import parse_provider, get_default_model, Provider
+from .providers import create_message
+
+SUPPORTED_TOOLS = ["evaluate", "plan", "redteam"]
+
+SYNTHESIS_PROMPT = """You are comparing two AI-generated outputs for the same analysis task.
+
+Your job is to write a short, direct summary (4-6 sentences) covering:
+- Where both outputs agreed
+- Where they differed — including any cases where one rated a dimension more harshly than the other
+- Which output gave more specific or actionable feedback, and why
+
+Be concrete. Reference specific dimensions or findings. No fluff."""
+
+
+def _get_tool_fn(tool_name: str):
+    if tool_name == "evaluate":
+        from .reviewer import evaluate
+        return evaluate
+    elif tool_name == "plan":
+        from .planner import plan
+        return plan
+    elif tool_name == "redteam":
+        from .redteam import redteam
+        return redteam
+    raise ValueError(f"Unknown tool: {tool_name!r}. Supported tools: {SUPPORTED_TOOLS}")
+
+
+def _call_tool(tool_name: str, text: str, provider: str, model, kwargs: dict) -> str:
+    fn = _get_tool_fn(tool_name)
+    if tool_name == "plan":
+        return fn(question=text, provider=provider, model=model, **kwargs)
+    return fn(text=text, provider=provider, model=model, **kwargs)
+
+
+def _synthesize(results: list) -> str:
+    (provider_a, model_a, output_a), (provider_b, model_b, output_b) = results
+    user_message = (
+        f"OUTPUT 1 ({provider_a.upper()} / {model_a}):\n{output_a}\n\n"
+        f"OUTPUT 2 ({provider_b.upper()} / {model_b}):\n{output_b}"
+    )
+    return create_message(
+        provider=Provider.ANTHROPIC,
+        system_prompt=SYNTHESIS_PROMPT,
+        user_message=user_message,
+        max_tokens=512,
+    )
+
+
+def _format_output(tool: str, summary: str, results: list) -> str:
+    divider = "─" * 41
+    lines = [
+        f"BRIDGEKIT COMPARE: {tool.upper()}",
+        divider,
+        "",
+        "SUMMARY",
+        divider,
+        summary,
+        "",
+        "",
+    ]
+    for i, (provider_name, model, output) in enumerate(results):
+        lines.append(f"{provider_name.upper()}  {model}")
+        lines.append(divider)
+        lines.append(output)
+        if i < len(results) - 1:
+            lines.append("")
+            lines.append("")
+    return "\n".join(lines)
+
+
+def compare(
+    text: str,
+    tool: str = "evaluate",
+    providers: list = None,
+    model_a: str = None,
+    model_b: str = None,
+    **kwargs
+) -> str:
+    """
+    Run the same tool through two providers and return both outputs with a summary.
+
+    Args:
+        text: The input text or question to analyze.
+        tool: Which tool to run: "evaluate", "plan", or "redteam". Defaults to "evaluate".
+        providers: List of exactly two providers to compare. Defaults to ["anthropic", "openai"].
+        model_a: Optional model override for the first provider.
+        model_b: Optional model override for the second provider.
+        **kwargs: Additional arguments passed through to the underlying tool
+                  (e.g. max_tokens, stakeholder for redteam, data_description/goal for plan).
+
+    Returns:
+        A summary of key differences followed by both full outputs with provider headers.
+    """
+    if not text or not text.strip():
+        raise ValueError("Text cannot be empty.")
+
+    if tool not in SUPPORTED_TOOLS:
+        raise ValueError(f"Unknown tool: {tool!r}. Supported tools: {SUPPORTED_TOOLS}")
+
+    if providers is None:
+        providers = ["anthropic", "openai"]
+
+    if len(providers) != 2:
+        raise ValueError(f"providers must contain exactly 2 providers, got {len(providers)}.")
+
+    models = [model_a, model_b]
+    resolved_models = []
+    for provider, model in zip(providers, models):
+        provider_enum = parse_provider(provider)
+        resolved_models.append(model if model else get_default_model(provider_enum))
+
+    results_map = {}
+
+    def run_one(idx):
+        output = _call_tool(tool, text, providers[idx], models[idx], kwargs)
+        return idx, providers[idx], resolved_models[idx], output
+
+    with ThreadPoolExecutor(max_workers=2) as executor:
+        futures = {executor.submit(run_one, i): i for i in range(2)}
+        for future in as_completed(futures):
+            idx, provider, model, output = future.result()
+            results_map[idx] = (provider, model, output)
+
+    results = [results_map[0], results_map[1]]
+    summary = _synthesize(results)
+    return _format_output(tool, summary, results)

{bridgekit-0.3.7 → bridgekit-0.3.9}/bridgekit/config.py

@@ -11,7 +11,7 @@ class Provider(Enum):
 
 # Default models for each provider
 DEFAULT_MODELS = {
-    Provider.ANTHROPIC: "claude-opus-4-6",
+    Provider.ANTHROPIC: "claude-opus-4-8",
     Provider.OPENAI: "gpt-4o",
     Provider.GEMINI: "gemini-1.5-pro"
 }

{bridgekit-0.3.7 → bridgekit-0.3.9}/bridgekit/planner.py

@@ -29,7 +29,7 @@ ALTERNATIVES
 """
 
 
-def plan(question: str, data_description: str = None, goal: str = None, provider: str = None, model: str = None, system_prompt: str = None) -> str:
+def plan(question: str, data_description: str = None, goal: str = None, provider: str = None, model: str = None, system_prompt: str = None, max_tokens: int = 1024) -> str:
     """
     Recommend the right analytical approach for your problem.
 
@@ -42,6 +42,7 @@ def plan(question: str, data_description: str = None, goal: str = None, provider
                           If not specified, defaults to "anthropic" or infers from model.
         model:            Optional. The specific model to use. If not specified, uses the provider's default.
         system_prompt:    Optional. A custom system prompt to override the default planner persona.
+        max_tokens:       Optional. Maximum tokens in the response. Defaults to 1024.
 
     Returns:
         A structured analytical plan covering the recommended approach, assumptions,
@@ -66,5 +67,5 @@ def plan(question: str, data_description: str = None, goal: str = None, provider
         system_prompt=system_prompt or SYSTEM_PROMPT,
         user_message=user_message,
         model=model,
-        max_tokens=1024
+        max_tokens=max_tokens
     )

{bridgekit-0.3.7 → bridgekit-0.3.9}/bridgekit/redteam.py

@@ -39,7 +39,7 @@ HARDEST QUESTION TO ANSWER
 """
 
 
-def redteam(text: str, stakeholder: str = None, provider: str = None, model: str = None, system_prompt: str = None) -> str:
+def redteam(text: str, stakeholder: str = None, provider: str = None, model: str = None, system_prompt: str = None, max_tokens: int = 1024) -> str:
     """
     Red-team a data science analysis writeup from the perspective of a skeptical stakeholder.
 
@@ -53,6 +53,7 @@ def redteam(text: str, stakeholder: str = None, provider: str = None, model: str
         model:         Optional. The specific model to use. If not specified, uses the provider's default.
         system_prompt: Optional. A custom system prompt to fully override the default red team persona.
                        When provided, the stakeholder parameter is ignored.
+        max_tokens:    Optional. Maximum tokens in the response. Defaults to 1024.
 
     Returns:
         The 3-5 hardest critiques the stakeholder would make, plus the single
@@ -81,5 +82,5 @@ def redteam(text: str, stakeholder: str = None, provider: str = None, model: str
         system_prompt=system_prompt,
         user_message=user_message,
         model=model,
-        max_tokens=1024
+        max_tokens=max_tokens
     )

{bridgekit-0.3.7 → bridgekit-0.3.9}/bridgekit/reviewer.py

@@ -42,7 +42,7 @@ BOTTOM LINE
 [one sentence]
 """
 
-def evaluate(text: str, provider: str = None, model: str = None, system_prompt: str = None) -> str:
+def evaluate(text: str, provider: str = None, model: str = None, system_prompt: str = None, max_tokens: int = 1024) -> str:
     """
     Evaluate a data science analysis writeup and return structured feedback.
 
@@ -52,6 +52,7 @@ def evaluate(text: str, provider: str = None, model: str = None, system_prompt:
                  If not specified, defaults to "anthropic" or infers from model.
         model: Optional. The specific model to use. If not specified, uses the provider's default.
         system_prompt: Optional. A custom system prompt to override the default reviewer persona.
+        max_tokens: Optional. Maximum tokens in the response. Defaults to 1024.
 
     Returns:
         Structured feedback across four dimensions.
@@ -71,5 +72,5 @@ def evaluate(text: str, provider: str = None, model: str = None, system_prompt:
         system_prompt=system_prompt or SYSTEM_PROMPT,
         user_message=user_message,
         model=model,
-        max_tokens=1024
+        max_tokens=max_tokens
     )

{bridgekit-0.3.7 → bridgekit-0.3.9}/bridgekit/search.py

@@ -56,7 +56,7 @@ DEFAULT_SYSTEM_PROMPT = (
 )
 
 
-def ask(question: str, source: str = None, text: str = None, provider: str = None, model: str = None, system_prompt: str = None) -> str:
+def ask(question: str, source: str = None, text: str = None, provider: str = None, model: str = None, system_prompt: str = None, max_tokens: int = 1024) -> str:
     """
     Ask a question across a collection of analysis documents or raw text.
 
@@ -68,6 +68,7 @@ def ask(question: str, source: str = None, text: str = None, provider: str = Non
                        If not specified, defaults to "anthropic" or infers from model.
         model:         Optional. The specific model to use. If not specified, uses the provider's default.
         system_prompt: Optional. A custom system prompt to override the default answering persona.
+        max_tokens:    Optional. Maximum tokens in the response. Defaults to 1024.
 
     Returns:
         An answer grounded in the provided documents.
@@ -121,5 +122,5 @@ def ask(question: str, source: str = None, text: str = None, provider: str = Non
         system_prompt=system_prompt or DEFAULT_SYSTEM_PROMPT,
         user_message=user_message,
         model=model,
-        max_tokens=1024
+        max_tokens=max_tokens
     )

{bridgekit-0.3.7 → bridgekit-0.3.9}/bridgekit.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bridgekit
-Version: 0.3.7
+Version: 0.3.9
 Summary: AI tools that make you a better data scientist, not a redundant one.
 License: MIT
 Project-URL: Homepage, https://usebridgekit.com
@@ -136,6 +136,9 @@ onboarding users to reporting as a growth lever.
 """
 
 print(evaluate(text))
+
+# Override for longer analyses
+print(evaluate(text, max_tokens=2048))
 ```
 
 **Output:**
@@ -190,6 +193,9 @@ Supports `.txt`, `.md`, `.pdf`, `.docx`, `.pptx`, and `.ipynb` files.
 from bridgekit import ask
 
 print(ask("what drove churn in Q3?", source="reports/"))
+
+# Override for longer responses
+print(ask("what drove churn in Q3?", source="reports/", max_tokens=2048))
 ```
 
 **From raw text:**
@@ -234,7 +240,7 @@ print(plan(
 ))
 ```
 
-`data_description` and `goal` are optional — the more context you provide, the more tailored the recommendation.
+`data_description`, `goal`, and `max_tokens` are optional — the more context you provide, the more tailored the recommendation.
 
 **`goal` examples:** `"causal inference"`, `"prediction"`, `"segmentation"`, `"hypothesis testing"`, `"exploration"`
 
@@ -297,6 +303,9 @@ print(redteam(text))
 # Or specify a stakeholder
 print(redteam(text, stakeholder="VP of Engineering"))
 print(redteam(text, stakeholder="VP of Marketing"))
+
+# Override for longer responses
+print(redteam(text, max_tokens=2048))
 ```
 
 Same writeup, different attack angles:
@@ -387,6 +396,72 @@ willing to commit to — and what's your confidence interval on that estimate?"
 
 ---
 
+## Tool #5: Compare
+
+Run the same tool through two providers and see both outputs side by side. Useful for evaluating which model works best for your use case — as a one-liner.
+
+```python
+from bridgekit import compare
+
+text = """
+I analyzed 90 days of user behavior data to understand what drives subscription
+upgrades. Users who engaged with the reporting feature within their first week
+were 3x more likely to upgrade within 30 days. I recommend we prioritize
+onboarding users to reporting as a growth lever.
+"""
+
+# Compare evaluate across Anthropic and OpenAI (default)
+print(compare(text, tool="evaluate"))
+
+# Compare plan across two providers
+print(compare("Did our onboarding flow reduce churn?", tool="plan"))
+
+# Compare redteam with a specific stakeholder
+print(compare(text, tool="redteam", stakeholder="VP of Finance"))
+
+# Override models for each provider
+print(compare(text, model_a="claude-haiku-4-5-20251001", model_b="gpt-4-turbo"))
+
+# Compare two specific providers
+print(compare(text, providers=["anthropic", "gemini"]))
+```
+
+**Parameters:**
+- `tool` - which tool to run: `"evaluate"`, `"plan"`, or `"redteam"` (defaults to `"evaluate"`)
+- `providers` - list of exactly two providers to compare (defaults to `["anthropic", "openai"]`)
+- `model_a`, `model_b` - optional model overrides for the first and second provider
+- `**kwargs` - additional arguments passed through to the underlying tool (e.g. `max_tokens`, `stakeholder`, `data_description`)
+
+**Output:**
+```
+BRIDGEKIT COMPARE: EVALUATE
+─────────────────────────────────────────
+
+ANTHROPIC  claude-opus-4-8
+─────────────────────────────────────────
+BRIDGEKIT ANALYSIS REVIEW
+─────────────────────────────────────────
+
+1. CLARITY
+✅ STRONG — Clean and jargon-free.
+
+...
+
+OPENAI  gpt-4o
+─────────────────────────────────────────
+BRIDGEKIT ANALYSIS REVIEW
+─────────────────────────────────────────
+
+1. CLARITY
+⚠️  NEEDS WORK — The phrase "engagement feature" needs more context.
+
+...
+```
+
+Both providers are called in parallel, so the total wait time is the slower of the two — not the sum.
+
+---
+
 ## Multi-Provider Support
 
 Bridgekit now supports multiple AI providers so you're not locked into one API. You can use Anthropic, OpenAI, or Google Gemini models with any tool.
@@ -414,7 +489,7 @@ Bridgekit automatically detects the provider from model names:
 - Models starting with "gemini" → Google Gemini
 
 **Default models by provider:**
-- Anthropic: `claude-3-5-sonnet-20241022`
+- Anthropic: `claude-opus-4-8`
 - OpenAI: `gpt-4o`
 - Gemini: `gemini-1.5-pro`
 

{bridgekit-0.3.7 → bridgekit-0.3.9}/bridgekit.egg-info/SOURCES.txt

@@ -3,6 +3,7 @@ README.md
 pyproject.toml
 bridgekit/__init__.py
 bridgekit/cli.py
+bridgekit/compare.py
 bridgekit/config.py
 bridgekit/planner.py
 bridgekit/providers.py
@@ -15,6 +16,8 @@ bridgekit.egg-info/dependency_links.txt
 bridgekit.egg-info/entry_points.txt
 bridgekit.egg-info/requires.txt
 bridgekit.egg-info/top_level.txt
+tests/test_cli.py
+tests/test_compare.py
 tests/test_config.py
 tests/test_planner.py
 tests/test_providers.py

{bridgekit-0.3.7 → bridgekit-0.3.9}/pyproject.toml

@@ -7,7 +7,7 @@ include = ["bridgekit*"]
 
 [project]
 name = "bridgekit"
-version = "0.3.7"
+version = "0.3.9"
 description = "AI tools that make you a better data scientist, not a redundant one."
 readme = "README.md"
 requires-python = ">=3.9"

bridgekit-0.3.9/tests/test_cli.py

@@ -0,0 +1,175 @@
+import sys
+import pytest
+from unittest.mock import patch
+
+
+FAKE_PLAN = "BRIDGEKIT ANALYSIS PLAN\n─────\nRECOMMENDED APPROACH\nUse a t-test."
+FAKE_REVIEW = "BRIDGEKIT ANALYSIS REVIEW\n─────\n1. CLARITY\n✅ STRONG Clear writing."
+FAKE_REDTEAM = "BRIDGEKIT RED TEAM\n─────\nCRITIQUE 1: Sample Size\nHARDEST QUESTION TO ANSWER\nWhat is n?"
+FAKE_SEARCH = "Based on the documents, the answer is 42."
+
+
+class TestPlanCommand:
+    def test_basic_question(self, capsys):
+        with patch("bridgekit.cli.plan", return_value=FAKE_PLAN) as mock_plan:
+            with patch("sys.argv", ["bridgekit", "plan", "should I use a t-test?"]):
+                from bridgekit.cli import main
+                main()
+        mock_plan.assert_called_once_with(
+            question="should I use a t-test?",
+            data_description=None,
+            goal=None,
+            provider=None,
+            model=None,
+        )
+        assert FAKE_PLAN in capsys.readouterr().out
+
+    def test_with_data_and_goal(self, capsys):
+        with patch("bridgekit.cli.plan", return_value=FAKE_PLAN) as mock_plan:
+            with patch("sys.argv", ["bridgekit", "plan", "my question",
+                                    "--data", "50 rows", "--goal", "compare means"]):
+                from bridgekit.cli import main
+                main()
+        mock_plan.assert_called_once_with(
+            question="my question",
+            data_description="50 rows",
+            goal="compare means",
+            provider=None,
+            model=None,
+        )
+
+    def test_with_provider_and_model(self):
+        with patch("bridgekit.cli.plan", return_value=FAKE_PLAN) as mock_plan:
+            with patch("sys.argv", ["bridgekit", "plan", "my question",
+                                    "--provider", "openai", "--model", "gpt-4o"]):
+                from bridgekit.cli import main
+                main()
+        mock_plan.assert_called_once_with(
+            question="my question",
+            data_description=None,
+            goal=None,
+            provider="openai",
+            model="gpt-4o",
+        )
+
+    def test_missing_question_exits(self):
+        with patch("sys.argv", ["bridgekit", "plan"]):
+            from bridgekit.cli import main
+            with pytest.raises(SystemExit):
+                main()
+
+    def test_environment_error_exits(self, capsys):
+        with patch("bridgekit.cli.plan", side_effect=EnvironmentError("ANTHROPIC_API_KEY not found")):
+            with patch("sys.argv", ["bridgekit", "plan", "my question"]):
+                from bridgekit.cli import main
+                with pytest.raises(SystemExit) as exc:
+                    main()
+        assert exc.value.code == 1
+        assert "ANTHROPIC_API_KEY" in capsys.readouterr().err
+
+
+class TestReviewCommand:
+    def test_basic_text(self, capsys):
+        with patch("bridgekit.cli.evaluate", return_value=FAKE_REVIEW) as mock_evaluate:
+            with patch("sys.argv", ["bridgekit", "review", "my analysis text"]):
+                from bridgekit.cli import main
+                main()
+        mock_evaluate.assert_called_once_with(
+            text="my analysis text",
+            provider=None,
+            model=None,
+        )
+        assert FAKE_REVIEW in capsys.readouterr().out
+
+    def test_missing_text_exits(self):
+        with patch("sys.argv", ["bridgekit", "review"]):
+            from bridgekit.cli import main
+            with pytest.raises(SystemExit):
+                main()
+
+
+class TestRedteamCommand:
+    def test_basic_text(self, capsys):
+        with patch("bridgekit.cli.redteam", return_value=FAKE_REDTEAM) as mock_redteam:
+            with patch("sys.argv", ["bridgekit", "redteam", "my analysis text"]):
+                from bridgekit.cli import main
+                main()
+        mock_redteam.assert_called_once_with(
+            text="my analysis text",
+            stakeholder=None,
+            provider=None,
+            model=None,
+        )
+        assert FAKE_REDTEAM in capsys.readouterr().out
+
+    def test_with_stakeholder(self):
+        with patch("bridgekit.cli.redteam", return_value=FAKE_REDTEAM) as mock_redteam:
+            with patch("sys.argv", ["bridgekit", "redteam", "my analysis text",
+                                    "--stakeholder", "VP of Finance"]):
+                from bridgekit.cli import main
+                main()
+        mock_redteam.assert_called_once_with(
+            text="my analysis text",
+            stakeholder="VP of Finance",
+            provider=None,
+            model=None,
+        )
+
+    def test_missing_text_exits(self):
+        with patch("sys.argv", ["bridgekit", "redteam"]):
+            from bridgekit.cli import main
+            with pytest.raises(SystemExit):
+                main()
+
+
+class TestSearchCommand:
+    def test_with_source(self, capsys):
+        with patch("bridgekit.cli.ask", return_value=FAKE_SEARCH) as mock_ask:
+            with patch("sys.argv", ["bridgekit", "search", "my question",
+                                    "--source", "./my_docs"]):
+                from bridgekit.cli import main
+                main()
+        mock_ask.assert_called_once_with(
+            question="my question",
+            source="./my_docs",
+            text=None,
+            provider=None,
+            model=None,
+        )
+        assert FAKE_SEARCH in capsys.readouterr().out
+
+    def test_with_text(self):
+        with patch("bridgekit.cli.ask", return_value=FAKE_SEARCH) as mock_ask:
+            with patch("sys.argv", ["bridgekit", "search", "my question",
+                                    "--text", "some raw text"]):
+                from bridgekit.cli import main
+                main()
+        mock_ask.assert_called_once_with(
+            question="my question",
+            source=None,
+            text="some raw text",
+            provider=None,
+            model=None,
+        )
+
+    def test_missing_source_and_text_exits(self, capsys):
+        with patch("sys.argv", ["bridgekit", "search", "my question"]):
+            from bridgekit.cli import main
+            with pytest.raises(SystemExit) as exc:
+                main()
+        assert exc.value.code == 1
+        assert "error" in capsys.readouterr().err
+
+    def test_missing_question_exits(self):
+        with patch("sys.argv", ["bridgekit", "search"]):
+            from bridgekit.cli import main
+            with pytest.raises(SystemExit):
+                main()
+
+
+class TestNoCommand:
+    def test_no_subcommand_exits(self):
+        with patch("sys.argv", ["bridgekit"]):
+            from bridgekit.cli import main
+            with pytest.raises(SystemExit):
+                main()

bridgekit-0.3.9/tests/test_compare.py

@@ -0,0 +1,275 @@
+import os
+import pytest
+from unittest.mock import patch
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+FAKE_ANTHROPIC = (
+    "BRIDGEKIT ANALYSIS REVIEW\n"
+    "─────────────────────────────────────────\n\n"
+    "1. CLARITY\n"
+    "✅ STRONG — Clear and jargon-free.\n\n"
+    "─────────────────────────────────────────\n"
+    "BOTTOM LINE\n"
+    "Add quantified business impact."
+)
+
+FAKE_OPENAI = (
+    "BRIDGEKIT ANALYSIS REVIEW\n"
+    "─────────────────────────────────────────\n\n"
+    "1. CLARITY\n"
+    "⚠️  NEEDS WORK — Too much jargon.\n\n"
+    "─────────────────────────────────────────\n"
+    "BOTTOM LINE\n"
+    "Define your methodology more clearly."
+)
+
+FAKE_SUMMARY = "Both agreed on Clarity. Anthropic was harsher on Statistical Rigor."
+
+DEFAULT_RESPONSES = {
+    "anthropic": FAKE_ANTHROPIC,
+    "openai": FAKE_OPENAI,
+}
+
+
+def _make_call_tool_side_effect(responses: dict):
+    def side_effect(tool_name, text, provider, model, kwargs):
+        return responses.get(provider, "fallback output")
+    return side_effect
+
+
+def _patches(responses=None):
+    """Context manager stacking _call_tool and _synthesize patches."""
+    if responses is None:
+        responses = DEFAULT_RESPONSES
+
+    class _Ctx:
+        def __enter__(self):
+            self._p1 = patch("bridgekit.compare._call_tool", side_effect=_make_call_tool_side_effect(responses))
+            self._p2 = patch("bridgekit.compare._synthesize", return_value=FAKE_SUMMARY)
+            self._p1.__enter__()
+            self._p2.__enter__()
+            return self
+
+        def __exit__(self, *args):
+            self._p2.__exit__(*args)
+            self._p1.__exit__(*args)
+
+    return _Ctx()
+
+
+# ---------------------------------------------------------------------------
+# Tests
+# ---------------------------------------------------------------------------
+
+class TestCompareReturnsString:
+    def test_returns_string(self):
+        with _patches():
+            from bridgekit.compare import compare
+            result = compare("Some analysis.")
+        assert isinstance(result, str)
+
+    def test_returns_non_empty_string(self):
+        with _patches():
+            from bridgekit.compare import compare
+            result = compare("Some analysis.")
+        assert len(result) > 0
+
+
+class TestCompareOutputStructure:
+    def test_output_contains_tool_header(self):
+        with _patches():
+            from bridgekit.compare import compare
+            result = compare("Some analysis.")
+        assert "BRIDGEKIT COMPARE: EVALUATE" in result
+
+    def test_output_contains_summary_section(self):
+        with _patches():
+            from bridgekit.compare import compare
+            result = compare("Some analysis.")
+        assert "SUMMARY" in result
+        assert FAKE_SUMMARY in result
+
+    def test_summary_appears_before_provider_outputs(self):
+        with _patches():
+            from bridgekit.compare import compare
+            result = compare("Some analysis.")
+        assert result.index("SUMMARY") < result.index(FAKE_ANTHROPIC)
+        assert result.index("SUMMARY") < result.index(FAKE_OPENAI)
+
+    def test_output_contains_both_provider_labels(self):
+        with _patches():
+            from bridgekit.compare import compare
+            result = compare("Some analysis.")
+        assert "ANTHROPIC" in result
+        assert "OPENAI" in result
+
+    def test_output_contains_both_responses(self):
+        with _patches():
+            from bridgekit.compare import compare
+            result = compare("Some analysis.")
+        assert FAKE_ANTHROPIC in result
+        assert FAKE_OPENAI in result
+
+    def test_anthropic_appears_before_openai(self):
+        with _patches():
+            from bridgekit.compare import compare
+            result = compare("Some analysis.")
+        assert result.index(FAKE_ANTHROPIC) < result.index(FAKE_OPENAI)
+
+    def test_plan_tool_header(self):
+        with _patches():
+            from bridgekit.compare import compare
+            result = compare("What caused churn?", tool="plan")
+        assert "BRIDGEKIT COMPARE: PLAN" in result
+
+    def test_redteam_tool_header(self):
+        with _patches():
+            from bridgekit.compare import compare
+            result = compare("Some analysis.", tool="redteam")
+        assert "BRIDGEKIT COMPARE: REDTEAM" in result
+
+
+class TestCompareValidation:
+    def test_empty_text_raises_value_error(self):
+        from bridgekit.compare import compare
+        with pytest.raises(ValueError, match="empty"):
+            compare("")
+
+    def test_whitespace_text_raises_value_error(self):
+        from bridgekit.compare import compare
+        with pytest.raises(ValueError, match="empty"):
+            compare("   ")
+
+    def test_invalid_tool_raises_value_error(self):
+        from bridgekit.compare import compare
+        with pytest.raises(ValueError, match="Unknown tool"):
+            compare("Some analysis.", tool="summarize")
+
+    def test_too_few_providers_raises_value_error(self):
+        from bridgekit.compare import compare
+        with pytest.raises(ValueError, match="exactly 2"):
+            compare("Some analysis.", providers=["anthropic"])
+
+    def test_too_many_providers_raises_value_error(self):
+        from bridgekit.compare import compare
+        with pytest.raises(ValueError, match="exactly 2"):
+            compare("Some analysis.", providers=["anthropic", "openai", "gemini"])
+
+
+class TestCompareModelOverrides:
+    def test_model_a_appears_in_output(self):
+        with _patches():
+            from bridgekit.compare import compare
+            result = compare("Some analysis.", model_a="claude-haiku-4-5-20251001")
+        assert "claude-haiku-4-5-20251001" in result
+
+    def test_model_b_appears_in_output(self):
+        with _patches():
+            from bridgekit.compare import compare
+            result = compare("Some analysis.", model_b="gpt-4-turbo")
+        assert "gpt-4-turbo" in result
+
+
+class TestCompareDefaultProviders:
+    def test_defaults_to_anthropic_and_openai(self):
+        with _patches():
+            from bridgekit.compare import compare
+            result = compare("Some analysis.")
+        assert "ANTHROPIC" in result
+        assert "OPENAI" in result
+
+    def test_default_models_shown(self):
+        with _patches():
+            from bridgekit.compare import compare
+            result = compare("Some analysis.")
+        assert "claude-opus-4-8" in result
+        assert "gpt-4o" in result
+
+
+class TestCompareSynthesis:
+    def test_synthesize_called_once(self):
+        with patch("bridgekit.compare._call_tool", side_effect=_make_call_tool_side_effect(DEFAULT_RESPONSES)):
+            with patch("bridgekit.compare._synthesize", return_value=FAKE_SUMMARY) as mock_syn:
+                from bridgekit.compare import compare
+                compare("Some analysis.")
+        mock_syn.assert_called_once()
+
+    def test_synthesize_receives_both_outputs(self):
+        captured = []
+
+        def capture_synth(results):
+            captured.extend(results)
+            return FAKE_SUMMARY
+
+        with patch("bridgekit.compare._call_tool", side_effect=_make_call_tool_side_effect(DEFAULT_RESPONSES)):
+            with patch("bridgekit.compare._synthesize", side_effect=capture_synth):
+                from bridgekit.compare import compare
+                compare("Some analysis.")
+
+        providers_seen = {r[0] for r in captured}
+        assert "anthropic" in providers_seen
+        assert "openai" in providers_seen
+
+
+class TestCompareApiCallShape:
+    def test_both_providers_called(self):
+        calls = []
+
+        def capture(tool_name, text, provider, model, kwargs):
+            calls.append(provider)
+            return "output"
+
+        with patch("bridgekit.compare._call_tool", side_effect=capture):
+            with patch("bridgekit.compare._synthesize", return_value=FAKE_SUMMARY):
+                from bridgekit.compare import compare
+                compare("Some analysis.")
+
+        assert sorted(calls) == ["anthropic", "openai"]
+
+    def test_user_text_passed_to_both_calls(self):
+        user_text = "Our conversion rate improved after the campaign."
+        seen_texts = []
+
+        def capture(tool_name, text, provider, model, kwargs):
+            seen_texts.append(text)
+            return "output"
+
+        with patch("bridgekit.compare._call_tool", side_effect=capture):
+            with patch("bridgekit.compare._synthesize", return_value=FAKE_SUMMARY):
+                from bridgekit.compare import compare
+                compare(user_text)
+
+        assert len(seen_texts) == 2
+        assert all(t == user_text for t in seen_texts)
+
+    def test_tool_name_passed_to_both_calls(self):
+        tool_names = []
+
+        def capture(tool_name, text, provider, model, kwargs):
+            tool_names.append(tool_name)
+            return "output"
+
+        with patch("bridgekit.compare._call_tool", side_effect=capture):
+            with patch("bridgekit.compare._synthesize", return_value=FAKE_SUMMARY):
+                from bridgekit.compare import compare
+                compare("Some analysis.", tool="redteam")
+
+        assert all(n == "redteam" for n in tool_names)
+
+    def test_kwargs_forwarded_to_tool(self):
+        received_kwargs = []
+
+        def capture(tool_name, text, provider, model, kwargs):
+            received_kwargs.append(kwargs)
+            return "output"
+
+        with patch("bridgekit.compare._call_tool", side_effect=capture):
+            with patch("bridgekit.compare._synthesize", return_value=FAKE_SUMMARY):
+                from bridgekit.compare import compare
+                compare("Some analysis.", max_tokens=2048)
+
+        assert all(kw.get("max_tokens") == 2048 for kw in received_kwargs)

{bridgekit-0.3.7 → bridgekit-0.3.9}/tests/test_planner.py

@@ -192,3 +192,33 @@ class TestPlanOptionalParameters:
                 content = str(messages_arg)
                 assert "5,000 users split 50/50." in content
                 assert "causal inference" in content
+
+
+class TestPlanMaxTokens:
+    """plan() should pass max_tokens through to the API."""
+
+    def test_default_max_tokens_is_1024(self):
+        with patch.dict(os.environ, {"ANTHROPIC_API_KEY": "test-key"}):
+            with patch("anthropic.Anthropic") as MockAnthropic:
+                mock_client = MagicMock()
+                mock_client.messages.create.return_value = _make_mock_message(FAKE_RESPONSE)
+                MockAnthropic.return_value = mock_client
+
+                from bridgekit.planner import plan
+                plan("Does our new onboarding flow increase upgrade rates?")
+
+                call_kwargs = mock_client.messages.create.call_args
+                assert call_kwargs.kwargs.get("max_tokens") == 1024
+
+    def test_custom_max_tokens_reaches_api(self):
+        with patch.dict(os.environ, {"ANTHROPIC_API_KEY": "test-key"}):
+            with patch("anthropic.Anthropic") as MockAnthropic:
+                mock_client = MagicMock()
+                mock_client.messages.create.return_value = _make_mock_message(FAKE_RESPONSE)
+                MockAnthropic.return_value = mock_client
+
+                from bridgekit.planner import plan
+                plan("Does our new onboarding flow increase upgrade rates?", max_tokens=2048)
+
+                call_kwargs = mock_client.messages.create.call_args
+                assert call_kwargs.kwargs.get("max_tokens") == 2048

{bridgekit-0.3.7 → bridgekit-0.3.9}/tests/test_redteam.py

@@ -153,3 +153,33 @@ class TestRedteamCustomSystemPrompt:
 
                 call_kwargs = mock_client.messages.create.call_args
                 assert call_kwargs.kwargs.get("system") == custom_prompt
+
+
+class TestRedteamMaxTokens:
+    """redteam() should pass max_tokens through to the API."""
+
+    def test_default_max_tokens_is_1024(self):
+        with patch.dict(os.environ, {"ANTHROPIC_API_KEY": "test-key"}):
+            with patch("anthropic.Anthropic") as MockAnthropic:
+                mock_client = MagicMock()
+                mock_client.messages.create.return_value = _make_mock_message(FAKE_RESPONSE)
+                MockAnthropic.return_value = mock_client
+
+                from bridgekit.redteam import redteam
+                redteam("Some analysis text.")
+
+                call_kwargs = mock_client.messages.create.call_args
+                assert call_kwargs.kwargs.get("max_tokens") == 1024
+
+    def test_custom_max_tokens_reaches_api(self):
+        with patch.dict(os.environ, {"ANTHROPIC_API_KEY": "test-key"}):
+            with patch("anthropic.Anthropic") as MockAnthropic:
+                mock_client = MagicMock()
+                mock_client.messages.create.return_value = _make_mock_message(FAKE_RESPONSE)
+                MockAnthropic.return_value = mock_client
+
+                from bridgekit.redteam import redteam
+                redteam("Some analysis text.", max_tokens=2048)
+
+                call_kwargs = mock_client.messages.create.call_args
+                assert call_kwargs.kwargs.get("max_tokens") == 2048

{bridgekit-0.3.7 → bridgekit-0.3.9}/tests/test_reviewer.py

@@ -176,3 +176,33 @@ class TestEvaluateCustomSystemPrompt:
 
                 call_kwargs = mock_client.messages.create.call_args
                 assert call_kwargs.kwargs.get("system") == custom_prompt
+
+
+class TestEvaluateMaxTokens:
+    """evaluate() should pass max_tokens through to the API."""
+
+    def test_default_max_tokens_is_1024(self):
+        with patch.dict(os.environ, {"ANTHROPIC_API_KEY": "test-key"}):
+            with patch("anthropic.Anthropic") as MockAnthropic:
+                mock_client = MagicMock()
+                mock_client.messages.create.return_value = _make_mock_message(FAKE_RESPONSE)
+                MockAnthropic.return_value = mock_client
+
+                from bridgekit.reviewer import evaluate
+                evaluate("Some analysis text.")
+
+                call_kwargs = mock_client.messages.create.call_args
+                assert call_kwargs.kwargs.get("max_tokens") == 1024
+
+    def test_custom_max_tokens_reaches_api(self):
+        with patch.dict(os.environ, {"ANTHROPIC_API_KEY": "test-key"}):
+            with patch("anthropic.Anthropic") as MockAnthropic:
+                mock_client = MagicMock()
+                mock_client.messages.create.return_value = _make_mock_message(FAKE_RESPONSE)
+                MockAnthropic.return_value = mock_client
+
+                from bridgekit.reviewer import evaluate
+                evaluate("Some analysis text.", max_tokens=2048)
+
+                call_kwargs = mock_client.messages.create.call_args
+                assert call_kwargs.kwargs.get("max_tokens") == 2048

{bridgekit-0.3.7 → bridgekit-0.3.9}/tests/test_search.py

@@ -257,3 +257,45 @@ class TestAskWithSourceFolder:
                     from bridgekit.search import ask
                     with pytest.raises(ValueError, match="No content found"):
                         ask("What happened?", source=tmpdir)
+
+
+class TestAskMaxTokens:
+    """ask() should pass max_tokens through to the API."""
+
+    def test_default_max_tokens_is_1024(self):
+        mock_chromadb, mock_ef = _make_mock_chromadb()
+        with patch.dict(os.environ, {"ANTHROPIC_API_KEY": "test-key"}):
+            with patch("anthropic.Anthropic") as MockAnthropic, \
+                 patch("chromadb.Client", mock_chromadb.Client), \
+                 patch(
+                     "chromadb.utils.embedding_functions.SentenceTransformerEmbeddingFunction",
+                     mock_ef,
+                 ):
+                mock_client = MagicMock()
+                mock_client.messages.create.return_value = _make_mock_message(FAKE_ANSWER)
+                MockAnthropic.return_value = mock_client
+
+                from bridgekit.search import ask
+                ask("What was the conversion rate?", text="The conversion rate increased by 12%.")
+
+                call_kwargs = mock_client.messages.create.call_args
+                assert call_kwargs.kwargs.get("max_tokens") == 1024
+
+    def test_custom_max_tokens_reaches_api(self):
+        mock_chromadb, mock_ef = _make_mock_chromadb()
+        with patch.dict(os.environ, {"ANTHROPIC_API_KEY": "test-key"}):
+            with patch("anthropic.Anthropic") as MockAnthropic, \
+                 patch("chromadb.Client", mock_chromadb.Client), \
+                 patch(
+                     "chromadb.utils.embedding_functions.SentenceTransformerEmbeddingFunction",
+                     mock_ef,
+                 ):
+                mock_client = MagicMock()
+                mock_client.messages.create.return_value = _make_mock_message(FAKE_ANSWER)
+                MockAnthropic.return_value = mock_client
+
+                from bridgekit.search import ask
+                ask("What was the conversion rate?", text="The conversion rate increased by 12%.", max_tokens=2048)
+
+                call_kwargs = mock_client.messages.create.call_args
+                assert call_kwargs.kwargs.get("max_tokens") == 2048