Version v0.9.9 done

Author: zacharias1219

aideator/search/providers.py

@@ -12,6 +12,18 @@
 from typing import Any
 
 
+class SignalType(str, Enum):
+    """Categories for signal evidence quality and type."""
+
+    PAIN_COMPLAINT = "pain_complaint"
+    FEATURE_REQUEST = "feature_request"
+    COMPETITOR_WEAKNESS = "competitor_weakness"
+    MARKET_DATA = "market_data"
+    ANECDOTAL_POSITIVE = "anecdotal_positive"
+    SEO_FILLER = "seo_filler"
+    UNSPECIFIED = "unspecified"
+
+
 class ProviderStatus(Enum):
     """Health check status for search providers."""
 
@@ -33,13 +45,17 @@ class SearchResult:
         snippet: Text excerpt / summary
         source: Provider that returned this result (e.g. 'tavily', 'builtin')
         score: Relevance score (0.0 to 1.0, provider-dependent)
+        signal_type: Categorized type of signal (e.g. 'pain_complaint')
+        confidence: Confidence score in the classification (0.0 to 1.0)
     """
 
     title: str
     url: str
     snippet: str
     source: str = ""
     score: float = 0.0
+    signal_type: SignalType = SignalType.UNSPECIFIED
+    confidence: float = 0.0
 
 
 @dataclass(frozen=True)

api/web.py

@@ -137,6 +137,10 @@ def _idea_rows(user_id: UUID | None = None) -> list[dict[str, object]]:
                 "created_at": _fmt_ts(idea.created_at),
                 "runs_count": len(idea_runs),
                 "last_run_status": last_run.status if last_run else "pending",
+                "validation_status": (
+                    idea.status.value if hasattr(idea.status, "value") 
+                    else str(idea.status)
+                ),
             }
         )
     rows.sort(key=lambda item: str(item["created_at"]), reverse=True)
@@ -489,6 +493,10 @@ def idea_detail_page(request: Request, idea_id: UUID) -> HTMLResponse:
                 "target_user": idea.target_user,
                 "context": idea.context,
                 "created_at": _fmt_ts(idea.created_at),
+                "status": (
+                    idea.status.value if hasattr(idea.status, "value")
+                    else str(idea.status)
+                ),
             },
             "runs": _run_rows(idea_filter=idea_id),
             "available_modes": ["local-only", "hybrid", "cloud-enabled"],

db/ideas.py

@@ -7,7 +7,7 @@
 
 from db.base import db_session, initialize_db
 from db.schema import IdeaModel, WorkspaceMemberModel
-from models.idea import Idea
+from models.idea import Idea, ValidationStatus
 
 LOGGER = logging.getLogger("db.ideas")
 
@@ -27,6 +27,7 @@ def _to_model(idea: Idea) -> IdeaModel:
         created_at=idea.created_at,
         tier=idea.tier,
         brand_hex=idea.brand_hex,
+        validation_status=idea.status.value if hasattr(idea.status, "value") else str(idea.status),
         workspace_id=str(idea.workspace_id) if idea.workspace_id else None,
     )
 
@@ -39,6 +40,7 @@ def _from_model(model: IdeaModel) -> Idea:
         context=model.context,
         tier=model.tier or "Bronze",
         brand_hex=model.brand_hex or "#888888",
+        status=ValidationStatus(model.validation_status or "desk_research"),
         workspace_id=UUID(model.workspace_id) if model.workspace_id else None,
     )
     idea.idea_id = UUID(model.idea_id)
@@ -57,6 +59,10 @@ def save_idea(idea: Idea, user_id: UUID | None = None) -> Idea:
             model.context = idea.context
             model.tier = idea.tier
             model.brand_hex = idea.brand_hex
+            model.validation_status = (
+                idea.status.value if hasattr(idea.status, "value")
+                else str(idea.status)
+            )
             if idea.workspace_id:
                 model.workspace_id = str(idea.workspace_id)
             if user_id:

db/schema.py

@@ -27,6 +27,7 @@ class IdeaModel(Base):
     )
     tier: Mapped[str | None] = mapped_column(String(50), default="Bronze")
     brand_hex: Mapped[str | None] = mapped_column(String(7), default="#888888")
+    validation_status: Mapped[str] = mapped_column(String(50), default="desk_research")
     user_id: Mapped[str | None] = mapped_column(
         String(36), ForeignKey("users.user_id"), nullable=True
     )

docs/idea-11111111-1111-1111-1111-111111111111.md

@@ -1,5 +1,8 @@
 # Idea Report 11111111-1111-1111-1111-111111111111
 
+## 🏆 Current Validation Phase
+**Stage:** `Desk Research`
+
 <div class="reveal">
 ## Market Demand — <span class="score-display animate-score" data-target="62">0</span>/100
 **Executive Summary:** Early demand is plausible but needs focused validation.

engine/analyst.py

@@ -2,6 +2,7 @@
 
 import json
 import logging
+from typing import Any
 
 from aideator.llm.registry import get_provider
 from api.config import settings
@@ -13,7 +14,7 @@ async def analyze_dimensions(
     *,
     title: str,
     description: str,
-    citations: list[dict[str, str]],
+    citations: list[dict[str, Any]],
 ) -> dict[str, object]:
     """Analyze collected signals across dimensions.
 
@@ -32,7 +33,13 @@ async def analyze_dimensions(
         provider = get_provider(settings)
 
         signals_text = "\n".join(
-            [f"- [{c['source_id']}] {c['content']} (URL: {c['url']})" for c in citations]
+            [
+                f"- [{c['source_id']}] "
+                f"[Type: {c.get('type', 'unknown')}, "
+                f"Confidence: {c.get('confidence', 0.5)}] "
+                f"{c['content']} (URL: {c['url']})"
+                for c in citations
+            ]
         )
 
         prompt = f"""You are a High-Precision Market Analyst. 
@@ -51,6 +58,13 @@ async def analyze_dimensions(
 4. MARKET_SIZING: Based on signals, estimate the TAM (Total Addressable Market),
    SAM (Serviceable Addressable Market), and SOM (Serviceable Obtainable Market) in USD.
 
+WEIGHTING RULES:
+- PRIORITIZE signals with type 'pain_complaint', 'feature_request', or 'competitor_weakness'.
+  These are high-intent signals.
+- TREAT signals with type 'seo_filler' or low confidence (< 0.4) as noise.
+  Do not let them drive major score changes.
+- HIGH CONFIDENCE 'pain_complaint' is your strongest evidence for Demand.
+
 For each of the first three dimensions, provide:
 - "strengths": Signals clearly supporting the case.
 - "weaknesses": Signals suggesting risks or lack of market fit.

engine/battle.py

@@ -15,7 +15,7 @@
 class BattleOrchestrator:
     """Orchestrates Bull and Bear agents for adversarial analysis."""
 
-    def __init__(self, title: str, description: str, signals: list[dict[str, str]]):
+    def __init__(self, title: str, description: str, signals: list[dict[str, Any]]):
         self.title = title
         self.description = description
         self.signals = signals

engine/experiments.py

@@ -0,0 +1,117 @@
+"""Experiment Engine for generating behavioral validation kits (Smoke Tests)."""
+
+from __future__ import annotations
+
+import json
+import logging
+from typing import Any
+
+from aideator.llm.registry import get_provider
+from models.report import ExperimentKit
+
+LOGGER = logging.getLogger("engine.experiments")
+
+
+async def generate_experiment_kit(
+    *,
+    title: str,
+    description: str,
+    analysis_results: dict[str, Any] | None = None,
+) -> ExperimentKit:
+    """Generate a behavioral experiment blueprint based on the idea and analysis.
+
+    Args:
+        title: Idea title.
+        description: Idea description.
+        analysis_results: Results from Dimensional Analysis for context.
+
+    Returns:
+        ExperimentKit object with copy, metrics, and tools.
+    """
+    try:
+        from api.config import settings
+        provider = get_provider(settings)
+
+        # Context from analysis if available
+        if analysis_results and "details" in analysis_results:
+            context_text = analysis_results["details"][:200]
+        else:
+            context_text = "the core problem"
+
+        prompt = f"""You are an Expert Growth Marketer and Experiment Designer.
+Your task is to design a "Smoke Test" experiment for a new business idea.
+
+IDEA:
+Title: {title}
+Description: {description}
+Context: {context_text}
+
+The experiment should be designed to move from "intent" (interviews) 
+to "commitment" (behavioral data).
+
+GENERATION RULES:
+1. HYPOTHESIS: State it as "If I [action], then [number/percent] of 
+   [audience] will [commitment action]."
+2. LANDING PAGE COPY: Use the PAS (Problem, Agitation, Solution) framework.
+   - Headline: Attention-grabbing benefit.
+   - Hero Subheadline: Clear value prop.
+   - Pain Points: 3 bullet points that hurt.
+   - Solution: How we fix it.
+   - CTA: Strong action (e.g., "Join the Early Access", "Pre-order Now").
+3. SUCCESS METRIC: Define a "Fail-Fast" threshold for a 48-hour or 1-week test.
+4. TOOL STACK: Recommend 2-3 specific no-code tools (e.g., Carrd, Framer, Tally, Loops, Stripe).
+
+Return a JSON object with:
+{{
+  "hypothesis": "...",
+  "method": "Smoke Test / Landing Page",
+  "landing_page_copy": {{
+    "headline": "...",
+    "subheadline": "...",
+    "pain_points": ["...", "...", "..."],
+    "solution": "...",
+    "cta": "..."
+  }},
+  "success_metric": "...",
+  "tool_stack": ["...", "..."]
+}}
+"""
+        messages = [{"role": "user", "content": prompt}]
+        response = await provider.generate(messages, temperature=0.3)
+        
+        content = response.content.strip()
+        if "```json" in content:
+            content = content.split("```json")[1].split("```")[0].strip()
+        elif "```" in content:
+            content = content.split("```")[1].split("```")[0].strip()
+
+        data = json.loads(content)
+        
+        # Ensure landing_page_copy is flattened correctly if needed, 
+        # but our model expects a dict[str, str]. 
+        # Let's adjust the data to match dict[str, str] by joining pain points.
+        copy = data.get("landing_page_copy", {})
+        if isinstance(copy.get("pain_points"), list):
+            copy["pain_points"] = "\n".join(copy["pain_points"])
+            
+        return ExperimentKit(
+            hypothesis=data.get("hypothesis", "If I launch a landing page, people will sign up."),
+            method=data.get("method", "Smoke Test"),
+            landing_page_copy=copy,
+            success_metric=data.get("success_metric", "5% conversion rate"),
+            tool_stack=data.get("tool_stack", ["Carrd", "Tally"])
+        )
+
+    except Exception as e:
+        LOGGER.warning(f"Experiment generation failed: {e}")
+        return ExperimentKit(
+            hypothesis=f"If I build a landing page for {title}, people will express interest.",
+            method="Smoke Test",
+            landing_page_copy={
+                "headline": f"Stop struggling with {title}",
+                "subheadline": description[:100],
+                "cta": "Get Early Access"
+            },
+            success_metric="10 signups from 200 visits",
+            tool_stack=["Carrd", "Typeform"]
+        )

engine/interviewer.py

@@ -0,0 +1,113 @@
+"""Engine for generating actionable user interview toolkits."""
+
+from __future__ import annotations
+
+import json
+import logging
+from typing import Any
+
+from aideator.llm.registry import get_provider
+from api.config import settings
+from models.report import InterviewKit
+
+LOGGER = logging.getLogger("engine.interviewer")
+
+async def generate_interview_kit(
+    *,
+    title: str,
+    description: str,
+    analysis: dict[str, Any],
+    signals: list[dict[str, Any]]
+) -> InterviewKit:
+    """Generate a customized interview kit based on validation results.
+    
+    Args:
+        title: Idea title
+        description: Idea description
+        analysis: Dimensional analysis results from Node 2
+        signals: Classified citations with weights
+        
+    Returns:
+        InterviewKit object
+    """
+    try:
+        provider = get_provider(settings)
+
+        # Identify the weakest dimension to focus the interview on
+        # Analysis structure: {"demand": {"strengths": [], "weaknesses": [], ...}, ...}
+        dimensions = ["demand", "competition", "viability"]
+        weakness_counts = {d: len(analysis.get(d, {}).get("weaknesses", [])) for d in dimensions}
+        # Sort by most weaknesses
+        primary_focus = max(weakness_counts, key=lambda k: weakness_counts[k])
+        
+        signals_summary = "\n".join([
+            f"- [{s.get('source_id')}] Type: {s.get('type')}, "
+            f"Content: {(s.get('content') or '')[:100]}..."
+            for s in signals[:5]
+        ])
+
+        prompt = f"""You are a Master User Researcher specialized in "The Mom Test" methodology.
+Your goal is to create a User Interview Toolkit for the business idea: "{title}".
+
+CONTEXT:
+{description}
+
+CURRENT FINDINGS:
+- Primary Risk Area: {primary_focus.upper()}
+- Signals Found:
+{signals_summary}
+
+TASK:
+Generate an interview toolkit that helps the user validate their riskiest assumptions
+through real conversations.
+
+REQUIREMENTS:
+1. SCRIPT: 5-7 non-leading questions. Focus on the user's PAST behavior, not their future opinions.
+   Include a "Rationale" for each question (e.g. "To test if they currently spend money on X").
+2. OUTREACH: 3 templates (LinkedIn, Email, Reddit/Discord) that are short, personal, and NOT salesy.
+3. TRACKER: 5-8 column headers for a spreadsheet to track responses.
+   (e.g. "Current Solution", "Monthly Pain Score (1-10)", "Budget Owner?").
+
+Return ONLY a JSON object with this structure:
+{{
+  "script": [
+    {{ "question": "...", "rationale": "..." }}
+  ],
+  "outreach_templates": {{
+    "linkedin": "...",
+    "email": "...",
+    "reddit": "..."
+  }},
+  "response_tracker": ["Column 1", "Column 2", ...]
+}}
+"""
+        messages = [{"role": "user", "content": prompt}]
+        response = await provider.generate(messages, temperature=0.5)
+        
+        content = response.content.strip()
+        if "```json" in content:
+            content = content.split("```json")[1].split("```")[0].strip()
+        elif "```" in content:
+            content = content.split("```")[1].split("```")[0].strip()
+
+        data = json.loads(content)
+        
+        return InterviewKit(
+            script=data.get("script", []),
+            outreach_templates=data.get("outreach_templates", {}),
+            response_tracker=data.get("response_tracker", [])
+        )
+
+    except Exception as e:
+        LOGGER.error(f"Interview kit generation failed: {e}", exc_info=True)
+        # Fallback to a generic kit
+        return InterviewKit(
+            script=[{
+                "question": "Can you tell me about the last time you tried to solve [Problem]?",
+                "rationale": "Discovery"
+            }],
+            outreach_templates={
+                "email": "Hi, I'm researching [Problem] and would love to hear your story."
+            },
+            response_tracker=["Name", "Role", "Last Time Problem Occurred", "Current Workaround"]
+        )