echome 0.1.0__py3-none-any.whl

echome/__init__.py

@@ -0,0 +1,3 @@
+"""EchoMe CLI - Personal memory sync tool for AI CLI environments."""
+
+__version__ = "0.1.0"

echome/commands/clean.py

@@ -0,0 +1,77 @@
+"""echome clean - Remove all EchoMe injected content for a clean environment."""
+
+from pathlib import Path
+
+import typer
+from rich.console import Console
+from rich.prompt import Confirm
+
+from echome.core.client import HubClient
+from echome.core.config import Config
+from echome.targets.claude import ClaudeCodeTarget
+from echome.targets.codex import CodexTarget
+
+console = Console()
+
+ALL_TARGETS = [ClaudeCodeTarget(), CodexTarget()]
+
+
+def clean(
+    scope: str = typer.Option(
+        "all",
+        "--scope",
+        "-s",
+        help="What to clean: 'global', 'project', or 'all'",
+    ),
+    delete_hub_data: bool = typer.Option(
+        False,
+        "--delete-hub-data",
+        help="Also delete all memories from Hub (DESTRUCTIVE!)",
+    ),
+) -> None:
+    """Remove EchoMe injected content for a clean AI environment.
+
+    Scopes:
+      global  — Remove from ~/.claude/CLAUDE.md and ~/.codex/AGENTS.md
+      project — Remove from current project's CLAUDE.md / AGENTS.md
+      all     — Remove both global and project level
+    """
+    project_dir = Path.cwd()
+    console.print("\n[bold yellow]EchoMe Clean[/bold yellow]\n")
+
+    if scope in ("global", "all"):
+        console.print("[bold]Global files:[/bold]")
+        for t in ALL_TARGETS:
+            t.eject_global()
+            console.print(f"  [green]✓[/green] Cleaned {t.name}: {t.global_file}")
+
+    if scope in ("project", "all"):
+        console.print(f"\n[bold]Project files[/bold] ({project_dir}):")
+        for t in ALL_TARGETS:
+            pf = t.project_file(project_dir)
+            if pf.exists() and "<!-- echome:begin -->" in pf.read_text():
+                t.eject_project(project_dir)
+                console.print(f"  [green]✓[/green] Cleaned {t.name}: {pf}")
+            else:
+                console.print(f"  [dim]  {t.name}: nothing to clean[/dim]")
+
+    if delete_hub_data:
+        console.print("\n[bold red]⚠ Delete ALL memories from Hub?[/bold red]")
+        console.print("[dim]This will permanently remove all your stored memories.[/dim]")
+        if Confirm.ask("Are you sure?", default=False):
+            config = Config.load()
+            client = HubClient(config)
+            try:
+                # Get all memories and delete them
+                result = client.list_memories(limit=200)
+                items = result.get("items", [])
+                for item in items:
+                    client.delete_memory(item["id"], hard=True)
+                console.print(f"  [green]✓[/green] Deleted {len(items)} memories from Hub")
+            except Exception as e:
+                console.print(f"  [red]Error: {e}[/red]")
+        else:
+            console.print("  [dim]Skipped.[/dim]")
+
+    console.print("\n[green]Done![/green] Your AI environment is clean.")
+    console.print("[dim]Run `echome sync` when you want to re-inject memories.[/dim]")

echome/commands/init.py

@@ -0,0 +1,123 @@
+"""echome init - Initialize local vault, configure Hub, and optionally set up MCP."""
+
+import typer
+from rich.console import Console
+from rich.prompt import Confirm, Prompt
+
+from echome.core.config import Config, ensure_vault_dirs
+
+console = Console()
+
+
+def _mcp_available() -> bool:
+    """Check if MCP server package is installed."""
+    try:
+        import echome_mcp  # noqa: F401
+        return True
+    except ImportError:
+        return False
+
+
+def _setup_mcp() -> None:
+    """Register EchoMe MCP server in Claude Code and Codex CLI."""
+    import json
+    from pathlib import Path
+
+    mcp_config = {
+        "command": "echome",
+        "args": ["mcp", "serve"],
+    }
+
+    registered = []
+
+    # Claude Code
+    claude_mcp = Path.home() / ".claude" / "mcp.json"
+    claude_mcp.parent.mkdir(parents=True, exist_ok=True)
+    try:
+        data = json.loads(claude_mcp.read_text()) if claude_mcp.exists() else {}
+    except (json.JSONDecodeError, OSError):
+        data = {}
+    data.setdefault("mcpServers", {})["echome"] = mcp_config
+    claude_mcp.write_text(json.dumps(data, indent=2))
+    registered.append(f"Claude Code ({claude_mcp})")
+
+    # Codex CLI
+    codex_mcp = Path.home() / ".codex" / "mcp.json"
+    codex_mcp.parent.mkdir(parents=True, exist_ok=True)
+    try:
+        data = json.loads(codex_mcp.read_text()) if codex_mcp.exists() else {}
+    except (json.JSONDecodeError, OSError):
+        data = {}
+    data.setdefault("mcpServers", {})["echome"] = mcp_config
+    codex_mcp.write_text(json.dumps(data, indent=2))
+    registered.append(f"Codex CLI ({codex_mcp})")
+
+    for r in registered:
+        console.print(f"    [green]✓[/green] {r}")
+
+
+def init(
+    hub_url: str = typer.Option("", "--hub-url", "-u", help="Hub URL"),
+    token: str = typer.Option("", "--token", "-t", help="Auth token"),
+    skip_mcp: bool = typer.Option(False, "--skip-mcp", help="Skip MCP server setup"),
+) -> None:
+    """Initialize EchoMe: vault + Hub connection + MCP registration."""
+    console.print("\n[bold green]━━━ EchoMe Init ━━━[/bold green]\n")
+
+    # ─── Step 1: Hub Connection ───
+    console.print("[bold]1. Hub Connection[/bold]")
+
+    if not hub_url:
+        hub_url = Prompt.ask("   Hub URL", default="http://localhost:20000")
+    if not token:
+        token = Prompt.ask("   Auth Token", password=True, default="")
+
+    config = Config(hub_url=hub_url, token=token)
+
+    # Test connection
+    if token:
+        console.print("   Testing connection...", end=" ")
+        try:
+            from echome.core.client import HubClient
+            client = HubClient(config)
+            health = client.health()
+            console.print(f"[green]✓ Connected[/green] (Hub v{health.get('version', '?')})")
+        except Exception as e:
+            console.print(f"[yellow]✗ Failed: {e}[/yellow]")
+            console.print("   [dim]You can fix this later in ~/.echome/config.yaml[/dim]")
+    else:
+        console.print("   [dim]Skipping connection test (no token)[/dim]")
+
+    # Save config + create vault dirs
+    config.save()
+    ensure_vault_dirs()
+    console.print("   [green]✓[/green] Vault created at ~/.echome/\n")
+
+    # ─── Step 2: MCP Server (optional) ───
+    console.print("[bold]2. MCP Server[/bold] [dim](让 AI 可以查询你的记忆)[/dim]")
+
+    if skip_mcp:
+        console.print("   [dim]Skipped (--skip-mcp)[/dim]\n")
+    elif _mcp_available():
+        install_mcp = Confirm.ask("   Register MCP server to Claude Code / Codex CLI?", default=True)
+        if install_mcp:
+            _setup_mcp()
+            console.print("   [green]✓[/green] MCP registered. Restart AI CLI to activate.\n")
+        else:
+            console.print("   [dim]Skipped. Run `echome mcp install` later if needed.[/dim]\n")
+    else:
+        console.print("   [yellow]⚠ MCP 未安装[/yellow]")
+        console.print("   [dim]安装 MCP 支持: pip install echome-cli[mcp][/dim]")
+        console.print("   [dim]安装后运行 `echome mcp install` 即可注册[/dim]\n")
+
+    # ─── Done ───
+    console.print("[bold green]━━━ 初始化完成 ━━━[/bold green]\n")
+    console.print("下一步:")
+    console.print("  [cyan]eme add[/cyan]      — 添加第一条记忆")
+    console.print("  [cyan]eme list[/cyan]     — 查看所有记忆")
+    console.print("  [cyan]eme search[/cyan]   — 搜索记忆")
+    console.print("  [cyan]eme sync[/cyan]     — 同步到 AI CLI 配置文件")
+
+
+if __name__ == "__main__":
+    typer.run(init)

echome/commands/login.py

@@ -0,0 +1,188 @@
+"""Login/logout/whoami commands for multi-user authentication."""
+
+import http.server
+import threading
+import urllib.parse
+import webbrowser
+
+import typer
+from rich.console import Console
+
+from echome.core.config import Config
+
+console = Console()
+
+# Local callback server state
+_received_token: str | None = None
+_server_event = threading.Event()
+
+
+class _CallbackHandler(http.server.BaseHTTPRequestHandler):
+    """HTTP handler to capture the JWT from browser redirect."""
+
+    def do_GET(self) -> None:
+        global _received_token
+        parsed = urllib.parse.urlparse(self.path)
+        params = urllib.parse.parse_qs(parsed.query)
+
+        token = params.get("token", [None])[0]
+        if token:
+            _received_token = token
+            self.send_response(200)
+            self.send_header("Content-Type", "text/html; charset=utf-8")
+            self.end_headers()
+            self.wfile.write(
+                b"<html><body><h2>&#10004; Login successful!</h2>"
+                b"<p>You can close this tab and return to the terminal.</p>"
+                b"</body></html>"
+            )
+            _server_event.set()
+        else:
+            self.send_response(400)
+            self.send_header("Content-Type", "text/html")
+            self.end_headers()
+            self.wfile.write(b"<html><body><h2>Missing token</h2></body></html>")
+
+    def log_message(self, format, *args) -> None:
+        """Suppress server logs."""
+        pass
+
+
+def login(
+    browser: bool = typer.Option(False, "--browser", "-b", help="Use browser flow (requires GUI desktop)"),
+    manual: bool = typer.Option(False, "--manual", "-m", help="(deprecated, now default) Paste token manually"),
+    hub: str = typer.Option("", "--hub", help="Hub URL (default: from config or https://echome.qzhqzh.com)"),
+) -> None:
+    """Login via GitHub OAuth. Default: open URL, copy token, paste back."""
+    global _received_token
+    _received_token = None
+
+    config = Config.load()
+
+    # Allow overriding hub URL
+    if hub.strip():
+        config.hub_url = hub.strip().rstrip("/")
+        config.save()
+
+    hub_url = config.hub_url.rstrip("/")
+
+    if browser:
+        # Browser flow with local callback server (for GUI desktops)
+        _login_browser(config, hub_url)
+        return
+
+    # Default: manual/token-paste flow (works on any Linux)
+    console.print("\n[bold]EchoMe Login[/bold]\n")
+
+    # Direct user to the CLI-friendly login page
+    cli_login_url = f"{hub_url}/login?source=cli"
+
+    console.print(f"  1. Open this URL in your browser:\n")
+    console.print(f"     [cyan]{cli_login_url}[/cyan]\n")
+    console.print(f"  2. Click [bold]Login with GitHub[/bold] and authorize")
+    console.print(f"  3. Copy the token shown on the page\n")
+
+    # Allow retrying if token is wrong
+    while True:
+        token = typer.prompt("Paste token here")
+        if not token.strip():
+            console.print("[red]No token provided.[/red]")
+            raise typer.Exit(1)
+
+        # Strip common accidental prefixes (e.g. "$ " from copy-paste)
+        cleaned = token.strip()
+        if cleaned.startswith("$ "):
+            cleaned = cleaned[2:]
+
+        config.token = cleaned
+        config.save()
+
+        # Verify the token works
+        try:
+            _verify_and_show_user(config)
+            console.print("[green]✓ Login successful![/green]\n")
+            return
+        except SystemExit:
+            # _verify_and_show_user calls typer.Exit on failure
+            console.print("[yellow]Token invalid or expired. Try again (Ctrl+C to quit).[/yellow]\n")
+            config.token = ""
+            config.save()
+            continue
+
+
+def _login_browser(config: Config, hub_url: str) -> None:
+    """Browser-based login with local callback server (for GUI desktops)."""
+    global _received_token
+    console.print("\n[bold]GitHub OAuth Login (Browser)[/bold]\n")
+
+    port = 19876
+    server = http.server.HTTPServer(("127.0.0.1", port), _CallbackHandler)
+    server_thread = threading.Thread(target=server.serve_forever, daemon=True)
+    server_thread.start()
+
+    auth_url = f"{hub_url}/api/v1/auth/github"
+    console.print(f"Opening browser to: [cyan]{auth_url}[/cyan]")
+    console.print(f"[dim]Waiting for callback on http://127.0.0.1:{port} ...[/dim]\n")
+
+    try:
+        webbrowser.open(auth_url)
+    except Exception:
+        console.print(f"[yellow]Could not open browser.[/yellow]")
+        console.print(f"Try: [cyan]echome login[/cyan] (default token-paste flow)\n")
+
+    if _server_event.wait(timeout=120):
+        server.shutdown()
+        if _received_token:
+            config.token = _received_token
+            config.save()
+            console.print("[green]✓ Login successful![/green]\n")
+            _verify_and_show_user(config)
+        else:
+            console.print("[red]✗ Failed to receive token.[/red]")
+            raise typer.Exit(1)
+    else:
+        server.shutdown()
+        console.print("[red]✗ Timeout.[/red] Try: [cyan]echome login[/cyan]\n")
+        raise typer.Exit(1)
+
+
+def logout() -> None:
+    """Clear saved JWT token."""
+    config = Config.load()
+    if not config.token:
+        console.print("[dim]Not logged in.[/dim]")
+        return
+    config.token = ""
+    config.save()
+    console.print("[green]✓ Logged out.[/green]\n")
+
+
+def whoami() -> None:
+    """Show current user info."""
+    config = Config.load()
+    if not config.token:
+        console.print("[yellow]Not logged in.[/yellow] Run: [cyan]echome login[/cyan]\n")
+        raise typer.Exit(1)
+    _verify_and_show_user(config)
+
+
+def _verify_and_show_user(config: Config) -> None:
+    """Verify token and display user info. Raises typer.Exit(1) on failure."""
+    from echome.core.client import HubClient
+
+    try:
+        client = HubClient(config)
+        with client._client() as http_client:
+            resp = http_client.get("/api/v1/auth/me")
+            resp.raise_for_status()
+            user = resp.json()
+
+        console.print(f"  User:  [bold]{user['username']}[/bold]")
+        console.print(f"  Role:  {user['role']}")
+        console.print(f"  Hub:   {config.hub_url}")
+        console.print()
+    except SystemExit:
+        raise
+    except Exception as e:
+        console.print(f"[red]✗ Verification failed:[/red] {e}")
+        raise typer.Exit(1)

echome/commands/market.py

@@ -0,0 +1,204 @@
+"""Market commands: browse, search, fork public memories."""
+
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from echome.core.client import HubClient
+from echome.core.config import Config
+
+console = Console()
+
+market_app = typer.Typer(help="Browse and fork public memories from the market")
+
+
+def _market_client() -> HubClient:
+    """Create a HubClient (auth optional for read-only)."""
+    return HubClient(Config.load())
+
+
+@market_app.callback(invoke_without_command=True)
+def market_default(ctx: typer.Context) -> None:
+    """Show market stats when no subcommand is given."""
+    if ctx.invoked_subcommand is not None:
+        return
+
+    client = _market_client()
+    with client._client() as http_client:
+        resp = http_client.get("/api/v1/market/stats")
+        resp.raise_for_status()
+        stats = resp.json()
+
+    console.print("\n[bold cyan]📚 EchoMe Memory Market[/bold cyan]\n")
+    console.print(f"  Total public memories: [green]{stats['total_public']}[/green]")
+    console.print(f"  New in last 7 days:    [green]{stats['recent_count_7d']}[/green]")
+
+    if stats.get("by_type"):
+        console.print("\n  [bold]By type:[/bold]")
+        for t, count in sorted(stats["by_type"].items(), key=lambda x: -x[1]):
+            console.print(f"    {t:<16} {count}")
+
+    console.print("\n[dim]Commands: echome market search <query> | echome market browse | echome market fork <id>[/dim]\n")
+
+
+@market_app.command("browse")
+def browse(
+    type: str = typer.Option(None, "--type", "-t", help="Filter by memory type"),
+    layer: str = typer.Option(None, "--layer", "-l", help="Filter by layer (L0/L1/L2)"),
+    tags: str = typer.Option(None, "--tags", help="Comma-separated tags to filter"),
+    limit: int = typer.Option(20, "--limit", "-n", help="Number of results"),
+    offset: int = typer.Option(0, "--offset", help="Pagination offset"),
+) -> None:
+    """Browse public memories in the market."""
+    client = _market_client()
+    params: dict = {"limit": limit, "offset": offset}
+    if type:
+        params["type"] = type
+    if layer:
+        params["layer"] = layer
+    if tags:
+        params["tags"] = tags
+
+    with client._client() as http_client:
+        resp = http_client.get("/api/v1/market/memories", params=params)
+        resp.raise_for_status()
+        data = resp.json()
+
+    if not data["items"]:
+        console.print("[dim]No public memories found.[/dim]\n")
+        return
+
+    table = Table(title=f"Market ({data['total']} total)")
+    table.add_column("ID", style="dim", max_width=8)
+    table.add_column("Title", style="bold")
+    table.add_column("Type", style="cyan")
+    table.add_column("Layer")
+    table.add_column("Tags", style="green")
+    table.add_column("Tokens", justify="right")
+
+    for item in data["items"]:
+        short_id = str(item["id"])[:8]
+        tags_str = ", ".join(item.get("tags", [])[:3])
+        table.add_row(
+            short_id,
+            item["title"][:50],
+            item["type"],
+            item["layer"],
+            tags_str,
+            str(item.get("token_count", 0)),
+        )
+
+    console.print(table)
+    console.print(f"\n[dim]Showing {data['offset'] + 1}-{data['offset'] + len(data['items'])} of {data['total']}[/dim]\n")
+
+
+@market_app.command("search")
+def search(
+    query: str = typer.Argument(..., help="Search keywords"),
+    type: str = typer.Option(None, "--type", "-t", help="Filter by memory type"),
+    limit: int = typer.Option(20, "--limit", "-n", help="Number of results"),
+) -> None:
+    """Search public memories by keyword."""
+    client = _market_client()
+    params: dict = {"q": query, "limit": limit}
+    if type:
+        params["type"] = type
+
+    with client._client() as http_client:
+        resp = http_client.get("/api/v1/market/memories", params=params)
+        resp.raise_for_status()
+        data = resp.json()
+
+    if not data["items"]:
+        console.print(f"[dim]No results for '{query}'[/dim]\n")
+        return
+
+    table = Table(title=f"Search: '{query}' ({data['total']} results)")
+    table.add_column("ID", style="dim", max_width=8)
+    table.add_column("Title", style="bold")
+    table.add_column("Type", style="cyan")
+    table.add_column("Layer")
+    table.add_column("Tags", style="green")
+
+    for item in data["items"]:
+        short_id = str(item["id"])[:8]
+        tags_str = ", ".join(item.get("tags", [])[:3])
+        table.add_row(short_id, item["title"][:50], item["type"], item["layer"], tags_str)
+
+    console.print(table)
+    console.print()
+
+
+@market_app.command("fork")
+def fork(
+    memory_id: str = typer.Argument(..., help="UUID of the public memory to fork"),
+) -> None:
+    """Fork a public memory into your personal library."""
+    config = Config.load()
+    if not config.token:
+        console.print("[red]Not logged in.[/red] Run [cyan]echome login[/cyan] first.\n")
+        raise typer.Exit(1)
+
+    client = HubClient(config)
+    with client._client() as http_client:
+        resp = http_client.post(f"/api/v1/market/memories/{memory_id}/fork")
+        if resp.status_code == 404:
+            console.print("[red]Memory not found or not public.[/red]\n")
+            raise typer.Exit(1)
+        if resp.status_code == 400:
+            console.print(f"[yellow]{resp.json().get('detail', 'Bad request')}[/yellow]\n")
+            raise typer.Exit(1)
+        resp.raise_for_status()
+        data = resp.json()
+
+    console.print(f"[green]✓ Forked![/green] New memory: {data['id']}")
+    console.print(f"  Title: {data['title']}")
+    console.print(f"  Source: {data['forked_from']}\n")
+
+
+@market_app.command("publish")
+def publish(
+    memory_id: str = typer.Argument(..., help="UUID of your memory to make public"),
+) -> None:
+    """Set one of your memories as public (visible in market)."""
+    config = Config.load()
+    if not config.token:
+        console.print("[red]Not logged in.[/red] Run [cyan]echome login[/cyan] first.\n")
+        raise typer.Exit(1)
+
+    client = HubClient(config)
+    with client._client() as http_client:
+        resp = http_client.patch(
+            f"/api/v1/memories/{memory_id}",
+            json={"visibility": "public"},
+        )
+        if resp.status_code == 404:
+            console.print("[red]Memory not found.[/red]\n")
+            raise typer.Exit(1)
+        resp.raise_for_status()
+
+    console.print(f"[green]✓ Memory {memory_id[:8]}... is now public.[/green]\n")
+
+
+@market_app.command("unpublish")
+def unpublish(
+    memory_id: str = typer.Argument(..., help="UUID of your memory to make private"),
+) -> None:
+    """Set one of your memories as private (hide from market)."""
+    config = Config.load()
+    if not config.token:
+        console.print("[red]Not logged in.[/red] Run [cyan]echome login[/cyan] first.\n")
+        raise typer.Exit(1)
+
+    client = HubClient(config)
+    with client._client() as http_client:
+        resp = http_client.patch(
+            f"/api/v1/memories/{memory_id}",
+            json={"visibility": "private"},
+        )
+        if resp.status_code == 404:
+            console.print("[red]Memory not found.[/red]\n")
+            raise typer.Exit(1)
+        resp.raise_for_status()
+
+    console.print(f"[green]✓ Memory {memory_id[:8]}... is now private.[/green]\n")