navcli 0.1.0__tar.gz → 0.2.0__tar.gz

navcli-0.2.0/PKG-INFO

@@ -0,0 +1,79 @@
+Metadata-Version: 2.4
+Name: navcli
+Version: 0.2.0
+Summary: 可交互、可探索的浏览器命令行工具，专为 AI Agent 设计
+Author: NavCLI Team
+License: MIT
+Project-URL: Homepage, https://github.com/navcli/navcli
+Project-URL: Repository, https://github.com/navcli/navcli
+Project-URL: Issues, https://github.com/navcli/navcli/issues
+Keywords: browser,cli,automation,ai-agent,playwright
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: playwright>=1.40.0
+Requires-Dist: cmd2>=2.4.0
+Requires-Dist: fastapi>=0.109.0
+Requires-Dist: uvicorn<1.0.0,>=0.25.0
+Requires-Dist: pydantic>=2.5.0
+Requires-Dist: cssify>=1.0.0
+Requires-Dist: aiohttp>=3.9.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.4.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.1.0; extra == "dev"
+Requires-Dist: ruff>=0.1.0; extra == "dev"
+Requires-Dist: mypy>=1.8.0; extra == "dev"
+
+# NavCLI - Goals & Vision
+
+## Core Goal
+
+**Enable AI Agents to browse the web like humans.**
+
+Existing solutions (HTTP APIs, headless browser scripts, Playwright MCP) have limitations:
+- No support for JS-rendered SPAs
+- No session persistence
+- Lack of interactive exploration
+
+NavCLI's positioning: **An interactive, explorable browser CLI**
+
+## Core Value
+
+| Feature | What NavCLI Solves |
+|---------|-------------------|
+| JS Rendering | Full SPA support |
+| Session Persistence | Cookies, session maintained |
+| Interactive CLI | Agent can explore while operating |
+| Token Optimization | Lightweight elements + on-demand text/html |
+
+## Typical Workflow
+
+```bash
+> g https://example.com          # Navigate
+> elements                       # Observe interactive elements
+> c .btn-login                   # Click login
+> t #email "test@example.com"    # Type email
+> t #password "123456"           # Type password
+> c button[type="submit"]       # Submit
+> text                           # Confirm result
+```
+
+Agent can: **Navigate → Observe → Interact → Feedback → Continue**
+
+## Vision
+
+Become the **standard browser interaction layer** for AI Agents, enabling any Agent to control browsers via command-line interface:
+- Form filling, login authentication
+- Information scraping, content exploration
+- Complex multi-step business processes
+
+## Related Documentation
+
+- [PRD Product Requirements](./NAVCLI_PRD.md)

navcli-0.2.0/docs/README.md

@@ -0,0 +1,46 @@
+# NavCLI - Goals & Vision
+
+## Core Goal
+
+**Enable AI Agents to browse the web like humans.**
+
+Existing solutions (HTTP APIs, headless browser scripts, Playwright MCP) have limitations:
+- No support for JS-rendered SPAs
+- No session persistence
+- Lack of interactive exploration
+
+NavCLI's positioning: **An interactive, explorable browser CLI**
+
+## Core Value
+
+| Feature | What NavCLI Solves |
+|---------|-------------------|
+| JS Rendering | Full SPA support |
+| Session Persistence | Cookies, session maintained |
+| Interactive CLI | Agent can explore while operating |
+| Token Optimization | Lightweight elements + on-demand text/html |
+
+## Typical Workflow
+
+```bash
+> g https://example.com          # Navigate
+> elements                       # Observe interactive elements
+> c .btn-login                   # Click login
+> t #email "test@example.com"    # Type email
+> t #password "123456"           # Type password
+> c button[type="submit"]       # Submit
+> text                           # Confirm result
+```
+
+Agent can: **Navigate → Observe → Interact → Feedback → Continue**
+
+## Vision
+
+Become the **standard browser interaction layer** for AI Agents, enabling any Agent to control browsers via command-line interface:
+- Form filling, login authentication
+- Information scraping, content exploration
+- Complex multi-step business processes
+
+## Related Documentation
+
+- [PRD Product Requirements](./NAVCLI_PRD.md)

{navcli-0.1.0 → navcli-0.2.0}/navcli/cli/app.py

@@ -54,6 +54,10 @@ class NavCLI(
             self.poutput("  state         Get full page state")
             self.poutput("  url           Get current URL")
             self.poutput("  title         Get page title")
+            self.poutput("  tables        Get all tables with data")
+            self.poutput("  paragraphs    Get large text paragraphs (200+ chars)")
+            self.poutput("  links         Get all links")
+            self.poutput("  forms         Get all forms")
 
             self.poutput("\nExplore Commands:")
             self.poutput("  find <text>        Find element by text")

{navcli-0.1.0 → navcli-0.2.0}/navcli/cli/client.py

@@ -123,6 +123,18 @@ class NavClient:
         """Get all forms on the page."""
         return await self._request("GET", "/query/forms")
 
+    async def get_tables(self):
+        """Get all tables on the page with their data."""
+        return await self._request("GET", "/query/tables")
+
+    async def get_paragraphs(self, min_length: int = 200):
+        """Get large text paragraphs (200+ chars) from the page.
+
+        Args:
+            min_length: Minimum paragraph length (default: 200)
+        """
+        return await self._request("GET", f"/query/paragraphs?min_length={min_length}")
+
     # Explore commands
     async def find(self, text: str):
         """Find element by text."""
@@ -234,25 +246,39 @@ class NavClient:
 
         return await self._request("POST", "/cmd/cookies/set", json=body)
 
-    async def save_session(self, path: str = ".navcli_session.json"):
+    async def save_session(self, name: str = None, path: str = None):
         """Save session to file.
 
         Args:
-            path: File path to save session
+            name: Session name (saves to ~/.navcli/sessions/<name>.json)
+            path: Full file path (alternative to name)
         """
         import urllib.parse
-        encoded_path = urllib.parse.quote(path)
-        return await self._request("POST", f"/cmd/session/save?path={encoded_path}")
 
-    async def load_session(self, path: str = ".navcli_session.json"):
+        if name:
+            return await self._request("POST", f"/cmd/session/save?name={name}")
+        elif path:
+            encoded_path = urllib.parse.quote(path)
+            return await self._request("POST", f"/cmd/session/save?path={encoded_path}")
+        else:
+            return await self._request("POST", "/cmd/session/save")
+
+    async def load_session(self, name: str = None, path: str = None):
         """Load session from file.
 
         Args:
-            path: File path to load session from
+            name: Session name (loads from ~/.navcli/sessions/<name>.json)
+            path: Full file path (alternative to name)
         """
         import urllib.parse
-        encoded_path = urllib.parse.quote(path)
-        return await self._request("POST", f"/cmd/session/load?path={encoded_path}")
+
+        if name:
+            return await self._request("POST", f"/cmd/session/load?name={name}")
+        elif path:
+            encoded_path = urllib.parse.quote(path)
+            return await self._request("POST", f"/cmd/session/load?path={encoded_path}")
+        else:
+            return await self._request("POST", "/cmd/session/load")
 
 
 async def main():

{navcli-0.1.0 → navcli-0.2.0}/navcli/cli/commands/control.py

@@ -21,7 +21,7 @@ class ControlCommands(BaseBrowserCommand):
         async def _quit():
             return await self.client.quit()
 
-        result = asyncio.run(self.run_async_client(_quit))
+        result = asyncio.run(self.run_async_client(_quit()))
         self.pretty_result(result)
 
     @cmd2.with_argparser(cmd2.Cmd2ArgumentParser())
@@ -35,7 +35,7 @@ class ControlCommands(BaseBrowserCommand):
         async def _shutdown():
             return await self.client.shutdown()
 
-        result = asyncio.run(self.run_async_client(_shutdown))
+        result = asyncio.run(self.run_async_client(_shutdown()))
         self.pretty_result(result)
 
     @cmd2.with_argparser(cmd2.Cmd2ArgumentParser())
@@ -50,41 +50,41 @@ class ControlCommands(BaseBrowserCommand):
     # Session commands
 
     save_parser = cmd2.Cmd2ArgumentParser()
-    save_parser.add_argument("path", nargs="?", default=".navcli_session.json",
-                              help="Path to save session file")
+    save_parser.add_argument("name", nargs="?", default=None,
+                             help="Session name (saves to ~/.navcli/sessions/<name>.json)")
 
     @cmd2.with_argparser(save_parser)
     def do_save_session(self, args):
         """Save session (cookies, storage) to file.
 
-        Usage: save_session [path]
-        Example: save_session my_session.json
+        Usage: save_session [name]
+        Example: save_session jisilu
         """
         import asyncio
 
         async def _save():
-            return await self.client.save_session(args.path)
+            return await self.client.save_session(name=args.name)
 
-        result = asyncio.run(self.run_async_client(_save))
+        result = asyncio.run(self.run_async_client(_save()))
         self.pretty_result(result)
 
     load_parser = cmd2.Cmd2ArgumentParser()
-    load_parser.add_argument("path", nargs="?", default=".navcli_session.json",
-                              help="Path to load session file from")
+    load_parser.add_argument("name", nargs="?", default=None,
+                             help="Session name (loads from ~/.navcli/sessions/<name>.json)")
 
     @cmd2.with_argparser(load_parser)
     def do_load_session(self, args):
         """Load session (cookies, storage) from file.
 
-        Usage: load_session [path]
-        Example: load_session my_session.json
+        Usage: load_session [name]
+        Example: load_session jisilu
         """
         import asyncio
 
         async def _load():
-            return await self.client.load_session(args.path)
+            return await self.client.load_session(name=args.name)
 
-        result = asyncio.run(self.run_async_client(_load))
+        result = asyncio.run(self.run_async_client(_load()))
         self.pretty_result(result)
 
     @cmd2.with_argparser(cmd2.Cmd2ArgumentParser())
@@ -98,7 +98,7 @@ class ControlCommands(BaseBrowserCommand):
         async def _get():
             return await self.client.get_cookies()
 
-        result = asyncio.run(self.run_async_client(_get))
+        result = asyncio.run(self.run_async_client(_get()))
         if result.get("success"):
             self.poutput("[OK] got cookies")
         else:
@@ -115,5 +115,5 @@ class ControlCommands(BaseBrowserCommand):
         async def _clear():
             return await self.client.clear_cookies()
 
-        result = asyncio.run(self.run_async_client(_clear))
+        result = asyncio.run(self.run_async_client(_clear()))
         self.pretty_result(result)

{navcli-0.1.0 → navcli-0.2.0}/navcli/cli/commands/explore.py

@@ -22,7 +22,7 @@ class ExploreCommands(BaseBrowserCommand):
         async def _find():
             return await self.client.find(args.text)
 
-        result = asyncio.run(self.run_async_client(_find))
+        result = asyncio.run(self.run_async_client(_find()))
         self.pretty_result(result)
 
     @cmd2.with_argparser(cmd2.Cmd2ArgumentParser())
@@ -37,7 +37,7 @@ class ExploreCommands(BaseBrowserCommand):
         async def _findall():
             return await self.client.findall(args.text)
 
-        result = asyncio.run(self.run_async_client(_findall))
+        result = asyncio.run(self.run_async_client(_findall()))
         self.pretty_result(result)
 
     @cmd2.with_argparser(cmd2.Cmd2ArgumentParser())
@@ -52,7 +52,7 @@ class ExploreCommands(BaseBrowserCommand):
         async def _inspect():
             return await self.client.inspect(args.selector)
 
-        result = asyncio.run(self.run_async_client(_inspect))
+        result = asyncio.run(self.run_async_client(_inspect()))
         self.pretty_result(result)
 
     @cmd2.with_argparser(cmd2.Cmd2ArgumentParser())
@@ -73,7 +73,7 @@ class ExploreCommands(BaseBrowserCommand):
             else:
                 return await self.client.wait()
 
-        result = asyncio.run(self.run_async_client(_wait))
+        result = asyncio.run(self.run_async_client(_wait()))
         self.pretty_result(result)
 
     @cmd2.with_argparser(cmd2.Cmd2ArgumentParser())
@@ -89,7 +89,7 @@ class ExploreCommands(BaseBrowserCommand):
             timeout = args.timeout if args.timeout else 3.0
             return await self.client.wait_idle(timeout=timeout)
 
-        result = asyncio.run(self.run_async_client(_wait_idle))
+        result = asyncio.run(self.run_async_client(_wait_idle()))
         self.pretty_result(result)
 
     @cmd2.with_argparser(cmd2.Cmd2ArgumentParser())
@@ -121,5 +121,5 @@ class ExploreCommands(BaseBrowserCommand):
             else:
                 return await self.client.scroll(direction="down")
 
-        result = asyncio.run(self.run_async_client(_scroll))
+        result = asyncio.run(self.run_async_client(_scroll()))
         self.pretty_result(result)

{navcli-0.1.0 → navcli-0.2.0}/navcli/cli/commands/interaction.py

@@ -33,7 +33,7 @@ class InteractionCommands(BaseBrowserCommand):
         async def _click():
             return await self.client.click(args.selector, force=args.force)
 
-        result = asyncio.run(self.run_async_client(_click))
+        result = asyncio.run(self.run_async_client(_click()))
         self.pretty_result(result)
 
     @cmd2.with_argparser(cmd2.Cmd2ArgumentParser())
@@ -48,7 +48,7 @@ class InteractionCommands(BaseBrowserCommand):
         async def _type():
             return await self.client.type(args.selector, args.text)
 
-        result = asyncio.run(self.run_async_client(_type))
+        result = asyncio.run(self.run_async_client(_type()))
         self.pretty_result(result)
 
     @cmd2.with_argparser(cmd2.Cmd2ArgumentParser())
@@ -63,7 +63,7 @@ class InteractionCommands(BaseBrowserCommand):
         async def _dblclick():
             return await self.client.dblclick(args.selector)
 
-        result = asyncio.run(self.run_async_client(_dblclick))
+        result = asyncio.run(self.run_async_client(_dblclick()))
         self.pretty_result(result)
 
     @cmd2.with_argparser(cmd2.Cmd2ArgumentParser())
@@ -78,7 +78,7 @@ class InteractionCommands(BaseBrowserCommand):
         async def _rightclick():
             return await self.client.rightclick(args.selector)
 
-        result = asyncio.run(self.run_async_client(_rightclick))
+        result = asyncio.run(self.run_async_client(_rightclick()))
         self.pretty_result(result)
 
     # Aliases
@@ -110,7 +110,7 @@ class InteractionCommands(BaseBrowserCommand):
         async def _clear():
             return await self.client.clear(args.selector)
 
-        result = asyncio.run(self.run_async_client(_clear))
+        result = asyncio.run(self.run_async_client(_clear()))
         self.pretty_result(result)
 
     @cmd2.with_argparser(cmd2.Cmd2ArgumentParser())
@@ -125,5 +125,5 @@ class InteractionCommands(BaseBrowserCommand):
         async def _upload():
             return await self.client.upload(args.selector, args.file_path)
 
-        result = asyncio.run(self.run_async_client(_upload))
+        result = asyncio.run(self.run_async_client(_upload()))
         self.pretty_result(result)

{navcli-0.1.0 → navcli-0.2.0}/navcli/cli/commands/navigation.py

@@ -17,7 +17,7 @@ class NavigationCommands(BaseBrowserCommand):
 
     @cmd2.with_argparser(_goto_parser)
     def do_goto(self, args):
-        """Navigate to a URL.
+        """Navigate to a URL and show page summary.
 
         Usage: goto <url>
         Example: goto https://example.com
@@ -28,9 +28,17 @@ class NavigationCommands(BaseBrowserCommand):
             url = "https://" + url
 
         async def _goto():
-            return await self.client.goto(url)
-
-        result = asyncio.run(self.run_async_client(_goto))
+            # Navigate first
+            result = await self.client.goto(url)
+            # Then get paragraphs and merge into state
+            para_result = await self.client.get_paragraphs(min_length=200)
+            if para_result.get("success") and result.get("success"):
+                # Extract paragraphs from state and merge
+                para_data = para_result.get("state", {}).get("paragraphs", [])
+                result["state"]["paragraphs"] = para_data
+            return result
+
+        result = asyncio.run(self.run_async_client(_goto()))
         self.pretty_result(result)
 
     @cmd2.with_argparser(cmd2.Cmd2ArgumentParser())
@@ -44,7 +52,7 @@ class NavigationCommands(BaseBrowserCommand):
         async def _back():
             return await self.client.back()
 
-        result = asyncio.run(self.run_async_client(_back))
+        result = asyncio.run(self.run_async_client(_back()))
         self.pretty_result(result)
 
     @cmd2.with_argparser(cmd2.Cmd2ArgumentParser())
@@ -58,7 +66,7 @@ class NavigationCommands(BaseBrowserCommand):
         async def _forward():
             return await self.client.forward()
 
-        result = asyncio.run(self.run_async_client(_forward))
+        result = asyncio.run(self.run_async_client(_forward()))
         self.pretty_result(result)
 
     @cmd2.with_argparser(cmd2.Cmd2ArgumentParser())
@@ -72,7 +80,7 @@ class NavigationCommands(BaseBrowserCommand):
         async def _reload():
             return await self.client.reload()
 
-        result = asyncio.run(self.run_async_client(_reload))
+        result = asyncio.run(self.run_async_client(_reload()))
         self.pretty_result(result)
 
     # Aliases
@@ -80,11 +88,25 @@ class NavigationCommands(BaseBrowserCommand):
     do_f = do_forward  # forward -> f
     do_r = do_reload  # reload -> r
 
-    # goto -> g (requires separate parser)
+    # goto -> g (shortcut with same logic as do_goto)
     @cmd2.with_argparser(_goto_parser)
     def do_g(self, args):
         """Navigate to a URL (shortcut).
 
         Usage: g <url>
         """
-        return self.do_goto(args)
+        import asyncio
+        url = args.url
+        if not url.startswith(("http://", "https://")):
+            url = "https://" + url
+
+        async def _goto():
+            result = await self.client.goto(url)
+            para_result = await self.client.get_paragraphs(min_length=200)
+            if para_result.get("success") and result.get("success"):
+                para_data = para_result.get("state", {}).get("paragraphs", [])
+                result["state"]["paragraphs"] = para_data
+            return result
+
+        result = asyncio.run(self.run_async_client(_goto()))
+        self.pretty_result(result)

{navcli-0.1.0 → navcli-0.2.0}/navcli/cli/commands/query.py

@@ -27,7 +27,7 @@ class QueryCommands(BaseBrowserCommand):
         async def _elements():
             return await self.client.get_elements()
 
-        result = asyncio.run(self.run_async_client(_elements))
+        result = asyncio.run(self.run_async_client(_elements()))
         self.pretty_result(result)
         if result.get("success"):
             state = result.get("state", {})
@@ -48,7 +48,7 @@ class QueryCommands(BaseBrowserCommand):
         async def _text():
             return await self.client.get_text()
 
-        result = asyncio.run(self.run_async_client(_text))
+        result = asyncio.run(self.run_async_client(_text()))
         self.pretty_result(result)
 
     @cmd2.with_argparser(cmd2.Cmd2ArgumentParser())
@@ -62,7 +62,7 @@ class QueryCommands(BaseBrowserCommand):
         async def _html():
             return await self.client.get_html()
 
-        result = asyncio.run(self.run_async_client(_html))
+        result = asyncio.run(self.run_async_client(_html()))
         self.pretty_result(result)
 
     @cmd2.with_argparser(cmd2.Cmd2ArgumentParser())
@@ -79,7 +79,7 @@ class QueryCommands(BaseBrowserCommand):
         async def _screenshot():
             return await self.client.get_screenshot()
 
-        result = asyncio.run(self.run_async_client(_screenshot))
+        result = asyncio.run(self.run_async_client(_screenshot()))
         self.pretty_result(result)
 
     @cmd2.with_argparser(cmd2.Cmd2ArgumentParser())
@@ -93,7 +93,7 @@ class QueryCommands(BaseBrowserCommand):
         async def _state():
             return await self.client.get_state()
 
-        result = asyncio.run(self.run_async_client(_state))
+        result = asyncio.run(self.run_async_client(_state()))
         self.pretty_result(result)
 
     @cmd2.with_argparser(cmd2.Cmd2ArgumentParser())
@@ -107,7 +107,7 @@ class QueryCommands(BaseBrowserCommand):
         async def _url():
             return await self.client.get_url()
 
-        result = asyncio.run(self.run_async_client(_url))
+        result = asyncio.run(self.run_async_client(_url()))
         self.pretty_result(result)
 
     @cmd2.with_argparser(cmd2.Cmd2ArgumentParser())
@@ -121,7 +121,7 @@ class QueryCommands(BaseBrowserCommand):
         async def _title():
             return await self.client.get_title()
 
-        result = asyncio.run(self.run_async_client(_title))
+        result = asyncio.run(self.run_async_client(_title()))
         self.pretty_result(result)
 
     @cmd2.with_argparser(_evaluate_parser)
@@ -137,7 +137,7 @@ class QueryCommands(BaseBrowserCommand):
         async def _evaluate():
             return await self.client.evaluate(args.expression)
 
-        result = asyncio.run(self.run_async_client(_evaluate))
+        result = asyncio.run(self.run_async_client(_evaluate()))
         self.pretty_result(result)
 
     @cmd2.with_argparser(cmd2.Cmd2ArgumentParser())
@@ -151,7 +151,7 @@ class QueryCommands(BaseBrowserCommand):
         async def _links():
             return await self.client.get_links()
 
-        result = asyncio.run(self.run_async_client(_links))
+        result = asyncio.run(self.run_async_client(_links()))
         self.pretty_result(result)
         if result.get("success"):
             state = result.get("state", {})
@@ -167,5 +167,49 @@ class QueryCommands(BaseBrowserCommand):
         async def _forms():
             return await self.client.get_forms()
 
-        result = asyncio.run(self.run_async_client(_forms))
+        result = asyncio.run(self.run_async_client(_forms()))
         self.pretty_result(result)
+
+    @cmd2.with_argparser(cmd2.Cmd2ArgumentParser())
+    def do_tables(self, _):
+        """Get all tables on the page with their data.
+
+        Usage: tables
+        """
+        import asyncio
+
+        async def _tables():
+            return await self.client.get_tables()
+
+        result = asyncio.run(self.run_async_client(_tables()))
+        self.pretty_result(result)
+        if result.get("success"):
+            state = result.get("state", {})
+            tables = state.get("tables", [])
+            for t in tables:
+                self.poutput(f"  Table: {t.get('id', 'N/A')} - {t.get('rowCount', 0)} rows")
+
+    _paragraphs_parser = cmd2.Cmd2ArgumentParser()
+    _paragraphs_parser.add_argument("min_length", nargs="?", type=int, default=200,
+                                   help="Minimum paragraph length (default: 200)")
+
+    @cmd2.with_argparser(_paragraphs_parser)
+    def do_paragraphs(self, args):
+        """Get large text paragraphs (200+ chars) from the page.
+
+        Useful for extracting article content, policy documents, etc.
+
+        Usage: paragraphs [min_length]
+        Example: paragraphs
+        Example: paragraphs 500
+        """
+        import asyncio
+
+        async def _paragraphs():
+            return await self.client.get_paragraphs(min_length=args.min_length)
+
+        result = asyncio.run(self.run_async_client(_paragraphs()))
+        self.pretty_result(result)
+        if result.get("success"):
+            state = result.get("state", {})
+            # Paragraphs are included in the feedback.result info

{navcli-0.1.0 → navcli-0.2.0}/navcli/core/models/__init__.py

@@ -2,7 +2,7 @@
 
 from .element import Element
 from .dom import DOMTree, DOMChange
-from .state import StateSnapshot
+from .state import StateSnapshot, Paragraph
 from .feedback import CommandResult, Feedback
 
 __all__ = [
@@ -10,6 +10,7 @@ __all__ = [
     'DOMTree',
     'DOMChange',
     'StateSnapshot',
+    'Paragraph',
     'CommandResult',
     'Feedback',
 ]

{navcli-0.1.0 → navcli-0.2.0}/navcli/core/models/state.py

@@ -1,11 +1,20 @@
 """StateSnapshot model for page state."""
 
-from typing import Optional
+from typing import Optional, List, Dict, Any
 from pydantic import BaseModel, Field
 
 from .dom import DOMTree
 
 
+class Paragraph(BaseModel):
+    """Represents a large text paragraph."""
+
+    index: int = 0
+    text: str = ""
+    length: int = 0
+    selector: str = ""
+
+
 class StateSnapshot(BaseModel):
     """Represents the current page state."""
 
@@ -15,5 +24,7 @@ class StateSnapshot(BaseModel):
     variables: dict = Field(default_factory=dict)  # page variables
     loading: bool = False          # is still loading
     network_idle: bool = True      # network is idle
-    dom_stable: bool = True       # DOM is stable
-    pending_requests: int = 0     # pending request count
+    dom_stable: bool = True        # DOM is stable
+    pending_requests: int = 0      # pending request count
+    tables: List[Dict[str, Any]] = Field(default_factory=list)  # extracted tables
+    paragraphs: List[Paragraph] = Field(default_factory=list)  # extracted paragraphs