docmost-cli 0.4.0__py3-none-any.whl

docmost_cli/cli/page.py

@@ -0,0 +1,382 @@
+"""Page subcommands."""
+
+import json
+import sys
+from pathlib import Path
+
+import typer
+
+from docmost_cli.api.pages import (
+    build_page_tree,
+    copy_page,
+    create_and_place_page,
+    delete_page,
+    duplicate_page,
+    export_page,
+    get_page_children,
+    get_page_content,
+    get_page_history,
+    get_page_info,
+    import_page,
+    list_recent_pages,
+    move_page,
+    update_page_content,
+    update_page_meta,
+)
+from docmost_cli.api.pagination import extract_id, extract_items
+from docmost_cli.api.spaces import resolve_space_id
+from docmost_cli.cli.main import get_client, state
+from docmost_cli.output.formatter import (
+    print_content,
+    print_content_with_meta,
+    print_error,
+    print_result,
+    print_table,
+)
+from docmost_cli.output.tree import print_tree
+
+__all__ = ["page_app"]
+
+page_app = typer.Typer(name="page", help="Page operations.")
+
+
+def _resolve_content(
+    content: str | None,
+    file: Path | None,
+    stdin: bool,
+) -> str | None:
+    """Resolve content from --content, --file, or --stdin.
+
+    These are mutually exclusive. Returns None if no source provided.
+
+    Args:
+        content: Inline content string.
+        file: Path to content file.
+        stdin: Whether to read from stdin.
+
+    Returns:
+        Resolved content string, or None.
+    """
+    sources = sum([content is not None, file is not None, stdin])
+    if sources > 1:
+        print_error("Only one of --content, --file, or --stdin may be specified.")
+    if sources == 0:
+        return None
+    if content is not None:
+        # Interpret common escape sequences so --content "Line 1\n\nLine 2" works
+        return content.replace("\\n", "\n").replace("\\t", "\t")
+    if file is not None:
+        if not file.exists():
+            print_error(f"File not found: {file}")
+        return file.read_text(encoding="utf-8")
+    # stdin
+    if sys.stdin.isatty():
+        print_error(
+            "No input piped to stdin. "
+            "Use --content or --file instead, or pipe input: "
+            "echo '# Page' | docmost-cli page create ..."
+        )
+    return sys.stdin.read()
+
+
+@page_app.command("create")
+def page_create_cmd(
+    space_slug: str = typer.Argument(help="Space slug to create the page in"),
+    title: str = typer.Option(..., "--title", help="Page title (required)"),
+    content: str | None = typer.Option(None, "--content", help="Markdown content string"),
+    file: Path | None = typer.Option(None, "--file", help="Read content from file"),
+    stdin: bool = typer.Option(False, "--stdin", help="Read content from stdin"),
+    parent: str | None = typer.Option(None, "--parent", help="Parent page ID"),
+    icon: str | None = typer.Option(None, "--icon", help="Page icon emoji"),
+) -> None:
+    """Create a new page via Markdown import.
+
+    See also: page move (reposition), page children (list children).
+    """
+    resolved = _resolve_content(content, file, stdin) or ""
+    client = get_client()
+    space_id = resolve_space_id(client, space_slug)
+
+    page_id = create_and_place_page(
+        client,
+        space_id=space_id,
+        title=title,
+        content=resolved,
+        parent_page_id=parent,
+        icon=icon,
+    )
+
+    msg = f"Created page '{title}' in space '{space_slug}'"
+    if not resolved:
+        msg = f"Created empty page '{title}' in space '{space_slug}'"
+    print_result(page_id, msg)
+
+
+@page_app.command("update")
+def page_update_cmd(
+    page_id: str = typer.Argument(help="Page ID to update"),
+    title: str | None = typer.Option(None, "--title", help="New title"),
+    icon: str | None = typer.Option(None, "--icon", help="Page icon emoji"),
+    content: str | None = typer.Option(None, "--content", help="New content (Markdown)"),
+    file: Path | None = typer.Option(None, "--file", help="Read content from file"),
+    stdin: bool = typer.Option(False, "--stdin", help="Read content from stdin"),
+) -> None:
+    """Update an existing page's title, icon, and/or content.
+
+    See also: page move (reposition), page get (view current content).
+    """
+    resolved = _resolve_content(content, file, stdin)
+    if title is None and icon is None and resolved is None:
+        print_error("At least one of --title, --icon, --content, --file, or --stdin is required.")
+
+    client = get_client()
+    info = get_page_info(client, page_id)
+    page_title = info.get("title", page_id)
+
+    if title is not None or icon is not None:
+        update_page_meta(client, page_id=page_id, title=title, icon=icon)
+        if title is not None:
+            page_title = title
+
+    if resolved is not None:
+        update_page_content(client, page_id=page_id, content=resolved)
+
+    print_result(page_id, f"Updated page '{page_title}'")
+
+
+@page_app.command("delete")
+def page_delete_cmd(
+    page_id: str = typer.Argument(help="Page ID to delete"),
+) -> None:
+    """Delete a page (requires confirmation unless --yes).
+
+    See also: page duplicate (copy before deleting).
+    """
+    client = get_client()
+    info = get_page_info(client, page_id)
+    page_title = info.get("title", page_id)
+
+    if not state.yes:
+        typer.confirm(f"Delete page '{page_title}' ({page_id})?", abort=True)
+
+    delete_page(client, page_id)
+    print_result(page_id, f"Deleted page '{page_title}'")
+
+
+@page_app.command("move")
+def page_move_cmd(
+    page_id: str = typer.Argument(help="Page ID to move"),
+    parent: str | None = typer.Option(None, "--parent", help="New parent page ID"),
+    space: str | None = typer.Option(None, "--space", help="Target space slug"),
+    position: str | None = typer.Option(None, "--position", help="Position among siblings"),
+) -> None:
+    """Move a page to a new location.
+
+    See also: page children (find targets), page list --tree (view hierarchy).
+    """
+    if parent is None and space is None and position is None:
+        print_error("At least one of --parent, --space, or --position is required.")
+
+    client = get_client()
+    target_space_id = None
+    if space is not None:
+        target_space_id = resolve_space_id(client, space)
+
+    move_page(
+        client,
+        page_id=page_id,
+        parent_page_id=parent,
+        space_id=target_space_id,
+        position=position,
+    )
+    print_result(page_id, f"Moved page '{page_id}'")
+
+
+@page_app.command("list")
+def page_list_cmd(
+    space_slug: str = typer.Argument(help="Space slug to list pages in"),
+    limit: int | None = typer.Option(None, "--limit", help="Max results (default: 50)"),
+    cursor: str | None = typer.Option(None, "--cursor", help="Pagination cursor"),
+    tree: bool = typer.Option(False, "--tree", help="Show as indented tree"),
+    json_mode: bool = typer.Option(False, "--json", help="Output as JSON array"),
+) -> None:
+    """List pages in a space.
+
+    See also: page children (list by parent), page get (single page).
+    """
+    client = get_client()
+    space_id = resolve_space_id(client, space_slug)
+
+    if tree:
+        pages = build_page_tree(client, space_id)
+        print_tree(pages)
+        return
+
+    result = list_recent_pages(client, space_id, limit=limit, cursor=cursor)
+    items = extract_items(result)
+    columns = ["id", "title", "icon", "updatedAt", "parentPageId"]
+    print_table(items, columns, json_mode=json_mode)
+
+
+@page_app.command("get")
+def page_get_cmd(
+    page_id: str = typer.Argument(help="Page ID to retrieve"),
+    raw: bool = typer.Option(False, "--raw", help="Output ProseMirror JSON instead of Markdown"),
+    meta: bool = typer.Option(False, "--meta", help="Prepend YAML frontmatter with metadata"),
+) -> None:
+    """Get page content as Markdown.
+
+    See also: page list --json (batch retrieval), page export (to file).
+    """
+    client = get_client()
+
+    if raw:
+        # Raw mode: reuse get_page_content which handles Enterprise/Community fallback
+        info = get_page_content(client, page_id)
+        pm_content = info.get("content")
+        if not pm_content:
+            print_error("No content available for raw output.", exit_code=1)
+        sys.stdout.write(json.dumps(pm_content, indent=2) + "\n")
+        return
+
+    # Normal mode: get content and convert to Markdown
+    info = get_page_content(client, page_id)
+    pm_content = info.get("content")
+    if not pm_content:
+        print_error("Page has no content.", exit_code=1)
+
+    from docmost_cli.convert.prosemirror_to_md import convert_to_markdown
+
+    markdown = convert_to_markdown(pm_content)
+
+    if meta:
+        metadata = {
+            "id": info.get("id", ""),
+            "title": info.get("title", ""),
+            "parent_id": info.get("parentPageId", ""),
+            "space_id": info.get("spaceId", ""),
+            "created": info.get("createdAt", ""),
+            "updated": info.get("updatedAt", ""),
+        }
+        print_content_with_meta(markdown, metadata)
+    else:
+        print_content(markdown)
+
+
+@page_app.command("duplicate")
+def page_duplicate_cmd(
+    page_id: str = typer.Argument(help="Page ID to duplicate"),
+) -> None:
+    """Duplicate a page."""
+    client = get_client()
+    info = get_page_info(client, page_id)
+    page_title = info.get("title", page_id)
+    result = duplicate_page(client, page_id)
+    new_id = extract_id(result)
+    print_result(new_id, f"Duplicated page '{page_title}'")
+
+
+@page_app.command("copy")
+def page_copy_cmd(
+    page_id: str = typer.Argument(help="Page ID to copy"),
+    space: str = typer.Option(..., "--space", help="Target space slug (required)"),
+) -> None:
+    """Copy a page to a different space."""
+    client = get_client()
+    info = get_page_info(client, page_id)
+    page_title = info.get("title", page_id)
+    target_space_id = resolve_space_id(client, space)
+    result = copy_page(client, page_id, target_space_id)
+    new_id = extract_id(result)
+    print_result(new_id, f"Copied page '{page_title}' to space '{space}'")
+
+
+@page_app.command("children")
+def page_children_cmd(
+    page_id: str = typer.Argument(help="Page ID to list children for"),
+    json_mode: bool = typer.Option(False, "--json", help="Output as JSON array"),
+) -> None:
+    """List child pages of a parent.
+
+    See also: page list --tree (full hierarchy), page move (reposition).
+    """
+    client = get_client()
+    result = get_page_children(client, page_id)
+    items = extract_items(result)
+    columns = ["id", "title", "icon", "updatedAt"]
+    print_table(items, columns, json_mode=json_mode)
+
+
+@page_app.command("history")
+def page_history_cmd(
+    page_id: str = typer.Argument(help="Page ID to show history for"),
+    limit: int | None = typer.Option(None, "--limit", help="Max results"),
+    json_mode: bool = typer.Option(False, "--json", help="Output as JSON array"),
+) -> None:
+    """Show page version history."""
+    client = get_client()
+    result = get_page_history(client, page_id, limit=limit)
+    items = extract_items(result)
+    columns = ["id", "creatorId", "createdAt"]
+    print_table(items, columns, json_mode=json_mode)
+
+
+@page_app.command("export")
+def page_export_cmd(
+    page_id: str = typer.Argument(help="Page ID to export"),
+    fmt: str = typer.Option("md", "--format", help="Export format: md or html"),
+    output: Path | None = typer.Option(None, "--output", help="Write to file instead of stdout"),
+) -> None:
+    """Export page content."""
+    client = get_client()
+    content = export_page(client, page_id, fmt=fmt)
+
+    if output:
+        if output.exists() and not state.yes:
+            typer.confirm(f"File '{output}' already exists. Overwrite?", abort=True)
+        output.write_text(str(content), encoding="utf-8")
+        from rich.console import Console
+
+        Console(stderr=True).print(f"Exported to {output}")
+    else:
+        print_content(str(content))
+
+
+@page_app.command("import")
+def page_import_cmd(
+    space_slug: str = typer.Argument(help="Space slug to import into"),
+    file: Path = typer.Option(..., "--file", help="Markdown or HTML file to import"),
+    title: str | None = typer.Option(None, "--title", help="Override page title"),
+    parent: str | None = typer.Option(None, "--parent", help="Parent page ID"),
+) -> None:
+    """Import a file as a new page."""
+    if not file.exists():
+        print_error(f"File not found: {file}")
+
+    client = get_client()
+    space_id = resolve_space_id(client, space_slug)
+
+    # Read file once
+    file_bytes = file.read_bytes()
+    file_text = file_bytes.decode("utf-8", errors="replace")
+
+    # Auto-detect title: flag > H1 in file > filename stem
+    detected_title = title
+    if not detected_title:
+        for line in file_text.split("\n"):
+            stripped = line.strip()
+            if stripped.startswith("# ") and not stripped.startswith("## "):
+                detected_title = stripped[2:].strip()
+                break
+    if not detected_title:
+        detected_title = file.stem
+
+    result = import_page(
+        client,
+        space_id=space_id,
+        file_name=file.name,
+        file_bytes=file_bytes,
+        parent_page_id=parent,
+    )
+    new_id = extract_id(result)
+    print_result(new_id, f"Imported '{detected_title}' from {file.name}")

docmost_cli/cli/search.py

@@ -0,0 +1,33 @@
+"""Search subcommand."""
+
+import typer
+
+from docmost_cli.api.pagination import extract_items
+from docmost_cli.api.search import search
+from docmost_cli.api.spaces import resolve_space_id
+from docmost_cli.cli.main import get_client
+from docmost_cli.output.formatter import print_table
+
+__all__ = ["search_app"]
+
+search_app = typer.Typer(name="search", help="Search across the wiki.")
+
+
+@search_app.command("query")
+def search_cmd(
+    query: str = typer.Argument(help="Search query"),
+    space: str | None = typer.Option(None, "--space", help="Filter by space slug"),
+    limit: int | None = typer.Option(None, "--limit", help="Max results (default: 20)"),
+    type_filter: str | None = typer.Option(None, "--type", help="Filter: page or attachment"),
+    json_mode: bool = typer.Option(False, "--json", help="Output as JSON array"),
+) -> None:
+    """Full-text search across the wiki."""
+    client = get_client()
+    space_id = None
+    if space is not None:
+        space_id = resolve_space_id(client, space)
+
+    result = search(client, query, space_id=space_id, result_type=type_filter, limit=limit)
+    items = extract_items(result)
+    columns = ["id", "title", "highlight"]
+    print_table(items, columns, json_mode=json_mode)

docmost_cli/cli/space.py

@@ -0,0 +1,57 @@
+"""Space subcommands."""
+
+import typer
+
+from docmost_cli.api.pagination import extract_id, extract_items
+from docmost_cli.api.spaces import (
+    create_space,
+    list_spaces,
+    resolve_space_id,
+    update_space,
+)
+from docmost_cli.cli.main import get_client
+from docmost_cli.output.formatter import print_error, print_result, print_table
+
+__all__ = ["space_app"]
+
+space_app = typer.Typer(name="space", help="Space operations.")
+
+
+@space_app.command("list")
+def space_list_cmd(
+    json_mode: bool = typer.Option(False, "--json", help="Output as JSON array"),
+) -> None:
+    """List all spaces."""
+    client = get_client()
+    result = list_spaces(client)
+    items = extract_items(result)
+    columns = ["id", "name", "slug", "description"]
+    print_table(items, columns, json_mode=json_mode)
+
+
+@space_app.command("create")
+def space_create_cmd(
+    name: str = typer.Option(..., "--name", help="Space name (required)"),
+    slug: str | None = typer.Option(None, "--slug", help="Space slug (auto-generated if omitted)"),
+    description: str | None = typer.Option(None, "--description", help="Space description"),
+) -> None:
+    """Create a new space."""
+    client = get_client()
+    result = create_space(client, name=name, slug=slug, description=description)
+    space_id = extract_id(result)
+    print_result(space_id, f"Created space '{name}'")
+
+
+@space_app.command("update")
+def space_update_cmd(
+    space_slug: str = typer.Argument(help="Space slug to update"),
+    name: str | None = typer.Option(None, "--name", help="New space name"),
+    description: str | None = typer.Option(None, "--description", help="New description"),
+) -> None:
+    """Update an existing space."""
+    if name is None and description is None:
+        print_error("At least one of --name or --description is required.")
+    client = get_client()
+    space_id = resolve_space_id(client, space_slug)
+    update_space(client, space_id=space_id, name=name, description=description)
+    print_result(space_id, f"Updated space '{space_slug}'")

docmost_cli/cli/sync_cmd.py

@@ -0,0 +1,122 @@
+"""Sync subcommands."""
+
+from pathlib import Path
+
+import typer
+
+from docmost_cli.cli.main import get_client, state
+from docmost_cli.output.formatter import print_error
+
+__all__ = ["sync_app"]
+
+sync_app = typer.Typer(name="sync", help="Sync space pages to/from local directory.")
+
+
+@sync_app.command("pull")
+def sync_pull_cmd(
+    space_slug: str = typer.Argument(help="Space slug to pull pages from"),
+    dir_path: Path = typer.Option(
+        None, "--dir", help="Target directory (default: ./<space-slug>/)"
+    ),
+    force: bool = typer.Option(False, "--force", help="Overwrite local changes without warning"),
+) -> None:
+    """Download all pages from a space to local Markdown files.
+
+    Creates a directory with one .md file per page (with YAML frontmatter)
+    and a .docmost-manifest.json tracking sync state.
+
+    See also: sync push (upload changes), sync status (show changes).
+    """
+    from docmost_cli.sync.pull import pull_space
+
+    client = get_client()
+    target = dir_path or Path(space_slug)
+    pull_space(client, space_slug, target, force=force)
+
+
+@sync_app.command("status")
+def sync_status_cmd(
+    space_slug: str = typer.Argument(help="Space slug to check"),
+    dir_path: Path = typer.Option(
+        None, "--dir", help="Directory to check (default: ./<space-slug>/)"
+    ),
+) -> None:
+    """Show changes between local files and last-pulled state.
+
+    See also: sync push (upload changes), sync pull (download from server).
+    """
+    import sys
+
+    from docmost_cli.sync.diff import compute_diff
+    from docmost_cli.sync.manifest import load_manifest
+
+    target = dir_path or Path(space_slug)
+    manifest = load_manifest(target)
+    if manifest is None:
+        print_error(f"No manifest found in '{target}'. Run 'sync pull' first.")
+        return  # unreachable (print_error exits), but makes control flow explicit
+
+    diff = compute_diff(manifest, target)
+
+    if not diff.has_changes:
+        sys.stdout.write("No changes.\n")
+        return
+
+    if diff.new:
+        sys.stdout.write(f"  New:       {len(diff.new)} file(s)\n")
+        for c in diff.new:
+            sys.stdout.write(f"    + {c.filename}\n")
+    if diff.modified:
+        sys.stdout.write(f"  Modified:  {len(diff.modified)} file(s)\n")
+        for c in diff.modified:
+            types = ", ".join(ct.value for ct in c.changes if ct.name != "MOVED")
+            sys.stdout.write(f"    ~ {c.filename} ({types})\n")
+    if diff.moved:
+        move_only = [c for c in diff.moved if c not in diff.modified]
+        if move_only:
+            sys.stdout.write(f"  Moved:     {len(move_only)} file(s)\n")
+            for c in move_only:
+                sys.stdout.write(f"    -> {c.filename}\n")
+    if diff.deleted:
+        sys.stdout.write(f"  Deleted:   {len(diff.deleted)} file(s)\n")
+        for c in diff.deleted:
+            entry = c.manifest_entry or {}
+            sys.stdout.write(f"    - {entry.get('filename', '?')}\n")
+    sys.stdout.write(f"  Unchanged: {diff.unchanged} file(s)\n")
+
+
+@sync_app.command("push")
+def sync_push_cmd(
+    space_slug: str = typer.Argument(help="Space slug to push changes to"),
+    dir_path: Path = typer.Option(
+        None, "--dir", help="Source directory (default: ./<space-slug>/)"
+    ),
+    dry_run: bool = typer.Option(False, "--dry-run", help="Show changes without executing"),
+    delete: bool = typer.Option(False, "--delete", help="Delete server pages not found locally"),
+) -> None:
+    """Upload local changes to Docmost server.
+
+    Requires a prior 'sync pull' to establish the manifest.
+    Use --dry-run to preview changes before applying.
+
+    See also: sync status (preview changes), sync pull (download from server).
+    """
+    from docmost_cli.sync.diff import compute_diff
+    from docmost_cli.sync.manifest import load_manifest
+    from docmost_cli.sync.push import push_space
+
+    client = get_client()
+    target = dir_path or Path(space_slug)
+
+    # Pre-compute diff once — reused for confirmation prompt and push_space
+    pre_diff = None
+    if not dry_run and not state.yes:
+        manifest = load_manifest(target)
+        if manifest is None:
+            print_error(f"No manifest found in '{target}'. Run 'sync pull' first.")
+            return
+        pre_diff = compute_diff(manifest, target)
+        if pre_diff.has_changes:
+            typer.confirm("Push changes?", abort=True)
+
+    push_space(client, space_slug, target, dry_run=dry_run, delete=delete, diff=pre_diff)

docmost_cli/cli/user.py

@@ -0,0 +1,25 @@
+"""User subcommands."""
+
+from typing import Any
+
+import typer
+
+from docmost_cli.api.users import get_current_user
+from docmost_cli.cli.main import get_client
+from docmost_cli.output.formatter import print_key_value
+
+__all__ = ["user_app"]
+
+user_app = typer.Typer(name="user", help="Current user info.")
+
+
+@user_app.command("me")
+def user_me_cmd() -> None:
+    """Show authenticated user info."""
+    client = get_client()
+    result = get_current_user(client)
+    display: dict[str, Any] = {}
+    for key in ["email", "name", "id", "role", "createdAt"]:
+        if key in result:
+            display[key] = result[key]
+    print_key_value(display)

docmost_cli/cli/workspace.py

@@ -0,0 +1,40 @@
+"""Workspace subcommands."""
+
+from typing import Any
+
+import typer
+
+from docmost_cli.api.pagination import extract_items
+from docmost_cli.api.workspace import get_workspace_info, list_workspace_members
+from docmost_cli.cli.main import get_client
+from docmost_cli.output.formatter import print_key_value, print_table
+
+__all__ = ["workspace_app"]
+
+workspace_app = typer.Typer(name="workspace", help="Workspace info.")
+
+
+@workspace_app.command("info")
+def workspace_info_cmd() -> None:
+    """Show workspace details."""
+    client = get_client()
+    result = get_workspace_info(client)
+    data = result.get("data", result)
+    display: dict[str, Any] = {}
+    for key in ["name", "id", "description", "memberCount", "createdAt"]:
+        if key in data:
+            display[key] = data[key]
+    print_key_value(display)
+
+
+@workspace_app.command("members")
+def workspace_members_cmd(
+    limit: int | None = typer.Option(None, "--limit", help="Max results"),
+    json_mode: bool = typer.Option(False, "--json", help="Output as JSON array"),
+) -> None:
+    """List workspace members."""
+    client = get_client()
+    result = list_workspace_members(client, limit=limit)
+    items = extract_items(result)
+    columns = ["id", "email", "name", "role"]
+    print_table(items, columns, json_mode=json_mode)

docmost_cli/config/__init__.py

@@ -0,0 +1,23 @@
+"""Configuration management: settings model and config file I/O."""
+
+from docmost_cli.config.settings import DocmostSettings
+from docmost_cli.config.store import (
+    get_cache_dir,
+    get_config_path,
+    load_settings,
+    read_config,
+    read_profile,
+    set_config_value,
+    write_config,
+)
+
+__all__ = [
+    "DocmostSettings",
+    "get_cache_dir",
+    "get_config_path",
+    "load_settings",
+    "read_config",
+    "read_profile",
+    "set_config_value",
+    "write_config",
+]