log-llm-config 1.0.7 → 1.0.9

package/dist/log_config_files.js

@@ -36,6 +36,11 @@ const JSON_FILE_PATHS = [
         path: join(homedir(), 'Library', 'Application Support', 'Cursor', 'hooks.json'),
         file_type: 'cursor_hooks',
     },
+    // Project-level Cursor Cloud Agent environment config
+    {
+        path: join(PROJECT_ROOT, '.cursor', 'environment.json'),
+        file_type: 'cursor_cloud_agent_config',
+    },
     // Project-level Claude settings (preferred over user)
     {
         path: join(PROJECT_ROOT, '.claude', 'settings.json'),
@@ -69,8 +74,22 @@ const CLAUDE_FILE_PATHS = [
 ];
 // Claude rules directory
 const CLAUDE_RULES_DIR = join(homedir(), '.claude', 'rules');
+// Claude subagents directories
+const CLAUDE_AGENTS_PROJECT_DIR = join(PROJECT_ROOT, '.claude', 'agents');
+const CLAUDE_AGENTS_USER_DIR = join(homedir(), '.claude', 'agents');
 // Cursor rules directory (project-level)
 const CURSOR_RULES_DIR = join(PROJECT_ROOT, '.cursor', 'rules');
+// Cursor commands directories
+const CURSOR_COMMANDS_PROJECT_DIR = join(PROJECT_ROOT, '.cursor', 'commands');
+const CURSOR_COMMANDS_USER_DIR = join(homedir(), '.cursor', 'commands');
+// Cursor subagents directory (project-level)
+const CURSOR_AGENTS_DIR = join(PROJECT_ROOT, '.cursor', 'agents');
+// Plugin directories to scan
+// Claude plugins can be in various locations (project, user home, etc.)
+const PLUGIN_SEARCH_DIRS = [
+    PROJECT_ROOT, // Project-level plugins
+    join(homedir(), '.claude', 'plugins'), // User-level plugins (if this becomes a standard location)
+];
 /**
  * Read and parse an MCP config file
  */
@@ -177,6 +196,90 @@ function getClaudeRuleFiles() {
     }
     return files;
 }
+/**
+ * Get all command files from Cursor commands directories
+ * Collects from both project-level (.cursor/commands/) and user-level (~/.cursor/commands/)
+ */
+function getCursorCommandFiles() {
+    const files = [];
+    // Collect from project-level commands directory
+    try {
+        if (existsSync(CURSOR_COMMANDS_PROJECT_DIR)) {
+            const entries = readdirSync(CURSOR_COMMANDS_PROJECT_DIR, { withFileTypes: true });
+            for (const entry of entries) {
+                if (entry.isFile() && entry.name.endsWith('.md')) {
+                    files.push({
+                        path: join(CURSOR_COMMANDS_PROJECT_DIR, entry.name),
+                        file_type: 'cursor_command',
+                    });
+                }
+            }
+        }
+    }
+    catch (error) {
+        console.warn(`Error reading Cursor project commands directory ${CURSOR_COMMANDS_PROJECT_DIR}:`, error instanceof Error ? error.message : String(error));
+    }
+    // Collect from user-level commands directory
+    try {
+        if (existsSync(CURSOR_COMMANDS_USER_DIR)) {
+            const entries = readdirSync(CURSOR_COMMANDS_USER_DIR, { withFileTypes: true });
+            for (const entry of entries) {
+                if (entry.isFile() && entry.name.endsWith('.md')) {
+                    files.push({
+                        path: join(CURSOR_COMMANDS_USER_DIR, entry.name),
+                        file_type: 'cursor_command',
+                    });
+                }
+            }
+        }
+    }
+    catch (error) {
+        console.warn(`Error reading Cursor user commands directory ${CURSOR_COMMANDS_USER_DIR}:`, error instanceof Error ? error.message : String(error));
+    }
+    return files;
+}
+/**
+ * Get all subagent files from Claude agents directories
+ * Collects from both project-level (.claude/agents/) and user-level (~/.claude/agents/)
+ */
+function getClaudeSubagentFiles() {
+    const files = [];
+    // Collect from project-level agents directory
+    try {
+        if (existsSync(CLAUDE_AGENTS_PROJECT_DIR)) {
+            const entries = readdirSync(CLAUDE_AGENTS_PROJECT_DIR, { withFileTypes: true });
+            for (const entry of entries) {
+                if (entry.isFile() && entry.name.endsWith('.md')) {
+                    files.push({
+                        path: join(CLAUDE_AGENTS_PROJECT_DIR, entry.name),
+                        file_type: 'claude_subagent',
+                    });
+                }
+            }
+        }
+    }
+    catch (error) {
+        console.warn(`Error reading Claude project agents directory ${CLAUDE_AGENTS_PROJECT_DIR}:`, error instanceof Error ? error.message : String(error));
+    }
+    // Collect from user-level agents directory
+    try {
+        if (existsSync(CLAUDE_AGENTS_USER_DIR)) {
+            const entries = readdirSync(CLAUDE_AGENTS_USER_DIR, { withFileTypes: true });
+            for (const entry of entries) {
+                if (entry.isFile() && entry.name.endsWith('.md')) {
+                    files.push({
+                        path: join(CLAUDE_AGENTS_USER_DIR, entry.name),
+                        file_type: 'claude_subagent',
+                    });
+                }
+            }
+        }
+    }
+    catch (error) {
+        console.warn(`Error reading Claude user agents directory ${CLAUDE_AGENTS_USER_DIR}:`, error instanceof Error ? error.message : String(error));
+    }
+    return files;
+}
 /**
  * Get all rule files from Cursor rules directory
  * Supports new format (.cursor/rules/rule-name/RULE.md) and legacy format (.cursor/rules/*.mdc or *.md)
@@ -263,6 +366,167 @@ function getCursorRulesFile(projectRoot) {
     }
     return files;
 }
+/**
+ * Find all Claude plugin directories by scanning for .claude-plugin/plugin.json files
+ * Searches in project root and common plugin locations
+ */
+function findClaudePluginDirectories() {
+    const plugins = [];
+    // Search in project root and subdirectories (up to 3 levels deep)
+    const searchDirs = [PROJECT_ROOT];
+    // Also check common plugin locations
+    const commonPluginPaths = [
+        join(PROJECT_ROOT, 'plugins'),
+        join(PROJECT_ROOT, '.plugins'),
+        join(homedir(), '.claude', 'plugins'),
+    ];
+    for (const searchPath of [...searchDirs, ...commonPluginPaths]) {
+        if (!existsSync(searchPath)) {
+            continue;
+        }
+        try {
+            // Recursively search for .claude-plugin directories
+            const findPluginDirs = (dir, depth = 0) => {
+                if (depth > 3)
+                    return; // Limit recursion depth
+                // Skip common directories that shouldn't contain plugins
+                const skipDirs = ['node_modules', '.git', '.venv', 'venv', 'dist', 'build', '.next', '.cache'];
+                const dirName = path.basename(dir);
+                if (skipDirs.includes(dirName)) {
+                    return;
+                }
+                try {
+                    const entries = readdirSync(dir, { withFileTypes: true });
+                    for (const entry of entries) {
+                        if (entry.isDirectory()) {
+                            // Check if this is a .claude-plugin directory
+                            if (entry.name === '.claude-plugin') {
+                                const manifestPath = join(dir, '.claude-plugin', 'plugin.json');
+                                if (existsSync(manifestPath)) {
+                                    plugins.push({
+                                        pluginDir: dir,
+                                        manifestPath: manifestPath,
+                                    });
+                                }
+                                // Don't recurse into .claude-plugin directory
+                                continue;
+                            }
+                            // Skip hidden directories (except .claude-plugin which we already handled)
+                            // and common build/cache directories
+                            if (entry.name.startsWith('.') || skipDirs.includes(entry.name)) {
+                                continue;
+                            }
+                            // Recursively search subdirectories
+                            findPluginDirs(join(dir, entry.name), depth + 1);
+                        }
+                    }
+                }
+                catch (error) {
+                    // Skip directories we can't read
+                }
+            };
+            findPluginDirs(searchPath);
+        }
+        catch (error) {
+            // Skip if we can't read the directory
+        }
+    }
+    return plugins;
+}
+/**
+ * Get Claude plugin manifest files (.claude-plugin/plugin.json)
+ */
+function getClaudePluginManifests() {
+    const files = [];
+    const plugins = findClaudePluginDirectories();
+    for (const { pluginDir, manifestPath } of plugins) {
+        files.push({
+            path: manifestPath,
+            file_type: 'claude_plugin_manifest',
+            pluginDir: pluginDir,
+        });
+    }
+    return files;
+}
+/**
+ * Get command files from a plugin directory (commands/*.md)
+ */
+function getPluginCommandFiles(pluginDir) {
+    const files = [];
+    // pluginDir is the directory containing .claude-plugin, so commands are at pluginDir/.claude-plugin/commands
+    const commandsDir = join(pluginDir, '.claude-plugin', 'commands');
+    try {
+        if (!existsSync(commandsDir)) {
+            return files;
+        }
+        const entries = readdirSync(commandsDir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (entry.isFile() && entry.name.endsWith('.md')) {
+                files.push({
+                    path: join(commandsDir, entry.name),
+                    file_type: 'claude_plugin_command',
+                });
+            }
+        }
+    }
+    catch (error) {
+        console.warn(`Error reading plugin commands directory ${commandsDir}:`, error instanceof Error ? error.message : String(error));
+    }
+    return files;
+}
+/**
+ * Get hook files from a plugin directory (hooks/hooks.json)
+ */
+function getPluginHookFiles(pluginDir) {
+    const files = [];
+    // pluginDir is the directory containing .claude-plugin, so hooks are at pluginDir/.claude-plugin/hooks/hooks.json
+    const hooksPath = join(pluginDir, '.claude-plugin', 'hooks', 'hooks.json');
+    if (existsSync(hooksPath)) {
+        files.push({
+            path: hooksPath,
+            file_type: 'claude_plugin_hooks',
+        });
+    }
+    return files;
+}
+/**
+ * Get MCP config files from a plugin directory (.mcp.json)
+ */
+function getPluginAgentFiles(pluginDir) {
+    const files = [];
+    // pluginDir is the directory containing .claude-plugin, so agents are at pluginDir/.claude-plugin/agents/*.md
+    const agentsDir = join(pluginDir, '.claude-plugin', 'agents');
+    try {
+        if (!existsSync(agentsDir)) {
+            return files;
+        }
+        const entries = readdirSync(agentsDir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (entry.isFile() && entry.name.endsWith('.md')) {
+                files.push({
+                    path: join(agentsDir, entry.name),
+                    file_type: 'claude_subagent',
+                });
+            }
+        }
+    }
+    catch (error) {
+        console.warn(`Error reading plugin agents directory ${agentsDir}:`, error instanceof Error ? error.message : String(error));
+    }
+    return files;
+}
+function getPluginMcpFiles(pluginDir) {
+    const files = [];
+    // pluginDir is the directory containing .claude-plugin, so MCP config is at pluginDir/.claude-plugin/.mcp.json
+    const mcpPath = join(pluginDir, '.claude-plugin', '.mcp.json');
+    if (existsSync(mcpPath)) {
+        files.push({
+            path: mcpPath,
+            file_type: 'claude_plugin_mcp',
+        });
+    }
+    return files;
+}
 /**
  * Get subdirectory Claude files for monorepo support
  * Checks immediate subdirectories (1 level deep) for CLAUDE.md files
@@ -293,7 +557,8 @@ function getSubdirectoryClaudeFiles(projectRoot) {
     return files;
 }
 /**
- * Read composerState from Cursor's state.vscdb SQLite database
+ * Read state data from Cursor's state.vscdb SQLite database
+ * Extracts composerState, extensionsAssistant, and extensions data
  */
 function readVSCDBState() {
     try {
@@ -308,34 +573,128 @@ function readVSCDBState() {
             console.warn('sqlite3 command not found; skipping state.vscdb reading');
             return null;
         }
+        const stateData = {};
         // Query the SQLite database for composerState
         // Escape single quotes in the key for SQL safety
-        const key = "src.vs.platform.reactivestorage.browser.reactiveStorageServiceImpl.persistentStorage.applicationUser";
-        const escapedKey = key.replace(/'/g, "''");
-        const query = `SELECT value FROM ItemTable WHERE key='${escapedKey}'`;
-        const result = execSync(`sqlite3 "${VSCDB_PATH}" "${query}"`, {
-            encoding: 'utf8',
-            stdio: ['ignore', 'pipe', 'pipe'],
-        }).trim();
-        if (!result || result === '') {
-            return null;
-        }
-        // Parse the JSON value
-        let parsed;
+        const composerStateKey = "src.vs.platform.reactivestorage.browser.reactiveStorageServiceImpl.persistentStorage.applicationUser";
+        const escapedComposerKey = composerStateKey.replace(/'/g, "''");
+        const composerQuery = `SELECT value FROM ItemTable WHERE key='${escapedComposerKey}'`;
         try {
-            parsed = JSON.parse(result);
+            const composerResult = execSync(`sqlite3 "${VSCDB_PATH}" "${composerQuery}"`, {
+                encoding: 'utf8',
+                stdio: ['ignore', 'pipe', 'pipe'],
+            }).trim();
+            if (composerResult && composerResult !== '') {
+                try {
+                    const parsed = JSON.parse(composerResult);
+                    // Extract composerState from the nested structure
+                    const composerState = parsed?.composerState || parsed;
+                    if (composerState && typeof composerState === 'object') {
+                        stateData.composerState = composerState;
+                    }
+                }
+                catch (parseError) {
+                    console.warn(`Failed to parse composerState from state.vscdb:`, parseError instanceof Error ? parseError.message : String(parseError));
+                }
+            }
         }
-        catch (parseError) {
-            console.error(`Failed to parse JSON from state.vscdb:`, parseError instanceof Error ? parseError.message : String(parseError));
-            return null;
+        catch (error) {
+            console.warn(`Error reading composerState from state.vscdb:`, error instanceof Error ? error.message : String(error));
         }
-        // Extract composerState from the nested structure
-        // The structure might be: { composerState: {...} } or just the composerState object
-        const composerState = parsed?.composerState || parsed;
-        if (!composerState || typeof composerState !== 'object') {
-            return null;
+        // Query for extensionsAssistant data
+        // The actual key in state.vscdb is "extensionsAssistant/recommendations" (with forward slash)
+        const extensionKeys = [
+            "extensionsAssistant/recommendations", // Actual key format in state.vscdb
+            "extensionsAssistant.recommendations",
+            "workbench.extensionsAssistant.recommendations",
+        ];
+        for (const key of extensionKeys) {
+            try {
+                const escapedKey = key.replace(/'/g, "''");
+                const query = `SELECT value FROM ItemTable WHERE key='${escapedKey}'`;
+                const result = execSync(`sqlite3 "${VSCDB_PATH}" "${query}"`, {
+                    encoding: 'utf8',
+                    stdio: ['ignore', 'pipe', 'pipe'],
+                }).trim();
+                if (result && result !== '') {
+                    try {
+                        const parsed = JSON.parse(result);
+                        // The value is an object with extension IDs as keys and timestamps as values
+                        // Convert to array of extension IDs for the recommendations path
+                        if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+                            const extensionIds = Object.keys(parsed);
+                            stateData.extensionsAssistant = { recommendations: extensionIds };
+                        }
+                        else if (Array.isArray(parsed)) {
+                            stateData.extensionsAssistant = { recommendations: parsed };
+                        }
+                        break; // Found it, stop searching
+                    }
+                    catch (parseError) {
+                        // Continue to next key
+                    }
+                }
+            }
+            catch (error) {
+                // Continue to next key
+            }
         }
-        return composerState;
+        // Query for extensions.trustedPublishers data
+        // The actual key in state.vscdb is "extensions.trustedPublishers"
+        const trustedPublisherKeys = [
+            "extensions.trustedPublishers", // Actual key format in state.vscdb
+            "workbench.extensions.trustedPublishers",
+        ];
+        for (const key of trustedPublisherKeys) {
+            try {
+                const escapedKey = key.replace(/'/g, "''");
+                const query = `SELECT value FROM ItemTable WHERE key='${escapedKey}'`;
+                const result = execSync(`sqlite3 "${VSCDB_PATH}" "${query}"`, {
+                    encoding: 'utf8',
+                    stdio: ['ignore', 'pipe', 'pipe'],
+                }).trim();
+                if (result && result !== '') {
+                    try {
+                        const parsed = JSON.parse(result);
+                        // The value is an object with publisher IDs as keys and publisher info as values
+                        // Extract publisher IDs/names for the trustedPublishers array
+                        if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+                            // Extract publisher IDs from the object keys
+                            const publisherIds = Object.keys(parsed);
+                            stateData.extensions = { trustedPublishers: publisherIds };
+                        }
+                        else if (Array.isArray(parsed)) {
+                            stateData.extensions = { trustedPublishers: parsed };
+                        }
+                        break; // Found it, stop searching
+                    }
+                    catch (parseError) {
+                        // Continue to next key
+                    }
+                }
+            }
+            catch (error) {
+                // Continue to next key
+            }
+        }
+        // If we found composerState, also check if extensionsAssistant/extensions are nested within it
+        if (stateData.composerState && typeof stateData.composerState === 'object') {
+            const composerState = stateData.composerState;
+            // Check if extensionsAssistant is in composerState
+            if (composerState.extensionsAssistant && !stateData.extensionsAssistant) {
+                stateData.extensionsAssistant = composerState.extensionsAssistant;
+            }
+            // Check if extensions is in composerState
+            if (composerState.extensions && !stateData.extensions) {
+                stateData.extensions = composerState.extensions;
+            }
+        }
+        // Return the combined state data (composerState, extensionsAssistant, extensions)
+        // If we have any data, return it; otherwise return null
+        if (Object.keys(stateData).length > 0) {
+            return stateData;
+        }
+        return null;
     }
     catch (error) {
         console.error(`Error reading state.vscdb:`, error instanceof Error ? error.message : String(error));
@@ -381,15 +740,51 @@ function collectConfigFiles() {
     const vscdbState = readVSCDBState();
     if (vscdbState) {
         console.log(`Found Cursor state data at: ${VSCDB_PATH}`);
-        configFiles.push({
-            file_type: 'vscode_settings', // Using vscode_settings type for state.vscdb (composerState)
-            file_path: VSCDB_PATH,
-            raw_content: {
-                composerState: vscdbState,
-                source: 'state.vscdb',
-                extracted_at: new Date().toISOString(),
-            },
-        });
+        // Store composerState as vscode_settings (general VS Code/Cursor state)
+        if (vscdbState.composerState) {
+            configFiles.push({
+                file_type: 'vscode_settings',
+                file_path: `${VSCDB_PATH}#composerState`, // Use fragment to distinguish
+                raw_content: {
+                    composerState: vscdbState.composerState,
+                    source: 'state.vscdb',
+                    extracted_at: new Date().toISOString(),
+                },
+            });
+        }
+        // Store extensionsAssistant.recommendations as cursor_extensions
+        // (same type as .vscode/extensions.json recommendations)
+        // Structure must match evaluation plan path: extensionsAssistant.recommendations
+        const extensionsAssistant = vscdbState.extensionsAssistant;
+        if (extensionsAssistant?.recommendations && Array.isArray(extensionsAssistant.recommendations)) {
+            configFiles.push({
+                file_type: 'cursor_extensions',
+                file_path: `${VSCDB_PATH}#extensionsAssistant.recommendations`, // Use fragment to distinguish
+                raw_content: {
+                    extensionsAssistant: {
+                        recommendations: extensionsAssistant.recommendations,
+                    },
+                    source: 'state.vscdb',
+                    extracted_at: new Date().toISOString(),
+                },
+            });
+        }
+        // Store extensions.trustedPublishers as cursor_extensions
+        // (extension-related data, should be checked by extension policies)
+        const extensions = vscdbState.extensions;
+        if (extensions?.trustedPublishers && Array.isArray(extensions.trustedPublishers)) {
+            configFiles.push({
+                file_type: 'cursor_extensions',
+                file_path: `${VSCDB_PATH}#extensions.trustedPublishers`, // Use fragment to distinguish
+                raw_content: {
+                    extensions: {
+                        trustedPublishers: extensions.trustedPublishers,
+                    },
+                    source: 'state.vscdb',
+                    extracted_at: new Date().toISOString(),
+                },
+            });
+        }
     }
     // Read Claude configuration files (project root, local overrides, home directory)
     for (const { path, file_type } of CLAUDE_FILE_PATHS) {
@@ -474,6 +869,48 @@ function collectConfigFiles() {
             console.warn(`Error reading ${path}: ${error instanceof Error ? error.message : String(error)}`);
         }
     }
+    // Read Claude subagent files from .claude/agents/*.md and ~/.claude/agents/*.md
+    const claudeSubagentFiles = getClaudeSubagentFiles();
+    for (const { path, file_type } of claudeSubagentFiles) {
+        try {
+            const markdownContent = readMarkdownFile(path);
+            if (markdownContent !== null) { // Log even if empty
+                console.log(`Found ${file_type} at: ${path}`);
+                configFiles.push({
+                    file_type,
+                    file_path: path,
+                    raw_content: {
+                        content: markdownContent,
+                        source: 'claude_subagent_file',
+                    },
+                });
+            }
+        }
+        catch (error) {
+            console.warn(`Error reading ${path}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    // Read Cursor command files from .cursor/commands/*.md and ~/.cursor/commands/*.md
+    const cursorCommandFiles = getCursorCommandFiles();
+    for (const { path, file_type } of cursorCommandFiles) {
+        try {
+            const markdownContent = readMarkdownFile(path);
+            if (markdownContent !== null) { // Log even if empty
+                console.log(`Found ${file_type} at: ${path}`);
+                configFiles.push({
+                    file_type,
+                    file_path: path,
+                    raw_content: {
+                        content: markdownContent,
+                        source: 'cursor_command_file',
+                    },
+                });
+            }
+        }
+        catch (error) {
+            console.warn(`Error reading ${path}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
     // Read Cursor rule files from .cursor/rules/ (new format: folders with RULE.md, legacy: .mdc/.md files)
     const cursorRuleFiles = getCursorRuleFiles();
     for (const { path, file_type } of cursorRuleFiles) {
@@ -537,6 +974,126 @@ function collectConfigFiles() {
             console.warn(`Error reading ${path}: ${error instanceof Error ? error.message : String(error)}`);
         }
     }
+    // Read Cursor extension recommendations (.vscode/extensions.json)
+    const extensionsJsonPath = join(PROJECT_ROOT, '.vscode', 'extensions.json');
+    if (existsSync(extensionsJsonPath)) {
+        try {
+            const extensionsContent = readJSONFile(extensionsJsonPath);
+            if (extensionsContent) {
+                console.log(`Found Cursor extensions.json at: ${extensionsJsonPath}`);
+                configFiles.push({
+                    file_type: 'cursor_extensions',
+                    file_path: extensionsJsonPath,
+                    raw_content: extensionsContent,
+                });
+            }
+        }
+        catch (error) {
+            console.warn(`Error reading ${extensionsJsonPath}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    // Read Claude plugin manifests and related files
+    const pluginManifests = getClaudePluginManifests();
+    for (const { path, file_type, pluginDir } of pluginManifests) {
+        try {
+            const manifestContent = readJSONFile(path);
+            if (manifestContent) {
+                configFiles.push({
+                    file_type,
+                    file_path: path,
+                    raw_content: manifestContent,
+                });
+                // Collect plugin command files (commands/*.md)
+                const commandFiles = getPluginCommandFiles(pluginDir);
+                for (const { path: cmdPath, file_type: cmdFileType } of commandFiles) {
+                    try {
+                        const cmdContent = readMarkdownFile(cmdPath);
+                        if (cmdContent !== null) {
+                            configFiles.push({
+                                file_type: cmdFileType,
+                                file_path: cmdPath,
+                                raw_content: {
+                                    content: cmdContent,
+                                    source: 'claude_rule_file', // Plugin command files are .md rule files
+                                    pluginDir: pluginDir,
+                                    pluginCommandFile: true, // Additional flag to identify as plugin command
+                                },
+                            });
+                        }
+                    }
+                    catch (error) {
+                        console.warn(`Error reading plugin command ${cmdPath}:`, error instanceof Error ? error.message : String(error));
+                    }
+                }
+                // Collect plugin hook files (hooks/hooks.json)
+                const hookFiles = getPluginHookFiles(pluginDir);
+                for (const { path: hookPath, file_type: hookFileType } of hookFiles) {
+                    try {
+                        const hookContent = readJSONFile(hookPath);
+                        if (hookContent) {
+                            configFiles.push({
+                                file_type: hookFileType,
+                                file_path: hookPath,
+                                raw_content: {
+                                    ...hookContent,
+                                    source: 'claude_plugin_hooks_file',
+                                    pluginDir: pluginDir,
+                                },
+                            });
+                        }
+                    }
+                    catch (error) {
+                        console.warn(`Error reading plugin hooks ${hookPath}:`, error instanceof Error ? error.message : String(error));
+                    }
+                }
+                // Collect plugin agent files (agents/*.md)
+                const agentFiles = getPluginAgentFiles(pluginDir);
+                for (const { path: agentPath, file_type: agentFileType } of agentFiles) {
+                    try {
+                        const agentContent = readMarkdownFile(agentPath);
+                        if (agentContent !== null) {
+                            configFiles.push({
+                                file_type: agentFileType,
+                                file_path: agentPath,
+                                raw_content: {
+                                    content: agentContent,
+                                    source: 'claude_plugin_agent_file',
+                                    pluginDir: pluginDir,
+                                },
+                            });
+                        }
+                    }
+                    catch (error) {
+                        console.warn(`Error reading plugin agent ${agentPath}:`, error instanceof Error ? error.message : String(error));
+                    }
+                }
+                // Collect plugin MCP config files (.mcp.json)
+                const mcpFiles = getPluginMcpFiles(pluginDir);
+                for (const { path: mcpPath, file_type: mcpFileType } of mcpFiles) {
+                    try {
+                        const mcpContent = readJSONFile(mcpPath);
+                        if (mcpContent) {
+                            configFiles.push({
+                                file_type: mcpFileType,
+                                file_path: mcpPath,
+                                raw_content: {
+                                    ...mcpContent,
+                                    source: 'claude_plugin_mcp_file',
+                                    pluginDir: pluginDir,
+                                },
+                            });
+                        }
+                    }
+                    catch (error) {
+                        console.warn(`Error reading plugin MCP config ${mcpPath}:`, error instanceof Error ? error.message : String(error));
+                    }
+                }
+            }
+        }
+        catch (error) {
+            console.warn(`Error reading plugin manifest ${path}:`, error instanceof Error ? error.message : String(error));
+        }
+    }
     return configFiles;
 }
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "log-llm-config",
-  "version": "1.0.7",
+  "version": "1.0.9",
   "description": "CLI helpers for logging hardware UUIDs and posting startup payloads to Optimus Security.",
   "type": "module",
   "bin": {