refactor: remove the weaver package and the chat-export import (P1.5)

Weaver consolidated and decayed frames of the legacy memory engine; mem0
updates and merges memories itself. The ChatGPT/Claude export import wrote
frames and its screen is hidden in v1 (ADR-0002).
This commit is contained in:
shumeiko.it
2026-10-24 12:01:22 +02:00
parent 101523e463
commit f4d2a62b24
17 changed files with 2 additions and 1718 deletions

View File

@@ -161,7 +161,5 @@ export {
SkillHashStore, computeSkillHash, SKILL_HASHES_TABLE_SQL,
type SkillHash,
} from './skill-hashes.js';
export { processImport, parseChatGPTExport, parseClaudeExport, extractKnowledge } from './memory-import.js';
export { createFileStore, LocalFileStore, LinkedDirStore, S3FileStore, isSensitiveFilePath, type FileStore, type FileEntry, type StorageInfo, type S3Config } from './file-store.js';
export { FileIndexer, MAX_CONTENT_BYTES, type FileIndexRow, type FileIndexResult } from './file-indexer.js';
export type { ImportSource, ImportResult, ExtractedKnowledge, ParsedConversation, ConversationMessage } from './memory-import.js';

View File

@@ -1,292 +0,0 @@
/**
* Memory Import — parse ChatGPT and Claude exports, extract knowledge.
*
* Flow: raw JSON → parse conversations → extract knowledge items → ImportResult
*/
export type ImportSource = 'chatgpt' | 'claude';
export interface ConversationMessage {
role: 'user' | 'assistant';
text: string;
timestamp?: string;
}
export interface ParsedConversation {
title: string;
messages: ConversationMessage[];
createdAt?: string;
source: ImportSource;
}
export interface ExtractedKnowledge {
type: 'decision' | 'fact' | 'preference' | 'topic';
content: string;
source: ImportSource;
conversationTitle: string;
importance: 'important' | 'normal';
}
export interface ImportResult {
source: ImportSource;
conversationsFound: number;
conversationsParsed: number;
knowledgeExtracted: ExtractedKnowledge[];
errors: string[];
}
// ── Raw export shapes (untrusted external JSON; all fields optional) ──
/** A ChatGPT export node carries an optional message in its `mapping` entry. */
interface ChatGPTMessage {
author?: { role?: string };
content?: { parts?: unknown[] };
create_time?: number;
}
interface ChatGPTNode {
message?: ChatGPTMessage;
}
interface ChatGPTConversation {
title?: string;
mapping?: Record<string, ChatGPTNode>;
create_time?: number;
}
interface ClaudeMessage {
sender?: string;
role?: string;
text?: string;
content?: string;
created_at?: string;
timestamp?: string;
}
interface ClaudeConversation {
name?: string;
title?: string;
chat_messages?: ClaudeMessage[];
messages?: ClaudeMessage[];
created_at?: string;
create_time?: string;
}
/** Pull the `conversations` array out of an export that may be the array itself. */
function extractConversations(json: unknown): unknown[] {
if (Array.isArray(json)) return json;
if (json && typeof json === 'object' && 'conversations' in json) {
const c = (json as { conversations?: unknown }).conversations;
if (Array.isArray(c)) return c;
}
return [];
}
// ── Parsers ───────────────────────────────────────
export function parseChatGPTExport(json: unknown): ParsedConversation[] {
const conversations = extractConversations(json);
return conversations.map((raw) => {
const conv = raw as ChatGPTConversation;
const title = conv.title || 'Untitled';
const messages: ConversationMessage[] = [];
// ChatGPT uses a mapping object with node IDs
if (conv.mapping && typeof conv.mapping === 'object') {
const nodes = Object.values(conv.mapping);
// Sort by create_time for chronological order
const sorted = nodes
.filter((n) => (n?.message?.content?.parts?.length ?? 0) > 0)
.sort((a, b) => (a.message?.create_time ?? 0) - (b.message?.create_time ?? 0));
for (const node of sorted) {
const msg = node.message;
if (!msg || !msg.author?.role) continue;
const role = msg.author.role === 'user' ? 'user' : 'assistant';
if (msg.author.role === 'system') continue; // Skip system messages
const text = (msg.content?.parts ?? [])
.filter((p): p is string => typeof p === 'string')
.join('\n')
.trim();
if (!text) continue;
messages.push({
role,
text,
timestamp: msg.create_time ? new Date(msg.create_time * 1000).toISOString() : undefined,
});
}
}
return {
title,
messages,
createdAt: conv.create_time ? new Date(conv.create_time * 1000).toISOString() : undefined,
source: 'chatgpt' as ImportSource,
};
}).filter(c => c.messages.length > 0);
}
export function parseClaudeExport(json: unknown): ParsedConversation[] {
const conversations = extractConversations(json);
return conversations.map((raw) => {
const conv = raw as ClaudeConversation;
const title = conv.name || conv.title || 'Untitled';
const messages: ConversationMessage[] = [];
const chatMessages = conv.chat_messages ?? conv.messages ?? [];
for (const msg of chatMessages) {
const role = (msg.sender === 'human' || msg.role === 'user') ? 'user' : 'assistant';
const text = (msg.text ?? msg.content ?? '').trim();
if (!text) continue;
messages.push({
role,
text,
timestamp: msg.created_at ?? msg.timestamp,
});
}
return {
title,
messages,
createdAt: conv.created_at ?? conv.create_time,
source: 'claude' as ImportSource,
};
}).filter(c => c.messages.length > 0);
}
// ── Knowledge Extraction ──────────────────────────
const DECISION_PATTERNS = [
/\b(?:decided|chose|going with|we'll use|confirmed|agreed|settled on|picked|selected)\b/i,
/\b(?:decision|choice):\s/i,
/\blet's go with\b/i,
];
const PREFERENCE_PATTERNS = [
/\b(?:I prefer|I like|I always|I never|I don't like|don't use|use .+ instead)\b/i,
/\b(?:my preference|I'd rather|please always|please never|from now on)\b/i,
/\b(?:my style is|I want you to|format it as)\b/i,
];
const FACT_PATTERNS = [
/\b(?:my name is|I work at|I'm a|I am a|my company|my team|my role|our product|our stack)\b/i,
/\b(?:we use|our tech|we're building|the project is|the codebase)\b/i,
];
export function extractKnowledge(conversations: ParsedConversation[]): ExtractedKnowledge[] {
const knowledge: ExtractedKnowledge[] = [];
const seen = new Set<string>(); // Deduplicate
for (const conv of conversations) {
// Extract conversation topic
if (conv.title && conv.title !== 'Untitled' && conv.title.length > 5) {
const topicKey = `topic:${conv.title.toLowerCase().trim()}`;
if (!seen.has(topicKey)) {
seen.add(topicKey);
knowledge.push({
type: 'topic',
content: `Conversation topic: ${conv.title}`,
source: conv.source,
conversationTitle: conv.title,
importance: 'normal',
});
}
}
// Scan user messages for decisions, preferences, facts
for (const msg of conv.messages) {
if (msg.role !== 'user') continue;
if (msg.text.length < 10 || msg.text.length > 500) continue; // Skip too short/long
const sentences = msg.text.split(/[.!?\n]+/).map(s => s.trim()).filter(s => s.length > 10);
for (const sentence of sentences) {
const contentKey = sentence.toLowerCase().slice(0, 80);
if (seen.has(contentKey)) continue;
// Check for decisions
if (DECISION_PATTERNS.some(p => p.test(sentence))) {
seen.add(contentKey);
knowledge.push({
type: 'decision',
content: `Decision: ${sentence}`,
source: conv.source,
conversationTitle: conv.title,
importance: 'important',
});
continue;
}
// Check for preferences
if (PREFERENCE_PATTERNS.some(p => p.test(sentence))) {
seen.add(contentKey);
knowledge.push({
type: 'preference',
content: `Preference: ${sentence}`,
source: conv.source,
conversationTitle: conv.title,
importance: 'important',
});
continue;
}
// Check for facts
if (FACT_PATTERNS.some(p => p.test(sentence))) {
seen.add(contentKey);
knowledge.push({
type: 'fact',
content: `${sentence}`,
source: conv.source,
conversationTitle: conv.title,
importance: 'normal',
});
continue;
}
}
}
}
// Cap at 100 items to avoid polluting memory
return knowledge.slice(0, 100);
}
// ── Main Import Function ──────────────────────────
export function processImport(jsonData: unknown, source: ImportSource): ImportResult {
const errors: string[] = [];
let conversations: ParsedConversation[];
try {
conversations = source === 'chatgpt'
? parseChatGPTExport(jsonData)
: parseClaudeExport(jsonData);
} catch (err: unknown) {
const message = err instanceof Error ? err.message : String(err);
return {
source,
conversationsFound: 0,
conversationsParsed: 0,
knowledgeExtracted: [],
errors: [`Parse error: ${message}`],
};
}
if (conversations.length === 0) {
errors.push('No conversations found in export');
}
const knowledge = extractKnowledge(conversations);
return {
source,
conversationsFound: conversations.length,
conversationsParsed: conversations.filter(c => c.messages.length > 0).length,
knowledgeExtracted: knowledge,
errors,
};
}

View File

@@ -1,340 +0,0 @@
import { describe, it, expect } from 'vitest';
import { parseChatGPTExport, parseClaudeExport, extractKnowledge, processImport } from '../src/memory-import';
describe('ChatGPT Export Parser', () => {
it('parses conversations with mapping structure', () => {
const data = [
{
title: 'Test Chat',
create_time: 1709000000,
mapping: {
'node1': {
message: {
author: { role: 'user' },
content: { parts: ['Hello, I need help with React'] },
create_time: 1709000001,
},
},
'node2': {
message: {
author: { role: 'assistant' },
content: { parts: ['Sure, I can help with React!'] },
create_time: 1709000002,
},
},
},
},
];
const result = parseChatGPTExport(data);
expect(result).toHaveLength(1);
expect(result[0].title).toBe('Test Chat');
expect(result[0].messages).toHaveLength(2);
expect(result[0].messages[0].role).toBe('user');
expect(result[0].messages[0].text).toBe('Hello, I need help with React');
expect(result[0].source).toBe('chatgpt');
});
it('skips system messages', () => {
const data = [
{
title: 'Test',
mapping: {
'sys': { message: { author: { role: 'system' }, content: { parts: ['System prompt'] } } },
'user': { message: { author: { role: 'user' }, content: { parts: ['Hi'] }, create_time: 1 } },
},
},
];
const result = parseChatGPTExport(data);
expect(result[0].messages).toHaveLength(1);
expect(result[0].messages[0].role).toBe('user');
});
it('handles empty/missing conversations gracefully', () => {
expect(parseChatGPTExport(null)).toEqual([]);
expect(parseChatGPTExport({})).toEqual([]);
expect(parseChatGPTExport([])).toEqual([]);
});
it('sorts messages chronologically by create_time', () => {
const data = [
{
title: 'Order Test',
mapping: {
'late': {
message: {
author: { role: 'user' },
content: { parts: ['Second message'] },
create_time: 200,
},
},
'early': {
message: {
author: { role: 'user' },
content: { parts: ['First message'] },
create_time: 100,
},
},
},
},
];
const result = parseChatGPTExport(data);
expect(result[0].messages[0].text).toBe('First message');
expect(result[0].messages[1].text).toBe('Second message');
});
it('filters out conversations with no messages', () => {
const data = [
{ title: 'Empty', mapping: {} },
{
title: 'Has Messages',
mapping: {
'n1': { message: { author: { role: 'user' }, content: { parts: ['Hello'] }, create_time: 1 } },
},
},
];
const result = parseChatGPTExport(data);
expect(result).toHaveLength(1);
expect(result[0].title).toBe('Has Messages');
});
it('handles wrapped format with conversations key', () => {
const data = {
conversations: [
{
title: 'Wrapped',
mapping: {
'n1': { message: { author: { role: 'user' }, content: { parts: ['Test'] }, create_time: 1 } },
},
},
],
};
const result = parseChatGPTExport(data);
expect(result).toHaveLength(1);
expect(result[0].title).toBe('Wrapped');
});
});
describe('Claude Export Parser', () => {
it('parses conversations with chat_messages', () => {
const data = [
{
name: 'Claude Chat',
created_at: '2024-03-01T10:00:00Z',
chat_messages: [
{ sender: 'human', text: 'What is TypeScript?', created_at: '2024-03-01T10:00:01Z' },
{ sender: 'assistant', text: 'TypeScript is a superset of JavaScript.', created_at: '2024-03-01T10:00:05Z' },
],
},
];
const result = parseClaudeExport(data);
expect(result).toHaveLength(1);
expect(result[0].title).toBe('Claude Chat');
expect(result[0].messages).toHaveLength(2);
expect(result[0].messages[0].role).toBe('user');
expect(result[0].source).toBe('claude');
});
it('handles empty exports gracefully', () => {
expect(parseClaudeExport(null)).toEqual([]);
expect(parseClaudeExport([])).toEqual([]);
});
it('handles alternative field names (title, messages, role, content)', () => {
const data = [
{
title: 'Alt Format',
messages: [
{ role: 'user', content: 'Hello from alt format', timestamp: '2024-03-01T10:00:00Z' },
],
},
];
const result = parseClaudeExport(data);
expect(result).toHaveLength(1);
expect(result[0].title).toBe('Alt Format');
expect(result[0].messages[0].text).toBe('Hello from alt format');
});
});
describe('Knowledge Extraction', () => {
it('extracts decisions from user messages', () => {
const convs = [{
title: 'Tech Discussion',
messages: [
{ role: 'user' as const, text: 'I decided to use React for the frontend and Node.js for the backend' },
{ role: 'assistant' as const, text: 'Great choice!' },
],
source: 'chatgpt' as const,
}];
const knowledge = extractKnowledge(convs);
const decisions = knowledge.filter(k => k.type === 'decision');
expect(decisions.length).toBeGreaterThan(0);
expect(decisions[0].content).toContain('decided');
expect(decisions[0].importance).toBe('important');
});
it('extracts preferences from user messages', () => {
const convs = [{
title: 'Preferences',
messages: [
{ role: 'user' as const, text: 'I prefer bullet-point summaries over long paragraphs' },
],
source: 'claude' as const,
}];
const knowledge = extractKnowledge(convs);
const prefs = knowledge.filter(k => k.type === 'preference');
expect(prefs.length).toBeGreaterThan(0);
expect(prefs[0].content).toContain('prefer');
expect(prefs[0].importance).toBe('important');
});
it('extracts facts about the user', () => {
const convs = [{
title: 'About me',
messages: [
{ role: 'user' as const, text: 'I work at Egzakta Advisory as a partner and consultant' },
],
source: 'chatgpt' as const,
}];
const knowledge = extractKnowledge(convs);
const facts = knowledge.filter(k => k.type === 'fact');
expect(facts.length).toBeGreaterThan(0);
expect(facts[0].content).toContain('Egzakta');
});
it('extracts conversation topics', () => {
const convs = [{
title: 'Building a SaaS Platform',
messages: [
{ role: 'user' as const, text: 'Help me plan the architecture' },
],
source: 'chatgpt' as const,
}];
const knowledge = extractKnowledge(convs);
const topics = knowledge.filter(k => k.type === 'topic');
expect(topics.length).toBeGreaterThan(0);
expect(topics[0].content).toContain('Building a SaaS Platform');
});
it('caps extraction at 100 items', () => {
const convs = Array.from({ length: 200 }, (_, i) => ({
title: `Conversation ${i}`,
messages: [
{ role: 'user' as const, text: `I decided to use approach ${i} for the implementation` },
],
source: 'chatgpt' as const,
}));
const knowledge = extractKnowledge(convs);
expect(knowledge.length).toBeLessThanOrEqual(100);
});
it('deduplicates similar content', () => {
const convs = [
{
title: 'Chat 1',
messages: [{ role: 'user' as const, text: 'I prefer TypeScript over JavaScript for type safety' }],
source: 'chatgpt' as const,
},
{
title: 'Chat 2',
messages: [{ role: 'user' as const, text: 'I prefer TypeScript over JavaScript for type safety' }],
source: 'chatgpt' as const,
},
];
const knowledge = extractKnowledge(convs);
const prefs = knowledge.filter(k => k.type === 'preference');
expect(prefs.length).toBe(1); // Deduped
});
it('skips very short and very long messages', () => {
const convs = [{
title: 'Test',
messages: [
{ role: 'user' as const, text: 'Hi' }, // Too short
{ role: 'user' as const, text: 'x'.repeat(600) }, // Too long
{ role: 'user' as const, text: 'I decided to use Python for data analysis tasks' }, // Just right
],
source: 'chatgpt' as const,
}];
const knowledge = extractKnowledge(convs);
const decisions = knowledge.filter(k => k.type === 'decision');
expect(decisions.length).toBe(1);
});
it('skips assistant messages', () => {
const convs = [{
title: 'Test',
messages: [
{ role: 'assistant' as const, text: 'I decided to use a different approach for this solution' },
],
source: 'chatgpt' as const,
}];
const knowledge = extractKnowledge(convs);
const decisions = knowledge.filter(k => k.type === 'decision');
expect(decisions.length).toBe(0);
});
});
describe('processImport (end-to-end)', () => {
it('processes a ChatGPT export end-to-end', () => {
const data = [
{
title: 'Project Planning',
create_time: 1709000000,
mapping: {
'n1': { message: { author: { role: 'user' }, content: { parts: ['I decided to use React with TypeScript for the frontend'] }, create_time: 1 } },
'n2': { message: { author: { role: 'assistant' }, content: { parts: ['Great choice!'] }, create_time: 2 } },
'n3': { message: { author: { role: 'user' }, content: { parts: ['I prefer concise responses without filler words'] }, create_time: 3 } },
},
},
];
const result = processImport(data, 'chatgpt');
expect(result.source).toBe('chatgpt');
expect(result.conversationsFound).toBe(1);
expect(result.conversationsParsed).toBe(1);
expect(result.knowledgeExtracted.length).toBeGreaterThan(0);
expect(result.errors).toHaveLength(0);
const decisions = result.knowledgeExtracted.filter(k => k.type === 'decision');
expect(decisions.length).toBeGreaterThan(0);
});
it('processes a Claude export end-to-end', () => {
const data = [
{
name: 'Architecture Discussion',
created_at: '2024-03-01T10:00:00Z',
chat_messages: [
{ sender: 'human', text: 'I work at Acme Corp as a senior engineer', created_at: '2024-03-01T10:00:01Z' },
{ sender: 'assistant', text: 'Nice to meet you!', created_at: '2024-03-01T10:00:05Z' },
],
},
];
const result = processImport(data, 'claude');
expect(result.source).toBe('claude');
expect(result.conversationsFound).toBe(1);
expect(result.knowledgeExtracted.length).toBeGreaterThan(0);
});
it('returns errors for invalid data', () => {
const result = processImport('not json', 'chatgpt');
expect(result.conversationsFound).toBe(0);
expect(result.knowledgeExtracted).toHaveLength(0);
});
it('reports when no conversations found', () => {
const result = processImport([], 'chatgpt');
expect(result.errors).toContain('No conversations found in export');
});
});