APC — AI Personal Context Manager

Collect, unify, and sync AI tool configurations across Claude Code, Cursor, Gemini CLI, GitHub Copilot, Windsurf, and OpenClaw.

Why APC?

You use multiple AI coding tools. Each one stores skills, MCP server configs, and memory in its own format, in its own directory. When you switch tools or set up a new machine, you lose everything — or spend hours copying files around.

APC fixes this. It extracts your configs from every installed tool into a single local cache, then syncs them back out to any combination of targets. Skills, MCP servers, memory, API keys — all managed from one CLI. No cloud account required.

At a Glance

$ apc status

  ╭─ Detected Tools ────────────────────╮
  │  claude-code      synced            │
  │  cursor           synced            │
  │  gemini-cli       not synced        │
  │  github-copilot   synced            │
  ╰─────────────────────────────────────╯

  ╭─ Local Cache ───────────────────────╮
  │  Skills        12                   │
  │  MCP Servers    4                   │
  │  Memory         7                   │
  ╰─────────────────────────────────────╯

  LLM: anthropic/claude-sonnet-4-6 (1 auth profile(s))

Features

Multi-tool sync — extract and apply skills, MCP servers, and memory across 6 supported AI tools
MCP server management — sync Model Context Protocol server configs between tools with secret redaction and OS keychain storage
Skill installation — install reusable instruction snippets directly from GitHub repositories
LLM-powered memory sync — transform and merge memory entries across tools using any configured LLM provider
Offline-first — no cloud account or login required; everything runs locally
Smart conflict resolution — detects overlapping configs from multiple tools and lets you choose
Manifest tracking — tracks what APC wrote vs. what you changed, so user edits are never overwritten

Supported Tools

Claude Code, Cursor, Gemini CLI, GitHub Copilot, Windsurf, and OpenClaw.

Installation

pip (recommended)

pip install git+https://github.com/FZ2000/apc-cli.git

One-liner

curl -fsSL https://raw.githubusercontent.com/FZ2000/apc-cli/main/install.sh | bash

This clones the repo to ~/.apc-cli, creates a venv, and symlinks apc into ~/.local/bin.

Quick Start

# 1. Extract configs from all installed AI tools into the local cache
apc collect

# 2. See what was collected
apc status

# 3. Sync everything to all your tools
apc sync

# 4. Or sync to specific tools only
apc sync --tools cursor,gemini-cli

# 5. Install skills from a GitHub repo
apc install owner/repo --skill my-skill

# 6. Add a memory entry manually
apc memory add "Always use TypeScript strict mode"

# 7. Set up an LLM provider for memory sync
apc configure

Command Reference

CLI Basics

# Check the installed version
apc --version
# apc, version 0.1.1

Core Workflow

Command	Description
`apc collect`	Extract skills, MCP servers, and memory from installed AI tools
`apc status`	Show detected tools and local cache summary
`apc sync`	Sync all cached configs to target tools

Options for collect:

Flag	Description
`--tools <list>`	Comma-separated tool list (e.g., `claude-code,cursor`)
`--no-memory`	Skip collecting memory entries
`--yes`, `-y`	Skip confirmation prompts

Options for sync:

Flag	Description
`--tools <list>`	Comma-separated tool list (e.g., `cursor,gemini-cli`)
`--all`	Apply to all detected tools without prompting
`--no-memory`	Skip memory entries
`--override-mcp`	Replace existing MCP servers instead of merging
`--dry-run`	Show files that would be written without writing
`--yes`, `-y`	Skip confirmation prompts

Skills

Command	Description
`apc skill list`	List all skills in the cache
`apc skill show [name]`	View full skill details with pagination
`apc skill sync`	Sync skills to target tools

Install

Command	Description
`apc install <repo>`	Install skills from a GitHub repository
`apc install <repo> --list`	List available skills in the repo
`apc install <repo> --skill <name>`	Install a specific skill
`apc install <repo> --all`	Install all skills from the repo

Options:

Flag	Description
`--skill`, `-s`	Skill name(s) to install (repeatable, or `'*'` for all)
`--branch`	Git branch to fetch from (default: `main`)
`--list`	List available skills without installing
`--yes`, `-y`	Skip confirmation prompts

Memory

Command	Description
`apc memory list`	List all memory entries
`apc memory show`	View full memory details with pagination
`apc memory add "<text>"`	Add a memory entry manually
`apc memory sync`	Sync memory to target tools via LLM

MCP Servers

Command	Description
`apc mcp list`	List cached MCP server configs
`apc mcp sync`	Sync MCP servers to target tools
`apc mcp remove <name>`	Remove an MCP server from the cache

Export / Import

Command	Description
`apc export [path]`	Export configs to a portable directory with age-encrypted secrets
`apc import [path]`	Import configs from an export directory, decrypting secrets

Options:

Flag	Description
`--no-secrets`	Skip secret encryption/decryption
`--yes`, `-y`	Skip confirmation prompts

Workflow: export on machine A, commit the directory to a private repo, pull on machine B, import. Transfer ~/.apc/age-identity.txt (private key) to the target machine once via a secure channel. Secrets stay safe even if the repo becomes public.

LLM Configuration

Command	Description
`apc configure`	Interactive LLM provider setup wizard
`apc model status`	Show default model and auth profiles
`apc model list`	List configured providers and models
`apc model set <provider/model>`	Set the default model
`apc model auth add`	Add an auth profile
`apc model auth remove <key>`	Remove an auth profile

How It Works

┌──────────────┐     collect     ┌──────────────┐      sync      ┌──────────────┐
│  Claude Code │─────────────┐   │              │   ┌────────────│  Claude Code │
│  Cursor      │─────────────┤   │  Local Cache │   ├────────────│  Cursor      │
│  Gemini CLI  │─────────────┤──▶│  (~/.apc/)   │──▶├────────────│  Gemini CLI  │
│  Copilot     │─────────────┤   │              │   ├────────────│  Copilot     │
│  Windsurf    │─────────────┤   │              │   ├────────────│  Windsurf    │
│  OpenClaw    │─────────────┘   └──────────────┘   └────────────│  OpenClaw    │
└──────────────┘                                                 └──────────────┘
     Extract                     Skills + MCP +                       Apply
                                 Memory + Secrets

Data flow:

Extract — apc collect scans installed tools, pulls out skills, MCP server configs, and memory files
Cache — everything is stored in ~/.apc/ as JSON; secrets are redacted and stored in the OS keychain
Sync — apc sync writes configs to target tools in their native formats, using manifests to track changes

Directory Structure

~/.apc/
├── cache/
│   ├── skills.json          # Collected skills from all tools
│   ├── mcp_servers.json     # Collected MCP server configs
│   └── memory.json          # Collected memory entries
├── skills/                  # Installed skills (source of truth)
│   └── <skill-name>/
│       └── SKILL.md
├── manifests/               # Per-tool sync tracking
├── auth-profiles.json       # LLM API credentials
├── models.json              # Model preferences
└── age-identity.txt         # Age private key (export/import encryption)

Configuration

LLM Providers

Memory sync uses an LLM to transform entries into each tool's native format. APC supports multiple providers:

Interactive setup:

apc configure

Non-interactive setup:

# Anthropic
apc configure --provider anthropic --api-key "$ANTHROPIC_API_KEY"

# OpenAI
apc configure --provider openai --api-key "$OPENAI_API_KEY"

# Google Gemini
apc configure --provider gemini --api-key "$GEMINI_API_KEY"

# Custom / local (Ollama, vLLM, LM Studio)
apc configure --provider custom --base-url "http://localhost:11434/v1" \
  --model-id "llama-3"

Supported LLM providers: Anthropic, OpenAI, Google Gemini, Qwen (Alibaba), GLM (Zhipu), MiniMax, Kimi (Moonshot), and any OpenAI-compatible or Anthropic-compatible endpoint.

Shell Completion

APC is built on Click which has built-in shell completion support.

# Bash — add to ~/.bashrc
echo 'eval "$(_APC_COMPLETE=bash_source apc)"' >> ~/.bashrc

# Zsh — add to ~/.zshrc
echo 'eval "$(_APC_COMPLETE=zsh_source apc)"' >> ~/.zshrc

# Fish — add to ~/.config/fish/completions/apc.fish
echo 'eval (env _APC_COMPLETE=fish_source apc)' >> ~/.config/fish/completions/apc.fish

Reload your shell (source ~/.bashrc / source ~/.zshrc) after adding the line.

Development

# Clone and install
git clone https://github.com/FZ2000/apc-cli.git
cd apc-cli
python -m venv .venv
source .venv/bin/activate
pip install -e ".[dev]"

# Run tests
pytest -v

# Lint and format
ruff check src/ tests/
ruff format --check src/ tests/

# Run integration tests in Docker
docker build -t apc-test -f tests/Dockerfile .
docker run --rm apc-test

Contributing

Contributions are welcome. Please open an issue to discuss your idea before submitting a PR.

Follow the existing code style (ruff for linting and formatting)
Add tests for new functionality
Keep commits focused and atomic

License

MIT

GeezerVison

Latest commit

History

Folders and files

Repository files navigation

APC — AI Personal Context Manager

Why APC?

At a Glance

Features

Supported Tools

Installation

pip (recommended)

One-liner

Quick Start

Command Reference

CLI Basics

Core Workflow

Skills

Install

Memory

MCP Servers

Export / Import

LLM Configuration

How It Works

Directory Structure

Configuration

LLM Providers

Shell Completion

Development

Contributing

License

About

Topics

Resources

Contributing

Stars

Watchers

Forks

Releases

Packages

Used by

Contributors

Languages