@rejot-dev/thalo 0.0.0

package/dist/ast/extract.js

@@ -0,0 +1,748 @@
+import { buildTimestamp, createSyntaxError } from "./builder.js";
+
+//#region src/ast/extract.ts
+/**
+* Extract location information from a tree-sitter node
+*/
+function extractLocation(node) {
+	return {
+		startIndex: node.startIndex,
+		endIndex: node.endIndex,
+		startPosition: node.startPosition,
+		endPosition: node.endPosition
+	};
+}
+/**
+* Create the base AST node properties
+*/
+function baseNode(node, type) {
+	return {
+		type,
+		location: extractLocation(node),
+		syntaxNode: node
+	};
+}
+/**
+* Get a required child by field name
+*/
+function getChildByField(node, field) {
+	const child = node.childForFieldName(field);
+	if (!child) throw new Error(`Missing required field '${field}' in ${node.type}`);
+	return child;
+}
+/**
+* Get an optional child by field name
+*/
+function getOptionalChildByField(node, field) {
+	return node.childForFieldName(field);
+}
+/**
+* Get all children of a specific type
+*/
+function getChildrenByType(node, type) {
+	return node.namedChildren.filter((child) => child !== null && child.type === type);
+}
+/**
+* Get the first child of a specific type
+*/
+function getChildByType(node, type) {
+	return node.namedChildren.find((child) => child !== null && child.type === type) ?? null;
+}
+/**
+* Strip quotes from a quoted string
+*/
+function stripQuotes(text) {
+	if (text.startsWith("\"") && text.endsWith("\"")) return text.slice(1, -1);
+	return text;
+}
+/**
+* Recursively find all ERROR nodes within a syntax tree.
+* Used to capture syntax errors nested inside entries.
+*/
+function findErrorNodes(node) {
+	const errors = [];
+	function walk(n) {
+		if (n.type === "ERROR") {
+			errors.push(n);
+			return;
+		}
+		for (const child of n.children) if (child) walk(child);
+	}
+	walk(node);
+	return errors;
+}
+/**
+* Convert an ERROR syntax node to a SyntaxErrorNode
+*/
+function errorNodeToSyntaxError(node) {
+	const text = node.text.trim();
+	return {
+		type: "syntax_error",
+		code: "parse_error",
+		message: `Parse error: unexpected content "${text.slice(0, 50)}${text.length > 50 ? "..." : ""}"`,
+		text: node.text,
+		location: extractLocation(node),
+		syntaxNode: node
+	};
+}
+/**
+* Extract a SourceFile from the root node
+*/
+function extractSourceFile(node) {
+	if (node.type !== "source_file") throw new Error(`Expected source_file, got ${node.type}`);
+	const entries = [];
+	const syntaxErrors = [];
+	for (const child of node.namedChildren) {
+		if (!child) continue;
+		if (child.type === "entry") {
+			const entry = extractEntry(child);
+			if (entry) entries.push(entry);
+			if (child.hasError) {
+				const nestedErrors = findErrorNodes(child);
+				for (const errorNode of nestedErrors) syntaxErrors.push(errorNodeToSyntaxError(errorNode));
+			}
+		} else if (child.type === "ERROR") syntaxErrors.push(errorNodeToSyntaxError(child));
+	}
+	return {
+		...baseNode(node, "source_file"),
+		entries,
+		syntaxErrors
+	};
+}
+/**
+* Extract an Entry from an entry node
+*/
+function extractEntry(node) {
+	const child = node.namedChildren[0];
+	if (!child) return null;
+	if (child.type === "data_entry") return extractDataEntry(child);
+	if (child.type === "schema_entry") return extractSchemaEntry(child);
+	return null;
+}
+/**
+* Extract a DataEntry - handles instance, synthesis, and actualize entries
+* based on the directive type
+*/
+function extractDataEntry(node) {
+	const directive = getChildByField(node, "directive").text;
+	if (directive === "define-synthesis") return extractSynthesisEntryFromData(node);
+	if (directive === "actualize-synthesis") return extractActualizeEntryFromData(node);
+	return extractInstanceEntryFromData(node);
+}
+/**
+* Extract an InstanceEntry from a data_entry node
+*/
+function extractInstanceEntryFromData(node) {
+	const timestampNode = getChildByField(node, "timestamp");
+	const directiveNode = getChildByField(node, "directive");
+	const argumentNode = getOptionalChildByField(node, "argument");
+	const titleNode = getOptionalChildByField(node, "title");
+	const linkNodes = getChildrenByType(node, "link");
+	const tagNodes = getChildrenByType(node, "tag");
+	const metadataNodes = getChildrenByType(node, "metadata");
+	const contentNode = getChildByType(node, "content");
+	const entityValue = argumentNode?.text || "";
+	const header = {
+		...baseNode(node, "instance_header"),
+		timestamp: extractTimestamp(timestampNode),
+		directive: directiveNode.text,
+		entity: entityValue,
+		title: titleNode ? extractTitle(titleNode) : {
+			type: "title",
+			location: extractLocation(node),
+			syntaxNode: node,
+			value: ""
+		},
+		link: linkNodes.filter((l) => l !== argumentNode).length > 0 ? extractLink(linkNodes.filter((l) => l !== argumentNode)[0]) : null,
+		tags: tagNodes.map(extractTag)
+	};
+	return {
+		...baseNode(node, "instance_entry"),
+		header,
+		metadata: metadataNodes.map(extractMetadata),
+		content: contentNode ? extractContent(contentNode) : null
+	};
+}
+/**
+* Extract a SynthesisEntry from a data_entry node
+*/
+function extractSynthesisEntryFromData(node) {
+	const timestampNode = getChildByField(node, "timestamp");
+	const titleNode = getOptionalChildByField(node, "title");
+	const argumentNode = getOptionalChildByField(node, "argument");
+	const linkNodes = getChildrenByType(node, "link");
+	const tagNodes = getChildrenByType(node, "tag");
+	const metadataNodes = getChildrenByType(node, "metadata");
+	const contentNode = getChildByType(node, "content");
+	const linkIdNode = argumentNode?.type === "link" ? argumentNode : linkNodes[0];
+	const header = {
+		...baseNode(node, "synthesis_header"),
+		timestamp: extractTimestamp(timestampNode),
+		title: titleNode ? extractTitle(titleNode) : {
+			type: "title",
+			location: extractLocation(node),
+			syntaxNode: node,
+			value: ""
+		},
+		linkId: linkIdNode ? extractLink(linkIdNode) : {
+			type: "link",
+			location: extractLocation(node),
+			syntaxNode: node,
+			id: ""
+		},
+		tags: tagNodes.map(extractTag)
+	};
+	return {
+		...baseNode(node, "synthesis_entry"),
+		header,
+		metadata: metadataNodes.map(extractMetadata),
+		content: contentNode ? extractContent(contentNode) : null
+	};
+}
+/**
+* Extract an ActualizeEntry from a data_entry node
+*/
+function extractActualizeEntryFromData(node) {
+	const timestampNode = getChildByField(node, "timestamp");
+	const argumentNode = getOptionalChildByField(node, "argument");
+	const linkNodes = getChildrenByType(node, "link");
+	const metadataNodes = getChildrenByType(node, "metadata");
+	const targetNode = argumentNode?.type === "link" ? argumentNode : linkNodes[0];
+	const header = {
+		...baseNode(node, "actualize_header"),
+		timestamp: extractTimestamp(timestampNode),
+		target: targetNode ? extractLink(targetNode) : {
+			type: "link",
+			location: extractLocation(node),
+			syntaxNode: node,
+			id: ""
+		}
+	};
+	return {
+		...baseNode(node, "actualize_entry"),
+		header,
+		metadata: metadataNodes.map(extractMetadata)
+	};
+}
+/**
+* Extract a SchemaEntry - header fields are now inline
+*/
+function extractSchemaEntry(node) {
+	const timestampNode = getChildByField(node, "timestamp");
+	const directiveNode = getChildByField(node, "directive");
+	const argumentNode = getOptionalChildByField(node, "argument");
+	const titleNode = getChildByField(node, "title");
+	const linkNodes = getChildrenByType(node, "link");
+	const tagNodes = getChildrenByType(node, "tag");
+	const metadataBlockNode = getChildByType(node, "metadata_block");
+	const sectionsBlockNode = getChildByType(node, "sections_block");
+	const removeMetadataBlockNode = getChildByType(node, "remove_metadata_block");
+	const removeSectionsBlockNode = getChildByType(node, "remove_sections_block");
+	const header = {
+		...baseNode(node, "schema_header"),
+		timestamp: extractTimestamp(timestampNode),
+		directive: directiveNode.text,
+		entityName: argumentNode ? extractIdentifier(argumentNode) : {
+			type: "identifier",
+			location: extractLocation(node),
+			syntaxNode: node,
+			value: ""
+		},
+		title: extractTitle(titleNode),
+		link: linkNodes.length > 0 ? extractLink(linkNodes[0]) : null,
+		tags: tagNodes.map(extractTag)
+	};
+	return {
+		...baseNode(node, "schema_entry"),
+		header,
+		metadataBlock: metadataBlockNode ? extractMetadataBlock(metadataBlockNode) : null,
+		sectionsBlock: sectionsBlockNode ? extractSectionsBlock(sectionsBlockNode) : null,
+		removeMetadataBlock: removeMetadataBlockNode ? extractRemoveMetadataBlock(removeMetadataBlockNode) : null,
+		removeSectionsBlock: removeSectionsBlockNode ? extractRemoveSectionsBlock(removeSectionsBlockNode) : null
+	};
+}
+/**
+* Extract a MetadataBlock
+*/
+function extractMetadataBlock(node) {
+	const fieldNodes = getChildrenByType(node, "field_definition");
+	return {
+		...baseNode(node, "metadata_block"),
+		fields: fieldNodes.map(extractFieldDefinition)
+	};
+}
+/**
+* Extract a SectionsBlock
+*/
+function extractSectionsBlock(node) {
+	const sectionNodes = getChildrenByType(node, "section_definition");
+	return {
+		...baseNode(node, "sections_block"),
+		sections: sectionNodes.map(extractSectionDefinition)
+	};
+}
+/**
+* Extract a RemoveMetadataBlock
+*/
+function extractRemoveMetadataBlock(node) {
+	const fieldNodes = getChildrenByType(node, "field_removal");
+	return {
+		...baseNode(node, "remove_metadata_block"),
+		fields: fieldNodes.map(extractFieldRemoval)
+	};
+}
+/**
+* Extract a RemoveSectionsBlock
+*/
+function extractRemoveSectionsBlock(node) {
+	const sectionNodes = getChildrenByType(node, "section_removal");
+	return {
+		...baseNode(node, "remove_sections_block"),
+		sections: sectionNodes.map(extractSectionRemoval)
+	};
+}
+/**
+* Extract a FieldDefinition
+*/
+function extractFieldDefinition(node) {
+	const nameNode = getChildByType(node, "field_name");
+	if (!nameNode) throw new Error("Missing field_name in field_definition");
+	const optionalMarker = getChildByType(node, "optional_marker");
+	const typeNode = getChildByField(node, "type");
+	const defaultNode = getOptionalChildByField(node, "default");
+	const descriptionNode = getOptionalChildByField(node, "description");
+	return {
+		...baseNode(node, "field_definition"),
+		name: extractFieldName(nameNode),
+		optional: optionalMarker !== null,
+		typeExpr: extractTypeExpression(typeNode),
+		defaultValue: defaultNode ? extractDefaultValue(defaultNode) : null,
+		description: descriptionNode ? extractDescription(descriptionNode) : null
+	};
+}
+/**
+* Extract a FieldRemoval
+*/
+function extractFieldRemoval(node) {
+	const nameNode = getChildByType(node, "field_name");
+	if (!nameNode) throw new Error("Missing field_name in field_removal");
+	const reasonNode = getOptionalChildByField(node, "reason");
+	return {
+		...baseNode(node, "field_removal"),
+		name: extractFieldName(nameNode),
+		reason: reasonNode ? extractDescription(reasonNode) : null
+	};
+}
+/**
+* Extract a SectionDefinition
+*/
+function extractSectionDefinition(node) {
+	const nameNode = getChildByType(node, "section_name");
+	if (!nameNode) throw new Error("Missing section_name in section_definition");
+	const optionalMarker = getChildByType(node, "optional_marker");
+	const descriptionNode = getOptionalChildByField(node, "description");
+	return {
+		...baseNode(node, "section_definition"),
+		name: extractSectionName(nameNode),
+		optional: optionalMarker !== null,
+		description: descriptionNode ? extractDescription(descriptionNode) : null
+	};
+}
+/**
+* Extract a SectionRemoval
+*/
+function extractSectionRemoval(node) {
+	const nameNode = getChildByType(node, "section_name");
+	if (!nameNode) throw new Error("Missing section_name in section_removal");
+	const reasonNode = getOptionalChildByField(node, "reason");
+	return {
+		...baseNode(node, "section_removal"),
+		name: extractSectionName(nameNode),
+		reason: reasonNode ? extractDescription(reasonNode) : null
+	};
+}
+/**
+* Extract a TypeExpression.
+* Returns a SyntaxErrorNode if an unknown type identifier is encountered.
+*/
+function extractTypeExpression(node) {
+	const child = node.namedChildren[0];
+	if (!child) throw new Error("Empty type_expression");
+	switch (child.type) {
+		case "primitive_type": return extractPrimitiveType(child);
+		case "literal_type": return extractLiteralType(child);
+		case "array_type": return extractArrayType(child);
+		case "union_type": return extractUnionType(child);
+		case "unknown_type": return createSyntaxError("unknown_type", `Unknown type '${child.text}'. Valid types: string, datetime, daterange, link, number`, child.text, child);
+		default: throw new Error(`Unknown type expression: ${child.type}`);
+	}
+}
+/**
+* Extract a PrimitiveType
+*/
+function extractPrimitiveType(node) {
+	return {
+		...baseNode(node, "primitive_type"),
+		name: node.text
+	};
+}
+/**
+* Extract a LiteralType
+*/
+function extractLiteralType(node) {
+	return {
+		...baseNode(node, "literal_type"),
+		value: stripQuotes(node.text)
+	};
+}
+/**
+* Extract an ArrayType.
+* Returns a SyntaxErrorNode if the element type is unknown.
+*/
+function extractArrayType(node) {
+	const child = node.namedChildren[0];
+	if (!child) throw new Error("Empty array_type");
+	let elementType;
+	if (child.type === "primitive_type") elementType = extractPrimitiveType(child);
+	else if (child.type === "literal_type") elementType = extractLiteralType(child);
+	else if (child.type === "unknown_type") return createSyntaxError("unknown_type", `Unknown type '${child.text}'. Valid types: string, datetime, daterange, link, number`, node.text, node);
+	else if (child.type === "paren_type") {
+		const innerTypeExpr = child.namedChildren[0];
+		if (!innerTypeExpr) throw new Error("Empty paren_type");
+		const extracted = extractTypeExpression(innerTypeExpr);
+		if (extracted.type === "syntax_error") return extracted;
+		if (extracted.type !== "union_type") throw new Error(`Unexpected paren_type content: ${extracted.type}`);
+		elementType = extracted;
+	} else throw new Error(`Invalid array element type: ${child.type}`);
+	return {
+		...baseNode(node, "array_type"),
+		elementType
+	};
+}
+/**
+* Extract a UnionType.
+* Returns a SyntaxErrorNode if any member is an unknown type.
+*/
+function extractUnionType(node) {
+	const members = [];
+	for (const child of node.namedChildren) {
+		if (!child) continue;
+		switch (child.type) {
+			case "primitive_type":
+				members.push(extractPrimitiveType(child));
+				break;
+			case "literal_type":
+				members.push(extractLiteralType(child));
+				break;
+			case "array_type": {
+				const arrayType = extractArrayType(child);
+				if (arrayType.type === "syntax_error") return arrayType;
+				members.push(arrayType);
+				break;
+			}
+			case "unknown_type": return createSyntaxError("unknown_type", `Unknown type '${child.text}'. Valid types: string, datetime, daterange, link, number`, node.text, node);
+		}
+	}
+	return {
+		...baseNode(node, "union_type"),
+		members
+	};
+}
+/**
+* Extract a Metadata entry
+*/
+function extractMetadata(node) {
+	const keyNode = getChildByField(node, "key");
+	const valueNode = getChildByField(node, "value");
+	return {
+		...baseNode(node, "metadata"),
+		key: extractKey(keyNode),
+		value: extractValue(valueNode)
+	};
+}
+/**
+* Extract Content
+*/
+function extractContent(node) {
+	const children = [];
+	for (const child of node.namedChildren) {
+		if (!child) continue;
+		if (child.type === "markdown_header") children.push(extractMarkdownHeader(child));
+		else if (child.type === "content_line") children.push(extractContentLine(child));
+	}
+	return {
+		...baseNode(node, "content"),
+		children
+	};
+}
+/**
+* Extract a MarkdownHeader
+*/
+function extractMarkdownHeader(node) {
+	const raw = node.text;
+	const trimmedRight = raw.replace(/[ \t]+$/, "");
+	const trimDelta = raw.length - trimmedRight.length;
+	const base = baseNode(node, "markdown_header");
+	return {
+		...base,
+		location: trimDelta === 0 ? base.location : {
+			...base.location,
+			endIndex: base.location.endIndex - trimDelta,
+			endPosition: {
+				...base.location.endPosition,
+				column: Math.max(0, base.location.endPosition.column - trimDelta)
+			}
+		},
+		text: raw.trim()
+	};
+}
+/**
+* Extract a ContentLine
+*/
+function extractContentLine(node) {
+	return {
+		...baseNode(node, "content_line"),
+		text: node.text.trim()
+	};
+}
+function extractTimestamp(node) {
+	return buildTimestamp(node);
+}
+function extractTitle(node) {
+	return {
+		...baseNode(node, "title"),
+		value: stripQuotes(node.text)
+	};
+}
+function extractLink(node) {
+	const text = node.text.trim();
+	return {
+		...baseNode(node, "link"),
+		id: text.slice(1)
+	};
+}
+function extractTag(node) {
+	const text = node.text.trim();
+	return {
+		...baseNode(node, "tag"),
+		name: text.slice(1)
+	};
+}
+function extractIdentifier(node) {
+	return {
+		...baseNode(node, "identifier"),
+		value: node.text
+	};
+}
+function extractKey(node) {
+	return {
+		...baseNode(node, "key"),
+		value: node.text
+	};
+}
+function extractValue(node) {
+	const child = node.namedChildren[0];
+	if (!child) return {
+		...baseNode(node, "value"),
+		raw: node.text.trim(),
+		content: {
+			...baseNode(node, "quoted_value"),
+			value: node.text.trim()
+		}
+	};
+	return {
+		...baseNode(node, "value"),
+		raw: node.text.trim(),
+		content: extractValueContent(child)
+	};
+}
+/**
+* Extract typed value content from a child node of value
+*/
+function extractValueContent(node) {
+	switch (node.type) {
+		case "quoted_value": return extractQuotedValue(node);
+		case "link": return {
+			...baseNode(node, "link_value"),
+			link: extractLink(node)
+		};
+		case "datetime_value": return extractDatetimeValue(node);
+		case "daterange": return {
+			...baseNode(node, "daterange"),
+			raw: node.text.trim()
+		};
+		case "number_value": return {
+			...baseNode(node, "number_value"),
+			raw: node.text.trim(),
+			value: parseFloat(node.text.trim())
+		};
+		case "value_array": return extractValueArray(node);
+		case "query": return {
+			...baseNode(node, "query_value"),
+			query: extractQuery(node)
+		};
+		default: return {
+			...baseNode(node, "quoted_value"),
+			value: node.text.trim()
+		};
+	}
+}
+/**
+* Extract a datetime value with its split components
+*/
+function extractDatetimeValue(node) {
+	const dateNode = node.childForFieldName("date");
+	const timeNode = node.childForFieldName("time");
+	const tzNode = node.childForFieldName("tz");
+	return {
+		...baseNode(node, "datetime_value"),
+		value: node.text.trim(),
+		date: dateNode?.text ?? "",
+		time: timeNode?.text ?? null,
+		tz: tzNode?.text ?? null
+	};
+}
+function extractQuotedValue(node) {
+	return {
+		...baseNode(node, "quoted_value"),
+		value: stripQuotes(node.text)
+	};
+}
+function extractValueArray(node) {
+	const elements = [];
+	for (const child of node.namedChildren) {
+		if (!child) continue;
+		if (child.type === "link") elements.push(extractLink(child));
+		else if (child.type === "quoted_value") elements.push(extractQuotedValue(child));
+		else if (child.type === "datetime_value") elements.push(extractDatetimeValue(child));
+		else if (child.type === "daterange") elements.push({
+			...baseNode(child, "daterange"),
+			raw: child.text.trim()
+		});
+		else if (child.type === "number_value") elements.push({
+			...baseNode(child, "number_value"),
+			raw: child.text.trim(),
+			value: parseFloat(child.text.trim())
+		});
+		else if (child.type === "query") elements.push(extractQuery(child));
+	}
+	return {
+		...baseNode(node, "value_array"),
+		elements
+	};
+}
+function extractQuery(node) {
+	const entityNode = node.childForFieldName("entity");
+	const conditionsNode = node.childForFieldName("conditions");
+	let entityText = "";
+	if (entityNode) {
+		const innerEntity = entityNode.namedChildren[0];
+		entityText = innerEntity ? innerEntity.text : entityNode.text;
+	}
+	const conditions = [];
+	if (conditionsNode) for (const child of conditionsNode.namedChildren) {
+		if (!child) continue;
+		if (child.type === "query_condition") {
+			const condition = extractQueryCondition(child);
+			if (condition) conditions.push(condition);
+		}
+	}
+	return {
+		...baseNode(node, "query"),
+		entity: entityText,
+		conditions
+	};
+}
+function extractQueryCondition(node) {
+	const child = node.namedChildren[0];
+	if (!child) return null;
+	switch (child.type) {
+		case "field_condition": {
+			const fieldNode = child.childForFieldName("field");
+			const valueNode = child.childForFieldName("value");
+			let fieldText = "";
+			if (fieldNode) {
+				const innerField = fieldNode.namedChildren[0];
+				fieldText = innerField ? innerField.text : fieldNode.text;
+			}
+			let valueText = "";
+			if (valueNode) if (valueNode.type === "link") valueText = valueNode.text;
+			else if (valueNode.type === "quoted_value") valueText = valueNode.text;
+			else {
+				const inner = valueNode.namedChildren[0];
+				valueText = inner ? inner.text : valueNode.text;
+			}
+			return {
+				...baseNode(child, "field_condition"),
+				field: fieldText,
+				value: valueText
+			};
+		}
+		case "tag_condition": {
+			const tagNode = getChildByType(child, "tag");
+			return {
+				...baseNode(child, "tag_condition"),
+				tag: tagNode ? tagNode.text.slice(1) : ""
+			};
+		}
+		case "link_condition": {
+			const linkNode = getChildByType(child, "link");
+			return {
+				...baseNode(child, "link_condition"),
+				linkId: linkNode ? linkNode.text.slice(1) : ""
+			};
+		}
+		default: return null;
+	}
+}
+function extractFieldName(node) {
+	return {
+		...baseNode(node, "field_name"),
+		value: node.text.trim()
+	};
+}
+function extractSectionName(node) {
+	return {
+		...baseNode(node, "section_name"),
+		value: node.text.trim()
+	};
+}
+function extractDescription(node) {
+	return {
+		...baseNode(node, "description"),
+		value: stripQuotes(node.text)
+	};
+}
+function extractDefaultValue(node) {
+	const child = node.namedChildren[0];
+	if (!child) throw new Error("Empty default_value");
+	let content;
+	switch (child.type) {
+		case "quoted_value":
+			content = extractQuotedValue(child);
+			break;
+		case "link":
+			content = extractLink(child);
+			break;
+		case "datetime_value":
+			content = extractDatetimeValue(child);
+			break;
+		case "number_value":
+			content = {
+				...baseNode(child, "number_value"),
+				raw: child.text.trim(),
+				value: parseFloat(child.text.trim())
+			};
+			break;
+		default: throw new Error(`Unknown default_value child type: ${child.type}`);
+	}
+	return {
+		...baseNode(node, "default_value"),
+		raw: node.text,
+		content
+	};
+}
+
+//#endregion
+export { extractFieldName, extractIdentifier, extractKey, extractLink, extractSectionName, extractSourceFile, extractTag, extractTimestamp, extractTypeExpression };
+//# sourceMappingURL=extract.js.map