feat(cli): add plugin system with marketplace integration

Add a complete plugin system that enables skill sharing via plugins:

- Plugin discovery, loading, and registry (PluginRegistry, PluginLoader)
- Marketplace integration with Anthropic's claude-plugins-official repo
- Plugin CLI commands: list, install, uninstall, update, search, info
- Skill discovery from plugins with namespaced pattern support (/plugin:skill)
- Compatible with Claude Code's .claude-plugin/plugin.json format

The plugin system allows users to:
- Search and install plugins from the official Anthropic marketplace
- Discover skills from installed plugins automatically
- Use namespaced skill invocation (e.g., /example-plugin:example-skill)
- Manage plugins via `codemie plugin` CLI commands

Generated with AI

Co-Authored-By: AI/Run CodeMie <noreply@codemieai.com>

Author: Maksym Diabin

src/agents/codemie-code/skills/core/SkillDiscovery.ts

@@ -17,9 +17,10 @@ import type {
  * Higher priority = loaded first, can override lower priority
  */
 const SOURCE_PRIORITY: Record<SkillSource, number> = {
-  project: 1000, // Highest priority
+  project: 1000, // Highest priority - project-specific skills
+  plugin: 750, // High priority - plugins can override global but not project
   'mode-specific': 500, // Medium priority
-  global: 100, // Lowest priority
+  global: 100, // Lowest priority - user's global skills
 };
 
 /**
@@ -47,14 +48,15 @@ export class SkillDiscovery {
     }
 
     // Discover from all locations
-    const [projectSkills, modeSkills, globalSkills] = await Promise.all([
+    const [projectSkills, pluginSkills, modeSkills, globalSkills] = await Promise.all([
       this.discoverProjectSkills(cwd),
+      this.discoverPluginSkills(),
       this.discoverModeSkills(options.mode),
       this.discoverGlobalSkills(),
     ]);
 
     // Combine and deduplicate by name (higher priority wins)
-    const allSkills = [...projectSkills, ...modeSkills, ...globalSkills];
+    const allSkills = [...projectSkills, ...pluginSkills, ...modeSkills, ...globalSkills];
     const deduplicatedSkills = this.deduplicateSkills(allSkills);
 
     // Filter by agent if specified
@@ -103,6 +105,44 @@ export class SkillDiscovery {
     return this.discoverFromDirectory(globalSkillsDir, 'global');
   }
 
+  /**
+   * Discover skills from installed plugins
+   * Path: ~/.codemie/plugins/{name}/skills/
+   */
+  private async discoverPluginSkills(): Promise<Skill[]> {
+    const skills: Skill[] = [];
+
+    try {
+      // Lazy import to avoid circular dependency
+      const { PluginRegistry } = await import('../../../../plugins/index.js');
+      const registry = PluginRegistry.getInstance();
+
+      // Get all loaded plugins
+      const plugins = await registry.getAllPlugins();
+
+      for (const plugin of plugins) {
+        // Discover skills from each plugin's skills directory
+        const pluginSkillsDir = join(plugin.path, 'skills');
+        const pluginSkills = await this.discoverFromDirectory(pluginSkillsDir, 'plugin');
+
+        // Add plugin info to each skill
+        for (const skill of pluginSkills) {
+          skill.pluginInfo = {
+            pluginName: plugin.name,
+            fullSkillName: `${plugin.name}:${skill.metadata.name}`,
+            pluginVersion: plugin.manifest.version,
+          };
+        }
+
+        skills.push(...pluginSkills);
+      }
+    } catch {
+      // Plugin system not available or error - return empty array
+    }
+
+    return skills;
+  }
+
   /**
    * Discover skills from a specific directory
    *

src/agents/codemie-code/skills/core/types.ts

@@ -27,7 +27,21 @@ export type SkillMetadata = z.infer<typeof SkillMetadataSchema>;
 /**
  * Source type for a skill
  */
-export type SkillSource = 'global' | 'project' | 'mode-specific';
+export type SkillSource = 'global' | 'project' | 'mode-specific' | 'plugin';
+
+/**
+ * Plugin info attached to skills from plugins
+ */
+export interface PluginSkillInfo {
+  /** Plugin name */
+  pluginName: string;
+
+  /** Full namespaced skill name (plugin-name:skill-name) */
+  fullSkillName: string;
+
+  /** Plugin version */
+  pluginVersion: string;
+}
 
 /**
  * Complete skill with metadata, content, and location info
@@ -47,6 +61,9 @@ export interface Skill {
 
   /** Computed priority (source-based + metadata priority) */
   computedPriority: number;
+
+  /** Plugin info (only present if source is 'plugin') */
+  pluginInfo?: PluginSkillInfo;
 }
 
 /**

src/agents/codemie-code/skills/index.ts

@@ -17,6 +17,7 @@ export type {
   SkillDiscoveryOptions,
   SkillValidationResult,
   SkillsConfig,
+  PluginSkillInfo,
 } from './core/types.js';
 export { SkillMetadataSchema } from './core/types.js';
 
@@ -29,3 +30,12 @@ export {
   FrontmatterParseError,
 } from './utils/frontmatter.js';
 export type { FrontmatterResult } from './utils/frontmatter.js';
+
+// Pattern matcher exports
+export {
+  extractSkillPatterns,
+  isValidSkillName,
+  isValidNamespacedSkillName,
+  parseNamespacedSkillName,
+} from './utils/pattern-matcher.js';
+export type { SkillPattern, PatternMatchResult } from './utils/pattern-matcher.js';

src/agents/codemie-code/skills/utils/pattern-matcher.test.ts

@@ -3,7 +3,12 @@
  */
 
 import { describe, it, expect } from 'vitest';
-import { extractSkillPatterns, isValidSkillName } from './pattern-matcher.js';
+import {
+  extractSkillPatterns,
+  isValidSkillName,
+  isValidNamespacedSkillName,
+  parseNamespacedSkillName,
+} from './pattern-matcher.js';
 
 describe('extractSkillPatterns', () => {
   it('should detect single pattern at start', () => {
@@ -13,6 +18,8 @@ describe('extractSkillPatterns', () => {
     expect(result.patterns).toHaveLength(1);
     expect(result.patterns[0]).toEqual({
       name: 'mr',
+      fullName: 'mr',
+      namespace: undefined,
       position: 0,
       args: undefined,
       raw: '/mr',
@@ -26,6 +33,8 @@ describe('extractSkillPatterns', () => {
     expect(result.patterns).toHaveLength(1);
     expect(result.patterns[0]).toEqual({
       name: 'commit',
+      fullName: 'commit',
+      namespace: undefined,
       position: 15,
       args: 'this',
       raw: '/commit this',
@@ -38,7 +47,9 @@ describe('extractSkillPatterns', () => {
     expect(result.hasPatterns).toBe(true);
     expect(result.patterns).toHaveLength(2);
     expect(result.patterns[0].name).toBe('commit');
+    expect(result.patterns[0].fullName).toBe('commit');
     expect(result.patterns[1].name).toBe('mr');
+    expect(result.patterns[1].fullName).toBe('mr');
   });
 
   it('should detect pattern with arguments', () => {
@@ -135,6 +146,7 @@ describe('extractSkillPatterns', () => {
 
     expect(result.hasPatterns).toBe(true);
     expect(result.patterns[0].name).toBe('my-skill-name');
+    expect(result.patterns[0].fullName).toBe('my-skill-name');
   });
 
   it('should detect skills with numbers', () => {
@@ -169,6 +181,60 @@ describe('extractSkillPatterns', () => {
 
     expect(result.originalMessage).toBe(originalMessage);
   });
+
+  // Namespaced skill tests
+  describe('namespaced skills', () => {
+    it('should detect namespaced skill pattern', () => {
+      const result = extractSkillPatterns('/gitlab-tools:mr');
+
+      expect(result.hasPatterns).toBe(true);
+      expect(result.patterns).toHaveLength(1);
+      expect(result.patterns[0]).toEqual({
+        name: 'mr',
+        fullName: 'gitlab-tools:mr',
+        namespace: 'gitlab-tools',
+        position: 0,
+        args: undefined,
+        raw: '/gitlab-tools:mr',
+      });
+    });
+
+    it('should detect namespaced skill with arguments', () => {
+      const result = extractSkillPatterns('/plugin-name:skill-name arg1 arg2');
+
+      expect(result.hasPatterns).toBe(true);
+      expect(result.patterns[0].name).toBe('skill-name');
+      expect(result.patterns[0].namespace).toBe('plugin-name');
+      expect(result.patterns[0].fullName).toBe('plugin-name:skill-name');
+      expect(result.patterns[0].args).toBe('arg1 arg2');
+    });
+
+    it('should detect both simple and namespaced patterns', () => {
+      const result = extractSkillPatterns('/commit and /gitlab:mr');
+
+      expect(result.hasPatterns).toBe(true);
+      expect(result.patterns).toHaveLength(2);
+      expect(result.patterns[0].fullName).toBe('commit');
+      expect(result.patterns[0].namespace).toBeUndefined();
+      expect(result.patterns[1].fullName).toBe('gitlab:mr');
+      expect(result.patterns[1].namespace).toBe('gitlab');
+    });
+
+    it('should deduplicate by full name', () => {
+      const result = extractSkillPatterns('/gitlab:mr and /gitlab:mr again');
+
+      expect(result.patterns).toHaveLength(1);
+      expect(result.patterns[0].fullName).toBe('gitlab:mr');
+    });
+
+    it('should NOT exclude built-in commands when namespaced', () => {
+      const result = extractSkillPatterns('/my-plugin:help');
+
+      expect(result.hasPatterns).toBe(true);
+      expect(result.patterns[0].name).toBe('help');
+      expect(result.patterns[0].namespace).toBe('my-plugin');
+    });
+  });
 });
 
 describe('isValidSkillName', () => {
@@ -220,3 +286,60 @@ describe('isValidSkillName', () => {
     expect(isValidSkillName('-skill')).toBe(false);
   });
 });
+
+describe('isValidNamespacedSkillName', () => {
+  it('should accept simple skill name', () => {
+    expect(isValidNamespacedSkillName('commit')).toBe(true);
+  });
+
+  it('should accept namespaced skill name', () => {
+    expect(isValidNamespacedSkillName('gitlab:mr')).toBe(true);
+  });
+
+  it('should accept complex namespaced name', () => {
+    expect(isValidNamespacedSkillName('my-plugin-123:skill-name-456')).toBe(true);
+  });
+
+  it('should reject invalid namespace', () => {
+    expect(isValidNamespacedSkillName('Invalid:skill')).toBe(false);
+  });
+
+  it('should reject invalid skill in namespace', () => {
+    expect(isValidNamespacedSkillName('plugin:Invalid')).toBe(false);
+  });
+
+  it('should reject multiple colons', () => {
+    expect(isValidNamespacedSkillName('a:b:c')).toBe(false);
+  });
+
+  it('should reject empty parts', () => {
+    expect(isValidNamespacedSkillName(':skill')).toBe(false);
+    expect(isValidNamespacedSkillName('plugin:')).toBe(false);
+  });
+});
+
+describe('parseNamespacedSkillName', () => {
+  it('should parse simple name', () => {
+    const result = parseNamespacedSkillName('commit');
+    expect(result).toEqual({
+      name: 'commit',
+      namespace: undefined,
+    });
+  });
+
+  it('should parse namespaced name', () => {
+    const result = parseNamespacedSkillName('gitlab:mr');
+    expect(result).toEqual({
+      name: 'mr',
+      namespace: 'gitlab',
+    });
+  });
+
+  it('should parse complex namespaced name', () => {
+    const result = parseNamespacedSkillName('my-plugin:my-skill');
+    expect(result).toEqual({
+      name: 'my-skill',
+      namespace: 'my-plugin',
+    });
+  });
+});