chunksmith-cli 0.4.0__py3-none-any.whl

chunksmith_cli/views/outline_browser.py

@@ -0,0 +1,247 @@
+"""Session-based outline browser (like Document Q&A load + sub-menu)."""
+
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Callable
+
+from rich.console import Console
+from rich.markup import escape
+from rich.panel import Panel
+from rich.prompt import Prompt
+
+from chunksmith_cli.menu import MenuOption, prompt_menu
+from chunksmith_cli.panels import print_extraction_warnings_panel
+from chunksmith_cli.paths import ensure_cli_storage, normalize_path_string, resolve_pdf_candidate
+from chunksmith_cli.saved_catalog import list_saved_outlines
+from chunksmith_cli.tree_view import print_structure_tree
+
+OUTLINE_BROWSER_MENU: tuple[MenuOption, ...] = (
+    MenuOption("1", "Open saved outline", "Pick from cli/data or enter a path"),
+    MenuOption("2", "Show section tree", "Nested outline (structure)"),
+    MenuOption("3", "Document summary", "doc_description and extraction warnings"),
+    MenuOption("4", "View raw JSON", "Full file contents in terminal"),
+    MenuOption(
+        "5",
+        "Outline reasoning",
+        "Chain-of-thought from outline_thinking (if saved)",
+    ),
+)
+
+
+@dataclass
+class OutlineBrowserState:
+    data: dict[str, Any] | None = None
+    path: Path | None = None
+    label: str | None = None
+
+    @property
+    def is_ready(self) -> bool:
+        return self.data is not None and isinstance(self.data.get("structure"), list)
+
+    def status_line(self) -> str:
+        if not self.is_ready:
+            return (
+                "[dim]No outline loaded — use option 1. "
+                "Works with ``*_multi_index.json``, ``*_pageindex.json``, or legacy ``*_v3_index.json``.[/dim]"
+            )
+        n_nodes = 0
+        st = self.data.get("structure") if self.data else None
+        if isinstance(st, list):
+
+            def _count(nodes: list[Any]) -> int:
+                total = len(nodes)
+                for node in nodes:
+                    if isinstance(node, dict) and isinstance(node.get("nodes"), list):
+                        total += _count(node["nodes"])
+                return total
+
+            n_nodes = _count(st)
+        kind = "outline"
+        if self.path:
+            if "_multi_index" in self.path.name:
+                kind = "multi-index"
+            elif "_pageindex" in self.path.name:
+                kind = "pageindex"
+            elif "_v3_index" in self.path.name:
+                kind = "v3 (legacy)"
+        return (
+            f"[green]Loaded:[/green] [bold]{escape(self.label or 'outline')}[/bold] "
+            f"[dim]({kind} · {n_nodes} nodes)[/dim]"
+        )
+
+
+def _load_outline_file(path: Path) -> dict[str, Any]:
+    data = json.loads(path.read_text(encoding="utf-8"))
+    if not isinstance(data, dict):
+        raise ValueError("root must be a JSON object")
+    if not isinstance(data.get("structure"), list):
+        raise ValueError("missing top-level 'structure' (not an outline file)")
+    return data
+
+
+def _prompt_outline_path(console: Console, storage: Path) -> Path | None:
+    rows = list_saved_outlines()
+    console.print(
+        f"\n[bold]Open saved outline[/bold]\n"
+        f"[dim]``*_pageindex.json`` or ``*_v3_index.json`` under[/dim] [cyan]{storage}[/cyan]\n"
+        f"[dim]Path, stem, or number from list. Empty line = cancel.[/dim]\n"
+    )
+    if rows:
+        console.print("[dim]Recent outlines:[/dim]")
+        for i, r in enumerate(rows, start=1):
+            tag = f" [dim]({r.kind} · {r.source})[/dim]"
+            console.print(f"  [cyan]{i:>2}[/]  {escape(r.stem)}{tag}")
+
+    while True:
+        raw = Prompt.ask("[bold]Outline path or number[/bold]", default="", show_default=False).strip()
+        if not raw:
+            if rows:
+                pick = Prompt.ask("[bold]Or pick number[/bold]", default="1")
+                try:
+                    return rows[int(pick) - 1].path
+                except (ValueError, IndexError):
+                    console.print("[red]Invalid number.[/red]")
+                    continue
+            return None
+
+        if raw.isdigit() and rows:
+            idx = int(raw)
+            if 1 <= idx <= len(rows):
+                return rows[idx - 1].path
+
+        path = resolve_pdf_candidate(normalize_path_string(raw))
+        if not path.is_file():
+            alt = (storage / path.name).resolve()
+            if alt.is_file():
+                path = alt
+        if path.is_file():
+            return path
+        console.print("[yellow]Not a file — try again or leave empty to cancel.[/yellow]\n")
+
+
+def _open_outline(console: Console, state: OutlineBrowserState, storage: Path) -> None:
+    path = _prompt_outline_path(console, storage)
+    if path is None:
+        console.print("[dim]Cancelled.[/dim]")
+        return
+    try:
+        data = _load_outline_file(path)
+    except (OSError, json.JSONDecodeError, ValueError) as e:
+        console.print(f"[bold red]Could not load:[/bold red] {e}")
+        return
+    state.data = data
+    state.path = path.resolve()
+    state.label = str(data.get("doc_name") or path.stem)
+    console.print(f"\n[bold green]Loaded.[/bold green] {state.status_line()}\n")
+    doc_title = str(data.get("doc_name") or path.stem)
+    print_structure_tree(console, data.get("structure"), title=f"Outline — {doc_title}")
+
+
+def _show_tree(console: Console, state: OutlineBrowserState) -> None:
+    if not state.is_ready:
+        console.print("[yellow]Load an outline first (option 1).[/yellow]")
+        return
+    doc_title = str(state.data.get("doc_name") or state.label or "document")
+    print_structure_tree(console, state.data.get("structure"), title=f"Outline — {doc_title}")
+
+
+def _show_summary(console: Console, state: OutlineBrowserState) -> None:
+    if not state.is_ready:
+        console.print("[yellow]Load an outline first (option 1).[/yellow]")
+        return
+    print_extraction_warnings_panel(console, state.data.get("extraction_warnings"))
+    desc = state.data.get("doc_description")
+    if isinstance(desc, str) and desc.strip():
+        console.print(
+            Panel(
+                escape(desc.strip()),
+                title="[bold]Document description[/bold]",
+                border_style="blue",
+            )
+        )
+    elif not state.data.get("extraction_warnings"):
+        console.print("[dim]No doc_description or warnings in this file.[/dim]")
+
+
+def _show_raw_json(console: Console, state: OutlineBrowserState) -> None:
+    if not state.is_ready:
+        console.print("[yellow]Load an outline first (option 1).[/yellow]")
+        return
+    console.print(
+        Panel(
+            json.dumps(state.data, ensure_ascii=False, indent=2),
+            title=f"[bold]JSON — {escape(state.label or '')}[/bold]",
+            border_style="green",
+            expand=False,
+        )
+    )
+
+
+def _show_outline_thinking(console: Console, state: OutlineBrowserState) -> None:
+    if not state.is_ready:
+        console.print("[yellow]Load an outline first (option 1).[/yellow]")
+        return
+    ot = state.data.get("outline_thinking")
+    if not isinstance(ot, list) or not ot:
+        console.print("[dim]No ``outline_thinking`` in this file.[/dim]")
+        return
+    console.print(
+        Panel(
+            json.dumps(ot, ensure_ascii=False, indent=2),
+            title="[bold]outline_thinking[/bold]",
+            border_style="magenta",
+            expand=False,
+        )
+    )
+
+
+_BROWSER_ACTIONS: dict[str, Callable[[Console, OutlineBrowserState, Path], None]] = {
+    "1": _open_outline,
+    "2": _show_tree,
+    "3": _show_summary,
+    "4": _show_raw_json,
+    "5": _show_outline_thinking,
+}
+
+
+def run_outline_browser_session(
+    console: Console,
+    *,
+    preload_path: Path | None = None,
+    preload_data: dict[str, Any] | None = None,
+) -> int:
+    """Agent-style loop: load once, browse outline with a sub-menu."""
+    state = OutlineBrowserState()
+    storage = ensure_cli_storage()
+
+    if preload_data is not None:
+        state.data = preload_data
+        state.path = preload_path
+        state.label = str(preload_data.get("doc_name") or (preload_path.stem if preload_path else "outline"))
+
+    console.print(
+        "\n[bold cyan]View outlines[/bold cyan]\n"
+        "[dim]Read-only — inspect section trees from saved runs (no element search here).[/dim]\n"
+        "[dim]For page/section text chunks use [bold]View → View elements[/bold].[/dim]\n"
+    )
+
+    while True:
+        console.print()
+        console.print(state.status_line())
+        choice = prompt_menu(
+            console,
+            title="View outlines",
+            options=OUTLINE_BROWSER_MENU,
+            prompt="What next",
+            default_key="2" if state.is_ready else "1",
+            allow_back=True,
+            hint="Option 2+ need a loaded outline — use option 1 first.",
+        )
+        if choice in ("exit", "back"):
+            return 0
+        action = _BROWSER_ACTIONS.get(choice)
+        if action:
+            action(console, state, storage)

chunksmith_cli/views/tree_view.py

@@ -0,0 +1,59 @@
+"""Rich tree rendering for outline ``structure`` JSON."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from rich.console import Console
+from rich.markup import escape
+from rich.tree import Tree
+
+
+def _node_caption(node: dict[str, Any], *, summary_max: int = 72) -> str:
+    title = str(node.get("title") or "").strip() or "(untitled)"
+    parts: list[str] = []
+    si, ei = node.get("start_index"), node.get("end_index")
+    if si is not None and ei is not None:
+        parts.append(f"pp.{si}–{ei}")
+    elif si is not None:
+        parts.append(f"pp.{si}+")
+    nid = node.get("node_id")
+    if nid:
+        parts.append(str(nid))
+    meta = f" [dim]({', '.join(parts)})[/dim]" if parts else ""
+    summary = str(node.get("summary") or "").strip().replace("\n", " ")
+    if summary:
+        if len(summary) > summary_max:
+            summary = summary[: summary_max - 1] + "…"
+        summary = f" [dim]— {escape(summary)}[/dim]"
+    return f"[bold white]{escape(title)}[/bold white]{meta}{summary}"
+
+
+def _add_node(branch: Tree, node: dict[str, Any]) -> None:
+    cap = _node_caption(node)
+    sub = node.get("nodes")
+    if isinstance(sub, list) and sub:
+        twig = branch.add(cap)
+        for child in sub:
+            if isinstance(child, dict):
+                _add_node(twig, child)
+            else:
+                twig.add(escape(str(child)))
+    else:
+        branch.add(cap)
+
+
+def print_structure_tree(console: Console, structure: Any, *, title: str = "Processed outline") -> None:
+    """Print nested ``structure`` (list of root dicts) as a Rich ``Tree``."""
+    root = Tree(f"[bold cyan]{escape(title)}[/bold cyan]")
+    if isinstance(structure, list):
+        for item in structure:
+            if isinstance(item, dict):
+                _add_node(root, item)
+            else:
+                root.add(escape(str(item)))
+    elif isinstance(structure, dict):
+        _add_node(root, structure)
+    else:
+        root.add(escape(str(structure)))
+    console.print(root)

chunksmith_cli/views/view_session.py

@@ -0,0 +1,32 @@
+"""View mode: browse saved outlines (multi-indexing and legacy pageindex JSON)."""
+
+from __future__ import annotations
+
+from rich.console import Console
+
+from chunksmith_cli.menu import prompt_menu
+from chunksmith_cli.menus import VIEW_MENU
+from chunksmith_cli.outline_browser import run_outline_browser_session
+
+
+def run_view_session(console: Console) -> None:
+    """Sub-menu: view saved outline JSON under cli/data."""
+    console.print(
+        "\n[bold cyan]View[/bold cyan]\n"
+        "[dim]Inspect saved runs — ``*_multi_index.json``, ``*_pageindex.json``, or legacy outlines.[/dim]\n"
+    )
+
+    while True:
+        choice = prompt_menu(
+            console,
+            title="View",
+            options=VIEW_MENU,
+            prompt="What to view",
+            default_key="1",
+            allow_back=True,
+            hint="Read-only section tree and JSON from prior chunking runs.",
+        )
+        if choice in ("exit", "back"):
+            return
+        if choice == "1":
+            run_outline_browser_session(console)

chunksmith_cli/wizard.py

@@ -0,0 +1,357 @@
+"""Interactive ChunkSmith CLI — multi-indexing and PageIndexer."""
+
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+from typing import Any, Callable
+
+from dotenv import load_dotenv
+
+from chunksmith_cli.agent_session import run_agent_session
+from chunksmith_cli.branding import print_chunksmith_banner, print_session_hint
+from chunksmith_cli.config import show_verbose_pipeline_events
+from chunksmith_cli.menu import confirm_continue_session, prompt_menu
+from chunksmith_cli.menus import CHUNKING_MENU, ROOT_MENU
+from chunksmith_cli.panels import print_extraction_warnings_panel
+from chunksmith_cli.paths import archive_multi_indexing_cli_outputs, archive_pageindex_cli_outputs, cli_archive_stamp
+from chunksmith_cli.pipelines.multi_indexing_wizard import gather_multi_indexing_inputs
+from chunksmith_cli.pipelines.pageindex_wizard import gather_pageindex_inputs
+from chunksmith_cli.pipelines.run_multi import run_multi_indexing
+from chunksmith_cli.tree_view import print_structure_tree
+from chunksmith_cli.view_session import run_view_session
+
+try:
+    from rich.console import Console
+    from rich.markup import escape
+    from rich.panel import Panel
+    from rich.prompt import Confirm
+
+    from chunksmith_cli.theme import make_console
+except ImportError:
+    print(
+        "Missing dependency: install Rich for the CLI.\n  pip install rich\n  pip install chunksmith-cli",
+        file=sys.stderr,
+    )
+    raise SystemExit(1) from None
+
+
+def _show_optional_outline_extras(console: Console, out: dict[str, Any]) -> None:
+    ot = out.get("outline_thinking")
+    if (
+        isinstance(ot, list)
+        and ot
+        and Confirm.ask(
+            "\n[bold]Show outline thinking?[/bold] [dim](optional JSON)[/dim]",
+            default=False,
+        )
+    ):
+        console.print(
+            Panel(
+                json.dumps(ot, ensure_ascii=False, indent=2),
+                title="[bold]outline_thinking[/bold]",
+                border_style="magenta",
+                expand=False,
+            )
+        )
+
+    desc = out.get("doc_description")
+    if isinstance(desc, str) and desc.strip():
+        console.print(
+            Panel(
+                escape(desc.strip()),
+                title="[bold]Document description[/bold]",
+                border_style="blue",
+            )
+        )
+
+    if encoding_fmt := out.get("flat_rows_toon"):
+        if Confirm.ask("\n[bold]Show flat_rows TOON snippet?[/bold]", default=False):
+            text = str(encoding_fmt)
+            console.print(
+                Panel(
+                    text[:12000] + ("…" if len(text) > 12000 else ""),
+                    title="[bold]flat_rows_toon[/bold]",
+                    border_style="cyan",
+                    expand=False,
+                )
+            )
+
+
+def _pipeline_result_to_dict(result: Any, *, encoding: str, pdf_path: Path) -> dict[str, Any]:
+    outline = result.title_outline if isinstance(result.title_outline, dict) else {}
+    out: dict[str, Any] = {
+        "doc_name": outline.get("doc_name") or pdf_path.name,
+        "llm_context_format": encoding,
+        "structure": outline.get("structure"),
+        "flat_rows": outline.get("flat_rows"),
+        "doc_description": outline.get("doc_description"),
+        "outline_thinking": outline.get("outline_thinking"),
+        "indexer_options": outline.get("indexer_options"),
+        "mapping_method": result.config.mapping_method,
+        "use_group_by_title": result.config.use_group_by_title,
+        "title_coded_formate_chars": len(result.title_coded_formate or ""),
+        "n_elements": len(result.elements or []),
+        "n_chunks": len(result.chunks_local or []) if result.chunks_local else 0,
+    }
+    if encoding == "toon":
+        out["flat_rows_toon"] = outline.get("flat_rows_toon")
+        out["structure_toon"] = outline.get("structure_toon")
+    return out
+
+
+def _run_multi_indexing_pipeline(console: Console) -> int:
+    code, inputs = gather_multi_indexing_inputs(console)
+    if code != 0 or inputs is None:
+        return code
+
+    encoding = inputs.encoding
+    console.print(
+        f"\n[bold cyan]Running multi-indexing ({encoding.upper()} context)…[/bold cyan]\n"
+        "[dim]partition → group → coded format → page index → mapper[/dim]\n"
+    )
+
+    def _progress(event: str, payload: dict[str, Any]) -> None:
+        if not inputs.stream_events:
+            return
+        if event == "pipeline:done":
+            console.print("[bold green]Pipeline finished[/bold green]")
+        elif event.startswith("partition:") or event.startswith("pipeline:"):
+            console.print(f"[cyan]{escape(event)}[/cyan] [dim]{escape(str(payload))}[/dim]", highlight=False)
+        elif show_verbose_pipeline_events():
+            console.print(f"[dim]{escape(event)}[/dim] {escape(str(payload))}", highlight=False)
+
+    try:
+        result = run_multi_indexing(
+            inputs.pdf_path,
+            inputs.mi_prefs,
+            progress=_progress,
+        )
+    except ImportError as e:
+        if encoding == "toon" and "toon" in str(e).lower():
+            console.print(
+                f"[bold red]Missing TOON dependency:[/bold red] {e}\n"
+                '[cyan]pip install "chunksmith-multimodal[toon]"[/cyan]'
+            )
+        else:
+            console.print(f"[bold red]Import error:[/bold red] {e}")
+        return 1
+    except ConnectionError as e:
+        console.print(f"[bold red]Network error:[/bold red] {e}")
+        return 1
+    except OSError as e:
+        if getattr(e, "winerror", None) == 11001 or getattr(e, "errno", None) in (11001, -2, -3):
+            console.print(
+                "[bold red]Cannot reach Unstructured API.[/bold red] "
+                "Check `.env` (``UNSTRUCTURED_API_KEY``, ``UNSTRUCTURED_API_URL``).\n"
+                f"[dim]{e}[/dim]"
+            )
+            return 1
+        console.print(f"[bold red]Failed:[/bold red] {e}")
+        return 1
+    except Exception as e:
+        console.print(f"[bold red]Failed:[/bold red] {e}")
+        return 1
+
+    out = _pipeline_result_to_dict(result, encoding=encoding, pdf_path=inputs.pdf_path)
+    doc_title = str(out.get("doc_name") or inputs.pdf_path.stem)
+    print_structure_tree(console, out.get("structure"), title=f"Outline tree — {doc_title}")
+    print_extraction_warnings_panel(console, out.get("extraction_warnings"))
+    _show_optional_outline_extras(console, out)
+
+    if inputs.show_toon_after and encoding == "toon":
+        flat_toon = out.get("flat_rows_toon") or out.get("structure_toon")
+        if flat_toon:
+            console.print("\n[bold cyan]TOON outline snippet[/bold cyan]\n")
+            text = str(flat_toon)
+            console.print(text[:8000] + ("…" if len(text) > 8000 else ""), highlight=False)
+
+    stamp = cli_archive_stamp()
+    archived = archive_multi_indexing_cli_outputs(
+        inputs.storage_root,
+        inputs.pdf_path.stem,
+        out,
+        elements=result.elements,
+        title_coded_formate=result.title_coded_formate,
+        title_outline=result.title_outline if isinstance(result.title_outline, dict) else None,
+        mapper_output=result.mapper_output,
+        stamp=stamp,
+        artifact_root=inputs.artifact_root,
+    )
+
+    if inputs.artifact_root is not None:
+        console.print(
+            f"\n[bold green]Saved under[/bold green] [cyan]{archived.get('artifact_root', inputs.artifact_root)}[/cyan]"
+        )
+        if "title_coded_formate" in archived:
+            console.print(f"[dim]Coded markup (LLM input string):[/dim] [cyan]{archived['title_coded_formate']}[/cyan]")
+    else:
+        console.print("\n[bold green]Saved to legacy flat storage[/bold green]")
+
+    for label, key in (
+        ("Multi-index", "multi_index"),
+        ("Page index", "pageindex"),
+        ("Unstructured JSON", "unstructured_elements"),
+        ("Pickle (raw elements)", "pickle"),
+        ("Images folder", "image_dir"),
+        ("Coded markup", "title_coded_formate"),
+        ("TOON flat rows", "flat_rows_toon"),
+        ("TOON structure", "structure_toon"),
+        ("Mapper", "mapper"),
+    ):
+        if key in archived:
+            console.print(f"  [cyan]{label}[/cyan]  {archived[key].resolve()}")
+
+    if Confirm.ask("\n[bold]Print full JSON here?[/bold]", default=False):
+        console.print(
+            Panel(
+                json.dumps(out, ensure_ascii=False, indent=2),
+                title="[bold]JSON[/bold]",
+                border_style="green",
+                expand=False,
+            )
+        )
+
+    console.print("\n[bold green]Done.[/bold green]")
+    return 0
+
+
+def _run_pageindex_pipeline(console: Console) -> int:
+    code, inputs = gather_pageindex_inputs(console)
+    if code != 0 or inputs is None:
+        return code
+
+    from chunksmith_pageindex import build_outline_from_pdf
+
+    console.print("\n[bold cyan]Running PageIndexer…[/bold cyan]\n[dim]PDF → tagged pages → LLM outline[/dim]\n")
+
+    if inputs.stream_progress:
+        console.print("[cyan]pipeline:load_pdf[/cyan] [dim]loading pages…[/dim]")
+
+    try:
+        result = build_outline_from_pdf(
+            str(inputs.pdf_path),
+            settings=inputs.settings,
+            add_text=inputs.add_text,
+            assign_node_ids=inputs.assign_node_ids,
+            add_summary=inputs.add_summary,
+            add_word_range=inputs.add_word_range,
+            generate_doc_summary=inputs.generate_doc_summary,
+        )
+    except Exception as e:
+        console.print(f"[bold red]PageIndexer failed:[/bold red] {e}")
+        return 1
+
+    if inputs.stream_progress:
+        console.print("[cyan]pipeline:done[/cyan] [dim]outline built[/dim]")
+
+    structure = result.get("structure")
+    if isinstance(structure, list) and structure:
+        console.print("\n[bold cyan]Outline tree[/bold cyan]\n")
+        print_structure_tree(console, structure, title=f"Outline — {inputs.pdf_path.stem}")
+
+    stamp = cli_archive_stamp()
+    archived = archive_pageindex_cli_outputs(
+        inputs.storage_root,
+        inputs.pdf_path.stem,
+        result,
+        stamp=stamp,
+        artifact_root=inputs.artifact_root,
+    )
+
+    if inputs.artifact_root is not None:
+        console.print(
+            f"\n[bold green]Saved under[/bold green] [cyan]{archived.get('artifact_root', inputs.artifact_root)}[/cyan]"
+        )
+    else:
+        console.print("\n[bold green]Saved to legacy flat storage[/bold green]")
+
+    if "pageindex" in archived:
+        console.print(f"  [cyan]Page index[/cyan]  {archived['pageindex'].resolve()}")
+    if "tagged_pages" in archived:
+        console.print(f"  [cyan]Tagged pages[/cyan]  {archived['tagged_pages'].resolve()}")
+
+    if Confirm.ask("\n[bold]Print full JSON here?[/bold]", default=False):
+        console.print(
+            Panel(
+                json.dumps(result, ensure_ascii=False, indent=2),
+                title="[bold]pageindex JSON[/bold]",
+                border_style="green",
+                expand=False,
+            )
+        )
+
+    console.print("\n[bold green]Done.[/bold green]")
+    return 0
+
+
+_CHUNKING_ACTIONS: dict[str, Callable[[Console], int]] = {
+    "1": _run_multi_indexing_pipeline,
+    "multi": _run_multi_indexing_pipeline,
+    "indexing": _run_multi_indexing_pipeline,
+    "2": _run_pageindex_pipeline,
+    "pageindex": _run_pageindex_pipeline,
+    "pi": _run_pageindex_pipeline,
+}
+
+
+def run_interactive(console: Console | None = None) -> int:
+    console = console or make_console()
+    load_dotenv()
+    print_chunksmith_banner(console)
+    print_session_hint(console)
+
+    while True:
+        root = prompt_menu(
+            console,
+            title="Start here",
+            options=ROOT_MENU,
+            prompt="Mode",
+            default_key="chunking",
+            hint="Chunking = build indexes · View = inspect saved JSON · Agent = Q&A (saved indexes).",
+        )
+        if root == "exit":
+            console.print("[dim]Goodbye.[/dim]")
+            return 0
+
+        if root == "agent":
+            try:
+                run_agent_session(console)
+            except ImportError as e:
+                console.print(
+                    "[bold yellow]Agent mode unavailable.[/bold yellow]\n"
+                    f"[dim]{e}[/dim]\n"
+                    'Install separately: [cyan]pip install "chunksmith-agent[langchain]"[/cyan]'
+                )
+            if not confirm_continue_session(console):
+                return 0
+            continue
+
+        if root == "view":
+            run_view_session(console)
+            if not confirm_continue_session(console):
+                return 0
+            continue
+
+        choice = prompt_menu(
+            console,
+            title="Chunking — pick pipeline",
+            options=CHUNKING_MENU,
+            prompt="What to run",
+            default_key="1",
+            allow_back=True,
+            hint="1 = Multi-indexing (JSON/TOON) · 2 = PageIndexer (no Unstructured API).",
+        )
+        if choice == "exit":
+            console.print("[dim]Goodbye.[/dim]")
+            return 0
+        if choice == "back":
+            continue
+
+        action = _CHUNKING_ACTIONS.get(choice)
+        if action:
+            action(console)
+
+        if not confirm_continue_session(console):
+            return 0