ntermqt 0.1.7__py3-none-any.whl → 0.1.9__py3-none-any.whl

nterm/parser/api_help_dialog.py

@@ -32,7 +32,7 @@ class APIHelpDialog(QDialog):
         header.setFont(header_font)
         layout.addWidget(header)
 
-        subtitle = QLabel("Access your network devices programmatically from IPython")
+        subtitle = QLabel("Programmatic network automation from IPython, Python scripts, or as the foundation for MCP tools")
         layout.addWidget(subtitle)
 
         layout.addSpacing(10)
@@ -42,6 +42,7 @@ class APIHelpDialog(QDialog):
         tabs.addTab(self._create_overview_tab(), "Overview")
         tabs.addTab(self._create_quickstart_tab(), "Quick Start")
         tabs.addTab(self._create_reference_tab(), "API Reference")
+        tabs.addTab(self._create_platform_tab(), "Platform Commands")
         tabs.addTab(self._create_examples_tab(), "Examples")
         tabs.addTab(self._create_troubleshooting_tab(), "Troubleshooting")
         layout.addWidget(tabs)
@@ -71,32 +72,33 @@ class APIHelpDialog(QDialog):
         text.setMarkdown("""
 # nterm Scripting API
 
-The nterm API provides programmatic access to your network devices from IPython.
+Programmatic network automation from IPython, Python scripts, or as the foundation for MCP tools and agentic workflows.
 
-## Features
+Connect to devices, execute commands, and get structured data back - all using your existing nterm sessions and encrypted credentials.
 
-**Device Management**
-- Query saved devices and folders
-- Search by name, hostname, or tags
-- Access device metadata and connection history
+## Features
 
-**Secure Connections**
-- Encrypted credential vault with pattern matching
-- Auto-platform detection (Cisco, Arista, Juniper, etc.)
+**Connection Management**
+- Auto-credential resolution from encrypted vault
+- Platform auto-detection (Cisco IOS/NX-OS/IOS-XE/XR, Arista EOS, Juniper)
+- **Context manager** for automatic cleanup (`with api.session()`)
 - Legacy device support (RSA SHA-1 fallback)
 - Jump host support built-in
+- Connection pooling and tracking
 
-**Command Execution**
-- Execute commands on network devices
-- Automatic TextFSM parsing for structured data
+**Structured Data**
+- **961 TextFSM templates** from networktocode/ntc-templates
+- Automatic command parsing - raw text → List[Dict]
+- **Platform-aware commands** - one call, correct syntax
 - Field normalization across vendors
 - Fallback to raw output if parsing fails
 
 **Developer Tools**
-- Rich data types with tab completion
-- Debugging tools for parsing issues
-- Database diagnostics
-- Connection tracking
+- Rich dataclasses with tab completion
+- `debug_parse()` for troubleshooting parsing
+- `db_info()` for database diagnostics
+- `disconnect_all()` for cleanup
+- Comprehensive help system (F1 in GUI)
 
 ## Accessing the API
 
@@ -110,11 +112,12 @@ The API is pre-loaded in IPython sessions:
 
 **TextFSM Template Database**
 
-The API requires the TextFSM template database for parsing command output.
+Required for command parsing. Download via GUI:
 
-- Download via: **Dev → Download NTC Templates...**
-- Select platforms you need (cisco_ios, arista_eos, etc.)
-- Database stored as `tfsm_templates.db`
+- **Dev → Download NTC Templates...**
+- Click **Fetch Available Platforms**
+- Select platforms (cisco_ios, arista_eos, etc.)
+- Click **Download Selected**
 
 **Credential Vault**
 
@@ -135,7 +138,7 @@ Store device credentials securely:
         text = QTextEdit()
         text.setReadOnly(True)
         text.setFont(QFont("Courier", 10))
-        text.setText("""# Quick Start - First Connection
+        text.setText("""# Quick Start - Context Manager (Recommended)
 
 # 1. Unlock vault
 api.unlock("vault-password")
@@ -144,47 +147,63 @@ api.unlock("vault-password")
 api.devices()
 # [Device(wan-core-1, 172.16.128.1:22, cred=home_lab), ...]
 
-# 3. Connect to a device
-session = api.connect("wan-core-1")
-# <ActiveSession wan-core-1@172.16.128.1:22 connected, platform=cisco_ios>
+# 3. Connect with context manager (auto-disconnects)
+with api.session("wan-core-1") as session:
+    result = api.send(session, "show version")
+    print(result.parsed_data)
+    # [{'VERSION': '15.2(4)M11', 'HOSTNAME': 'wan-core-1', ...}]
+# Session automatically closed here
 
-# 4. Execute a command
-result = api.send(session, "show version")
 
-# 5. Access parsed data
-print(result.parsed_data)
-# [{'VERSION': '15.2(4)M11', 'HOSTNAME': 'wan-core-1', ...}]
+# Platform-Aware Commands
 
-# 6. Disconnect
-api.disconnect(session)
+with api.session("wan-core-1") as s:
+    # Automatically uses correct syntax for platform
+    result = api.send_platform_command(s, 'config', parse=False)
+    print(f"Config: {len(result.raw_output)} bytes")
+    
+    # Get version info
+    result = api.send_platform_command(s, 'version')
+    
+    # Get BGP summary (works on Cisco, Arista, Juniper)
+    result = api.send_platform_command(s, 'bgp_summary')
 
 
-# Common Workflows
+# Try Multiple Commands (CDP/LLDP discovery)
 
-# Search devices
-devices = api.search("leaf")
-devices = api.devices("eng-*")
-devices = api.devices(folder="Lab-ENG")
+with api.session("wan-core-1") as s:
+    # Try CDP first, fall back to LLDP
+    result = api.send_first(s, [
+        "show cdp neighbors detail",
+        "show lldp neighbors detail",
+    ])
+    
+    if result and result.parsed_data:
+        for neighbor in result.parsed_data:
+            print(f"{neighbor.get('NEIGHBOR', 'unknown')}")
 
-# Connect with specific credential
-session = api.connect("device", credential="lab-admin")
 
-# Check connection status
-if session.is_connected():
-    result = api.send(session, "show ip route")
+# Multi-Device Workflow
 
-# Disable parsing for raw output
-result = api.send(session, "show run", parse=False)
-print(result.raw_output)
-
-# Multi-device workflow
 for device in api.devices("spine-*"):
-    session = api.connect(device.name)
-    result = api.send(session, "show version")
-    if result.parsed_data:
-        version = result.parsed_data[0]['VERSION']
-        print(f"{device.name}: {version}")
-    api.disconnect(session)
+    with api.session(device.name) as s:
+        result = api.send(s, "show version")
+        
+        if result.parsed_data:
+            version = result.parsed_data[0]['VERSION']
+            print(f"{device.name}: {version}")
+# Sessions auto-disconnect when exiting context
+
+
+# Manual Connection (requires explicit disconnect)
+
+session = api.connect("device-name")
+result = api.send(session, "show version")
+api.disconnect(session)
+
+# Cleanup all sessions
+count = api.disconnect_all()
+print(f"Disconnected {count} session(s)")
 """)
         layout.addWidget(text)
         return widget
@@ -204,207 +223,358 @@ for device in api.devices("spine-*"):
 api.devices()                     # List all devices
 api.devices("pattern*")           # Filter by glob pattern
 api.devices(folder="Lab-ENG")     # Filter by folder
-api.search("query")               # Search by name/hostname
+api.search("query")               # Search by name/hostname/description
 api.device("name")                # Get specific device
 api.folders()                     # List all folders
 
+DeviceInfo fields: name, hostname, port, folder, credential,
+                   last_connected, connect_count
+
 ## Credential Operations (requires unlocked vault)
 
 api.unlock("password")            # Unlock vault
 api.lock()                        # Lock vault
-api.credentials()                 # List all credentials
+api.credentials()                 # List credentials (no secrets)
 api.credentials("*admin*")        # Filter by pattern
 api.credential("name")            # Get specific credential
 api.resolve_credential("host")    # Find matching credential
 
+Properties:
+api.vault_initialized             # Vault exists
+api.vault_unlocked                # Vault is unlocked
+
+CredentialInfo fields: name, username, has_password, has_key,
+                       match_hosts, match_tags, is_default
+
 ## Connection Operations
 
-session = api.connect("device")              # Connect and auto-detect
-session = api.connect("device", "cred")      # Connect with credential
-api.disconnect(session)                      # Close connection
-api.active_sessions()                        # List open connections
+# Context manager (recommended) - auto-disconnects on exit
+with api.session("device-name") as session:
+    result = api.send(session, "show version")
+# Session automatically closed here
+
+# Manual connection (requires explicit disconnect)
+session = api.connect("device-name")
+session = api.connect("device", credential="cred-name")
+session = api.connect("192.168.1.1", debug=True)
+
+# Session attributes
+session.device_name               # Device name
+session.hostname                  # IP/hostname
+session.platform                  # 'cisco_ios', 'arista_eos', etc.
+session.prompt                    # Device prompt
+session.is_connected()            # Check if active
+session.connected_at              # Timestamp
+
+# Disconnect
+api.disconnect(session)           # Single session
+api.disconnect_all()              # All active sessions
+api.active_sessions()             # List open connections
 
 ## Command Execution
 
-result = api.send(session, "show version")              # Execute and parse
-result = api.send(session, "cmd", parse=False)          # Raw output only
-result = api.send(session, "cmd", timeout=60)           # Custom timeout
-result = api.send(session, "cmd", normalize=False)      # Don't normalize fields
+# Execute with parsing (default)
+result = api.send(session, "show version")
+result = api.send(session, "show interfaces")
 
-## Result Access
+# Options
+result = api.send(session, "cmd", parse=False)        # Raw output only
+result = api.send(session, "cmd", timeout=60)         # Custom timeout
+result = api.send(session, "cmd", normalize=False)    # Keep vendor field names
 
+# Result attributes
+result.command                    # Command that was run
 result.raw_output                 # Raw text from device
-result.parsed_data                # Parsed List[Dict] or None
+result.parsed_data                # List[Dict] or None
 result.platform                   # Detected platform
 result.parse_success              # Whether parsing worked
 result.parse_template             # Template used
+result.timestamp                  # When command was run
 result.to_dict()                  # Export as dictionary
 
-## Session Attributes
-
-session.device_name               # Device name
-session.hostname                  # IP/hostname
-session.port                      # SSH port
-session.platform                  # Detected platform
-session.prompt                    # Device prompt
-session.is_connected()            # Check if active
-session.connected_at              # Connection timestamp
+## Platform-Aware Commands (NEW)
+
+# Automatically uses correct syntax for detected platform
+result = api.send_platform_command(session, 'config', parse=False)
+result = api.send_platform_command(session, 'version')
+result = api.send_platform_command(session, 'interfaces_status')
+result = api.send_platform_command(session, 'interface_detail', name='Gi0/1')
+result = api.send_platform_command(session, 'bgp_summary')
+result = api.send_platform_command(session, 'routing_table')
+
+# See "Platform Commands" tab for full list
+
+## Try Multiple Commands (NEW)
+
+# Try commands in order until one succeeds
+result = api.send_first(session, [
+    "show cdp neighbors detail",
+    "show lldp neighbors detail",
+])
+
+# Options
+result = api.send_first(
+    session,
+    commands,
+    parse=True,              # Attempt parsing
+    timeout=30,              # Per-command timeout
+    require_parsed=True,     # Only succeed if parsed_data is non-empty
+)
 
 ## Debugging
 
 api.debug_parse(cmd, output, platform)  # Debug parsing issues
 api.db_info()                           # Database diagnostics
 api.status()                            # API summary
-
-## Status Properties
-
-api.vault_unlocked                # Vault status (bool)
-api.vault_initialized             # Vault exists (bool)
-api._tfsm_engine                  # Parser instance
+api.help()                              # Show all commands
 """)
         layout.addWidget(text)
         return widget
 
-    def _create_examples_tab(self) -> QWidget:
-        """Create examples tab."""
+    def _create_platform_tab(self) -> QWidget:
+        """Create platform commands tab."""
         widget = QWidget()
         layout = QVBoxLayout(widget)
 
         text = QTextEdit()
         text.setReadOnly(True)
-        text.setFont(QFont("Courier", 9))
-        text.setText("""# Examples
+        text.setMarkdown("""
+# Platform-Aware Commands
 
-# Example 1: Collect Software Versions
-api.unlock("password")
-versions = {}
+The `send_platform_command()` method automatically uses the correct syntax for the detected platform.
 
-for device in api.devices():
-    try:
-        session = api.connect(device.name)
-        result = api.send(session, "show version")
+## Supported Platforms
 
-        if result.parsed_data:
-            ver = result.parsed_data[0].get('VERSION', 'unknown')
-            versions[device.name] = ver
+Auto-detected from `show version` output:
 
-        api.disconnect(session)
-    except Exception as e:
-        print(f"Failed on {device.name}: {e}")
+- `cisco_ios` - Cisco IOS
+- `cisco_nxos` - Cisco Nexus NX-OS
+- `cisco_iosxe` - Cisco IOS-XE
+- `cisco_iosxr` - Cisco IOS-XR
+- `arista_eos` - Arista EOS
+- `juniper_junos` - Juniper Junos
 
-# Print results
-for name, ver in sorted(versions.items()):
-    print(f"{name:20} {ver}")
+## Available Command Types
 
+| Command Type | Cisco IOS | Arista EOS | Juniper |
+|--------------|-----------|------------|---------|
+| `config` | show running-config | show running-config | show configuration |
+| `version` | show version | show version | show version |
+| `interfaces` | show interfaces | show interfaces | show interfaces |
+| `interfaces_status` | show interfaces status | show interfaces status | show interfaces terse |
+| `interface_detail` | show interfaces {name} | show interfaces {name} | show interfaces {name} |
+| `neighbors_cdp` | show cdp neighbors detail | show lldp neighbors detail | - |
+| `neighbors_lldp` | show lldp neighbors detail | show lldp neighbors detail | show lldp neighbors |
+| `neighbors` | show cdp neighbors detail | show lldp neighbors detail | show lldp neighbors |
+| `routing_table` | show ip route | show ip route | show route |
+| `bgp_summary` | show ip bgp summary | show ip bgp summary | show bgp summary |
+| `bgp_neighbors` | show ip bgp neighbors | show ip bgp neighbors | show bgp neighbor |
 
-# Example 2: Find Interfaces with Errors
-session = api.connect("core-switch")
-result = api.send(session, "show interfaces")
+## Usage Examples
+
+```python
+# Get running config (works on any platform)
+result = api.send_platform_command(session, 'config', parse=False)
 
-if result.parsed_data:
-    for intf in result.parsed_data:
-        in_errors = int(intf.get('in_errors', 0))
-        out_errors = int(intf.get('out_errors', 0))
+# Get version info
+result = api.send_platform_command(session, 'version')
 
-        if in_errors > 0 or out_errors > 0:
-            print(f"{intf['interface']}: in={in_errors}, out={out_errors}")
+# Get interface status
+result = api.send_platform_command(session, 'interfaces_status')
 
-api.disconnect(session)
+# Get specific interface
+result = api.send_platform_command(session, 'interface_detail', name='Gi0/1')
 
+# Get BGP summary
+result = api.send_platform_command(session, 'bgp_summary')
 
-# Example 3: Configuration Backup
-import json
-from datetime import datetime
+# Get routing table
+result = api.send_platform_command(session, 'routing_table')
+```
 
-backups = {}
+## Try Multiple Commands
 
-for device in api.devices(folder="Production"):
-    session = api.connect(device.name)
-    result = api.send(session, "show running-config", parse=False)
+For discovery across platforms with different capabilities:
 
-    backups[device.name] = {
-        'hostname': device.hostname,
-        'config': result.raw_output,
-        'timestamp': datetime.now().isoformat(),
-    }
+```python
+# Try CDP first, fall back to LLDP
+result = api.send_first(session, [
+    "show cdp neighbors detail",
+    "show lldp neighbors detail",
+])
+
+# Platform-agnostic config fetch
+result = api.send_first(session, [
+    "show running-config",
+    "show configuration",
+], parse=False, require_parsed=False)
+```
 
-    api.disconnect(session)
+## Template Coverage
 
-# Save to file
-with open('backups.json', 'w') as f:
-    json.dump(backups, f, indent=2)
+**961 TextFSM templates** available for 69 platforms via ntc-templates.
 
+Download additional templates via:
+**Dev → Download NTC Templates...**
+""")
+        layout.addWidget(text)
+        return widget
 
-# Example 4: Audit Device Reachability
-api.unlock("password")
+    def _create_examples_tab(self) -> QWidget:
+        """Create examples tab."""
+        widget = QWidget()
+        layout = QVBoxLayout(widget)
 
-print("Testing device connectivity...")
-print(f"{'Device':<20} {'Status':<10} {'Platform':<15}")
-print("-" * 45)
+        text = QTextEdit()
+        text.setReadOnly(True)
+        text.setFont(QFont("Courier", 9))
+        text.setText("""# Examples
+
+# Example 1: Collect Software Versions (Context Manager)
+api.unlock("password")
+versions = {}
 
 for device in api.devices():
     try:
-        session = api.connect(device.name)
-        platform = session.platform or 'unknown'
-        print(f"{device.name:<20} {'UP':<10} {platform:<15}")
-        api.disconnect(session)
+        with api.session(device.name) as s:
+            result = api.send(s, "show version")
+            
+            if result.parsed_data:
+                ver = result.parsed_data[0].get('VERSION', 'unknown')
+                versions[device.name] = ver
     except Exception as e:
-        print(f"{device.name:<20} {'DOWN':<10} {str(e)[:15]}")
+        print(f"Failed on {device.name}: {e}")
 
+# Print results
+for name, ver in sorted(versions.items()):
+    print(f"{name:20} {ver}")
 
-# Example 5: Compare Configurations
-session1 = api.connect("spine-1")
-session2 = api.connect("spine-2")
 
-config1 = api.send(session1, "show run", parse=False).raw_output
-config2 = api.send(session2, "show run", parse=False).raw_output
+# Example 2: CDP/LLDP Neighbor Discovery
+with api.session("wan-core-1") as s:
+    # Automatically tries CDP then LLDP
+    result = api.send_first(s, [
+        "show cdp neighbors detail",
+        "show lldp neighbors detail",
+    ])
+    
+    if result and result.parsed_data:
+        for neighbor in result.parsed_data:
+            local_intf = neighbor.get('LOCAL_INTERFACE', 'unknown')
+            remote = neighbor.get('NEIGHBOR', 'unknown')
+            print(f"{remote:30} via {local_intf}")
 
-# Find differences
-lines1 = set(config1.split('\\n'))
-lines2 = set(config2.split('\\n'))
 
-print("Only in spine-1:")
-for line in sorted(lines1 - lines2)[:10]:
-    print(f"  {line}")
+# Example 3: Platform-Aware Config Backup
+from pathlib import Path
+from datetime import datetime
 
-print("\\nOnly in spine-2:")
-for line in sorted(lines2 - lines1)[:10]:
-    print(f"  {line}")
+api.unlock("password")
+backup_dir = Path("config_backups")
+backup_dir.mkdir(exist_ok=True)
 
-api.disconnect(session1)
-api.disconnect(session2)
+for device in api.devices(folder="Production"):
+    try:
+        with api.session(device.name) as s:
+            # Works on Cisco, Arista, Juniper - picks correct command
+            result = api.send_platform_command(s, 'config', parse=False)
+            
+            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+            filename = backup_dir / f"{device.name}_{timestamp}.cfg"
+            filename.write_text(result.raw_output)
+            
+            print(f"✓ {device.name}: {len(result.raw_output)} bytes")
+    except Exception as e:
+        print(f"✗ {device.name}: {e}")
+
+print(f"\\nBackups saved to: {backup_dir}")
 
 
-# Example 6: Device Inventory Report
+# Example 4: Interface Error Report
+with api.session("distribution-1") as s:
+    result = api.send(s, "show interfaces")
+    
+    if result.parsed_data:
+        errors_found = False
+        for intf in result.parsed_data:
+            in_errors = int(intf.get('in_errors', 0) or 0)
+            out_errors = int(intf.get('out_errors', 0) or 0)
+            
+            if in_errors > 0 or out_errors > 0:
+                errors_found = True
+                print(f"{intf['interface']:15} IN: {in_errors:>8}  OUT: {out_errors:>8}")
+        
+        if not errors_found:
+            print("No interface errors found")
+
+
+# Example 5: Device Inventory CSV
 import csv
+from nterm.scripting.platform_utils import extract_version_info
 
 api.unlock("password")
 
 with open('inventory.csv', 'w', newline='') as f:
     writer = csv.writer(f)
     writer.writerow(['Device', 'IP', 'Platform', 'Version', 'Serial', 'Uptime'])
-
+    
     for device in api.devices():
         try:
-            session = api.connect(device.name)
-            result = api.send(session, "show version")
-
-            if result.parsed_data:
-                data = result.parsed_data[0]
-                writer.writerow([
-                    device.name,
-                    device.hostname,
-                    session.platform,
-                    data.get('VERSION', ''),
-                    data.get('SERIAL', [''])[0],
-                    data.get('UPTIME', ''),
-                ])
-
-            api.disconnect(session)
+            with api.session(device.name) as s:
+                result = api.send_platform_command(s, 'version')
+                
+                if result and result.parsed_data:
+                    info = extract_version_info(result.parsed_data, s.platform)
+                    writer.writerow([
+                        device.name,
+                        device.hostname,
+                        s.platform,
+                        info.get('version', ''),
+                        info.get('serial', ''),
+                        info.get('uptime', ''),
+                    ])
+                else:
+                    writer.writerow([device.name, device.hostname, s.platform, '', '', ''])
         except Exception as e:
             writer.writerow([device.name, device.hostname, 'ERROR', str(e), '', ''])
 
 print("Inventory saved to inventory.csv")
+
+
+# Example 6: Multi-Device BGP Summary
+api.unlock("password")
+bgp_report = {}
+
+for device in api.devices("*spine*"):
+    try:
+        with api.session(device.name) as s:
+            result = api.send_platform_command(s, 'bgp_summary')
+            
+            if result and result.parsed_data:
+                neighbor_count = len(result.parsed_data)
+                established = sum(1 for n in result.parsed_data 
+                                  if str(n.get('STATE_PFXRCD', '')).isdigit())
+                bgp_report[device.name] = {
+                    'total': neighbor_count,
+                    'established': established,
+                }
+    except Exception as e:
+        bgp_report[device.name] = {'error': str(e)}
+
+# Print report
+print(f"{'Device':<25} {'Total':<10} {'Established':<10}")
+print("-" * 45)
+for device, info in sorted(bgp_report.items()):
+    if 'error' in info:
+        print(f"{device:<25} ERROR: {info['error']}")
+    else:
+        print(f"{device:<25} {info['total']:<10} {info['established']:<10}")
+
+
+# Example 7: Cleanup All Sessions
+# At end of script or in finally block
+count = api.disconnect_all()
+print(f"Disconnected {count} session(s)")
 """)
         layout.addWidget(text)
         return widget
@@ -430,10 +600,10 @@ print("Inventory saved to inventory.csv")
 4. Click **Download Selected**
 5. Restart IPython session
 
-**Check status:**
+**Verify:**
 ```python
 api.db_info()
-# Shows: db_path, db_exists, db_size
+# {'db_exists': True, 'db_size_mb': 0.3, ...}
 ```
 
 ## Vault Locked
@@ -465,54 +635,82 @@ api.credentials()  # List all credentials
 api.resolve_credential("192.168.1.1")  # Check which would match
 ```
 
-## Connection Failed
+## Parsing Failed
 
-**Error:** Connection timeout or authentication failure
+**Symptom:** `result.parsed_data` is `None`
 
 **Debug:**
 ```python
-# Check device info
-device = api.device("device-name")
-print(device)
+result = api.send(session, "show version")
 
-# Try with different credential
-session = api.connect("device", credential="other-cred")
+# Check raw output
+print(result.raw_output[:200])
 
-# Check if device is reachable
-# (try from terminal first)
+# Debug parsing
+debug = api.debug_parse("show version", result.raw_output, session.platform)
+print(debug)
+# Shows: template_used, best_score, all_scores, error
 ```
 
-## Parsing Failed
+**Common causes:**
+- Template doesn't exist for this platform/command
+- Platform not detected (check `session.platform`)
+- Output format non-standard
+- Database missing templates (download more)
+
+**Workaround:**
+```python
+result = api.send(session, "show version", parse=False)
+print(result.raw_output)
+```
 
-**Symptom:** `result.parsed_data` is None but command succeeded
+## Paging Not Disabled
+
+**Error:** `PagingNotDisabledError: Paging prompt '--More--' detected`
+
+**Cause:** Terminal paging wasn't disabled before command execution.
+
+This indicates a problem with platform detection or session setup. The API automatically sends `terminal length 0` (or equivalent) after connecting.
 
 **Debug:**
 ```python
-result = api.send(session, "show version")
+# Check platform was detected
+print(session.platform)  # Should not be None
 
-# Check raw output
-print(result.raw_output[:200])
+# Try with debug enabled
+session = api.connect("device", debug=True)
+```
 
-# Debug parsing
-debug = api.debug_parse(
-    command="show version",
-    output=result.raw_output,
-    platform=session.platform
-)
+## Connection Failed
 
-print(debug)
-# Shows: template_used, best_score, all_scores, error
-```
+**Debug:**
+```python
+# Check device info
+device = api.device("device-name")
+print(device)
 
-**Solutions:**
-- Template might not exist for this command/platform
-- Output format might be non-standard
-- Use `parse=False` to get raw output
-- Download more templates if platform is missing
+# Try with different credential
+session = api.connect("device", credential="other-cred")
+
+# Check credentials
+api.credentials()
+api.resolve_credential("192.168.1.1")
+
+# Enable debug mode
+session = api.connect("device", debug=True)
+```
 
 ## Platform Not Detected
 
-**Symptom:** `session.platform` is None
+**Symptom:** `session.platform` is `None`
+
+Platform detection looks for keywords in `show version` output:
+- Cisco IOS: "Cisco IOS Software"
+- Cisco NX-OS: "Cisco Nexus Operating System"
+- Arista: "Arista", "vEOS"
+- Juniper: "JUNOS"
+
+If not detected, parsing won't work automatically.
 
 **Debug:**
 ```python
@@ -524,14 +722,6 @@ result = api.send(session, "show version", parse=False)
 print(result.raw_output[:500])
 ```
 
-**Solution:**
-Platform detection looks for keywords in show version:
-- Cisco: "Cisco IOS Software"
-- Arista: "Arista"
-- Juniper: "JUNOS"
-
-If not detected, parsing won't work. Set manually if needed (not currently supported, but you can modify the session object).
-
 ## Session Stuck
 
 **Symptom:** Command hangs or times out
@@ -542,11 +732,14 @@ If not detected, parsing won't work. Set manually if needed (not currently suppo
 result = api.send(session, "show tech-support", timeout=120)
 
 # Check if session still active
-session.is_connected()  # Returns 1 or 0
+session.is_connected()
 
 # Disconnect and reconnect
 api.disconnect(session)
 session = api.connect("device")
+
+# Or cleanup all
+api.disconnect_all()
 ```
 
 ## Getting Help
@@ -566,6 +759,7 @@ result?              # Show CommandResult help
 - **Dev → API Help...** (this dialog)
 - **Dev → Download NTC Templates...**
 - **Edit → Credential Manager...**
+- Press **F1** for comprehensive help
 """)
         layout.addWidget(text)
         return widget
@@ -573,7 +767,6 @@ result?              # Show CommandResult help
     def _copy_sample_code(self):
         """Copy sample code to clipboard."""
         sample = """# nterm API Quick Start
-from nterm.scripting import api
 
 # Unlock vault
 api.unlock("vault-password")
@@ -581,20 +774,30 @@ api.unlock("vault-password")
 # List devices
 devices = api.devices()
 
-# Connect to device
-session = api.connect("device-name")
-
-# Execute command
-result = api.send(session, "show version")
-
-# Access parsed data
-if result.parsed_data:
-    print(result.parsed_data[0])
-else:
-    print(result.raw_output)
-
-# Disconnect
+# Connect with context manager (recommended)
+with api.session("device-name") as s:
+    # Execute command with parsing
+    result = api.send(s, "show version")
+    
+    # Access parsed data
+    if result.parsed_data:
+        print(result.parsed_data[0])
+    else:
+        print(result.raw_output)
+    
+    # Platform-aware command
+    config = api.send_platform_command(s, 'config', parse=False)
+    print(f"Config size: {len(config.raw_output)} bytes")
+
+# Session auto-disconnects when exiting 'with' block
+
+# Manual connection (if needed)
+session = api.connect("other-device")
+result = api.send(session, "show interfaces")
 api.disconnect(session)
+
+# Cleanup all sessions
+api.disconnect_all()
 """
         from PyQt6.QtWidgets import QApplication
         clipboard = QApplication.clipboard()