@laststance/claude-plugin-dashboard 0.1.0

package/dist/components/SearchInput.js

@@ -0,0 +1,14 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * SearchInput component
+ * Filter/search box for the plugin list
+ */
+import { Box, Text } from 'ink';
+/**
+ * Search input display (read-only display, actual input handled by useInput)
+ * @example
+ * <SearchInput query={searchQuery} isActive={isSearchMode} />
+ */
+export default function SearchInput({ query, isActive = false, placeholder = 'Type to search...', }) {
+    return (_jsxs(Box, { borderStyle: isActive ? 'round' : 'single', borderColor: isActive ? 'cyan' : 'gray', paddingX: 1, children: [_jsx(Text, { color: isActive ? 'cyan' : 'gray', children: "Q " }), query ? _jsx(Text, { children: query }) : _jsx(Text, { dimColor: true, children: placeholder }), isActive && _jsx(Text, { color: "cyan", children: "\u258C" })] }));
+}

package/dist/components/SortDropdown.d.ts

@@ -0,0 +1,21 @@
+/**
+ * SortDropdown component
+ * Displays current sort option
+ */
+type SortBy = 'installs' | 'name' | 'date';
+type SortOrder = 'asc' | 'desc';
+interface SortDropdownProps {
+    sortBy: SortBy;
+    sortOrder: SortOrder;
+}
+/**
+ * Displays the current sort option
+ * @example
+ * <SortDropdown sortBy="installs" sortOrder="desc" />
+ */
+export default function SortDropdown({ sortBy, sortOrder }: SortDropdownProps): import("react/jsx-runtime").JSX.Element;
+/**
+ * Get next sort option in cycle
+ */
+export declare function getNextSort(current: SortBy): SortBy;
+export {};

package/dist/components/SortDropdown.js

@@ -0,0 +1,29 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * SortDropdown component
+ * Displays current sort option
+ */
+import { Box, Text } from 'ink';
+const SORT_LABELS = {
+    installs: 'Installs',
+    name: 'Name',
+    date: 'Date',
+};
+/**
+ * Displays the current sort option
+ * @example
+ * <SortDropdown sortBy="installs" sortOrder="desc" />
+ */
+export default function SortDropdown({ sortBy, sortOrder }) {
+    const label = SORT_LABELS[sortBy];
+    const arrow = sortOrder === 'desc' ? '▼' : '▲';
+    return (_jsxs(Box, { gap: 1, children: [_jsx(Text, { dimColor: true, children: "Sort:" }), _jsx(Text, { color: "cyan", children: label }), _jsx(Text, { color: "cyan", children: arrow })] }));
+}
+/**
+ * Get next sort option in cycle
+ */
+export function getNextSort(current) {
+    const options = ['installs', 'name', 'date'];
+    const currentIndex = options.indexOf(current);
+    return options[(currentIndex + 1) % options.length];
+}

package/dist/components/StatusIcon.d.ts

@@ -0,0 +1,20 @@
+/**
+ * StatusIcon component
+ * Displays plugin status with colored icons:
+ * - ● (green) = Installed & Enabled
+ * - ◐ (yellow) = Installed & Disabled
+ * - ○ (gray) = Not installed
+ */
+interface StatusIconProps {
+    isInstalled: boolean;
+    isEnabled: boolean;
+}
+/**
+ * Displays a status icon based on plugin installation and enabled state
+ * @example
+ * <StatusIcon isInstalled={true} isEnabled={true} />  // ● (green)
+ * <StatusIcon isInstalled={true} isEnabled={false} /> // ◐ (yellow)
+ * <StatusIcon isInstalled={false} isEnabled={false} /> // ○ (gray)
+ */
+export default function StatusIcon({ isInstalled, isEnabled, }: StatusIconProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/StatusIcon.js

@@ -0,0 +1,25 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * StatusIcon component
+ * Displays plugin status with colored icons:
+ * - ● (green) = Installed & Enabled
+ * - ◐ (yellow) = Installed & Disabled
+ * - ○ (gray) = Not installed
+ */
+import { Text } from 'ink';
+/**
+ * Displays a status icon based on plugin installation and enabled state
+ * @example
+ * <StatusIcon isInstalled={true} isEnabled={true} />  // ● (green)
+ * <StatusIcon isInstalled={true} isEnabled={false} /> // ◐ (yellow)
+ * <StatusIcon isInstalled={false} isEnabled={false} /> // ○ (gray)
+ */
+export default function StatusIcon({ isInstalled, isEnabled, }) {
+    if (isInstalled && isEnabled) {
+        return _jsx(Text, { color: "green", children: "\u25CF" });
+    }
+    if (isInstalled && !isEnabled) {
+        return _jsx(Text, { color: "yellow", children: "\u25D0" });
+    }
+    return _jsx(Text, { color: "gray", children: "\u25CB" });
+}

package/dist/components/TabBar.d.ts

@@ -0,0 +1,24 @@
+/**
+ * TabBar component
+ * Horizontal tab navigation for the dashboard
+ * Supports ← → arrow key navigation
+ */
+type Tab = 'discover' | 'installed' | 'marketplaces' | 'errors';
+interface TabBarProps {
+    activeTab: Tab;
+    onTabChange?: (tab: Tab) => void;
+}
+/**
+ * Horizontal tab bar component
+ * @example
+ * <TabBar activeTab="discover" onTabChange={setActiveTab} />
+ */
+export default function TabBar({ activeTab }: TabBarProps): import("react/jsx-runtime").JSX.Element;
+/**
+ * Get the next tab in the cycle
+ * @param currentTab - Current active tab
+ * @param direction - Navigation direction
+ * @returns Next tab ID
+ */
+export declare function getNextTab(currentTab: Tab, direction: 'next' | 'prev'): Tab;
+export {};

package/dist/components/TabBar.js

@@ -0,0 +1,38 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * TabBar component
+ * Horizontal tab navigation for the dashboard
+ * Supports ← → arrow key navigation
+ */
+import { Box, Text } from 'ink';
+const TABS = [
+    { id: 'discover', label: 'Discover' },
+    { id: 'installed', label: 'Installed' },
+    { id: 'marketplaces', label: 'Marketplaces' },
+    { id: 'errors', label: 'Errors' },
+];
+/**
+ * Horizontal tab bar component
+ * @example
+ * <TabBar activeTab="discover" onTabChange={setActiveTab} />
+ */
+export default function TabBar({ activeTab }) {
+    return (_jsx(Box, { gap: 2, marginBottom: 1, children: TABS.map((tab) => {
+            const isActive = tab.id === activeTab;
+            return (_jsx(Box, { children: isActive ? (_jsx(Text, { bold: true, color: "cyan", backgroundColor: "#333333", children: ` ${tab.label} ` })) : (_jsx(Text, { color: "gray", children: ` ${tab.label} ` })) }, tab.id));
+        }) }));
+}
+/**
+ * Get the next tab in the cycle
+ * @param currentTab - Current active tab
+ * @param direction - Navigation direction
+ * @returns Next tab ID
+ */
+export function getNextTab(currentTab, direction) {
+    const currentIndex = TABS.findIndex((t) => t.id === currentTab);
+    const tabCount = TABS.length;
+    const newIndex = direction === 'next'
+        ? (currentIndex + 1) % tabCount
+        : (currentIndex - 1 + tabCount) % tabCount;
+    return TABS[newIndex].id;
+}

package/dist/services/fileService.d.ts

@@ -0,0 +1,41 @@
+/**
+ * File service for safe JSON read/write operations
+ * Provides atomic writes and proper error handling
+ */
+/**
+ * Safely read a JSON file with error handling
+ * @param filePath - Absolute path to JSON file
+ * @returns Parsed JSON or null if file doesn't exist
+ * @throws Error if file exists but contains invalid JSON
+ * @example
+ * const data = readJsonFile<Settings>('/path/to/settings.json');
+ * // Returns parsed Settings or null
+ */
+export declare function readJsonFile<T>(filePath: string): T | null;
+/**
+ * Safely write a JSON file with atomic write (write to temp, then rename)
+ * @param filePath - Absolute path to JSON file
+ * @param data - Data to write
+ * @throws Error if write fails
+ * @example
+ * writeJsonFile('/path/to/settings.json', { enabledPlugins: {} });
+ */
+export declare function writeJsonFile<T>(filePath: string, data: T): void;
+/**
+ * Check if a directory exists
+ * @param dirPath - Absolute path to directory
+ * @returns true if directory exists
+ */
+export declare function directoryExists(dirPath: string): boolean;
+/**
+ * Check if a file exists
+ * @param filePath - Absolute path to file
+ * @returns true if file exists
+ */
+export declare function fileExists(filePath: string): boolean;
+/**
+ * List directories in a directory
+ * @param dirPath - Absolute path to directory
+ * @returns Array of directory names (not full paths)
+ */
+export declare function listDirectories(dirPath: string): string[];

package/dist/services/fileService.js

@@ -0,0 +1,104 @@
+/**
+ * File service for safe JSON read/write operations
+ * Provides atomic writes and proper error handling
+ */
+import * as fs from 'node:fs';
+/**
+ * Safely read a JSON file with error handling
+ * @param filePath - Absolute path to JSON file
+ * @returns Parsed JSON or null if file doesn't exist
+ * @throws Error if file exists but contains invalid JSON
+ * @example
+ * const data = readJsonFile<Settings>('/path/to/settings.json');
+ * // Returns parsed Settings or null
+ */
+export function readJsonFile(filePath) {
+    try {
+        if (!fs.existsSync(filePath)) {
+            return null;
+        }
+        const content = fs.readFileSync(filePath, 'utf-8');
+        return JSON.parse(content);
+    }
+    catch (error) {
+        if (error instanceof SyntaxError) {
+            throw new Error(`Invalid JSON in ${filePath}: ${error.message}`);
+        }
+        throw error;
+    }
+}
+/**
+ * Safely write a JSON file with atomic write (write to temp, then rename)
+ * @param filePath - Absolute path to JSON file
+ * @param data - Data to write
+ * @throws Error if write fails
+ * @example
+ * writeJsonFile('/path/to/settings.json', { enabledPlugins: {} });
+ */
+export function writeJsonFile(filePath, data) {
+    const tempPath = `${filePath}.tmp`;
+    try {
+        const content = JSON.stringify(data, null, 2) + '\n';
+        // Write to temp file first
+        fs.writeFileSync(tempPath, content, 'utf-8');
+        // Atomic rename
+        fs.renameSync(tempPath, filePath);
+    }
+    catch (error) {
+        // Cleanup temp file on error
+        if (fs.existsSync(tempPath)) {
+            try {
+                fs.unlinkSync(tempPath);
+            }
+            catch {
+                // Ignore cleanup errors
+            }
+        }
+        throw new Error(`Failed to write ${filePath}: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+}
+/**
+ * Check if a directory exists
+ * @param dirPath - Absolute path to directory
+ * @returns true if directory exists
+ */
+export function directoryExists(dirPath) {
+    try {
+        return fs.existsSync(dirPath) && fs.statSync(dirPath).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Check if a file exists
+ * @param filePath - Absolute path to file
+ * @returns true if file exists
+ */
+export function fileExists(filePath) {
+    try {
+        return fs.existsSync(filePath) && fs.statSync(filePath).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * List directories in a directory
+ * @param dirPath - Absolute path to directory
+ * @returns Array of directory names (not full paths)
+ */
+export function listDirectories(dirPath) {
+    try {
+        if (!directoryExists(dirPath)) {
+            return [];
+        }
+        return fs.readdirSync(dirPath).filter((name) => {
+            const fullPath = `${dirPath}/${name}`;
+            return fs.statSync(fullPath).isDirectory();
+        });
+    }
+    catch {
+        return [];
+    }
+}

package/dist/services/pluginActionsService.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Plugin actions service for install/uninstall operations
+ * Executes `claude plugin install/uninstall` as subprocess
+ */
+export interface PluginActionResult {
+    success: boolean;
+    message: string;
+    error?: string;
+}
+/**
+ * Install a plugin via Claude CLI
+ * @param pluginId - Plugin identifier (e.g., "context7@claude-plugins-official")
+ * @returns Promise resolving to action result
+ */
+export declare function installPlugin(pluginId: string): Promise<PluginActionResult>;
+/**
+ * Uninstall a plugin via Claude CLI
+ * @param pluginId - Plugin identifier
+ * @returns Promise resolving to action result
+ */
+export declare function uninstallPlugin(pluginId: string): Promise<PluginActionResult>;

package/dist/services/pluginActionsService.js

@@ -0,0 +1,65 @@
+/**
+ * Plugin actions service for install/uninstall operations
+ * Executes `claude plugin install/uninstall` as subprocess
+ */
+import { spawn } from 'node:child_process';
+/**
+ * Install a plugin via Claude CLI
+ * @param pluginId - Plugin identifier (e.g., "context7@claude-plugins-official")
+ * @returns Promise resolving to action result
+ */
+export function installPlugin(pluginId) {
+    return executePluginAction('install', pluginId);
+}
+/**
+ * Uninstall a plugin via Claude CLI
+ * @param pluginId - Plugin identifier
+ * @returns Promise resolving to action result
+ */
+export function uninstallPlugin(pluginId) {
+    return executePluginAction('uninstall', pluginId);
+}
+/**
+ * Execute a plugin command (install/uninstall)
+ * @param action - 'install' or 'uninstall'
+ * @param pluginId - Plugin identifier
+ * @returns Promise resolving to action result
+ */
+function executePluginAction(action, pluginId) {
+    return new Promise((resolve) => {
+        const child = spawn('claude', ['plugin', action, pluginId], {
+            stdio: ['ignore', 'pipe', 'pipe'],
+            shell: false,
+        });
+        let stdout = '';
+        let stderr = '';
+        child.stdout?.on('data', (data) => {
+            stdout += data.toString();
+        });
+        child.stderr?.on('data', (data) => {
+            stderr += data.toString();
+        });
+        child.on('close', (code) => {
+            if (code === 0) {
+                resolve({
+                    success: true,
+                    message: `${action === 'install' ? 'Installed' : 'Uninstalled'} ${pluginId}`,
+                });
+            }
+            else {
+                resolve({
+                    success: false,
+                    message: `Failed to ${action} ${pluginId}`,
+                    error: stderr || stdout || `Exit code: ${code}`,
+                });
+            }
+        });
+        child.on('error', (err) => {
+            resolve({
+                success: false,
+                message: 'Failed to execute claude command',
+                error: err.message,
+            });
+        });
+    });
+}

package/dist/services/pluginService.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Plugin service for aggregating plugin data from multiple sources
+ * Combines data from marketplace.json, installed_plugins.json, settings.json, etc.
+ */
+import type { Plugin, Marketplace } from '../types/index.js';
+/**
+ * Load all plugins from all marketplaces
+ * Aggregates data from marketplace.json, installed_plugins.json, settings.json, and install-counts-cache.json
+ * @returns Array of aggregated Plugin objects sorted by install count (descending)
+ * @example
+ * const plugins = await loadAllPlugins();
+ * console.log(`Found ${plugins.length} plugins`);
+ */
+export declare function loadAllPlugins(): Plugin[];
+/**
+ * Load installed plugins only
+ * @returns Array of installed Plugin objects
+ * @example
+ * const installed = loadInstalledPlugins();
+ * console.log(`${installed.length} plugins installed`);
+ */
+export declare function loadInstalledPlugins(): Plugin[];
+/**
+ * Load enabled plugins only
+ * @returns Array of enabled Plugin objects
+ */
+export declare function loadEnabledPlugins(): Plugin[];
+/**
+ * Load all known marketplaces
+ * @returns Array of Marketplace objects
+ * @example
+ * const marketplaces = loadMarketplaces();
+ * console.log(`Found ${marketplaces.length} marketplaces`);
+ */
+export declare function loadMarketplaces(): Marketplace[];
+/**
+ * Get a single plugin by ID
+ * @param pluginId - Plugin identifier (e.g., "context7@claude-plugins-official")
+ * @returns Plugin object or undefined if not found
+ */
+export declare function getPluginById(pluginId: string): Plugin | undefined;
+/**
+ * Search plugins by query
+ * @param query - Search query
+ * @param plugins - Plugins to search (defaults to all plugins)
+ * @returns Filtered plugins matching the query
+ */
+export declare function searchPlugins(query: string, plugins?: Plugin[]): Plugin[];
+/**
+ * Sort plugins by field
+ * @param plugins - Plugins to sort
+ * @param sortBy - Field to sort by
+ * @param order - Sort order
+ * @returns Sorted plugins array
+ */
+export declare function sortPlugins(plugins: Plugin[], sortBy: 'installs' | 'name' | 'date', order: 'asc' | 'desc'): Plugin[];
+/**
+ * Get plugin statistics
+ * @returns Object with various plugin counts
+ */
+export declare function getPluginStatistics(): {
+    total: number;
+    installed: number;
+    enabled: number;
+    marketplaces: number;
+};

package/dist/services/pluginService.js

@@ -0,0 +1,188 @@
+/**
+ * Plugin service for aggregating plugin data from multiple sources
+ * Combines data from marketplace.json, installed_plugins.json, settings.json, etc.
+ */
+import { readJsonFile, directoryExists, listDirectories, } from './fileService.js';
+import { getEnabledPlugins } from './settingsService.js';
+import { PATHS, getMarketplaceJsonPath } from '../utils/paths.js';
+/**
+ * Load all plugins from all marketplaces
+ * Aggregates data from marketplace.json, installed_plugins.json, settings.json, and install-counts-cache.json
+ * @returns Array of aggregated Plugin objects sorted by install count (descending)
+ * @example
+ * const plugins = await loadAllPlugins();
+ * console.log(`Found ${plugins.length} plugins`);
+ */
+export function loadAllPlugins() {
+    // Load data from all sources
+    const installed = readJsonFile(PATHS.installedPlugins);
+    const counts = readJsonFile(PATHS.installCountsCache);
+    const enabledPlugins = getEnabledPlugins();
+    // Build lookup maps
+    const installedMap = new Map();
+    if (installed?.plugins) {
+        for (const [pluginId, entries] of Object.entries(installed.plugins)) {
+            if (entries[0]) {
+                installedMap.set(pluginId, entries[0]);
+            }
+        }
+    }
+    const countsMap = new Map();
+    if (counts?.counts) {
+        for (const entry of counts.counts) {
+            countsMap.set(entry.plugin, entry.unique_installs);
+        }
+    }
+    // Scan all marketplaces
+    const plugins = [];
+    if (directoryExists(PATHS.marketplacesDir)) {
+        const marketplaces = listDirectories(PATHS.marketplacesDir);
+        for (const marketplace of marketplaces) {
+            const manifestPath = getMarketplaceJsonPath(marketplace);
+            const manifest = readJsonFile(manifestPath);
+            if (manifest?.plugins) {
+                for (const plugin of manifest.plugins) {
+                    const pluginId = `${plugin.name}@${marketplace}`;
+                    const installedEntry = installedMap.get(pluginId);
+                    plugins.push({
+                        id: pluginId,
+                        name: plugin.name,
+                        marketplace,
+                        description: plugin.description || '',
+                        version: installedEntry?.version || plugin.version || 'unknown',
+                        installCount: countsMap.get(pluginId) || 0,
+                        isInstalled: installedMap.has(pluginId),
+                        isEnabled: enabledPlugins[pluginId] ?? false,
+                        installedAt: installedEntry?.installedAt,
+                        lastUpdated: installedEntry?.lastUpdated,
+                        category: plugin.category,
+                        author: plugin.author,
+                        homepage: plugin.homepage,
+                        tags: plugin.tags || plugin.keywords,
+                        isLocal: installedEntry?.isLocal,
+                        gitCommitSha: installedEntry?.gitCommitSha,
+                    });
+                }
+            }
+        }
+    }
+    // Sort by install count (descending)
+    plugins.sort((a, b) => b.installCount - a.installCount);
+    return plugins;
+}
+/**
+ * Load installed plugins only
+ * @returns Array of installed Plugin objects
+ * @example
+ * const installed = loadInstalledPlugins();
+ * console.log(`${installed.length} plugins installed`);
+ */
+export function loadInstalledPlugins() {
+    const allPlugins = loadAllPlugins();
+    return allPlugins.filter((p) => p.isInstalled);
+}
+/**
+ * Load enabled plugins only
+ * @returns Array of enabled Plugin objects
+ */
+export function loadEnabledPlugins() {
+    const allPlugins = loadAllPlugins();
+    return allPlugins.filter((p) => p.isEnabled);
+}
+/**
+ * Load all known marketplaces
+ * @returns Array of Marketplace objects
+ * @example
+ * const marketplaces = loadMarketplaces();
+ * console.log(`Found ${marketplaces.length} marketplaces`);
+ */
+export function loadMarketplaces() {
+    const known = readJsonFile(PATHS.knownMarketplaces);
+    if (!known) {
+        return [];
+    }
+    const marketplaces = [];
+    for (const [id, data] of Object.entries(known)) {
+        // Count plugins in this marketplace
+        const manifestPath = getMarketplaceJsonPath(id);
+        const manifest = readJsonFile(manifestPath);
+        const pluginCount = manifest?.plugins?.length || 0;
+        marketplaces.push({
+            id,
+            name: manifest?.name || id,
+            source: data.source,
+            installLocation: data.installLocation,
+            lastUpdated: data.lastUpdated,
+            pluginCount,
+        });
+    }
+    // Sort by plugin count (descending)
+    marketplaces.sort((a, b) => (b.pluginCount || 0) - (a.pluginCount || 0));
+    return marketplaces;
+}
+/**
+ * Get a single plugin by ID
+ * @param pluginId - Plugin identifier (e.g., "context7@claude-plugins-official")
+ * @returns Plugin object or undefined if not found
+ */
+export function getPluginById(pluginId) {
+    const allPlugins = loadAllPlugins();
+    return allPlugins.find((p) => p.id === pluginId);
+}
+/**
+ * Search plugins by query
+ * @param query - Search query
+ * @param plugins - Plugins to search (defaults to all plugins)
+ * @returns Filtered plugins matching the query
+ */
+export function searchPlugins(query, plugins) {
+    const allPlugins = plugins || loadAllPlugins();
+    const lowerQuery = query.toLowerCase();
+    return allPlugins.filter((p) => p.name.toLowerCase().includes(lowerQuery) ||
+        p.description.toLowerCase().includes(lowerQuery) ||
+        p.marketplace.toLowerCase().includes(lowerQuery) ||
+        p.category?.toLowerCase().includes(lowerQuery) ||
+        p.tags?.some((t) => t.toLowerCase().includes(lowerQuery)));
+}
+/**
+ * Sort plugins by field
+ * @param plugins - Plugins to sort
+ * @param sortBy - Field to sort by
+ * @param order - Sort order
+ * @returns Sorted plugins array
+ */
+export function sortPlugins(plugins, sortBy, order) {
+    const sorted = [...plugins];
+    sorted.sort((a, b) => {
+        let comparison = 0;
+        switch (sortBy) {
+            case 'installs':
+                comparison = a.installCount - b.installCount;
+                break;
+            case 'name':
+                comparison = a.name.localeCompare(b.name);
+                break;
+            case 'date':
+                const dateA = a.installedAt ? new Date(a.installedAt).getTime() : 0;
+                const dateB = b.installedAt ? new Date(b.installedAt).getTime() : 0;
+                comparison = dateA - dateB;
+                break;
+        }
+        return order === 'asc' ? comparison : -comparison;
+    });
+    return sorted;
+}
+/**
+ * Get plugin statistics
+ * @returns Object with various plugin counts
+ */
+export function getPluginStatistics() {
+    const allPlugins = loadAllPlugins();
+    const marketplaces = loadMarketplaces();
+    return {
+        total: allPlugins.length,
+        installed: allPlugins.filter((p) => p.isInstalled).length,
+        enabled: allPlugins.filter((p) => p.isEnabled).length,
+        marketplaces: marketplaces.length,
+    };
+}