bluera-knowledge 0.13.2 → 0.14.0

package/dist/index.js

@@ -7,10 +7,10 @@ import {
   isWebStoreDefinition,
   runMCPServer,
   spawnBackgroundWorker
-} from "./chunk-H5AKKHY7.js";
+} from "./chunk-UAWKTJWN.js";
 import {
   IntelligentCrawler
-} from "./chunk-GCUKVV33.js";
+} from "./chunk-AIS5S77C.js";
 import {
   ASTParser,
   AdapterRegistry,
@@ -24,7 +24,7 @@ import {
   err,
   extractRepoName,
   ok
-} from "./chunk-6ZVW2P2F.js";
+} from "./chunk-Y24ZJRZP.js";
 import "./chunk-HRQD3MPH.js";
 
 // src/index.ts

package/dist/mcp/server.js

@@ -1,8 +1,8 @@
 import {
   createMCPServer,
   runMCPServer
-} from "../chunk-H5AKKHY7.js";
-import "../chunk-6ZVW2P2F.js";
+} from "../chunk-UAWKTJWN.js";
+import "../chunk-Y24ZJRZP.js";
 import "../chunk-HRQD3MPH.js";
 export {
   createMCPServer,

package/dist/workers/background-worker-cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   IntelligentCrawler
-} from "../chunk-GCUKVV33.js";
+} from "../chunk-AIS5S77C.js";
 import {
   JobService,
   createDocumentId,
@@ -10,7 +10,7 @@ import {
   createStoreId,
   destroyServices,
   shutdownLogger
-} from "../chunk-6ZVW2P2F.js";
+} from "../chunk-Y24ZJRZP.js";
 import "../chunk-HRQD3MPH.js";
 
 // src/workers/background-worker-cli.ts

package/hooks/check-dependencies.sh

@@ -3,12 +3,12 @@
 # Automatically checks and installs dependencies for the plugin
 #
 # Environment variables:
-#   BK_SKIP_AUTO_INSTALL=1  - Skip automatic pip installation of crawl4ai
+#   BK_SKIP_AUTO_INSTALL=1  - Skip automatic installation of crawl4ai
 #                             Set this if you prefer to manage Python packages manually
 #
 # What this script auto-installs (if missing):
 #   - Node.js dependencies (via bun or npm, from package.json)
-#   - crawl4ai Python package (via pip, for web crawling)
+#   - Python virtual environment with crawl4ai (isolated from system Python)
 #   - Playwright Chromium browser (via playwright CLI, for headless crawling)
 
 set -e
@@ -16,6 +16,11 @@ set -e
 # Get the plugin root directory
 PLUGIN_ROOT="${CLAUDE_PLUGIN_ROOT:-$(dirname "$(dirname "$0")")}"
 
+# Venv location within plugin (isolated from system Python)
+VENV_DIR="$PLUGIN_ROOT/.venv"
+VENV_PYTHON="$VENV_DIR/bin/python3"
+VENV_PIP="$VENV_DIR/bin/pip"
+
 # Colors for output
 RED='\033[0;31m'
 GREEN='\033[0;32m'
@@ -26,21 +31,24 @@ NC='\033[0m' # No Color
 # Helper Functions
 # =====================
 
-# Install Playwright browser (called after crawl4ai is confirmed installed)
+# Install Playwright browser using specified python
+# Args: $1 = python path to use
 install_playwright_browser() {
+    local PYTHON_CMD="${1:-python3}"
+
     # Check if Playwright Chromium is already installed by testing if browser can be launched
-    if python3 -c "from playwright.sync_api import sync_playwright; p = sync_playwright().start(); b = p.chromium.launch(); b.close(); p.stop()" 2>/dev/null; then
+    if "$PYTHON_CMD" -c "from playwright.sync_api import sync_playwright; p = sync_playwright().start(); b = p.chromium.launch(); b.close(); p.stop()" 2>/dev/null; then
         echo -e "${GREEN}[bluera-knowledge] Playwright Chromium ready ✓${NC}"
         return 0
     fi
 
     echo -e "${YELLOW}[bluera-knowledge] Installing Playwright browser (one-time setup)...${NC}"
-    if python3 -m playwright install chromium 2>/dev/null; then
+    if "$PYTHON_CMD" -m playwright install chromium 2>/dev/null; then
         echo -e "${GREEN}[bluera-knowledge] Playwright Chromium installed ✓${NC}"
         return 0
     else
         echo -e "${YELLOW}[bluera-knowledge] Playwright browser install failed.${NC}"
-        echo -e "${YELLOW}Manual fix: python3 -m playwright install chromium${NC}"
+        echo -e "${YELLOW}Manual fix: $PYTHON_CMD -m playwright install chromium${NC}"
         return 1
     fi
 }
@@ -68,7 +76,7 @@ if [ ! -d "$PLUGIN_ROOT/node_modules" ]; then
 fi
 
 # =====================
-# Python Dependencies
+# Python Dependencies (using venv)
 # =====================
 
 # Check if Python3 is installed
@@ -81,75 +89,56 @@ fi
 
 # Check Python version (require 3.8+)
 python_version=$(python3 -c 'import sys; print(".".join(map(str, sys.version_info[:2])))')
-required_version="3.8"
 
 if ! python3 -c "import sys; exit(0 if sys.version_info >= (3, 8) else 1)"; then
     echo -e "${YELLOW}[bluera-knowledge] Python ${python_version} detected. Python 3.8+ recommended for crawl4ai${NC}"
 fi
 
-# Check if crawl4ai is installed
-if python3 -c "import crawl4ai" 2>/dev/null; then
-    # Already installed - get version
-    crawl4ai_version=$(python3 -c "import crawl4ai; print(crawl4ai.__version__)" 2>/dev/null || echo "unknown")
-    echo -e "${GREEN}[bluera-knowledge] crawl4ai ${crawl4ai_version} is installed ✓${NC}"
+# Check if venv exists and has crawl4ai installed
+if [ -f "$VENV_PYTHON" ] && "$VENV_PYTHON" -c "import crawl4ai" 2>/dev/null; then
+    crawl4ai_version=$("$VENV_PYTHON" -c "import crawl4ai; print(crawl4ai.__version__)" 2>/dev/null || echo "unknown")
+    echo -e "${GREEN}[bluera-knowledge] crawl4ai ${crawl4ai_version} ready (venv) ✓${NC}"
     # Ensure Playwright browser is installed for headless crawling
-    install_playwright_browser
+    install_playwright_browser "$VENV_PYTHON"
     exit 0
 fi
 
-# crawl4ai not installed - attempt installation
-echo -e "${YELLOW}[bluera-knowledge] crawl4ai not found. Web crawling features will be unavailable.${NC}"
-echo ""
-echo -e "${YELLOW}To enable web crawling, install crawl4ai:${NC}"
-echo -e "  ${GREEN}pip install crawl4ai${NC}"
-echo ""
-
 # Check if auto-install is disabled
 if [ "${BK_SKIP_AUTO_INSTALL:-}" = "1" ]; then
     echo -e "${YELLOW}[bluera-knowledge] Auto-install disabled (BK_SKIP_AUTO_INSTALL=1)${NC}"
-    echo -e "${YELLOW}Install manually: pip install crawl4ai && python3 -m playwright install chromium${NC}"
+    echo -e "${YELLOW}To enable web crawling, create venv manually:${NC}"
+    echo -e "  ${GREEN}python3 -m venv $VENV_DIR${NC}"
+    echo -e "  ${GREEN}$VENV_PIP install crawl4ai${NC}"
+    echo -e "  ${GREEN}$VENV_PYTHON -m playwright install chromium${NC}"
     exit 0
 fi
 
-# Check if we should auto-install
-if command -v pip3 &> /dev/null || command -v pip &> /dev/null; then
-    echo -e "${YELLOW}[bluera-knowledge] Auto-installing crawl4ai via pip...${NC}"
-    echo -e "${YELLOW}(Set BK_SKIP_AUTO_INSTALL=1 to disable auto-install)${NC}"
-
-    # Try to install using pip3 or pip
-    if command -v pip3 &> /dev/null; then
-        PIP_CMD="pip3"
+# Create venv if it doesn't exist
+if [ ! -d "$VENV_DIR" ]; then
+    echo -e "${YELLOW}[bluera-knowledge] Creating Python virtual environment...${NC}"
+    if python3 -m venv "$VENV_DIR" 2>/dev/null; then
+        echo -e "${GREEN}[bluera-knowledge] Virtual environment created ✓${NC}"
     else
-        PIP_CMD="pip"
+        echo -e "${RED}[bluera-knowledge] Failed to create virtual environment${NC}"
+        echo -e "${YELLOW}Manual fix: python3 -m venv $VENV_DIR${NC}"
+        exit 0
     fi
+fi
 
-    # Try with --break-system-packages for PEP 668 environments (Python 3.11+)
-    # This is needed on modern Python versions (macOS Homebrew, some Linux distros)
-    if $PIP_CMD install --quiet --break-system-packages crawl4ai 2>/dev/null; then
-        echo -e "${GREEN}[bluera-knowledge] Successfully installed crawl4ai ✓${NC}"
-        crawl4ai_version=$(python3 -c "import crawl4ai; print(crawl4ai.__version__)" 2>/dev/null || echo "installed")
-        echo -e "${GREEN}[bluera-knowledge] crawl4ai ${crawl4ai_version} ready${NC}"
-        # Install Playwright browser for headless crawling
-        install_playwright_browser
-    else
-        # Fallback: try without --break-system-packages for older Python
-        if $PIP_CMD install --quiet --user crawl4ai 2>/dev/null; then
-            echo -e "${GREEN}[bluera-knowledge] Successfully installed crawl4ai ✓${NC}"
-            crawl4ai_version=$(python3 -c "import crawl4ai; print(crawl4ai.__version__)" 2>/dev/null || echo "installed")
-            echo -e "${GREEN}[bluera-knowledge] crawl4ai ${crawl4ai_version} ready${NC}"
-            # Install Playwright browser for headless crawling
-            install_playwright_browser
-        else
-            echo -e "${RED}[bluera-knowledge] Auto-installation failed${NC}"
-            echo ""
-            echo -e "${YELLOW}For Python 3.11+ (externally-managed), install manually:${NC}"
-            echo -e "  ${GREEN}pip install --break-system-packages crawl4ai${NC}"
-            echo -e "${YELLOW}Or use a virtual environment:${NC}"
-            echo -e "  ${GREEN}python3 -m venv venv && source venv/bin/activate && pip install crawl4ai${NC}"
-        fi
-    fi
+# Install crawl4ai into venv
+echo -e "${YELLOW}[bluera-knowledge] Installing crawl4ai into virtual environment...${NC}"
+echo -e "${YELLOW}(Set BK_SKIP_AUTO_INSTALL=1 to disable auto-install)${NC}"
+
+if "$VENV_PIP" install --quiet crawl4ai 2>/dev/null; then
+    crawl4ai_version=$("$VENV_PYTHON" -c "import crawl4ai; print(crawl4ai.__version__)" 2>/dev/null || echo "installed")
+    echo -e "${GREEN}[bluera-knowledge] crawl4ai ${crawl4ai_version} installed (venv) ✓${NC}"
+    # Install Playwright browser for headless crawling
+    install_playwright_browser "$VENV_PYTHON"
 else
-    echo -e "${YELLOW}pip not found. Please install crawl4ai manually.${NC}"
+    echo -e "${RED}[bluera-knowledge] Failed to install crawl4ai${NC}"
+    echo -e "${YELLOW}Manual fix:${NC}"
+    echo -e "  ${GREEN}$VENV_PIP install crawl4ai${NC}"
+    echo -e "  ${GREEN}$VENV_PYTHON -m playwright install chromium${NC}"
 fi
 
 # Always exit 0 to not block the session

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bluera-knowledge",
-  "version": "0.13.2",
+  "version": "0.14.0",
   "description": "CLI tool for managing knowledge stores with semantic search",
   "type": "module",
   "bin": {

package/src/crawl/bridge.test.ts

@@ -78,7 +78,7 @@ describe('PythonBridge', () => {
 
       expect(spawn).toHaveBeenCalledWith(
         'python3',
-        ['python/crawl_worker.py'],
+        [expect.stringMatching(/.*\/python\/crawl_worker\.py$/)],
         expect.objectContaining({
           stdio: ['pipe', 'pipe', 'pipe'],
         })

package/src/crawl/bridge.ts

@@ -1,6 +1,9 @@
 import { spawn, type ChildProcess } from 'node:child_process';
 import { randomUUID } from 'node:crypto';
+import { existsSync } from 'node:fs';
+import path from 'node:path';
 import { createInterface, type Interface as ReadlineInterface } from 'node:readline';
+import { fileURLToPath } from 'node:url';
 import { ZodError } from 'zod';
 import {
   type CrawlResult,
@@ -37,9 +40,39 @@ export class PythonBridge {
   start(): Promise<void> {
     if (this.process) return Promise.resolve();
 
-    logger.debug('Starting Python bridge process');
+    // Compute absolute path to Python worker using import.meta.url
+    // This works both in development (src/) and production (dist/)
+    const currentFilePath = fileURLToPath(import.meta.url);
+    const isProduction = currentFilePath.includes('/dist/');
+
+    let pythonWorkerPath: string;
+    let pythonPath: string;
+
+    if (isProduction) {
+      // Production: Find dist dir and go to sibling python/ directory
+      const distIndex = currentFilePath.indexOf('/dist/');
+      const pluginRoot = currentFilePath.substring(0, distIndex);
+      pythonWorkerPath = path.join(pluginRoot, 'python', 'crawl_worker.py');
+
+      // Use venv python if available (installed by check-dependencies.sh hook)
+      const venvPython = path.join(pluginRoot, '.venv', 'bin', 'python3');
+      pythonPath = existsSync(venvPython) ? venvPython : 'python3';
+    } else {
+      // Development: Go up from src/crawl to find python/
+      const srcDir = path.dirname(path.dirname(currentFilePath));
+      const projectRoot = path.dirname(srcDir);
+      pythonWorkerPath = path.join(projectRoot, 'python', 'crawl_worker.py');
+
+      // Development: Use system python (user manages their own environment)
+      pythonPath = 'python3';
+    }
+
+    logger.debug(
+      { pythonWorkerPath, pythonPath, currentFilePath, isProduction },
+      'Starting Python bridge process'
+    );
 
-    this.process = spawn('python3', ['python/crawl_worker.py'], {
+    this.process = spawn(pythonPath, [pythonWorkerPath], {
       stdio: ['pipe', 'pipe', 'pipe'],
     });
 

package/src/mcp/commands/index.ts

@@ -10,12 +10,14 @@ import { metaCommands } from './meta.commands.js';
 import { commandRegistry } from './registry.js';
 import { storeCommands } from './store.commands.js';
 import { syncCommands } from './sync.commands.js';
+import { uninstallCommands } from './uninstall.commands.js';
 
 // Register all commands
 commandRegistry.registerAll(storeCommands);
 commandRegistry.registerAll(jobCommands);
 commandRegistry.registerAll(metaCommands);
 commandRegistry.registerAll(syncCommands);
+commandRegistry.registerAll(uninstallCommands);
 
 // Re-export for convenience
 export { commandRegistry, executeCommand, generateHelp } from './registry.js';

package/src/mcp/commands/uninstall.commands.test.ts

@@ -0,0 +1,37 @@
+import { describe, it, expect } from 'vitest';
+import { uninstallCommands } from './uninstall.commands.js';
+
+describe('uninstall.commands', () => {
+  it('should export uninstall command', () => {
+    expect(uninstallCommands).toHaveLength(1);
+    expect(uninstallCommands[0].name).toBe('uninstall');
+  });
+
+  it('should have correct command definition', () => {
+    const cmd = uninstallCommands[0];
+    expect(cmd.description).toContain('Remove Bluera Knowledge data');
+    expect(cmd.argsSchema).toBeDefined();
+    expect(cmd.handler).toBeTypeOf('function');
+  });
+
+  it('should have valid schema for global and keepDefinitions options', () => {
+    const cmd = uninstallCommands[0];
+    const schema = cmd.argsSchema;
+
+    // Validate the schema accepts expected args
+    const result = schema?.safeParse({
+      global: true,
+      keepDefinitions: false,
+    });
+    expect(result?.success).toBe(true);
+  });
+
+  it('should have optional args in schema', () => {
+    const cmd = uninstallCommands[0];
+    const schema = cmd.argsSchema;
+
+    // Empty args should be valid
+    const result = schema?.safeParse({});
+    expect(result?.success).toBe(true);
+  });
+});

package/src/mcp/commands/uninstall.commands.ts

@@ -0,0 +1,29 @@
+import { z } from 'zod';
+import { handleUninstall } from '../handlers/uninstall.handler.js';
+import type { CommandDefinition } from './registry.js';
+import type { UninstallArgs } from '../handlers/uninstall.handler.js';
+
+/**
+ * Uninstall commands for removing Bluera Knowledge data
+ *
+ * Provides cleanup functionality for testing fresh installs or removing the plugin.
+ */
+/* eslint-disable @typescript-eslint/consistent-type-assertions */
+export const uninstallCommands: CommandDefinition[] = [
+  {
+    name: 'uninstall',
+    description: 'Remove Bluera Knowledge data from project (and optionally global data)',
+    argsSchema: z.object({
+      global: z
+        .boolean()
+        .optional()
+        .describe('Also remove global data (~/.local/share/bluera-knowledge)'),
+      keepDefinitions: z
+        .boolean()
+        .optional()
+        .describe('Keep stores.config.json for team sharing (default: true)'),
+    }),
+    handler: (args, context) => handleUninstall(args as unknown as UninstallArgs, context),
+  },
+];
+/* eslint-enable @typescript-eslint/consistent-type-assertions */

package/src/mcp/handlers/uninstall.handler.test.ts

@@ -0,0 +1,194 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { existsSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import { tmpdir } from 'os';
+import { handleUninstall } from './uninstall.handler.js';
+import type { HandlerContext } from '../types.js';
+import type { UninstallArgs } from './uninstall.handler.js';
+
+// Mock os module to control homedir for testing global data deletion
+vi.mock('node:os', async () => {
+  const actual = await vi.importActual<typeof import('node:os')>('node:os');
+  return {
+    ...actual,
+    homedir: vi.fn(() => actual.homedir()),
+  };
+});
+
+describe('uninstall.handler', () => {
+  let tempDir: string;
+  let projectRoot: string;
+  let mockContext: HandlerContext;
+
+  beforeEach(() => {
+    tempDir = mkdtempSync(join(tmpdir(), 'uninstall-handler-test-'));
+    projectRoot = tempDir;
+
+    // Create minimal mock context - uninstall handler doesn't use services
+    mockContext = {
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+      services: {} as HandlerContext['services'],
+      options: { projectRoot },
+    };
+  });
+
+  afterEach(() => {
+    rmSync(tempDir, { recursive: true, force: true });
+    vi.restoreAllMocks();
+  });
+
+  describe('handleUninstall', () => {
+    it('should delete project data when it exists', async () => {
+      // Create project data structure
+      const bkDir = join(projectRoot, '.bluera', 'bluera-knowledge');
+      const dataDir = join(bkDir, 'data');
+      mkdirSync(dataDir, { recursive: true });
+      writeFileSync(join(bkDir, 'config.json'), '{}');
+      writeFileSync(join(dataDir, 'stores.json'), '[]');
+
+      const args: UninstallArgs = {};
+      const result = await handleUninstall(args, mockContext);
+
+      // Verify deletion
+      expect(existsSync(join(bkDir, 'data'))).toBe(false);
+      expect(existsSync(join(bkDir, 'config.json'))).toBe(false);
+
+      // Verify response
+      expect(result.content[0].type).toBe('text');
+      expect(result.content[0].text).toContain('Deleted:');
+      expect(result.content[0].text).toContain('plugin cache');
+    });
+
+    it('should preserve stores.config.json by default', async () => {
+      // Create project data structure
+      const bkDir = join(projectRoot, '.bluera', 'bluera-knowledge');
+      const dataDir = join(bkDir, 'data');
+      mkdirSync(dataDir, { recursive: true });
+      writeFileSync(join(bkDir, 'config.json'), '{}');
+      writeFileSync(join(bkDir, 'stores.config.json'), '{"stores":[]}');
+      writeFileSync(join(dataDir, 'stores.json'), '[]');
+
+      const args: UninstallArgs = { keepDefinitions: true };
+      const result = await handleUninstall(args, mockContext);
+
+      // Verify stores.config.json is preserved
+      expect(existsSync(join(bkDir, 'stores.config.json'))).toBe(true);
+      expect(existsSync(join(bkDir, 'data'))).toBe(false);
+      expect(existsSync(join(bkDir, 'config.json'))).toBe(false);
+
+      // Verify response mentions preserved files
+      expect(result.content[0].text).toContain('Preserved:');
+      expect(result.content[0].text).toContain('stores.config.json');
+    });
+
+    it('should delete stores.config.json when keepDefinitions is false', async () => {
+      // Create project data structure
+      const bkDir = join(projectRoot, '.bluera', 'bluera-knowledge');
+      mkdirSync(bkDir, { recursive: true });
+      writeFileSync(join(bkDir, 'stores.config.json'), '{"stores":[]}');
+
+      const args: UninstallArgs = { keepDefinitions: false };
+      const result = await handleUninstall(args, mockContext);
+
+      // Verify entire directory is gone
+      expect(existsSync(bkDir)).toBe(false);
+
+      // Verify response
+      expect(result.content[0].text).toContain('Deleted:');
+      expect(result.content[0].text).not.toContain('Preserved:');
+    });
+
+    it('should handle missing project data gracefully', async () => {
+      const args: UninstallArgs = {};
+      const result = await handleUninstall(args, mockContext);
+
+      // Verify response indicates nothing to delete
+      expect(result.content[0].text).toContain('No data found to delete');
+      expect(result.content[0].text).toContain('plugin cache');
+    });
+
+    it('should always include plugin cache instructions', async () => {
+      const args: UninstallArgs = {};
+      const result = await handleUninstall(args, mockContext);
+
+      expect(result.content[0].text).toContain('To fully uninstall (clear plugin cache):');
+      expect(result.content[0].text).toContain('~/.claude/plugins/cache/bluera-knowledge-*');
+    });
+
+    it('should mention venv is cleaned with plugin cache', async () => {
+      const args: UninstallArgs = {};
+      const result = await handleUninstall(args, mockContext);
+
+      expect(result.content[0].text).toContain('Python venv');
+      expect(result.content[0].text).toContain('all dependencies');
+    });
+
+    it('should handle subdirectories in data folder', async () => {
+      // Create nested structure
+      const bkDir = join(projectRoot, '.bluera', 'bluera-knowledge');
+      const reposDir = join(bkDir, 'data', 'repos', 'test-repo');
+      mkdirSync(reposDir, { recursive: true });
+      writeFileSync(join(reposDir, 'file.txt'), 'test');
+
+      const args: UninstallArgs = {};
+      await handleUninstall(args, mockContext);
+
+      // Verify everything is deleted
+      expect(existsSync(join(bkDir, 'data'))).toBe(false);
+    });
+
+    it('should delete global data when global flag is true', async () => {
+      // Mock homedir to return our temp directory
+      const { homedir } = await import('node:os');
+      vi.mocked(homedir).mockReturnValue(tempDir);
+
+      // Create fake global data directory
+      const globalDir = join(tempDir, '.local', 'share', 'bluera-knowledge');
+      mkdirSync(globalDir, { recursive: true });
+      writeFileSync(join(globalDir, 'jobs.json'), '[]');
+
+      const args: UninstallArgs = { global: true };
+      const result = await handleUninstall(args, mockContext);
+
+      // Verify global data was deleted
+      expect(existsSync(globalDir)).toBe(false);
+      expect(result.content[0].text).toContain('Deleted:');
+      expect(result.content[0].text).toContain('.local/share/bluera-knowledge');
+    });
+
+    it('should handle global flag when global data does not exist', async () => {
+      // Mock homedir to return our temp directory (no global data exists)
+      const { homedir } = await import('node:os');
+      vi.mocked(homedir).mockReturnValue(tempDir);
+
+      const args: UninstallArgs = { global: true };
+      const result = await handleUninstall(args, mockContext);
+
+      // The handler should still complete without errors
+      expect(result.content[0].text).toContain('plugin cache');
+    });
+
+    it('should report global data deletion in result', async () => {
+      // Mock homedir to return our temp directory
+      const { homedir } = await import('node:os');
+      vi.mocked(homedir).mockReturnValue(tempDir);
+
+      // Create both project and global data
+      const bkDir = join(projectRoot, '.bluera', 'bluera-knowledge');
+      mkdirSync(bkDir, { recursive: true });
+      writeFileSync(join(bkDir, 'config.json'), '{}');
+
+      const globalDir = join(tempDir, '.local', 'share', 'bluera-knowledge');
+      mkdirSync(globalDir, { recursive: true });
+      writeFileSync(join(globalDir, 'jobs.json'), '[]');
+
+      const args: UninstallArgs = { global: true, keepDefinitions: false };
+      const result = await handleUninstall(args, mockContext);
+
+      // Verify both were deleted
+      expect(existsSync(bkDir)).toBe(false);
+      expect(existsSync(globalDir)).toBe(false);
+      expect(result.content[0].text).toContain('Deleted:');
+    });
+  });
+});