arcgispro-cli 0.1.2__tar.gz

arcgispro_cli-0.1.2/.gitignore

@@ -0,0 +1,21 @@
+# Visual Studio
+.vs/
+bin/
+obj/
+*.user
+*.suo
+
+# Python
+__pycache__/
+*.pyc
+*.egg-info/
+dist/
+.venv/
+venv/
+
+# ArcGIS Pro
+# *.esriAddinX  # Commented out - we bundle the addin in the CLI package
+
+# OS
+.DS_Store
+Thumbs.db

arcgispro_cli-0.1.2/PKG-INFO

@@ -0,0 +1,97 @@
+Metadata-Version: 2.4
+Name: arcgispro-cli
+Version: 0.1.2
+Summary: CLI tool for inspecting ArcGIS Pro session exports
+Author: mcveydb
+License: MIT
+Keywords: arcgis,cli,esri,gis
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: Microsoft :: Windows
+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
+Classifier: Topic :: Scientific/Engineering :: GIS
+Requires-Python: >=3.9
+Requires-Dist: click>=8.0
+Requires-Dist: rich>=13.0
+Provides-Extra: dev
+Requires-Dist: pytest-cov>=4.0; extra == 'dev'
+Requires-Dist: pytest>=7.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# ArcGIS Pro CLI
+
+A command-line tool for inspecting and managing ArcGIS Pro session exports.
+
+## Installation
+
+```bash
+cd cli
+pip install -e .
+```
+
+## Usage
+
+```bash
+# View help
+arcgispro --help
+
+# Inspect exported context
+arcgispro inspect
+
+# Validate JSON exports
+arcgispro dump
+
+# Validate images
+arcgispro images
+
+# Assemble snapshot
+arcgispro snapshot
+
+# Clean up exports
+arcgispro clean --all
+
+# Select active project
+arcgispro open
+```
+
+## Workflow
+
+1. **In ArcGIS Pro:** Click "Snapshot" button in the ArcGIS Pro CLI ribbon
+2. **In terminal:** Run `arcgispro inspect` to see what was exported
+3. **Use context:** Read JSON files or markdown summary for AI analysis
+
+## Folder Structure
+
+The CLI reads from `.arcgispro/` folder created by the add-in:
+
+```
+.arcgispro/
+├── meta.json           # Export metadata
+├── active_project.txt  # Path to active .aprx
+├── context/
+│   ├── project.json
+│   ├── maps.json
+│   ├── layers.json
+│   ├── tables.json
+│   ├── connections.json
+│   └── layouts.json
+├── snapshot/
+│   ├── context.md
+│   ├── CONTEXT_SKILL.md
+│   └── AGENT_TOOL_SKILL.md
+└── images/
+    ├── map_*.png
+    └── layout_*.png
+```
+
+## Requirements
+
+- Python 3.9+
+- click
+- rich

arcgispro_cli-0.1.2/README.md

@@ -0,0 +1,71 @@
+# ArcGIS Pro CLI
+
+A command-line tool for inspecting and managing ArcGIS Pro session exports.
+
+## Installation
+
+```bash
+cd cli
+pip install -e .
+```
+
+## Usage
+
+```bash
+# View help
+arcgispro --help
+
+# Inspect exported context
+arcgispro inspect
+
+# Validate JSON exports
+arcgispro dump
+
+# Validate images
+arcgispro images
+
+# Assemble snapshot
+arcgispro snapshot
+
+# Clean up exports
+arcgispro clean --all
+
+# Select active project
+arcgispro open
+```
+
+## Workflow
+
+1. **In ArcGIS Pro:** Click "Snapshot" button in the ArcGIS Pro CLI ribbon
+2. **In terminal:** Run `arcgispro inspect` to see what was exported
+3. **Use context:** Read JSON files or markdown summary for AI analysis
+
+## Folder Structure
+
+The CLI reads from `.arcgispro/` folder created by the add-in:
+
+```
+.arcgispro/
+├── meta.json           # Export metadata
+├── active_project.txt  # Path to active .aprx
+├── context/
+│   ├── project.json
+│   ├── maps.json
+│   ├── layers.json
+│   ├── tables.json
+│   ├── connections.json
+│   └── layouts.json
+├── snapshot/
+│   ├── context.md
+│   ├── CONTEXT_SKILL.md
+│   └── AGENT_TOOL_SKILL.md
+└── images/
+    ├── map_*.png
+    └── layout_*.png
+```
+
+## Requirements
+
+- Python 3.9+
+- click
+- rich

arcgispro_cli-0.1.2/arcgispro_cli/__init__.py

@@ -0,0 +1,3 @@
+"""ArcGIS Pro CLI - Inspect and manage ArcGIS Pro session exports."""
+
+__version__ = "0.1.2"

arcgispro_cli-0.1.2/arcgispro_cli/cli.py

@@ -0,0 +1,56 @@
+"""
+ArcGIS Pro CLI - Main entry point
+
+Commands:
+    arcgispro install    - Install the ProExporter add-in
+    arcgispro uninstall  - Show uninstall instructions
+    arcgispro inspect    - Print human-readable summary of exports
+    arcgispro dump       - Validate context JSON files
+    arcgispro images     - Validate exported images
+    arcgispro snapshot   - Assemble full snapshot
+    arcgispro clean      - Remove generated files
+    arcgispro open       - Select active project
+"""
+
+import click
+from rich.console import Console
+
+from . import __version__
+from .commands import inspect, dump, images, snapshot, clean, open_project, install
+
+console = Console()
+
+
+@click.group()
+@click.version_option(version=__version__, prog_name="arcgispro")
+@click.pass_context
+def main(ctx):
+    """ArcGIS Pro CLI - Inspect and manage session exports.
+    
+    This tool reads exports from the .arcgispro/ folder created by the
+    ProExporter add-in. Use it to validate exports, view summaries,
+    and assemble snapshots for AI agents.
+    
+    \b
+    Quick start:
+        pip install arcgispro-cli
+        arcgispro install        # Install add-in (one time)
+        # In ArcGIS Pro: Click "Snapshot" button
+        arcgispro inspect        # View exported context
+    """
+    ctx.ensure_object(dict)
+
+
+# Register commands
+main.add_command(install.install_cmd, name="install")
+main.add_command(install.uninstall_cmd, name="uninstall")
+main.add_command(inspect.inspect_cmd, name="inspect")
+main.add_command(dump.dump_cmd, name="dump")
+main.add_command(images.images_cmd, name="images")
+main.add_command(snapshot.snapshot_cmd, name="snapshot")
+main.add_command(clean.clean_cmd, name="clean")
+main.add_command(open_project.open_cmd, name="open")
+
+
+if __name__ == "__main__":
+    main()

arcgispro_cli-0.1.2/arcgispro_cli/commands/__init__.py

@@ -0,0 +1 @@
+"""Command implementations for arcgispro CLI."""

arcgispro_cli-0.1.2/arcgispro_cli/commands/clean.py

@@ -0,0 +1,119 @@
+"""clean command - Remove generated files."""
+
+import click
+import shutil
+from rich.console import Console
+from pathlib import Path
+
+from ..paths import (
+    find_arcgispro_folder,
+    get_context_folder,
+    get_images_folder,
+    get_snapshot_folder,
+)
+
+console = Console()
+
+
+@click.command("clean")
+@click.option("--path", "-p", type=click.Path(exists=True), help="Path to search for .arcgispro folder")
+@click.option("--images", "clean_images", is_flag=True, help="Remove images/ folder")
+@click.option("--context", "clean_context", is_flag=True, help="Remove context/ folder")
+@click.option("--snapshot", "clean_snapshot", is_flag=True, help="Remove snapshot/ folder")
+@click.option("--all", "clean_all", is_flag=True, help="Remove everything in .arcgispro/")
+@click.option("--yes", "-y", is_flag=True, help="Skip confirmation")
+def clean_cmd(path, clean_images, clean_context, clean_snapshot, clean_all, yes):
+    """Remove generated files from .arcgispro/ folder.
+    
+    Use flags to specify what to remove:
+    
+    \b
+        --images    Remove images/ folder
+        --context   Remove context/ folder  
+        --snapshot  Remove snapshot/ folder
+        --all       Remove everything
+    
+    By default, asks for confirmation before deleting.
+    """
+    start_path = Path(path) if path else None
+    arcgispro_path = find_arcgispro_folder(start_path)
+    
+    if not arcgispro_path:
+        console.print("[red]✗[/red] No .arcgispro folder found")
+        raise SystemExit(1)
+    
+    # If no flags specified, show help
+    if not any([clean_images, clean_context, clean_snapshot, clean_all]):
+        console.print("[yellow]No cleanup option specified.[/yellow]")
+        console.print()
+        console.print("Use one of:")
+        console.print("  --images    Remove images/ folder")
+        console.print("  --context   Remove context/ folder")
+        console.print("  --snapshot  Remove snapshot/ folder")
+        console.print("  --all       Remove everything in .arcgispro/")
+        raise SystemExit(1)
+    
+    to_remove = []
+    
+    if clean_all:
+        # Remove everything
+        for item in arcgispro_path.iterdir():
+            to_remove.append(item)
+    else:
+        if clean_images:
+            images_folder = get_images_folder(arcgispro_path)
+            if images_folder.exists():
+                to_remove.append(images_folder)
+        
+        if clean_context:
+            context_folder = get_context_folder(arcgispro_path)
+            if context_folder.exists():
+                to_remove.append(context_folder)
+            # Also remove meta.json and active_project.txt
+            meta_file = arcgispro_path / "meta.json"
+            if meta_file.exists():
+                to_remove.append(meta_file)
+            active_file = arcgispro_path / "active_project.txt"
+            if active_file.exists():
+                to_remove.append(active_file)
+        
+        if clean_snapshot:
+            snapshot_folder = get_snapshot_folder(arcgispro_path)
+            if snapshot_folder.exists():
+                to_remove.append(snapshot_folder)
+    
+    if not to_remove:
+        console.print("[dim]Nothing to remove.[/dim]")
+        return
+    
+    # Show what will be removed
+    console.print("[bold]Will remove:[/bold]")
+    for item in to_remove:
+        if item.is_dir():
+            count = sum(1 for _ in item.rglob("*") if _.is_file())
+            console.print(f"  📁 {item.name}/ ({count} files)")
+        else:
+            console.print(f"  📄 {item.name}")
+    
+    # Confirm
+    if not yes:
+        console.print()
+        if not click.confirm("Proceed with deletion?"):
+            console.print("[dim]Cancelled.[/dim]")
+            return
+    
+    # Delete
+    removed = 0
+    for item in to_remove:
+        try:
+            if item.is_dir():
+                shutil.rmtree(item)
+            else:
+                item.unlink()
+            removed += 1
+            console.print(f"[green]✓[/green] Removed {item.name}")
+        except Exception as e:
+            console.print(f"[red]✗[/red] Failed to remove {item.name}: {e}")
+    
+    console.print()
+    console.print(f"[bold]Removed {removed} item(s)[/bold]")

arcgispro_cli-0.1.2/arcgispro_cli/commands/dump.py

@@ -0,0 +1,87 @@
+"""dump command - Validate context JSON files."""
+
+import click
+from rich.console import Console
+from pathlib import Path
+
+from ..paths import find_arcgispro_folder, get_context_folder, load_json_file
+
+console = Console()
+
+EXPECTED_FILES = [
+    ("meta.json", False),  # (filename, is_in_context_folder)
+    ("project.json", True),
+    ("maps.json", True),
+    ("layers.json", True),
+    ("tables.json", True),
+    ("connections.json", True),
+    ("layouts.json", True),
+]
+
+
+@click.command("dump")
+@click.option("--path", "-p", type=click.Path(exists=True), help="Path to search for .arcgispro folder")
+@click.option("--verbose", "-v", is_flag=True, help="Show file contents")
+def dump_cmd(path, verbose):
+    """Validate that context JSON files exist and are valid.
+    
+    Checks for expected JSON files in the .arcgispro/context/ folder
+    and validates they contain valid JSON.
+    
+    Exit code 0 if all files valid, 1 if any issues found.
+    """
+    start_path = Path(path) if path else None
+    arcgispro_path = find_arcgispro_folder(start_path)
+    
+    if not arcgispro_path:
+        console.print("[red]✗[/red] No .arcgispro folder found")
+        raise SystemExit(1)
+    
+    context_folder = get_context_folder(arcgispro_path)
+    
+    console.print(f"[bold]Validating context files in:[/bold] {arcgispro_path}")
+    console.print()
+    
+    all_valid = True
+    valid_count = 0
+    
+    for filename, in_context in EXPECTED_FILES:
+        if in_context:
+            file_path = context_folder / filename
+        else:
+            file_path = arcgispro_path / filename
+        
+        if not file_path.exists():
+            console.print(f"[yellow]⚠[/yellow] {filename}: [yellow]missing[/yellow]")
+            all_valid = False
+            continue
+        
+        data = load_json_file(file_path)
+        if data is None:
+            console.print(f"[red]✗[/red] {filename}: [red]invalid JSON[/red]")
+            all_valid = False
+            continue
+        
+        # Get some stats about the data
+        if isinstance(data, list):
+            info = f"{len(data)} items"
+        elif isinstance(data, dict):
+            info = f"{len(data)} keys"
+        else:
+            info = "valid"
+        
+        console.print(f"[green]✓[/green] {filename}: {info}")
+        valid_count += 1
+        
+        if verbose and isinstance(data, dict):
+            for key in list(data.keys())[:5]:
+                console.print(f"    {key}: {type(data[key]).__name__}")
+    
+    console.print()
+    console.print(f"[bold]Result:[/bold] {valid_count}/{len(EXPECTED_FILES)} files valid")
+    
+    if not all_valid:
+        console.print("[yellow]Some files are missing or invalid. Re-run export from ArcGIS Pro.[/yellow]")
+        raise SystemExit(1)
+    
+    console.print("[green]All context files valid![/green]")

arcgispro_cli-0.1.2/arcgispro_cli/commands/images.py

@@ -0,0 +1,76 @@
+"""images command - Validate exported images."""
+
+import click
+from rich.console import Console
+from pathlib import Path
+
+from ..paths import find_arcgispro_folder, list_image_files, get_images_folder
+
+console = Console()
+
+
+@click.command("images")
+@click.option("--path", "-p", type=click.Path(exists=True), help="Path to search for .arcgispro folder")
+def images_cmd(path):
+    """Validate that exported images exist.
+    
+    Checks for PNG files in the .arcgispro/images/ folder.
+    
+    Exit code 0 if images exist, 1 if none found.
+    """
+    start_path = Path(path) if path else None
+    arcgispro_path = find_arcgispro_folder(start_path)
+    
+    if not arcgispro_path:
+        console.print("[red]✗[/red] No .arcgispro folder found")
+        raise SystemExit(1)
+    
+    images_folder = get_images_folder(arcgispro_path)
+    
+    console.print(f"[bold]Checking images in:[/bold] {images_folder}")
+    console.print()
+    
+    if not images_folder.exists():
+        console.print("[yellow]⚠[/yellow] images/ folder does not exist")
+        console.print("  Run 'Export Images' or 'Snapshot' from ArcGIS Pro.")
+        raise SystemExit(1)
+    
+    images = list_image_files(arcgispro_path)
+    
+    if not images:
+        console.print("[yellow]⚠[/yellow] No PNG images found")
+        console.print("  Make sure a map view is active when exporting.")
+        raise SystemExit(1)
+    
+    # Categorize images
+    map_images = [img for img in images if img.name.startswith("map_")]
+    layout_images = [img for img in images if img.name.startswith("layout_")]
+    other_images = [img for img in images if not img.name.startswith(("map_", "layout_"))]
+    
+    console.print("[bold]Map images:[/bold]")
+    if map_images:
+        for img in map_images:
+            size_kb = img.stat().st_size / 1024
+            console.print(f"  [green]✓[/green] {img.name} ({size_kb:.1f} KB)")
+    else:
+        console.print("  [dim]None[/dim]")
+    
+    console.print()
+    console.print("[bold]Layout images:[/bold]")
+    if layout_images:
+        for img in layout_images:
+            size_kb = img.stat().st_size / 1024
+            console.print(f"  [green]✓[/green] {img.name} ({size_kb:.1f} KB)")
+    else:
+        console.print("  [dim]None[/dim]")
+    
+    if other_images:
+        console.print()
+        console.print("[bold]Other images:[/bold]")
+        for img in other_images:
+            size_kb = img.stat().st_size / 1024
+            console.print(f"  [green]✓[/green] {img.name} ({size_kb:.1f} KB)")
+    
+    console.print()
+    console.print(f"[bold]Total:[/bold] {len(images)} images found")
+    console.print("[green]Image validation passed![/green]")

arcgispro_cli-0.1.2/arcgispro_cli/commands/inspect.py

@@ -0,0 +1,126 @@
+"""inspect command - Print human-readable summary of exports."""
+
+import click
+from rich.console import Console
+from rich.table import Table
+from rich.panel import Panel
+from rich import box
+from datetime import datetime
+
+from ..paths import find_arcgispro_folder, load_context_files, list_image_files
+
+console = Console()
+
+
+@click.command("inspect")
+@click.option("--path", "-p", type=click.Path(exists=True), help="Path to search for .arcgispro folder")
+def inspect_cmd(path):
+    """Print a human-readable summary of the exported context.
+    
+    Shows project info, maps, layers, and export metadata in a
+    formatted display.
+    """
+    from pathlib import Path
+    
+    start_path = Path(path) if path else None
+    arcgispro_path = find_arcgispro_folder(start_path)
+    
+    if not arcgispro_path:
+        console.print("[red]✗[/red] No .arcgispro folder found")
+        console.print("  Run the Snapshot export from ArcGIS Pro first.")
+        raise SystemExit(1)
+    
+    context = load_context_files(arcgispro_path)
+    images = list_image_files(arcgispro_path)
+    
+    # Header
+    console.print()
+    console.print(Panel.fit(
+        "[bold blue]ArcGIS Pro Session Context[/bold blue]",
+        border_style="blue"
+    ))
+    
+    # Meta info
+    meta = context.get("meta")
+    if meta:
+        exported_at = meta.get("exportedAt", "Unknown")
+        if isinstance(exported_at, str) and "T" in exported_at:
+            try:
+                dt = datetime.fromisoformat(exported_at.replace("Z", "+00:00"))
+                exported_at = dt.strftime("%Y-%m-%d %H:%M:%S UTC")
+            except ValueError:
+                pass
+        console.print(f"[dim]Exported: {exported_at}[/dim]")
+        console.print(f"[dim]Location: {arcgispro_path}[/dim]")
+    console.print()
+    
+    # Project info
+    project = context.get("project")
+    if project:
+        console.print("[bold]📁 Project[/bold]")
+        console.print(f"   Name: [cyan]{project.get('name', 'Unknown')}[/cyan]")
+        if project.get("path"):
+            console.print(f"   Path: {project.get('path')}")
+        map_count = len(project.get("mapNames", []))
+        layout_count = len(project.get("layoutNames", []))
+        console.print(f"   Maps: {map_count} | Layouts: {layout_count}")
+        console.print()
+    else:
+        console.print("[yellow]⚠ No project info found[/yellow]")
+        console.print()
+    
+    # Maps
+    maps = context.get("maps") or []
+    if maps:
+        console.print("[bold]🗺️  Maps[/bold]")
+        for m in maps:
+            active = " [green]★ Active[/green]" if m.get("isActiveMap") else ""
+            console.print(f"   • {m.get('name', 'Unknown')}{active}")
+            console.print(f"     Type: {m.get('mapType', '-')} | Layers: {m.get('layerCount', 0)} | Tables: {m.get('standaloneTableCount', 0)}")
+            if m.get("scale"):
+                console.print(f"     Scale: 1:{m.get('scale'):,.0f}")
+        console.print()
+    
+    # Layers summary
+    layers = context.get("layers") or []
+    if layers:
+        console.print("[bold]📊 Layers[/bold]")
+        
+        table = Table(box=box.SIMPLE, show_header=True, header_style="bold")
+        table.add_column("Layer", style="cyan")
+        table.add_column("Type")
+        table.add_column("Geometry")
+        table.add_column("Features", justify="right")
+        table.add_column("Visible")
+        
+        for layer in layers[:15]:  # Limit to first 15
+            visible = "✓" if layer.get("isVisible") else "✗"
+            broken = " [red]⚠[/red]" if layer.get("isBroken") else ""
+            features = f"{layer.get('featureCount', '-'):,}" if layer.get('featureCount') else "-"
+            
+            table.add_row(
+                f"{layer.get('name', 'Unknown')}{broken}",
+                layer.get("layerType", "-"),
+                layer.get("geometryType", "-"),
+                features,
+                visible
+            )
+        
+        console.print(table)
+        
+        if len(layers) > 15:
+            console.print(f"   [dim]...and {len(layers) - 15} more layers[/dim]")
+        console.print()
+    
+    # Images
+    if images:
+        console.print("[bold]🖼️  Images[/bold]")
+        for img in images:
+            console.print(f"   • {img.name}")
+        console.print()
+    
+    # Summary
+    console.print("[bold]Summary[/bold]")
+    console.print(f"   Context files: {sum(1 for v in context.values() if v is not None)}/7")
+    console.print(f"   Images: {len(images)}")
+    console.print()

arcgispro_cli-0.1.2/arcgispro_cli/commands/install.py

@@ -0,0 +1,76 @@
+"""install command - Install the ArcGIS Pro add-in."""
+
+import os
+import shutil
+import tempfile
+from pathlib import Path
+
+import click
+from rich.console import Console
+
+console = Console()
+
+
+def get_addin_path() -> Path:
+    """Get the path to the bundled .addin file."""
+    return Path(__file__).parent.parent / "addin" / "ProExporter.addin"
+
+
+@click.command("install")
+def install_cmd():
+    """Install the ProExporter add-in for ArcGIS Pro.
+    
+    Extracts the bundled add-in and launches the installer.
+    You'll see the ArcGIS Pro Add-In Installation Utility dialog.
+    Click "Install Add-In" to complete installation.
+    """
+    addin_source = get_addin_path()
+    
+    if not addin_source.exists():
+        console.print("[red]✗[/red] Add-in file not found in package.")
+        console.print(f"  Expected: {addin_source}")
+        raise SystemExit(1)
+    
+    # Copy to temp folder (some systems have issues launching from site-packages)
+    temp_dir = Path(tempfile.gettempdir()) / "arcgispro_cli"
+    temp_dir.mkdir(exist_ok=True)
+    
+    addin_dest = temp_dir / "ProExporter.esriAddinX"
+    shutil.copy2(addin_source, addin_dest)
+    
+    console.print("[bold]Installing ProExporter add-in...[/bold]")
+    console.print()
+    console.print(f"  Add-in: {addin_dest}")
+    console.print()
+    
+    # Launch the installer (Windows shell "open" action)
+    try:
+        os.startfile(str(addin_dest))
+        console.print("[green]✓[/green] Add-in installer launched!")
+        console.print()
+        console.print("  [dim]Click 'Install Add-In' in the dialog that appeared.[/dim]")
+        console.print("  [dim]Then restart ArcGIS Pro to use ProExporter.[/dim]")
+    except OSError as e:
+        console.print(f"[red]✗[/red] Failed to launch installer: {e}")
+        console.print()
+        console.print("  Try double-clicking the file manually:")
+        console.print(f"  {addin_dest}")
+        raise SystemExit(1)
+
+
+@click.command("uninstall")
+def uninstall_cmd():
+    """Show instructions for uninstalling the add-in.
+    
+    ArcGIS Pro add-ins must be removed through ArcGIS Pro settings.
+    """
+    console.print("[bold]Uninstalling ProExporter add-in[/bold]")
+    console.print()
+    console.print("  Add-ins are managed in ArcGIS Pro:")
+    console.print()
+    console.print("  1. Open ArcGIS Pro")
+    console.print("  2. Go to [cyan]Project → Add-In Manager[/cyan]")
+    console.print("  3. Find [cyan]ProExporter[/cyan] in the list")
+    console.print("  4. Click [cyan]Delete this Add-In[/cyan]")
+    console.print("  5. Restart ArcGIS Pro")
+    console.print()

arcgispro_cli-0.1.2/arcgispro_cli/commands/open_project.py

@@ -0,0 +1,99 @@
+"""open command - Select active project."""
+
+import click
+from rich.console import Console
+from pathlib import Path
+
+from ..paths import find_arcgispro_folder, find_aprx_files
+
+console = Console()
+
+
+@click.command("open")
+@click.option("--path", "-p", type=click.Path(exists=True), help="Path to search for .aprx files")
+@click.argument("project", required=False)
+def open_cmd(path, project):
+    """Select the active ArcGIS Pro project.
+    
+    If PROJECT is not specified, searches for .aprx files in the
+    current directory and lets you choose.
+    
+    The selected project path is written to .arcgispro/active_project.txt
+    
+    \b
+    Examples:
+        arcgispro open                    # Search and select
+        arcgispro open MyProject.aprx     # Select specific project
+    """
+    search_path = Path(path) if path else Path.cwd()
+    
+    # If project specified directly, use it
+    if project:
+        project_path = Path(project)
+        if not project_path.exists():
+            # Try relative to search path
+            project_path = search_path / project
+        
+        if not project_path.exists():
+            console.print(f"[red]✗[/red] Project not found: {project}")
+            raise SystemExit(1)
+        
+        if not project_path.suffix.lower() == ".aprx":
+            console.print(f"[red]✗[/red] Not an ArcGIS Pro project file: {project}")
+            raise SystemExit(1)
+        
+        _save_active_project(search_path, project_path)
+        return
+    
+    # Search for .aprx files
+    console.print(f"[bold]Searching for .aprx files in:[/bold] {search_path}")
+    console.print()
+    
+    aprx_files = find_aprx_files(search_path)
+    
+    if not aprx_files:
+        console.print("[yellow]No .aprx files found[/yellow]")
+        console.print("  Navigate to a folder containing an ArcGIS Pro project.")
+        raise SystemExit(1)
+    
+    # Show found projects
+    console.print(f"[bold]Found {len(aprx_files)} project(s):[/bold]")
+    console.print()
+    
+    for i, aprx in enumerate(aprx_files, 1):
+        relative = aprx.relative_to(search_path) if aprx.is_relative_to(search_path) else aprx
+        console.print(f"  {i}. {relative}")
+    
+    console.print()
+    
+    # Let user choose
+    if len(aprx_files) == 1:
+        choice = 1
+        console.print(f"[dim]Auto-selecting the only project found.[/dim]")
+    else:
+        choice = click.prompt(
+            "Select project",
+            type=click.IntRange(1, len(aprx_files)),
+            default=1
+        )
+    
+    selected = aprx_files[choice - 1]
+    _save_active_project(search_path, selected)
+
+
+def _save_active_project(base_path: Path, project_path: Path):
+    """Save the selected project to .arcgispro/active_project.txt"""
+    
+    # Create .arcgispro folder if needed
+    arcgispro_folder = base_path / ".arcgispro"
+    arcgispro_folder.mkdir(exist_ok=True)
+    
+    # Write active project
+    active_file = arcgispro_folder / "active_project.txt"
+    active_file.write_text(str(project_path.resolve()), encoding="utf-8")
+    
+    console.print()
+    console.print(f"[green]✓[/green] Active project set to: [cyan]{project_path.name}[/cyan]")
+    console.print(f"  Path: {project_path.resolve()}")
+    console.print()
+    console.print("[dim]Open this project in ArcGIS Pro and run Snapshot to export context.[/dim]")

arcgispro_cli-0.1.2/arcgispro_cli/commands/snapshot.py

@@ -0,0 +1,124 @@
+"""snapshot command - Assemble full snapshot."""
+
+import click
+import shutil
+from rich.console import Console
+from pathlib import Path
+
+from ..paths import (
+    find_arcgispro_folder,
+    load_context_files,
+    list_image_files,
+    get_snapshot_folder,
+    get_images_folder,
+)
+
+console = Console()
+
+
+@click.command("snapshot")
+@click.option("--path", "-p", type=click.Path(exists=True), help="Path to search for .arcgispro folder")
+@click.option("--force", "-f", is_flag=True, help="Overwrite existing snapshot")
+def snapshot_cmd(path, force):
+    """Assemble a complete snapshot from context and images.
+    
+    Verifies that context JSON and images exist, then assembles
+    everything into the snapshot/ folder for AI consumption.
+    
+    The snapshot includes:
+    - context.md: Human-readable summary
+    - CONTEXT_SKILL.md: How to use the exports
+    - AGENT_TOOL_SKILL.md: CLI usage guide  
+    - images/: Copy of exported images
+    """
+    start_path = Path(path) if path else None
+    arcgispro_path = find_arcgispro_folder(start_path)
+    
+    if not arcgispro_path:
+        console.print("[red]✗[/red] No .arcgispro folder found")
+        console.print("  Run the Snapshot export from ArcGIS Pro first.")
+        raise SystemExit(1)
+    
+    console.print(f"[bold]Assembling snapshot from:[/bold] {arcgispro_path}")
+    console.print()
+    
+    # Verify context exists
+    context = load_context_files(arcgispro_path)
+    missing_context = [k for k, v in context.items() if v is None]
+    
+    if missing_context:
+        console.print(f"[yellow]⚠[/yellow] Missing context files: {', '.join(missing_context)}")
+        console.print("  Run 'Dump Context' or 'Snapshot' from ArcGIS Pro.")
+    
+    # Check for images
+    images = list_image_files(arcgispro_path)
+    if not images:
+        console.print("[yellow]⚠[/yellow] No images found")
+        console.print("  Run 'Export Images' or 'Snapshot' from ArcGIS Pro.")
+    
+    # Check if snapshot already exists
+    snapshot_folder = get_snapshot_folder(arcgispro_path)
+    
+    if snapshot_folder.exists():
+        existing_files = list(snapshot_folder.iterdir())
+        if existing_files and not force:
+            console.print(f"[yellow]⚠[/yellow] Snapshot folder already contains {len(existing_files)} items")
+            console.print("  Use --force to overwrite, or delete snapshot/ manually.")
+            raise SystemExit(1)
+    
+    # Check if the add-in already created the snapshot files
+    context_md = snapshot_folder / "context.md"
+    context_skill = snapshot_folder / "CONTEXT_SKILL.md"
+    agent_skill = snapshot_folder / "AGENT_TOOL_SKILL.md"
+    
+    files_created = 0
+    
+    if context_md.exists():
+        console.print(f"[green]✓[/green] context.md exists")
+        files_created += 1
+    else:
+        console.print(f"[yellow]⚠[/yellow] context.md missing (should be created by add-in)")
+    
+    if context_skill.exists():
+        console.print(f"[green]✓[/green] CONTEXT_SKILL.md exists")
+        files_created += 1
+    else:
+        console.print(f"[yellow]⚠[/yellow] CONTEXT_SKILL.md missing")
+    
+    if agent_skill.exists():
+        console.print(f"[green]✓[/green] AGENT_TOOL_SKILL.md exists")
+        files_created += 1
+    else:
+        console.print(f"[yellow]⚠[/yellow] AGENT_TOOL_SKILL.md missing")
+    
+    # Copy images to snapshot folder
+    snapshot_images_folder = snapshot_folder / "images"
+    
+    if images:
+        snapshot_images_folder.mkdir(parents=True, exist_ok=True)
+        
+        copied = 0
+        for img in images:
+            dest = snapshot_images_folder / img.name
+            if not dest.exists() or force:
+                shutil.copy2(img, dest)
+                copied += 1
+        
+        console.print(f"[green]✓[/green] Copied {copied} images to snapshot/images/")
+    
+    console.print()
+    
+    # Summary
+    if files_created >= 2 and images:
+        console.print("[green]✓ Snapshot is ready![/green]")
+        console.print()
+        console.print("[bold]Contents:[/bold]")
+        console.print(f"  {snapshot_folder}/")
+        console.print(f"    context.md         - Human-readable summary")
+        console.print(f"    CONTEXT_SKILL.md   - How to use exports")
+        console.print(f"    AGENT_TOOL_SKILL.md - CLI usage")
+        console.print(f"    images/            - {len(images)} PNG files")
+    else:
+        console.print("[yellow]⚠ Snapshot incomplete[/yellow]")
+        console.print("  Run 'Snapshot' from ArcGIS Pro to generate all files.")
+        raise SystemExit(1)

arcgispro_cli-0.1.2/arcgispro_cli/paths.py

@@ -0,0 +1,161 @@
+"""Utility functions for finding and validating .arcgispro folders."""
+
+import json
+from pathlib import Path
+from typing import Optional, Dict, Any, List
+
+
+def find_arcgispro_folder(start_path: Optional[Path] = None) -> Optional[Path]:
+    """
+    Find the .arcgispro folder by searching current directory and ancestors.
+    
+    Args:
+        start_path: Starting directory to search from. Defaults to cwd.
+        
+    Returns:
+        Path to .arcgispro folder, or None if not found.
+    """
+    if start_path is None:
+        start_path = Path.cwd()
+    
+    current = start_path.resolve()
+    
+    # Search current directory and ancestors
+    while current != current.parent:
+        candidate = current / ".arcgispro"
+        if candidate.is_dir():
+            return candidate
+        current = current.parent
+    
+    # Check root as well
+    candidate = current / ".arcgispro"
+    if candidate.is_dir():
+        return candidate
+    
+    return None
+
+
+def get_context_folder(arcgispro_path: Path) -> Path:
+    """Get the context subfolder path."""
+    return arcgispro_path / "context"
+
+
+def get_images_folder(arcgispro_path: Path) -> Path:
+    """Get the images subfolder path."""
+    return arcgispro_path / "images"
+
+
+def get_snapshot_folder(arcgispro_path: Path) -> Path:
+    """Get the snapshot subfolder path."""
+    return arcgispro_path / "snapshot"
+
+
+def load_json_file(path: Path) -> Optional[Dict[str, Any]]:
+    """
+    Load and parse a JSON file.
+    
+    Args:
+        path: Path to JSON file
+        
+    Returns:
+        Parsed JSON as dict, or None if file doesn't exist or is invalid.
+    """
+    if not path.exists():
+        return None
+    
+    try:
+        with open(path, "r", encoding="utf-8-sig") as f:
+            return json.load(f)
+    except (json.JSONDecodeError, IOError):
+        return None
+
+
+def load_context_files(arcgispro_path: Path) -> Dict[str, Any]:
+    """
+    Load all context JSON files.
+    
+    Args:
+        arcgispro_path: Path to .arcgispro folder
+        
+    Returns:
+        Dict with keys: meta, project, maps, layers, tables, connections, layouts
+        Values are the parsed JSON or None if missing/invalid.
+    """
+    context_dir = get_context_folder(arcgispro_path)
+    
+    return {
+        "meta": load_json_file(arcgispro_path / "meta.json"),
+        "project": load_json_file(context_dir / "project.json"),
+        "maps": load_json_file(context_dir / "maps.json"),
+        "layers": load_json_file(context_dir / "layers.json"),
+        "tables": load_json_file(context_dir / "tables.json"),
+        "connections": load_json_file(context_dir / "connections.json"),
+        "layouts": load_json_file(context_dir / "layouts.json"),
+    }
+
+
+def list_image_files(arcgispro_path: Path) -> List[Path]:
+    """
+    List all PNG files in the images folder.
+    
+    Args:
+        arcgispro_path: Path to .arcgispro folder
+        
+    Returns:
+        List of paths to PNG files.
+    """
+    images_dir = get_images_folder(arcgispro_path)
+    if not images_dir.exists():
+        return []
+    
+    return list(images_dir.glob("*.png"))
+
+
+def get_active_project(arcgispro_path: Path) -> Optional[str]:
+    """
+    Read the active project path from active_project.txt.
+    
+    Args:
+        arcgispro_path: Path to .arcgispro folder
+        
+    Returns:
+        Active project path string, or None if not set.
+    """
+    active_file = arcgispro_path / "active_project.txt"
+    if not active_file.exists():
+        return None
+    
+    try:
+        return active_file.read_text(encoding="utf-8").strip()
+    except IOError:
+        return None
+
+
+def find_aprx_files(directory: Path, max_depth: int = 2) -> List[Path]:
+    """
+    Find .aprx files in directory and subdirectories.
+    
+    Args:
+        directory: Starting directory
+        max_depth: Maximum depth to search
+        
+    Returns:
+        List of paths to .aprx files.
+    """
+    aprx_files = []
+    
+    def search(path: Path, depth: int):
+        if depth > max_depth:
+            return
+        
+        try:
+            for item in path.iterdir():
+                if item.is_file() and item.suffix.lower() == ".aprx":
+                    aprx_files.append(item)
+                elif item.is_dir() and not item.name.startswith("."):
+                    search(item, depth + 1)
+        except PermissionError:
+            pass
+    
+    search(directory, 0)
+    return aprx_files

arcgispro_cli-0.1.2/pyproject.toml

@@ -0,0 +1,50 @@
+[project]
+name = "arcgispro-cli"
+version = "0.1.2"
+description = "CLI tool for inspecting ArcGIS Pro session exports"
+readme = "README.md"
+requires-python = ">=3.9"
+license = {text = "MIT"}
+authors = [
+    {name = "mcveydb"}
+]
+keywords = ["arcgis", "gis", "cli", "esri"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Environment :: Console",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: Microsoft :: Windows",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Scientific/Engineering :: GIS",
+]
+
+dependencies = [
+    "click>=8.0",
+    "rich>=13.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.0",
+    "pytest-cov>=4.0",
+]
+
+[project.scripts]
+arcgispro = "arcgispro_cli.cli:main"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["arcgispro_cli"]
+
+[tool.hatch.build.targets.sdist]
+include = [
+    "arcgispro_cli/**/*",
+]