@jotx-labs/core 2.4.82 → 2.4.183

package/README.md

@@ -1,4 +1,4 @@
-# @jotx/core
+# @jotx-labs/core
 
 Platform-agnostic core package for jotx note parsing and serialization.
 
@@ -12,7 +12,7 @@ npm test
 ## Usage
 
 ```typescript
-import { Tokenizer } from '@jotx/core';
+import { Tokenizer } from '@jotx-labs/core';
 
 const tokenizer = new Tokenizer('hdef page MyNote');
 const tokens = tokenizer.tokenize();

package/dist/NodeManager.d.ts

@@ -0,0 +1,140 @@
+/**
+ * NodeManager - Platform-agnostic node registry and graph management
+ * Shared implementation for VS Code and web applications
+ /**
+ * INDEXED BLOCK TYPES:
+ * - jotx: The document node (parent of all blocks in a file)
+ *
+ * Visualization & Data:
+ * - table: Rich data tables with title
+ * - mermaid: Mermaid diagrams with title
+ * - chart: Chart.js visualizations with title
+ * - math: LaTeX equations with title
+ * - properties: Property tables with title
+ *
+ * Navigational (for knowledge graph):
+ * - jotxlink: Reference links (can link to blocks + documents)
+ * - link: Hyperlinks (document-level)
+ * - button: Navigation buttons (document-level)
+ * - card: Dashboard cards (document-level)
+ */
+import type { NodeEntry, DefTreeNode } from './types/nodeManager';
+/**
+ * Block types that are indexed by NodeManager for graph visualization.
+ */
+export declare const INDEXED_BLOCK_TYPES: readonly ["table", "mermaid", "chart", "math", "properties", "jotxlink", "link", "button", "card"];
+export type IndexedBlockType = typeof INDEXED_BLOCK_TYPES[number];
+/**
+ * Edge representing a link between two nodes
+ */
+export interface NodeEdge {
+    sourceId: string;
+    targetId: string;
+    type: 'jotxlink' | 'link' | 'button' | 'card' | 'parent-child';
+    metadata?: {
+        label?: string;
+        style?: string;
+        icon?: string;
+        color?: string;
+    };
+}
+/**
+ * Options for NodeManager initialization
+ */
+export interface NodeManagerOptions {
+    /** Optional error handler */
+    onError?: (message: string, error: any) => void;
+    /** Optional logger */
+    log?: (message: string) => void;
+}
+/**
+ * Base NodeManager with shared logic across platforms
+ */
+export declare class NodeManager {
+    protected nodeRegistry: Map<string, NodeEntry>;
+    protected fileNodeIndex: Map<string, Set<string>>;
+    protected typeIndex: Map<string, Set<string>>;
+    protected defHierarchy: Map<string, DefTreeNode>;
+    protected linkGraph: Map<string, Set<string>>;
+    protected options: NodeManagerOptions;
+    constructor(options?: NodeManagerOptions);
+    /**
+     * Extract nodes from AST - ONLY indexes document (jotx) and INDEXED_BLOCK_TYPES
+     */
+    protected extractNodes(ast: any, filePath: string, fileName: string): void;
+    /**
+     * Extract ONLY the indexed block types
+     */
+    protected extractBlockNodes(blocks: any[], filePath: string, fileNodes: Set<string>, parentId: string): void;
+    /**
+     * Check if block type should be indexed
+     */
+    protected isIndexedBlockType(type: string): boolean;
+    /**
+     * Extract content preview from block
+     */
+    protected extractBlockContent(block: any): string | undefined;
+    /**
+     * Process JotxLink block - can reference documents OR blocks
+     */
+    protected processJotxLink(sourceId: string, properties: any): void;
+    /**
+     * Process link block - document references only
+     */
+    protected processLink(sourceId: string, properties: any): void;
+    /**
+     * Process button - navigation links
+     */
+    protected processButton(sourceId: string, properties: any): void;
+    /**
+     * Process card - dashboard cards from gridcard
+     */
+    protected processCard(sourceId: string, properties: any): void;
+    /**
+     * Helper: Extract document ID from file path
+     */
+    protected extractDocumentId(filePath: string): string;
+    /**
+     * Add edge to linkGraph
+     */
+    protected addEdge(edge: NodeEdge): void;
+    /**
+     * Add node to registry and indices
+     */
+    protected addNode(node: NodeEntry, fileNodes: Set<string>): void;
+    /**
+     * Build def tree for a document
+     */
+    protected buildDefTree(ast: any, filePath: string): void;
+    /**
+     * Remove all nodes from a file
+     */
+    protected removeFileNodes(filePath: string): void;
+    getNode(id: string): NodeEntry | undefined;
+    getNodeByShortId(shortId: string): NodeEntry | undefined;
+    getNodesByFile(filePath: string): NodeEntry[];
+    getNodesByType(type: string): NodeEntry[];
+    getAllNodes(): NodeEntry[];
+    getAllDocuments(): NodeEntry[];
+    getAllBlocks(): NodeEntry[];
+    /**
+     * Get all edges for graph visualization (all link types)
+     */
+    getAllEdges(): NodeEdge[];
+    /**
+     * Legacy method for backward compatibility
+     * @deprecated Use getAllEdges() instead
+     */
+    getJotxLinkEdges(): NodeEdge[];
+    getLinkedNodes(nodeId: string): NodeEntry[];
+    getBacklinks(nodeId: string): NodeEntry[];
+    getDefTree(filePath: string): DefTreeNode | undefined;
+    validateUniqueIds(): Map<string, string[]>;
+    clear(): void;
+    getStats(): {
+        documents: number;
+        blocks: number;
+        edges: number;
+    };
+}
+//# sourceMappingURL=NodeManager.d.ts.map

package/dist/NodeManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NodeManager.d.ts","sourceRoot":"","sources":["../src/NodeManager.ts"],"names":[],"mappings":"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"}

package/dist/NodeManager.js

@@ -0,0 +1,521 @@
+"use strict";
+/**
+ * NodeManager - Platform-agnostic node registry and graph management
+ * Shared implementation for VS Code and web applications
+ /**
+ * INDEXED BLOCK TYPES:
+ * - jotx: The document node (parent of all blocks in a file)
+ *
+ * Visualization & Data:
+ * - table: Rich data tables with title
+ * - mermaid: Mermaid diagrams with title
+ * - chart: Chart.js visualizations with title
+ * - math: LaTeX equations with title
+ * - properties: Property tables with title
+ *
+ * Navigational (for knowledge graph):
+ * - jotxlink: Reference links (can link to blocks + documents)
+ * - link: Hyperlinks (document-level)
+ * - button: Navigation buttons (document-level)
+ * - card: Dashboard cards (document-level)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodeManager = exports.INDEXED_BLOCK_TYPES = void 0;
+/**
+ * Block types that are indexed by NodeManager for graph visualization.
+ */
+exports.INDEXED_BLOCK_TYPES = [
+    // Visualization & Data
+    'table',
+    'mermaid',
+    'chart',
+    'math',
+    'properties',
+    // Navigational (for knowledge graph)
+    'jotxlink',
+    'link',
+    'button',
+    'card'
+];
+/**
+ * Base NodeManager with shared logic across platforms
+ */
+class NodeManager {
+    constructor(options = {}) {
+        // Fast O(1) lookups
+        this.nodeRegistry = new Map();
+        this.fileNodeIndex = new Map();
+        this.typeIndex = new Map();
+        this.defHierarchy = new Map();
+        this.linkGraph = new Map();
+        this.options = {
+            onError: options.onError || ((msg, err) => console.error(msg, err)),
+            log: options.log || (() => { })
+        };
+    }
+    /**
+     * Extract nodes from AST - ONLY indexes document (jotx) and INDEXED_BLOCK_TYPES
+     */
+    extractNodes(ast, filePath, fileName) {
+        const fileNodes = new Set();
+        // 1. Add document node (jotx - the parent node)
+        const docTitle = ast.document.metadata?.title || fileName;
+        const docId = ast.document.id || fileName;
+        const docType = ast.document.type || 'jotx';
+        const docMetadataType = ast.document.metadata?.type || undefined;
+        const docNode = {
+            id: docId,
+            type: 'jotx',
+            filePath,
+            label: docTitle,
+            properties: {
+                ...ast.document.metadata,
+                documentType: docMetadataType
+            },
+            content: docTitle,
+            parentId: undefined,
+            children: []
+        };
+        this.addNode(docNode, fileNodes);
+        // 2. Extract indexed block nodes
+        this.extractBlockNodes(ast.document.blocks || [], filePath, fileNodes, docId);
+        // Update file index
+        this.fileNodeIndex.set(filePath, fileNodes);
+    }
+    /**
+     * Extract ONLY the indexed block types
+     */
+    extractBlockNodes(blocks, filePath, fileNodes, parentId) {
+        if (!blocks)
+            return;
+        for (const block of blocks) {
+            const blockType = block.type;
+            // FILTER: Only index specified block types
+            if (!this.isIndexedBlockType(blockType)) {
+                // Check children of non-indexed blocks
+                if (block.children) {
+                    this.extractBlockNodes(block.children, filePath, fileNodes, parentId);
+                }
+                continue;
+            }
+            const nodeId = `${parentId}#${block.id}`;
+            // Determine label based on block type
+            let label = block.properties?.title || block.id;
+            if (blockType === 'jotxlink') {
+                label = 'JotxLink';
+            }
+            // Create node entry with ALL properties and children preserved
+            const node = {
+                id: nodeId,
+                type: blockType,
+                filePath,
+                label,
+                properties: { ...block.properties },
+                content: this.extractBlockContent(block),
+                parentId,
+                children: [],
+                // Preserve original AST children for content rendering (tables, callouts, etc.)
+                astChildren: block.children || undefined
+            };
+            this.addNode(node, fileNodes);
+            // Update parent children
+            const parent = this.nodeRegistry.get(parentId);
+            if (parent) {
+                parent.children.push(nodeId);
+            }
+            // Process links: populate linkGraph based on block type
+            if (blockType === 'jotxlink') {
+                this.processJotxLink(nodeId, block.properties);
+            }
+            else if (blockType === 'link') {
+                this.processLink(nodeId, block.properties);
+            }
+            else if (blockType === 'button') {
+                this.processButton(nodeId, block.properties);
+            }
+            else if (blockType === 'card') {
+                this.processCard(nodeId, block.properties);
+            }
+        }
+    }
+    /**
+     * Check if block type should be indexed
+     */
+    isIndexedBlockType(type) {
+        return exports.INDEXED_BLOCK_TYPES.includes(type);
+    }
+    /**
+     * Extract content preview from block
+     */
+    extractBlockContent(block) {
+        const props = block.properties || {};
+        if (props.text)
+            return props.text;
+        if (props.src)
+            return props.src;
+        if (props.json)
+            return typeof props.json === 'string' ? props.json : JSON.stringify(props.json);
+        if (props.title)
+            return props.title;
+        return undefined;
+    }
+    /**
+     * Process JotxLink block - can reference documents OR blocks
+     */
+    processJotxLink(sourceId, properties) {
+        const refId = properties?.refid || properties?.refId;
+        if (!refId)
+            return;
+        this.addEdge({
+            sourceId,
+            targetId: refId,
+            type: 'jotxlink',
+            metadata: { label: properties?.title }
+        });
+    }
+    /**
+     * Process link block - document references only
+     */
+    processLink(sourceId, properties) {
+        const url = properties?.url || properties?.href;
+        if (!url)
+            return;
+        // Only track internal .jot file links
+        if (url.endsWith('.jot') || url.endsWith('.jotx')) {
+            this.addEdge({
+                sourceId,
+                targetId: this.extractDocumentId(url),
+                type: 'link',
+                metadata: { label: properties?.text }
+            });
+        }
+    }
+    /**
+     * Process button - navigation links
+     */
+    processButton(sourceId, properties) {
+        const link = properties?.link;
+        if (!link || !(link.endsWith('.jot') || link.endsWith('.jotx')))
+            return;
+        this.addEdge({
+            sourceId,
+            targetId: this.extractDocumentId(link),
+            type: 'button',
+            metadata: {
+                label: properties?.label,
+                style: properties?.style
+            }
+        });
+    }
+    /**
+     * Process card - dashboard cards from gridcard
+     */
+    processCard(sourceId, properties) {
+        const link = properties?.link;
+        if (!link || !(link.endsWith('.jot') || link.endsWith('.jotx')))
+            return;
+        this.addEdge({
+            sourceId,
+            targetId: this.extractDocumentId(link),
+            type: 'card',
+            metadata: {
+                label: properties?.title,
+                icon: properties?.icon,
+                color: properties?.color
+            }
+        });
+    }
+    /**
+     * Helper: Extract document ID from file path
+     */
+    extractDocumentId(filePath) {
+        // "./docs/example.jot" → "example"
+        // "../other.jot" → "other"
+        // "folder/file.jot" → "file"
+        const fileName = filePath.split('/').pop();
+        return fileName?.replace(/\.(jot|jotx)$/, '') || filePath;
+    }
+    /**
+     * Add edge to linkGraph
+     */
+    addEdge(edge) {
+        const key = `${edge.sourceId}:${edge.targetId}:${edge.type}`;
+        if (!this.linkGraph.has(edge.sourceId)) {
+            this.linkGraph.set(edge.sourceId, new Set());
+        }
+        // Store target ID (we'll reconstruct edges with metadata when needed)
+        this.linkGraph.get(edge.sourceId).add(edge.targetId);
+        this.options.log?.(`[NodeManager] ${edge.type}: ${edge.sourceId} -> ${edge.targetId}`);
+    }
+    /**
+     * Add node to registry and indices
+     */
+    addNode(node, fileNodes) {
+        this.nodeRegistry.set(node.id, node);
+        fileNodes.add(node.id);
+        // Add to type index
+        if (!this.typeIndex.has(node.type)) {
+            this.typeIndex.set(node.type, new Set());
+        }
+        this.typeIndex.get(node.type).add(node.id);
+    }
+    /**
+     * Build def tree for a document
+     */
+    buildDefTree(ast, filePath) {
+        const buildTree = (blocks, parentId) => {
+            const children = [];
+            for (const block of blocks) {
+                if (this.isIndexedBlockType(block.type)) {
+                    const nodeId = `${filePath}#${block.id}`;
+                    const defNode = {
+                        nodeId,
+                        children: block.children ? buildTree(block.children, nodeId) : []
+                    };
+                    children.push(defNode);
+                }
+                else if (block.children) {
+                    // Continue searching in nested blocks
+                    children.push(...buildTree(block.children, parentId));
+                }
+            }
+            return children;
+        };
+        const tree = {
+            nodeId: filePath,
+            children: buildTree(ast.document.blocks, filePath)
+        };
+        this.defHierarchy.set(filePath, tree);
+    }
+    /**
+     * Remove all nodes from a file
+     */
+    removeFileNodes(filePath) {
+        const nodeIds = this.fileNodeIndex.get(filePath);
+        if (!nodeIds)
+            return;
+        for (const nodeId of nodeIds) {
+            const node = this.nodeRegistry.get(nodeId);
+            if (node) {
+                // Remove from type index
+                this.typeIndex.get(node.type)?.delete(nodeId);
+            }
+            // Remove from registry
+            this.nodeRegistry.delete(nodeId);
+            // Remove from linkGraph (as source)
+            this.linkGraph.delete(nodeId);
+        }
+        // Remove file index
+        this.fileNodeIndex.delete(filePath);
+        this.defHierarchy.delete(filePath);
+    }
+    // ========== Public API ==========
+    getNode(id) {
+        this.options.log?.(`[NodeManager] getNode called with: "${id}", registry size: ${this.nodeRegistry.size}`);
+        // First try direct lookup
+        let node = this.nodeRegistry.get(id);
+        if (node) {
+            this.options.log?.(`[NodeManager] getNode DIRECT HIT: ${id}`);
+            return node;
+        }
+        this.options.log?.(`[NodeManager] getNode direct lookup MISS for: "${id}"`);
+        // If ID contains #, try parsing as documentId#blockId
+        if (id.includes('#')) {
+            const [docPart, blockPart] = id.split('#');
+            this.options.log?.(`[NodeManager] getNode parsing: docPart="${docPart}", blockPart="${blockPart}"`);
+            // Search for nodes where the ID ends with #blockPart
+            for (const [nodeId, nodeEntry] of this.nodeRegistry) {
+                if (nodeId.endsWith(`#${blockPart}`)) {
+                    this.options.log?.(`[NodeManager] getNode found via blockPart match: ${nodeId}`);
+                    return nodeEntry;
+                }
+            }
+            this.options.log?.(`[NodeManager] getNode no blockPart match found for #${blockPart}`);
+        }
+        this.options.log?.(`[NodeManager] getNode returning undefined for: "${id}"`);
+        return undefined;
+    }
+    getNodeByShortId(shortId) {
+        this.options.log?.(`[NodeManager] getNodeByShortId called with: "${shortId}"`);
+        // First try direct lookup
+        const direct = this.nodeRegistry.get(shortId);
+        if (direct) {
+            this.options.log?.(`[NodeManager] Direct match found`);
+            return direct;
+        }
+        // Try looking up by filePath (for document nodes)
+        if (shortId.endsWith('.jot') || shortId.endsWith('.jotx')) {
+            for (const [nodeId, node] of this.nodeRegistry) {
+                if (node.filePath === shortId && node.type === 'jotx') {
+                    this.options.log?.(`[NodeManager] Found document by filePath: ${nodeId}`);
+                    return node;
+                }
+            }
+        }
+        // Search for blocks: their ID is "filePath#shortId"
+        for (const [nodeId, node] of this.nodeRegistry) {
+            if (nodeId.endsWith(`#${shortId}`)) {
+                this.options.log?.(`[NodeManager] Found via #suffix match: ${nodeId}`);
+                return node;
+            }
+            const idPart = nodeId.split('#').pop();
+            if (idPart === shortId) {
+                this.options.log?.(`[NodeManager] Found via split match: ${nodeId}`);
+                return node;
+            }
+        }
+        this.options.log?.(`[NodeManager] No node found for "${shortId}"`);
+        return undefined;
+    }
+    getNodesByFile(filePath) {
+        const nodeIds = this.fileNodeIndex.get(filePath);
+        if (!nodeIds)
+            return [];
+        return Array.from(nodeIds)
+            .map(id => this.nodeRegistry.get(id))
+            .filter((node) => node !== undefined);
+    }
+    getNodesByType(type) {
+        const nodeIds = this.typeIndex.get(type);
+        if (!nodeIds)
+            return [];
+        return Array.from(nodeIds)
+            .map(id => this.nodeRegistry.get(id))
+            .filter((node) => node !== undefined);
+    }
+    getAllNodes() {
+        return Array.from(this.nodeRegistry.values());
+    }
+    getAllDocuments() {
+        return Array.from(this.nodeRegistry.values()).filter(node => !node.parentId);
+    }
+    getAllBlocks() {
+        const blocks = [];
+        for (const type of exports.INDEXED_BLOCK_TYPES) {
+            blocks.push(...this.getNodesByType(type));
+        }
+        return blocks;
+    }
+    /**
+     * Get all edges for graph visualization (all link types)
+     */
+    getAllEdges() {
+        const edges = [];
+        for (const [sourceId, targets] of this.linkGraph) {
+            const sourceNode = this.nodeRegistry.get(sourceId);
+            if (!sourceNode)
+                continue;
+            for (const targetId of targets) {
+                // Determine edge type from source node type
+                let edgeType = 'jotxlink';
+                let metadata = {};
+                if (sourceNode.type === 'jotxlink') {
+                    edgeType = 'jotxlink';
+                    metadata = { label: sourceNode.properties?.title };
+                }
+                else if (sourceNode.type === 'link') {
+                    edgeType = 'link';
+                    metadata = { label: sourceNode.properties?.text };
+                }
+                else if (sourceNode.type === 'button') {
+                    edgeType = 'button';
+                    metadata = {
+                        label: sourceNode.properties?.label,
+                        style: sourceNode.properties?.style
+                    };
+                }
+                else if (sourceNode.type === 'card') {
+                    edgeType = 'card';
+                    metadata = {
+                        label: sourceNode.properties?.title,
+                        icon: sourceNode.properties?.icon,
+                        color: sourceNode.properties?.color
+                    };
+                }
+                edges.push({
+                    sourceId,
+                    targetId,
+                    type: edgeType,
+                    metadata
+                });
+            }
+        }
+        return edges;
+    }
+    /**
+     * Legacy method for backward compatibility
+     * @deprecated Use getAllEdges() instead
+     */
+    getJotxLinkEdges() {
+        return this.getAllEdges().filter(edge => edge.type === 'jotxlink');
+    }
+    getLinkedNodes(nodeId) {
+        const targetIds = this.linkGraph.get(nodeId);
+        if (!targetIds)
+            return [];
+        return Array.from(targetIds)
+            .map(id => this.getNodeByShortId(id) || this.nodeRegistry.get(id))
+            .filter((node) => node !== undefined);
+    }
+    getBacklinks(nodeId) {
+        const backlinks = [];
+        // Extract shortId from full nodeId for comparison
+        const targetShortId = nodeId.includes('#') ? nodeId.split('#').pop() : nodeId;
+        for (const [sourceId, targets] of this.linkGraph) {
+            for (const targetId of targets) {
+                // Match by full ID or short ID
+                if (targetId === nodeId || targetId === targetShortId) {
+                    const node = this.nodeRegistry.get(sourceId);
+                    if (node)
+                        backlinks.push(node);
+                }
+            }
+        }
+        return backlinks;
+    }
+    getDefTree(filePath) {
+        return this.defHierarchy.get(filePath);
+    }
+    validateUniqueIds() {
+        const duplicates = new Map();
+        const idToFiles = new Map();
+        for (const [nodeId, node] of this.nodeRegistry) {
+            // Skip document nodes
+            if (node.type === 'jotx')
+                continue;
+            // Extract shortUUID from nodeId
+            const parts = nodeId.split('#');
+            if (parts.length !== 2)
+                continue;
+            const shortId = parts[1];
+            const filePath = node.filePath;
+            if (!idToFiles.has(shortId)) {
+                idToFiles.set(shortId, []);
+            }
+            idToFiles.get(shortId).push(filePath);
+        }
+        // Find duplicates
+        for (const [id, files] of idToFiles) {
+            if (files.length > 1) {
+                duplicates.set(id, files);
+            }
+        }
+        return duplicates;
+    }
+    clear() {
+        this.nodeRegistry.clear();
+        this.fileNodeIndex.clear();
+        this.typeIndex.clear();
+        this.defHierarchy.clear();
+        this.linkGraph.clear();
+    }
+    getStats() {
+        return {
+            documents: this.getAllDocuments().length,
+            blocks: this.getAllBlocks().length,
+            edges: this.getAllEdges().length
+        };
+    }
+}
+exports.NodeManager = NodeManager;
+//# sourceMappingURL=NodeManager.js.map