log-llm-config 1.0.5 → 1.0.7

package/dist/log_config_files.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { readFileSync, existsSync, mkdirSync, writeFileSync } from 'node:fs';
+import { readFileSync, existsSync, mkdirSync, writeFileSync, readdirSync } from 'node:fs';
 import { join, dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { homedir } from 'node:os';
@@ -49,6 +49,28 @@ const JSON_FILE_PATHS = [
 ];
 // VS Code/Cursor state database path
 const VSCDB_PATH = join(homedir(), 'Library', 'Application Support', 'Cursor', 'User', 'globalStorage', 'state.vscdb');
+// Claude configuration file paths
+const CLAUDE_FILE_PATHS = [
+    // Project Root
+    {
+        path: join(PROJECT_ROOT, 'CLAUDE.md'),
+        file_type: 'claude_rule_config',
+    },
+    // Local Overrides (project-level)
+    {
+        path: join(PROJECT_ROOT, 'CLAUDE.local.md'),
+        file_type: 'claude_rule_config',
+    },
+    // Home Directory
+    {
+        path: join(homedir(), '.claude', 'CLAUDE.md'),
+        file_type: 'claude_rule_config',
+    },
+];
+// Claude rules directory
+const CLAUDE_RULES_DIR = join(homedir(), '.claude', 'rules');
+// Cursor rules directory (project-level)
+const CURSOR_RULES_DIR = join(PROJECT_ROOT, '.cursor', 'rules');
 /**
  * Read and parse an MCP config file
  */
@@ -86,6 +108,190 @@ function readJSONFile(filePath) {
         return null;
     }
 }
+/**
+ * Read a markdown/text file and return as content string
+ */
+function readMarkdownFile(filePath) {
+    try {
+        if (!existsSync(filePath)) {
+            return null;
+        }
+        const content = readFileSync(filePath, 'utf-8');
+        return content;
+    }
+    catch (error) {
+        if (error.code === 'EACCES' || error.code === 'EPERM') {
+            console.warn(`Permission denied reading ${filePath} (may require elevated permissions)`);
+        }
+        return null;
+    }
+}
+/**
+ * Get parent directory paths for monorepo support
+ * Checks parent directories up to 5 levels for CLAUDE.md files
+ */
+function getParentClaudeFiles(projectRoot) {
+    const files = [];
+    let currentPath = projectRoot;
+    let levels = 0;
+    const maxLevels = 5; // Limit to prevent infinite loops
+    while (levels < maxLevels) {
+        const parentPath = path.dirname(currentPath);
+        if (parentPath === currentPath) {
+            // Reached filesystem root
+            break;
+        }
+        const claudePath = join(parentPath, 'CLAUDE.md');
+        if (existsSync(claudePath)) {
+            files.push({
+                path: claudePath,
+                file_type: 'claude_rule_config',
+            });
+        }
+        currentPath = parentPath;
+        levels++;
+    }
+    return files;
+}
+/**
+ * Get all markdown files from Claude rules directory
+ */
+function getClaudeRuleFiles() {
+    const files = [];
+    try {
+        if (!existsSync(CLAUDE_RULES_DIR)) {
+            return files;
+        }
+        const entries = readdirSync(CLAUDE_RULES_DIR, { withFileTypes: true });
+        for (const entry of entries) {
+            if (entry.isFile() && entry.name.endsWith('.md')) {
+                files.push({
+                    path: join(CLAUDE_RULES_DIR, entry.name),
+                    file_type: 'claude_rule',
+                });
+            }
+        }
+    }
+    catch (error) {
+        console.warn(`Error reading Claude rules directory ${CLAUDE_RULES_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)
+ */
+function getCursorRuleFiles() {
+    const files = [];
+    try {
+        if (!existsSync(CURSOR_RULES_DIR)) {
+            return files;
+        }
+        const entries = readdirSync(CURSOR_RULES_DIR, { withFileTypes: true });
+        for (const entry of entries) {
+            if (entry.isDirectory()) {
+                // New format: rule folder containing RULE.md
+                const ruleMdPath = join(CURSOR_RULES_DIR, entry.name, 'RULE.md');
+                if (existsSync(ruleMdPath)) {
+                    files.push({
+                        path: ruleMdPath,
+                        file_type: 'cursor_rule',
+                    });
+                }
+            }
+            else if (entry.isFile()) {
+                // Legacy format: flat .mdc or .md files
+                if (entry.name.endsWith('.mdc') || entry.name.endsWith('.md')) {
+                    files.push({
+                        path: join(CURSOR_RULES_DIR, entry.name),
+                        file_type: 'cursor_rule',
+                    });
+                }
+            }
+        }
+    }
+    catch (error) {
+        console.warn(`Error reading Cursor rules directory ${CURSOR_RULES_DIR}:`, error instanceof Error ? error.message : String(error));
+    }
+    return files;
+}
+/**
+ * Get AGENTS.md files from project root and subdirectories
+ * Supports nested AGENTS.md files as per Cursor documentation
+ */
+function getAgentsMdFiles(projectRoot) {
+    const files = [];
+    // Check project root
+    const rootAgentsMd = join(projectRoot, 'AGENTS.md');
+    if (existsSync(rootAgentsMd)) {
+        files.push({
+            path: rootAgentsMd,
+            file_type: 'cursor_rule',
+        });
+    }
+    // Check subdirectories (1 level deep for now, can be extended)
+    try {
+        const entries = readdirSync(projectRoot, { withFileTypes: true });
+        for (const entry of entries) {
+            if (entry.isDirectory() && !entry.name.startsWith('.') && entry.name !== 'node_modules') {
+                const subdirAgentsMd = join(projectRoot, entry.name, 'AGENTS.md');
+                if (existsSync(subdirAgentsMd)) {
+                    files.push({
+                        path: subdirAgentsMd,
+                        file_type: 'cursor_rule',
+                    });
+                }
+            }
+        }
+    }
+    catch (error) {
+        console.warn(`Error reading subdirectories for AGENTS.md in ${projectRoot}:`, error instanceof Error ? error.message : String(error));
+    }
+    return files;
+}
+/**
+ * Get .cursorrules file from project root (legacy format, deprecated but still supported)
+ */
+function getCursorRulesFile(projectRoot) {
+    const files = [];
+    const cursorRulesPath = join(projectRoot, '.cursorrules');
+    if (existsSync(cursorRulesPath)) {
+        files.push({
+            path: cursorRulesPath,
+            file_type: 'cursor_rule',
+        });
+    }
+    return files;
+}
+/**
+ * Get subdirectory Claude files for monorepo support
+ * Checks immediate subdirectories (1 level deep) for CLAUDE.md files
+ */
+function getSubdirectoryClaudeFiles(projectRoot) {
+    const files = [];
+    try {
+        if (!existsSync(projectRoot)) {
+            return files;
+        }
+        const entries = readdirSync(projectRoot, { withFileTypes: true });
+        for (const entry of entries) {
+            // Only check immediate subdirectories (not files, not hidden dirs like .git, node_modules, etc.)
+            if (entry.isDirectory() && !entry.name.startsWith('.') && entry.name !== 'node_modules') {
+                const claudePath = join(projectRoot, entry.name, 'CLAUDE.md');
+                if (existsSync(claudePath)) {
+                    files.push({
+                        path: claudePath,
+                        file_type: 'claude_rule_config',
+                    });
+                }
+            }
+        }
+    }
+    catch (error) {
+        console.warn(`Error reading subdirectories in ${projectRoot}:`, error instanceof Error ? error.message : String(error));
+    }
+    return files;
+}
 /**
  * Read composerState from Cursor's state.vscdb SQLite database
  */
@@ -185,6 +391,152 @@ function collectConfigFiles() {
             },
         });
     }
+    // Read Claude configuration files (project root, local overrides, home directory)
+    for (const { path, file_type } of CLAUDE_FILE_PATHS) {
+        try {
+            const markdownContent = readMarkdownFile(path);
+            if (markdownContent !== null) { // Log even if empty (null means file doesn't exist or error)
+                console.log(`Found ${file_type} at: ${path}`);
+                configFiles.push({
+                    file_type,
+                    file_path: path,
+                    raw_content: {
+                        content: markdownContent,
+                        source: 'claude_rule_config_file',
+                    },
+                });
+            }
+        }
+        catch (error) {
+            console.warn(`Error reading ${path}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    // Read parent directory Claude files (for monorepo support)
+    const parentClaudeFiles = getParentClaudeFiles(PROJECT_ROOT);
+    for (const { path, file_type } of parentClaudeFiles) {
+        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_rule_config_file',
+                    },
+                });
+            }
+        }
+        catch (error) {
+            console.warn(`Error reading ${path}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    // Read subdirectory Claude files (for monorepo support - root/subdir/CLAUDE.md)
+    const subdirectoryClaudeFiles = getSubdirectoryClaudeFiles(PROJECT_ROOT);
+    for (const { path, file_type } of subdirectoryClaudeFiles) {
+        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_rule_config_file',
+                    },
+                });
+            }
+        }
+        catch (error) {
+            console.warn(`Error reading ${path}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    // Read Claude rule files from ~/.claude/rules/*.md
+    const claudeRuleFiles = getClaudeRuleFiles();
+    for (const { path, file_type } of claudeRuleFiles) {
+        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_rule_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) {
+        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_rule_file',
+                    },
+                });
+            }
+        }
+        catch (error) {
+            console.warn(`Error reading ${path}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    // Read AGENTS.md files (project root and subdirectories)
+    const agentsMdFiles = getAgentsMdFiles(PROJECT_ROOT);
+    for (const { path, file_type } of agentsMdFiles) {
+        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_rule_file',
+                    },
+                });
+            }
+        }
+        catch (error) {
+            console.warn(`Error reading ${path}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    // Read .cursorrules file (legacy format, deprecated but still supported)
+    const cursorRulesFiles = getCursorRulesFile(PROJECT_ROOT);
+    for (const { path, file_type } of cursorRulesFiles) {
+        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_rule_file',
+                    },
+                });
+            }
+        }
+        catch (error) {
+            console.warn(`Error reading ${path}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
     return configFiles;
 }
 /**

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "log-llm-config",
-  "version": "1.0.5",
+  "version": "1.0.7",
   "description": "CLI helpers for logging hardware UUIDs and posting startup payloads to Optimus Security.",
   "type": "module",
   "bin": {
-    "log-llm-config": "./dist/cli.js",
-    "log_uuid": "./dist/log_uuid.js",
-    "log_config_files": "./dist/log_config_files.js"
+    "log-llm-config": "dist/cli.js",
+    "log_uuid": "dist/log_uuid.js",
+    "log_config_files": "dist/log_config_files.js"
   },
   "scripts": {
     "build": "tsc -p tsconfig.json",
@@ -26,7 +26,7 @@
   "license": "UNLICENSED",
   "repository": {
     "type": "git",
-    "url": "https://github.com/optimuslabs-io/optimus-secure-fdn.git",
+    "url": "git+https://github.com/optimuslabs-io/optimus-secure-fdn.git",
     "directory": "npx_packages/log-llm-config"
   },
   "bugs": {
@@ -41,11 +41,11 @@
     "node": ">=18"
   },
   "devDependencies": {
-    "@types/node": "^20.11.30",
-    "@vitest/ui": "^2.1.8",
+    "@types/node": "^24.10.1",
+    "@vitest/ui": "^4.0.15",
     "ts-node": "^10.9.2",
     "typescript": "^5.4.5",
-    "vitest": "^2.1.8"
+    "vitest": "^4.0.15"
   },
   "dependencies": {
     "axios": "^1.7.9"