gobby 0.2.5__py3-none-any.whl

gobby/cli/memory.py

@@ -0,0 +1,304 @@
+import asyncio
+
+import click
+
+from gobby.cli.utils import resolve_project_ref
+from gobby.config.app import DaemonConfig
+from gobby.memory.manager import MemoryManager
+from gobby.storage.database import LocalDatabase
+
+
+def get_memory_manager(ctx: click.Context) -> MemoryManager:
+    """Get memory manager."""
+    config: DaemonConfig = ctx.obj["config"]
+    db = LocalDatabase()
+
+    return MemoryManager(db, config.memory)
+
+
+@click.group()
+def memory() -> None:
+    """Manage Gobby memories."""
+    pass
+
+
+@memory.command()
+@click.argument("content")
+@click.option(
+    "--type", "-t", "memory_type", default="fact", help="Type of memory (fact, preference, etc.)"
+)
+@click.option("--importance", "-i", type=float, default=0.5, help="Importance (0.0 - 1.0)")
+@click.option("--project", "-p", "project_ref", help="Project (name or UUID)")
+@click.pass_context
+def create(
+    ctx: click.Context, content: str, memory_type: str, importance: float, project_ref: str | None
+) -> None:
+    """Create a new memory."""
+    project_id = resolve_project_ref(project_ref) if project_ref else None
+    manager = get_memory_manager(ctx)
+    memory = asyncio.run(
+        manager.remember(
+            content=content,
+            memory_type=memory_type,
+            importance=importance,
+            project_id=project_id,
+            source_type="cli",
+        )
+    )
+    click.echo(f"Created memory: {memory.id} - {memory.content}")
+
+
+@memory.command()
+@click.argument("query", required=False)
+@click.option("--project", "-p", "project_ref", help="Project (name or UUID)")
+@click.option("--limit", "-n", default=10, help="Max results")
+@click.option("--tags-all", "tags_all", help="Require ALL tags (comma-separated)")
+@click.option("--tags-any", "tags_any", help="Require ANY tag (comma-separated)")
+@click.option("--tags-none", "tags_none", help="Exclude memories with these tags (comma-separated)")
+@click.pass_context
+def recall(
+    ctx: click.Context,
+    query: str | None,
+    project_ref: str | None,
+    limit: int,
+    tags_all: str | None,
+    tags_any: str | None,
+    tags_none: str | None,
+) -> None:
+    """Retrieve memories with optional tag filtering."""
+    project_id = resolve_project_ref(project_ref) if project_ref else None
+    manager = get_memory_manager(ctx)
+
+    # Parse comma-separated tags
+    tags_all_list = [t.strip() for t in tags_all.split(",") if t.strip()] if tags_all else None
+    tags_any_list = [t.strip() for t in tags_any.split(",") if t.strip()] if tags_any else None
+    tags_none_list = [t.strip() for t in tags_none.split(",") if t.strip()] if tags_none else None
+
+    memories = manager.recall(
+        query=query,
+        project_id=project_id,
+        limit=limit,
+        tags_all=tags_all_list,
+        tags_any=tags_any_list,
+        tags_none=tags_none_list,
+    )
+    if not memories:
+        click.echo("No memories found.")
+        return
+
+    for mem in memories:
+        tags_str = f" [{', '.join(mem.tags)}]" if mem.tags else ""
+        click.echo(f"[{mem.id[:8]}] ({mem.memory_type}, {mem.importance}){tags_str} {mem.content}")
+
+
+@memory.command()
+@click.argument("memory_ref")
+@click.pass_context
+def delete(ctx: click.Context, memory_ref: str) -> None:
+    """Delete a memory by ID (UUID or prefix)."""
+    manager = get_memory_manager(ctx)
+    memory_id = resolve_memory_id(manager, memory_ref)
+    success = manager.forget(memory_id)
+    if success:
+        click.echo(f"Deleted memory: {memory_id}")
+    else:
+        click.echo(f"Memory not found: {memory_id}")
+
+
+@memory.command("list")
+@click.option("--type", "-t", "memory_type", help="Filter by memory type")
+@click.option("--min-importance", "-i", type=float, help="Minimum importance threshold")
+@click.option("--limit", "-n", default=50, help="Max results")
+@click.option("--project", "-p", "project_ref", help="Project (name or UUID)")
+@click.option("--tags-all", "tags_all", help="Require ALL tags (comma-separated)")
+@click.option("--tags-any", "tags_any", help="Require ANY tag (comma-separated)")
+@click.option("--tags-none", "tags_none", help="Exclude memories with these tags (comma-separated)")
+@click.pass_context
+def list_memories(
+    ctx: click.Context,
+    memory_type: str | None,
+    min_importance: float | None,
+    project_ref: str | None,
+    limit: int,
+    tags_all: str | None,
+    tags_any: str | None,
+    tags_none: str | None,
+) -> None:
+    """List all memories with optional filtering."""
+    project_id = resolve_project_ref(project_ref) if project_ref else None
+    manager = get_memory_manager(ctx)
+
+    # Parse comma-separated tags
+    tags_all_list = [t.strip() for t in tags_all.split(",") if t.strip()] if tags_all else None
+    tags_any_list = [t.strip() for t in tags_any.split(",") if t.strip()] if tags_any else None
+    tags_none_list = [t.strip() for t in tags_none.split(",") if t.strip()] if tags_none else None
+
+    memories = manager.list_memories(
+        project_id=project_id,
+        memory_type=memory_type,
+        min_importance=min_importance,
+        limit=limit,
+        tags_all=tags_all_list,
+        tags_any=tags_any_list,
+        tags_none=tags_none_list,
+    )
+    if not memories:
+        click.echo("No memories found.")
+        return
+
+    for mem in memories:
+        tags_str = f" [{', '.join(mem.tags)}]" if mem.tags else ""
+        click.echo(f"[{mem.id[:8]}] ({mem.memory_type}, {mem.importance:.2f}){tags_str}")
+        click.echo(f"  {mem.content[:100]}{'...' if len(mem.content) > 100 else ''}")
+
+
+@memory.command("show")
+@click.argument("memory_ref")
+@click.pass_context
+def show_memory(ctx: click.Context, memory_ref: str) -> None:
+    """Show details of a specific memory (UUID or prefix)."""
+    manager = get_memory_manager(ctx)
+    memory_id = resolve_memory_id(manager, memory_ref)
+    memory = manager.get_memory(memory_id)
+    if not memory:
+        click.echo(f"Memory not found: {memory_id}")
+        return
+
+    click.echo(f"ID: {memory.id}")
+    click.echo(f"Type: {memory.memory_type}")
+    click.echo(f"Importance: {memory.importance}")
+    click.echo(f"Created: {memory.created_at}")
+    click.echo(f"Updated: {memory.updated_at}")
+    click.echo(f"Source: {memory.source_type}")
+    click.echo(f"Access Count: {memory.access_count}")
+    if memory.tags:
+        click.echo(f"Tags: {', '.join(memory.tags)}")
+    click.echo(f"Content:\n{memory.content}")
+
+
+@memory.command("update")
+@click.argument("memory_ref")
+@click.option("--content", "-c", help="New content")
+@click.option("--importance", "-i", type=float, help="New importance (0.0-1.0)")
+@click.option("--tags", "-t", help="New tags (comma-separated)")
+@click.pass_context
+def update_memory(
+    ctx: click.Context,
+    memory_ref: str,
+    content: str | None,
+    importance: float | None,
+    tags: str | None,
+) -> None:
+    """Update an existing memory (UUID or prefix)."""
+    manager = get_memory_manager(ctx)
+    memory_id = resolve_memory_id(manager, memory_ref)
+
+    # Parse tags if provided
+    tag_list = [t.strip() for t in tags.split(",") if t.strip()] if tags else None
+    if tag_list is not None and len(tag_list) == 0:
+        tag_list = None
+
+    try:
+        memory = manager.update_memory(
+            memory_id=memory_id,
+            content=content,
+            importance=importance,
+            tags=tag_list,
+        )
+        click.echo(f"Updated memory: {memory.id}")
+        click.echo(f"  Content: {memory.content[:80]}{'...' if len(memory.content) > 80 else ''}")
+        click.echo(f"  Importance: {memory.importance}")
+    except ValueError as e:
+        click.echo(f"Error: {e}")
+
+
+@memory.command("stats")
+@click.option("--project", "-p", "project_ref", help="Project (name or UUID)")
+@click.pass_context
+def memory_stats(ctx: click.Context, project_ref: str | None) -> None:
+    """Show memory system statistics."""
+    project_id = resolve_project_ref(project_ref) if project_ref else None
+    manager = get_memory_manager(ctx)
+    stats = manager.get_stats(project_id=project_id)
+
+    click.echo("Memory Statistics:")
+    click.echo(f"  Total Memories: {stats['total_count']}")
+    click.echo(f"  Average Importance: {stats['avg_importance']:.3f}")
+    if stats["by_type"]:
+        click.echo("  By Type:")
+        for mem_type, count in stats["by_type"].items():
+            click.echo(f"    {mem_type}: {count}")
+
+
+@memory.command("export")
+@click.option("--project", "-p", "project_ref", help="Project (name or UUID)")
+@click.option(
+    "--output", "-o", "output_file", type=click.Path(), help="Output file (stdout if not specified)"
+)
+@click.option("--no-metadata", is_flag=True, help="Exclude memory metadata")
+@click.option("--no-stats", is_flag=True, help="Exclude summary statistics")
+@click.pass_context
+def export_memories(
+    ctx: click.Context,
+    project_ref: str | None,
+    output_file: str | None,
+    no_metadata: bool,
+    no_stats: bool,
+) -> None:
+    """Export memories as markdown.
+
+    Exports all memories (or filtered by project) to a formatted markdown document.
+    Output goes to stdout by default, or to a file with --output.
+
+    Examples:
+
+        gobby memory export                    # Export all to stdout
+
+        gobby memory export -o memories.md    # Export to file
+
+        gobby memory export -p myproject      # Export specific project
+
+        gobby memory export --no-metadata     # Content only, no metadata
+    """
+    project_id = resolve_project_ref(project_ref) if project_ref else None
+    manager = get_memory_manager(ctx)
+
+    markdown = manager.export_markdown(
+        project_id=project_id,
+        include_metadata=not no_metadata,
+        include_stats=not no_stats,
+    )
+
+    if output_file:
+        from pathlib import Path
+
+        path = Path(output_file)
+        try:
+            path.write_text(markdown, encoding="utf-8")
+            click.echo(f"Exported memories to {output_file}")
+        except OSError as e:
+            raise click.ClickException(f"Failed to write to {output_file}: {e}") from e
+    else:
+        click.echo(markdown)
+
+
+def resolve_memory_id(manager: MemoryManager, memory_ref: str) -> str:
+    """Resolve memory reference (UUID or prefix) to full ID."""
+    # Try exact match first
+    # Optimization: check 36 chars?
+    if len(memory_ref) == 36 and manager.get_memory(memory_ref):
+        return memory_ref
+
+    # Try prefix match using MemoryManager method
+    memories = manager.find_by_prefix(memory_ref, limit=5)
+
+    if not memories:
+        raise click.ClickException(f"Memory not found: {memory_ref}")
+
+    if len(memories) > 1:
+        click.echo(f"Ambiguous memory reference '{memory_ref}' matches:", err=True)
+        for mem in memories:
+            click.echo(f"  {mem.id}", err=True)
+        raise click.ClickException(f"Ambiguous memory reference: {memory_ref}")
+
+    return memories[0].id

gobby/cli/merge.py

@@ -0,0 +1,384 @@
+"""
+Merge conflict resolution CLI commands.
+
+Commands for managing merge operations:
+- start: Start a merge with AI-powered resolution
+- status: Show merge resolution status
+- resolve: Resolve a specific file conflict
+- apply: Apply resolved changes and complete merge
+- abort: Abort the merge operation
+"""
+
+import json
+from typing import Any
+
+import click
+
+from gobby.storage.database import LocalDatabase
+from gobby.storage.merge_resolutions import MergeResolutionManager
+
+
+def get_merge_manager() -> MergeResolutionManager:
+    """Get initialized merge resolution manager."""
+    db = LocalDatabase()
+    return MergeResolutionManager(db)
+
+
+def get_merge_resolver() -> Any:
+    """Get merge resolver for AI-powered resolution."""
+    from gobby.worktrees.merge import MergeResolver
+
+    return MergeResolver()
+
+
+def get_project_context() -> dict[str, Any] | None:
+    """Get current project context."""
+    import os
+    from pathlib import Path
+
+    # Look for .gobby/project.json in current directory or parents
+    cwd = Path(os.getcwd())
+    for parent in [cwd, *cwd.parents]:
+        project_file = parent / ".gobby" / "project.json"
+        if project_file.exists():
+            import json as json_module
+
+            result: dict[str, Any] = json_module.loads(project_file.read_text())
+            return result
+    return None
+
+
+def get_worktree_context() -> dict[str, Any] | None:
+    """Get current worktree context if in a worktree."""
+    import os
+    from pathlib import Path
+
+    from gobby.storage.worktrees import LocalWorktreeManager
+
+    db = LocalDatabase()
+    manager = LocalWorktreeManager(db)
+
+    # Check if current directory is a worktree
+    cwd = Path(os.getcwd()).resolve()
+    worktrees = manager.list_worktrees()
+    for wt in worktrees:
+        if wt.worktree_path:
+            worktree_path = Path(wt.worktree_path).resolve()
+            # Use is_relative_to for proper path containment check
+            try:
+                cwd.relative_to(worktree_path)
+                # If we get here, cwd is inside worktree_path
+                return {
+                    "id": wt.id,
+                    "branch_name": wt.branch_name,
+                    "worktree_path": wt.worktree_path,
+                    "base_branch": wt.base_branch,
+                }
+            except ValueError:
+                # cwd is not relative to worktree_path
+                continue
+    return None
+
+
+@click.group()
+def merge() -> None:
+    """Manage merge operations with AI-powered conflict resolution."""
+    pass
+
+
+@merge.command("start")
+@click.argument("source_branch")
+@click.option(
+    "--target",
+    "-t",
+    "target_branch",
+    default="main",
+    help="Target branch to merge into (default: main)",
+)
+@click.option(
+    "--strategy",
+    "-s",
+    type=click.Choice(["auto", "ai-only", "human"]),
+    default="auto",
+    help="Resolution strategy (default: auto)",
+)
+@click.option("--json", "json_format", is_flag=True, help="Output as JSON")
+def merge_start(
+    source_branch: str,
+    target_branch: str,
+    strategy: str,
+    json_format: bool,
+) -> None:
+    """Start a merge operation with AI-powered conflict resolution.
+
+    Examples:
+
+        gobby merge start feature/my-feature
+
+        gobby merge start feature/auth --target develop --strategy ai-only
+    """
+    project = get_project_context()
+    if not project:
+        click.echo("Error: Not in a Gobby project. Run 'gobby init' first.", err=True)
+        raise SystemExit(1)
+
+    # Get worktree context if available
+    worktree = get_worktree_context()
+    worktree_id = worktree["id"] if worktree else project.get("id", "default")
+
+    manager = get_merge_manager()
+
+    try:
+        # Create resolution record with strategy
+        resolution = manager.create_resolution(
+            worktree_id=worktree_id,
+            source_branch=source_branch,
+            target_branch=target_branch,
+            status="pending",
+            tier_used=strategy,
+        )
+
+        if json_format:
+            click.echo(json.dumps(resolution.to_dict(), indent=2, default=str))
+            return
+
+        click.echo(f"Started merge: {resolution.id}")
+        click.echo(f"  Source: {source_branch}")
+        click.echo(f"  Target: {target_branch}")
+        click.echo(f"  Strategy: {strategy}")
+        click.echo(f"  Status: {resolution.status}")
+
+    except Exception as e:
+        click.echo(f"Error starting merge: {e}", err=True)
+        raise SystemExit(1) from None
+
+
+@merge.command("status")
+@click.option("--verbose", "-v", is_flag=True, help="Show detailed conflict information")
+@click.option("--json", "json_format", is_flag=True, help="Output as JSON")
+def merge_status(verbose: bool, json_format: bool) -> None:
+    """Show the status of current merge operation.
+
+    Examples:
+
+        gobby merge status
+
+        gobby merge status --verbose
+    """
+    project = get_project_context()
+    if not project:
+        click.echo("Error: Not in a Gobby project. Run 'gobby init' first.", err=True)
+        raise SystemExit(1)
+
+    manager = get_merge_manager()
+
+    # Get worktree context for filtering
+    worktree = get_worktree_context()
+    worktree_id = worktree["id"] if worktree else None
+
+    # List active resolutions
+    resolutions = manager.list_resolutions(
+        worktree_id=worktree_id,
+        status="pending",
+    )
+
+    if json_format:
+        output = []
+        for res in resolutions:
+            res_dict = res.to_dict()
+            res_dict["conflicts"] = [
+                c.to_dict() for c in manager.list_conflicts(resolution_id=res.id)
+            ]
+            output.append(res_dict)
+        click.echo(json.dumps(output, indent=2, default=str))
+        return
+
+    if not resolutions:
+        click.echo("No active merge operations found.")
+        return
+
+    for res in resolutions:
+        conflicts = manager.list_conflicts(resolution_id=res.id)
+        pending_count = sum(1 for c in conflicts if c.status == "pending")
+        resolved_count = sum(1 for c in conflicts if c.status == "resolved")
+
+        click.echo(f"Merge: {res.id}")
+        click.echo(f"  Source: {res.source_branch} -> {res.target_branch}")
+        click.echo(f"  Status: {res.status}")
+        click.echo(f"  Conflicts: {pending_count} pending, {resolved_count} resolved")
+
+        if verbose and conflicts:
+            click.echo("  Files:")
+            for conflict in conflicts:
+                status_icon = "✓" if conflict.status == "resolved" else "○"
+                click.echo(f"    {status_icon} {conflict.file_path} ({conflict.status})")
+
+
+@merge.command("resolve")
+@click.argument("file_path")
+@click.option(
+    "--strategy",
+    "-s",
+    type=click.Choice(["ai", "human"]),
+    default="ai",
+    help="Resolution strategy (default: ai)",
+)
+@click.option("--json", "json_format", is_flag=True, help="Output as JSON")
+def merge_resolve(file_path: str, strategy: str, json_format: bool) -> None:
+    """Resolve a specific file conflict.
+
+    Examples:
+
+        gobby merge resolve src/main.py
+
+        gobby merge resolve src/config.py --strategy human
+    """
+    project = get_project_context()
+    if not project:
+        click.echo("Error: Not in a Gobby project. Run 'gobby init' first.", err=True)
+        raise SystemExit(1)
+
+    manager = get_merge_manager()
+
+    try:
+        # Find conflict by file path
+        conflict = manager.get_conflict_by_path(file_path)
+        if not conflict:
+            click.echo(f"Error: No conflict found for file '{file_path}'", err=True)
+            raise SystemExit(1)
+
+        if strategy == "ai":
+            # AI resolution
+            get_merge_resolver()  # Validates resolver is available
+            # Would call AI resolver here
+            click.echo(f"Resolving {file_path} with AI...")
+            manager.update_conflict(conflict.id, status="resolved")
+        else:
+            # Human resolution - just mark as pending human review
+            click.echo(f"Marked {file_path} for human resolution")
+
+        if json_format:
+            updated = manager.get_conflict(conflict.id)
+            if updated:
+                click.echo(json.dumps(updated.to_dict(), indent=2, default=str))
+            return
+
+        click.echo(f"Resolved: {file_path}")
+
+    except AttributeError:
+        # get_conflict_by_path may not exist
+        click.echo(f"Error: Conflict not found for '{file_path}'", err=True)
+        raise SystemExit(1) from None
+    except Exception as e:
+        click.echo(f"Error resolving conflict: {e}", err=True)
+        raise SystemExit(1) from None
+
+
+@merge.command("apply")
+@click.option("--force", "-f", is_flag=True, help="Force apply even with pending conflicts")
+@click.option("--json", "json_format", is_flag=True, help="Output as JSON")
+def merge_apply(force: bool, json_format: bool) -> None:
+    """Apply resolved changes and complete the merge.
+
+    Examples:
+
+        gobby merge apply
+
+        gobby merge apply --force
+    """
+    project = get_project_context()
+    if not project:
+        click.echo("Error: Not in a Gobby project. Run 'gobby init' first.", err=True)
+        raise SystemExit(1)
+
+    manager = get_merge_manager()
+
+    try:
+        # Get active resolution
+        resolution = manager.get_active_resolution()
+        if not resolution:
+            click.echo("Error: No active merge operation found.", err=True)
+            raise SystemExit(1)
+
+        # Check for pending conflicts
+        conflicts = manager.list_conflicts(resolution_id=resolution.id)
+        pending = [c for c in conflicts if c.status == "pending"]
+
+        if pending and not force:
+            click.echo(
+                f"Error: {len(pending)} pending conflict(s). "
+                "Resolve them or use --force to apply anyway.",
+                err=True,
+            )
+            raise SystemExit(1)
+
+        # Apply merge
+        manager.update_resolution(resolution.id, status="resolved")
+
+        if json_format:
+            updated = manager.get_resolution(resolution.id)
+            if updated:
+                click.echo(json.dumps(updated.to_dict(), indent=2, default=str))
+            return
+
+        click.echo(f"Applied merge: {resolution.id}")
+        click.echo(f"  {len(conflicts)} file(s) merged")
+
+    except AttributeError:
+        # get_active_resolution may not exist
+        click.echo("Error: No active merge operation found.", err=True)
+        raise SystemExit(1) from None
+    except Exception as e:
+        click.echo(f"Error applying merge: {e}", err=True)
+        raise SystemExit(1) from None
+
+
+@merge.command("abort")
+@click.option("--json", "json_format", is_flag=True, help="Output as JSON")
+def merge_abort(json_format: bool) -> None:
+    """Abort the current merge operation.
+
+    Examples:
+
+        gobby merge abort
+    """
+    project = get_project_context()
+    if not project:
+        click.echo("Error: Not in a Gobby project. Run 'gobby init' first.", err=True)
+        raise SystemExit(1)
+
+    manager = get_merge_manager()
+
+    try:
+        # Get active resolution
+        resolution = manager.get_active_resolution()
+        if not resolution:
+            click.echo("Error: No active merge operation to abort.", err=True)
+            raise SystemExit(1)
+
+        # Check if already resolved
+        if resolution.status == "resolved":
+            click.echo("Error: Cannot abort an already resolved merge.", err=True)
+            raise SystemExit(1)
+
+        # Delete resolution (cascades to conflicts)
+        resolution_id = resolution.id
+        deleted = manager.delete_resolution(resolution_id)
+
+        if json_format:
+            click.echo(json.dumps({"aborted": deleted, "resolution_id": resolution_id}))
+            return
+
+        if deleted:
+            click.echo(f"Aborted merge: {resolution_id}")
+        else:
+            click.echo("Failed to abort merge.", err=True)
+            raise SystemExit(1)
+
+    except AttributeError:
+        # get_active_resolution may not exist
+        click.echo("Error: No active merge operation to abort.", err=True)
+        raise SystemExit(1) from None
+    except Exception as e:
+        click.echo(f"Error aborting merge: {e}", err=True)
+        raise SystemExit(1) from None