gobby 0.2.5__py3-none-any.whl → 0.2.6__py3-none-any.whl

gobby/conductor/token_tracker.py

@@ -0,0 +1,160 @@
+"""Session-based token tracking for budget management.
+
+This module provides SessionTokenTracker which aggregates usage from sessions
+over time and enables budget tracking for agent spawning decisions.
+"""
+
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass, field
+from datetime import UTC, datetime, timedelta
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class SessionTokenTracker:
+    """Track token usage from sessions for budget management.
+
+    This class aggregates usage data from sessions over time and provides
+    budget checking for agent spawning decisions.
+
+    Example:
+        tracker = SessionTokenTracker(
+            session_storage=session_manager,
+            daily_budget_usd=10.0,
+        )
+
+        # Get usage summary for last 7 days
+        summary = tracker.get_usage_summary(days=7)
+
+        # Check if we can spawn an agent
+        can_spawn, reason = tracker.can_spawn_agent()
+    """
+
+    session_storage: Any  # LocalSessionManager
+    daily_budget_usd: float = 50.0  # Default daily budget in USD
+
+    # Cached data
+    _usage_cache: dict[str, Any] = field(default_factory=dict)
+    _cache_time: datetime | None = field(default=None)
+    _cache_ttl_seconds: int = 60  # Cache for 60 seconds
+
+    def get_usage_summary(self, days: int = 1) -> dict[str, Any]:
+        """Get usage summary for the specified number of days.
+
+        Args:
+            days: Number of days to look back (default: 1 = today)
+
+        Returns:
+            Dict with total cost, tokens, session count, and model breakdown
+        """
+        since = datetime.now(UTC) - timedelta(days=days)
+        sessions = self.session_storage.get_sessions_since(since)
+
+        total_cost = 0.0
+        total_input_tokens = 0
+        total_output_tokens = 0
+        total_cache_creation_tokens = 0
+        total_cache_read_tokens = 0
+        usage_by_model: dict[str, dict[str, Any]] = {}
+
+        for session in sessions:
+            # Safely handle None values by defaulting to 0
+            total_cost += session.usage_total_cost_usd or 0
+            total_input_tokens += session.usage_input_tokens or 0
+            total_output_tokens += session.usage_output_tokens or 0
+            total_cache_creation_tokens += session.usage_cache_creation_tokens or 0
+            total_cache_read_tokens += session.usage_cache_read_tokens or 0
+
+            # Aggregate by model
+            model = session.model or "unknown"
+            if model not in usage_by_model:
+                usage_by_model[model] = {
+                    "cost": 0.0,
+                    "input_tokens": 0,
+                    "output_tokens": 0,
+                    "sessions": 0,
+                }
+
+            usage_by_model[model]["cost"] += session.usage_total_cost_usd or 0
+            usage_by_model[model]["input_tokens"] += session.usage_input_tokens or 0
+            usage_by_model[model]["output_tokens"] += session.usage_output_tokens or 0
+            usage_by_model[model]["sessions"] += 1
+
+        return {
+            "total_cost_usd": total_cost,
+            "total_input_tokens": total_input_tokens,
+            "total_output_tokens": total_output_tokens,
+            "total_cache_creation_tokens": total_cache_creation_tokens,
+            "total_cache_read_tokens": total_cache_read_tokens,
+            "session_count": len(sessions),
+            "usage_by_model": usage_by_model,
+            "period_days": days,
+        }
+
+    def get_budget_status(self) -> dict[str, Any]:
+        """Get current budget status for today.
+
+        Returns:
+            Dict with budget info: daily_budget_usd, used_today_usd,
+            remaining_usd, percentage_used, over_budget
+        """
+        summary = self.get_usage_summary(days=1)
+        used_today = summary["total_cost_usd"]
+
+        # Handle unlimited budget (daily_budget_usd <= 0)
+        if self.daily_budget_usd <= 0:
+            return {
+                "daily_budget_usd": self.daily_budget_usd,
+                "used_today_usd": used_today,
+                "remaining_usd": float("inf"),
+                "percentage_used": 0.0,
+                "over_budget": False,
+            }
+
+        remaining = self.daily_budget_usd - used_today
+
+        return {
+            "daily_budget_usd": self.daily_budget_usd,
+            "used_today_usd": used_today,
+            "remaining_usd": remaining,
+            "percentage_used": (used_today / self.daily_budget_usd * 100),
+            "over_budget": used_today > self.daily_budget_usd,
+        }
+
+    def can_spawn_agent(self, estimated_cost: float | None = None) -> tuple[bool, str | None]:
+        """Check if we can spawn an agent based on budget.
+
+        Args:
+            estimated_cost: Optional estimated cost for the agent run
+
+        Returns:
+            Tuple of (can_spawn, reason if not)
+        """
+        # Unlimited budget (0 or negative means no limit)
+        if self.daily_budget_usd <= 0.0:
+            return True, None
+
+        status = self.get_budget_status()
+
+        # Already over budget
+        if status["over_budget"]:
+            return (
+                False,
+                f"Daily budget exceeded: ${status['used_today_usd']:.2f} used "
+                f"of ${self.daily_budget_usd:.2f}",
+            )
+
+        # Check if estimated cost would exceed budget
+        if estimated_cost is not None:
+            if status["used_today_usd"] + estimated_cost > self.daily_budget_usd:
+                return (
+                    False,
+                    f"Estimated cost ${estimated_cost:.2f} would exceed budget. "
+                    f"Remaining: ${status['remaining_usd']:.2f}",
+                )
+
+        return True, None

gobby/config/app.py

@@ -39,6 +39,7 @@ from gobby.config.persistence import (
     MemoryConfig,
     MemorySyncConfig,
 )
+from gobby.config.search import SearchConfig
 from gobby.config.servers import MCPClientProxyConfig, WebSocketSettings
 from gobby.config.sessions import (
     ArtifactHandoffConfig,
@@ -48,6 +49,7 @@ from gobby.config.sessions import (
     SessionSummaryConfig,
     TitleSynthesisConfig,
 )
+from gobby.config.skills import SkillsConfig
 from gobby.config.tasks import (
     CompactHandoffConfig,
     GobbyTasksConfig,
@@ -81,9 +83,13 @@ __all__ = [
     # From gobby.config.persistence
     "MemoryConfig",
     "MemorySyncConfig",
+    # From gobby.config.search
+    "SearchConfig",
     # From gobby.config.servers
     "MCPClientProxyConfig",
     "WebSocketSettings",
+    # From gobby.config.skills
+    "SkillsConfig",
     # From gobby.config.sessions
     "ArtifactHandoffConfig",
     "ContextInjectionConfig",
@@ -99,6 +105,7 @@ __all__ = [
     "TaskValidationConfig",
     "WorkflowConfig",
     # Local definitions
+    "ConductorConfig",
     "DaemonConfig",
     "expand_env_vars",
     "load_yaml",
@@ -114,6 +121,37 @@ __all__ = [
 ENV_VAR_PATTERN = re.compile(r"\$\{([A-Za-z_][A-Za-z0-9_]*)(?::-([^}]*))?\}")
 
 
+class ConductorConfig(BaseModel):
+    """
+    Configuration for the Conductor orchestration system.
+
+    Controls token budget management and agent spawning throttling.
+    """
+
+    daily_budget_usd: float = Field(
+        default=50.0,
+        ge=0.0,
+        description="Daily budget limit in USD. Set to 0 for unlimited.",
+    )
+    warning_threshold: float = Field(
+        default=0.8,
+        ge=0.0,
+        le=1.0,
+        description="Budget percentage at which to issue warnings (0.0-1.0).",
+    )
+    throttle_threshold: float = Field(
+        default=0.9,
+        ge=0.0,
+        le=1.0,
+        description="Budget percentage at which to throttle agent spawning (0.0-1.0).",
+    )
+    tracking_window_days: int = Field(
+        default=7,
+        gt=0,
+        description="Number of days to track usage for reporting.",
+    )
+
+
 def expand_env_vars(content: str) -> str:
     """
     Expand environment variables in configuration content.
@@ -188,13 +226,17 @@ class DaemonConfig(BaseModel):
 
     # Daemon settings
     daemon_port: int = Field(
-        default=8765,
+        default=60887,
         description="Port for daemon to listen on",
     )
     daemon_health_check_interval: float = Field(
         default=10.0,
         description="Daemon health check interval in seconds",
     )
+    test_mode: bool = Field(
+        default=False,
+        description="Run daemon in test mode (enables test endpoints)",
+    )
 
     # Local storage
     database_path: str = Field(
@@ -279,6 +321,10 @@ class DaemonConfig(BaseModel):
         default_factory=MemorySyncConfig,
         description="Memory synchronization configuration",
     )
+    skills: SkillsConfig = Field(
+        default_factory=SkillsConfig,
+        description="Skills injection configuration",
+    )
     message_tracking: MessageTrackingConfig = Field(
         default_factory=MessageTrackingConfig,
         description="Session message tracking configuration",
@@ -295,6 +341,14 @@ class DaemonConfig(BaseModel):
         default_factory=ProjectVerificationConfig,
         description="Default verification commands for projects without auto-detected config",
     )
+    conductor: ConductorConfig = Field(
+        default_factory=ConductorConfig,
+        description="Conductor orchestration system configuration",
+    )
+    search: SearchConfig = Field(
+        default_factory=SearchConfig,
+        description="Unified search configuration with embedding fallback",
+    )
 
     def get_recommend_tools_config(self) -> RecommendToolsConfig:
         """Get recommend_tools configuration."""
@@ -324,6 +378,10 @@ class DaemonConfig(BaseModel):
         """Get memory sync configuration."""
         return self.memory_sync
 
+    def get_skills_config(self) -> SkillsConfig:
+        """Get skills configuration."""
+        return self.skills
+
     def get_gobby_tasks_config(self) -> GobbyTasksConfig:
         """Get gobby-tasks configuration."""
         return self.gobby_tasks
@@ -336,6 +394,10 @@ class DaemonConfig(BaseModel):
         """Get default verification commands configuration."""
         return self.verification_defaults
 
+    def get_search_config(self) -> SearchConfig:
+        """Get search configuration."""
+        return self.search
+
     @field_validator("daemon_port")
     @classmethod
     def validate_port(cls, v: int) -> int:

gobby/config/search.py

@@ -0,0 +1,110 @@
+"""Search configuration for Gobby daemon.
+
+Provides configuration for the unified search layer with embedding
+support and TF-IDF fallback.
+
+Example usage in config.yaml:
+    search:
+      mode: auto  # tfidf, embedding, auto, hybrid
+      embedding_model: text-embedding-3-small
+      tfidf_weight: 0.4
+      embedding_weight: 0.6
+      notify_on_fallback: true
+
+For Ollama (local embeddings):
+    search:
+      mode: auto
+      embedding_model: openai/nomic-embed-text
+      embedding_api_base: http://localhost:11434/v1
+"""
+
+from pydantic import BaseModel, Field
+
+from gobby.search.models import SearchMode
+
+
+class SearchConfig(BaseModel):
+    """Configuration for unified search with fallback.
+
+    This config controls how UnifiedSearcher behaves, including:
+    - Which search mode to use (tfidf, embedding, auto, hybrid)
+    - Which embedding model to use (LiteLLM format)
+    - Weights for hybrid mode
+    - Whether to notify on fallback
+
+    Supported modes:
+    - tfidf: TF-IDF only (always works, no API needed)
+    - embedding: Embedding-based search only (fails if unavailable)
+    - auto: Try embedding, fallback to TF-IDF if unavailable
+    - hybrid: Combine both with weighted scores
+
+    LiteLLM model format examples:
+    - OpenAI: text-embedding-3-small (needs OPENAI_API_KEY)
+    - Ollama: openai/nomic-embed-text (with embedding_api_base)
+    - Azure: azure/azure-embedding-model
+    - Vertex AI: vertex_ai/text-embedding-004
+    - Gemini: gemini/text-embedding-004 (needs GEMINI_API_KEY)
+    - Mistral: mistral/mistral-embed (needs MISTRAL_API_KEY)
+    """
+
+    mode: str = Field(
+        default="auto",
+        description="Search mode: tfidf, embedding, auto, hybrid",
+    )
+    embedding_model: str = Field(
+        default="text-embedding-3-small",
+        description="LiteLLM model string (e.g., text-embedding-3-small, openai/nomic-embed-text)",
+    )
+    embedding_api_base: str | None = Field(
+        default=None,
+        description="API base URL for Ollama/custom endpoints (e.g., http://localhost:11434/v1)",
+    )
+    embedding_api_key: str | None = Field(
+        default=None,
+        description="API key for embedding provider (uses env var if not set)",
+    )
+    tfidf_weight: float = Field(
+        default=0.4,
+        ge=0.0,
+        le=1.0,
+        description="Weight for TF-IDF scores in hybrid mode",
+    )
+    embedding_weight: float = Field(
+        default=0.6,
+        ge=0.0,
+        le=1.0,
+        description="Weight for embedding scores in hybrid mode",
+    )
+    notify_on_fallback: bool = Field(
+        default=True,
+        description="Log warning when falling back to TF-IDF",
+    )
+
+    def get_normalized_weights(self) -> tuple[float, float]:
+        """Get normalized weights that sum to 1.0.
+
+        Returns:
+            Tuple of (tfidf_weight, embedding_weight) normalized to sum to 1.0
+        """
+        total = self.tfidf_weight + self.embedding_weight
+        if total == 0:
+            # Default to equal weights if both are 0
+            return (0.5, 0.5)
+        return (self.tfidf_weight / total, self.embedding_weight / total)
+
+    def get_mode_enum(self) -> SearchMode:
+        """Get the SearchMode enum instance for the configured mode.
+
+        Returns:
+            SearchMode enum corresponding to the mode string value
+
+        Raises:
+            ValueError: If the configured mode is not a valid SearchMode
+        """
+        try:
+            return SearchMode(self.mode)
+        except ValueError as e:
+            valid_modes = [m.value for m in SearchMode]
+            raise ValueError(
+                f"Invalid search mode '{self.mode}'. Valid modes are: {', '.join(valid_modes)}"
+            ) from e

gobby/config/servers.py

@@ -23,7 +23,7 @@ class WebSocketSettings(BaseModel):
         description="Enable WebSocket server for real-time communication",
     )
     port: int = Field(
-        default=8766,
+        default=60888,
         description="Port for WebSocket server to listen on",
     )
     ping_interval: int = Field(

gobby/config/skills.py

@@ -0,0 +1,43 @@
+"""
+Skills configuration for Gobby daemon.
+
+Provides configuration for skill injection and discovery.
+"""
+
+from __future__ import annotations
+
+from typing import Literal
+
+from pydantic import BaseModel, Field, field_validator
+
+
+class SkillsConfig(BaseModel):
+    """
+    Configuration for skill injection and discovery.
+
+    Controls whether and how skills are injected into session context.
+    """
+
+    inject_core_skills: bool = Field(
+        default=True,
+        description="Whether to inject core skills into session context",
+    )
+
+    core_skills_path: str | None = Field(
+        default=None,
+        description="Override path for core skills (default: install/shared/skills/)",
+    )
+
+    injection_format: Literal["summary", "full", "none"] = Field(
+        default="summary",
+        description="Format for skill injection: 'summary' (names only), 'full' (with content), 'none' (disabled)",
+    )
+
+    @field_validator("injection_format")
+    @classmethod
+    def validate_injection_format(cls, v: str) -> str:
+        """Validate injection_format is one of the allowed values."""
+        allowed = {"summary", "full", "none"}
+        if v not in allowed:
+            raise ValueError(f"injection_format must be one of {allowed}, got '{v}'")
+        return v

gobby/config/tasks.py

@@ -181,16 +181,12 @@ class TaskExpansionConfig(BaseModel):
     )
     tdd_prompt: str | None = Field(
         default=None,
-        description="DEPRECATED: TDD mode is now integrated into the system prompt template via Jinja2 conditionals",
+        description="DEPRECATED: TDD instructions are now embedded in task descriptions for code/config categories",
     )
     web_research_enabled: bool = Field(
         default=True,
         description="Enable web research for task expansion using MCP tools",
     )
-    tdd_mode: bool = Field(
-        default=True,
-        description="Enable TDD mode: create test->implement task pairs with appropriate blocking for coding tasks",
-    )
     max_subtasks: int = Field(
         default=15,
         description="Maximum number of subtasks to create per expansion",
@@ -724,10 +720,6 @@ class WorkflowVariablesConfig(BaseModel):
         default=False,
         description="Require an active task (in_progress) before allowing file edits",
     )
-    tdd_mode: bool = Field(
-        default=True,
-        description="Enable TDD mode for task expansion (test-implementation pairs)",
-    )
     session_task: str | list[str] | None = Field(
         default=None,
         description="Task(s) to complete before stopping. "
@@ -759,13 +751,13 @@ def merge_workflow_variables(
         ValidationError: If validate=True and merged values fail validation.
 
     Example:
-        >>> yaml_defaults = {"tdd_mode": True, "require_task_before_edit": False}
-        >>> db_overrides = {"tdd_mode": False}
+        >>> yaml_defaults = {"require_task_before_edit": False, "session_task": None}
+        >>> db_overrides = {"require_task_before_edit": True}
         >>> effective = merge_workflow_variables(yaml_defaults, db_overrides)
-        >>> effective["tdd_mode"]
-        False
         >>> effective["require_task_before_edit"]
-        False
+        True
+        >>> effective["session_task"]
+        None
     """
     # Start with defaults
     effective = dict(yaml_defaults)