@xelth/eck-snapshot 6.6.0 → 6.7.0

package/README.md

@@ -1,4 +1,4 @@
-# 📸 eckSnapshot v6.5.0 (AI-Native Edition)
+# 📸 eckSnapshot v6.7.0 (AI-Native Edition)
 
 A specialized, AI-native CLI tool that creates single-file text snapshots of entire Git repositories and feeds them directly into LLM context windows. Instead of letting AI agents guess which files to read, eckSnapshot force-feeds the complete project into the model's context — giving it a "university degree" in your codebase from the very first prompt.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xelth/eck-snapshot",
-  "version": "6.6.0",
+  "version": "6.7.0",
   "description": "A powerful CLI tool to create and restore single-file text snapshots of Git repositories. Optimized for AI context, LLM workflows, and multi-agent Swarm coordination.",
   "keywords": [
     "ai",

package/setup.json

@@ -164,6 +164,19 @@
         ],
         "priority": 7
       },
+      "esp-idf": {
+        "files": [
+          "sdkconfig.defaults",
+          "partitions.csv"
+        ],
+        "directories": [
+          "managed_components"
+        ],
+        "manifestFiles": [
+          "idf_component.yml"
+        ],
+        "priority": 8
+      },
       "c": {
         "files": [
           "Makefile",
@@ -518,6 +531,27 @@
           "packages/"
         ]
       },
+      "esp-idf": {
+        "filesToIgnore": [
+          "sdkconfig.old",
+          "dependencies.lock"
+        ],
+        "dirsToIgnore": [
+          "managed_components/",
+          "build/",
+          "managed_components/*/examples/",
+          "managed_components/*/test/",
+          "managed_components/*/test_apps/",
+          "managed_components/*/docs/",
+          "managed_components/*/hw/"
+        ],
+        "extensionsToIgnore": [
+          ".bin",
+          ".elf",
+          ".map",
+          ".flash"
+        ]
+      },
       "c": {
         "filesToIgnore": [
           "*.o",

package/src/cli/cli.js

@@ -49,17 +49,17 @@ const LEGACY_COMMANDS = {
     const base = baseIdx !== -1 && args[baseIdx + 1] ? args[baseIdx + 1] : undefined;
     return { name: 'eck_update_auto', arguments: { fail: args.includes('--fail') || args.includes('-f'), base } };
   },
-  'snapshot':    () => ({ name: 'eck_snapshot', arguments: {} }),
+  'snapshot':    (args) => ({ name: 'eck_snapshot', arguments: { ml: args.includes('--ml') } }),
   'update':      (args) => {
     const baseIdx = args.indexOf('--base');
     const base = baseIdx !== -1 && args[baseIdx + 1] ? args[baseIdx + 1] : undefined;
-    return { name: 'eck_update', arguments: { fail: args.includes('--fail') || args.includes('-f'), base } };
+    return { name: 'eck_update', arguments: { fail: args.includes('--fail') || args.includes('-f'), base, ml: args.includes('--ml') } };
   },
   'setup-mcp':   (args) => ({ name: 'eck_setup_mcp', arguments: { opencode: args.includes('--opencode'), both: args.includes('--both') } }),
   'detect':      () => ({ name: 'eck_detect', arguments: {} }),
   'doctor':      () => ({ name: 'eck_doctor', arguments: {} }),
-  'scout':       (args) => ({ name: 'eck_scout', arguments: { depth: args[0] !== undefined ? parseInt(args[0], 10) : 0 } }),
-  'fetch':       (args) => ({ name: 'eck_fetch', arguments: { patterns: args } }),
+  'scout':       (args) => ({ name: 'eck_scout', arguments: { depth: args[0] !== undefined ? parseInt(args[0], 10) : 0, ml: args.includes('--ml') } }),
+  'fetch':       (args) => ({ name: 'eck_fetch', arguments: { patterns: args.filter(a => a !== '--ml'), ml: args.includes('--ml') } }),
   'link':        (args) => ({ name: 'eck_snapshot', arguments: { isLinkedProject: true, linkDepth: args[0] !== undefined ? parseInt(args[0], 10) : 0 } }),
   'profile':     (args) => args[0] ? ({ name: 'eck_snapshot', arguments: { profile: args.join(',') } }) : ({ name: 'eck_snapshot', arguments: { profile: true } }),
   'booklm':      () => ({ name: 'eck_snapshot', arguments: { notebooklm: 'scout' } }),

package/src/cli/commands/createSnapshot.js

@@ -3,7 +3,6 @@ import path from 'path';
 import { execa } from 'execa';
 import pLimit from 'p-limit';
 import { SingleBar, Presets } from 'cli-progress';
-import isBinaryPath from 'is-binary-path';
 import zlib from 'zlib';
 import { promisify } from 'util';
 import ora from 'ora';
@@ -15,7 +14,8 @@ import {
   scanDirectoryRecursively, loadGitignore, readFileWithSizeCheck,
   generateDirectoryTree, loadConfig, displayProjectInfo, loadProjectEckManifest,
   ensureSnapshotsInGitignore, initializeEckManifest, generateTimestamp,
-  getShortRepoName, SecretScanner, getProjectFiles, readMlModelMetadata
+  getShortRepoName, SecretScanner, getProjectFiles, readMlModelMetadata,
+  isBinaryFile
 } from '../../utils/fileUtils.js';
 import { detectProjectType, getProjectSpecificFiltering, getAllDetectedTypes } from '../../utils/projectDetector.js';
 import { estimateTokensWithPolynomial, generateTrainingCommand } from '../../utils/tokenEstimator.js';
@@ -252,7 +252,7 @@ async function estimateProjectTokens(projectPath, config, projectTypes = null) {
         continue;
       }
 
-      if (isBinaryPath(file)) {
+      if (await isBinaryFile(path.join(projectPath, file))) {
         continue;
       }
 
@@ -396,10 +396,14 @@ async function processProjectFiles(repoPath, options, config, projectTypes = nul
 
         const mlExt = path.extname(filePath).toLowerCase();
         const ML_EXTENSIONS = ['.safetensors', '.onnx', '.pt', '.pth', '.h5', '.pb', '.bin', '.ckpt', '.gguf'];
-        const isMlModel = ML_EXTENSIONS.includes(mlExt);
-
-        // Check if binary file (bypass if it's an ML model we want to peek into)
-        if (isBinaryPath(filePath) && !isMlModel) {
+        // ML peek is opt-in via `arguments.ml: true`. Default: ML files treated as plain binaries.
+        // This prevents false-positives where `.bin` raw dumps (mitm captures, sniffer output)
+        // get included via readMlModelMetadata when no real model is present.
+        const isMlModel = !!options?.ml && ML_EXTENSIONS.includes(mlExt);
+
+        // Content-aware binary check (catches extensionless ELFs, SQLite DBs, archives).
+        // ML models bypass to allow header metadata extraction below.
+        if (!isMlModel && await isBinaryFile(path.join(repoPath, filePath))) {
           stats.binaryFiles++;
           trackSkippedFile(normalizedPath, 'Binary files');
           return null;

package/src/cli/commands/recon.js

@@ -2,7 +2,6 @@ import fs from 'fs/promises';
 import path from 'path';
 import chalk from 'chalk';
 import micromatch from 'micromatch';
-import isBinaryPath from 'is-binary-path';
 import {
   generateDirectoryTree,
   generateTimestamp,
@@ -12,7 +11,8 @@ import {
   getProjectFiles,
   matchesPattern,
   ensureSnapshotsInGitignore,
-  readMlModelMetadata
+  readMlModelMetadata,
+  isBinaryFile
 } from '../../utils/fileUtils.js';
 import { detectProjectType, getProjectSpecificFiltering, getAllDetectedTypes } from '../../utils/projectDetector.js';
 import { loadSetupConfig } from '../../config.js';
@@ -22,20 +22,21 @@ import { skeletonize } from '../../core/skeletonizer.js';
 export async function runReconTool(payload) {
   const toolName = payload.name;
   const args = payload.arguments || {};
+  const ml = !!args.ml;
 
   if (toolName === 'eck_scout') {
     const depth = args.depth !== undefined ? parseInt(args.depth, 10) : 0;
-    await runScout(depth);
+    await runScout(depth, { ml });
   } else if (toolName === 'eck_fetch') {
     if (!args.patterns || !Array.isArray(args.patterns)) {
       console.log(chalk.red('❌ Error: eck_fetch requires an array of "patterns" in arguments.'));
       return;
     }
-    await runFetch(args.patterns);
+    await runFetch(args.patterns, { ml });
   }
 }
 
-async function runScout(depth = 0) {
+async function runScout(depth = 0, opts = {}) {
   const depthCfg = getDepthConfig(depth);
   const depthInfo = DEPTH_SCALE[depth] || DEPTH_SCALE[0];
   console.log(chalk.blue(`🕵️ Scouting repository (depth ${depth}: ${depthInfo.mode})...`));
@@ -65,16 +66,21 @@ async function runScout(depth = 0) {
     let allFiles = await getProjectFiles(repoPath, config);
     const gitignore = await loadGitignore(repoPath);
 
-    // Filter binaries, gitignore/eckignore, and file-level ignores
-    allFiles = allFiles.filter(f => {
+    // Filter binaries, gitignore/eckignore, and file-level ignores.
+    // Binary check is content-aware (magic-bytes) — needed for extensionless firmware/DB files.
+    // ML peek is opt-in (opts.ml === true) — otherwise ML extensions go through normal binary skip.
+    const ML_EXTENSIONS = ['.safetensors', '.onnx', '.pt', '.pth', '.h5', '.pb', '.bin', '.ckpt', '.gguf'];
+    const mlPeek = !!opts.ml;
+    const keepFlags = await Promise.all(allFiles.map(async (f) => {
       const normalized = f.replace(/\\/g, '/');
       const mlExt = path.extname(f).toLowerCase();
-      const ML_EXTENSIONS = ['.safetensors', '.onnx', '.pt', '.pth', '.h5', '.pb', '.bin', '.ckpt', '.gguf'];
-      if (isBinaryPath(f) && !ML_EXTENSIONS.includes(mlExt)) return false;
+      const isMlModel = mlPeek && ML_EXTENSIONS.includes(mlExt);
       if (gitignore.ignores(normalized)) return false;
       if (config.filesToIgnore && matchesPattern(normalized, config.filesToIgnore)) return false;
+      if (!isMlModel && await isBinaryFile(path.join(repoPath, f))) return false;
       return true;
-    });
+    }));
+    allFiles = allFiles.filter((_, i) => keepFlags[i]);
 
     const directoryTree = await generateDirectoryTree(repoPath, '', allFiles, 0, config.maxDepth, config);
 
@@ -91,7 +97,7 @@ async function runScout(depth = 0) {
           const ML_EXTENSIONS = ['.safetensors', '.onnx', '.pt', '.pth', '.h5', '.pb', '.bin', '.ckpt', '.gguf'];
 
           let content;
-          if (ML_EXTENSIONS.includes(mlExt)) {
+          if (mlPeek && ML_EXTENSIONS.includes(mlExt)) {
             content = await readMlModelMetadata(fullPath);
           } else {
             content = await readFileWithSizeCheck(fullPath, maxFileSize);
@@ -188,7 +194,7 @@ ${directoryTree}
   }
 }
 
-async function runFetch(patterns) {
+async function runFetch(patterns, opts = {}) {
   console.log(chalk.blue(`🚚 Fetching files matching patterns: ${patterns.join(', ')}...`));
   try {
     const repoPath = process.cwd();
@@ -213,15 +219,18 @@ async function runFetch(patterns) {
     let allFiles = await getProjectFiles(repoPath, config);
     const gitignore = await loadGitignore(repoPath);
 
-    allFiles = allFiles.filter(f => {
+    const ML_EXTENSIONS = ['.safetensors', '.onnx', '.pt', '.pth', '.h5', '.pb', '.bin', '.ckpt', '.gguf'];
+    const mlPeek = !!opts.ml;
+    const keepFlags = await Promise.all(allFiles.map(async (f) => {
       const normalized = f.replace(/\\/g, '/');
       const mlExt = path.extname(f).toLowerCase();
-      const ML_EXTENSIONS = ['.safetensors', '.onnx', '.pt', '.pth', '.h5', '.pb', '.bin', '.ckpt', '.gguf'];
-      if (isBinaryPath(f) && !ML_EXTENSIONS.includes(mlExt)) return false;
+      const isMlModel = mlPeek && ML_EXTENSIONS.includes(mlExt);
       if (gitignore.ignores(normalized)) return false;
       if (config.filesToIgnore && matchesPattern(normalized, config.filesToIgnore)) return false;
+      if (!isMlModel && await isBinaryFile(path.join(repoPath, f))) return false;
       return true;
-    });
+    }));
+    allFiles = allFiles.filter((_, i) => keepFlags[i]);
 
     // Normalize patterns: strip absolute cwd prefix, convert backslashes,
     // and auto-wrap bare filenames with **/ for convenience
@@ -262,7 +271,7 @@ async function runFetch(patterns) {
         const ML_EXTENSIONS = ['.safetensors', '.onnx', '.pt', '.pth', '.h5', '.pb', '.bin', '.ckpt', '.gguf'];
 
         let content;
-        if (ML_EXTENSIONS.includes(mlExt)) {
+        if (mlPeek && ML_EXTENSIONS.includes(mlExt)) {
           content = await readMlModelMetadata(fullPath);
         } else {
           content = await readFileWithSizeCheck(fullPath, maxFileSize);

package/src/cli/commands/updateSnapshot.js

@@ -2,10 +2,9 @@ import fs from 'fs/promises';
 import path from 'path';
 import ora from 'ora';
 import chalk from 'chalk';
-import isBinaryPath from 'is-binary-path';
 import { getGitAnchor, getChangedFiles } from '../../utils/gitUtils.js';
 import { loadSetupConfig } from '../../config.js';
-import { readFileWithSizeCheck, parseSize, formatSize, matchesPattern, loadGitignore, generateTimestamp, getShortRepoName, ensureSnapshotsInGitignore, readMlModelMetadata } from '../../utils/fileUtils.js';
+import { readFileWithSizeCheck, parseSize, formatSize, matchesPattern, loadGitignore, generateTimestamp, getShortRepoName, ensureSnapshotsInGitignore, readMlModelMetadata, isBinaryFile } from '../../utils/fileUtils.js';
 import { detectProjectType, getProjectSpecificFiltering } from '../../utils/projectDetector.js';
 import { execa } from 'execa';
 import { fileURLToPath } from 'url';
@@ -105,10 +104,11 @@ async function generateSnapshotContent(repoPath, changedFiles, anchor, config, g
 
     const mlExt = path.extname(filePath).toLowerCase();
     const ML_EXTENSIONS = ['.safetensors', '.onnx', '.pt', '.pth', '.h5', '.pb', '.bin', '.ckpt', '.gguf'];
-    const isMlModel = ML_EXTENSIONS.includes(mlExt);
+    // ML peek is opt-in (`arguments.ml: true` flows into config via options spread upstream).
+    const isMlModel = !!config?.ml && ML_EXTENSIONS.includes(mlExt);
 
-    // Skip binary files — mirrors createSnapshot.js
-    if (isBinaryPath(filePath) && !isMlModel) continue;
+    // Skip binary files — mirrors createSnapshot.js (content-aware: catches extensionless ELFs/DBs)
+    if (!isMlModel && await isBinaryFile(path.join(repoPath, filePath))) continue;
 
     const pathParts = normalizedPath.split('/');
     let isIgnoredDir = false;

package/src/utils/fileUtils.js

@@ -1,6 +1,84 @@
 import fs from 'fs/promises';
 import path from 'path';
 import { execa } from 'execa';
+import isBinaryPath from 'is-binary-path';
+
+// Magic-byte signatures for content-based binary detection.
+// Used by isBinaryFile() when an extension-only check (is-binary-path) is inconclusive —
+// catches extensionless binaries like ARM ELF firmware (`xlt_agent`), SQLite dumps without
+// `.db`/`.sqlite` suffix (`inbody270DB`), and similar files common in embedded/firmware repos.
+const BINARY_MAGIC_NUMBERS = [
+  Buffer.from([0x7F, 0x45, 0x4C, 0x46]),                          // ELF (Linux/Android executables, .so)
+  Buffer.from([0x4D, 0x5A]),                                       // PE/EXE/DLL (Windows)
+  Buffer.from('SQLite format 3\0', 'binary'),                      // SQLite 3
+  Buffer.from([0xCA, 0xFE, 0xBA, 0xBE]),                          // Java .class / Mach-O fat
+  Buffer.from([0xFE, 0xED, 0xFA, 0xCE]),                          // Mach-O 32-bit
+  Buffer.from([0xFE, 0xED, 0xFA, 0xCF]),                          // Mach-O 64-bit
+  Buffer.from([0xCF, 0xFA, 0xED, 0xFE]),                          // Mach-O 64-bit LE
+  Buffer.from([0xCE, 0xFA, 0xED, 0xFE]),                          // Mach-O 32-bit LE
+  Buffer.from([0x00, 0x61, 0x73, 0x6D]),                          // WebAssembly
+  Buffer.from([0x50, 0x4B, 0x03, 0x04]),                          // ZIP / JAR / APK / docx / xlsx
+  Buffer.from([0x50, 0x4B, 0x05, 0x06]),                          // ZIP (empty)
+  Buffer.from([0x50, 0x4B, 0x07, 0x08]),                          // ZIP (spanned)
+  Buffer.from([0x1F, 0x8B]),                                       // GZIP
+  Buffer.from([0x42, 0x5A, 0x68]),                                 // BZIP2
+  Buffer.from([0xFD, 0x37, 0x7A, 0x58, 0x5A, 0x00]),              // XZ
+  Buffer.from([0x37, 0x7A, 0xBC, 0xAF, 0x27, 0x1C]),              // 7-zip
+  Buffer.from([0x52, 0x61, 0x72, 0x21, 0x1A, 0x07]),              // RAR
+  Buffer.from([0xD0, 0xCF, 0x11, 0xE0, 0xA1, 0xB1, 0x1A, 0xE1]),  // MS Compound (old .doc/.xls/.ppt/.msi)
+  Buffer.from('%PDF-', 'binary'),                                  // PDF
+  Buffer.from([0x89, 0x50, 0x4E, 0x47]),                          // PNG
+  Buffer.from([0xFF, 0xD8, 0xFF]),                                 // JPEG
+  Buffer.from('GIF8', 'binary'),                                   // GIF
+  Buffer.from('RIFF', 'binary'),                                   // RIFF (AVI/WAV/WebP)
+  Buffer.from('OggS', 'binary'),                                   // OGG
+  Buffer.from('fLaC', 'binary'),                                   // FLAC
+  Buffer.from('ID3', 'binary'),                                    // MP3 (with ID3)
+];
+
+/**
+ * Async binary detection with two-tier strategy.
+ * Fast path: `is-binary-path` extension match (instant, no I/O).
+ * Slow path: read first 8KB and check magic-byte signatures + null-byte heuristic.
+ *
+ * The slow path is what catches extensionless binaries that the extension-only
+ * detector misses (firmware ELFs, SQLite DBs, archives renamed without extension, etc.)
+ * — the primary cause of past snapshot bloat in embedded/firmware repos.
+ *
+ * @param {string} absolutePath - Absolute path to the file
+ * @returns {Promise<boolean>} True if the file is binary
+ */
+export async function isBinaryFile(absolutePath) {
+  if (isBinaryPath(absolutePath)) return true;
+
+  let fileHandle;
+  try {
+    fileHandle = await fs.open(absolutePath, 'r');
+    const buffer = Buffer.alloc(8192);
+    const { bytesRead } = await fileHandle.read(buffer, 0, 8192, 0);
+    if (bytesRead === 0) return false; // empty file → treat as text
+
+    const sample = buffer.subarray(0, bytesRead);
+
+    for (const magic of BINARY_MAGIC_NUMBERS) {
+      if (bytesRead >= magic.length && sample.subarray(0, magic.length).equals(magic)) {
+        return true;
+      }
+    }
+
+    // Null-byte heuristic — text files virtually never contain NULs; binaries almost always do.
+    // Strong signal even when the file has no recognizable magic header (raw dumps, custom formats).
+    for (let i = 0; i < bytesRead; i++) {
+      if (sample[i] === 0) return true;
+    }
+
+    return false;
+  } catch {
+    return false; // unreadable → don't skip; let downstream surface the error
+  } finally {
+    if (fileHandle) await fileHandle.close();
+  }
+}
 
 /**
  * Safely extracts metadata headers from Large ML models without loading them into memory.
@@ -38,6 +116,24 @@ import { minimatch } from 'minimatch';
 // Global hard-ignore patterns (shared between git-based and scan-based file collection)
 const GLOBAL_HARD_IGNORE_DIRS = ['node_modules', '.git', '.idea', '.vscode', '.gradle', 'build', '__pycache__'];
 const GLOBAL_HARD_IGNORE_FILES = ['package-lock.json', 'yarn.lock', 'pnpm-lock.yaml', 'go.sum'];
+// Glob-based hard-ignore — for patterns that exact-name matching can't express.
+// Primary target: rotated logs (logrotate/journald) and core dumps.
+// `*.log` is widely conventional to ignore; including it here hardens the default for projects
+// without their own .eckignore. Caller can still opt-in to logs via explicit profile/include.
+const GLOBAL_HARD_IGNORE_GLOBS = [
+  '*.log',          // standard log files
+  '*.log.[0-9]*',   // logrotate numeric suffix: app.log.0, app.log.1
+  '*.log.gz',       // compressed rotated log
+  '*.log.*.gz',     // app.log.0.gz
+  '*.log.bz2',
+  '*.log.xz',
+  'core.[0-9]*',    // Linux core dumps: core.12345
+  '*.swp', '*.swo', // editor swap files
+];
+
+function matchesGlobalHardIgnoreGlob(fileName) {
+  return GLOBAL_HARD_IGNORE_GLOBS.some(p => minimatch(fileName, p, { nocase: true }));
+}
 
 /**
  * Scanner for detecting and redacting secrets (API keys, tokens)
@@ -234,7 +330,7 @@ export async function scanDirectoryRecursively(dirPath, config, relativeTo = dir
       // --- GLOBAL HARD IGNORES (Zero-Config Safety) ---
       if (entry.isDirectory() && GLOBAL_HARD_IGNORE_DIRS.includes(entry.name)) {
         continue;
-      } else if (!entry.isDirectory() && GLOBAL_HARD_IGNORE_FILES.includes(entry.name)) {
+      } else if (!entry.isDirectory() && (GLOBAL_HARD_IGNORE_FILES.includes(entry.name) || matchesGlobalHardIgnoreGlob(entry.name))) {
         continue;
       }
       // -----------------------------------------------
@@ -340,7 +436,7 @@ export async function generateDirectoryTree(dir, prefix = '', allFiles, depth =
     for (const entry of sortedEntries) {
       // --- GLOBAL HARD IGNORES ---
       if (entry.isDirectory() && GLOBAL_HARD_IGNORE_DIRS.includes(entry.name)) continue;
-      if (!entry.isDirectory() && GLOBAL_HARD_IGNORE_FILES.includes(entry.name)) continue;
+      if (!entry.isDirectory() && (GLOBAL_HARD_IGNORE_FILES.includes(entry.name) || matchesGlobalHardIgnoreGlob(entry.name))) continue;
       // ---------------------------
 
       // Skip hidden directories and files (starting with '.')
@@ -1075,6 +1171,7 @@ export async function getProjectFiles(projectPath, config) {
         if (dirsToIgnore.includes(pathParts[i])) return false;
       }
       if (filesToIgnore.includes(fileName)) return false;
+      if (matchesGlobalHardIgnoreGlob(fileName)) return false;
       if (fileExt && extensionsToIgnore.includes(fileExt)) return false;
       return true;
     });

package/src/utils/projectDetector.js

@@ -207,6 +207,8 @@ async function getProjectDetails(projectPath, type) {
       return await getGoDetails(projectPath);
     case 'dotnet':
       return await getDotnetDetails(projectPath);
+    case 'esp-idf':
+      return await getEspIdfDetails(projectPath);
     default:
       return details;
   }
@@ -641,6 +643,64 @@ async function getDotnetDetails(projectPath) {
   return details;
 }
 
+async function getEspIdfDetails(projectPath) {
+  const details = { type: 'esp-idf' };
+
+  try {
+    const cmakePath = path.join(projectPath, 'CMakeLists.txt');
+    if (await fileExists(cmakePath)) {
+      const cmakeContent = await fs.readFile(cmakePath, 'utf-8');
+      const projectMatch = cmakeContent.match(/project\((\w+)/);
+      if (projectMatch) details.projectName = projectMatch[1];
+      const idfPathMatch = cmakeContent.includes('IDF_PATH');
+      if (idfPathMatch) details.usesIdfPath = true;
+    }
+
+    const sdkDefaultsPath = path.join(projectPath, 'sdkconfig.defaults');
+    if (await fileExists(sdkDefaultsPath)) {
+      const sdkContent = await fs.readFile(sdkDefaultsPath, 'utf-8');
+      const chipMatch = sdkContent.match(/CONFIG_IDF_TARGET="(\w+)"/);
+      if (chipMatch) details.targetChip = chipMatch[1];
+      const flashSizeMatch = sdkContent.match(/CONFIG_ESPTOOLPY_FLASHSIZE_(\w+)/);
+      if (flashSizeMatch) details.flashSize = flashSizeMatch[1];
+    }
+
+    const componentYmlPath = path.join(projectPath, 'main', 'idf_component.yml');
+    if (await fileExists(componentYmlPath)) {
+      details.hasComponentManifest = true;
+      try {
+        const ymlContent = await fs.readFile(componentYmlPath, 'utf-8');
+        const deps = [];
+        const depMatches = ymlContent.matchAll(/^\s{2}(\S+):/gm);
+        for (const m of depMatches) {
+          if (m[1] !== 'version') deps.push(m[1]);
+        }
+        if (deps.length > 0) details.dependencies = deps;
+      } catch {}
+    }
+
+    const partitionsPath = path.join(projectPath, 'partitions.csv');
+    if (await fileExists(partitionsPath)) {
+      details.hasPartitions = true;
+    }
+
+    const mainDir = path.join(projectPath, 'main');
+    if (await directoryExists(mainDir)) {
+      try {
+        const mainFiles = await fs.readdir(mainDir);
+        details.mainFiles = mainFiles.filter(f =>
+          f.endsWith('.c') || f.endsWith('.h') || f.endsWith('.cpp')
+        );
+      } catch {}
+    }
+
+  } catch (error) {
+    console.warn('Error getting ESP-IDF project details:', error.message);
+  }
+
+  return details;
+}
+
 // Utility functions
 async function fileExists(filePath) {
   try {