@brunobrise/xfeat 1.0.5 → 1.1.0

package/README.md

@@ -93,6 +93,7 @@ The foundational Tree-sitter AST parser natively understands:
 - JavaScript (`.js`, `.jsx`)
 - TypeScript (`.ts`, `.tsx`)
 - Python (`.py`)
+- Rust (`.rs`)
 
 ## License
 

package/index.js

@@ -4,6 +4,7 @@ const path = require("path");
 const fg = require("fast-glob");
 const ignore = require("ignore");
 const { Parser, Language } = require("web-tree-sitter");
+const { Listr } = require("listr2");
 require("dotenv").config({ path: path.join(process.cwd(), ".env") });
 const { Anthropic } = require("@anthropic-ai/sdk");
 const anthropic = new Anthropic({
@@ -587,43 +588,6 @@ async function main() {
     return;
   }
 
-  // 1. Extract structural data
-  const structuralData = [];
-  for (const file of targetFiles) {
-    // Only analyze files from the codebase (skip our own index.js if running locally)
-    if (file.endsWith("index.js") && __dirname === targetDir) continue;
-
-    console.log(`Analyzing file structure: ${file}...`);
-    const data = await extractStructure(file);
-
-    if (
-      data &&
-      (data.classes.length > 0 ||
-        data.functions.length > 0 ||
-        data.exports.length > 0)
-    ) {
-      structuralData.push({
-        path: path.relative(targetDir, file),
-        ...data,
-      });
-    } else {
-      // Graceful Fallback for missing AST or empty extractions (LLM must read whole file)
-      structuralData.push({
-        path: path.relative(targetDir, file),
-        classes: [],
-        functions: [],
-        exports: [],
-        imports: [],
-        note: "AST parsing unavailable. You MUST use view_file to extract features.",
-      });
-    }
-  }
-
-  if (structuralData.length === 0) {
-    console.log("No valid structural data found.");
-    return;
-  }
-
   // --- CACHE INITIALIZATION ---
   const folderName = path.basename(path.resolve(targetDir));
   const outputPath = path.join(process.cwd(), `${folderName}-features.md`);
@@ -656,8 +620,6 @@ async function main() {
     await fs.writeFile(cachePath, JSON.stringify(cache, null, 2), "utf8");
   };
 
-  // --- PIPELINE EXECUTION ---
-
   if (!process.env.ANTHROPIC_API_KEY && !process.env.ANTHROPIC_AUTH_TOKEN) {
     console.error(
       "\n❌ ERROR: Missing ANTHROPIC_API_KEY or ANTHROPIC_AUTH_TOKEN environment variable.",
@@ -667,107 +629,192 @@ async function main() {
 
   const CONCURRENCY_LIMIT = parseInt(process.env.CONCURRENCY_LIMIT || "5", 10);
 
-  console.log(`\n--- STAGE 1: Micro Analysis (File Level) ---`);
-  console.log(`Using concurrency limit: ${CONCURRENCY_LIMIT}`);
-
-  const fileAnalysesRaw = await pMap(
-    structuralData,
-    async (data) => {
-      // Check cache first
-      if (cache.fileAnalyses[data.path]) {
-        console.log(`[File] Skipping ${data.path} (Already in cache)`);
-        return cache.fileAnalyses[data.path];
-      }
+  const tasks = new Listr(
+    [
+      {
+        title: "Analyzing File Structure",
+        task: async (ctx, task) => {
+          const structuralData = [];
+          let completed = 0;
+          const total = targetFiles.length;
+
+          for (const file of targetFiles) {
+            if (file.endsWith("index.js") && __dirname === targetDir) {
+              completed++;
+              continue;
+            }
 
-      console.log(`[File] Analyzing ${data.path}...`);
-      try {
-        const featuresMd = await extractFeaturesWithClaude(data, targetDir);
-        const result = {
-          path: data.path,
-          dir: path.dirname(data.path),
-          features: featuresMd,
-        };
-
-        // Save to cache immediately
-        cache.fileAnalyses[data.path] = result;
-        await saveCache();
-
-        return result;
-      } catch (e) {
-        console.error(`Failed to analyze ${data.path}`, e);
-        return null;
-      }
-    },
-    CONCURRENCY_LIMIT,
-  );
+            task.output = `${path.relative(targetDir, file)} (${completed}/${total})`;
+            const data = await extractStructure(file);
+
+            if (
+              data &&
+              (data.classes.length > 0 ||
+                data.functions.length > 0 ||
+                data.exports.length > 0)
+            ) {
+              structuralData.push({
+                path: path.relative(targetDir, file),
+                ...data,
+              });
+            } else {
+              structuralData.push({
+                path: path.relative(targetDir, file),
+                classes: [],
+                functions: [],
+                exports: [],
+                imports: [],
+                note: "AST parsing unavailable. You MUST use view_file to extract features.",
+              });
+            }
+            completed++;
+          }
 
-  const fileAnalyses = fileAnalysesRaw.filter(Boolean);
+          if (structuralData.length === 0) {
+            throw new Error("No valid structural data found.");
+          }
+          ctx.structuralData = structuralData;
+        },
+      },
+      {
+        title: "STAGE 1: Micro Analysis (File Level)",
+        task: async (ctx, task) => {
+          let completed = 0;
+          const total = ctx.structuralData.length;
+          task.output = `Completed 0/${total} files`;
+
+          const fileAnalysesRaw = await pMap(
+            ctx.structuralData,
+            async (data) => {
+              if (cache.fileAnalyses[data.path]) {
+                completed++;
+                task.output = `Completed ${completed}/${total} files`;
+                return cache.fileAnalyses[data.path];
+              }
+
+              try {
+                const featuresMd = await extractFeaturesWithClaude(
+                  data,
+                  targetDir,
+                );
+                const result = {
+                  path: data.path,
+                  dir: path.dirname(data.path),
+                  features: featuresMd,
+                };
+
+                // Save to cache immediately
+                cache.fileAnalyses[data.path] = result;
+                await saveCache();
+
+                completed++;
+                task.output = `Completed ${completed}/${total} files`;
+                return result;
+              } catch (e) {
+                completed++;
+                task.output = `Failed to analyze ${data.path}`;
+                return null;
+              }
+            },
+            CONCURRENCY_LIMIT,
+          );
 
-  console.log(`\n--- STAGE 2: Macro Analysis (Component Level) ---`);
-  // Group files by directory
-  const directories = {};
-  for (const file of fileAnalyses) {
-    if (!directories[file.dir]) directories[file.dir] = [];
-    directories[file.dir].push(file);
-  }
+          ctx.fileAnalyses = fileAnalysesRaw.filter(Boolean);
+        },
+        options: { bottomBar: Infinity },
+      },
+      {
+        title: "STAGE 2: Macro Analysis (Component Level)",
+        task: async (ctx, task) => {
+          const directories = {};
+          for (const file of ctx.fileAnalyses) {
+            if (!directories[file.dir]) directories[file.dir] = [];
+            directories[file.dir].push(file);
+          }
 
-  const componentSummaries = {};
-  const dirEntries = Object.entries(directories);
-
-  await pMap(
-    dirEntries,
-    async ([dir, files]) => {
-      // Check cache first
-      if (cache.componentSummaries[dir]) {
-        console.log(`[Component] Skipping ${dir} (Already in cache)`);
-        componentSummaries[dir] = cache.componentSummaries[dir];
-        return;
-      }
+          const componentSummaries = {};
+          const dirEntries = Object.entries(directories);
+          let completed = 0;
+          const total = dirEntries.length;
+          task.output = `Completed 0/${total} components`;
+
+          await pMap(
+            dirEntries,
+            async ([dir, files]) => {
+              if (cache.componentSummaries[dir]) {
+                componentSummaries[dir] = cache.componentSummaries[dir];
+                completed++;
+                task.output = `Completed ${completed}/${total} components`;
+                return;
+              }
+
+              try {
+                const summary = await extractComponentSummary(dir, files);
+                componentSummaries[dir] = summary;
+
+                cache.componentSummaries[dir] = summary;
+                await saveCache();
+
+                completed++;
+                task.output = `Completed ${completed}/${total} components`;
+              } catch (e) {
+                completed++;
+                task.output = `Failed to synthesize component ${dir}`;
+              }
+            },
+            CONCURRENCY_LIMIT,
+          );
+          ctx.componentSummaries = componentSummaries;
+        },
+        options: { bottomBar: Infinity },
+      },
+      {
+        title: "STAGE 3: Global Architecture Mapping",
+        task: async (ctx, task) => {
+          let globalArchitecture = cache.globalArchitecture;
+          if (!globalArchitecture) {
+            globalArchitecture = await extractGlobalArchitecture(
+              ctx.componentSummaries,
+            );
+            cache.globalArchitecture = globalArchitecture;
+            await saveCache();
+          }
+          ctx.globalArchitecture = globalArchitecture;
+        },
+      },
+      {
+        title: "Final Assembly",
+        task: async (ctx, task) => {
+          let finalDocument = `# Codebase Architecture & Feature Map\n\n`;
+          finalDocument += `${ctx.globalArchitecture}\n\n`;
+          finalDocument += `---\n\n## Component Breakdown\n\n`;
+
+          for (const [dir, summary] of Object.entries(ctx.componentSummaries)) {
+            finalDocument += `### Directory: \`${dir}\`\n${summary}\n\n`;
+          }
 
-      console.log(`[Component] Synthesizing ${dir} (${files.length} files)...`);
-      try {
-        const summary = await extractComponentSummary(dir, files);
-        componentSummaries[dir] = summary;
+          finalDocument += `---\n\n## File-Level Details\n\n`;
+          for (const file of ctx.fileAnalyses) {
+            finalDocument += `#### \`${file.path}\`\n${file.features}\n\n`;
+          }
 
-        // Save to cache immediately
-        cache.componentSummaries[dir] = summary;
-        await saveCache();
-      } catch (e) {
-        console.error(`Failed to synthesize component ${dir}`, e);
-      }
+          await fs.writeFile(outputPath, finalDocument, "utf8");
+          task.title = `Codebase mapping complete! Saved to ${outputPath}`;
+        },
+      },
+    ],
+    {
+      rendererOptions: {
+        collapseSubtasks: false,
+      },
     },
-    CONCURRENCY_LIMIT,
   );
 
-  console.log(`\n--- STAGE 3: Global Architecture Mapping ---`);
-  let globalArchitecture = cache.globalArchitecture;
-  if (globalArchitecture) {
-    console.log(`[Global] Skipping global architecture (Already in cache)`);
-  } else {
-    console.log(`[Global] Synthesizing final architecture...`);
-    globalArchitecture = await extractGlobalArchitecture(componentSummaries);
-    cache.globalArchitecture = globalArchitecture;
-    await saveCache();
-  }
-
-  // --- FINAL ASSEMBLY ---
-  console.log(`\nWriting final report to ${outputPath}...`);
-
-  let finalDocument = `# Codebase Architecture & Feature Map\n\n`;
-  finalDocument += `${globalArchitecture}\n\n`;
-  finalDocument += `---\n\n## Component Breakdown\n\n`;
-
-  for (const [dir, summary] of Object.entries(componentSummaries)) {
-    finalDocument += `### Directory: \`${dir}\`\n${summary}\n\n`;
-  }
-
-  finalDocument += `---\n\n## File-Level Details\n\n`;
-  for (const file of fileAnalyses) {
-    finalDocument += `#### \`${file.path}\`\n${file.features}\n\n`;
+  try {
+    await tasks.run();
+  } catch (err) {
+    console.error("An error occurred during execution:", err.message);
   }
-
-  await fs.writeFile(outputPath, finalDocument, "utf8");
-  console.log(`\n✅ Codebase mapping complete! Saved to ${outputPath}`);
 }
 
 if (require.main === module) {

package/index.test.js

@@ -1,13 +1,9 @@
-const path = require('path');
-const fs = require('fs/promises');
-const {
-  getIgnores,
-  initTreeSitter,
-  extractStructure
-} = require('./index');
+const path = require("path");
+const fs = require("fs/promises");
+const { getIgnores, initTreeSitter, extractStructure } = require("./index");
 
-describe('Code Features Extractor Unit Tests', () => {
-  const testDir = path.join(__dirname, '__test_workspace__');
+describe("Code Features Extractor Unit Tests", () => {
+  const testDir = path.join(__dirname, "__test_workspace__");
 
   beforeAll(async () => {
     // Create a temporary workspace for testing
@@ -15,24 +11,24 @@ describe('Code Features Extractor Unit Tests', () => {
 
     // Create a fake .gitignore
     await fs.writeFile(
-      path.join(testDir, '.gitignore'),
-      'ignored_folder/\n*.log\n'
+      path.join(testDir, ".gitignore"),
+      "ignored_folder/\n*.log\n",
     );
 
     // Create some fake code files
     await fs.writeFile(
-      path.join(testDir, 'sample.js'),
+      path.join(testDir, "sample.js"),
       `
       import { someLib } from 'some-lib';
       export class MyClass {
         myMethod() {}
       }
       export function myFunction() {}
-      `
+      `,
     );
 
     await fs.writeFile(
-      path.join(testDir, 'sample.py'),
+      path.join(testDir, "sample.py"),
       `
 from math import sqrt
 class PythonClass:
@@ -40,14 +36,25 @@ class PythonClass:
         pass
 def py_function():
     pass
-      `
+      `,
     );
 
     await fs.writeFile(
-      path.join(testDir, 'unsupported.txt'),
-      'Hello world'
+      path.join(testDir, "sample.rs"),
+      `
+      use std::collections::HashMap;
+      pub struct MyRustStruct {
+          field: i32,
+      }
+      impl MyRustStruct {
+          pub fn rs_method(&self) {}
+      }
+      pub fn rs_function() {}
+      `,
     );
 
+    await fs.writeFile(path.join(testDir, "unsupported.txt"), "Hello world");
+
     // Initialize TreeSitter before testing extraction
     await initTreeSitter();
   });
@@ -57,71 +64,82 @@ def py_function():
     await fs.rm(testDir, { recursive: true, force: true });
   });
 
-  describe('getIgnores', () => {
-    it('should parse .gitignore and include defaults', async () => {
+  describe("getIgnores", () => {
+    it("should parse .gitignore and include defaults", async () => {
       const ig = await getIgnores(testDir);
-      
+
       // Defaults
-      expect(ig.ignores('node_modules')).toBe(true);
-      expect(ig.ignores('.git')).toBe(true);
-      
+      expect(ig.ignores("node_modules")).toBe(true);
+      expect(ig.ignores(".git")).toBe(true);
+
       // Custom rules
-      expect(ig.ignores('ignored_folder/file.js')).toBe(true);
-      expect(ig.ignores('test.log')).toBe(true);
-      
+      expect(ig.ignores("ignored_folder/file.js")).toBe(true);
+      expect(ig.ignores("test.log")).toBe(true);
+
       // Non-ignored
-      expect(ig.ignores('src/main.js')).toBe(false);
-      expect(ig.ignores('index.js')).toBe(false);
+      expect(ig.ignores("src/main.js")).toBe(false);
+      expect(ig.ignores("index.js")).toBe(false);
     });
 
-    it('should handle missing .gitignore by returning defaults', async () => {
-      const emptyDir = path.join(__dirname, '__empty_test_dir__');
+    it("should handle missing .gitignore by returning defaults", async () => {
+      const emptyDir = path.join(__dirname, "__empty_test_dir__");
       await fs.mkdir(emptyDir, { recursive: true });
 
       const ig = await getIgnores(emptyDir);
-      expect(ig.ignores('node_modules')).toBe(true);
-      expect(ig.ignores('.git')).toBe(true);
-      expect(ig.ignores('test.log')).toBe(false); // custom rule should be false
+      expect(ig.ignores("node_modules")).toBe(true);
+      expect(ig.ignores(".git")).toBe(true);
+      expect(ig.ignores("test.log")).toBe(false); // custom rule should be false
 
       await fs.rm(emptyDir, { recursive: true, force: true });
     });
   });
 
-  describe('extractStructure', () => {
-    it('should extract AST structure for JavaScript files', async () => {
-      const jsFilePath = path.join(testDir, 'sample.js');
+  describe("extractStructure", () => {
+    it("should extract AST structure for JavaScript files", async () => {
+      const jsFilePath = path.join(testDir, "sample.js");
       const structure = await extractStructure(jsFilePath);
-      
+
       expect(structure).not.toBeNull();
       expect(structure.file).toBe(jsFilePath);
-      expect(structure.classes).toContain('MyClass');
-      expect(structure.functions).toContain('myMethod');
-      expect(structure.functions).toContain('myFunction');
-      expect(structure.exports).toContain('MyClass');
-      expect(structure.exports).toContain('myFunction');
+      expect(structure.classes).toContain("MyClass");
+      expect(structure.functions).toContain("myMethod");
+      expect(structure.functions).toContain("myFunction");
+      expect(structure.exports).toContain("MyClass");
+      expect(structure.exports).toContain("myFunction");
       expect(structure.imports).toContain("'some-lib'");
     });
 
-    it('should extract AST structure for Python files', async () => {
-      const pyFilePath = path.join(testDir, 'sample.py');
+    it("should extract AST structure for Python files", async () => {
+      const pyFilePath = path.join(testDir, "sample.py");
       const structure = await extractStructure(pyFilePath);
-      
+
       expect(structure).not.toBeNull();
       expect(structure.file).toBe(pyFilePath);
-      expect(structure.classes).toContain('PythonClass');
-      expect(structure.functions).toContain('py_method');
-      expect(structure.functions).toContain('py_function');
-      expect(structure.imports).toContain('math');
+      expect(structure.classes).toContain("PythonClass");
+      expect(structure.functions).toContain("py_method");
+      expect(structure.functions).toContain("py_function");
+      expect(structure.imports).toContain("math");
+    });
+
+    it("should extract AST structure for Rust files", async () => {
+      const rsFilePath = path.join(testDir, "sample.rs");
+      const structure = await extractStructure(rsFilePath);
+
+      expect(structure).not.toBeNull();
+      expect(structure.file).toBe(rsFilePath);
+      expect(structure.classes).toContain("MyRustStruct");
+      expect(structure.functions).toContain("rs_method");
+      expect(structure.functions).toContain("rs_function");
     });
 
-    it('should return null for unsupported file extensions', async () => {
-      const txtFilePath = path.join(testDir, 'unsupported.txt');
+    it("should return null for unsupported file extensions", async () => {
+      const txtFilePath = path.join(testDir, "unsupported.txt");
       const structure = await extractStructure(txtFilePath);
       expect(structure).toBeNull();
     });
 
-    it('should return null (graceful failure) when parsing a nonexistent file', async () => {
-      const nonexistentPath = path.join(testDir, 'does-not-exist.js');
+    it("should return null (graceful failure) when parsing a nonexistent file", async () => {
+      const nonexistentPath = path.join(testDir, "does-not-exist.js");
       const structure = await extractStructure(nonexistentPath);
       expect(structure).toBeNull();
     });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@brunobrise/xfeat",
-  "version": "1.0.5",
+  "version": "1.1.0",
   "description": "",
   "publishConfig": {
     "access": "public"
@@ -37,6 +37,7 @@
     "dotenv": "^17.3.1",
     "fast-glob": "^3.3.3",
     "ignore": "^7.0.5",
+    "listr2": "^6.6.1",
     "map-stream": "^0.0.7",
     "tree-sitter-bash": "^0.25.1",
     "tree-sitter-css": "^0.25.0",