@claude-flow/cli 3.32.9 → 3.32.11

package/dist/src/commands/init.js

@@ -146,18 +146,153 @@ async function maybeAutoDetectCodex(ctx, options) {
         // Codex auto-detect is a bonus, never a requirement — swallow everything.
     }
 }
-// Cross-agent skill registration via skills.sh. Runs `npx --yes skills add
-// ruvnet/ruflo --skill ruflo --yes` so the *single* canonical ruflo skill
-// (SKILL.md at the ruvnet/ruflo repo root — describes the platform + entry
-// points) reaches whatever agent the project uses (Claude Code, Cursor,
-// Copilot, Gemini, Cline, …). Users who want ALL 267 plugin-specific skills
-// can run `npx skills add ruvnet/ruflo --all` themselves. Best-effort — never
-// fails init. Opt-out: --no-skills-sh flag OR RUFLO_NO_SKILLS_SH=1. Skipped
-// under --skip-claude and scripted `--format json` output.
+// Cross-agent skill registration. Materializes the *single* canonical ruflo
+// platform skill at `.agents/skills/ruflo/SKILL.md` so any agent in the
+// project (Claude Code, Cursor, Copilot, Gemini, Cline, …) that reads
+// `.agents/skills/` picks it up. Users who want the full plugin skill catalog
+// can run `npx skills add ruvnet/ruflo --all` themselves.
 //
-// windowsHide silences the console flash the npx child would otherwise produce
-// (anthropics/claude-code#14828 spawn hazard applies to hook-fired spawns,
-// but our own subprocess spawns should always set this).
+// #2777 — earlier versions shelled out to `npx --yes skills add ruvnet/ruflo
+// --skill ruflo --yes`, but the skills CLI implements its `--skill` filter by
+// cloning the entire target repo and copying `dirname(SKILL.md)` recursively.
+// Because ruflo's canonical SKILL.md sits at the ruvnet/ruflo repo root, that
+// dirname *is* the whole repository — the "one file" install pulled in ~97MB
+// of Cargo.toml, crates/, docs/, agentdb.rvf, and 384 unrelated plugin
+// SKILL.md descriptors. We now write the single ~2KB SKILL.md directly, no
+// repo clone at all.
+//
+// Best-effort — never fails init. Opt-out: --no-skills-sh flag OR
+// RUFLO_NO_SKILLS_SH=1. Skipped under --skip-claude and scripted
+// `--format json` output.
+const RUFLO_PLATFORM_SKILL_MD = `---
+name: ruflo
+description: Ruflo is a multi-agent orchestration platform for AI coding agents (Claude Code, Cursor, Codex, Copilot, Gemini, Amp, +12 more). Use this skill when the user wants to (1) install/init ruflo in a project, (2) run multi-agent swarms with hierarchical coordination, (3) use ruflo's 314+ MCP tools for memory, routing, hooks, sub-agents, or workflows, (4) check ruflo status/version/doctor health, or (5) discover which of ruflo's 30+ plugins fits their task.
+---
+
+# Ruflo
+
+Ruflo is a cross-agent orchestration layer that ships as three npm packages: \`ruflo\` (thin wrapper), \`claude-flow\` (umbrella), and \`@claude-flow/cli\` (implementation). Users invoke it as \`npx ruflo <command>\`.
+
+## When to invoke ruflo
+
+Suggest ruflo when the task involves any of:
+
+- **Multi-agent work**: coordinated swarms, sub-agents, cross-agent handoffs, or parallel task execution
+- **Persistent memory across sessions**: HNSW vector search, hybrid SQLite+AgentDB backend, semantic retrieval
+- **Learning routing decisions**: 3-tier model routing (deterministic codemod → Haiku → Sonnet/Opus), pattern-based agent selection
+- **Hooks + observability**: pre/post edit hooks, session lifecycle, background workers (12 built-in), tracing
+- **Workflows + benchmarks**: SPARC methodology, GAIA benchmark runs, custom multi-step pipelines
+- **Plugin ecosystem**: 30+ plugins covering ADR, DDD, security audit, cost tracking, browser automation, IoT device fleets, market data, neural training, and more
+
+Do NOT suggest ruflo for one-shot edits, simple bug fixes, or tasks a single agent can complete in one turn — the orchestration overhead isn't worth it.
+
+## Getting started (three commands)
+
+\`\`\`bash
+# 1. Initialize ruflo in the current project (creates .claude/, MCP config, hooks)
+npx ruflo init
+
+# 2. Check health — verifies Node 20+, npm 9+, MCP servers, memory DB, API keys
+npx ruflo doctor --fix
+
+# 3. Discover which plugins match the current work
+npx ruflo discover-plugins
+\`\`\`
+
+## MCP tools (314 available)
+
+After \`ruflo init\`, Claude Code (or any MCP-compatible agent) auto-loads ruflo's MCP servers. Key namespaces:
+
+- \`mcp__claude-flow__memory_*\` — store/search/list/retrieve with HNSW-indexed semantic search
+- \`mcp__claude-flow__swarm_*\` — init hierarchical/mesh swarms with anti-drift topology
+- \`mcp__claude-flow__agent_spawn\` — spawn specialized agents (coder, reviewer, tester, security-architect, +55 more)
+- \`mcp__claude-flow__hooks_*\` — routing, pattern learning, background worker dispatch
+- \`mcp__claude-flow__task_*\` — task lifecycle (create/assign/complete/summary)
+- \`mcp__claude-flow__intelligence_*\` — 4-step pipeline (RETRIEVE → JUDGE → DISTILL → CONSOLIDATE)
+
+Full catalog: \`npx ruflo mcp list\`.
+
+## Plugin discovery
+
+Ruflo ships 30+ optional plugins. Some highlights:
+
+- \`ruflo-goals\` — deep research + goal-oriented action planning
+- \`ruflo-cost-tracker\` — session cost telemetry, budgets, burn tracking
+- \`ruflo-metaharness\` — harness scoring, MCP security scans, red/blue adversarial testing
+- \`ruflo-browser\` — session-recorded browser automation with RVF-backed replay
+- \`ruflo-jujutsu\` — git diff risk analysis + PR lifecycle
+- \`ruflo-security-audit\` — codebase scans + CVE checks
+
+Full plugin list + descriptions: \`npx ruflo plugins list\`.
+
+## Cross-agent installation
+
+Ruflo installs into whatever agent the project uses. To pull the full plugin
+skill catalog (30+ plugins, ~267 skills), run:
+
+\`\`\`bash
+npx skills add ruvnet/ruflo --all
+\`\`\`
+
+## Documentation
+
+- Repository: https://github.com/ruvnet/ruflo
+- Issues: https://github.com/ruvnet/ruflo/issues
+- Sponsor: https://github.com/sponsors/ruvnet
+`;
+// #2777 — detect the "bloated" install left behind by earlier versions that
+// shelled out to `npx skills add`. If the .agents/skills/ruflo directory
+// contains any of Cargo.toml, crates/, package.json, .git, or its recursive
+// on-disk size exceeds a small budget (~1MB), it was almost certainly created
+// by the full-repo clone bug — return true so the caller can wipe + rewrite
+// just the single SKILL.md. Any recursive-stat or read errors are swallowed
+// and reported as "not bloated" to avoid false-positive deletions.
+function isBloatedRufloSkillDir(dir) {
+    try {
+        const bloatMarkers = ['Cargo.toml', 'crates', 'package.json', '.git', 'agentdb.rvf', 'docs', 'plugins'];
+        for (const marker of bloatMarkers) {
+            if (fs.existsSync(path.join(dir, marker)))
+                return true;
+        }
+        const BLOAT_BYTES_THRESHOLD = 1_048_576; // 1 MB — a canonical SKILL.md is ~2KB
+        let bytes = 0;
+        const walk = (p) => {
+            const entries = fs.readdirSync(p, { withFileTypes: true });
+            for (const entry of entries) {
+                const child = path.join(p, entry.name);
+                if (entry.isDirectory()) {
+                    walk(child);
+                }
+                else if (entry.isFile()) {
+                    try {
+                        bytes += fs.statSync(child).size;
+                        if (bytes > BLOAT_BYTES_THRESHOLD)
+                            throw new Error('__bloat_threshold__');
+                    }
+                    catch (err) {
+                        if (err instanceof Error && err.message === '__bloat_threshold__')
+                            throw err;
+                        // Ignore stat errors for individual files.
+                    }
+                }
+                if (bytes > BLOAT_BYTES_THRESHOLD)
+                    return;
+            }
+        };
+        try {
+            walk(dir);
+        }
+        catch (err) {
+            if (err instanceof Error && err.message === '__bloat_threshold__')
+                return true;
+            // Any other walk error → don't declare bloat.
+        }
+        return bytes > BLOAT_BYTES_THRESHOLD;
+    }
+    catch {
+        return false;
+    }
+}
 async function maybeInstallSkillsSh(ctx) {
     try {
         if (ctx.flags['no-skills-sh'] === true)
@@ -166,37 +301,52 @@ async function maybeInstallSkillsSh(ctx) {
             return;
         if (/^(1|true|on|yes)$/i.test(String(process.env.RUFLO_NO_SKILLS_SH || '')))
             return;
-        // Idempotency gate: if this project has already registered ruflo with
-        // skills.sh, don't re-clone the repo + re-fire a fresh install telemetry
-        // event on every `ruflo init --force` / `init upgrade` / etc. Each install
-        // pings skills.sh's leaderboard AND clones the whole ruvnet/ruflo repo
-        // (~50MB) — re-running per-init would silently inflate our own metrics
-        // (GitHub unique-cloners, skills.sh rank) and waste user bandwidth. This
-        // check makes the registration once-per-project, matching the intent.
-        const nodePath = await import('path');
-        const nodeFs = await import('fs');
-        const marker = nodePath.join(ctx.cwd, '.agents', 'skills', 'ruflo');
-        if (nodeFs.existsSync(marker)) {
+        const skillDir = path.join(ctx.cwd, '.agents', 'skills', 'ruflo');
+        const skillFile = path.join(skillDir, 'SKILL.md');
+        // Idempotency gate. Three cases:
+        //   1. Directory absent → materialize.
+        //   2. Directory present but "bloated" (Cargo.toml/crates/ or >1MB) →
+        //      previous `npx skills add` full-repo clone left junk behind
+        //      (#2777). Wipe and re-materialize so `rm -rf .agents/skills/ruflo`
+        //      + re-init is a valid recovery path.
+        //   3. Directory present and healthy (just our SKILL.md) → skip.
+        let mode = 'create';
+        if (fs.existsSync(skillDir)) {
+            if (isBloatedRufloSkillDir(skillDir)) {
+                mode = 'rewrite';
+            }
+            else {
+                mode = 'skip';
+            }
+        }
+        if (mode === 'skip') {
             output.writeln();
             output.writeln(output.dim('  skills.sh registration already present at .agents/skills/ruflo — skipping'));
             return;
         }
-        const npxCmd = process.platform === 'win32' ? 'npx.cmd' : 'npx';
-        if (!commandExists('npx'))
-            return;
         output.writeln();
-        output.printInfo('Registering the core `ruflo` skill with skills.sh (cross-agent catalog)…');
-        const { spawnSync } = await import('child_process');
-        const result = spawnSync(npxCmd, ['--yes', 'skills', 'add', 'ruvnet/ruflo', '--skill', 'ruflo', '--yes'], { cwd: ctx.cwd, stdio: 'pipe', timeout: 60_000, windowsHide: true, encoding: 'utf-8' });
-        if (result.status === 0) {
-            output.writeln(output.success('  ✓ ruflo registered via skills.sh — the platform skill is available to any agent in this project'));
+        if (mode === 'rewrite') {
+            output.printInfo('Cleaning up bloated .agents/skills/ruflo/ from a prior init (#2777) and re-materializing the single platform SKILL.md…');
+            try {
+                fs.rmSync(skillDir, { recursive: true, force: true });
+            }
+            catch (err) {
+                output.writeln(output.dim(`  Could not remove ${skillDir}: ${err instanceof Error ? err.message : String(err)}`));
+                return;
+            }
+        }
+        else {
+            output.printInfo('Registering the core `ruflo` skill for cross-agent discovery (.agents/skills/ruflo/SKILL.md)…');
+        }
+        try {
+            fs.mkdirSync(skillDir, { recursive: true });
+            fs.writeFileSync(skillFile, RUFLO_PLATFORM_SKILL_MD, 'utf-8');
+            output.writeln(output.success('  ✓ ruflo skill materialized at .agents/skills/ruflo/SKILL.md — available to any agent in this project'));
             output.writeln(output.dim('    Want all 267 plugin skills? npx skills add ruvnet/ruflo --all'));
             output.writeln(output.dim('    Opt out next time: --no-skills-sh or RUFLO_NO_SKILLS_SH=1'));
         }
-        else {
-            // Common non-fatal reasons: offline, npx cache miss, skills CLI version
-            // mismatch, unknown package. Log a soft note; users can retry manually.
-            output.writeln(output.dim('  skills.sh registration skipped (network or npx cache) — retry with: npx skills add ruvnet/ruflo --skill ruflo --yes'));
+        catch (err) {
+            output.writeln(output.dim(`  skills.sh registration skipped (write failed: ${err instanceof Error ? err.message : String(err)})`));
         }
     }
     catch {
@@ -583,6 +733,13 @@ const initAction = async (ctx) => {
             try {
                 output.writeln(output.dim(`  Model: ${embeddingModel}`));
                 output.writeln(output.dim('  Hyperbolic: Enabled (Poincaré ball)'));
+                // #2770: On Windows, `npx` ships as `npx.cmd`; execFileSync cannot spawn
+                // a .cmd file without going through cmd.exe. Enable shell on win32 so
+                // cmd.exe resolves the .cmd extension. POSIX keeps shell:false.
+                // NOTE: shell:true joins args by spaces and passes to cmd.exe — the args
+                // here are hard-coded flags + an npm package name pre-validated against
+                // /^[a-zA-Z0-9_-]+\/[a-zA-Z0-9._-]+$/, so no injection risk. If
+                // user-controlled args are ever added, escape them before spawn.
                 execFileInit('npx', [
                     '@claude-flow/cli@latest', 'embeddings', 'init',
                     '--model', embeddingModel,
@@ -591,6 +748,8 @@ const initAction = async (ctx) => {
                     stdio: 'pipe',
                     cwd: ctx.cwd,
                     timeout: 30000,
+                    shell: process.platform === 'win32',
+                    windowsHide: true,
                 });
                 output.writeln(output.success('  ✓ Embeddings initialized'));
                 output.writeln(output.dim('    Run "embeddings init --download" to download model'));
@@ -822,6 +981,13 @@ const wizardCommand = {
                     throw new Error(`Invalid embedding model name: ${embeddingModel}`);
                 }
                 try {
+                    // #2770: On Windows, `npx` ships as `npx.cmd`; execFileSync cannot spawn
+                    // a .cmd file without going through cmd.exe. Enable shell on win32 so
+                    // cmd.exe resolves the .cmd extension. POSIX keeps shell:false.
+                    // NOTE: shell:true joins args by spaces and passes to cmd.exe — the args
+                    // here are hard-coded flags + an npm package name pre-validated against
+                    // /^[a-zA-Z0-9_-]+\/[a-zA-Z0-9._-]+$/, so no injection risk. If
+                    // user-controlled args are ever added, escape them before spawn.
                     execFileSync('npx', [
                         '@claude-flow/cli@latest', 'embeddings', 'init',
                         '--model', embeddingModel,
@@ -830,6 +996,8 @@ const wizardCommand = {
                         stdio: 'pipe',
                         cwd: ctx.cwd,
                         timeout: 30000,
+                        shell: process.platform === 'win32',
+                        windowsHide: true,
                     });
                     output.writeln(output.success('  ✓ Embeddings configured'));
                     embeddingsInitialized = true;

package/dist/src/commands/memory.js

@@ -89,7 +89,18 @@ const storeCommand = {
         const ttl = ctx.flags.ttl;
         const tags = ctx.flags.tags ? ctx.flags.tags.split(',') : [];
         const asVector = ctx.flags.vector;
-        const upsert = ctx.flags.upsert;
+        // #2775: the parser's `applyDefaults` only materializes global-option
+        // defaults, not per-subcommand ones — so despite the `default: true`
+        // above, `ctx.flags.upsert` arrives as `undefined` unless the user
+        // passes `--upsert` explicitly. That is exactly the trap #2594 tried
+        // to close: `store → delete → store` and even plain `store → store`
+        // (against an active row) both fall through to the bridge's strict
+        // insert, and before #2775's ON-CONFLICT-DO-UPDATE-WHERE-status-
+        // 'deleted' fix, both dead-ended with the misleading #2735 guard.
+        // Materialize the declared default locally so it takes effect
+        // regardless of the parser gap: only an explicit `--no-upsert` (which
+        // arrives as `false`) turns it off.
+        const upsert = ctx.flags.upsert !== false;
         if (!key) {
             output.printError('Key is required. Use --key or -k');
             return { success: false, exitCode: 1 };

package/dist/src/commands/ruvector/backup.js

@@ -182,10 +182,10 @@ const backupSubcommand = {
                 tables = tablesFilter.split(',').map(t => t.trim());
             }
             else {
-                const tablesResult = await client.query(`
-          SELECT table_name FROM information_schema.tables
-          WHERE table_schema = $1 AND table_type = 'BASE TABLE'
-          ORDER BY table_name
+                const tablesResult = await client.query(`
+          SELECT table_name FROM information_schema.tables
+          WHERE table_schema = $1 AND table_type = 'BASE TABLE'
+          ORDER BY table_name
         `, [config.schema]);
                 tables = tablesResult.rows.map(r => r.table_name);
             }
@@ -209,16 +209,16 @@ const backupSubcommand = {
                 spinner.setText(`Exporting ${tableName}...`);
                 spinner.start();
                 // Get columns
-                const columnsResult = await client.query(`
-          SELECT column_name, data_type
-          FROM information_schema.columns
-          WHERE table_schema = $1 AND table_name = $2
-          ORDER BY ordinal_position
+                const columnsResult = await client.query(`
+          SELECT column_name, data_type
+          FROM information_schema.columns
+          WHERE table_schema = $1 AND table_name = $2
+          ORDER BY ordinal_position
         `, [config.schema, tableName]);
                 const columns = columnsResult.rows.map(r => r.column_name);
                 // Get data
-                const dataResult = await client.query(`
-          SELECT * FROM ${config.schema}.${tableName}
+                const dataResult = await client.query(`
+          SELECT * FROM ${config.schema}.${tableName}
         `);
                 backupData.tables.push({
                     name: tableName,
@@ -233,14 +233,14 @@ const backupSubcommand = {
             if (includeIndexes) {
                 spinner.setText('Exporting index definitions...');
                 spinner.start();
-                const indexResult = await client.query(`
-          SELECT pg_get_indexdef(i.oid) as indexdef
-          FROM pg_index idx
-          JOIN pg_class i ON i.oid = idx.indexrelid
-          JOIN pg_class t ON t.oid = idx.indrelid
-          JOIN pg_namespace n ON n.oid = t.relnamespace
-          WHERE n.nspname = $1
-            AND NOT idx.indisprimary
+                const indexResult = await client.query(`
+          SELECT pg_get_indexdef(i.oid) as indexdef
+          FROM pg_index idx
+          JOIN pg_class i ON i.oid = idx.indexrelid
+          JOIN pg_class t ON t.oid = idx.indrelid
+          JOIN pg_namespace n ON n.oid = t.relnamespace
+          WHERE n.nspname = $1
+            AND NOT idx.indisprimary
         `, [config.schema]);
                 backupData.indexes = indexResult.rows.map(r => r.indexdef);
                 spinner.succeed(`Exported ${backupData.indexes.length} index definitions`);
@@ -566,10 +566,10 @@ const restoreSubcommand = {
                             return typeof val === 'object' ? JSON.stringify(val) : val;
                         });
                         try {
-                            await client.query(`
-                INSERT INTO ${config.schema}.${table.name} (${columns.join(', ')})
-                VALUES (${values.join(', ')})
-                ON CONFLICT DO NOTHING
+                            await client.query(`
+                INSERT INTO ${config.schema}.${table.name} (${columns.join(', ')})
+                VALUES (${values.join(', ')})
+                ON CONFLICT DO NOTHING
               `, params);
                             restoredRows++;
                         }

package/dist/src/commands/ruvector/benchmark.js

@@ -228,8 +228,8 @@ export const benchmarkCommand = {
             spinner.succeed('Connected to PostgreSQL');
             // Detect vector extension type: prefer ruvector, fall back to pgvector
             let vectorTypeName = 'vector';
-            const ruvectorCheck = await client.query(`
-        SELECT extname FROM pg_extension WHERE extname = 'ruvector'
+            const ruvectorCheck = await client.query(`
+        SELECT extname FROM pg_extension WHERE extname = 'ruvector'
       `);
             if (ruvectorCheck.rows.length > 0) {
                 vectorTypeName = 'ruvector';
@@ -238,12 +238,12 @@ export const benchmarkCommand = {
             const benchmarkTable = `${config.schema}.benchmark_${Date.now()}`;
             spinner.setText('Creating benchmark table...');
             spinner.start();
-            await client.query(`
-        CREATE TABLE ${benchmarkTable} (
-          id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
-          embedding ${vectorTypeName}(${dimensions}),
-          created_at TIMESTAMPTZ DEFAULT NOW()
-        )
+            await client.query(`
+        CREATE TABLE ${benchmarkTable} (
+          id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+          embedding ${vectorTypeName}(${dimensions}),
+          created_at TIMESTAMPTZ DEFAULT NOW()
+        )
       `);
             spinner.succeed('Benchmark table created');
             // Insert vectors
@@ -259,9 +259,9 @@ export const benchmarkCommand = {
                     const vector = generateRandomVector(dimensions);
                     batchVectors.push(`('[${vector.join(',')}]')`);
                 }
-                await client.query(`
-          INSERT INTO ${benchmarkTable} (embedding)
-          VALUES ${batchVectors.join(',')}
+                await client.query(`
+          INSERT INTO ${benchmarkTable} (embedding)
+          VALUES ${batchVectors.join(',')}
         `);
                 insertedCount = batchEnd;
                 spinner.setText(`Inserting vectors... ${insertedCount.toLocaleString()}/${numVectors.toLocaleString()}`);
@@ -283,21 +283,21 @@ export const benchmarkCommand = {
                 const metricOp = metric === 'cosine' ? `${opsPrefix}_cosine_ops` :
                     metric === 'l2' ? `${opsPrefix}_l2_ops` : `${opsPrefix}_ip_ops`;
                 if (indexType === 'hnsw') {
-                    await client.query(`
-            CREATE INDEX idx_benchmark_hnsw
-            ON ${benchmarkTable}
-            USING hnsw (embedding ${metricOp})
-            WITH (m = 16, ef_construction = 64)
+                    await client.query(`
+            CREATE INDEX idx_benchmark_hnsw
+            ON ${benchmarkTable}
+            USING hnsw (embedding ${metricOp})
+            WITH (m = 16, ef_construction = 64)
           `);
                 }
                 else if (indexType === 'ivfflat') {
                     // Need to train IVFFlat with existing data
                     const lists = Math.max(100, Math.floor(numVectors / 1000));
-                    await client.query(`
-            CREATE INDEX idx_benchmark_ivfflat
-            ON ${benchmarkTable}
-            USING ivfflat (embedding ${metricOp})
-            WITH (lists = ${lists})
+                    await client.query(`
+            CREATE INDEX idx_benchmark_ivfflat
+            ON ${benchmarkTable}
+            USING ivfflat (embedding ${metricOp})
+            WITH (lists = ${lists})
           `);
                 }
                 const indexDuration = Date.now() - indexStart;
@@ -320,11 +320,11 @@ export const benchmarkCommand = {
             for (let q = 0; q < numQueries; q++) {
                 const queryVector = generateRandomVector(dimensions);
                 const queryStart = Date.now();
-                await client.query(`
-          SELECT id, embedding ${distanceOp} '[${queryVector.join(',')}]' as distance
-          FROM ${benchmarkTable}
-          ORDER BY embedding ${distanceOp} '[${queryVector.join(',')}]'
-          LIMIT ${topK}
+                await client.query(`
+          SELECT id, embedding ${distanceOp} '[${queryVector.join(',')}]' as distance
+          FROM ${benchmarkTable}
+          ORDER BY embedding ${distanceOp} '[${queryVector.join(',')}]'
+          LIMIT ${topK}
         `);
                 queryLatencies.push(Date.now() - queryStart);
                 if (q % 10 === 0) {
@@ -354,11 +354,11 @@ export const benchmarkCommand = {
             // Get memory usage
             spinner.setText('Analyzing memory usage...');
             spinner.start();
-            const sizeResult = await client.query(`
-        SELECT
-          pg_relation_size('${benchmarkTable}') as table_size,
-          pg_total_relation_size('${benchmarkTable}') as total_size,
-          pg_indexes_size('${benchmarkTable}') as index_size
+            const sizeResult = await client.query(`
+        SELECT
+          pg_relation_size('${benchmarkTable}') as table_size,
+          pg_total_relation_size('${benchmarkTable}') as total_size,
+          pg_indexes_size('${benchmarkTable}') as index_size
       `);
             const tableSize = parseInt(sizeResult.rows[0].table_size, 10);
             const totalSize = parseInt(sizeResult.rows[0].total_size, 10);

package/dist/src/commands/ruvector/import.js

@@ -61,20 +61,20 @@ function generateInsertSQL(entry) {
     const updatedAt = entry.updated_at
         ? `'${escapeString(validateTimestamp(String(entry.updated_at)))}'::timestamptz`
         : 'NOW()';
-    return `INSERT INTO claude_flow.memory_entries (key, value, embedding, namespace, metadata, created_at, updated_at)
-VALUES (
-  '${key}',
-  '${value}',
-  ${embeddingClause},
-  '${namespace}',
-  '${metadata}'::jsonb,
-  ${createdAt},
-  ${updatedAt}
-)
-ON CONFLICT (key, namespace) DO UPDATE SET
-  value = EXCLUDED.value,
-  embedding = COALESCE(EXCLUDED.embedding, claude_flow.memory_entries.embedding),
-  metadata = EXCLUDED.metadata,
+    return `INSERT INTO claude_flow.memory_entries (key, value, embedding, namespace, metadata, created_at, updated_at)
+VALUES (
+  '${key}',
+  '${value}',
+  ${embeddingClause},
+  '${namespace}',
+  '${metadata}'::jsonb,
+  ${createdAt},
+  ${updatedAt}
+)
+ON CONFLICT (key, namespace) DO UPDATE SET
+  value = EXCLUDED.value,
+  embedding = COALESCE(EXCLUDED.embedding, claude_flow.memory_entries.embedding),
+  metadata = EXCLUDED.metadata,
   updated_at = NOW();`;
 }
 /**