GitMap Skill
Version control for ArcGIS web maps — exposed as native OpenClaw tools.
About this skill
GitMap is an AI agent skill that brings robust, Git-like version control capabilities to ArcGIS Online and Enterprise Portal web maps. It operates by wrapping the `gitmap` command-line interface, exposing its core functionalities such as branching, committing, diffing, pushing, and pulling as direct AI-callable tools. This allows AI agents to programmatically manage the lifecycle of web maps, ensuring changes are tracked, auditable, and easily revertable. The skill is designed for scenarios where consistent and automated management of ArcGIS web maps is crucial. It supports map discovery, viewing commit history, saving current map states, creating and switching branches for different versions, comparing map changes, and synchronizing these versions with the live ArcGIS Portal. It requires the `gitmap-core` Python package and environment variables for ArcGIS credentials. Developers and GIS professionals can leverage GitMap to integrate advanced version control directly into their AI-driven workflows. This simplifies map deployment, facilitates collaborative map development, and provides a safety net for critical web map configurations by offering a clear history of changes and the ability to revert to previous states.
Best use case
The primary use case for GitMap is the automated and version-controlled management of ArcGIS web maps. It enables AI agents to handle tasks such as tracking changes to web maps, deploying specific map versions, branching for experimental map configurations, and maintaining an auditable history of all modifications within ArcGIS Online or Enterprise Portal. This skill particularly benefits GIS administrators, developers, and organizations that require robust change management and automation for their critical geospatial web applications.
Version control for ArcGIS web maps — exposed as native OpenClaw tools.
Users should expect a version-controlled, auditable history of their ArcGIS web maps, enabling efficient management and deployment directly through AI agent commands.
Practical example
Example input
List all web maps owned by 'mygisadmin', then commit a change to 'My Project Map' with a message about symbology updates. Agent Tool Calls: `gitmap_list(owner='mygisadmin')` `gitmap_commit(map_id='<map_id_from_list>', message='Updated symbology for Q3 data')`
Example output
Agent Response for `gitmap_list`:
`[{'id': 'a1b2c3d4e5', 'title': 'My Project Map', 'owner': 'mygisadmin', 'lastModified': '2023-10-26T10:00:00'}, ...]`
Agent Response for `gitmap_commit`:
`'Successfully committed map "My Project Map" (a1b2c3d4e5) with commit ID: "abcdef12345".'`When to use this skill
- To apply Git-like version control to ArcGIS Online or Enterprise Portal web maps.
- When you need to automate the deployment, updates, or configuration management of ArcGIS web maps.
- To track and audit all changes made to your critical geospatial web maps.
- When collaborating on ArcGIS web map development and requiring clear branching and merging capabilities.
When not to use this skill
- For managing ArcGIS data layers (feature services, image services) rather than web maps themselves.
- If you are not working with ArcGIS Online or Enterprise Portal environments.
- When only performing infrequent, simple manual updates to web maps that don't require version control.
- For general Git operations on code or documents not related to ArcGIS web maps.
Installation
Claude Code / Cursor / Codex
Manual Installation
- Download SKILL.md from GitHub
- Place it in
.claude/skills/gitmap/SKILL.mdinside your project - Restart your AI agent — it will auto-discover the skill
How GitMap Skill Compares
| Feature / Agent | GitMap Skill | Standard Approach |
|---|---|---|
| Platform Support | Not specified | Limited / Varies |
| Context Awareness | High | Baseline |
| Installation Complexity | easy | N/A |
Frequently Asked Questions
What does this skill do?
Version control for ArcGIS web maps — exposed as native OpenClaw tools.
How difficult is it to install?
The installation complexity is rated as easy. You can find the installation instructions above.
Where can I find the source code?
You can find the source code on GitHub using the link provided at the top of the page.
Related Guides
AI Agents for Coding
Browse AI agent skills for coding, debugging, testing, refactoring, code review, and developer workflows across Claude, Cursor, and Codex.
Cursor vs Codex for AI Workflows
Compare Cursor and Codex for AI coding workflows, repository assistance, debugging, refactoring, and reusable developer skills.
Top AI Agents for Productivity
See the top AI agent skills for productivity, workflow automation, operational systems, documentation, and everyday task execution.
SKILL.md Source
# GitMap Skill
Version control for ArcGIS web maps — exposed as native OpenClaw tools.
## Overview
GitMap provides Git-like version control for ArcGIS Online and Enterprise Portal web maps. This skill wraps the `gitmap` CLI as thin subprocess calls, exposing branch, commit, diff, push/pull, and map discovery as callable tools.
**8 tools** | Thin CLI wrapper | No local database | Requires: `gitmap-core` Python package
---
## Prerequisites
### Install GitMap Core
```bash
pip install gitmap-core
```
### Configure Credentials
Set the following environment variables:
```bash
export PORTAL_URL="https://your-org.maps.arcgis.com"
export ARCGIS_USERNAME="your_username"
export ARCGIS_PASSWORD="your_password"
```
**Security Note:** Prefer using scoped API tokens over plaintext passwords when possible.
---
## Required environment variables
- **PORTAL_URL**: Your ArcGIS Portal or AGOL URL (e.g., `https://myorg.maps.arcgis.com`)
- **ARCGIS_USERNAME**: Portal username
- **ARCGIS_PASSWORD**: Portal password (prefer scoped API tokens over plaintext passwords)
---
## Tools
### Discovery & Status
- `gitmap_list` — List available web maps from Portal (with optional filters)
- `gitmap_status` — Show working tree status for a local GitMap repo
- `gitmap_log` — View commit history for a repo
### Versioning
- `gitmap_commit` — Commit current map state with a message
- `gitmap_branch` — List or create branches in a repo
- `gitmap_diff` — Show changes between commits or branches
### Portal Sync
- `gitmap_push` — Push committed changes to ArcGIS Portal
- `gitmap_pull` — Pull latest map from ArcGIS Portal
---
## Tool Reference
### `gitmap_list`
Discover web maps in Portal.
```python
gitmap_list(
query=None, # Search query (e.g., "title:MyMap")
owner=None, # Filter by owner username
tag=None, # Filter by tag
max_results=50, # Max results to return
portal_url=None, # Portal URL (or use PORTAL_URL env var)
username=None, # Portal username (or ARCGIS_USERNAME env var)
password=None, # Portal password (or ARCGIS_PASSWORD env var)
cwd=None, # Working directory (default: home)
)
```
### `gitmap_status`
Show repo status.
```python
gitmap_status(
cwd, # Path to GitMap repository (required)
)
```
### `gitmap_commit`
Commit current changes.
```python
gitmap_commit(
message, # Commit message (required)
cwd, # Path to GitMap repository (required)
author=None, # Override commit author
)
```
### `gitmap_branch`
List or create branches.
```python
gitmap_branch(
cwd, # Path to GitMap repository (required)
name=None, # Branch name to create (omit to list)
delete=False, # Delete the named branch
)
```
### `gitmap_diff`
Show changes between versions.
```python
gitmap_diff(
cwd, # Path to GitMap repository (required)
branch=None, # Compare with this branch
commit=None, # Compare with this commit hash
)
```
### `gitmap_push`
Push changes to Portal.
```python
gitmap_push(
cwd, # Path to GitMap repository (required)
branch=None, # Branch to push (default: current)
portal_url=None, # Portal URL
username=None, # Portal username
password=None, # Portal password
)
```
### `gitmap_pull`
Pull changes from Portal.
```python
gitmap_pull(
cwd, # Path to GitMap repository (required)
branch=None, # Branch to pull (default: current)
portal_url=None, # Portal URL
username=None, # Portal username
password=None, # Portal password
)
```
### `gitmap_log`
View commit history.
```python
gitmap_log(
cwd, # Path to GitMap repository (required)
branch=None, # Branch to show log for
limit=None, # Max commits to show
)
```
---
## Usage Examples
### Discover Maps and Clone
```python
# Find maps owned by a user
gitmap_list(owner="john.doe", max_results=20)
# → returns table of maps with item IDs
# Then clone manually:
# cd ~/maps && gitmap clone <item_id>
```
### Typical Edit → Commit → Push Loop
```python
# Check what changed
gitmap_status(cwd="~/maps/MyWebMap")
# Commit changes
gitmap_commit(message="Updated layer symbology", cwd="~/maps/MyWebMap")
# Push to Portal
gitmap_push(cwd="~/maps/MyWebMap")
```
### Feature Branch Workflow
```python
# List branches
gitmap_branch(cwd="~/maps/MyWebMap")
# Create a feature branch
gitmap_branch(name="feature/new-basemap", cwd="~/maps/MyWebMap")
# After editing, commit and push feature branch
gitmap_commit(message="Added satellite basemap", cwd="~/maps/MyWebMap")
gitmap_push(cwd="~/maps/MyWebMap", branch="feature/new-basemap")
```
### Review History
```python
# Recent commits
gitmap_log(cwd="~/maps/MyWebMap", limit=10)
# What changed since main?
gitmap_diff(cwd="~/maps/MyWebMap", branch="main")
```
---
## Server
HTTP server at `localhost:7400` (when running):
```bash
python server.py
```
Endpoints:
- `POST /tools/{tool_name}` — Call a tool with JSON body
- `GET /health` — Health check
---
## Installation
**Install command:**
```bash
pip install gitmap-core
```
The skill uses the `gitmap_core` Python package directly for API access.
---
## Notes & Known Limitations
- **Working directory is required** for most commands — GitMap repos are directory-based like Git.
- **Portal credentials** can be passed per-call or via environment variables (PORTAL_URL, ARCGIS_USERNAME, ARCGIS_PASSWORD).
- **`gitmap list`** doesn't require a local repo — it queries Portal directly.
- **Output is raw CLI text** — parsed lightly for structured responses where possible.
NOT implement `clone`, `init`,- This skill does `merge`, `checkout`, `l`, or `setupsm`, `context-repos` — call the CLI directly for those.
---
## Related
- GitMap Project: https://github.com/14-TR/gitmapRelated Skills
botlearn-healthcheck
botlearn-healthcheck — BotLearn autonomous health inspector for OpenClaw instances across 5 domains (hardware, config, security, skills, autonomy); triggers on system check, health report, diagnostics, or scheduled heartbeat inspection.
Incident Postmortem Generator
Generate blameless incident postmortems from raw notes, Slack threads, or bullet points.
Post-Mortem & Incident Review Framework
Run structured post-mortems that actually prevent repeat failures. Blameless analysis, root cause identification, and action tracking.
afrexai-performance-engineering
Complete performance engineering system — profiling, optimization, load testing, capacity planning, and performance culture. Use when diagnosing slow applications, optimizing code/queries/infrastructure, load testing before launch, planning capacity, or building performance into CI/CD. Covers Node.js, Python, Go, Java, databases, APIs, and frontend.
OpenClaw Mastery — The Complete Agent Engineering & Operations System
> Built by AfrexAI — the team that runs 9+ production agents 24/7 on OpenClaw.
Legacy System Modernization Engine
Complete methodology for assessing, planning, and executing legacy system modernization — from monolith decomposition to cloud migration. Works for any tech stack, any scale.
Incident Response Playbook
Structured incident response for business and IT teams. Guides you through detection, triage, containment, resolution, and post-mortem — with auto-generated timelines and action items.
Git Engineering & Repository Strategy
You are a Git Engineering expert. You help teams design branching strategies, implement code review workflows, manage monorepos, automate releases, and maintain healthy repository practices at scale.
Django Production Engineering
Complete methodology for building, scaling, and operating production Django applications. From project structure to deployment, security to performance — every decision framework a Django team needs.
IT Disaster Recovery Plan Generator
Build production-ready disaster recovery plans that actually get followed when things break.
afrexai-api-architect
Design, build, test, document, and secure production-grade APIs. Covers the full lifecycle from schema design through deployment, monitoring, and versioning. Use when designing new APIs, reviewing existing ones, generating OpenAPI specs, building test suites, or debugging production issues.
Agent Ops Runbook
Generate a production-ready operations runbook for deploying AI agents. Covers pre-deployment checklists, shadow mode → supervised → autonomous rollout stages, monitoring dashboards, rollback procedures, cost management, and incident response templates.