feat(plugin): smart scope resolution for plugin uninstall (#64)

When no --scope flag is given, uninstall now checks both project and
user scopes and removes the plugin from all scopes where it exists.
This eliminates the confusing error when a plugin is installed in user
scope but the user doesn't specify --scope user.

- Add hasPlugin() and hasUserPlugin() helpers for non-destructive lookup
- Auto-uninstall from both scopes when no --scope specified
- Always show scope label in install/uninstall success messages
- Clear "Plugin not found" error when plugin doesn't exist in any scope

Co-authored-by: Claude Opus 4.5 <noreply@anthropic.com>

Author: christso

src/cli/commands/plugin.ts

@@ -8,8 +8,8 @@ import {
   getWellKnownMarketplaces,
 } from '../../core/marketplace.js';
 import { syncWorkspace, syncUserWorkspace } from '../../core/sync.js';
-import { addPlugin, removePlugin } from '../../core/workspace-modify.js';
-import { addUserPlugin, removeUserPlugin } from '../../core/user-workspace.js';
+import { addPlugin, removePlugin, hasPlugin } from '../../core/workspace-modify.js';
+import { addUserPlugin, removeUserPlugin, hasUserPlugin } from '../../core/user-workspace.js';
 import { isJsonMode, jsonOutput } from '../json-output.js';
 import { buildDescription, conciseSubcommands } from '../help.js';
 import {
@@ -637,7 +637,7 @@ const pluginInstallCmd = command({
       if (result.autoRegistered) {
         console.log(`\u2713 Auto-registered marketplace: ${result.autoRegistered}`);
       }
-      console.log(`\u2713 Installed plugin${isUser ? ' (user scope)' : ''}: ${plugin}`);
+      console.log(`\u2713 Installed plugin (${isUser ? 'user' : 'project'} scope): ${plugin}`);
 
       const { ok: syncOk } = isUser
         ? await runUserSyncAndPrint()
@@ -673,48 +673,122 @@ const pluginUninstallCmd = command({
   },
   handler: async ({ plugin, scope }) => {
     try {
-      const isUser = scope === 'user';
-      const result = isUser
-        ? await removeUserPlugin(plugin)
-        : await removePlugin(plugin);
+      // When an explicit scope is given, only uninstall from that scope
+      if (scope) {
+        const isUser = scope === 'user';
+        const result = isUser
+          ? await removeUserPlugin(plugin)
+          : await removePlugin(plugin);
+
+        if (!result.success) {
+          if (isJsonMode()) {
+            jsonOutput({ success: false, command: 'plugin uninstall', error: result.error ?? 'Unknown error' });
+            process.exit(1);
+          }
+          console.error(`Error: ${result.error}`);
+          process.exit(1);
+        }
 
-      if (!result.success) {
         if (isJsonMode()) {
-          jsonOutput({ success: false, command: 'plugin uninstall', error: result.error ?? 'Unknown error' });
+          const { ok, syncData } = isUser
+            ? await runUserSyncAndPrint()
+            : await runSyncAndPrint();
+          jsonOutput({
+            success: ok,
+            command: 'plugin uninstall',
+            data: { plugin, scope, syncResult: syncData },
+            ...(!ok && { error: 'Sync completed with failures' }),
+          });
+          if (!ok) process.exit(1);
+          return;
+        }
+
+        console.log(`\u2713 Uninstalled plugin (${scope} scope): ${plugin}`);
+        const { ok: syncOk } = isUser
+          ? await runUserSyncAndPrint()
+          : await runSyncAndPrint();
+        if (!syncOk) process.exit(1);
+        return;
+      }
+
+      // No explicit scope: uninstall from all scopes where the plugin exists
+      const inProject = await hasPlugin(plugin);
+      const inUser = await hasUserPlugin(plugin);
+
+      if (!inProject && !inUser) {
+        const error = `Plugin not found: ${plugin}`;
+        if (isJsonMode()) {
+          jsonOutput({ success: false, command: 'plugin uninstall', error });
           process.exit(1);
         }
-        console.error(`Error: ${result.error}`);
+        console.error(`Error: ${error}`);
         process.exit(1);
       }
 
+      const removedScopes: string[] = [];
+
+      if (inProject) {
+        const result = await removePlugin(plugin);
+        if (!result.success) {
+          if (isJsonMode()) {
+            jsonOutput({ success: false, command: 'plugin uninstall', error: result.error ?? 'Unknown error' });
+            process.exit(1);
+          }
+          console.error(`Error: ${result.error}`);
+          process.exit(1);
+        }
+        removedScopes.push('project');
+      }
+
+      if (inUser) {
+        const result = await removeUserPlugin(plugin);
+        if (!result.success) {
+          if (isJsonMode()) {
+            jsonOutput({ success: false, command: 'plugin uninstall', error: result.error ?? 'Unknown error' });
+            process.exit(1);
+          }
+          console.error(`Error: ${result.error}`);
+          process.exit(1);
+        }
+        removedScopes.push('user');
+      }
+
       if (isJsonMode()) {
-        const { ok, syncData } = isUser
-          ? await runUserSyncAndPrint()
-          : await runSyncAndPrint();
+        const syncResults: Record<string, ReturnType<typeof buildSyncData> | null> = {};
+        let allOk = true;
+        if (removedScopes.includes('project')) {
+          const { ok, syncData } = await runSyncAndPrint();
+          syncResults.project = syncData;
+          if (!ok) allOk = false;
+        }
+        if (removedScopes.includes('user')) {
+          const { ok, syncData } = await runUserSyncAndPrint();
+          syncResults.user = syncData;
+          if (!ok) allOk = false;
+        }
         jsonOutput({
-          success: ok,
+          success: allOk,
           command: 'plugin uninstall',
-          data: {
-            plugin,
-            scope: isUser ? 'user' : 'project',
-            syncResult: syncData,
-          },
-          ...(!ok && { error: 'Sync completed with failures' }),
+          data: { plugin, scopes: removedScopes, syncResults },
+          ...(!allOk && { error: 'Sync completed with failures' }),
         });
-        if (!ok) {
-          process.exit(1);
-        }
+        if (!allOk) process.exit(1);
         return;
       }
 
-      console.log(`\u2713 Uninstalled plugin${isUser ? ' (user scope)' : ''}: ${plugin}`);
+      const scopeLabel = removedScopes.join(' + ');
+      console.log(`\u2713 Uninstalled plugin (${scopeLabel} scope): ${plugin}`);
 
-      const { ok: syncOk } = isUser
-        ? await runUserSyncAndPrint()
-        : await runSyncAndPrint();
-      if (!syncOk) {
-        process.exit(1);
+      let syncOk = true;
+      if (removedScopes.includes('project')) {
+        const { ok } = await runSyncAndPrint();
+        if (!ok) syncOk = false;
+      }
+      if (removedScopes.includes('user')) {
+        const { ok } = await runUserSyncAndPrint();
+        if (!ok) syncOk = false;
       }
+      if (!syncOk) process.exit(1);
     } catch (error) {
       if (error instanceof Error) {
         if (isJsonMode()) {

src/core/user-workspace.ts

@@ -112,6 +112,24 @@ export async function addUserPlugin(plugin: string): Promise<ModifyResult> {
   return addPluginToUserConfig(plugin, configPath);
 }
 
+/**
+ * Check if a plugin exists in the user-level workspace config.
+ * @param plugin - Plugin source to find (exact match or partial match)
+ * @returns true if the plugin is found
+ */
+export async function hasUserPlugin(plugin: string): Promise<boolean> {
+  const config = await getUserWorkspaceConfig();
+  if (!config) return false;
+
+  // Exact match first
+  if (config.plugins.indexOf(plugin) !== -1) return true;
+
+  // Partial match
+  return config.plugins.some(
+    (p) => p.startsWith(`${plugin}@`) || p === plugin,
+  );
+}
+
 /**
  * Remove a plugin from the user-level workspace config.
  */

src/core/workspace-modify.ts

@@ -145,6 +145,39 @@ async function addPluginToConfig(
   }
 }
 
+/**
+ * Check if a plugin exists in .allagents/workspace.yaml (project scope)
+ * @param plugin - Plugin source to find (exact match or partial match)
+ * @param workspacePath - Path to workspace directory (default: cwd)
+ * @returns true if the plugin is found
+ */
+export async function hasPlugin(
+  plugin: string,
+  workspacePath: string = process.cwd(),
+): Promise<boolean> {
+  const configPath = join(workspacePath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
+  if (!existsSync(configPath)) return false;
+
+  try {
+    const content = await readFile(configPath, 'utf-8');
+    const config = load(content) as WorkspaceConfig;
+
+    // Exact match first
+    if (config.plugins.indexOf(plugin) !== -1) return true;
+
+    // Partial match
+    if (!isPluginSpec(plugin)) {
+      return config.plugins.some(
+        (p) => p.startsWith(`${plugin}@`) || p === plugin,
+      );
+    }
+
+    return false;
+  } catch {
+    return false;
+  }
+}
+
 /**
  * Remove a plugin from .allagents/workspace.yaml
  * @param plugin - Plugin source to remove (exact match or partial match)

tests/cli/plugin-uninstall-scope.test.ts

@@ -0,0 +1,111 @@
+import { describe, expect, test, beforeEach, afterEach } from 'bun:test';
+import { mkdtemp, rm, mkdir, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { dump } from 'js-yaml';
+
+describe('plugin uninstall smart scope resolution', () => {
+  let tempHome: string;
+  let tempProject: string;
+  let originalHome: string;
+
+  beforeEach(async () => {
+    tempHome = await mkdtemp(join(tmpdir(), 'allagents-uninstall-home-'));
+    tempProject = await mkdtemp(join(tmpdir(), 'allagents-uninstall-proj-'));
+    originalHome = process.env.HOME || '';
+    process.env.HOME = tempHome;
+  });
+
+  afterEach(async () => {
+    process.env.HOME = originalHome;
+    await rm(tempHome, { recursive: true, force: true });
+    await rm(tempProject, { recursive: true, force: true });
+  });
+
+  async function setupProjectWorkspace(plugins: string[]) {
+    const configDir = join(tempProject, '.allagents');
+    await mkdir(configDir, { recursive: true });
+    await writeFile(
+      join(configDir, 'workspace.yaml'),
+      dump({ repositories: [], plugins, clients: ['claude'] }, { lineWidth: -1 }),
+    );
+  }
+
+  async function setupUserWorkspace(plugins: string[]) {
+    const configDir = join(tempHome, '.allagents');
+    await mkdir(configDir, { recursive: true });
+    await writeFile(
+      join(configDir, 'workspace.yaml'),
+      dump({ repositories: [], plugins, clients: ['claude'] }, { lineWidth: -1 }),
+    );
+  }
+
+  test('hasPlugin returns true for exact match in project scope', async () => {
+    await setupProjectWorkspace(['my-plugin@marketplace']);
+    const { hasPlugin } = await import('../../src/core/workspace-modify.js');
+    expect(await hasPlugin('my-plugin@marketplace', tempProject)).toBe(true);
+  });
+
+  test('hasPlugin returns true for partial match in project scope', async () => {
+    await setupProjectWorkspace(['my-plugin@marketplace']);
+    const { hasPlugin } = await import('../../src/core/workspace-modify.js');
+    expect(await hasPlugin('my-plugin', tempProject)).toBe(true);
+  });
+
+  test('hasPlugin returns false when plugin not in project scope', async () => {
+    await setupProjectWorkspace(['other-plugin@marketplace']);
+    const { hasPlugin } = await import('../../src/core/workspace-modify.js');
+    expect(await hasPlugin('my-plugin', tempProject)).toBe(false);
+  });
+
+  test('hasPlugin returns false when no project workspace exists', async () => {
+    const { hasPlugin } = await import('../../src/core/workspace-modify.js');
+    expect(await hasPlugin('my-plugin', tempProject)).toBe(false);
+  });
+
+  test('hasUserPlugin returns true for exact match in user scope', async () => {
+    await setupUserWorkspace(['my-plugin@marketplace']);
+    const { hasUserPlugin } = await import('../../src/core/user-workspace.js');
+    expect(await hasUserPlugin('my-plugin@marketplace')).toBe(true);
+  });
+
+  test('hasUserPlugin returns true for partial match in user scope', async () => {
+    await setupUserWorkspace(['my-plugin@marketplace']);
+    const { hasUserPlugin } = await import('../../src/core/user-workspace.js');
+    expect(await hasUserPlugin('my-plugin')).toBe(true);
+  });
+
+  test('hasUserPlugin returns false when plugin not in user scope', async () => {
+    await setupUserWorkspace(['other-plugin@marketplace']);
+    const { hasUserPlugin } = await import('../../src/core/user-workspace.js');
+    expect(await hasUserPlugin('my-plugin')).toBe(false);
+  });
+
+  test('hasUserPlugin returns false when no user workspace exists', async () => {
+    const { hasUserPlugin } = await import('../../src/core/user-workspace.js');
+    expect(await hasUserPlugin('my-plugin')).toBe(false);
+  });
+
+  test('removePlugin succeeds when plugin is in project scope', async () => {
+    await setupProjectWorkspace(['my-plugin@marketplace']);
+    const { removePlugin } = await import('../../src/core/workspace-modify.js');
+    const result = await removePlugin('my-plugin@marketplace', tempProject);
+    expect(result.success).toBe(true);
+  });
+
+  test('removeUserPlugin succeeds when plugin is in user scope', async () => {
+    await setupUserWorkspace(['my-plugin@marketplace']);
+    const { removeUserPlugin } = await import('../../src/core/user-workspace.js');
+    const result = await removeUserPlugin('my-plugin@marketplace');
+    expect(result.success).toBe(true);
+  });
+
+  test('removePlugin fails when plugin only in user scope', async () => {
+    await setupProjectWorkspace([]);
+    await setupUserWorkspace(['my-plugin@marketplace']);
+    const { removePlugin } = await import('../../src/core/workspace-modify.js');
+    const result = await removePlugin('my-plugin@marketplace', tempProject);
+    expect(result.success).toBe(false);
+    expect(result.error).toContain('not found');
+  });
+});