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

gobby/cli/memory.py

@@ -282,6 +282,191 @@ def export_memories(
         click.echo(markdown)
 
 
+@memory.command("dedupe")
+@click.option("--dry-run", is_flag=True, help="Show duplicates without deleting")
+@click.pass_context
+def dedupe_memories(ctx: click.Context, dry_run: bool) -> None:
+    """Remove duplicate memories (same content, different IDs).
+
+    Identifies memories with identical content but different IDs (caused by
+    project_id variations) and removes duplicates, keeping the earliest one.
+
+    Examples:
+
+        gobby memory dedupe --dry-run   # Preview duplicates
+
+        gobby memory dedupe             # Remove duplicates
+    """
+    manager = get_memory_manager(ctx)
+
+    # Get all memories
+    memories = manager.list_memories(limit=10000)
+
+    if not memories:
+        click.echo("No memories found.")
+        return
+
+    # Group by normalized content
+    content_groups: dict[str, list[tuple[str, str, str | None]]] = {}
+    for m in memories:
+        normalized = m.content.strip()
+        if normalized not in content_groups:
+            content_groups[normalized] = []
+        content_groups[normalized].append((m.id, m.created_at, m.project_id))
+
+    # Find duplicates
+    duplicates_to_delete: list[str] = []
+    duplicate_count = 0
+
+    for content, entries in content_groups.items():
+        if len(entries) > 1:
+            duplicate_count += len(entries) - 1
+            # Sort by created_at to keep earliest
+            entries.sort(key=lambda x: x[1])
+            keeper = entries[0]
+            to_delete = entries[1:]
+
+            if dry_run:
+                click.echo(f"\nDuplicate content ({len(entries)} copies):")
+                click.echo(f"  Content: {content[:80]}{'...' if len(content) > 80 else ''}")
+                click.echo(f"  Keep: {keeper[0][:12]} (created: {keeper[1][:19]})")
+                for d in to_delete:
+                    click.echo(f"  Delete: {d[0][:12]} (created: {d[1][:19]}, project: {d[2]})")
+            else:
+                for d in to_delete:
+                    duplicates_to_delete.append(d[0])
+
+    if dry_run:
+        click.echo(f"\nFound {duplicate_count} duplicate memories.")
+        click.echo("Run without --dry-run to delete them.")
+    else:
+        # Delete duplicates
+        deleted = 0
+        for memory_id in duplicates_to_delete:
+            if manager.forget(memory_id):
+                deleted += 1
+
+        click.echo(f"Deleted {deleted} duplicate memories.")
+
+
+@memory.command("fix-null-project")
+@click.option("--dry-run", is_flag=True, help="Show affected memories without updating")
+@click.pass_context
+def fix_null_project(ctx: click.Context, dry_run: bool) -> None:
+    """Fix memories with NULL project_id from their source session.
+
+    Finds memories with source_type='session' and NULL project_id, then
+    looks up the source session to get the correct project_id.
+
+    Examples:
+
+        gobby memory fix-null-project --dry-run   # Preview changes
+
+        gobby memory fix-null-project             # Apply fixes
+    """
+    from gobby.storage.sessions import LocalSessionManager
+
+    db = LocalDatabase()
+    session_mgr = LocalSessionManager(db)
+
+    # Find memories with NULL project_id and session source
+    rows = db.fetchall(
+        """
+        SELECT id, content, source_session_id
+        FROM memories
+        WHERE project_id IS NULL AND source_type = 'session' AND source_session_id IS NOT NULL
+        """,
+        (),
+    )
+
+    if not rows:
+        click.echo("No memories with NULL project_id from sessions found.")
+        return
+
+    click.echo(f"Found {len(rows)} memories with NULL project_id from sessions.")
+
+    fixed = 0
+    for row in rows:
+        memory_id = row["id"]
+        session_id = row["source_session_id"]
+        content_preview = row["content"][:50] if row["content"] else ""
+
+        # Look up session to get project_id
+        session = session_mgr.get(session_id)
+        if session and session.project_id:
+            if dry_run:
+                click.echo(
+                    f"  Would fix {memory_id[:12]}: set project_id={session.project_id[:12]}"
+                )
+                click.echo(f"    Content: {content_preview}...")
+            else:
+                # Update the memory's project_id
+                with db.transaction() as conn:
+                    conn.execute(
+                        "UPDATE memories SET project_id = ? WHERE id = ?",
+                        (session.project_id, memory_id),
+                    )
+                fixed += 1
+        else:
+            if dry_run:
+                click.echo(
+                    f"  Cannot fix {memory_id[:12]}: session {session_id} not found or has no project_id"
+                )
+
+    if dry_run:
+        click.echo(f"\nWould fix {fixed} memories. Run without --dry-run to apply.")
+    else:
+        click.echo(f"Fixed {fixed} memories with project_id from their source sessions.")
+
+
+@memory.command("backup")
+@click.option(
+    "--output",
+    "-o",
+    "output_path",
+    type=click.Path(),
+    help="Output file path (default: .gobby/memories.jsonl)",
+)
+@click.pass_context
+def backup_memories(ctx: click.Context, output_path: str | None) -> None:
+    """Backup memories to JSONL file.
+
+    Exports all memories to a JSONL file for backup/disaster recovery.
+    This runs synchronously and can be used even when the daemon is not running.
+
+    Examples:
+
+        gobby memory backup                           # Export to .gobby/memories.jsonl
+
+        gobby memory backup -o ~/backups/mem.jsonl   # Export to custom path
+    """
+    from pathlib import Path
+
+    from gobby.config.persistence import MemorySyncConfig
+    from gobby.sync.memories import MemoryBackupManager
+
+    manager = get_memory_manager(ctx)
+
+    # Create a backup manager with custom or default path
+    if output_path:
+        export_path = Path(output_path)
+    else:
+        export_path = Path(".gobby/memories.jsonl")
+
+    config = MemorySyncConfig(enabled=True, export_path=export_path)
+    backup_mgr = MemoryBackupManager(
+        db=manager.db,
+        memory_manager=manager,
+        config=config,
+    )
+
+    count = backup_mgr.backup_sync()
+    if count > 0:
+        click.echo(f"Backed up {count} memories to {export_path}")
+    else:
+        click.echo("No memories to backup.")
+
+
 def resolve_memory_id(manager: MemoryManager, memory_ref: str) -> str:
     """Resolve memory reference (UUID or prefix) to full ID."""
     # Try exact match first

gobby/cli/sessions.py

@@ -387,7 +387,7 @@ def create_handoff(
     import time
     from pathlib import Path
 
-    from gobby.mcp_proxy.tools.session_messages import _format_handoff_markdown
+    from gobby.mcp_proxy.tools.sessions._handoff import _format_handoff_markdown
     from gobby.sessions.analyzer import TranscriptAnalyzer
 
     manager = get_session_manager()

gobby/cli/utils.py

@@ -118,7 +118,7 @@ def get_active_session_id(db: LocalDatabase | None = None) -> str | None:
             db.close()
 
 
-def resolve_session_id(session_ref: str | None) -> str:
+def resolve_session_id(session_ref: str | None, project_id: str | None = None) -> str:
     """
     Resolve session reference to UUID.
 
@@ -126,6 +126,8 @@ def resolve_session_id(session_ref: str | None) -> str:
 
     Args:
         session_ref: User input string (UUID, #N, N, prefix) or None
+        project_id: Project ID for project-scoped #N lookup.
+            If not provided, auto-detected from current project context.
 
     Returns:
         Resolved UUID string
@@ -142,10 +144,15 @@ def resolve_session_id(session_ref: str | None) -> str:
                 raise click.ClickException("No active session found. Specify --session.")
             return active_id
 
+        # Get project_id from context if not provided
+        if not project_id:
+            ctx = get_project_context()
+            project_id = ctx.get("id") if ctx else None
+
         # Use SessionManager for resolution logic
         manager = LocalSessionManager(db)
         try:
-            return manager.resolve_session_reference(session_ref)
+            return manager.resolve_session_reference(session_ref, project_id)
         except ValueError as e:
             raise click.ClickException(str(e)) from None
     finally:

gobby/clones/git.py

@@ -231,6 +231,89 @@ class CloneGitManager:
                 error=str(e),
             )
 
+    def full_clone(
+        self,
+        remote_url: str,
+        clone_path: str | Path,
+        branch: str = "main",
+    ) -> GitOperationResult:
+        """
+        Create a full (non-shallow) clone of a repository.
+
+        Args:
+            remote_url: URL of the remote repository (HTTPS or SSH)
+            clone_path: Path where clone will be created
+            branch: Branch to clone
+
+        Returns:
+            GitOperationResult with success status and message
+        """
+        clone_path = Path(clone_path)
+
+        # Check if path already exists
+        if clone_path.exists():
+            return GitOperationResult(
+                success=False,
+                message=f"Path already exists: {clone_path}",
+            )
+
+        # Ensure parent directory exists
+        clone_path.parent.mkdir(parents=True, exist_ok=True)
+
+        try:
+            # Build clone command without --depth (full clone)
+            cmd = [
+                "git",
+                "clone",
+                "-b",
+                branch,
+                remote_url,
+                str(clone_path),
+            ]
+
+            # Sanitize URL in command before logging to avoid exposing credentials
+            safe_cmd = cmd.copy()
+            safe_cmd[safe_cmd.index(remote_url)] = _sanitize_url(remote_url)
+            logger.debug(f"Running: {' '.join(safe_cmd)}")
+
+            result = subprocess.run(  # nosec B603 B607 - cmd built from hardcoded git arguments
+                cmd,
+                capture_output=True,
+                text=True,
+                timeout=600,  # 10 minutes for full clone
+            )
+
+            if result.returncode == 0:
+                return GitOperationResult(
+                    success=True,
+                    message=f"Successfully cloned to {clone_path}",
+                    output=result.stdout,
+                )
+            else:
+                return GitOperationResult(
+                    success=False,
+                    message=f"Clone failed: {result.stderr}",
+                    error=result.stderr,
+                )
+
+        except subprocess.TimeoutExpired:
+            # Clean up partial clone
+            if clone_path.exists():
+                shutil.rmtree(clone_path, ignore_errors=True)
+            return GitOperationResult(
+                success=False,
+                message="Git clone timed out",
+            )
+        except Exception as e:
+            # Clean up partial clone
+            if clone_path.exists():
+                shutil.rmtree(clone_path, ignore_errors=True)
+            return GitOperationResult(
+                success=False,
+                message=f"Error cloning repository: {e}",
+                error=str(e),
+            )
+
     def sync_clone(
         self,
         clone_path: str | Path,
@@ -422,6 +505,100 @@ class CloneGitManager:
             logger.error(f"Error getting clone status: {e}")
             return None
 
+    def create_clone(
+        self,
+        clone_path: str | Path,
+        branch_name: str,
+        base_branch: str = "main",
+        shallow: bool = True,
+    ) -> GitOperationResult:
+        """
+        Create a clone for isolated work.
+
+        This is the high-level API used by CloneIsolationHandler.
+        It gets the remote URL from the current repository and creates
+        either a shallow or full clone at the specified path.
+
+        Args:
+            clone_path: Path where clone will be created
+            branch_name: Branch to create/checkout in the clone
+            base_branch: Base branch to clone from (default: main)
+            shallow: Whether to create a shallow clone (default: True)
+
+        Returns:
+            GitOperationResult with success status and message
+        """
+        # Get remote URL from current repo
+        remote_url = self.get_remote_url()
+        if not remote_url:
+            return GitOperationResult(
+                success=False,
+                message="Could not get remote URL from repository",
+                error="no_remote_url",
+            )
+
+        # Create clone (shallow or full based on parameter)
+        if shallow:
+            result = self.shallow_clone(
+                remote_url=remote_url,
+                clone_path=clone_path,
+                branch=base_branch,
+                depth=1,
+            )
+        else:
+            result = self.full_clone(
+                remote_url=remote_url,
+                clone_path=clone_path,
+                branch=base_branch,
+            )
+
+        if not result.success:
+            return result
+
+        # If branch_name differs from base_branch, create and checkout the new branch
+        if branch_name != base_branch:
+            try:
+                # Create new branch from base
+                create_result = self._run_git(
+                    ["checkout", "-b", branch_name],
+                    cwd=clone_path,
+                    timeout=30,
+                )
+                if create_result.returncode != 0:
+                    # Clean up the clone on branch creation failure
+                    try:
+                        if Path(clone_path).exists():
+                            shutil.rmtree(clone_path)
+                    except Exception as cleanup_err:
+                        logger.warning(
+                            f"Failed to clean up clone after branch creation failure: {cleanup_err}"
+                        )
+                    return GitOperationResult(
+                        success=False,
+                        message=f"Failed to create branch {branch_name}: {create_result.stderr}",
+                        error=create_result.stderr,
+                    )
+            except Exception as e:
+                # Clean up the clone on exception
+                try:
+                    if Path(clone_path).exists():
+                        shutil.rmtree(clone_path)
+                except Exception as cleanup_err:
+                    logger.warning(
+                        f"Failed to clean up clone after branch creation error: {cleanup_err}"
+                    )
+                return GitOperationResult(
+                    success=False,
+                    message=f"Error creating branch: {e}",
+                    error=str(e),
+                )
+
+        return GitOperationResult(
+            success=True,
+            message=f"Successfully created clone at {clone_path} on branch {branch_name}",
+            output=result.output,
+        )
+
     def merge_branch(
         self,
         source_branch: str,

gobby/config/__init__.py

@@ -14,116 +14,31 @@ Module structure:
 - extensions.py: Hook extension configs (webhooks, plugins)
 - sessions.py: Session lifecycle and tracking configs
 - features.py: MCP proxy feature configs (code execution, tool recommendation)
+
+Import from submodules directly for specific configs:
+    from gobby.config.tasks import TaskValidationConfig
+    from gobby.config.extensions import WebhooksConfig
+
+Import from this package for app-level items:
+    from gobby.config import DaemonConfig, load_config
 """
 
 # Core configuration and utilities from app.py
 from gobby.config.app import (
     DaemonConfig,
     expand_env_vars,
+    generate_default_config,
     load_config,
+    load_yaml,
     save_config,
 )
 
-# Extension configs
-from gobby.config.extensions import (
-    HookExtensionsConfig,
-    PluginItemConfig,
-    PluginsConfig,
-    WebhookEndpointConfig,
-    WebhooksConfig,
-    WebSocketBroadcastConfig,
-)
-
-# Feature configs
-from gobby.config.features import (
-    ImportMCPServerConfig,
-    MetricsConfig,
-    ProjectVerificationConfig,
-    RecommendToolsConfig,
-    ToolSummarizerConfig,
-)
-
-# LLM provider configs
-from gobby.config.llm_providers import (
-    LLMProviderConfig,
-    LLMProvidersConfig,
-)
-
-# Logging configs
-from gobby.config.logging import LoggingSettings
-
-# Persistence configs
-from gobby.config.persistence import (
-    MemoryConfig,
-    MemorySyncConfig,
-)
-
-# Server configs
-from gobby.config.servers import (
-    MCPClientProxyConfig,
-    WebSocketSettings,
-)
-
-# Session configs
-from gobby.config.sessions import (
-    ContextInjectionConfig,
-    MessageTrackingConfig,
-    SessionLifecycleConfig,
-    SessionSummaryConfig,
-    TitleSynthesisConfig,
-)
-
-# Task configs
-from gobby.config.tasks import (
-    CompactHandoffConfig,
-    GobbyTasksConfig,
-    PatternCriteriaConfig,
-    TaskExpansionConfig,
-    TaskValidationConfig,
-    WorkflowConfig,
-)
-
 __all__ = [
-    # Core
+    # Core app-level exports only
     "DaemonConfig",
     "expand_env_vars",
+    "generate_default_config",
     "load_config",
+    "load_yaml",
     "save_config",
-    # Extension configs
-    "HookExtensionsConfig",
-    "PluginItemConfig",
-    "PluginsConfig",
-    "WebhookEndpointConfig",
-    "WebhooksConfig",
-    "WebSocketBroadcastConfig",
-    # Feature configs
-    "ImportMCPServerConfig",
-    "MetricsConfig",
-    "ProjectVerificationConfig",
-    "RecommendToolsConfig",
-    "ToolSummarizerConfig",
-    # LLM provider configs
-    "LLMProviderConfig",
-    "LLMProvidersConfig",
-    # Logging configs
-    "LoggingSettings",
-    # Persistence configs
-    "MemoryConfig",
-    "MemorySyncConfig",
-    # Server configs
-    "MCPClientProxyConfig",
-    "WebSocketSettings",
-    # Session configs
-    "ContextInjectionConfig",
-    "MessageTrackingConfig",
-    "SessionLifecycleConfig",
-    "SessionSummaryConfig",
-    "TitleSynthesisConfig",
-    # Task configs
-    "CompactHandoffConfig",
-    "GobbyTasksConfig",
-    "PatternCriteriaConfig",
-    "TaskExpansionConfig",
-    "TaskValidationConfig",
-    "WorkflowConfig",
 ]

gobby/config/app.py

@@ -15,14 +15,8 @@ from typing import Any
 import yaml
 from pydantic import BaseModel, Field, field_validator
 
-from gobby.config.extensions import (
-    HookExtensionsConfig,
-    PluginItemConfig,
-    PluginsConfig,
-    WebhookEndpointConfig,
-    WebhooksConfig,
-    WebSocketBroadcastConfig,
-)
+# Internal imports for DaemonConfig fields - NOT re-exported
+from gobby.config.extensions import HookExtensionsConfig
 from gobby.config.features import (
     ImportMCPServerConfig,
     MetricsConfig,
@@ -31,14 +25,9 @@ from gobby.config.features import (
     TaskDescriptionConfig,
     ToolSummarizerConfig,
 )
-
-# Re-export from extracted modules (Strangler Fig pattern for backwards compatibility)
-from gobby.config.llm_providers import LLMProviderConfig, LLMProvidersConfig
+from gobby.config.llm_providers import LLMProvidersConfig
 from gobby.config.logging import LoggingSettings
-from gobby.config.persistence import (
-    MemoryConfig,
-    MemorySyncConfig,
-)
+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 (
@@ -50,61 +39,10 @@ from gobby.config.sessions import (
     TitleSynthesisConfig,
 )
 from gobby.config.skills import SkillsConfig
-from gobby.config.tasks import (
-    CompactHandoffConfig,
-    GobbyTasksConfig,
-    PatternCriteriaConfig,
-    TaskExpansionConfig,
-    TaskValidationConfig,
-    WorkflowConfig,
-)
+from gobby.config.tasks import CompactHandoffConfig, GobbyTasksConfig, WorkflowConfig
 
-# Explicit exports for mypy (re-exported symbols from submodules)
 __all__ = [
-    # From gobby.config.extensions
-    "HookExtensionsConfig",
-    "PluginItemConfig",
-    "PluginsConfig",
-    "WebhookEndpointConfig",
-    "WebhooksConfig",
-    "WebSocketBroadcastConfig",
-    # From gobby.config.features
-    "ImportMCPServerConfig",
-    "MetricsConfig",
-    "ProjectVerificationConfig",
-    "RecommendToolsConfig",
-    "TaskDescriptionConfig",
-    "ToolSummarizerConfig",
-    # From gobby.config.llm_providers
-    "LLMProviderConfig",
-    "LLMProvidersConfig",
-    # From gobby.config.logging
-    "LoggingSettings",
-    # 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",
-    "MessageTrackingConfig",
-    "SessionLifecycleConfig",
-    "SessionSummaryConfig",
-    "TitleSynthesisConfig",
-    # From gobby.config.tasks
-    "CompactHandoffConfig",
-    "GobbyTasksConfig",
-    "PatternCriteriaConfig",
-    "TaskExpansionConfig",
-    "TaskValidationConfig",
-    "WorkflowConfig",
-    # Local definitions
+    # Local definitions only - no re-exports
     "ConductorConfig",
     "DaemonConfig",
     "expand_env_vars",
@@ -184,32 +122,6 @@ def expand_env_vars(content: str) -> str:
     return ENV_VAR_PATTERN.sub(replace_match, content)
 
 
-# WebSocketSettings moved to gobby.config.servers (re-exported above)
-# LoggingSettings moved to gobby.config.logging (re-exported above)
-# CompactHandoffConfig moved to gobby.config.tasks (re-exported above)
-
-# ContextInjectionConfig, SessionSummaryConfig, TitleSynthesisConfig,
-# MessageTrackingConfig, SessionLifecycleConfig
-# moved to gobby.config.sessions (re-exported above)
-
-# ToolSummarizerConfig, RecommendToolsConfig, ImportMCPServerConfig,
-# MetricsConfig, ProjectVerificationConfig
-# moved to gobby.config.features (re-exported above)
-
-# WebSocketBroadcastConfig, WebhookEndpointConfig, WebhooksConfig,
-# PluginItemConfig, PluginsConfig, HookExtensionsConfig
-# moved to gobby.config.extensions (re-exported above)
-
-# PatternCriteriaConfig, TaskExpansionConfig, TaskValidationConfig, WorkflowConfig,
-# GobbyTasksConfig, CompactHandoffConfig
-# moved to gobby.config.tasks (re-exported above)
-
-# MCPClientProxyConfig moved to gobby.config.servers (re-exported above)
-# LLMProviderConfig and LLMProvidersConfig moved to gobby.config.llm_providers (re-exported above)
-# MemoryConfig, MemorySyncConfig
-# moved to gobby.config.persistence (re-exported above)
-
-
 class DaemonConfig(BaseModel):
     """
     Main configuration for Gobby daemon.
@@ -243,6 +155,10 @@ class DaemonConfig(BaseModel):
         default="~/.gobby/gobby-hub.db",
         description="Path to hub database for cross-project queries.",
     )
+    use_flattened_baseline: bool = Field(
+        default=True,
+        description="Use flattened V2 baseline schema (v75) for new databases instead of legacy migrations.",
+    )
 
     # Sub-configs
     websocket: WebSocketSettings = Field(