@workglow/knowledge-base 0.0.115

package/dist/node.js

@@ -0,0 +1,1071 @@
+// src/document/DocumentSchema.ts
+var NodeKind = {
+  DOCUMENT: "document",
+  SECTION: "section",
+  PARAGRAPH: "paragraph",
+  SENTENCE: "sentence",
+  TOPIC: "topic"
+};
+var NodeRangeSchema = {
+  type: "object",
+  properties: {
+    startOffset: {
+      type: "integer",
+      title: "Start Offset",
+      description: "Starting character offset"
+    },
+    endOffset: {
+      type: "integer",
+      title: "End Offset",
+      description: "Ending character offset"
+    }
+  },
+  required: ["startOffset", "endOffset"],
+  additionalProperties: false
+};
+var EntitySchema = {
+  type: "object",
+  properties: {
+    text: {
+      type: "string",
+      title: "Text",
+      description: "Entity text"
+    },
+    type: {
+      type: "string",
+      title: "Type",
+      description: "Entity type (e.g., PERSON, ORG, LOC)"
+    },
+    score: {
+      type: "number",
+      title: "Score",
+      description: "Confidence score"
+    }
+  },
+  required: ["text", "type", "score"],
+  additionalProperties: false
+};
+var NodeEnrichmentSchema = {
+  type: "object",
+  properties: {
+    summary: {
+      type: "string",
+      title: "Summary",
+      description: "Summary of the node content"
+    },
+    entities: {
+      type: "array",
+      items: EntitySchema,
+      title: "Entities",
+      description: "Named entities extracted from the node"
+    },
+    keywords: {
+      type: "array",
+      items: { type: "string" },
+      title: "Keywords",
+      description: "Keywords associated with the node"
+    }
+  },
+  additionalProperties: false
+};
+var DocumentNodeBaseSchema = {
+  type: "object",
+  properties: {
+    nodeId: {
+      type: "string",
+      title: "Node ID",
+      description: "Unique identifier for this node"
+    },
+    kind: {
+      type: "string",
+      enum: Object.values(NodeKind),
+      title: "Kind",
+      description: "Node type discriminator"
+    },
+    range: NodeRangeSchema,
+    text: {
+      type: "string",
+      title: "Text",
+      description: "Text content of the node"
+    },
+    enrichment: NodeEnrichmentSchema
+  },
+  required: ["nodeId", "kind", "range", "text"],
+  additionalProperties: true
+};
+var DocumentNodeSchema = {
+  type: "object",
+  title: "Document Node",
+  description: "A node in the hierarchical document tree",
+  properties: {
+    ...DocumentNodeBaseSchema.properties,
+    level: {
+      type: "integer",
+      title: "Level",
+      description: "Header level for section nodes"
+    },
+    title: {
+      type: "string",
+      title: "Title",
+      description: "Section title"
+    },
+    children: {
+      type: "array",
+      title: "Children",
+      description: "Child nodes"
+    }
+  },
+  required: [...DocumentNodeBaseSchema.required],
+  additionalProperties: false
+};
+var ParagraphNodeSchema = {
+  type: "object",
+  properties: {
+    ...DocumentNodeBaseSchema.properties,
+    kind: {
+      type: "string",
+      const: NodeKind.PARAGRAPH,
+      title: "Kind",
+      description: "Node type discriminator"
+    }
+  },
+  required: [...DocumentNodeBaseSchema.required],
+  additionalProperties: false
+};
+var SentenceNodeSchema = {
+  type: "object",
+  properties: {
+    ...DocumentNodeBaseSchema.properties,
+    kind: {
+      type: "string",
+      const: NodeKind.SENTENCE,
+      title: "Kind",
+      description: "Node type discriminator"
+    }
+  },
+  required: [...DocumentNodeBaseSchema.required],
+  additionalProperties: false
+};
+var SectionNodeSchema = {
+  type: "object",
+  properties: {
+    ...DocumentNodeBaseSchema.properties,
+    kind: {
+      type: "string",
+      const: NodeKind.SECTION,
+      title: "Kind",
+      description: "Node type discriminator"
+    },
+    level: {
+      type: "integer",
+      minimum: 1,
+      maximum: 6,
+      title: "Level",
+      description: "Header level (1-6 for markdown)"
+    },
+    title: {
+      type: "string",
+      title: "Title",
+      description: "Section title"
+    },
+    children: {
+      type: "array",
+      items: DocumentNodeSchema,
+      title: "Children",
+      description: "Child nodes"
+    }
+  },
+  required: [...DocumentNodeBaseSchema.required, "level", "title", "children"],
+  additionalProperties: false
+};
+var TopicNodeSchema = {
+  type: "object",
+  properties: {
+    ...DocumentNodeBaseSchema.properties,
+    kind: {
+      type: "string",
+      const: NodeKind.TOPIC,
+      title: "Kind",
+      description: "Node type discriminator"
+    },
+    children: {
+      type: "array",
+      items: DocumentNodeSchema,
+      title: "Children",
+      description: "Child nodes"
+    }
+  },
+  required: [...DocumentNodeBaseSchema.required, "children"],
+  additionalProperties: false
+};
+var DocumentRootNodeSchema = {
+  type: "object",
+  properties: {
+    ...DocumentNodeBaseSchema.properties,
+    kind: {
+      type: "string",
+      const: NodeKind.DOCUMENT,
+      title: "Kind",
+      description: "Node type discriminator"
+    },
+    title: {
+      type: "string",
+      title: "Title",
+      description: "Document title"
+    },
+    children: {
+      type: "array",
+      items: DocumentNodeSchema,
+      title: "Children",
+      description: "Child nodes"
+    }
+  },
+  required: [...DocumentNodeBaseSchema.required, "title", "children"],
+  additionalProperties: false
+};
+var TokenBudgetSchema = {
+  type: "object",
+  properties: {
+    maxTokensPerChunk: {
+      type: "integer",
+      title: "Max Tokens Per Chunk",
+      description: "Maximum tokens allowed per chunk"
+    },
+    overlapTokens: {
+      type: "integer",
+      title: "Overlap Tokens",
+      description: "Number of tokens to overlap between chunks"
+    },
+    reservedTokens: {
+      type: "integer",
+      title: "Reserved Tokens",
+      description: "Tokens reserved for metadata or context"
+    }
+  },
+  required: ["maxTokensPerChunk", "overlapTokens", "reservedTokens"],
+  additionalProperties: false
+};
+var DocumentMetadataSchema = {
+  type: "object",
+  properties: {
+    title: {
+      type: "string",
+      title: "Title",
+      description: "Document title"
+    },
+    sourceUri: {
+      type: "string",
+      title: "Source URI",
+      description: "Original source URI of the document"
+    },
+    createdAt: {
+      type: "string",
+      title: "Created At",
+      description: "ISO timestamp of creation"
+    }
+  },
+  required: ["title"],
+  additionalProperties: true
+};
+
+// src/chunk/ChunkSchema.ts
+var ChunkRecordSchema = () => ({
+  type: "object",
+  properties: {
+    chunkId: {
+      type: "string",
+      title: "Chunk ID",
+      description: "Unique identifier for this chunk"
+    },
+    doc_id: {
+      type: "string",
+      title: "Document ID",
+      description: "ID of the parent document"
+    },
+    text: {
+      type: "string",
+      title: "Text",
+      description: "Text content of the chunk"
+    },
+    nodePath: {
+      type: "array",
+      items: { type: "string" },
+      title: "Node Path",
+      description: "Node IDs from root to leaf"
+    },
+    depth: {
+      type: "integer",
+      title: "Depth",
+      description: "Depth in the document tree"
+    },
+    leafNodeId: {
+      type: "string",
+      title: "Leaf Node ID",
+      description: "ID of the leaf node this chunk belongs to"
+    },
+    summary: {
+      type: "string",
+      title: "Summary",
+      description: "Summary of the chunk content"
+    },
+    entities: {
+      type: "array",
+      items: EntitySchema,
+      title: "Entities",
+      description: "Named entities extracted from the chunk"
+    },
+    parentSummaries: {
+      type: "array",
+      items: { type: "string" },
+      title: "Parent Summaries",
+      description: "Summaries from ancestor nodes"
+    },
+    sectionTitles: {
+      type: "array",
+      items: { type: "string" },
+      title: "Section Titles",
+      description: "Titles of ancestor section nodes"
+    },
+    doc_title: {
+      type: "string",
+      title: "Document Title",
+      description: "Title of the parent document"
+    }
+  },
+  required: ["chunkId", "doc_id", "text", "nodePath", "depth"],
+  additionalProperties: true
+});
+var ChunkRecordArraySchema = {
+  type: "array",
+  items: ChunkRecordSchema(),
+  title: "Chunk Records",
+  description: "Array of chunk records"
+};
+// src/chunk/ChunkVectorStorageSchema.ts
+import { TypedArraySchema } from "@workglow/util";
+var ChunkVectorStorageSchema = {
+  type: "object",
+  properties: {
+    chunk_id: { type: "string", "x-auto-generated": true },
+    doc_id: { type: "string" },
+    vector: TypedArraySchema(),
+    metadata: { type: "object", format: "metadata", additionalProperties: true }
+  },
+  required: ["chunk_id", "doc_id", "vector", "metadata"],
+  additionalProperties: false
+};
+var ChunkVectorPrimaryKey = ["chunk_id"];
+// src/document/Document.ts
+class Document {
+  doc_id;
+  metadata;
+  root;
+  chunks;
+  constructor(root, metadata, chunks = [], doc_id) {
+    this.doc_id = doc_id;
+    this.root = root;
+    this.metadata = metadata;
+    this.chunks = chunks || [];
+  }
+  setChunks(chunks) {
+    this.chunks = chunks;
+  }
+  getChunks() {
+    return this.chunks;
+  }
+  setDocId(doc_id) {
+    this.doc_id = doc_id;
+  }
+  findChunksByNodeId(nodeId) {
+    return this.chunks.filter((chunk) => chunk.nodePath.includes(nodeId));
+  }
+  toJSON() {
+    return {
+      metadata: this.metadata,
+      root: this.root,
+      chunks: this.chunks
+    };
+  }
+  static fromJSON(json, doc_id) {
+    const obj = JSON.parse(json);
+    return new Document(obj.root, obj.metadata, obj.chunks, doc_id);
+  }
+}
+
+// src/knowledge-base/KnowledgeBase.ts
+class KnowledgeBase {
+  name;
+  title;
+  description;
+  tabularStorage;
+  chunkStorage;
+  constructor(name, documentStorage, chunkStorage, title, description) {
+    this.name = name;
+    this.title = title ?? name;
+    this.description = description ?? "";
+    this.tabularStorage = documentStorage;
+    this.chunkStorage = chunkStorage;
+  }
+  async upsertDocument(document) {
+    const serialized = JSON.stringify(document.toJSON());
+    const insertEntity = {
+      doc_id: document.doc_id,
+      data: serialized
+    };
+    const entity = await this.tabularStorage.put(insertEntity);
+    if (document.doc_id !== entity.doc_id) {
+      document.setDocId(entity.doc_id);
+    }
+    return document;
+  }
+  async getDocument(doc_id) {
+    const entity = await this.tabularStorage.get({ doc_id });
+    if (!entity) {
+      return;
+    }
+    return Document.fromJSON(entity.data, entity.doc_id);
+  }
+  async deleteDocument(doc_id) {
+    await this.deleteChunksForDocument(doc_id);
+    await this.tabularStorage.delete({ doc_id });
+  }
+  async listDocuments() {
+    const entities = await this.tabularStorage.getAll();
+    if (!entities) {
+      return [];
+    }
+    return entities.map((e) => e.doc_id);
+  }
+  async getNode(doc_id, nodeId) {
+    const doc = await this.getDocument(doc_id);
+    if (!doc) {
+      return;
+    }
+    const traverse = (node) => {
+      if (node.nodeId === nodeId) {
+        return node;
+      }
+      if ("children" in node && Array.isArray(node.children)) {
+        for (const child of node.children) {
+          const found = traverse(child);
+          if (found)
+            return found;
+        }
+      }
+      return;
+    };
+    return traverse(doc.root);
+  }
+  async getAncestors(doc_id, nodeId) {
+    const doc = await this.getDocument(doc_id);
+    if (!doc) {
+      return [];
+    }
+    const path = [];
+    const findPath = (node) => {
+      path.push(node.nodeId);
+      if (node.nodeId === nodeId) {
+        return true;
+      }
+      if ("children" in node && Array.isArray(node.children)) {
+        for (const child of node.children) {
+          if (findPath(child)) {
+            return true;
+          }
+        }
+      }
+      path.pop();
+      return false;
+    };
+    if (!findPath(doc.root)) {
+      return [];
+    }
+    const ancestors = [];
+    let currentNode = doc.root;
+    ancestors.push(currentNode);
+    for (let i = 1;i < path.length; i++) {
+      const targetId = path[i];
+      if ("children" in currentNode && Array.isArray(currentNode.children)) {
+        const found = currentNode.children.find((child) => child.nodeId === targetId);
+        if (found) {
+          currentNode = found;
+          ancestors.push(currentNode);
+        } else {
+          break;
+        }
+      } else {
+        break;
+      }
+    }
+    return ancestors;
+  }
+  async upsertChunk(chunk) {
+    if (chunk.vector.length !== this.getVectorDimensions()) {
+      throw new Error(`Vector dimension mismatch: expected ${this.getVectorDimensions()}, got ${chunk.vector.length}.`);
+    }
+    return this.chunkStorage.put(chunk);
+  }
+  async upsertChunksBulk(chunks) {
+    const expected = this.getVectorDimensions();
+    for (const chunk of chunks) {
+      if (chunk.vector.length !== expected) {
+        throw new Error(`Vector dimension mismatch: expected ${expected}, got ${chunk.vector.length}.`);
+      }
+    }
+    return this.chunkStorage.putBulk(chunks);
+  }
+  async deleteChunksForDocument(doc_id) {
+    await this.chunkStorage.deleteSearch({ doc_id });
+  }
+  async getChunksForDocument(doc_id) {
+    const results = await this.chunkStorage.query({ doc_id });
+    return results ?? [];
+  }
+  async similaritySearch(query, options) {
+    return this.chunkStorage.similaritySearch(query, options);
+  }
+  async hybridSearch(query, options) {
+    if (typeof this.chunkStorage.hybridSearch !== "function") {
+      throw new Error("Hybrid search is not supported by the configured chunk storage backend. " + "Please use a vector storage implementation that provides `hybridSearch`.");
+    }
+    return this.chunkStorage.hybridSearch(query, options);
+  }
+  async prepareReindex(doc_id) {
+    const doc = await this.getDocument(doc_id);
+    if (!doc) {
+      return;
+    }
+    await this.deleteChunksForDocument(doc_id);
+    return doc;
+  }
+  async setupDatabase() {
+    await this.tabularStorage.setupDatabase();
+    await this.chunkStorage.setupDatabase();
+  }
+  destroy() {
+    this.tabularStorage.destroy();
+    this.chunkStorage.destroy();
+  }
+  async getChunk(chunk_id) {
+    return this.chunkStorage.get({ chunk_id });
+  }
+  async put(chunk) {
+    return this.chunkStorage.put(chunk);
+  }
+  async putBulk(chunks) {
+    return this.chunkStorage.putBulk(chunks);
+  }
+  async getAllChunks() {
+    return this.chunkStorage.getAll();
+  }
+  async chunkCount() {
+    return this.chunkStorage.size();
+  }
+  async clearChunks() {
+    return this.chunkStorage.deleteAll();
+  }
+  getVectorDimensions() {
+    return this.chunkStorage.getVectorDimensions();
+  }
+  async getDocumentChunks(doc_id) {
+    const doc = await this.getDocument(doc_id);
+    if (!doc) {
+      return [];
+    }
+    return doc.getChunks();
+  }
+  async findChunksByNodeId(doc_id, nodeId) {
+    const doc = await this.getDocument(doc_id);
+    if (!doc) {
+      return [];
+    }
+    return doc.findChunksByNodeId(nodeId);
+  }
+}
+// src/knowledge-base/KnowledgeBaseSchema.ts
+var KnowledgeBaseRecordSchema = {
+  type: "object",
+  properties: {
+    kb_id: { type: "string" },
+    title: { type: "string" },
+    description: { type: "string" },
+    vector_dimensions: { type: "integer" },
+    document_table: { type: "string" },
+    chunk_table: { type: "string" },
+    created_at: { type: "string" },
+    updated_at: { type: "string" }
+  },
+  required: [
+    "kb_id",
+    "title",
+    "description",
+    "vector_dimensions",
+    "document_table",
+    "chunk_table",
+    "created_at",
+    "updated_at"
+  ],
+  additionalProperties: false
+};
+var KnowledgeBasePrimaryKeyNames = ["kb_id"];
+function knowledgeBaseTableNames(kbId) {
+  const safe = kbId.replace(/[^a-zA-Z0-9_]/g, "_");
+  return {
+    documentTable: `kb_docs_${safe}`,
+    chunkTable: `kb_chunks_${safe}`
+  };
+}
+// src/knowledge-base/KnowledgeBaseRepository.ts
+import { EventEmitter } from "@workglow/util";
+
+class KnowledgeBaseRepository {
+  storage;
+  constructor(storage) {
+    this.storage = storage;
+  }
+  events = new EventEmitter;
+  async setupDatabase() {
+    await this.storage.setupDatabase?.();
+  }
+  on(name, fn) {
+    this.events.on(name, fn);
+  }
+  off(name, fn) {
+    this.events.off(name, fn);
+  }
+  once(name, fn) {
+    this.events.once(name, fn);
+  }
+  waitOn(name) {
+    return this.events.waitOn(name);
+  }
+  async addKnowledgeBase(record) {
+    await this.storage.put(record);
+    this.events.emit("knowledge_base_added", record);
+    return record;
+  }
+  async removeKnowledgeBase(kb_id) {
+    const record = await this.storage.get({ kb_id });
+    if (!record) {
+      throw new Error(`KnowledgeBase with id "${kb_id}" not found`);
+    }
+    await this.storage.delete({ kb_id });
+    this.events.emit("knowledge_base_removed", record);
+  }
+  async getKnowledgeBase(kb_id) {
+    if (typeof kb_id !== "string")
+      return;
+    const record = await this.storage.get({ kb_id });
+    return record ?? undefined;
+  }
+  async enumerateAll() {
+    const records = await this.storage.getAll();
+    if (!records || records.length === 0)
+      return [];
+    return records;
+  }
+  async size() {
+    return await this.storage.size();
+  }
+}
+// src/knowledge-base/InMemoryKnowledgeBaseRepository.ts
+import { InMemoryTabularStorage } from "@workglow/storage";
+class InMemoryKnowledgeBaseRepository extends KnowledgeBaseRepository {
+  constructor() {
+    super(new InMemoryTabularStorage(KnowledgeBaseRecordSchema, KnowledgeBasePrimaryKeyNames));
+  }
+}
+// src/knowledge-base/KnowledgeBaseRegistry.ts
+import {
+  createServiceToken,
+  globalServiceRegistry,
+  registerInputResolver
+} from "@workglow/util";
+var KNOWLEDGE_BASES = createServiceToken("knowledge-base.registry");
+var KNOWLEDGE_BASE_REPOSITORY = createServiceToken("knowledge-base.repository");
+if (!globalServiceRegistry.has(KNOWLEDGE_BASES)) {
+  globalServiceRegistry.register(KNOWLEDGE_BASES, () => new Map, true);
+}
+if (!globalServiceRegistry.has(KNOWLEDGE_BASE_REPOSITORY)) {
+  globalServiceRegistry.register(KNOWLEDGE_BASE_REPOSITORY, () => new InMemoryKnowledgeBaseRepository, true);
+}
+function getGlobalKnowledgeBases() {
+  return globalServiceRegistry.get(KNOWLEDGE_BASES);
+}
+function getGlobalKnowledgeBaseRepository() {
+  return globalServiceRegistry.get(KNOWLEDGE_BASE_REPOSITORY);
+}
+function setGlobalKnowledgeBaseRepository(repository) {
+  globalServiceRegistry.registerInstance(KNOWLEDGE_BASE_REPOSITORY, repository);
+}
+async function registerKnowledgeBase(id, kb) {
+  const kbs = getGlobalKnowledgeBases();
+  kbs.set(id, kb);
+  const now = new Date().toISOString();
+  const tableNames = knowledgeBaseTableNames(id);
+  const record = {
+    kb_id: id,
+    title: kb.title,
+    description: kb.description,
+    vector_dimensions: kb.getVectorDimensions(),
+    document_table: tableNames.documentTable,
+    chunk_table: tableNames.chunkTable,
+    created_at: now,
+    updated_at: now
+  };
+  const repo = getGlobalKnowledgeBaseRepository();
+  await repo.addKnowledgeBase(record);
+}
+function getKnowledgeBase(id) {
+  return getGlobalKnowledgeBases().get(id);
+}
+async function resolveKnowledgeBaseFromRegistry(id, format, registry) {
+  const kbs = registry.has(KNOWLEDGE_BASES) ? registry.get(KNOWLEDGE_BASES) : getGlobalKnowledgeBases();
+  const kb = kbs.get(id);
+  if (!kb) {
+    throw new Error(`Knowledge base "${id}" not found in registry`);
+  }
+  return kb;
+}
+registerInputResolver("knowledge-base", resolveKnowledgeBaseFromRegistry);
+// src/knowledge-base/createKnowledgeBase.ts
+import { InMemoryTabularStorage as InMemoryTabularStorage2, InMemoryVectorStorage } from "@workglow/storage";
+
+// src/document/DocumentStorageSchema.ts
+var DocumentStorageSchema = {
+  type: "object",
+  properties: {
+    doc_id: {
+      type: "string",
+      "x-auto-generated": true,
+      title: "Document ID",
+      description: "Unique identifier for the document"
+    },
+    data: {
+      type: "string",
+      title: "Document Data",
+      description: "JSON-serialized document"
+    },
+    metadata: {
+      type: "object",
+      title: "Metadata",
+      description: "Metadata of the document"
+    }
+  },
+  required: ["doc_id", "data"],
+  additionalProperties: true
+};
+var DocumentStorageKey = ["doc_id"];
+
+// src/knowledge-base/createKnowledgeBase.ts
+async function createKnowledgeBase(options) {
+  const {
+    name,
+    vectorDimensions,
+    vectorType = Float32Array,
+    register: shouldRegister = true,
+    title,
+    description
+  } = options;
+  const tabularStorage = new InMemoryTabularStorage2(DocumentStorageSchema, DocumentStorageKey);
+  await tabularStorage.setupDatabase();
+  const vectorStorage = new InMemoryVectorStorage(ChunkVectorStorageSchema, ChunkVectorPrimaryKey, [], vectorDimensions, vectorType);
+  await vectorStorage.setupDatabase();
+  const kb = new KnowledgeBase(name, tabularStorage, vectorStorage, title, description);
+  if (shouldRegister) {
+    await registerKnowledgeBase(name, kb);
+  }
+  return kb;
+}
+// src/util/DatasetSchema.ts
+function TypeTabularStorage(options = {}) {
+  return {
+    title: "Tabular Storage",
+    description: "Storage ID or instance for tabular data storage",
+    ...options,
+    format: "storage:tabular",
+    oneOf: [
+      { type: "string", title: "Storage ID" },
+      { title: "Storage Instance", additionalProperties: true }
+    ]
+  };
+}
+function TypeKnowledgeBase(options = {}) {
+  return {
+    title: "Knowledge Base",
+    description: "Knowledge base ID or instance",
+    ...options,
+    format: "knowledge-base",
+    anyOf: [
+      { type: "string", title: "Knowledge Base ID" },
+      { title: "Knowledge Base Instance", additionalProperties: true }
+    ]
+  };
+}
+// src/document/DocumentNode.ts
+function estimateTokens(text) {
+  return Math.ceil(text.length / 4);
+}
+function hasChildren(node) {
+  return node.kind === NodeKind.DOCUMENT || node.kind === NodeKind.SECTION || node.kind === NodeKind.TOPIC;
+}
+function getChildren(node) {
+  if (hasChildren(node)) {
+    return node.children;
+  }
+  return [];
+}
+function* traverseDepthFirst(node) {
+  yield node;
+  if (hasChildren(node)) {
+    for (const child of node.children) {
+      yield* traverseDepthFirst(child);
+    }
+  }
+}
+function getNodePath(root, targetNodeId) {
+  const path = [];
+  function search(node) {
+    path.push(node.nodeId);
+    if (node.nodeId === targetNodeId) {
+      return true;
+    }
+    if (hasChildren(node)) {
+      for (const child of node.children) {
+        if (search(child)) {
+          return true;
+        }
+      }
+    }
+    path.pop();
+    return false;
+  }
+  return search(root) ? path : undefined;
+}
+function getDocumentRange(root, nodePath) {
+  let currentNode = root;
+  for (let i = 1;i < nodePath.length; i++) {
+    const targetId = nodePath[i];
+    const children = currentNode.children;
+    let found;
+    for (let j = 0;j < children.length; j++) {
+      if (children[j].nodeId === targetId) {
+        found = children[j];
+        break;
+      }
+    }
+    if (!found) {
+      throw new Error(`Node with id ${targetId} not found in path`);
+    }
+    currentNode = found;
+  }
+  return currentNode.range;
+}
+// src/document/StructuralParser.ts
+import { uuid4 } from "@workglow/util";
+class StructuralParser {
+  static async parseMarkdown(doc_id, text, title) {
+    const lines = text.split(`
+`);
+    let currentOffset = 0;
+    const root = {
+      nodeId: uuid4(),
+      kind: NodeKind.DOCUMENT,
+      range: { startOffset: 0, endOffset: text.length },
+      text: title,
+      title,
+      children: []
+    };
+    let currentParentStack = [root];
+    let textBuffer = [];
+    let textBufferStartOffset = 0;
+    const flushTextBuffer = async () => {
+      if (textBuffer.length > 0) {
+        const content = textBuffer.join(`
+`).trim();
+        if (content) {
+          const paragraphStartOffset = textBufferStartOffset;
+          const paragraphEndOffset = currentOffset;
+          const paragraph = {
+            nodeId: uuid4(),
+            kind: NodeKind.PARAGRAPH,
+            range: {
+              startOffset: paragraphStartOffset,
+              endOffset: paragraphEndOffset
+            },
+            text: content
+          };
+          currentParentStack[currentParentStack.length - 1].children.push(paragraph);
+        }
+        textBuffer = [];
+      }
+    };
+    for (const line of lines) {
+      const lineLength = line.length + 1;
+      const headerMatch = line.match(/^(#{1,6})\s+(.*)$/);
+      if (headerMatch) {
+        await flushTextBuffer();
+        const level = headerMatch[1].length;
+        const headerTitle = headerMatch[2];
+        while (currentParentStack.length > 1 && currentParentStack[currentParentStack.length - 1].kind === NodeKind.SECTION && currentParentStack[currentParentStack.length - 1].level >= level) {
+          const poppedSection = currentParentStack.pop();
+          const updatedSection = {
+            ...poppedSection,
+            range: {
+              ...poppedSection.range,
+              endOffset: currentOffset
+            }
+          };
+          const parent = currentParentStack[currentParentStack.length - 1];
+          parent.children[parent.children.length - 1] = updatedSection;
+        }
+        const sectionStartOffset = currentOffset;
+        const section = {
+          nodeId: uuid4(),
+          kind: NodeKind.SECTION,
+          level,
+          title: headerTitle,
+          range: {
+            startOffset: sectionStartOffset,
+            endOffset: text.length
+          },
+          text: headerTitle,
+          children: []
+        };
+        currentParentStack[currentParentStack.length - 1].children.push(section);
+        currentParentStack.push(section);
+      } else {
+        if (textBuffer.length === 0) {
+          textBufferStartOffset = currentOffset;
+        }
+        textBuffer.push(line);
+      }
+      currentOffset += lineLength;
+    }
+    await flushTextBuffer();
+    while (currentParentStack.length > 1) {
+      const section = currentParentStack.pop();
+      const updatedSection = {
+        ...section,
+        range: {
+          ...section.range,
+          endOffset: text.length
+        }
+      };
+      const parent = currentParentStack[currentParentStack.length - 1];
+      parent.children[parent.children.length - 1] = updatedSection;
+    }
+    return root;
+  }
+  static async parsePlainText(doc_id, text, title) {
+    const root = {
+      nodeId: uuid4(),
+      kind: NodeKind.DOCUMENT,
+      range: { startOffset: 0, endOffset: text.length },
+      text: title,
+      title,
+      children: []
+    };
+    const paragraphRegex = /\n\s*\n/g;
+    let lastIndex = 0;
+    let paragraphIndex = 0;
+    let match;
+    while ((match = paragraphRegex.exec(text)) !== null) {
+      const rawParagraph = text.slice(lastIndex, match.index);
+      const paragraphText = rawParagraph.trim();
+      if (paragraphText.length > 0) {
+        const trimmedRelativeStart = rawParagraph.indexOf(paragraphText);
+        const startOffset = lastIndex + trimmedRelativeStart;
+        const endOffset = startOffset + paragraphText.length;
+        const paragraph = {
+          nodeId: uuid4(),
+          kind: NodeKind.PARAGRAPH,
+          range: {
+            startOffset,
+            endOffset
+          },
+          text: paragraphText
+        };
+        root.children.push(paragraph);
+        paragraphIndex++;
+      }
+      lastIndex = paragraphRegex.lastIndex;
+    }
+    if (lastIndex < text.length) {
+      const rawParagraph = text.slice(lastIndex);
+      const paragraphText = rawParagraph.trim();
+      if (paragraphText.length > 0) {
+        const trimmedRelativeStart = rawParagraph.indexOf(paragraphText);
+        const startOffset = lastIndex + trimmedRelativeStart;
+        const endOffset = startOffset + paragraphText.length;
+        const paragraph = {
+          nodeId: uuid4(),
+          kind: NodeKind.PARAGRAPH,
+          range: {
+            startOffset,
+            endOffset
+          },
+          text: paragraphText
+        };
+        root.children.push(paragraph);
+      }
+    }
+    return root;
+  }
+  static parse(doc_id, text, title, format) {
+    if (format === "markdown" || !format && this.looksLikeMarkdown(text)) {
+      return this.parseMarkdown(doc_id, text, title);
+    }
+    return this.parsePlainText(doc_id, text, title);
+  }
+  static looksLikeMarkdown(text) {
+    return /^#{1,6}\s/m.test(text);
+  }
+}
+export {
+  traverseDepthFirst,
+  setGlobalKnowledgeBaseRepository,
+  registerKnowledgeBase,
+  knowledgeBaseTableNames,
+  hasChildren,
+  getNodePath,
+  getKnowledgeBase,
+  getGlobalKnowledgeBases,
+  getGlobalKnowledgeBaseRepository,
+  getDocumentRange,
+  getChildren,
+  estimateTokens,
+  createKnowledgeBase,
+  TypeTabularStorage,
+  TypeKnowledgeBase,
+  TopicNodeSchema,
+  TokenBudgetSchema,
+  StructuralParser,
+  SentenceNodeSchema,
+  SectionNodeSchema,
+  ParagraphNodeSchema,
+  NodeRangeSchema,
+  NodeKind,
+  NodeEnrichmentSchema,
+  KnowledgeBaseRepository,
+  KnowledgeBaseRecordSchema,
+  KnowledgeBasePrimaryKeyNames,
+  KnowledgeBase,
+  KNOWLEDGE_BASE_REPOSITORY,
+  KNOWLEDGE_BASES,
+  InMemoryKnowledgeBaseRepository,
+  EntitySchema,
+  DocumentStorageSchema,
+  DocumentStorageKey,
+  DocumentRootNodeSchema,
+  DocumentNodeSchema,
+  DocumentNodeBaseSchema,
+  DocumentMetadataSchema,
+  Document,
+  ChunkVectorStorageSchema,
+  ChunkVectorPrimaryKey,
+  ChunkRecordSchema,
+  ChunkRecordArraySchema
+};
+
+//# debugId=5A4C1CAE3E58975C64756E2164756E21