aifastdb 3.7.6 → 3.8.6-mac.0

package/dist/social-graph.js

@@ -1,997 +0,0 @@
-"use strict";
-/**
- * SocialGraph - High-level TypeScript API for social network operations
- *
- * Provides a friendly API wrapper around the native Rust social graph implementation.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SocialGraph = void 0;
-/**
- * SocialGraph provides high-level APIs for social network operations.
- *
- * @example
- * ```typescript
- * const db = new AiFastDb({ path: './data', dimension: 768 });
- * const social = new SocialGraph(db);
- *
- * // Add persons
- * const alice = social.addPerson({ name: 'Alice' });
- * const bob = social.addPerson({ name: 'Bob' });
- *
- * // Create friendship
- * social.addFriend(alice.id, bob.id);
- *
- * // Find path between people
- * const path = social.findPath(alice.id, someoneElse.id);
- * ```
- */
-class SocialGraph {
-    constructor(db) {
-        // Access the native social graph through AiFastDb
-        this.native = db.socialGraph();
-    }
-    // ========================================================================
-    // Person Management
-    // ========================================================================
-    /**
-     * Add a new person to the social graph
-     */
-    addPerson(input) {
-        return this.native.addPerson(input);
-    }
-    /**
-     * Get a person by ID
-     */
-    getPerson(id) {
-        return this.native.getPerson(id) ?? null;
-    }
-    /**
-     * Update a person's information
-     */
-    updatePerson(id, updates) {
-        return this.native.updatePerson(id, updates) ?? null;
-    }
-    /**
-     * Delete a person from the social graph
-     */
-    deletePerson(id) {
-        return this.native.deletePerson(id);
-    }
-    /**
-     * List all persons with optional filter
-     */
-    listPersons(filter) {
-        return this.native.listPersons(filter);
-    }
-    // ========================================================================
-    // Friend Relationships
-    // ========================================================================
-    /**
-     * Add a friend relationship between two persons
-     */
-    addFriend(personA, personB, config) {
-        return this.native.addFriend(personA, personB, config) ?? null;
-    }
-    /**
-     * Remove a friend relationship
-     */
-    removeFriend(personA, personB) {
-        return this.native.removeFriend(personA, personB);
-    }
-    /**
-     * Get all friends of a person
-     */
-    getFriends(personId) {
-        return this.native.getFriends(personId);
-    }
-    /**
-     * Check if two persons are friends
-     */
-    areFriends(personA, personB) {
-        return this.native.areFriends(personA, personB);
-    }
-    /**
-     * List all relations with optional filter
-     *
-     * Returns all relation edges including friend relations, person-tag relations, etc.
-     * Each relation includes full metadata (relation_type, weight, bidirectional, metadata).
-     *
-     * @param filter - Optional filter criteria
-     * @returns Array of relations
-     *
-     * @example
-     * ```typescript
-     * // Get all relations
-     * const allRelations = social.listRelations();
-     *
-     * // Get only friend relations
-     * const friendRelations = social.listRelations({ relationType: 'friend' });
-     *
-     * // Get relations for a specific person
-     * const personRelations = social.listRelations({ sourceId: alice.id });
-     * ```
-     */
-    listRelations(filter) {
-        // Try native method first
-        if (typeof this.native.listRelations === 'function') {
-            return this.native.listRelations(filter);
-        }
-        // Fallback: reconstruct relations from API calls
-        // Note: This fallback has limitations - it may not capture all metadata
-        const relations = [];
-        const seenEdges = new Set();
-        const now = Date.now();
-        const persons = this.listPersons();
-        for (const person of persons) {
-            // Get friend relations
-            const friends = this.getFriends(person.id);
-            for (const friend of friends) {
-                // Create unique edge ID (sorted to avoid duplicates)
-                const edgeId = [person.id, friend.id].sort().join('-');
-                if (!seenEdges.has(edgeId)) {
-                    seenEdges.add(edgeId);
-                    relations.push({
-                        id: edgeId,
-                        source: person.id,
-                        target: friend.id,
-                        relation_type: 'friend', // Default - actual type not available in fallback
-                        weight: 1.0, // Default - actual weight not available in fallback
-                        bidirectional: true,
-                        metadata: {},
-                        created_at: now,
-                    });
-                }
-            }
-            // Get person-tag relations
-            const tags = this.getPersonTags(person.id);
-            for (const tag of tags) {
-                const edgeId = `${person.id}-tag-${tag.id}`;
-                if (!seenEdges.has(edgeId)) {
-                    seenEdges.add(edgeId);
-                    const props = tag.properties;
-                    const isCompany = props?.tagType === 'company' || props?.category === 'company';
-                    relations.push({
-                        id: edgeId,
-                        source: person.id,
-                        target: tag.id,
-                        relation_type: isCompany ? 'work_for' : 'tagged',
-                        weight: 1.0,
-                        bidirectional: false,
-                        metadata: { tagType: props?.tagType },
-                        created_at: now,
-                    });
-                }
-            }
-        }
-        // Apply filters
-        let results = relations;
-        if (filter) {
-            if (filter.relationType) {
-                results = results.filter(r => r.relation_type === filter.relationType);
-            }
-            if (filter.sourceId) {
-                results = results.filter(r => r.source === filter.sourceId || r.target === filter.sourceId);
-            }
-            if (filter.targetId) {
-                results = results.filter(r => r.target === filter.targetId || r.source === filter.targetId);
-            }
-            if (filter.limit && filter.limit > 0) {
-                results = results.slice(0, filter.limit);
-            }
-        }
-        return results;
-    }
-    /**
-     * Get a specific relation by ID
-     *
-     * @param relationId - The relation ID
-     * @returns The relation if found, null otherwise
-     */
-    getRelation(relationId) {
-        // Try native method first
-        if (typeof this.native.getRelation === 'function') {
-            return this.native.getRelation(relationId) ?? null;
-        }
-        // Fallback: search in listRelations
-        const relations = this.listRelations();
-        return relations.find(r => r.id === relationId) ?? null;
-    }
-    /**
-     * Get relation between two specific entities
-     *
-     * @param entityA - First entity ID
-     * @param entityB - Second entity ID
-     * @returns The relation if found, null otherwise
-     */
-    getRelationBetween(entityA, entityB) {
-        // Try native method first
-        if (typeof this.native.getRelationBetween === 'function') {
-            return this.native.getRelationBetween(entityA, entityB) ?? null;
-        }
-        // Fallback: search in listRelations
-        const relations = this.listRelations();
-        return relations.find(r => (r.source === entityA && r.target === entityB) ||
-            (r.source === entityB && r.target === entityA)) ?? null;
-    }
-    // ========================================================================
-    // Tag Management
-    // ========================================================================
-    /**
-     * Add a new tag
-     */
-    addTag(input) {
-        return this.native.addTag(input);
-    }
-    /**
-     * Tag a person (add person to a tag/organization)
-     */
-    tagPerson(personId, tagId) {
-        return this.native.tagPerson(personId, tagId) ?? null;
-    }
-    /**
-     * Remove tag from person
-     */
-    untagPerson(personId, tagId) {
-        return this.native.untagPerson(personId, tagId);
-    }
-    /**
-     * Get all tags of a person
-     */
-    getPersonTags(personId) {
-        return this.native.getPersonTags(personId);
-    }
-    /**
-     * Get all members of a tag
-     */
-    getTagMembers(tagId) {
-        return this.native.getTagMembers(tagId);
-    }
-    /**
-     * List all tags with optional filter
-     *
-     * Returns all tag entities (including company, organization, skill, interest types).
-     * Use the filter to narrow down results by tagType or name.
-     *
-     * @param filter - Optional filter criteria
-     * @returns Array of tag entities
-     *
-     * @example
-     * ```typescript
-     * // Get all tags
-     * const allTags = social.listTags();
-     *
-     * // Get only companies
-     * const companies = social.listTags({ tagType: 'company' });
-     *
-     * // Get tags with name containing 'tech'
-     * const techTags = social.listTags({ name: 'tech' });
-     * ```
-     */
-    listTags(filter) {
-        // Try native method first
-        if (typeof this.native.listTags === 'function') {
-            return this.native.listTags(filter);
-        }
-        // Fallback: collect tags from all persons (may miss orphan tags)
-        const tagMap = new Map();
-        const persons = this.listPersons();
-        for (const person of persons) {
-            const tags = this.getPersonTags(person.id);
-            for (const tag of tags) {
-                if (!tagMap.has(tag.id)) {
-                    tagMap.set(tag.id, tag);
-                }
-            }
-        }
-        let results = Array.from(tagMap.values());
-        // Apply filters
-        if (filter) {
-            if (filter.tagType) {
-                results = results.filter(t => {
-                    const props = t.properties;
-                    return props?.tagType === filter.tagType;
-                });
-            }
-            if (filter.name) {
-                const nameLower = filter.name.toLowerCase();
-                results = results.filter(t => t.name.toLowerCase().includes(nameLower));
-            }
-            if (filter.limit && filter.limit > 0) {
-                results = results.slice(0, filter.limit);
-            }
-        }
-        return results;
-    }
-    /**
-     * Get a tag by ID
-     */
-    getTag(tagId) {
-        // Try native method first
-        if (typeof this.native.getTag === 'function') {
-            return this.native.getTag(tagId) ?? null;
-        }
-        // Fallback: search in listTags
-        const tags = this.listTags();
-        return tags.find(t => t.id === tagId) ?? null;
-    }
-    // ========================================================================
-    // Item Management
-    // ========================================================================
-    /**
-     * Add a new item
-     */
-    addItem(input) {
-        return this.native.addItem(input);
-    }
-    /**
-     * Add item to person (ownership)
-     */
-    addItemToPerson(personId, itemId, relation) {
-        return this.native.addItemToPerson(personId, itemId, relation) ?? null;
-    }
-    /**
-     * Get all items owned by a person
-     */
-    getPersonItems(personId) {
-        return this.native.getPersonItems(personId);
-    }
-    /**
-     * Get all owners of an item
-     */
-    getItemOwners(itemId) {
-        return this.native.getItemOwners(itemId);
-    }
-    // ========================================================================
-    // Attribute Management
-    // ========================================================================
-    /**
-     * Add a new attribute
-     */
-    addAttribute(input) {
-        return this.native.addAttribute(input);
-    }
-    /**
-     * Find or create an attribute by category and value
-     */
-    findOrCreateAttribute(category, value) {
-        return this.native.findOrCreateAttribute(category, value);
-    }
-    /**
-     * Set a person's attribute
-     */
-    setPersonAttribute(personId, attrId, relation) {
-        return this.native.setPersonAttribute(personId, attrId, relation) ?? null;
-    }
-    /**
-     * Get all attributes of a person
-     */
-    getPersonAttributes(personId) {
-        return this.native.getPersonAttributes(personId);
-    }
-    /**
-     * Get all persons with a specific attribute
-     */
-    getPersonsByAttribute(attrId) {
-        return this.native.getPersonsByAttribute(attrId);
-    }
-    // ========================================================================
-    // Path Finding (Person-to-Person)
-    // ========================================================================
-    /**
-     * Find the shortest path between two persons
-     *
-     * @example
-     * ```typescript
-     * const path = social.findPath(alice.id, bob.id);
-     * if (path) {
-     *   console.log(`Found path with ${path.hops} hops`);
-     *   console.log('Intermediaries:', path.intermediaries.map(p => p.name));
-     * }
-     * ```
-     */
-    findPath(fromId, toId, options) {
-        return this.native.findPath(fromId, toId, options) ?? null;
-    }
-    /**
-     * Find all paths between two persons
-     */
-    findAllPaths(fromId, toId, maxHops, maxPaths) {
-        return this.native.findAllPaths(fromId, toId, maxHops, maxPaths);
-    }
-    /**
-     * Find all intermediaries who can introduce two persons
-     *
-     * @example
-     * ```typescript
-     * const intermediaries = social.findIntermediaries(alice.id, bob.id);
-     * console.log('Can be introduced via:', intermediaries.map(p => p.name));
-     * ```
-     */
-    findIntermediaries(personA, personB, maxHops) {
-        return this.native.findIntermediaries(personA, personB, maxHops);
-    }
-    // ========================================================================
-    // Network Analysis
-    // ========================================================================
-    /**
-     * Get N-degree contacts of a person
-     *
-     * @example
-     * ```typescript
-     * const contacts = social.getNthDegreeContacts(alice.id, 3);
-     * console.log('Direct friends:', contacts.degree1.length);
-     * console.log('Friends of friends:', contacts.degree2.length);
-     * console.log('3rd degree:', contacts.degree3.length);
-     * ```
-     */
-    getNthDegreeContacts(personId, maxDegree) {
-        return this.native.getNthDegreeContacts(personId, maxDegree);
-    }
-    /**
-     * Get mutual friends between two persons
-     */
-    getMutualFriends(personA, personB) {
-        return this.native.getMutualFriends(personA, personB);
-    }
-    /**
-     * Get mutual tags between two persons
-     */
-    getMutualTags(personA, personB) {
-        return this.native.getMutualTags(personA, personB);
-    }
-    /**
-     * Calculate relationship strength between two persons
-     */
-    getRelationshipStrength(personA, personB) {
-        return this.native.getRelationshipStrength(personA, personB);
-    }
-    /**
-     * Get connection suggestions for a person
-     *
-     * @example
-     * ```typescript
-     * const suggestions = social.suggestConnections(alice.id, {
-     *   maxResults: 10,
-     *   minScore: 0.3,
-     * });
-     *
-     * for (const s of suggestions) {
-     *   console.log(`Suggest: ${s.person.name} (score: ${s.score})`);
-     *   for (const reason of s.reasons) {
-     *     console.log(`  - ${reason.type}`);
-     *   }
-     * }
-     * ```
-     */
-    suggestConnections(personId, config) {
-        return this.native.suggestConnections(personId, config);
-    }
-    /**
-     * Get network statistics for a person
-     */
-    getNetworkStats(personId) {
-        return this.native.getNetworkStats(personId);
-    }
-    // ========================================================================
-    // Item Matching
-    // ========================================================================
-    /**
-     * Find shared items between two people
-     */
-    findSharedItems(personA, personB) {
-        return this.native.findSharedItems(personA, personB);
-    }
-    /**
-     * Find people who share items with a given person
-     *
-     * @example
-     * ```typescript
-     * const carFriends = social.findPeopleBySharedItems(alice.id, 'vehicle');
-     * for (const match of carFriends) {
-     *   console.log(`${match.person.name} shares ${match.sharedItems.length} items`);
-     * }
-     * ```
-     */
-    findPeopleBySharedItems(personId, category) {
-        return this.native.findPeopleBySharedItems(personId, category);
-    }
-    /**
-     * Find people who own items of a specific brand
-     */
-    findPeopleByBrand(brand, category) {
-        return this.native.findPeopleByBrand(brand, category);
-    }
-    /**
-     * Get popular items (most owned)
-     */
-    getPopularItems(category, limit) {
-        return this.native.getPopularItems(category, limit);
-    }
-    // ========================================================================
-    // Attribute Matching
-    // ========================================================================
-    /**
-     * Find shared attributes between two people
-     */
-    findSharedAttributes(personA, personB) {
-        return this.native.findSharedAttributes(personA, personB);
-    }
-    /**
-     * Find people who share attributes with a given person
-     */
-    findPeopleBySharedAttributes(personId, config) {
-        return this.native.findPeopleBySharedAttributes(personId, config);
-    }
-    /**
-     * Find alumni (people who went to the same school)
-     */
-    findAlumni(personId) {
-        return this.native.findAlumni(personId);
-    }
-    /**
-     * Find people in the same city
-     */
-    findSameCity(personId) {
-        return this.native.findSameCity(personId);
-    }
-    /**
-     * Find people with the same zodiac sign
-     */
-    findSameZodiac(personId) {
-        return this.native.findSameZodiac(personId);
-    }
-    /**
-     * Analyze compatibility between two people
-     *
-     * @example
-     * ```typescript
-     * const compat = social.analyzeCompatibility(alice.id, bob.id);
-     * console.log(`Compatibility: ${(compat.overallScore * 100).toFixed(0)}%`);
-     * console.log(compat.analysis);
-     * ```
-     */
-    analyzeCompatibility(personA, personB) {
-        return this.native.analyzeCompatibility(personA, personB);
-    }
-    /**
-     * Get popular attributes in a category
-     */
-    getPopularAttributes(category, limit) {
-        return this.native.getPopularAttributes(category, limit);
-    }
-    // ========================================================================
-    // Birthday Management
-    // ========================================================================
-    /**
-     * Set a person's birthday (solar calendar, YYYY-MM-DD format)
-     *
-     * @param personId - The person's ID
-     * @param birthday - Birthday in YYYY-MM-DD format (e.g., "1990-05-15")
-     * @returns true if set successfully, false if person not found or invalid format
-     *
-     * @example
-     * ```typescript
-     * social.setBirthday(alice.id, '1990-05-15');
-     * ```
-     */
-    setBirthday(personId, birthday) {
-        return this.native.setBirthday(personId, birthday);
-    }
-    /**
-     * Get a person's birthday
-     *
-     * @returns Birthday in YYYY-MM-DD format, or null if not set
-     */
-    getBirthday(personId) {
-        return this.native.getBirthday(personId) ?? null;
-    }
-    /**
-     * Remove a person's birthday
-     */
-    removeBirthday(personId) {
-        return this.native.removeBirthday(personId);
-    }
-    /**
-     * Find people with exact same birthday (same year-month-day)
-     *
-     * @param birthday - Birthday in YYYY-MM-DD format
-     *
-     * @example
-     * ```typescript
-     * const sameBirthday = social.findSameBirthdayExact('1990-05-15');
-     * // Returns people born on May 15, 1990
-     * ```
-     */
-    findSameBirthdayExact(birthday) {
-        return this.native.findSameBirthdayExact(birthday);
-    }
-    /**
-     * Find people with same month-day birthday (different years allowed)
-     *
-     * @param birthday - Birthday in YYYY-MM-DD or MM-DD format
-     *
-     * @example
-     * ```typescript
-     * const sameDayMonth = social.findSameBirthdayDayMonth('05-15');
-     * // Returns all people born on May 15 (any year)
-     * ```
-     */
-    findSameBirthdayDayMonth(birthday) {
-        return this.native.findSameBirthdayDayMonth(birthday);
-    }
-    /**
-     * Find people with same birthday as a given person (exact match)
-     *
-     * @example
-     * ```typescript
-     * const twins = social.findSameBirthdayAsPersonExact(alice.id);
-     * // Returns people born on the exact same date as Alice
-     * ```
-     */
-    findSameBirthdayAsPersonExact(personId) {
-        return this.native.findSameBirthdayAsPersonExact(personId);
-    }
-    /**
-     * Find people with same month-day birthday as a given person
-     *
-     * @example
-     * ```typescript
-     * const sameDayPeople = social.findSameBirthdayAsPerson(alice.id);
-     * // Returns people who share Alice's birthday month and day
-     * ```
-     */
-    findSameBirthdayAsPerson(personId) {
-        return this.native.findSameBirthdayAsPerson(personId);
-    }
-    /**
-     * Recommend birthday matches with priority: exact > same_day_month
-     *
-     * @example
-     * ```typescript
-     * const recommendations = social.recommendBirthdayMatches(alice.id, 10);
-     * for (const match of recommendations) {
-     *   console.log(`${match.person.name}: ${match.birthday} (${match.matchType})`);
-     * }
-     * ```
-     */
-    recommendBirthdayMatches(personId, limit) {
-        return this.native.recommendBirthdayMatches(personId, limit);
-    }
-    /**
-     * Find people with birthdays in the next N days
-     *
-     * @example
-     * ```typescript
-     * const upcoming = social.findUpcomingBirthdays(7);
-     * // Returns people with birthdays in the next 7 days
-     * ```
-     */
-    findUpcomingBirthdays(days) {
-        return this.native.findUpcomingBirthdays(days);
-    }
-    /**
-     * Find people with birthdays today
-     */
-    findTodayBirthdays() {
-        return this.native.findTodayBirthdays();
-    }
-    /**
-     * Find people with birthdays in a specific month
-     *
-     * @param month - Month number (1-12)
-     */
-    findBirthdaysInMonth(month) {
-        return this.native.findBirthdaysInMonth(month);
-    }
-    /**
-     * Get birthday statistics
-     *
-     * @example
-     * ```typescript
-     * const stats = social.getBirthdayStats();
-     * console.log(`Total: ${stats.totalWithBirthday}`);
-     * console.log('Most common dates:', stats.mostCommonDates);
-     * ```
-     */
-    getBirthdayStats() {
-        return this.native.getBirthdayStats();
-    }
-    /**
-     * Check if two people have the same birthday
-     *
-     * @param exact - If true, checks for same year-month-day. If false, same month-day only.
-     *
-     * @example
-     * ```typescript
-     * // Check if same year-month-day
-     * const exactSame = social.isSameBirthday(alice.id, bob.id, true);
-     *
-     * // Check if same month-day (different years allowed)
-     * const sameDayMonth = social.isSameBirthday(alice.id, bob.id, false);
-     * ```
-     */
-    isSameBirthday(personId1, personId2, exact) {
-        return this.native.isSameBirthday(personId1, personId2, exact);
-    }
-    /**
-     * Rebuild birthday index from all persons
-     *
-     * Call this after loading data to rebuild the in-memory index.
-     */
-    rebuildBirthdayIndex() {
-        this.native.rebuildBirthdayIndex();
-    }
-    // ========================================================================
-    // Graph Export (for visualization)
-    // ========================================================================
-    /**
-     * Export the entire social graph for visualization
-     *
-     * Returns nodes (persons, companies, tags) and edges (friend relations, person-tag relations)
-     * in a format suitable for vis-network or similar graph visualization libraries.
-     *
-     * @param options - Export options for filtering and limiting results
-     * @returns Exported graph data with nodes, edges, and statistics
-     *
-     * @example
-     * ```typescript
-     * const graph = social.exportGraph();
-     * console.log(`Nodes: ${graph.nodes.length}, Edges: ${graph.edges.length}`);
-     * console.log(`Stats:`, graph.stats);
-     *
-     * // With options
-     * const filteredGraph = social.exportGraph({
-     *   maxNodes: 100,
-     *   includeTags: true,
-     *   includeCompanies: true,
-     * });
-     * ```
-     */
-    exportGraph(options) {
-        // Try native method first (high-performance Rust implementation)
-        if (typeof this.native.exportGraph === 'function') {
-            const nativeOptions = options ? {
-                max_nodes: options.maxNodes,
-                max_edges: options.maxEdges,
-                include_tags: options.includeTags,
-                include_companies: options.includeCompanies,
-                include_edge_meta: options.includeEdgeMeta,
-                include_node_degree: options.includeNodeDegree,
-                relation_types: options.relationTypes,
-            } : undefined;
-            const result = this.native.exportGraph(nativeOptions);
-            // Transform from snake_case to camelCase if needed
-            return {
-                nodes: result.nodes.map((n) => ({
-                    id: n.id,
-                    label: n.label,
-                    group: n.group,
-                    title: n.title,
-                    degree: n.degree,
-                    data: n.data,
-                })),
-                edges: result.edges.map((e) => ({
-                    id: e.id,
-                    from: e.from,
-                    to: e.to,
-                    label: e.label,
-                    relationType: e.relation_type,
-                    weight: e.weight,
-                    data: e.data,
-                })),
-                stats: {
-                    persons: result.stats.persons,
-                    companies: result.stats.companies,
-                    tags: result.stats.tags,
-                    relations: result.stats.relations,
-                },
-            };
-        }
-        // Fallback: TypeScript implementation
-        const opts = {
-            maxNodes: options?.maxNodes ?? 500,
-            includeTags: options?.includeTags ?? true,
-            includeCompanies: options?.includeCompanies ?? true,
-            includeEdgeMeta: options?.includeEdgeMeta ?? true,
-            relationTypes: options?.relationTypes,
-        };
-        const nodes = [];
-        const edges = [];
-        const personIds = new Set();
-        const tagIds = new Set();
-        const edgeIds = new Set();
-        // Helper: determine if a tag is a company
-        const isCompanyTag = (tag) => {
-            const props = tag.properties;
-            return props?.tagType === 'company' || props?.category === 'company';
-        };
-        // Helper: get node group for a tag
-        const getTagGroup = (tag) => {
-            return isCompanyTag(tag) ? 'company' : 'tag';
-        };
-        // Helper: get edge label based on relation type
-        const getEdgeLabel = (relationType) => {
-            const labels = {
-                friend: '好友',
-                knows: '认识',
-                colleague: '同事',
-                classmate: '同学',
-                family: '家人',
-                mentor: '导师',
-                tagged: '标签',
-                work_for: '就职于',
-            };
-            return labels[relationType] || relationType;
-        };
-        let nodeCount = 0;
-        // 1. Get all persons and add person nodes
-        const persons = this.listPersons();
-        for (const person of persons) {
-            if (opts.maxNodes && nodeCount >= opts.maxNodes)
-                break;
-            const props = person.properties;
-            nodes.push({
-                id: person.id,
-                label: person.name,
-                group: 'person',
-                title: props?.description || person.name,
-                data: {
-                    type: 'person',
-                    name: person.name,
-                    avatar: props?.avatar,
-                    phone: props?.phone,
-                    email: props?.email,
-                    wechat: props?.wechat,
-                    position: props?.position,
-                    description: props?.description,
-                    ...props,
-                },
-            });
-            personIds.add(person.id);
-            nodeCount++;
-        }
-        // 2. Get all tags (using listTags to include orphan tags)
-        const allTags = this.listTags();
-        for (const tag of allTags) {
-            if (opts.maxNodes && nodeCount >= opts.maxNodes)
-                break;
-            const tagGroup = getTagGroup(tag);
-            // Check if we should include this tag type
-            if (tagGroup === 'company' && !opts.includeCompanies)
-                continue;
-            if (tagGroup === 'tag' && !opts.includeTags)
-                continue;
-            const props = tag.properties;
-            nodes.push({
-                id: tag.id,
-                label: tag.name,
-                group: tagGroup,
-                title: props?.description || tag.name,
-                data: {
-                    type: tagGroup,
-                    name: tag.name,
-                    tagType: props?.tagType,
-                    category: props?.category,
-                    color: props?.color,
-                    industry: props?.industry,
-                    description: props?.description,
-                    ...props,
-                },
-            });
-            tagIds.add(tag.id);
-            nodeCount++;
-        }
-        // 3. Get all relations (using listRelations to get full metadata)
-        const allRelations = this.listRelations();
-        for (const relation of allRelations) {
-            // Check relation type filter
-            if (opts.relationTypes && !opts.relationTypes.includes(relation.relation_type))
-                continue;
-            // Skip edges to/from nodes not in our node set
-            const sourceInNodes = personIds.has(relation.source) || tagIds.has(relation.source);
-            const targetInNodes = personIds.has(relation.target) || tagIds.has(relation.target);
-            if (!sourceInNodes || !targetInNodes)
-                continue;
-            // Skip duplicate edges (for bidirectional relations)
-            const edgeKey = [relation.source, relation.target].sort().join('-');
-            if (edgeIds.has(edgeKey))
-                continue;
-            edgeIds.add(edgeKey);
-            edges.push({
-                id: relation.id,
-                from: relation.source,
-                to: relation.target,
-                label: getEdgeLabel(relation.relation_type),
-                relationType: relation.relation_type,
-                weight: relation.weight,
-                data: opts.includeEdgeMeta ? {
-                    bidirectional: relation.bidirectional,
-                    ...relation.metadata,
-                } : undefined,
-            });
-        }
-        // 4. Calculate statistics
-        const companyCount = allTags.filter(isCompanyTag).length;
-        const tagCount = allTags.length - companyCount;
-        const stats = {
-            persons: persons.length,
-            companies: opts.includeCompanies ? companyCount : 0,
-            tags: opts.includeTags ? tagCount : 0,
-            relations: edges.length,
-        };
-        return { nodes, edges, stats };
-    }
-    // ========================================================================
-    // Persistence
-    // ========================================================================
-    /**
-     * Save changes to disk
-     */
-    save() {
-        this.native.save();
-    }
-    // ========================================================================
-    // Diagnostics
-    // ========================================================================
-    /**
-     * Diagnose WAL recovery and database state
-     *
-     * Returns diagnostic information about the database including:
-     * - Current entity/relation counts
-     * - Shard information
-     * - Recovery status
-     *
-     * @example
-     * ```typescript
-     * const diag = social.diagnose();
-     * console.log('Counts:', diag.counts);
-     * console.log('Message:', diag.message);
-     * ```
-     */
-    diagnose() {
-        if (typeof this.native.diagnose === 'function') {
-            return this.native.diagnose();
-        }
-        // Fallback for older versions
-        const persons = this.listPersons();
-        const tags = this.listTags();
-        const relations = this.listRelations();
-        return {
-            status: 'ok',
-            counts: {
-                persons: persons.length,
-                tags: tags.length,
-                relations: relations.length,
-            },
-            shards: { count: 0 },
-            message: `Fallback diagnose: ${persons.length} persons, ${tags.length} tags, ${relations.length} relations`,
-        };
-    }
-    /**
-     * Force re-recover from WAL files
-     *
-     * This can be used to reload data from WAL if the initial recovery failed.
-     *
-     * @example
-     * ```typescript
-     * const result = social.recover();
-     * if (result.success) {
-     *   console.log('Recovered:', result.counts);
-     * } else {
-     *   console.error('Recovery failed:', result.error);
-     * }
-     * ```
-     */
-    recover() {
-        if (typeof this.native.recover === 'function') {
-            return this.native.recover();
-        }
-        return {
-            success: false,
-            error: 'Native recover method not available',
-        };
-    }
-}
-exports.SocialGraph = SocialGraph;
-exports.default = SocialGraph;
-//# sourceMappingURL=social-graph.js.map