crowdmind 0.1.0__py3-none-any.whl

crowdmind/__init__.py

@@ -0,0 +1,22 @@
+"""
+CrowdMind - AI-Powered Research & Validation for Products
+
+Validate your product ideas with simulated user panels,
+research market pain points, and generate feature ideas.
+"""
+
+__version__ = "0.1.0"
+
+from crowdmind.validate.panel import run_evaluation as analyze
+from crowdmind.validate.panel import run_evaluation as validate
+from crowdmind.research.multi import run_multi_research as research
+from crowdmind.validate.personas import Persona, PersonaPack
+
+__all__ = [
+    "analyze",
+    "validate", 
+    "research",
+    "Persona",
+    "PersonaPack",
+    "__version__",
+]

crowdmind/cli.py

@@ -0,0 +1,371 @@
+"""
+CrowdMind CLI
+
+A command-line interface for product research and validation.
+"""
+
+import typer
+from pathlib import Path
+from typing import Optional, List
+from rich.console import Console
+from rich.table import Table
+from rich.panel import Panel
+from rich.progress import Progress, SpinnerColumn, TextColumn
+
+app = typer.Typer(
+    name="crowdmind",
+    help="AI-Powered Research & Validation for Products",
+    no_args_is_help=True,
+)
+
+console = Console()
+
+
+# Common options
+def common_options(func):
+    """Decorator for common CLI options."""
+    func = typer.Option(None, "--personas", "-p", help="Number of personas to use")(func)
+    return func
+
+
+@app.command()
+def analyze(
+    path: Path = typer.Argument(..., help="Path to project or README file"),
+    personas: int = typer.Option(10, "--personas", "-p", help="Number of personas"),
+    pack: Optional[str] = typer.Option(None, "--pack", help="Persona pack (developers, enterprise, mixed)"),
+    users: Optional[List[str]] = typer.Option(None, "--users", "-u", help="Custom user types"),
+    provider: str = typer.Option("anthropic", "--provider", help="LLM provider"),
+    model: Optional[str] = typer.Option(None, "--model", "-m", help="Model to use"),
+    output: Optional[Path] = typer.Option(None, "--output", "-o", help="Output file"),
+    verbose: bool = typer.Option(False, "--verbose", "-v", help="Verbose output"),
+    quiet: bool = typer.Option(False, "--quiet", "-q", help="Minimal output"),
+):
+    """
+    Run full analysis pipeline on a project.
+    
+    Includes: codebase analysis, research, ideation, and validation.
+    """
+    from crowdmind.research.codebase import run_analysis as analyze_codebase
+    from crowdmind.research.multi import run_multi_research
+    from crowdmind.ideate.features import run_ideation
+    from crowdmind.validate.panel import run_evaluation
+    from crowdmind.report.markdown import generate_report
+    
+    if not quiet:
+        console.print(Panel.fit(
+            "[bold blue]CrowdMind Analysis[/bold blue]\n"
+            f"Project: {path}",
+            border_style="blue"
+        ))
+    
+    results = {}
+    
+    with Progress(
+        SpinnerColumn(),
+        TextColumn("[progress.description]{task.description}"),
+        console=console,
+        disable=quiet,
+    ) as progress:
+        # Step 1: Codebase analysis
+        task = progress.add_task("Analyzing codebase...", total=None)
+        results["codebase"] = analyze_codebase(path, verbose=verbose)
+        progress.update(task, completed=True)
+        
+        # Step 2: Research
+        task = progress.add_task("Researching market...", total=None)
+        results["research"] = run_multi_research(use_cache=True, verbose=verbose)
+        progress.update(task, completed=True)
+        
+        # Step 3: Ideation
+        task = progress.add_task("Generating ideas...", total=None)
+        results["ideation"] = run_ideation(num_ideas=5, verbose=verbose)
+        progress.update(task, completed=True)
+        
+        # Step 4: Validation
+        task = progress.add_task("Validating with personas...", total=None)
+        readme_path = path / "README.md" if path.is_dir() else path
+        if readme_path.exists():
+            readme_content = readme_path.read_text()
+            results["validation"] = run_evaluation(
+                readme_content=readme_content,
+                verbose=verbose,
+                num_agents=personas,
+            )
+        progress.update(task, completed=True)
+    
+    # Generate report
+    report = generate_report(results)
+    
+    if output:
+        output.write_text(report)
+        if not quiet:
+            console.print(f"\n[green]Report saved to:[/green] {output}")
+    else:
+        console.print(report)
+    
+    # Summary
+    if not quiet and results.get("validation"):
+        val = results["validation"]
+        console.print(Panel(
+            f"[bold]Star Rate:[/bold] {val.get('star_rate', 0)}%\n"
+            f"[bold]Avg Score:[/bold] {val.get('avg_star', 0)}/10\n"
+            f"[bold]Personas:[/bold] {val.get('agents_evaluated', 0)}",
+            title="Validation Summary",
+            border_style="green" if val.get('star_rate', 0) >= 50 else "yellow"
+        ))
+
+
+@app.command()
+def validate(
+    idea: str = typer.Argument(..., help="Idea or README content to validate"),
+    personas: int = typer.Option(10, "--personas", "-p", help="Number of personas"),
+    pack: Optional[str] = typer.Option(None, "--pack", help="Persona pack"),
+    categories: Optional[List[str]] = typer.Option(None, "--categories", "-c", help="Persona categories"),
+    provider: str = typer.Option("anthropic", "--provider", help="LLM provider"),
+    model: Optional[str] = typer.Option(None, "--model", "-m", help="Model to use"),
+    output: Optional[Path] = typer.Option(None, "--output", "-o", help="Output file (JSON)"),
+    verbose: bool = typer.Option(False, "--verbose", "-v", help="Verbose output"),
+    quiet: bool = typer.Option(False, "--quiet", "-q", help="Minimal output"),
+):
+    """
+    Validate a single idea with AI personas.
+    
+    Pass a product description, README content, or path to README file.
+    """
+    from crowdmind.validate.panel import run_evaluation
+    import json
+    
+    # Check if idea is a file path
+    idea_path = Path(idea)
+    if idea_path.exists():
+        content = idea_path.read_text()
+    else:
+        content = idea
+    
+    if not quiet:
+        console.print(Panel.fit(
+            "[bold blue]CrowdMind Validation[/bold blue]\n"
+            f"Personas: {personas}",
+            border_style="blue"
+        ))
+    
+    result = run_evaluation(
+        readme_content=content,
+        verbose=verbose and not quiet,
+        num_agents=personas,
+        categories=categories,
+    )
+    
+    if output:
+        output.write_text(json.dumps(result, indent=2))
+        if not quiet:
+            console.print(f"\n[green]Results saved to:[/green] {output}")
+    
+    # Display results
+    if not quiet:
+        table = Table(title="Validation Results")
+        table.add_column("Metric", style="cyan")
+        table.add_column("Value", style="green")
+        
+        table.add_row("Star Rate", f"{result.get('star_rate', 0)}%")
+        table.add_row("Avg Star Likelihood", f"{result.get('avg_star', 0)}/10")
+        table.add_row("Total Score", f"{result.get('total_score', 0)}/100")
+        table.add_row("Personas Evaluated", str(result.get("agents_evaluated", 0)))
+        
+        console.print(table)
+        
+        # Category breakdown
+        if result.get("by_category"):
+            console.print("\n[bold]By Category:[/bold]")
+            for cat, data in sorted(result["by_category"].items(), key=lambda x: x[1]["avg"], reverse=True):
+                console.print(f"  {cat}: {data['avg']}/10")
+
+
+@app.command()
+def research(
+    path: Optional[Path] = typer.Argument(None, help="Path to project (optional)"),
+    sources: List[str] = typer.Option(
+        ["reddit", "hackernews", "github"], 
+        "--sources", "-s", 
+        help="Sources to research"
+    ),
+    topics: Optional[List[str]] = typer.Option(None, "--topics", "-t", help="Custom topics to search"),
+    no_cache: bool = typer.Option(False, "--no-cache", help="Skip cache"),
+    output: Optional[Path] = typer.Option(None, "--output", "-o", help="Output file"),
+    verbose: bool = typer.Option(False, "--verbose", "-v", help="Verbose output"),
+    quiet: bool = typer.Option(False, "--quiet", "-q", help="Minimal output"),
+):
+    """
+    Research market pain points from multiple sources.
+    
+    Sources: reddit, hackernews, github
+    """
+    from crowdmind.research.multi import run_multi_research, get_multi_research_summary
+    import json
+    
+    if not quiet:
+        console.print(Panel.fit(
+            "[bold blue]CrowdMind Research[/bold blue]\n"
+            f"Sources: {', '.join(sources)}",
+            border_style="blue"
+        ))
+    
+    result = run_multi_research(
+        use_cache=not no_cache,
+        verbose=verbose and not quiet,
+        sources=sources,
+    )
+    
+    if output:
+        output.write_text(json.dumps(result, indent=2))
+        if not quiet:
+            console.print(f"\n[green]Results saved to:[/green] {output}")
+    
+    # Display summary
+    if not quiet:
+        summary = get_multi_research_summary()
+        console.print(summary)
+
+
+@app.command()
+def market(
+    path: Path = typer.Argument(..., help="Path to project or README"),
+    personas: int = typer.Option(10, "--personas", "-p", help="Number of buyer personas"),
+    no_cache: bool = typer.Option(False, "--no-cache", help="Skip cache"),
+    output: Optional[Path] = typer.Option(None, "--output", "-o", help="Output file"),
+    verbose: bool = typer.Option(False, "--verbose", "-v", help="Verbose output"),
+    quiet: bool = typer.Option(False, "--quiet", "-q", help="Minimal output"),
+):
+    """
+    Run market analysis on a project.
+    
+    Includes: buyer personas, pricing analysis, success predictions.
+    """
+    from crowdmind.market.analysis import run_full_market_analysis, get_market_summary
+    import json
+    
+    if not quiet:
+        console.print(Panel.fit(
+            "[bold blue]CrowdMind Market Analysis[/bold blue]\n"
+            f"Project: {path}",
+            border_style="blue"
+        ))
+    
+    result = run_full_market_analysis(
+        project_path=path,
+        use_cache=not no_cache,
+        verbose=verbose and not quiet,
+    )
+    
+    if output:
+        output.write_text(json.dumps(result, indent=2))
+        if not quiet:
+            console.print(f"\n[green]Results saved to:[/green] {output}")
+    
+    if not quiet:
+        summary = get_market_summary()
+        console.print(summary)
+
+
+@app.command()
+def personas():
+    """
+    Interactive wizard to create custom personas.
+    
+    [Stub - Coming soon]
+    """
+    from crowdmind.validate.personas import PERSONA_PACKS, Persona
+    
+    console.print(Panel.fit(
+        "[bold blue]CrowdMind Personas[/bold blue]\n"
+        "Interactive persona creation wizard",
+        border_style="blue"
+    ))
+    
+    console.print("\n[bold]Available Persona Packs:[/bold]")
+    for name, pack in PERSONA_PACKS.items():
+        console.print(f"  [cyan]{name}[/cyan]: {pack.description} ({len(pack.personas)} personas)")
+    
+    console.print("\n[yellow]Interactive wizard coming soon![/yellow]")
+    console.print("For now, use --pack option with validate/analyze commands.")
+
+
+@app.command()
+def demo():
+    """
+    Show a demo of CrowdMind capabilities.
+    
+    [Stub - Coming soon]
+    """
+    console.print(Panel.fit(
+        "[bold blue]CrowdMind Demo[/bold blue]\n"
+        "Interactive demonstration",
+        border_style="blue"
+    ))
+    
+    console.print("\n[yellow]Demo mode coming soon![/yellow]")
+    console.print("\nTry these commands instead:")
+    console.print("  [cyan]crowdmind validate \"My SaaS idea description\"[/cyan]")
+    console.print("  [cyan]crowdmind research --sources reddit hackernews[/cyan]")
+    console.print("  [cyan]crowdmind analyze ./my-project[/cyan]")
+
+
+@app.command()
+def config():
+    """
+    Setup wizard for CrowdMind configuration.
+    
+    [Stub - Coming soon]
+    """
+    from crowdmind.config import CONFIG_FILE, get_config
+    
+    console.print(Panel.fit(
+        "[bold blue]CrowdMind Configuration[/bold blue]",
+        border_style="blue"
+    ))
+    
+    cfg = get_config()
+    
+    console.print(f"\n[bold]Config file:[/bold] {CONFIG_FILE}")
+    console.print(f"[bold]Config exists:[/bold] {CONFIG_FILE.exists()}")
+    
+    console.print("\n[bold]Current Settings:[/bold]")
+    console.print(f"  Default model: {cfg.default_model}")
+    console.print(f"  Default personas: {cfg.default_personas}")
+    console.print(f"  Default provider: {cfg.default_provider}")
+    console.print(f"  Cache dir: {cfg.cache_dir}")
+    
+    console.print("\n[bold]API Keys:[/bold]")
+    console.print(f"  OpenAI: {'[green]configured[/green]' if cfg.openai_api_key else '[red]not set[/red]'}")
+    console.print(f"  Anthropic: {'[green]configured[/green]' if cfg.anthropic_api_key else '[red]not set[/red]'}")
+    console.print(f"  Google: {'[green]configured[/green]' if cfg.google_api_key else '[red]not set[/red]'}")
+    console.print(f"  Groq: {'[green]configured[/green]' if cfg.groq_api_key else '[red]not set[/red]'}")
+    console.print(f"  GitHub: {'[green]configured[/green]' if cfg.github_token else '[red]not set[/red]'}")
+    
+    console.print("\n[yellow]Interactive setup wizard coming soon![/yellow]")
+    console.print("\nFor now, set environment variables:")
+    console.print("  export ANTHROPIC_API_KEY=your-key")
+    console.print("  export CROWDMIND_MODEL=claude-sonnet-4-6")
+    console.print("  export CROWDMIND_PERSONAS=15")
+
+
+@app.callback()
+def main_callback(
+    version: bool = typer.Option(False, "--version", "-V", help="Show version"),
+):
+    """
+    CrowdMind - AI-Powered Research & Validation for Products
+    """
+    if version:
+        from crowdmind import __version__
+        console.print(f"crowdmind version {__version__}")
+        raise typer.Exit()
+
+
+def main():
+    """Entry point for the CLI."""
+    app()
+
+
+if __name__ == "__main__":
+    main()

crowdmind/config.py

@@ -0,0 +1,177 @@
+"""
+CrowdMind Configuration
+
+Loads configuration from:
+1. ~/.crowdmind/config.yaml
+2. Environment variables
+"""
+
+import os
+from pathlib import Path
+from typing import Optional, Dict, Any
+from dataclasses import dataclass, field
+
+try:
+    import yaml
+    HAS_YAML = True
+except ImportError:
+    HAS_YAML = False
+
+
+CONFIG_DIR = Path.home() / ".crowdmind"
+CONFIG_FILE = CONFIG_DIR / "config.yaml"
+
+
+@dataclass
+class CrowdMindConfig:
+    """Configuration for CrowdMind."""
+    
+    # API Keys
+    openai_api_key: Optional[str] = None
+    anthropic_api_key: Optional[str] = None
+    google_api_key: Optional[str] = None
+    groq_api_key: Optional[str] = None
+    github_token: Optional[str] = None
+    
+    # Default settings
+    default_model: str = "claude-sonnet-4-6"
+    default_personas: int = 10
+    default_provider: str = "anthropic"
+    
+    # Cache settings
+    cache_dir: Path = field(default_factory=lambda: CONFIG_DIR / "cache")
+    cache_hours: int = 12
+    
+    # Output settings
+    output_dir: Path = field(default_factory=lambda: Path.cwd() / "crowdmind_output")
+    
+    # Research settings
+    reddit_subreddits: list = field(default_factory=lambda: [
+        "programming", "webdev", "devops", "startups", "SaaS"
+    ])
+    
+    @classmethod
+    def load(cls) -> "CrowdMindConfig":
+        """Load configuration from file and environment variables."""
+        config = cls()
+        
+        # Load from YAML if available
+        if HAS_YAML and CONFIG_FILE.exists():
+            try:
+                with open(CONFIG_FILE) as f:
+                    yaml_config = yaml.safe_load(f) or {}
+                config = cls._from_dict(yaml_config)
+            except Exception:
+                pass
+        
+        # Override with environment variables
+        config.openai_api_key = os.getenv("OPENAI_API_KEY", config.openai_api_key)
+        config.anthropic_api_key = os.getenv("ANTHROPIC_API_KEY", config.anthropic_api_key)
+        config.google_api_key = os.getenv("GOOGLE_API_KEY", config.google_api_key)
+        config.groq_api_key = os.getenv("GROQ_API_KEY", config.groq_api_key)
+        config.github_token = os.getenv("GITHUB_TOKEN", config.github_token)
+        
+        # CrowdMind-specific env vars
+        if os.getenv("CROWDMIND_MODEL"):
+            config.default_model = os.getenv("CROWDMIND_MODEL")
+        if os.getenv("CROWDMIND_PERSONAS"):
+            try:
+                config.default_personas = int(os.getenv("CROWDMIND_PERSONAS"))
+            except ValueError:
+                pass
+        if os.getenv("CROWDMIND_PROVIDER"):
+            config.default_provider = os.getenv("CROWDMIND_PROVIDER")
+        
+        return config
+    
+    @classmethod
+    def _from_dict(cls, data: Dict[str, Any]) -> "CrowdMindConfig":
+        """Create config from dictionary."""
+        config = cls()
+        
+        # API keys
+        api_keys = data.get("api_keys", {})
+        config.openai_api_key = api_keys.get("openai")
+        config.anthropic_api_key = api_keys.get("anthropic")
+        config.google_api_key = api_keys.get("google")
+        config.groq_api_key = api_keys.get("groq")
+        config.github_token = api_keys.get("github")
+        
+        # Defaults
+        defaults = data.get("defaults", {})
+        config.default_model = defaults.get("model", config.default_model)
+        config.default_personas = defaults.get("personas", config.default_personas)
+        config.default_provider = defaults.get("provider", config.default_provider)
+        
+        # Cache
+        cache = data.get("cache", {})
+        if cache.get("dir"):
+            config.cache_dir = Path(cache["dir"]).expanduser()
+        config.cache_hours = cache.get("hours", config.cache_hours)
+        
+        # Output
+        if data.get("output_dir"):
+            config.output_dir = Path(data["output_dir"]).expanduser()
+        
+        # Research
+        research = data.get("research", {})
+        if research.get("subreddits"):
+            config.reddit_subreddits = research["subreddits"]
+        
+        return config
+    
+    def save(self) -> None:
+        """Save configuration to YAML file."""
+        if not HAS_YAML:
+            raise ImportError("PyYAML is required to save config. Install with: pip install pyyaml")
+        
+        CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+        
+        data = {
+            "api_keys": {
+                "openai": self.openai_api_key,
+                "anthropic": self.anthropic_api_key,
+                "google": self.google_api_key,
+                "groq": self.groq_api_key,
+                "github": self.github_token,
+            },
+            "defaults": {
+                "model": self.default_model,
+                "personas": self.default_personas,
+                "provider": self.default_provider,
+            },
+            "cache": {
+                "dir": str(self.cache_dir),
+                "hours": self.cache_hours,
+            },
+            "output_dir": str(self.output_dir),
+            "research": {
+                "subreddits": self.reddit_subreddits,
+            },
+        }
+        
+        with open(CONFIG_FILE, "w") as f:
+            yaml.dump(data, f, default_flow_style=False)
+    
+    def ensure_dirs(self) -> None:
+        """Ensure required directories exist."""
+        self.cache_dir.mkdir(parents=True, exist_ok=True)
+        self.output_dir.mkdir(parents=True, exist_ok=True)
+
+
+def get_config() -> CrowdMindConfig:
+    """Get the current configuration."""
+    return CrowdMindConfig.load()
+
+
+def get_api_key(provider: str) -> Optional[str]:
+    """Get API key for a provider."""
+    config = get_config()
+    key_map = {
+        "openai": config.openai_api_key,
+        "anthropic": config.anthropic_api_key,
+        "google": config.google_api_key,
+        "groq": config.groq_api_key,
+        "github": config.github_token,
+    }
+    return key_map.get(provider.lower())

crowdmind/ideate/__init__.py

@@ -0,0 +1,13 @@
+"""
+CrowdMind Ideate Module
+
+Generate feature ideas based on research and codebase analysis.
+"""
+
+from crowdmind.ideate.features import run_ideation, generate_feature_ideas, get_top_ideas
+
+__all__ = [
+    "run_ideation",
+    "generate_feature_ideas",
+    "get_top_ideas",
+]