feat: add SkillKit extension with 9 tools for cross-agent skill management

- Add @moltbot/skillkit extension with tools:
  - skillkit_search: Search 15,000+ skills marketplace
  - skillkit_install: Install skills with auto-translation
  - skillkit_translate: Translate between 17 AI agents
  - skillkit_recommend: Project-aware skill recommendations
  - skillkit_sync: Team skill synchronization
  - skillkit_list: List available/installed skills
  - skillkit_context: Analyze project context
  - skillkit_publish: Publish skills to marketplace
  - skillkit_memory: Manage skill preferences

- Add docs/tools/skillkit.md with full documentation
- Fix memory-core missing devDependencies (upstream bug)
- Regenerate pnpm-lock.yaml for CI compatibility

SkillKit v1.7.2: https://agenstskills.com

docs/tools/skillkit.md

@@ -0,0 +1,203 @@
+---
+summary: "SkillKit: cross-agent skill management CLI for 17 AI coding agents"
+read_when:
+  - Porting skills from other AI coding agents to Moltbot
+  - Managing skills across multiple AI agents
+  - Looking for cross-agent skill portability
+---
+
+# SkillKit
+
+SkillKit is a **universal CLI for managing AI agent skills** across 17 different coding agents. It provides cross-agent skill portability, team collaboration features, and smart project-aware recommendations. While ClawdHub is the Moltbot-specific skill registry, SkillKit enables you to translate and sync skills from other AI agents like Cursor, Claude Code, Codex, and more.
+
+**Current version**: v1.7.2
+
+Website: [agenstskills.com](https://agenstskills.com)
+
+GitHub: [github.com/rohitg00/skillkit](https://github.com/rohitg00/skillkit)
+
+npm: [npmjs.com/package/skillkit](https://www.npmjs.com/package/skillkit)
+
+GitHub Packages: [github.com/rohitg00/skillkit/pkgs/npm/skillkit](https://github.com/rohitg00/skillkit/pkgs/npm/skillkit)
+
+## Why use SkillKit with Moltbot
+
+SkillKit complements Moltbot and ClawdHub by solving cross-agent workflows:
+
+- **Skill portability**: Translate skills from Cursor, Claude Code, Codex, or other agents into Moltbot-compatible format.
+- **Team collaboration**: Share skill configurations across your team with sync and import/export workflows.
+- **Smart recommendations**: Get project-aware skill suggestions based on your codebase.
+- **Multi-agent workflows**: Manage skills for multiple AI agents from a single CLI.
+- **Marketplace access**: Browse 15,000+ skills from curated sources.
+
+If you only use Moltbot, ClawdHub is the primary registry. If you work with multiple AI coding agents, SkillKit bridges the gap.
+
+## Install the CLI
+
+```bash
+# npm (recommended)
+npm install -g skillkit
+
+# pnpm
+pnpm add -g skillkit
+
+# npx (no install)
+npx skillkit --help
+
+# GitHub Packages
+npm install -g @rohitg00/skillkit --registry=https://npm.pkg.github.com
+```
+
+## Available Tools
+
+The SkillKit extension provides 9 tools for Moltbot:
+
+### skillkit_search
+
+Search the SkillKit marketplace for AI agent skills.
+
+```
+skillkit_search(query: "react testing", agent: "cursor", limit: 10)
+```
+
+### skillkit_install
+
+Install a skill from the marketplace.
+
+```
+skillkit_install(skill: "typescript-strict", agent: "clawdbot")
+```
+
+### skillkit_translate
+
+Translate skills between different AI agent formats.
+
+```
+skillkit_translate(skill: "./cursor-rules", from: "cursor", to: "clawdbot", recursive: true)
+```
+
+### skillkit_recommend
+
+Get smart skill recommendations based on your project.
+
+```
+skillkit_recommend(path: "./my-project", limit: 5)
+```
+
+### skillkit_sync
+
+Sync skills between local and remote configurations.
+
+```
+skillkit_sync(direction: "push", agent: "clawdbot")
+```
+
+### skillkit_list
+
+List available or installed skills.
+
+```
+skillkit_list(agent: "clawdbot", installed: true)
+```
+
+### skillkit_context
+
+Analyze project context for intelligent recommendations.
+
+```
+skillkit_context(path: "./my-project", format: "json")
+```
+
+### skillkit_publish
+
+Publish a skill to the SkillKit marketplace.
+
+```
+skillkit_publish(path: "./my-skill", name: "awesome-skill")
+```
+
+### skillkit_memory
+
+Manage SkillKit memory for persisting preferences.
+
+```
+skillkit_memory(action: "save", key: "preferred_agent", value: "clawdbot")
+```
+
+## Supported Agents
+
+SkillKit supports 17 AI coding agents:
+
+| Agent | Format | Native Support |
+|-------|--------|----------------|
+| Claude Code | CLAUDE.md | ✅ |
+| Cursor | .cursorrules | ✅ |
+| Codex | AGENTS.md | ✅ |
+| Gemini CLI | GEMINI.md | ✅ |
+| OpenCode | OPENCODE.md | ✅ |
+| Antigravity | .antigravity | ✅ |
+| Amp | AMP.md | ✅ |
+| Clawdbot/Moltbot | SKILL.md | ✅ |
+| Droid | DROID.md | ✅ |
+| GitHub Copilot | .github/copilot | ✅ |
+| Goose | .goose | ✅ |
+| Kilo | KILO.md | ✅ |
+| Kiro CLI | .kiro | ✅ |
+| Roo | .roo | ✅ |
+| Trae | .trae | ✅ |
+| Windsurf | .windsurfrules | ✅ |
+| Universal | SKILL.md | ✅ |
+
+## Skill Translation
+
+SkillKit can translate skills between any supported agents. For example, to translate Cursor rules to Moltbot:
+
+```bash
+skillkit translate .cursorrules --from cursor --to clawdbot
+```
+
+Or use the `skillkit_translate` tool within Moltbot:
+
+```
+skillkit_translate(skill: ".cursorrules", from: "cursor", to: "clawdbot")
+```
+
+## Team Collaboration
+
+SkillKit provides team collaboration features:
+
+```bash
+# Initialize team config
+skillkit team init
+
+# Share skills with team
+skillkit team share
+
+# Import team skills
+skillkit team import
+
+# Sync skills
+skillkit team sync
+```
+
+## Project Context Analysis
+
+SkillKit analyzes your project to provide intelligent recommendations:
+
+```bash
+skillkit context
+```
+
+This detects:
+- Programming languages
+- Frameworks (React, Next.js, Express, etc.)
+- Build tools (Webpack, Vite, etc.)
+- Testing frameworks
+- Package managers
+- Git configuration
+
+## Related Resources
+
+- [ClawdHub Skills](./clawdhub.md) - Moltbot-native skill registry
+- [Creating Skills](./creating-skills.md) - How to create custom skills
+- [SkillKit Website](https://agenstskills.com) - Browse the marketplace

extensions/memory-core/package.json

@@ -8,6 +8,9 @@
       "./index.ts"
     ]
   },
+  "devDependencies": {
+    "moltbot": "workspace:*"
+  },
   "peerDependencies": {
     "moltbot": ">=2026.1.26"
   },

extensions/skillkit/clawdbot.plugin.json

@@ -0,0 +1,8 @@
+{
+  "id": "skillkit",
+  "configSchema": {
+    "type": "object",
+    "additionalProperties": false,
+    "properties": {}
+  }
+}

extensions/skillkit/index.ts

@@ -0,0 +1,124 @@
+import type { MoltbotPluginApi } from "clawdbot/plugin-sdk";
+import { emptyPluginConfigSchema } from "clawdbot/plugin-sdk";
+
+import {
+  SkillkitSearchSchema,
+  executeSkillkitSearch,
+  SkillkitInstallSchema,
+  executeSkillkitInstall,
+  SkillkitTranslateSchema,
+  executeSkillkitTranslate,
+  SkillkitRecommendSchema,
+  executeSkillkitRecommend,
+  SkillkitSyncSchema,
+  executeSkillkitSync,
+  SkillkitListSchema,
+  executeSkillkitList,
+  SkillkitContextSchema,
+  executeSkillkitContext,
+  SkillkitPublishSchema,
+  executeSkillkitPublish,
+  SkillkitMemorySchema,
+  executeSkillkitMemory,
+} from "./src/tools.js";
+
+const plugin = {
+  id: "skillkit",
+  name: "SkillKit",
+  description:
+    "Universal AI agent skills management - search, install, translate, and sync skills across 17 coding agents",
+  configSchema: emptyPluginConfigSchema(),
+  register(api: MoltbotPluginApi) {
+    api.registerTool({
+      name: "skillkit_search",
+      label: "SkillKit Search",
+      description:
+        "Search the SkillKit marketplace for AI agent skills. " +
+        "Browse 15,000+ skills from curated sources including Cursor, Claude Code, Codex, and more.",
+      parameters: SkillkitSearchSchema,
+      execute: executeSkillkitSearch,
+    });
+
+    api.registerTool({
+      name: "skillkit_install",
+      label: "SkillKit Install",
+      description:
+        "Install a skill from the SkillKit marketplace. " +
+        "Automatically translates skills to the target agent format.",
+      parameters: SkillkitInstallSchema,
+      execute: executeSkillkitInstall,
+    });
+
+    api.registerTool({
+      name: "skillkit_translate",
+      label: "SkillKit Translate",
+      description:
+        "Translate skills between different AI agent formats. " +
+        "Supports Cursor, Claude Code, Codex, Gemini CLI, Windsurf, Roo, and 11 more agents.",
+      parameters: SkillkitTranslateSchema,
+      execute: executeSkillkitTranslate,
+    });
+
+    api.registerTool({
+      name: "skillkit_recommend",
+      label: "SkillKit Recommend",
+      description:
+        "Get smart skill recommendations based on your project's tech stack, " +
+        "dependencies, and codebase patterns.",
+      parameters: SkillkitRecommendSchema,
+      execute: executeSkillkitRecommend,
+    });
+
+    api.registerTool({
+      name: "skillkit_sync",
+      label: "SkillKit Sync",
+      description:
+        "Sync skills between local and remote configurations. " +
+        "Push local skills to team storage or pull team skills locally.",
+      parameters: SkillkitSyncSchema,
+      execute: executeSkillkitSync,
+    });
+
+    api.registerTool({
+      name: "skillkit_list",
+      label: "SkillKit List",
+      description:
+        "List available or installed skills. " +
+        "Filter by agent or show only locally installed skills.",
+      parameters: SkillkitListSchema,
+      execute: executeSkillkitList,
+    });
+
+    api.registerTool({
+      name: "skillkit_context",
+      label: "SkillKit Context",
+      description:
+        "Analyze project context to understand tech stack, dependencies, and patterns. " +
+        "Used for intelligent skill recommendations.",
+      parameters: SkillkitContextSchema,
+      execute: executeSkillkitContext,
+    });
+
+    api.registerTool({
+      name: "skillkit_publish",
+      label: "SkillKit Publish",
+      description:
+        "Publish a skill to the SkillKit marketplace. " +
+        "Share your custom skills with the community.",
+      parameters: SkillkitPublishSchema,
+      execute: executeSkillkitPublish,
+    });
+
+    api.registerTool({
+      name: "skillkit_memory",
+      label: "SkillKit Memory",
+      description:
+        "Manage SkillKit memory for persisting skill preferences and configurations. " +
+        "Save, load, list, or clear memory entries.",
+      parameters: SkillkitMemorySchema,
+      execute: executeSkillkitMemory,
+    });
+  },
+};
+
+export default plugin;

extensions/skillkit/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "@moltbot/skillkit",
+  "version": "2026.1.27",
+  "type": "module",
+  "description": "SkillKit integration for Moltbot - Universal AI agent skills management",
+  "moltbot": {
+    "extensions": [
+      "./index.ts"
+    ]
+  },
+  "dependencies": {
+    "skillkit": "^1.7.2"
+  },
+  "devDependencies": {
+    "moltbot": "workspace:*"
+  },
+  "peerDependencies": {
+    "moltbot": ">=2026.1.26"
+  }
+}

extensions/skillkit/src/tools.ts

@@ -0,0 +1,161 @@
+import { z } from "zod";
+import { execSync } from "child_process";
+
+function runSkillkit(args: string): string {
+  try {
+    return execSync(`npx skillkit ${args}`, {
+      encoding: "utf-8",
+      timeout: 30000,
+    }).trim();
+  } catch (error: any) {
+    return error.message || "Command failed";
+  }
+}
+
+export const SkillkitSearchSchema = z.object({
+  query: z.string().describe("Search query for skills"),
+  agent: z
+    .string()
+    .optional()
+    .describe("Filter by agent (e.g., cursor, claude-code, codex)"),
+  limit: z.number().optional().default(10).describe("Maximum results"),
+});
+
+export async function executeSkillkitSearch(
+  params: z.infer<typeof SkillkitSearchSchema>,
+): Promise<string> {
+  const args = [`search "${params.query}"`];
+  if (params.agent) args.push(`--agent ${params.agent}`);
+  if (params.limit) args.push(`--limit ${params.limit}`);
+  return runSkillkit(args.join(" "));
+}
+
+export const SkillkitInstallSchema = z.object({
+  skill: z.string().describe("Skill name or URL to install"),
+  agent: z
+    .string()
+    .optional()
+    .default("clawdbot")
+    .describe("Target agent for installation"),
+});
+
+export async function executeSkillkitInstall(
+  params: z.infer<typeof SkillkitInstallSchema>,
+): Promise<string> {
+  return runSkillkit(`install "${params.skill}" --agent ${params.agent}`);
+}
+
+export const SkillkitTranslateSchema = z.object({
+  skill: z.string().describe("Skill name or path to translate"),
+  from: z.string().describe("Source agent format"),
+  to: z.string().default("clawdbot").describe("Target agent format"),
+  recursive: z
+    .boolean()
+    .optional()
+    .default(false)
+    .describe("Translate all skills in directory"),
+});
+
+export async function executeSkillkitTranslate(
+  params: z.infer<typeof SkillkitTranslateSchema>,
+): Promise<string> {
+  const args = [`translate "${params.skill}" --from ${params.from} --to ${params.to}`];
+  if (params.recursive) args.push("--recursive");
+  return runSkillkit(args.join(" "));
+}
+
+export const SkillkitRecommendSchema = z.object({
+  path: z
+    .string()
+    .optional()
+    .default(".")
+    .describe("Project path to analyze for recommendations"),
+  limit: z.number().optional().default(5).describe("Maximum recommendations"),
+});
+
+export async function executeSkillkitRecommend(
+  params: z.infer<typeof SkillkitRecommendSchema>,
+): Promise<string> {
+  return runSkillkit(`recommend --path "${params.path}" --limit ${params.limit}`);
+}
+
+export const SkillkitSyncSchema = z.object({
+  direction: z
+    .enum(["push", "pull"])
+    .describe("Sync direction (push local to remote, pull remote to local)"),
+  agent: z
+    .string()
+    .optional()
+    .default("clawdbot")
+    .describe("Agent to sync skills for"),
+});
+
+export async function executeSkillkitSync(
+  params: z.infer<typeof SkillkitSyncSchema>,
+): Promise<string> {
+  return runSkillkit(`sync ${params.direction} --agent ${params.agent}`);
+}
+
+export const SkillkitListSchema = z.object({
+  agent: z.string().optional().describe("Filter by agent"),
+  installed: z
+    .boolean()
+    .optional()
+    .default(false)
+    .describe("Show only installed skills"),
+});
+
+export async function executeSkillkitList(
+  params: z.infer<typeof SkillkitListSchema>,
+): Promise<string> {
+  const args = ["list"];
+  if (params.agent) args.push(`--agent ${params.agent}`);
+  if (params.installed) args.push("--installed");
+  return runSkillkit(args.join(" "));
+}
+
+export const SkillkitContextSchema = z.object({
+  path: z.string().optional().default(".").describe("Project path to analyze"),
+  format: z
+    .enum(["json", "text"])
+    .optional()
+    .default("text")
+    .describe("Output format"),
+});
+
+export async function executeSkillkitContext(
+  params: z.infer<typeof SkillkitContextSchema>,
+): Promise<string> {
+  return runSkillkit(`context --path "${params.path}" --format ${params.format}`);
+}
+
+export const SkillkitPublishSchema = z.object({
+  path: z.string().optional().default(".").describe("Path to skill directory"),
+  name: z.string().optional().describe("Skill name (defaults to directory name)"),
+});
+
+export async function executeSkillkitPublish(
+  params: z.infer<typeof SkillkitPublishSchema>,
+): Promise<string> {
+  const args = ["publish"];
+  if (params.path !== ".") args.push(`--path "${params.path}"`);
+  if (params.name) args.push(`--name "${params.name}"`);
+  return runSkillkit(args.join(" "));
+}
+
+export const SkillkitMemorySchema = z.object({
+  action: z
+    .enum(["save", "load", "list", "clear"])
+    .describe("Memory action to perform"),
+  key: z.string().optional().describe("Memory key (for save/load)"),
+  value: z.string().optional().describe("Value to save (for save action)"),
+});
+
+export async function executeSkillkitMemory(
+  params: z.infer<typeof SkillkitMemorySchema>,
+): Promise<string> {
+  const args = [`memory ${params.action}`];
+  if (params.key) args.push(`--key "${params.key}"`);
+  if (params.value) args.push(`--value "${params.value}"`);
+  return runSkillkit(args.join(" "));
+}