fix(skills): flatten skill directories to avoid nesting limitations

Each skill now gets a completely flat directory name (e.g., aipm-marketplace-plugin-skill) with no nesting, addressing Claude Code's limitation with nested directories (issue #10238). Also fixed fallback for meta-plugins where skills are defined in plugin.json rather than marketplace manifest.

Signed-off-by: Yordis Prieto <yordis.prieto@gmail.com>

Author: yordis

bun.lock

@@ -21,7 +21,7 @@
     "ci:all": "bun run format:check && bun run typecheck && bun run test",
     "test": "bun test",
     "test:coverage": "bun test --coverage",
-    "typecheck": "tsc --noEmit",
+    "typecheck": "tsgo --noEmit",
     "dev": "bun --watch src/cli.ts",
     "format": "prettier --write .",
     "format:check": "prettier --check .",
@@ -33,6 +33,7 @@
     "@straw-hat/prettier-config": "3.1.5",
     "@types/bun": "1.2.2",
     "@types/lodash.merge": "4.6.9",
+    "@typescript/native-preview": "7.0.0-dev.20251014.1",
     "prettier": "3.6.2"
   },
   "peerDependencies": {

package.json

@@ -1,10 +1,10 @@
 import merge from 'lodash.merge';
 import { join } from 'node:path';
 import { z } from 'zod';
-import { getConfigPath, getNotInitializedMessage, loadPluginsConfig } from '../config/loader';
-import { DIR_CURSOR, FILE_AIPM_CONFIG, FILE_AIPM_CONFIG_LOCAL } from '../constants';
+import { loadClaudeCodeMarketplaces, loadPluginsConfig } from '../config/loader';
+import { DIR_CURSOR } from '../constants';
 import { getErrorMessage } from '../errors';
-import { loadTargetConfig, saveConfig } from '../helpers/aipm-config';
+import { isClaudeCodeInstalled } from '../helpers/claude-code-config';
 import { fileExists } from '../helpers/fs';
 import { resolveMarketplacePath } from '../helpers/git';
 import { defaultIO } from '../helpers/io';
@@ -15,9 +15,7 @@ import { formatSyncResult, syncMetaPluginToCursor, syncPluginToCursor } from '..
 const PluginInstallOptionsSchema = z.object({
   pluginId: z.string().min(1),
   cwd: z.string().optional(),
-  local: z.boolean().optional(),
   dryRun: z.boolean().optional(),
-  force: z.boolean().optional(),
 });
 
 export async function pluginInstall(options: unknown): Promise<void> {
@@ -26,54 +24,86 @@ export async function pluginInstall(options: unknown): Promise<void> {
   const cwd = cmd.cwd || process.cwd();
 
   try {
-    const { config, sources } = await loadPluginsConfig(cwd);
+    const { pluginName, marketplaceName } = parsePluginId(cmd.pluginId);
 
-    if (!sources.project && !sources.local) {
-      const error = new Error(getNotInitializedMessage());
-      defaultIO.logError(error.message);
-      throw error;
+    // Load marketplaces from both AIPM config (optional) and Claude Code (auto-discovered)
+    let aipmMarketplaces: Record<string, any> = {};
+    try {
+      const config = await loadPluginsConfig(cwd);
+      aipmMarketplaces = config.config.marketplaces || {};
+    } catch (error: unknown) {
+      // AIPM config is optional - proceed without it
+      // Log at info level so users know about config issues but can continue
+      if (!(error instanceof Error && error.message.includes('not found'))) {
+        const message = getErrorMessage(error);
+        defaultIO.logInfo(`ℹ️  Config loading: ${message}`);
+      }
     }
-    const configName = cmd.local ? getConfigPath(FILE_AIPM_CONFIG_LOCAL) : getConfigPath(FILE_AIPM_CONFIG);
 
-    const { pluginName, marketplaceName } = parsePluginId(cmd.pluginId);
-
-    const marketplace = config.marketplaces[marketplaceName];
+    const claudeMarketplaces = await loadClaudeCodeMarketplaces();
+    const allMarketplaces = merge({}, claudeMarketplaces, aipmMarketplaces);
+    const marketplace = allMarketplaces[marketplaceName];
 
     if (!marketplace) {
-      const error = new Error(`Marketplace '${marketplaceName}' not found. Add it first with 'marketplace add'.`);
+      const availableMarketplaces = Object.keys(allMarketplaces);
+
+      let errorMessage: string;
+      if (!availableMarketplaces.includes(marketplaceName) && marketplaceName.startsWith('claude/')) {
+        const claudeCodeInstalled = await isClaudeCodeInstalled();
+        if (!claudeCodeInstalled) {
+          errorMessage = `Claude Code is not installed. Install Claude Code to use Claude Code marketplaces like '${marketplaceName}'.`;
+        } else {
+          errorMessage =
+            `Marketplace '${marketplaceName}' not found in Claude Code. ` +
+            `Available marketplaces: ${availableMarketplaces.join(', ')}`;
+        }
+      } else if (availableMarketplaces.length === 0) {
+        errorMessage = `Marketplace '${marketplaceName}' not found. No marketplaces available.`;
+      } else {
+        errorMessage =
+          `Marketplace '${marketplaceName}' not found. ` +
+          `Available marketplaces: ${availableMarketplaces.join(', ')}`;
+      }
+
+      const error = new Error(errorMessage);
       defaultIO.logError(error.message);
       throw error;
     }
 
-    const marketplacePath = await resolveMarketplacePath(marketplaceName, marketplace, cwd, {
-      dryRun: cmd.dryRun,
-    });
+    let marketplacePath: string | null = null;
+
+    // For git/url sources, resolve the path (clone/download if needed)
+    if (marketplace.source && marketplace.source !== 'directory') {
+      marketplacePath = await resolveMarketplacePath(marketplaceName, marketplace, cwd, {
+        dryRun: cmd.dryRun,
+      });
+    } else {
+      // For directory sources, use the path directly
+      marketplacePath = marketplace.path;
+    }
 
     if (!marketplacePath) {
       const error = new Error(`Marketplace '${marketplaceName}' has no path/url configured`);
       defaultIO.logError(error.message);
       throw error;
     }
 
-    // In dry-run mode, skip validation for git/url marketplaces that haven't been cached yet.
-    // Directory marketplaces can still be validated since they exist locally.
-    const isDirectoryMarketplace = marketplace.source === 'directory';
-    const shouldSkipValidation = cmd.dryRun && !isDirectoryMarketplace;
-
     let manifest: Awaited<ReturnType<typeof loadMarketplaceManifest>> = null;
     let pluginPath: string | null = null;
 
-    if (!shouldSkipValidation) {
+    // Always validate for directory sources; skip expensive operations for git/url in dry-run
+    const isDirectorySource = !marketplace.source || marketplace.source === 'directory';
+    const shouldValidate = isDirectorySource || !cmd.dryRun;
+
+    if (shouldValidate) {
       manifest = await loadMarketplaceManifest(marketplacePath, getMarketplaceType(marketplaceName));
 
       // Resolve plugin path: try manifest first, then search recursively if needed
       pluginPath = await resolvePluginPath(marketplacePath, pluginName, manifest);
 
       if (!(await fileExists(pluginPath))) {
         const error = new Error(
-          `Plugin '${pluginName}' not found in marketplace '${marketplaceName}'. ` +
-            `Checked path: ${pluginPath}. ` +
-            `If the plugin is in a nested directory, use the full path shown in search results.`,
+          `Plugin '${pluginName}' not found in marketplace '${marketplaceName}'. ` + `Checked path: ${pluginPath}.`,
         );
         defaultIO.logError(error.message);
         throw error;
@@ -90,40 +120,35 @@ export async function pluginInstall(options: unknown): Promise<void> {
       }
     }
 
-    const isAlreadyEnabled = config.plugins[cmd.pluginId]?.enabled;
-
-    if (isAlreadyEnabled && !cmd.force) {
-      defaultIO.logInfo(`Plugin '${cmd.pluginId}' is already installed`);
-      return;
-    }
-
     if (cmd.dryRun) {
-      defaultIO.logInfo(`[DRY RUN] Would enable plugin '${cmd.pluginId}' in ${configName}`);
-      defaultIO.logInfo(`[DRY RUN] Would sync ${cmd.pluginId} to .cursor/`);
+      defaultIO.logInfo(`[DRY RUN] Would sync ${cmd.pluginId} to .cursor/skills/`);
       return;
     }
 
-    const targetConfig = await loadTargetConfig(cwd, cmd.local);
-    const updatedConfig = merge({}, targetConfig, {
-      plugins: { [cmd.pluginId]: { enabled: true } },
-    });
-
-    await saveConfig(cwd, updatedConfig, cmd.local);
-    defaultIO.logSuccess(`Enabled plugin '${cmd.pluginId}' in ${configName}`);
-
-    // pluginPath is guaranteed to be set here since we skip validation only in dry-run mode,
-    // and dry-run mode returns early above
+    // For git/url sources in dry-run, we skip validation so pluginPath won't be set
+    // In this case, we can't perform the sync, so we already returned above
     if (!pluginPath) {
       throw new Error(`Plugin path not resolved for '${pluginName}'`);
     }
 
     const cursorDir = join(cwd, DIR_CURSOR);
     const isMetaPluginCheck = isMetaPlugin(marketplacePath, pluginPath, manifest);
 
-    const syncResult =
-      isMetaPluginCheck && manifest
-        ? await syncMetaPluginToCursor(marketplacePath, manifest, pluginName, marketplaceName, cursorDir)
-        : await syncPluginToCursor(pluginPath, marketplaceName, pluginName, cursorDir);
+    // Check if it's a meta-plugin with skills defined in the manifest
+    let syncResult;
+    if (isMetaPluginCheck && manifest) {
+      const pluginEntry = manifest.plugins.find((p) => p.name === pluginName);
+      if (pluginEntry && pluginEntry.skills && pluginEntry.skills.length > 0) {
+        // True meta-plugin with skills in manifest
+        syncResult = await syncMetaPluginToCursor(marketplacePath, manifest, pluginName, marketplaceName, cursorDir);
+      } else {
+        // Meta-plugin path but skills are in plugin.json (not in marketplace manifest)
+        // Fall back to regular plugin sync
+        syncResult = await syncPluginToCursor(pluginPath, marketplaceName, pluginName, cursorDir);
+      }
+    } else {
+      syncResult = await syncPluginToCursor(pluginPath, marketplaceName, pluginName, cursorDir);
+    }
 
     const summary = formatSyncResult(syncResult);
 

src/commands/plugin-install.ts

@@ -1,4 +1,4 @@
-import { rm } from 'node:fs/promises';
+import { readdir, rm } from 'node:fs/promises';
 import { join } from 'node:path';
 import { z } from 'zod';
 import { getConfigPath, getNotInitializedMessage, loadPluginsConfig } from '../config/loader';
@@ -147,6 +147,31 @@ export async function pluginUninstall(options: unknown): Promise<void> {
                 }
               }
             }
+
+            // Remove flattened skill directories for this plugin
+            // Pattern: .cursor/skills/aipm-<marketplace>-<plugin>[-subskill]
+            const skillsDir = join(cwd, DIR_CURSOR, DIR_SKILLS);
+            try {
+              const entries = await readdir(skillsDir, { withFileTypes: true });
+              const flattenedPrefix = `aipm-${marketplaceName.replace(/\//g, '-')}-${pluginName}`;
+              for (const entry of entries) {
+                if (entry.isDirectory() && entry.name.startsWith(flattenedPrefix)) {
+                  try {
+                    await rm(join(skillsDir, entry.name), { recursive: true });
+                    deletedCount++;
+                  } catch (error) {
+                    if (!isFileNotFoundError(error)) {
+                      throw error;
+                    }
+                  }
+                }
+              }
+            } catch (error) {
+              // Ignore errors reading skills directory
+              if (!isFileNotFoundError(error)) {
+                throw error;
+              }
+            }
           }
         } else {
           // Marketplace config missing - can still delete AIPM plugins, but not Claude Code meta-plugins

src/commands/plugin-uninstall.ts

@@ -1,8 +1,15 @@
-import { rm, stat } from 'node:fs/promises';
+import { readdir, rm, stat } from 'node:fs/promises';
 import { join } from 'node:path';
 import { z } from 'zod';
 import { getNotInitializedMessage, loadPluginsConfig } from '../config/loader';
-import { DIR_AIPM_NAMESPACE, DIR_HOOKS, DIR_MARKETPLACE, INTEGRATION_INCLUDE_ALL, PLUGIN_SUBDIRS } from '../constants';
+import {
+  DIR_AIPM_NAMESPACE,
+  DIR_HOOKS,
+  DIR_MARKETPLACE,
+  DIR_SKILLS,
+  INTEGRATION_INCLUDE_ALL,
+  PLUGIN_SUBDIRS,
+} from '../constants';
 import { getErrorMessage } from '../errors';
 import { ensureDir, fileExists } from '../helpers/fs';
 import { resolveMarketplacePath } from '../helpers/git';
@@ -74,17 +81,6 @@ export async function sync(options: SyncOptions = {}): Promise<void> {
     // Collect hooks early to enable cleanup even if no plugins are enabled
     const collectedPluginHooks: CursorHooksConfig[] = [];
 
-    if (enabledPlugins.length === 0) {
-      defaultIO.logInfo('No enabled plugins found');
-      // Clean up hooks from disabled/uninstalled plugins
-      if (!cmd.dryRun) {
-        await mergeHooks(targetDir, collectedPluginHooks);
-      }
-      return;
-    }
-
-    console.log(`\n🔄 Syncing ${enabledPlugins.length} enabled plugin(s)...\n`);
-
     const targetSubdirs = getEnabledSubdirs(cursorIntegration?.include);
 
     if (!cmd.dryRun) {
@@ -103,8 +99,42 @@ export async function sync(options: SyncOptions = {}): Promise<void> {
         }
         await ensureDir(aipmSubdirPath);
       }
+
+      // Clean up flattened skill directories and nested aipm structure for disabled plugins
+      // Both flattened (aipm-*) and nested (aipm/marketplace/plugin) skill paths need cleanup
+      // This must run even if no plugins are enabled to clean up skills from disabled plugins
+      const skillsDir = join(targetDir, DIR_SKILLS);
+      try {
+        const entries = await readdir(skillsDir, { withFileTypes: true });
+        for (const entry of entries) {
+          if (entry.isDirectory()) {
+            if (entry.name.startsWith('aipm-')) {
+              // Remove flattened skill directories
+              await rm(join(skillsDir, entry.name), { recursive: true, force: true });
+              defaultIO.logInfo(`Cleaned up flattened skill: ${entry.name}`);
+            } else if (entry.name === DIR_AIPM_NAMESPACE) {
+              // Remove entire nested aipm structure which gets rebuilt
+              await rm(join(skillsDir, entry.name), { recursive: true, force: true });
+              defaultIO.logInfo(`Cleaned up nested skills structure`);
+            }
+          }
+        }
+      } catch {
+        // Skills directory doesn't exist yet, which is fine
+      }
+    }
+
+    if (enabledPlugins.length === 0) {
+      defaultIO.logInfo('No enabled plugins found');
+      // Clean up hooks from disabled/uninstalled plugins
+      if (!cmd.dryRun) {
+        await mergeHooks(targetDir, collectedPluginHooks);
+      }
+      return;
     }
 
+    console.log(`\n🔄 Syncing ${enabledPlugins.length} enabled plugin(s)...\n`);
+
     let installedCount = 0;
     let skippedCount = 0;
 

src/commands/sync.ts

@@ -152,3 +152,28 @@ export function getConfigPaths(baseDir: string) {
     gitignore: join(baseDir, FILE_GITIGNORE),
   };
 }
+
+function accumulateClaudeMarketplace(
+  acc: Record<string, MarketplaceSource>,
+  [marketplaceName, marketplaceConfig]: [string, unknown],
+): Record<string, MarketplaceSource> {
+  const prefixedName = `claude/${marketplaceName}`;
+  acc[prefixedName] = convertClaudeMarketplaceToAIPM(marketplaceName, marketplaceConfig as never);
+  return acc;
+}
+
+/**
+ * Load Claude Code's marketplaces without requiring AIPM config
+ */
+export async function loadClaudeCodeMarketplaces(): Promise<Record<string, MarketplaceSource>> {
+  if (!(await isClaudeCodeInstalled())) {
+    return {};
+  }
+
+  const claudeCodeMarketplaces = await readClaudeCodeMarketplaces();
+
+  return Object.entries(claudeCodeMarketplaces).reduce(
+    accumulateClaudeMarketplace,
+    {} as Record<string, MarketplaceSource>,
+  );
+}