claude-flow 3.7.0-alpha.34 → 3.7.0-alpha.36

package/README.md

@@ -156,11 +156,17 @@ This adds slash commands and agent definitions only. The Ruflo MCP server is NOT
 
 ### CLI Install
 
+**macOS / Linux / WSL / Git-Bash:**
+
 ```bash
-# One-line install
+# One-line install (POSIX shells only — see Windows note below)
 curl -fsSL https://cdn.jsdelivr.net/gh/ruvnet/ruflo@main/scripts/install.sh | bash
+```
+
+**All platforms (including native Windows PowerShell / cmd):**
 
-# Or via npx (interactive setup)
+```bash
+# Interactive setup wizard — runs identically on every platform
 npx ruflo@latest init wizard
 
 # Quick non-interactive init
@@ -170,6 +176,8 @@ npx ruflo@latest init wizard
 npm install -g ruflo@latest
 ```
 
+> 💡 **Windows users:** the `curl ... | bash` form needs a POSIX shell (Git-Bash, WSL, MSYS). The `npx ruflo@latest init wizard` line works natively in PowerShell and cmd. If you hit an `'bash' is not recognized` error, use the `npx` line instead — both end up running the same init flow.
+
 ### MCP Server
 
 ```bash

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-flow",
-  "version": "3.7.0-alpha.34",
+  "version": "3.7.0-alpha.36",
   "description": "Ruflo - Enterprise AI agent orchestration for Claude Code. Deploy 60+ specialized agents in coordinated swarms with self-learning, fault-tolerant consensus, vector memory, and MCP integration",
   "main": "dist/index.js",
   "type": "module",
@@ -89,7 +89,10 @@
     "make-fetch-happen": ">=15.0.0",
     "express-rate-limit": ">=8.4.1",
     "protobufjs": ">=7.5.5",
-    "uuid": ">=14.0.0"
+    "uuid": ">=14.0.0",
+    "@opentelemetry/core": "1.25.1",
+    "@opentelemetry/resources": "1.25.1",
+    "@opentelemetry/sdk-trace-base": "1.25.1"
   },
   "devDependencies": {
     "@openai/codex": "^0.98.0",
@@ -152,4 +155,4 @@
     "access": "public",
     "tag": "latest"
   }
-}
+}

package/v3/@claude-flow/cli/README.md

@@ -156,11 +156,17 @@ This adds slash commands and agent definitions only. The Ruflo MCP server is NOT
 
 ### CLI Install
 
+**macOS / Linux / WSL / Git-Bash:**
+
 ```bash
-# One-line install
+# One-line install (POSIX shells only — see Windows note below)
 curl -fsSL https://cdn.jsdelivr.net/gh/ruvnet/ruflo@main/scripts/install.sh | bash
+```
+
+**All platforms (including native Windows PowerShell / cmd):**
 
-# Or via npx (interactive setup)
+```bash
+# Interactive setup wizard — runs identically on every platform
 npx ruflo@latest init wizard
 
 # Quick non-interactive init
@@ -170,6 +176,8 @@ npx ruflo@latest init wizard
 npm install -g ruflo@latest
 ```
 
+> 💡 **Windows users:** the `curl ... | bash` form needs a POSIX shell (Git-Bash, WSL, MSYS). The `npx ruflo@latest init wizard` line works natively in PowerShell and cmd. If you hit an `'bash' is not recognized` error, use the `npx` line instead — both end up running the same init flow.
+
 ### MCP Server
 
 ```bash

package/v3/@claude-flow/cli/dist/src/commands/memory.js

@@ -694,11 +694,25 @@ const statsCommand = {
                         },
                         {
                             metric: 'HNSW Index',
-                            value: hnsw.available && hnsw.initialized
-                                ? output.success(`active (${hnsw.entryCount.toLocaleString()} entries)`)
-                                : hnsw.available
-                                    ? output.warning('available but not initialized')
-                                    : output.dim('not active'),
+                            // ruflo#1989 / #1987: `hnsw.entryCount` is in-process JS state
+                            // (the live HNSW index of the current Node process). A fresh
+                            // `memory stats` invocation has never indexed anything, so it
+                            // reports 0 even when the persistent DB has thousands of
+                            // entries with embeddings. Use the persistent count from the
+                            // MCP tool (`entriesWithEmbeddings`, which is the actual
+                            // count of rows that have a vector) as the source of truth.
+                            value: (() => {
+                                const persisted = typeof statsResult.entriesWithEmbeddings === 'number'
+                                    ? statsResult.entriesWithEmbeddings
+                                    : null;
+                                const live = hnsw.entryCount || 0;
+                                const total = persisted !== null ? Math.max(persisted, live) : live;
+                                if (!hnsw.available)
+                                    return output.dim('not active');
+                                if (total === 0)
+                                    return output.warning('available but not initialized');
+                                return output.success(`active (${total.toLocaleString()} entries)`);
+                            })(),
                         },
                     ]
                 });

package/v3/@claude-flow/cli/dist/src/init/settings-generator.js

@@ -200,13 +200,45 @@ function generateStatusLineConfig(_options) {
     // Claude Code pipes JSON session data to the script via stdin.
     // Valid fields: type, command, padding (optional).
     // The script runs after each assistant message (debounced 300ms).
-    // NOTE: statusline must NOT use `cmd /c` — Claude Code manages its stdin
-    // directly for statusline commands, and `cmd /c` blocks stdin forwarding.
     //
-    // Same project-local / $HOME fallback as `hookCmd()` (see #1943): the
-    // earlier `${CLAUDE_PROJECT_DIR:-.}` form broke statusline for any
-    // global-install user. Probe project-local first, fall back to $HOME.
+    // ruflo#1948 + #1973: the previous `sh -c 'D="${CLAUDE_PROJECT_DIR:-.}"; …'`
+    // form requires a POSIX shell on PATH. On native Windows (no
+    // Git-Bash / WSL), `sh` either isn't found or its quoting gets
+    // mangled, producing weird artifacts like files named `0)` or
+    // `toastr.error('ESD...` from misparsed tokens leaking back into
+    // the file system. NEVER use `cmd /c` for statusline — Claude Code
+    // manages stdin directly for statusline commands and `cmd /c`
+    // blocks the stdin forwarding.
+    //
+    // Solution: emit a platform-appropriate command at init time.
+    //   POSIX:   `sh -c 'D="…"; … exec node "$D/<script>"'` (existing)
+    //   Windows: a Node.js one-liner that resolves the path internally
+    //            using `process.env.CLAUDE_PROJECT_DIR` with a HOME
+    //            fallback — no shell-quoting hazards because the
+    //            resolution happens inside node, not in the shell.
     const script = '.claude/helpers/statusline.cjs';
+    if (process.platform === 'win32') {
+        // The Node CLI's `-e` flag avoids all shell-quoting pitfalls.
+        // We write the path resolution in JS:
+        //   const fs = require('fs'); const p = require('path');
+        //   const d = process.env.CLAUDE_PROJECT_DIR || '.';
+        //   const f = p.join(d, '.claude/helpers/statusline.cjs');
+        //   const home = process.env.USERPROFILE || process.env.HOME || '.';
+        //   const h = p.join(home, '.claude/helpers/statusline.cjs');
+        //   require(fs.existsSync(f) ? f : h);
+        // …compressed onto one line. Double-quotes around the -e arg are
+        // safe on cmd.exe; the inner JS uses single-quotes for strings.
+        const js = "const fs=require('fs'),p=require('path');" +
+            `const d=process.env.CLAUDE_PROJECT_DIR||'.';` +
+            `const f=p.join(d,'${script}');` +
+            `const h=p.join(process.env.USERPROFILE||process.env.HOME||'.', '${script}');` +
+            'require(fs.existsSync(f)?f:h);';
+        return {
+            type: 'command',
+            command: `node -e "${js}"`,
+        };
+    }
+    // Same project-local / $HOME fallback as `hookCmd()` (see #1943).
     // eslint-disable-next-line no-template-curly-in-string
     const projVar = '${CLAUDE_PROJECT_DIR:-.}';
     // eslint-disable-next-line no-template-curly-in-string

package/v3/@claude-flow/cli/dist/src/init/statusline-generator.js

@@ -225,8 +225,19 @@ function getLearningStats() {
     } catch { /* ignore */ }
   }
 
-  // 3. Count patterns from memory.db using row count (sqlite header bytes 28-31)
+  // 3. Count patterns from memory.db using row count (sqlite header bytes 28-31).
+  //
+  // ruflo#1989: when encryption at rest is enabled, memory.db is no
+  // longer a SQLite database -- it is an RFE1-magicked ciphertext blob.
+  // The original code blindly read bytes 28-31 as a page count and
+  // rendered 3.3B patterns (uint32 of random ciphertext). That
+  // cascaded into fake DDD 5/5 / 100% indicators downstream.
+  //
+  // Guard with the SQLite magic ("SQLite format 3\\0", 16 bytes at
+  // offset 0). Also clamp implausible page counts (>1M pages ~= 4GB)
+  // to avoid reporting nonsense even on plaintext SQLite.
   if (patterns === 0) {
+    const SQLITE_MAGIC = Buffer.from('SQLite format 3\\0', 'binary');
     const memoryPaths = [
       path.join(CWD, '.claude-flow', 'memory.db'),
       path.join(CWD, 'data', 'memory.db'),
@@ -234,18 +245,27 @@ function getLearningStats() {
     ];
     for (const dbPath of memoryPaths) {
       try {
-        if (fs.existsSync(dbPath)) {
-          // Read SQLite header: page count at offset 28 (4 bytes big-endian)
-          const fd = fs.openSync(dbPath, 'r');
-          const buf = Buffer.alloc(4);
-          fs.readSync(fd, buf, 0, 4, 28);
+        if (!fs.existsSync(dbPath)) continue;
+        const fd = fs.openSync(dbPath, 'r');
+        const head = Buffer.alloc(16);
+        fs.readSync(fd, head, 0, 16, 0);
+        if (!head.equals(SQLITE_MAGIC)) {
+          // Not plaintext SQLite (likely RFE1 encrypted, an empty
+          // file, or some other format). Skip — let the daemon or
+          // patterns.json fallback report the real number.
           fs.closeSync(fd);
-          const pageCount = buf.readUInt32BE(0);
-          // Each page typically holds ~10-50 rows; use page count as conservative estimate
-          // But report 0 if DB exists but has only schema pages (< 3)
-          patterns = pageCount > 2 ? pageCount - 2 : 0;
-          break;
+          continue;
         }
+        const buf = Buffer.alloc(4);
+        fs.readSync(fd, buf, 0, 4, 28);
+        fs.closeSync(fd);
+        const pageCount = buf.readUInt32BE(0);
+        // Sanity: reject implausible counts (> 1M pages ≈ 4 GB DB).
+        if (pageCount > 1_000_000) continue;
+        // Each page typically holds ~10-50 rows; use page count as
+        // conservative estimate. Report 0 if only schema pages (< 3).
+        patterns = pageCount > 2 ? pageCount - 2 : 0;
+        break;
       } catch { /* ignore */ }
     }
   }
@@ -281,17 +301,24 @@ function getV3Progress() {
   let domainsCompleted = Math.min(5, Math.floor(dddProgress / 20));
 
   // Only derive DDD progress from real ddd-progress.json or real pattern data
-  // Don't inflate domains from pattern count — 0 means no DDD work tracked
-  if (dddProgress === 0 && learning.patterns > 0) {
+  // Don't inflate domains from pattern count — 0 means no DDD work tracked.
+  // ruflo#1989: defensively clamp learning.patterns even though
+  // getLearningStats already guards against the RFE1-encrypted case --
+  // if any future regression in the upstream reader returns a wild
+  // value, we do not want to silently inflate DDD to 5/5 / 100%.
+  const realPatterns = Number.isFinite(learning.patterns) && learning.patterns >= 0 && learning.patterns < 1_000_000
+    ? learning.patterns
+    : 0;
+  if (dddProgress === 0 && realPatterns > 0) {
     // Conservative: only count domains if we have substantial real pattern data
     // Each domain requires ~100 real stored patterns to claim completion
-    domainsCompleted = Math.min(5, Math.floor(learning.patterns / 100));
+    domainsCompleted = Math.min(5, Math.floor(realPatterns / 100));
     dddProgress = Math.floor((domainsCompleted / totalDomains) * 100);
   }
 
   return {
     domainsCompleted, totalDomains, dddProgress,
-    patternsLearned: learning.patterns,
+    patternsLearned: realPatterns,
     sessionsCompleted: learning.sessions,
   };
 }
@@ -377,8 +404,14 @@ function getSystemMetrics() {
   if (learningData && learningData.intelligence && learningData.intelligence.score !== undefined) {
     intelligencePct = Math.min(100, Math.floor(learningData.intelligence.score));
   } else {
-    // Use real data only — patterns from actual store, vectors from actual DB
-    const fromPatterns = learning.patterns > 0 ? Math.min(100, Math.floor(learning.patterns / 20)) : 0;
+    // Use real data only — patterns from actual store, vectors from actual DB.
+    // ruflo#1989: clamp patterns to a sane upper bound. A multi-billion
+    // pattern count from a buggy reader would saturate intelligencePct
+    // to 100% and silently lie about progress.
+    const realPatterns = Number.isFinite(learning.patterns) && learning.patterns >= 0 && learning.patterns < 1_000_000
+      ? learning.patterns
+      : 0;
+    const fromPatterns = realPatterns > 0 ? Math.min(100, Math.floor(realPatterns / 20)) : 0;
     const fromVectors = agentdb.vectorCount > 0 ? Math.min(100, Math.floor(agentdb.vectorCount / 20)) : 0;
     intelligencePct = Math.max(fromPatterns, fromVectors);
   }

package/v3/@claude-flow/cli/dist/src/mcp-server.js

@@ -235,6 +235,39 @@ export class MCPServerManager extends EventEmitter {
      * Handles stdin/stdout directly like V2 implementation
      */
     async startStdioServer() {
+        // ruflo#1910 — protect the JSON-RPC stdout from any stray
+        // console.log/info/debug emitted by lazily-loaded modules
+        // (@ruvector/router, @claude-flow/neural, transformers.js, ONNX,
+        // semantic-router init, etc.). Codex closes the MCP transport
+        // the moment it sees a non-JSON line on stdout, and one such
+        // line during a tool batch bricked the whole session.
+        //
+        // Strategy: replace console.log/info/debug with stderr writers
+        // for the rest of the process. JSON-RPC frames go out via the
+        // dedicated `writeFrame()` helper below (process.stdout.write
+        // with the original native binding, NOT console.log), so the
+        // hijack can't accidentally redirect protocol frames too.
+        process.env.MCP_STDIO_MODE = '1';
+        const originalLog = console.log; // eslint-disable-line no-console
+        console.log = (...args) => process.stderr.write('[stdout→stderr] ' + args.map(a => typeof a === 'string' ? a : JSON.stringify(a)).join(' ') + '\n');
+        console.info = (...args) => process.stderr.write('[stdout→stderr] ' + args.map(a => typeof a === 'string' ? a : JSON.stringify(a)).join(' ') + '\n');
+        console.debug = (...args) => process.stderr.write('[stdout→stderr] ' + args.map(a => typeof a === 'string' ? a : JSON.stringify(a)).join(' ') + '\n');
+        /** Send a single JSON-RPC frame to the real stdout. Use this instead
+         * of `console.log` so the hijack above can't redirect protocol frames. */
+        const writeFrame = (msg) => {
+            process.stdout.write(JSON.stringify(msg) + '\n');
+        };
+        // Reference originalLog to keep the eslint-disable meaningful — also
+        // gives us an escape hatch if a test wants to verify it was replaced.
+        void originalLog;
+        // Catch fatal errors that would otherwise close the transport
+        // mid-batch with no JSON-RPC error returned to the client.
+        process.on('uncaughtException', (err) => {
+            process.stderr.write(`[mcp-stdio] uncaughtException: ${err.stack || err.message}\n`);
+        });
+        process.on('unhandledRejection', (reason) => {
+            process.stderr.write(`[mcp-stdio] unhandledRejection: ${reason instanceof Error ? reason.stack || reason.message : String(reason)}\n`);
+        });
         // Import the tool registry
         const { listMCPTools, callMCPTool, hasTool } = await import('./mcp-client.js');
         const VERSION = '3.0.0';
@@ -277,7 +310,7 @@ export class MCPServerManager extends EventEmitter {
             version: VERSION,
         }));
         // Send server initialization notification
-        console.log(JSON.stringify({
+        writeFrame({
             jsonrpc: '2.0',
             method: 'server.initialized',
             params: {
@@ -290,7 +323,7 @@ export class MCPServerManager extends EventEmitter {
                     },
                 },
             },
-        }));
+        });
         // Handle stdin messages (S-5: bounded buffer to prevent OOM)
         const MAX_BUFFER_SIZE = 10 * 1024 * 1024; // 10MB
         let buffer = '';
@@ -299,10 +332,10 @@ export class MCPServerManager extends EventEmitter {
             if (buffer.length > MAX_BUFFER_SIZE) {
                 console.error(`[${new Date().toISOString()}] ERROR [claude-flow-mcp] Buffer exceeded ${MAX_BUFFER_SIZE} bytes, rejecting`);
                 buffer = '';
-                console.log(JSON.stringify({
+                writeFrame({
                     jsonrpc: '2.0',
                     error: { code: -32600, message: 'Request too large' },
-                }));
+                });
                 return;
             }
             // Process complete JSON messages
@@ -314,7 +347,7 @@ export class MCPServerManager extends EventEmitter {
                         const message = JSON.parse(line);
                         const response = await this.handleMCPMessage(message, sessionId);
                         if (response) {
-                            console.log(JSON.stringify(response));
+                            writeFrame(response);
                         }
                     }
                     catch (error) {

package/v3/@claude-flow/cli/dist/src/mcp-tools/memory-tools.js

@@ -70,6 +70,37 @@ function sanitizeMemoryKey(key) {
     const safe = key.replace(DANGEROUS_KEY_CHARS, '_');
     return safe.length > MAX_KEY_LENGTH ? safe.slice(0, MAX_KEY_LENGTH) : safe;
 }
+// #1937 — minimal glob → RegExp helper for memory_import_claude exclusion
+// patterns. Anchored. Supports the three operators the issue's voice-fidelity
+// workflow needs:
+//   `**` — any chars including path separators
+//   `*`  — any chars except path separators
+//   `?`  — exactly one char except a path separator
+// Everything else is regex-escaped. Used to match absolute file paths.
+function globToRegex(pattern) {
+    // Tokenize so we can replace `**` before `*` without overlap.
+    let out = '';
+    for (let i = 0; i < pattern.length; i++) {
+        const c = pattern[i];
+        if (c === '*' && pattern[i + 1] === '*') {
+            out += '.*';
+            i++;
+        }
+        else if (c === '*') {
+            out += '[^/\\\\]*';
+        }
+        else if (c === '?') {
+            out += '[^/\\\\]';
+        }
+        else if (/[.+^$|(){}\[\]\\]/.test(c)) {
+            out += '\\' + c;
+        }
+        else {
+            out += c;
+        }
+    }
+    return new RegExp('^' + out + '$');
+}
 // #1883 — resolve the Claude-Code project memory directory for the *current*
 // project. Claude Code hashes the project path differently per host OS, and
 // our previous logic only POSIX-slash-replaced cwd, which breaks for:
@@ -677,7 +708,7 @@ export const memoryTools = [
     // ===== Claude Code Memory Bridge Tools =====
     {
         name: 'memory_import_claude',
-        description: 'Import Claude Code auto-memory files into AgentDB with ONNX vector embeddings. Reads ~/.claude/projects/*/memory/*.md files, parses YAML frontmatter, splits into sections, and stores with 384-dim embeddings for semantic search. Use allProjects=true to import from ALL Claude projects. Pass projectPath to override cwd-based detection (#1883 — required when Ruflo runs in WSL but Claude Code is on Windows). Use when native Read/Write is wrong because you need (a) cross-session retrieval by semantic similarity (vector embeddings) not by file path, (b) namespacing across projects without managing directory layout, or (c) the .swarm/memory.db audit trail. For one-shot file I/O, native Read/Write is fine.',
+        description: 'Import Claude Code auto-memory files into AgentDB with ONNX vector embeddings. Reads ~/.claude/projects/*/memory/*.md files, parses YAML frontmatter, splits into sections, and stores with 384-dim embeddings for semantic search. Use allProjects=true to import from ALL Claude projects. Pass projectPath to override cwd-based detection (#1883 — required when Ruflo runs in WSL but Claude Code is on Windows). Pass excludeFilePatterns (glob list) or excludeFiles (absolute path list) to skip voice-load-bearing, PII, or persona-restricted files (#1937). Use when native Read/Write is wrong because you need (a) cross-session retrieval by semantic similarity (vector embeddings) not by file path, (b) namespacing across projects without managing directory layout, or (c) the .swarm/memory.db audit trail. For one-shot file I/O, native Read/Write is fine.',
         category: 'memory',
         inputSchema: {
             type: 'object',
@@ -685,6 +716,16 @@ export const memoryTools = [
                 allProjects: { type: 'boolean', description: 'Import from all Claude projects (default: current project only)' },
                 namespace: { type: 'string', description: 'Target namespace (default: "claude-memories")' },
                 projectPath: { type: 'string', description: '#1883 — explicit project path to hash, used when cwd does not match Claude Code\'s view (e.g. WSL bridge to Windows host). Pass the canonical project root as Claude Code sees it.' },
+                excludeFilePatterns: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: '#1937 — glob patterns matched against the absolute file path. Files matching ANY pattern are skipped. Supports `*` (any chars within a path segment), `**` (any chars including separators), and `?` (single char). Examples: `**/voice-*.md`, `**/persona-*.md`. Combine with excludeFiles for explicit paths.',
+                },
+                excludeFiles: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: '#1937 — absolute file paths to skip verbatim. Faster than a pattern when the list is known ahead of time (operator captured baselines). Combine with excludeFilePatterns.',
+                },
             },
         },
         handler: async (input) => {
@@ -699,8 +740,18 @@ export const memoryTools = [
             const allProjects = input.allProjects;
             const projectPathOverride = input.projectPath;
             const claudeProjectsDir = join(homedir(), '.claude', 'projects');
+            // #1937 — voice-fidelity / persona-restricted exclusion.
+            const excludeFilePatterns = Array.isArray(input.excludeFilePatterns) ? input.excludeFilePatterns : [];
+            const excludeFilesList = Array.isArray(input.excludeFiles) ? new Set(input.excludeFiles) : new Set();
+            const excludeRegexes = excludeFilePatterns.map(globToRegex);
+            const isExcluded = (absPath) => {
+                if (excludeFilesList.has(absPath))
+                    return true;
+                return excludeRegexes.some(re => re.test(absPath));
+            };
             // Find memory files
             const memoryFiles = [];
+            let excludedByPattern = 0;
             if (allProjects) {
                 // Scan all projects
                 if (existsSync(claudeProjectsDir)) {
@@ -712,7 +763,12 @@ export const memoryTools = [
                             if (!existsSync(memDir))
                                 continue;
                             for (const file of readdirSync(memDir).filter((f) => f.endsWith('.md'))) {
-                                memoryFiles.push({ path: join(memDir, file), project: project.name, file });
+                                const absPath = join(memDir, file);
+                                if (isExcluded(absPath)) {
+                                    excludedByPattern++;
+                                    continue;
+                                }
+                                memoryFiles.push({ path: absPath, project: project.name, file });
                             }
                         }
                     }
@@ -726,7 +782,12 @@ export const memoryTools = [
                 if (resolved) {
                     try {
                         for (const file of readdirSync(resolved.memDir).filter((f) => f.endsWith('.md'))) {
-                            memoryFiles.push({ path: join(resolved.memDir, file), project: resolved.projectHash, file });
+                            const absPath = join(resolved.memDir, file);
+                            if (isExcluded(absPath)) {
+                                excludedByPattern++;
+                                continue;
+                            }
+                            memoryFiles.push({ path: absPath, project: resolved.projectHash, file });
                         }
                     }
                     catch { /* scan error */ }
@@ -802,6 +863,7 @@ export const memoryTools = [
                 imported,
                 skipped,
                 duplicatesSkipped,
+                excludedByPattern,
                 files: memoryFiles.length,
                 projects: projects.size,
                 namespace: ns,

package/v3/@claude-flow/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@claude-flow/cli",
-  "version": "3.7.0-alpha.34",
+  "version": "3.7.0-alpha.36",
   "type": "module",
   "description": "Ruflo CLI - Enterprise AI agent orchestration with 60+ specialized agents, swarm coordination, MCP server, self-learning hooks, and vector memory for Claude Code",
   "main": "dist/src/index.js",