fix: installing claude code plugins (#39)

yordis · web-flow · commit 06f36ff7bd97 · 2025-11-24T23:32:10.000-05:00
Signed-off-by: Yordis Prieto &lt;yordis.prieto@gmail.com&gt;
diff --git a/.gitignore b/.gitignore
@@ -40,3 +40,6 @@ report.[0-9]_.[0-9]_.[0-9]_.[0-9]_.json
 # TrogonAI internal files
 .trogonai/
 *.internal.trogonai.md
+
+# AIPM local configuration
+.aipm/config.local.json
diff --git a/src/commands/plugin-install.ts b/src/commands/plugin-install.ts
@@ -8,8 +8,8 @@ import { fileExists } from '../helpers/fs';
 import { resolveMarketplacePath } from '../helpers/git';
 import { defaultIO } from '../helpers/io';
 import { getMarketplaceType, loadMarketplaceManifest, resolvePluginPath } from '../helpers/marketplace';
-import { validatePluginStructure } from '../helpers/plugin';
-import { formatSyncResult, syncPluginToCursor } from '../helpers/sync-strategy';
+import { isMetaPlugin, validatePluginStructure } from '../helpers/plugin';
+import { formatSyncResult, syncMetaPluginToCursor, syncPluginToCursor } from '../helpers/sync-strategy';
 
 const PluginInstallOptionsSchema = z.object({
   pluginId: z.string().min(1),
@@ -85,7 +85,8 @@ export async function pluginInstall(options: unknown): Promise<void> {
       }
 
       try {
-        await validatePluginStructure(pluginPath);
+        const isMetaPluginCheck = isMetaPlugin(marketplacePath, pluginPath, manifest);
+        await validatePluginStructure(pluginPath, { isMetaPlugin: isMetaPluginCheck });
       } catch (error: unknown) {
         const message = error instanceof Error ? error.message : String(error);
         const validationError = new Error(`Invalid plugin '${pluginName}': ${message}`);
@@ -122,7 +123,13 @@ export async function pluginInstall(options: unknown): Promise<void> {
     }
 
     const cursorDir = join(cwd, DIR_CURSOR);
-    const syncResult = await syncPluginToCursor(pluginPath, marketplaceName, pluginName, cursorDir);
+    const isMetaPluginCheck = isMetaPlugin(marketplacePath, pluginPath, manifest);
+
+    const syncResult =
+      isMetaPluginCheck && manifest
+        ? await syncMetaPluginToCursor(marketplacePath, manifest, pluginName, marketplaceName, cursorDir)
+        : await syncPluginToCursor(pluginPath, marketplaceName, pluginName, cursorDir);
+
     const summary = formatSyncResult(syncResult);
 
     defaultIO.logSuccess(`Installed ${cmd.pluginId}`);
diff --git a/src/commands/plugin-uninstall.ts b/src/commands/plugin-uninstall.ts
@@ -2,10 +2,25 @@ import { rm } from 'node:fs/promises';
 import { join } from 'node:path';
 import { z } from 'zod';
 import { getConfigPath, getNotInitializedMessage, loadPluginsConfig } from '../config/loader';
-import { DIR_AIPM_NAMESPACE, DIR_CURSOR, FILE_AIPM_CONFIG, FILE_AIPM_CONFIG_LOCAL, PLUGIN_SUBDIRS } from '../constants';
+import {
+  DIR_AIPM_NAMESPACE,
+  DIR_CURSOR,
+  DIR_SKILLS,
+  FILE_AIPM_CONFIG,
+  FILE_AIPM_CONFIG_LOCAL,
+  PLUGIN_SUBDIRS,
+} from '../constants';
+import { isFileNotFoundError } from '../errors';
 import { loadTargetConfig, saveConfig } from '../helpers/aipm-config';
-import { fileExists } from '../helpers/fs';
+import { resolveMarketplacePath } from '../helpers/git';
 import { defaultIO } from '../helpers/io';
+import {
+  getMarketplaceType,
+  getPluginSourcePath,
+  hasPluginName,
+  loadMarketplaceManifest,
+} from '../helpers/marketplace';
+import { isMetaPlugin } from '../helpers/plugin';
 
 const PluginUninstallOptionsSchema = z.object({
   pluginId: z.string().min(1),
@@ -66,12 +81,83 @@ export async function pluginUninstall(options: unknown): Promise<void> {
         if (pluginName && marketplaceName) {
           let deletedCount = 0;
 
-          for (const subdir of PLUGIN_SUBDIRS) {
-            const installedPath = join(cwd, DIR_CURSOR, subdir, DIR_AIPM_NAMESPACE, marketplaceName, pluginName);
+          const marketplaceConfig = config.marketplaces[marketplaceName];
+          const isClaudeCodeMarketplace = getMarketplaceType(marketplaceName) === 'claude';
 
-            if (await fileExists(installedPath)) {
-              await rm(installedPath, { recursive: true, force: true });
-              deletedCount++;
+          if (marketplaceConfig) {
+            const marketplacePath = await resolveMarketplacePath(marketplaceName, marketplaceConfig, cwd);
+            if (!marketplacePath) {
+              throw new Error(`Could not resolve marketplace path for '${marketplaceName}'`);
+            }
+            const manifest = await loadMarketplaceManifest(marketplacePath, getMarketplaceType(marketplaceName));
+            const pluginPath = getPluginSourcePath(marketplacePath, pluginName, manifest);
+
+            const isMetaPluginCheck = isMetaPlugin(marketplacePath, pluginPath, manifest);
+
+            if (isMetaPluginCheck && manifest) {
+              const pluginEntry = manifest.plugins.find(hasPluginName(pluginName));
+              if (pluginEntry?.skills) {
+                for (const skillPath of pluginEntry.skills) {
+                  const normalizedSkillPath = skillPath.replace(/^\.\//, '');
+                  const marketplaceSegments = marketplaceName.split('/');
+                  const installedPath = join(
+                    cwd,
+                    DIR_CURSOR,
+                    DIR_SKILLS,
+                    DIR_AIPM_NAMESPACE,
+                    ...marketplaceSegments,
+                    normalizedSkillPath,
+                  );
+
+                  try {
+                    await rm(installedPath, { recursive: true });
+                    deletedCount++;
+                  } catch (error) {
+                    // Ignore if path doesn't exist - that's fine
+                    if (!isFileNotFoundError(error)) {
+                      throw error;
+                    }
+                  }
+                }
+              }
+            } else {
+              for (const subdir of PLUGIN_SUBDIRS) {
+                const installedPath = join(cwd, DIR_CURSOR, subdir, DIR_AIPM_NAMESPACE, marketplaceName, pluginName);
+
+                try {
+                  await rm(installedPath, { recursive: true });
+                  deletedCount++;
+                } catch (error) {
+                  // Ignore if path doesn't exist - that's fine
+                  if (!isFileNotFoundError(error)) {
+                    throw error;
+                  }
+                }
+              }
+            }
+          } else {
+            // Marketplace config missing - can still delete AIPM plugins, but not Claude Code meta-plugins
+            if (isClaudeCodeMarketplace) {
+              defaultIO.logInfo(
+                `⚠️  Cannot delete files for Claude Code plugin '${cmd.pluginId}': ` +
+                  `marketplace '${marketplaceName}' not found in config. ` +
+                  `Manual cleanup may be required in .cursor/skills/aipm/${marketplaceName}/`,
+              );
+            } else {
+              // AIPM plugins have predictable paths - delete them directly
+              for (const subdir of PLUGIN_SUBDIRS) {
+                const installedPath = join(cwd, DIR_CURSOR, subdir, DIR_AIPM_NAMESPACE, marketplaceName, pluginName);
+
+                try {
+                  await rm(installedPath, { recursive: true });
+                  deletedCount++;
+                } catch (error) {
+                  // Ignore if path doesn't exist - that's fine
+                  if (!isFileNotFoundError(error)) {
+                    throw error;
+                  }
+                }
+              }
             }
           }
 
diff --git a/src/constants.ts b/src/constants.ts
@@ -14,6 +14,11 @@ export const DIR_AIPM_NAMESPACE = 'aipm';
 export const PLUGIN_SUBDIRS = ['commands', 'rules', 'agents', 'skills', 'hooks'] as const;
 export type PluginSubdir = (typeof PLUGIN_SUBDIRS)[number];
 
+/**
+ * Individual subdirectory names (for direct reference)
+ */
+export const DIR_SKILLS = 'skills' as const;
+
 /**
  * Project-level AIPM directory
  */
diff --git a/src/helpers/fs.ts b/src/helpers/fs.ts
@@ -1,7 +1,7 @@
 import { copyFile, mkdir, stat } from 'node:fs/promises';
 import { dirname } from 'node:path';
 import type { z } from 'zod';
-import { isNodeError } from '../errors';
+import { isFileNotFoundError, isNodeError } from '../errors';
 
 export class JsonFileError extends Error {
   constructor(
@@ -72,7 +72,8 @@ export async function backupFile(path: string, dryRun?: boolean): Promise<void>
   try {
     await copyFile(path, backupPath);
   } catch (error: unknown) {
-    if (isNodeError(error) && error.code !== 'ENOENT') {
+    // Ignore if file doesn't exist - nothing to backup
+    if (!isFileNotFoundError(error)) {
       throw error;
     }
   }
diff --git a/src/helpers/marketplace.ts b/src/helpers/marketplace.ts
@@ -14,6 +14,13 @@ export function getMarketplaceType(marketplaceName: string): MarketplaceType {
   return marketplaceName.startsWith('claude/') ? 'claude' : 'aipm';
 }
 
+/**
+ * Creates a predicate function to find a plugin by name.
+ * @param name - The plugin name to search for
+ * @returns A predicate function that returns true if the plugin name matches
+ */
+export const hasPluginName = (name: string) => (plugin: { name: string }) => plugin.name === name;
+
 export async function loadAipmMarketplaceManifest(marketplacePath: string): Promise<MarketplaceManifest | null> {
   const manifestPath = join(marketplacePath, FILE_MARKETPLACE_MANIFEST);
 
diff --git a/src/helpers/plugin.ts b/src/helpers/plugin.ts
@@ -1,7 +1,7 @@
-import { join } from 'node:path';
+import { join, normalize } from 'node:path';
 import { DIR_CLAUDE_PLUGIN, FILE_PLUGIN_MANIFEST } from '../constants';
 import { isFileNotFoundError, PluginManifestInvalidError, PluginManifestNotFoundError } from '../errors';
-import type { PluginManifest } from '../schema';
+import type { MarketplaceManifest, PluginManifest } from '../schema';
 import { PluginManifestSchema } from '../schema';
 import { readJsonFile } from './fs';
 
@@ -19,7 +19,31 @@ export async function loadPluginManifest(pluginPath: string): Promise<PluginMani
   }
 }
 
-export async function validatePluginStructure(pluginPath: string): Promise<void> {
+export function isMetaPlugin(
+  marketplacePath: string,
+  pluginPath: string,
+  marketplaceManifest: MarketplaceManifest | null,
+): boolean {
+  if (!marketplaceManifest) {
+    return false;
+  }
+
+  const normalizedMarketplace = normalize(marketplacePath).replace(/\/$/, '');
+  const normalizedPlugin = normalize(pluginPath).replace(/\/$/, '');
+
+  return normalizedMarketplace === normalizedPlugin;
+}
+
+export async function validatePluginStructure(
+  pluginPath: string,
+  options?: {
+    isMetaPlugin?: boolean;
+  },
+): Promise<void> {
+  if (options?.isMetaPlugin) {
+    return;
+  }
+
   const manifest = await loadPluginManifest(pluginPath);
 
   if (!manifest.name) {
diff --git a/src/helpers/sync-strategy.ts b/src/helpers/sync-strategy.ts
@@ -1,18 +1,28 @@
 import { cp, readdir, readFile, writeFile } from 'node:fs/promises';
 import { basename, extname, join } from 'node:path';
-import { DIR_AIPM_NAMESPACE } from '../constants';
+import { DIR_AIPM_NAMESPACE, DIR_SKILLS } from '../constants';
 import { DirectoryNotFoundError, isFileNotFoundError } from '../errors';
+import type { MarketplaceManifest } from '../schema';
 import { applyCursorFrontmatter } from './frontmatter';
 import { ensureDir, fileExists } from './fs';
+import { hasPluginName } from './marketplace';
 
-export type SyncResult = {
+export type AipmPluginSyncResult = {
+  type: 'aipm';
   commandsCount: number;
   rulesCount: number;
   agentsCount: number;
   skillsCount: number;
   hooksCount: number;
 };
 
+export type ClaudeCodePluginSyncResult = {
+  type: 'claudecode';
+  skillsCount: number;
+};
+
+export type SyncResult = AipmPluginSyncResult | ClaudeCodePluginSyncResult;
+
 /**
  * Syncs a plugin to the correct Cursor directories:
  * - commands/*.md → .cursor/commands/aipm/marketplace-name/plugin-name/
@@ -26,8 +36,9 @@ export async function syncPluginToCursor(
   marketplaceName: string,
   pluginName: string,
   cursorDir: string,
-): Promise<SyncResult> {
-  const result: SyncResult = {
+): Promise<AipmPluginSyncResult> {
+  const result: AipmPluginSyncResult = {
+    type: 'aipm',
     commandsCount: 0,
     rulesCount: 0,
     agentsCount: 0,
@@ -193,26 +204,65 @@ async function syncDirectory(sourceDir: string, targetDir: string, extensions: s
   return count;
 }
 
+/**
+ * Syncs a Claude Code meta-plugin to Cursor directories.
+ * Meta-plugins point to the marketplace root and define skills in the manifest.
+ * We sync each skill directory listed in the manifest's skills array.
+ */
+export async function syncMetaPluginToCursor(
+  marketplacePath: string,
+  marketplaceManifest: MarketplaceManifest,
+  pluginName: string,
+  marketplaceName: string,
+  cursorDir: string,
+): Promise<ClaudeCodePluginSyncResult> {
+  const pluginEntry = marketplaceManifest.plugins.find(hasPluginName(pluginName));
+  if (!pluginEntry || !pluginEntry.skills) {
+    return { type: 'claudecode', skillsCount: 0 };
+  }
+
+  let skillsCount = 0;
+
+  for (const skillPath of pluginEntry.skills) {
+    const normalizedSkillPath = skillPath.replace(/^\.\//, '');
+    const fullSkillPath = join(marketplacePath, normalizedSkillPath);
+
+    const marketplaceSegments = marketplaceName.split('/');
+    const targetPath = join(cursorDir, DIR_SKILLS, DIR_AIPM_NAMESPACE, ...marketplaceSegments, normalizedSkillPath);
+
+    const count = await syncDirectory(fullSkillPath, targetPath, ['.md']);
+    skillsCount += count;
+  }
+
+  return { type: 'claudecode', skillsCount };
+}
+
 /**
  * Gets a summary string for sync results
  */
 export function formatSyncResult(result: SyncResult): string {
   const parts: string[] = [];
 
-  if (result.commandsCount > 0) {
-    parts.push(`${result.commandsCount} command(s)`);
-  }
-  if (result.rulesCount > 0) {
-    parts.push(`${result.rulesCount} rule(s)`);
-  }
-  if (result.agentsCount > 0) {
-    parts.push(`${result.agentsCount} agent(s)`);
-  }
-  if (result.skillsCount > 0) {
-    parts.push(`${result.skillsCount} skill(s)`);
-  }
-  if (result.hooksCount > 0) {
-    parts.push(`${result.hooksCount} hook(s)`);
+  if (result.type === 'aipm') {
+    if (result.commandsCount > 0) {
+      parts.push(`${result.commandsCount} command(s)`);
+    }
+    if (result.rulesCount > 0) {
+      parts.push(`${result.rulesCount} rule(s)`);
+    }
+    if (result.agentsCount > 0) {
+      parts.push(`${result.agentsCount} agent(s)`);
+    }
+    if (result.skillsCount > 0) {
+      parts.push(`${result.skillsCount} skill(s)`);
+    }
+    if (result.hooksCount > 0) {
+      parts.push(`${result.hooksCount} hook(s)`);
+    }
+  } else if (result.type === 'claudecode') {
+    if (result.skillsCount > 0) {
+      parts.push(`${result.skillsCount} skill(s)`);
+    }
   }
 
   return parts.length > 0 ? parts.join(', ') : 'no files';
diff --git a/src/schema.ts b/src/schema.ts
@@ -31,6 +31,8 @@ export const MarketplacePluginEntrySchema = z.object({
       email: z.string().optional(),
     })
     .optional(),
+  skills: z.array(z.string()).optional(),
+  strict: z.boolean().optional(),
 });
 
 export const MarketplaceManifestSchema = z.object({
diff --git a/tests/commands/plugin-install.test.ts b/tests/commands/plugin-install.test.ts
diff --git a/tests/commands/plugin-uninstall.test.ts b/tests/commands/plugin-uninstall.test.ts
