htmlgraph 0.21.0__py3-none-any.whl → 0.23.0__py3-none-any.whl

htmlgraph/cli.py

@@ -8,6 +8,11 @@ Usage:
     htmlgraph status [--dir DIR]
     htmlgraph query SELECTOR [--dir DIR]
 
+Claude Code Integration:
+    htmlgraph claude                    # Start Claude Code
+    htmlgraph claude --init             # Start with orchestrator system prompt (recommended)
+    htmlgraph claude --continue         # Resume last Claude Code session
+
 Session Management:
     htmlgraph session start [--id ID] [--agent AGENT]
     htmlgraph session end ID [--notes NOTES] [--recommend NEXT] [--blocker BLOCKER]
@@ -111,9 +116,9 @@ def cmd_install_gemini_extension(args: argparse.Namespace) -> None:
 
 def cmd_serve(args: argparse.Namespace) -> None:
     """Start the HtmlGraph server."""
-    from htmlgraph.server import serve
+    from htmlgraph.operations import start_server
 
-    serve(
+    start_server(
         port=args.port,
         graph_dir=args.graph_dir,
         static_dir=args.static_dir,
@@ -122,10 +127,14 @@ def cmd_serve(args: argparse.Namespace) -> None:
         auto_port=args.auto_port,
     )
 
+    # The start_server operation already handles all output and blocks
+    # No additional CLI formatting needed
+
 
 def cmd_init(args: argparse.Namespace) -> None:
     """Initialize a new .htmlgraph directory."""
     import shutil
+    from contextlib import nullcontext
 
     from htmlgraph.analytics_index import AnalyticsIndex
     from htmlgraph.server import HtmlGraphAPIHandler
@@ -160,38 +169,33 @@ def cmd_init(args: argparse.Namespace) -> None:
         agent_name = "claude"
         generate_docs = True  # Always generate in non-interactive mode
 
-    graph_dir = Path(args.dir) / ".htmlgraph"
-    graph_dir.mkdir(parents=True, exist_ok=True)
-
-    for collection in HtmlGraphAPIHandler.COLLECTIONS:
-        (graph_dir / collection).mkdir(exist_ok=True)
-
-    # Event stream directory (Git-friendly source of truth)
-    events_dir = graph_dir / "events"
-    events_dir.mkdir(exist_ok=True)
-    if not args.no_events_keep:
-        keep = events_dir / ".gitkeep"
-        if not keep.exists():
-            keep.write_text("", encoding="utf-8")
-
-    # Copy stylesheet
-    styles_src = Path(__file__).parent / "styles.css"
-    styles_dest = graph_dir / "styles.css"
-    if styles_src.exists() and not styles_dest.exists():
-        styles_dest.write_text(styles_src.read_text())
-
-    # Create default index.html if not exists
-    index_path = Path(args.dir) / "index.html"
-    if not index_path.exists():
-        create_default_index(index_path)
-
-    # Create analytics cache DB (rebuildable; typically gitignored)
-    if not args.no_index:
+    def init_progress() -> tuple[Any | None, Any | None]:
+        if args.quiet or getattr(args, "format", "text") != "text":
+            return None, None
         try:
-            AnalyticsIndex(graph_dir / "index.sqlite").ensure_schema()
+            from rich.console import Console
+            from rich.progress import (
+                BarColumn,
+                Progress,
+                SpinnerColumn,
+                TextColumn,
+                TimeElapsedColumn,
+            )
         except Exception:
-            # Never fail init because of analytics cache.
-            pass
+            return None, None
+        console = Console()
+        progress = Progress(
+            SpinnerColumn(),
+            TextColumn("{task.description}"),
+            BarColumn(),
+            TimeElapsedColumn(),
+            console=console,
+            transient=True,
+        )
+        return progress, console
+
+    graph_dir = Path(args.dir) / ".htmlgraph"
+    events_dir = graph_dir / "events"
 
     def ensure_gitignore_entries(project_dir: Path, lines: list[str]) -> None:
         if args.no_update_gitignore:
@@ -218,19 +222,12 @@ def cmd_init(args: argparse.Namespace) -> None:
             # Don't fail init on .gitignore issues.
             pass
 
-    ensure_gitignore_entries(
-        Path(args.dir),
-        [
-            ".htmlgraph/index.sqlite",
-            ".htmlgraph/index.sqlite-wal",
-            ".htmlgraph/index.sqlite-shm",
-            ".htmlgraph/git-hook-errors.log",
-        ],
-    )
+    progress, progress_console = init_progress()
 
-    # Ensure versioned hook scripts exist (installation into .git/hooks is optional)
-    hooks_dir = graph_dir / "hooks"
-    hooks_dir.mkdir(exist_ok=True)
+    def status_context(message: str) -> Any:
+        if progress_console is None:
+            return nullcontext()
+        return progress_console.status(message)
 
     # Hook templates (used when htmlgraph is installed without this repo layout).
     post_commit = """#!/bin/bash
@@ -443,26 +440,77 @@ fi
 exit 0
 """
 
-    def ensure_hook_file(hook_name: str, hook_content: str) -> Path:
-        hook_dest = hooks_dir / f"{hook_name}.sh"
-        if not hook_dest.exists():
-            hook_dest.write_text(hook_content)
-        try:
-            hook_dest.chmod(0o755)
-        except Exception:
-            pass
-        return hook_dest
-
-    hook_files = {
-        "pre-commit": ensure_hook_file("pre-commit", pre_commit),
-        "post-commit": ensure_hook_file("post-commit", post_commit),
-        "post-checkout": ensure_hook_file("post-checkout", post_checkout),
-        "post-merge": ensure_hook_file("post-merge", post_merge),
-        "pre-push": ensure_hook_file("pre-push", pre_push),
-    }
+    hook_files: dict[str, Path] = {}
 
-    # Generate documentation files from templates
-    if generate_docs:
+    def create_graph_dirs() -> None:
+        graph_dir.mkdir(parents=True, exist_ok=True)
+        for collection in HtmlGraphAPIHandler.COLLECTIONS:
+            (graph_dir / collection).mkdir(exist_ok=True)
+
+    def create_events_dir() -> None:
+        events_dir.mkdir(exist_ok=True)
+        if not args.no_events_keep:
+            keep = events_dir / ".gitkeep"
+            if not keep.exists():
+                keep.write_text("", encoding="utf-8")
+
+    def copy_assets() -> None:
+        styles_src = Path(__file__).parent / "styles.css"
+        styles_dest = graph_dir / "styles.css"
+        if styles_src.exists() and not styles_dest.exists():
+            styles_dest.write_text(styles_src.read_text())
+
+        index_path = Path(args.dir) / "index.html"
+        if not index_path.exists():
+            create_default_index(index_path)
+
+    def init_analytics_cache() -> None:
+        if args.no_index:
+            return
+        with status_context("Initializing analytics cache..."):
+            try:
+                AnalyticsIndex(graph_dir / "index.sqlite").ensure_schema()
+            except Exception:
+                # Never fail init because of analytics cache.
+                pass
+
+    def update_gitignore() -> None:
+        ensure_gitignore_entries(
+            Path(args.dir),
+            [
+                ".htmlgraph/index.sqlite",
+                ".htmlgraph/index.sqlite-wal",
+                ".htmlgraph/index.sqlite-shm",
+                ".htmlgraph/git-hook-errors.log",
+            ],
+        )
+
+    def create_hook_templates() -> None:
+        nonlocal hook_files
+        hooks_dir = graph_dir / "hooks"
+        hooks_dir.mkdir(exist_ok=True)
+
+        def ensure_hook_file(hook_name: str, hook_content: str) -> Path:
+            hook_dest = hooks_dir / f"{hook_name}.sh"
+            if not hook_dest.exists():
+                hook_dest.write_text(hook_content)
+            try:
+                hook_dest.chmod(0o755)
+            except Exception:
+                pass
+            return hook_dest
+
+        hook_files = {
+            "pre-commit": ensure_hook_file("pre-commit", pre_commit),
+            "post-commit": ensure_hook_file("post-commit", post_commit),
+            "post-checkout": ensure_hook_file("post-checkout", post_checkout),
+            "post-merge": ensure_hook_file("post-merge", post_merge),
+            "pre-push": ensure_hook_file("pre-push", pre_push),
+        }
+
+    def generate_docs_step() -> None:
+        if not generate_docs:
+            return
 
         def render_template(
             template_path: Path, replacements: dict[str, str]
@@ -483,7 +531,7 @@ exit 0
             from htmlgraph import __version__
 
             version = __version__
-        except:
+        except Exception:
             version = "unknown"
 
         replacements = {
@@ -519,17 +567,9 @@ exit 0
                 gemini_dest.write_text(content, encoding="utf-8")
                 print(f"✓ Generated: {gemini_dest}")
 
-    print(f"\nInitialized HtmlGraph in {graph_dir}")
-    print(f"Collections: {', '.join(HtmlGraphAPIHandler.COLLECTIONS)}")
-    print("\nStart server with: htmlgraph serve")
-    if not args.no_index:
-        print(
-            f"Analytics cache: {graph_dir / 'index.sqlite'} (rebuildable; typically gitignored)"
-        )
-    print(f"Events: {events_dir}/ (append-only JSONL)")
-
-    # Install Git hooks if requested
-    if args.install_hooks:
+    def install_hooks_step() -> None:
+        if not args.install_hooks:
+            return
         git_dir = Path(args.dir) / ".git"
         if not git_dir.exists():
             print("\n⚠️  Warning: No .git directory found. Git hooks not installed.")
@@ -606,6 +646,46 @@ fi
 
         print("\nGit events will now be logged to HtmlGraph automatically.")
 
+    steps: list[tuple[str, Any]] = [
+        ("Create .htmlgraph directories", create_graph_dirs),
+        ("Create event log directory", create_events_dir),
+        ("Update .gitignore", update_gitignore),
+        ("Prepare git hook templates", create_hook_templates),
+        ("Copy default assets", copy_assets),
+    ]
+    if not args.no_index:
+        steps.append(("Initialize analytics cache", init_analytics_cache))
+    if generate_docs:
+        steps.append(("Generate documentation", generate_docs_step))
+    if args.install_hooks:
+        steps.append(("Install git hooks", install_hooks_step))
+
+    def run_steps(step_list: list[tuple[str, Any]]) -> None:
+        if progress is None:
+            for _, fn in step_list:
+                fn()
+            return
+
+        with progress:
+            task_id = progress.add_task(
+                "Initializing HtmlGraph...", total=len(step_list)
+            )
+            for description, fn in step_list:
+                progress.update(task_id, description=description)
+                fn()
+                progress.advance(task_id)
+
+    run_steps(steps)
+
+    print(f"\nInitialized HtmlGraph in {graph_dir}")
+    print(f"Collections: {', '.join(HtmlGraphAPIHandler.COLLECTIONS)}")
+    print("\nStart server with: htmlgraph serve")
+    if not args.no_index:
+        print(
+            f"Analytics cache: {graph_dir / 'index.sqlite'} (rebuildable; typically gitignored)"
+        )
+    print(f"Events: {events_dir}/ (append-only JSONL)")
+
 
 def cmd_install_hooks(args: argparse.Namespace) -> None:
     """Install Git hooks for automatic tracking."""
@@ -2164,6 +2244,173 @@ def cmd_track(args: argparse.Namespace) -> None:
             print(f"  Drift warning: {entry.drift_score:.2f}")
 
 
+# =============================================================================
+# Documentation Version Management Commands
+# =============================================================================
+
+
+def cmd_docs_version(args: argparse.Namespace) -> None:
+    """Check documentation version compatibility."""
+    from htmlgraph.docs import check_docs_version
+
+    htmlgraph_dir = Path(args.graph_dir)
+
+    if not htmlgraph_dir.exists():
+        print(f"❌ Directory not found: {htmlgraph_dir}")
+        print("   Run `htmlgraph init` first")
+        sys.exit(1)
+
+    compatible, message = check_docs_version(htmlgraph_dir)
+
+    if compatible and not message:
+        print("✅ Documentation is up to date")
+    elif compatible and message:
+        print(message)
+        print("\n💡 Run `htmlgraph docs upgrade` to update to latest version")
+    else:
+        print(message)
+        print("\n❌ Documentation version is incompatible")
+        print("   Run `htmlgraph docs upgrade` to migrate")
+        sys.exit(1)
+
+
+def cmd_docs_upgrade(args: argparse.Namespace) -> None:
+    """Upgrade documentation to latest version."""
+    from htmlgraph.docs import upgrade_docs_interactive
+    from htmlgraph.docs.docs_version import get_current_doc_version
+    from htmlgraph.docs.metadata import DocsMetadata
+    from htmlgraph.docs.migrations import get_migration
+
+    htmlgraph_dir = Path(args.graph_dir)
+
+    if not htmlgraph_dir.exists():
+        print(f"❌ Directory not found: {htmlgraph_dir}")
+        print("   Run `htmlgraph init` first")
+        sys.exit(1)
+
+    if args.auto:
+        # Auto-migrate without prompts
+        metadata = DocsMetadata.load(htmlgraph_dir)
+        current_version = get_current_doc_version()
+
+        if metadata.schema_version == current_version:
+            print("✅ Documentation is already up to date")
+            return
+
+        migration = get_migration(metadata.schema_version, current_version)
+        if not migration:
+            print(
+                f"❌ No migration available from v{metadata.schema_version} to v{current_version}"
+            )
+            sys.exit(1)
+
+        backup_dir = htmlgraph_dir / ".docs-backups"
+        backup_dir.mkdir(exist_ok=True)
+
+        print("🚀 Starting auto-migration...")
+        success = migration.migrate(htmlgraph_dir, backup_dir)
+
+        if success:
+            print("✅ Migration complete!")
+            print(f"📦 Backup saved to {backup_dir}")
+        else:
+            print("❌ Migration failed")
+            sys.exit(1)
+    else:
+        # Interactive upgrade
+        upgrade_docs_interactive(htmlgraph_dir)
+
+
+def cmd_docs_diff(args: argparse.Namespace) -> None:
+    """Show migration diff preview."""
+    htmlgraph_dir = Path(args.graph_dir)
+
+    if not htmlgraph_dir.exists():
+        print(f"❌ Directory not found: {htmlgraph_dir}")
+        print("   Run `htmlgraph init` first")
+        sys.exit(1)
+
+    print("📊 Showing migration preview...")
+    print("⚠️  Diff preview not yet implemented")
+    print("    Use `htmlgraph docs upgrade` instead")
+
+
+def cmd_docs_rollback(args: argparse.Namespace) -> None:
+    """Rollback to previous documentation version."""
+    from htmlgraph.docs.metadata import DocsMetadata
+    from htmlgraph.docs.migrations import get_migration
+
+    htmlgraph_dir = Path(args.graph_dir)
+
+    if not htmlgraph_dir.exists():
+        print(f"❌ Directory not found: {htmlgraph_dir}")
+        print("   Run `htmlgraph init` first")
+        sys.exit(1)
+
+    backup_dir = htmlgraph_dir / ".docs-backups"
+    if not backup_dir.exists() or not list(backup_dir.glob("v*")):
+        print("❌ No backups found")
+        print("   Nothing to rollback to")
+        sys.exit(1)
+
+    # Get target version
+    metadata = DocsMetadata.load(htmlgraph_dir)
+    target_version = int(args.version) if args.version else metadata.schema_version - 1
+
+    if target_version < 1:
+        print("❌ Invalid version")
+        sys.exit(1)
+
+    # Get migration script
+    migration = get_migration(target_version, metadata.schema_version)
+    if not migration:
+        print(
+            f"❌ Cannot rollback from v{metadata.schema_version} to v{target_version}"
+        )
+        sys.exit(1)
+
+    print(f"🔄 Rolling back to v{target_version}...")
+    try:
+        migration.rollback(htmlgraph_dir, backup_dir)
+        print("✅ Rollback complete")
+    except Exception as e:
+        print(f"❌ Rollback failed: {e}")
+        sys.exit(1)
+
+
+def cmd_docs_generate(args: argparse.Namespace) -> None:
+    """Generate documentation from templates with user customizations."""
+    from htmlgraph.docs import sync_docs_to_file
+
+    htmlgraph_dir = Path(args.graph_dir)
+    output_file = Path(args.output) if args.output else Path("AGENTS.md")
+    platform = args.platform
+
+    if not htmlgraph_dir.exists():
+        print(f"❌ Directory not found: {htmlgraph_dir}")
+        print("   Run `htmlgraph init` first")
+        sys.exit(1)
+
+    try:
+        print(f"📝 Generating documentation for platform: {platform}")
+        print(f"   Output: {output_file}")
+
+        result_path = sync_docs_to_file(htmlgraph_dir, output_file, platform)
+
+        print(f"✅ Documentation generated: {result_path}")
+        print("\n💡 To customize:")
+        print(f"   1. Create {htmlgraph_dir}/docs/templates/agents.md.j2")
+        print("   2. Extend base template: {% extends 'base_agents.md.j2' %}")
+        print("   3. Override blocks: header, introduction, custom_workflows, etc.")
+
+    except Exception as e:
+        print(f"❌ Generation failed: {e}")
+        import traceback
+
+        traceback.print_exc()
+        sys.exit(1)
+
+
 # =============================================================================
 # Events & Index Commands
 # =============================================================================
@@ -2191,22 +2438,15 @@ def cmd_events_export(args: argparse.Namespace) -> None:
 
 def cmd_index_rebuild(args: argparse.Namespace) -> None:
     """Rebuild the SQLite analytics index from JSONL event logs."""
-    from htmlgraph.analytics_index import AnalyticsIndex
-    from htmlgraph.event_log import JsonlEventLog
+    from htmlgraph.operations import rebuild_index
 
     graph_dir = Path(args.graph_dir)
-    events_dir = graph_dir / "events"
-    db_path = graph_dir / "index.sqlite"
 
-    log = JsonlEventLog(events_dir)
-    index = AnalyticsIndex(db_path)
+    result = rebuild_index(graph_dir=graph_dir)
 
-    events = (event for _, event in log.iter_events())
-    result = index.rebuild_from_events(events)
-
-    print(f"DB: {db_path}")
-    print(f"Inserted: {result['inserted']}")
-    print(f"Skipped:  {result['skipped']}")
+    print(f"DB: {result.db_path}")
+    print(f"Inserted: {result.inserted}")
+    print(f"Skipped:  {result.skipped}")
 
 
 def cmd_watch(args: argparse.Namespace) -> None:
@@ -3345,6 +3585,106 @@ def create_default_index(path: Path) -> None:
     )
 
 
+def cmd_claude(args: argparse.Namespace) -> None:
+    """Start Claude Code with orchestrator prompt."""
+    import textwrap
+
+    try:
+        if args.init:
+            # Load optimized orchestrator system prompt
+            prompt_file = Path(__file__).parent / "orchestrator_system_prompt.txt"
+
+            if prompt_file.exists():
+                system_prompt = prompt_file.read_text(encoding="utf-8")
+            else:
+                # Fallback: provide minimal orchestrator guidance
+                system_prompt = textwrap.dedent(
+                    """
+                    You are an AI orchestrator for HtmlGraph project development.
+
+                    CRITICAL DIRECTIVES:
+                    1. DELEGATE to subagents - do not implement directly
+                    2. CREATE work items before delegating (features, bugs, spikes)
+                    3. USE SDK for tracking - all work must be tracked in .htmlgraph/
+                    4. RESPECT dependencies - check blockers before starting
+
+                    Key Rules:
+                    - Implementation work → delegate to general-purpose subagent
+                    - Research/exploration → delegate to explorer subagent
+                    - Testing/validation → delegate to test-runner subagent
+                    - Complex analysis → delegate to appropriate specialist
+
+                    Always use:
+                        from htmlgraph import SDK
+                        sdk = SDK(agent='orchestrator')
+
+                    See CLAUDE.md for complete orchestrator directives.
+                    """
+                )
+
+            if args.quiet or args.format == "json":
+                # Non-interactive: directly launch Claude with system prompt
+                cmd = ["claude", "--append-system-prompt", system_prompt]
+            else:
+                # Interactive: show summary first
+                print("=" * 60)
+                print("🤖 HtmlGraph Orchestrator Mode")
+                print("=" * 60)
+                print("\nStarting Claude Code with orchestrator system prompt...")
+                print("Key directives:")
+                print("  ✓ Delegate implementation to subagents")
+                print("  ✓ Create work items before delegating")
+                print("  ✓ Track all work in .htmlgraph/")
+                print("  ✓ Respect dependency chains")
+                print()
+
+                cmd = ["claude", "--append-system-prompt", system_prompt]
+
+            try:
+                subprocess.run(cmd, check=False)
+            except FileNotFoundError:
+                print("Error: 'claude' command not found.", file=sys.stderr)
+                print(
+                    "Please install Claude Code CLI: https://code.claude.com",
+                    file=sys.stderr,
+                )
+                sys.exit(1)
+
+        elif args.continue_session:
+            # Resume last Claude Code session
+            if args.quiet or args.format == "json":
+                cmd = ["claude", "--resume"]
+            else:
+                print("Resuming last Claude Code session...")
+                cmd = ["claude", "--resume"]
+
+            try:
+                subprocess.run(cmd, check=False)
+            except FileNotFoundError:
+                print("Error: 'claude' command not found.", file=sys.stderr)
+                print(
+                    "Please install Claude Code CLI: https://code.claude.com",
+                    file=sys.stderr,
+                )
+                sys.exit(1)
+
+        else:
+            # Default: start normal Claude Code session
+            try:
+                subprocess.run(["claude"], check=False)
+            except FileNotFoundError:
+                print("Error: 'claude' command not found.", file=sys.stderr)
+                print(
+                    "Please install Claude Code CLI: https://code.claude.com",
+                    file=sys.stderr,
+                )
+                sys.exit(1)
+
+    except Exception as e:
+        print(f"Error: Failed to start Claude Code: {e}", file=sys.stderr)
+        sys.exit(1)
+
+
 def main() -> None:
     parser = argparse.ArgumentParser(
         description="HtmlGraph - HTML is All You Need",
@@ -4428,6 +4768,64 @@ For more help: https://github.com/Shakes-tzd/htmlgraph
         "--graph-dir", "-g", default=".htmlgraph", help="Graph directory"
     )
 
+    # =========================================================================
+    # Documentation Version Management
+    # =========================================================================
+
+    docs_parser = subparsers.add_parser("docs", help="Documentation version management")
+    docs_subparsers = docs_parser.add_subparsers(
+        dest="docs_command", help="Docs command"
+    )
+
+    docs_version = docs_subparsers.add_parser(
+        "version", help="Check documentation version compatibility"
+    )
+    docs_version.add_argument(
+        "--graph-dir", "-g", default=".htmlgraph", help="Graph directory"
+    )
+
+    docs_upgrade = docs_subparsers.add_parser(
+        "upgrade", help="Upgrade documentation to latest version"
+    )
+    docs_upgrade.add_argument(
+        "--graph-dir", "-g", default=".htmlgraph", help="Graph directory"
+    )
+    docs_upgrade.add_argument(
+        "--auto", action="store_true", help="Auto-migrate without prompts"
+    )
+
+    docs_diff = docs_subparsers.add_parser("diff", help="Show migration diff preview")
+    docs_diff.add_argument(
+        "--graph-dir", "-g", default=".htmlgraph", help="Graph directory"
+    )
+
+    docs_rollback = docs_subparsers.add_parser(
+        "rollback", help="Rollback to previous version"
+    )
+    docs_rollback.add_argument(
+        "--graph-dir", "-g", default=".htmlgraph", help="Graph directory"
+    )
+    docs_rollback.add_argument(
+        "version", nargs="?", help="Version to rollback to (default: latest backup)"
+    )
+
+    docs_generate = docs_subparsers.add_parser(
+        "generate", help="Generate documentation from templates"
+    )
+    docs_generate.add_argument(
+        "--graph-dir", "-g", default=".htmlgraph", help="Graph directory"
+    )
+    docs_generate.add_argument(
+        "--platform",
+        "-p",
+        default="claude",
+        choices=["claude", "gemini", "api", "cli"],
+        help="Platform to generate docs for",
+    )
+    docs_generate.add_argument(
+        "--output", "-o", help="Output file (default: AGENTS.md)"
+    )
+
     # =========================================================================
     # Events & Analytics Index
     # =========================================================================
@@ -4692,6 +5090,24 @@ For more help: https://github.com/Shakes-tzd/htmlgraph
         help="Install the Gemini CLI extension from the bundled package",
     )
 
+    # claude - Start Claude Code with orchestrator support
+    claude_parser = subparsers.add_parser(
+        "claude", help="Start Claude Code with HtmlGraph integration"
+    )
+    claude_group = claude_parser.add_mutually_exclusive_group()
+    claude_group.add_argument(
+        "--init",
+        action="store_true",
+        help="Start with orchestrator system prompt (recommended)",
+    )
+    claude_group.add_argument(
+        "--continue",
+        dest="continue_session",
+        action="store_true",
+        help="Resume last Claude Code session",
+    )
+    claude_parser.set_defaults(func=cmd_claude)
+
     args = parser.parse_args()
 
     if args.command == "serve":
@@ -4840,6 +5256,20 @@ For more help: https://github.com/Shakes-tzd/htmlgraph
         from htmlgraph.analytics.cli import cmd_analytics
 
         cmd_analytics(args)
+    elif args.command == "docs":
+        if args.docs_command == "version":
+            cmd_docs_version(args)
+        elif args.docs_command == "upgrade":
+            cmd_docs_upgrade(args)
+        elif args.docs_command == "diff":
+            cmd_docs_diff(args)
+        elif args.docs_command == "rollback":
+            cmd_docs_rollback(args)
+        elif args.docs_command == "generate":
+            cmd_docs_generate(args)
+        else:
+            docs_parser.print_help()
+            sys.exit(1)
     elif args.command == "events":
         if args.events_command == "export-sessions":
             cmd_events_export(args)
@@ -4915,6 +5345,8 @@ For more help: https://github.com/Shakes-tzd/htmlgraph
             sys.exit(1)
     elif args.command == "install-gemini-extension":
         cmd_install_gemini_extension(args)
+    elif args.command == "claude":
+        cmd_claude(args)
     else:
         parser.print_help()
         sys.exit(1)