Skip to content
vibecoder880Public

About

Universal AI Agent Toolkit — 82 agents, 147 skills, 5 MCP servers, 10 platform adapters (Claude Code, Cursor, Windsurf, Cline, Gemini CLI, Codex, OpenCode, Aider, Continue)

Resources

Stars

0 stars

Watchers

0 watching

Forks

Latest commit

 

History

59 Commits

Folders and files

Repository files navigation

Super Kit

Universal AI Agent Toolkit — 82 agents, 147 skills, 5 MCP servers (50 tools) (50 tools), 15 core modules.

Version npm CI Tests License: MIT Node TypeScript

82 agents · 147 skills · 5 MCP servers · 15 core modules · 11 platform adapters.

Quick Start · CLI Reference · Architecture · Configuration · Publishing to npm · Contributing


What is Super Kit?

Super Kit is a universal AI agent toolkit that gives any AI coding assistant — Claude Code, Cursor, Windsurf, Cline, Roo Code, Gemini CLI, Codex, OpenCode, Aider, Continue, or any MCP-compatible platform — instant access to 82 specialized agents organized into 5 teams, with 147 skills and 5 MCP servers for real-world engineering tasks.

The package is designed for local installation — it is distributed as a tarball you build from source and npm install into any project that needs it.


Features

Agents & Skills

  • 82 specialized agents across 5 teams: DEV (development), QA (quality assurance), DATA (data engineering), BIZ (business/marketing), DESIGN (design)
  • 147 skills covering architecture, code review, testing, analytics, ETL, performance, security, accessibility, and more
  • 313 agent shortcuts for fast lookup and slash-command generation
  • YAML-based agent definitions — extend without touching code

Platform Adapters (10 supported)

Platform Adapter Auto-configures
Claude Code claude/ CLAUDE.md, .mcp.json, slash commands
Cursor cursor/ .cursorrules, MCP servers
Windsurf windsurf/ .windsurfrules
Cline cline/ .clinerules, MCP config
Gemini CLI gemini/ GEMINI.md, .gemini/settings.json
Codex codex/ Codex config
OpenCode opencode/ OpenCode settings
Aider aider/ CONVENTIONS.md, .aider.conf.yml
Continue continue/ .continue/config.json
Generic MCP generic/ Any MCP-compatible client

Multi-Model Routing & Cost Arbitrage

  • Model registry with 10+ models across 4 tiers (premium / standard / economy / local)
  • Smart router with 4 strategies: cost, quality, speed, balanced
  • Budget tracking with daily/monthly limits and automatic downgrade on budget pressure
  • Cost-tracker records every call (model, tokens, cost, latency) for analytics

MCP Servers (5 included)

  • filesystem — safe file I/O with path validation, glob search, YAML/JSON read/write
  • git — branch, diff, log, commit, status, blame, stash (read-only by default)
  • database — SQLite / Postgres / MySQL query with schema introspection
  • browser — headless Chromium with screenshots, navigation, interaction
  • vietnam — ⭐ Unique! Zalo messenger integration, Vietnamese NLP, admin data lookup, VND currency conversion

💡 The Vietnam MCP server makes Super Kit the only AI toolkit with native Vietnamese platform support — perfect for projects targeting the Vietnamese market.

Dashboard

Visualize your Super Kit installation in a single self-contained HTML page:

npx tsx cli/src/index.ts dashboard              # Generate + open in browser
npx tsx cli/src/index.ts dashboard -o out.html  # Save to a specific file
npx tsx cli/src/index.ts dashboard --agents-only

The dashboard command (cli/src/commands/dashboard.ts) walks core/agents/ and core/skills/, parses each YAML manifest, and renders a static HTML page showing:

  • Stats — total agents, skills, teams, and skill categories
  • Team breakdown — colored badges per team (dev / qa / data / biz / design)
  • Agent cards — name, role, description, and keyboard shortcut
  • Skill cards — grouped by category
  • Footer — version + GitHub link

Output is saved to ~/.super-kit/dashboard.html by default and opened with xdg-open / open / start. The HTML is fully self-contained (inline CSS, no JavaScript, no external assets), so you can host it on GitHub Pages, email it, or share it as a single file.

💡 Perfect for onboarding new contributors or showing stakeholders what your Super Kit installation contains — no server, no build step, just one HTML file.

Core Modules (15)

core/
├── orchestrator/      # Task routing + workflow DAG execution
├── cost-arbitrage/    # Multi-model registry, smart router, cost tracker
├── marketplace/       # Plugin registry (publish, search, install, rating)
├── memory/            # Persistent agent memory (in-memory + JSONL)
├── schemas/           # Agent/Skill/Workflow YAML schema validation
├── types/             # Shared TypeScript types
├── multi-model/       # Provider adapters (anthropic, openai, google, ...)
├── collaboration/     # Inter-agent messaging (pub/sub, channels)
├── benchmark/         # Performance benchmarks
├── observability/     # Tracing, logging, health checks
└── ...                # 6 more modules

Install

Super Kit is installed from a local tarball. Build the tarball once from this repo, then npm install it into any project.

1. Build the tarball (one-time)

git clone https://github.com/qkhalk/super-kit.git
cd super-kit
npm install
npm run build
npm pack
# → creates super-kit-3.1.0.tgz (~800 KB)

2. Install into a target project

# In any project that needs Super Kit:
npm install /absolute/path/to/super-kit-3.1.0.tgz

For convenience, copy the tarball somewhere stable (e.g. ~/packages/) and reference it from there:

mkdir -p ~/packages
cp super-kit-3.1.0.tgz ~/packages/
# In a project:
npm install ~/packages/super-kit-3.1.0.tgz

3. Verify install

node -e "const {MemoryStore}=require('super-kit/core/memory');const m=new MemoryStore();m.save('check','ok');console.log(m.recall('check'))"
# → ok

Requires Node.js ≥ 18.


Quick Start

Use as a library

import { MemoryStore } from 'super-kit/core/memory';
import { SchemaValidator } from 'super-kit/core/schemas';
import { SmartRouter, ModelRegistry } from 'super-kit/core/cost-arbitrage';
import { TaskRouter, WorkflowEngine } from 'super-kit/core/orchestrator';

// 1. Validate agent YAML definitions
const validator = new SchemaValidator();
const results = validator.validateAllAgents('./agents');
console.log(validator.getSummary(results));

// 2. Store and recall memory
const memory = new MemoryStore();
memory.save('arch-choice', 'Use microservices', { type: 'decision' });
console.log(memory.recall('arch-choice'));

// 3. Route a task to the best agent
const taskRouter = new TaskRouter(/* agent loader, intent classifier */);
const decision = taskRouter.routeByIntent('design a rate limiter');
console.log(decision[0].agent.id, decision[0].confidence);

// 4. Pick the cheapest model that meets a quality bar
const registry = new ModelRegistry();
const smartRouter = new SmartRouter(registry, /* agent map */, /* cost tracker */);
const routing = smartRouter.route('code-review-agent', { prioritize: 'cost' });

Run the CLI

After installing the tarball, the superkit CLI is available inside node_modules/.bin/:

# After npm install /path/to/super-kit-3.1.0.tgz in your project:
./node_modules/.bin/superkit init --platform claude
./node_modules/.bin/superkit agents
./node_modules/.bin/superkit skills
./node_modules/.bin/superkit --help

To use superkit without the ./node_modules/.bin/ prefix, add it to your PATH:

export PATH="$PWD/node_modules/.bin:$PATH"
superkit init --platform claude

Or add it to your shell profile for permanent access in a project directory.

The init command writes the platform-specific rules file (e.g. CLAUDE.md), MCP server registrations, and slash command files into the current project.

Run an MCP server

# Direct invocation from the installed package:
node node_modules/super-kit/dist/core/mcp-servers/filesystem/server.js
node node_modules/super-kit/dist/core/mcp-servers/git/server.js
node node_modules/super-kit/dist/core/mcp-servers/database/server.js
node node_modules/super-kit/dist/core/mcp-servers/browser/server.js
node node_modules/super-kit/dist/core/mcp-servers/vietnam/server.js

Sub-path Imports

Import path What it exports
super-kit Top-level re-exports (MemoryStore, TaskRouter, SmartRouter, ...)
super-kit/core/memory MemoryStore, MemoryEntry, MemoryType
super-kit/core/schemas SchemaValidator, AgentDefinitionSchema, SkillDefinitionSchema
super-kit/core/orchestrator TaskRouter, WorkflowEngine
super-kit/core/cost-arbitrage SmartRouter, ModelRegistry, CostTracker
super-kit/core/marketplace MarketplaceRegistry
super-kit/core/types PlatformType, AgentTeam, TaskStatus
super-kit/core/multi-model Multi-model provider adapters
super-kit/mcp/filesystem Filesystem MCP server
super-kit/mcp/git Git MCP server
super-kit/mcp/database Database MCP server
super-kit/mcp/browser Browser MCP server
super-kit/mcp/vietnam Vietnam MCP server
super-kit/adapters/claude Claude Code adapter
super-kit/adapters/cursor Cursor adapter
... and 5 more adapters See package.json exports field

CLI Reference

superkit init [options]              # Initialize platform config in current project
superkit agents list                 # List all 82 agents
superkit agents show <id>            # Show agent details
superkit skills list                 # List all skills
superkit workflow run <file>         # Execute a workflow YAML
superkit marketplace search <query>  # Search community plugins
superkit marketplace install <id>    # Install a plugin
superkit memory search <query>       # Search agent memory
superkit cost report                 # Show cost report (daily / monthly)
superkit doctor                      # Diagnose installation issues

All commands support --help for full option list.


Architecture

Request flow

User input
   │
   ▼
Platform (Claude / Cursor / Gemini / ...)
   │
   ▼
Slash command / Agent invocation
   │
   ▼
TaskRouter ─────► Command match? ─────► Direct agent
   │
   ▼
Intent scoring (82 agents × keywords × weights)
   │
   ▼
Top agent (with confidence) + alternatives
   │
   ▼
SmartRouter ────► Model selection (cost / quality / speed / balanced)
   │
   ▼
Provider (anthropic / openai / google / kimi / glm / local)
   │
   ▼
Result → AgentMemory → CostTracker → Metrics

Workflow execution

Workflow YAML
   │
   ▼
WorkflowEngine.execute()
   │
   ├── parallel: true  → run ready steps via Promise.allSettled
   │                     (steps with met deps run concurrently)
   │
   └── parallel: false → run sequentially
                        (skip step if deps not met)
   │
   ▼
Step results → context Map → next iteration

Memory

Agent save(key, value)
   │
   ▼
MemoryStore (in-memory Map) ──► auto-flush to JSONL
   │
   ▼
Persistent file: ~/.super-kit/memory/memory.jsonl

Configuration

Environment variables

Variable Description Default
SUPERKIT_HOME Super Kit home directory ~/.super-kit
SUPERKIT_LOG_LEVEL Log level (debug, info, warn, error) info
ANTHROPIC_API_KEY Anthropic API key for Claude models —
OPENAI_API_KEY OpenAI API key for GPT models —
GOOGLE_API_KEY Google API key for Gemini models —
KIMI_API_KEY Moonshot API key for Kimi models —
GLM_API_KEY Zhipu API key for GLM models —
GROK_API_KEY xAI API key for Grok models —
SUPERKIT_BUDGET_DAILY Daily budget in USD 5.00
SUPERKIT_BUDGET_MONTHLY Monthly budget in USD 100.00

Config file

# ~/.super-kit/config.yaml
budget:
  daily: 5.00
  monthly: 100.00
routing:
  default: balanced
  fallback: cost
memory:
  defaultTtlMs: 86400000  # 24 hours
  persistPath: ~/.super-kit/memory
models:
  preferLocal: false
  preferProvider: anthropic

Repository Layout

super-kit/
├── core/                 # Core TypeScript modules (15)
├── adapters/             # Platform adapters (10)
├── cli/                  # CLI entry point
├── docs/                 # Additional documentation
├── examples/             # Example workflows and agents
├── scripts/              # Build / dev scripts
├── .github/workflows/    # CI / CD
├── package.json
├── tsconfig.json
├── vitest.config.ts
└── README.md

Development

Build

npm install
npm run build          # Compile TypeScript → dist/
npm run dev            # Watch mode (tsx)

Test

npm test                            # Full suite
npm test -- --run                   # CI mode (no watch)
npm test -- core/__tests__/router   # Single file

Lint

npm run lint           # ESLint
npx tsc --noEmit       # Type check only

Add a new agent

  1. Create core/agents/<team>/<your-agent>.yaml — see core/agents/dev/architect.yaml for example
  2. Run npm run lint to validate
  3. Add tests in core/__tests__/agents.test.ts if needed

Add a new platform adapter

  1. Create adapters/<platform>/index.ts extending BaseAdapter
  2. Implement required methods: generateRulesContent, generateMCPConfig, postInstall
  3. Register in adapters/index.ts
  4. Add tests

Contributing

Contributions welcome. Please:

  1. Fork the repo
  2. Create a feature branch (git checkout -b feature/my-change)
  3. Add tests for new functionality
  4. Run npm test && npm run lint before committing
  5. Open a pull request

For major changes, open an issue first to discuss.


Publishing to npm

Status (v3.2.0): Build is green, package metadata is complete, and the npm name super-kit is available on the public registry. This section documents the exact steps to publish.

Prerequisites

  1. An npm account with publish rights for the package name (or its scoped variant).
  2. Two-factor authentication enabled (recommended).
  3. NODE_AUTH_TOKEN exported (or run npm login first).
  4. Node.js ≥ 18 and npm ≥ 9.

Package metadata checklist

The package.json for super-kit@3.2.0 is already configured with:

Field Value
name super-kit
version 3.2.0
description Universal AI Agent Toolkit — 82 agents, 147 skills, ...
keywords ai, agent, mcp, toolkit, claude, cursor, windsurf, cline, ...
author tqk09 <qkhalk@users.noreply.github.com>
license MIT
repository git+https://github.com/qkhalk/super-kit.git
homepage https://github.com/qkhalk/super-kit#readme
bugs https://github.com/qkhalk/super-kit/issues
engines.node >=18.0.0
bin superkit → ./dist/cli/index.js
exports Library sub-paths + per-adapter + MCP servers
prepublishOnly npm run lint && npm test -- --run && npm run build
files dist, README.md, LICENSE, CHANGELOG.md, core, adapters, cli (+ test/.ts excludes)

Step-by-step publish

# 1. Authenticate (one-time per machine / CI runner)
npm login                       # interactive, or set NPM_TOKEN env var
npm whoami                      # confirm identity

# 2. Verify the registry sees the name as available
npm view super-kit name         # should 404 (means available for a fresh publish)
npm view super-kit version      # if this prints, someone owns it — see fallback below

# 3. Make sure working tree is clean and on the release tag
git checkout main
git pull --rebase origin main
git status                      # nothing uncommitted
git tag v3.2.0 --list           # confirm tag exists (it does for v3.2.0)

# 4. Pre-flight (this also runs automatically via `prepublishOnly`)
npm ci
npm run lint
npm test -- --run
npm run build

# 5. Inspect what will ship
npm pack --dry-run              # 943 files → super-kit-3.2.0.tgz (~853 KB)

# 6. Dry-run the publish itself (no actual upload)
npm publish --dry-run           # validates auth + tarball + access

# 7. Real publish (with OTP if 2FA enabled)
npm publish --access public --otp=123456

# 8. Verify on the registry
npm view super-kit
npm view super-kit versions

npm pack --dry-run summary (v3.2.0)

  • Tarball: super-kit-3.2.0.tgz
  • Package size: 853.1 kB (unpacked 4.0 MB)
  • Total files: 943
  • Includes: everything under dist/, core/, adapters/, cli/, README.md, LICENSE, CHANGELOG.md
  • Excludes: *.test.ts, *.spec.ts, **/__tests__/**, **/__test_plugins__/**, .env*, secrets, runtime caches, .super-kit/, etc. (per files + .npmignore)

Fallback: if super-kit is taken

If someone publishes super-kit between this readiness check and the real publish, pick one of these pre-validated alternatives:

Candidate name npm registry status (2026-06-22) Notes
superkit 404 (available) Drop the hyphen, classic fallback
@qkhalk/super-kit 404 (available) Scoped under npm user qkhalk
superkit-cli taken (superkit-cli@1.0.0) ❌ do not use
superkit-core check before use Run npm view superkit-core
universal-agent-kit check before use More descriptive

To switch, edit package.json → name (and the bin.superkit path if relevant), then re-run npm pack --dry-run and npm publish --dry-run. For a scoped package, also add a publishConfig:

{
  "publishConfig": {
    "access": "public"
  }
}

Unpublish / deprecate

# Deprecate a version (preferred over unpublish)
npm deprecate super-kit@3.2.0 "use 3.2.1 instead"

# Unpublish (only within 72h of publish per npm policy)
npm unpublish super-kit@3.2.0

CI publishing (GitHub Actions example)

name: publish
on:
  push:
    tags: [ "v*.*.*" ]
jobs:
  publish:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with: { node-version: 20, registry-url: https://registry.npmjs.org/ }
      - run: npm ci
      - run: npm run lint && npm test -- --run && npm run build
      - run: npm publish --access public
        env:
          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}


License

MIT — see LICENSE.


Acknowledgments

Built on:

Inspired by:

  • Claude Code (slash commands, sub-agents)
  • Cursor Agents
  • OpenHands
  • Continue
  • AutoGPT

Maintainers: Tran Quoc Khanh (@tqk09) Status: Active development

About

Universal AI Agent Toolkit — 82 agents, 147 skills, 5 MCP servers, 10 platform adapters (Claude Code, Cursor, Windsurf, Cline, Gemini CLI, Codex, OpenCode, Aider, Continue)

Resources

Stars

0 stars

Watchers

0 watching

Forks

Releases

Packages

Contributors

Languages