Skip to content

armgit / ruflo

Public Imported from GitHub
0

🌊 The original agent harness. Deploy intelligent multi-player swarms, coordinate autonomous workflows, and build conversational AI systems. Features adaptive memory, self-learning intelligence, federation, vector RAG integration, and native Claude Code / Codex / Hermes and many more Integrated

fix(memory): report rejected JSON import writes accurately

Rudy Celekli43fc2a877900
diff --git a/v3/@claude-flow/cli/__tests__/memory-import-write-results.test.ts b/v3/@claude-flow/cli/__tests__/memory-import-write-results.test.ts
new file mode 100644
index 0000000000..2197b75f4b
--- /dev/null
+++ b/v3/@claude-flow/cli/__tests__/memory-import-write-results.test.ts
@@ -0,0 +1,47 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+const layer = vi.hoisted(() => ({ storeEntry: vi.fn() }));
+vi.mock('../src/memory/memory-initializer.js', () => ({
+ storeEntry: layer.storeEntry,
+ searchEntries: vi.fn(), listEntries: vi.fn(), getEntry: vi.fn(), deleteEntry: vi.fn(),
+ initializeMemoryDatabase: vi.fn(),
+ checkMemoryInitialization: vi.fn(async () => ({ initialized: true })),
+}));
+const { memoryTools } = await import('../src/mcp-tools/memory-tools.js');
+const importer = memoryTools.find(t => t.name === 'memory_import')!;
+let dir: string;
+beforeEach(() => {
+ dir = mkdtempSync(join(tmpdir(), 'ruflo-import-result-'));
+ layer.storeEntry.mockReset().mockResolvedValue({ success: true, id: 'saved' });
+});
+afterEach(() => rmSync(dir, { recursive: true, force: true }));
+function file() {
+ const inputPath = join(dir, 'export.json');
+ writeFileSync(inputPath, JSON.stringify({ schema: 'ruflo-memory-export/v1', entries: [
+ { key: 'first', namespace: 'notes', value: 'first value' },
+ { key: 'second', namespace: 'notes', value: 'second value' },
+ ] }));
+ return inputPath;
+}
+describe('JSON memory import write acknowledgments', () => {
+ it.each(['resolved failure', 'thrown failure'])('reports %s without counting a rejected write as imported', async mode => {
+ if (mode === 'resolved failure') layer.storeEntry.mockResolvedValueOnce({ success: false, id: '', error: 'database write refused' });
+ else layer.storeEntry.mockRejectedValueOnce(new Error('database write refused'));
+ const result = await importer.handler({ inputPath: file() });
+ expect(result).toMatchObject({ success: false, imported: { entries: 1 }, failed: 1 });
+ expect(JSON.stringify(result)).toContain('database write refused');
+ expect(layer.storeEntry).toHaveBeenCalledTimes(2);
+ });
+ it('reports all rejected writes as failures, not a completed import', async () => {
+ layer.storeEntry.mockResolvedValue({ success: false, error: 'conflict' });
+ expect(await importer.handler({ inputPath: file(), merge: false }))
+ .toMatchObject({ success: false, imported: { entries: 0 }, failed: 2 });
+ expect(layer.storeEntry.mock.calls.every(([options]) => options.upsert === false)).toBe(true);
+ });
+ it('counts acknowledged writes normally', async () => {
+ expect(await importer.handler({ inputPath: file() }))
+ .toMatchObject({ success: true, imported: { entries: 2 }, failed: 0 });
+ });
+});
diff --git a/v3/@claude-flow/cli/src/mcp-tools/memory-tools.ts b/v3/@claude-flow/cli/src/mcp-tools/memory-tools.ts
index 5e4e34bffd..467338dc37 100644
--- a/v3/@claude-flow/cli/src/mcp-tools/memory-tools.ts
+++ b/v3/@claude-flow/cli/src/mcp-tools/memory-tools.ts
@@ -1611,17 +1611,24 @@ export const memoryTools: MCPTool[] = [
const entries = Array.isArray(doc.entries) ? doc.entries : [];
const nsOverride = input.namespace ? String(input.namespace) : undefined;
if (nsOverride) { const v = validateIdentifier(nsOverride, 'namespace'); if (!v.valid) throw new Error(v.error); }
- let imported = 0; let skipped = 0;
+ let imported = 0; let skipped = 0; let failed = 0;
+ const errors: string[] = [];
for (const e of entries) {
if (!e || typeof e.key !== 'string') { skipped++; continue; }
const value = typeof e.value === 'string' ? e.value : JSON.stringify(e.value ?? null);
try {
const result = await storeEntry({ key: e.key, value, namespace: nsOverride ?? e.namespace ?? 'default', upsert: input.merge !== false, dbPath });
- if (result.success) imported++;
- else skipped++;
- } catch { skipped++; }
+ if (!result.success) throw new Error(result.error || 'Memory write was rejected');
+ imported++;
+ } catch (error) {
+ failed++;
+ if (errors.length < 10) errors.push(`${e.key}: ${error instanceof Error ? error.message : String(error)}`);
+ }
}
return {
+ success: failed === 0,
+ error: failed > 0 ? `${failed} memory write(s) failed: ${errors.join('; ')}` : undefined,
+ failed,
inputPath,
imported: { entries: imported, vectors: 0, patterns: 0 },
skipped,