@rejot-dev/thalo 0.0.0

package/dist/services/hover.js

@@ -0,0 +1,669 @@
+import { toFileLocation } from "../source-map.js";
+import { formatTimestamp } from "../formatters.js";
+import { TypeExpr } from "../schema/registry.js";
+
+//#region src/services/hover.ts
+/**
+* Get tags from an entry
+*/
+function getEntryTags(entry) {
+	switch (entry.type) {
+		case "instance_entry": return entry.header.tags.map((t) => t.name);
+		case "schema_entry": return entry.header.tags.map((t) => t.name);
+		case "synthesis_entry": return entry.header.tags.map((t) => t.name);
+		case "actualize_entry": return [];
+	}
+}
+/**
+* Format an entry for hover display
+*/
+function formatEntryHover(entry, file) {
+	switch (entry.type) {
+		case "instance_entry": return formatInstanceEntry(entry, file);
+		case "synthesis_entry": return formatSynthesisEntry(entry, file);
+		case "actualize_entry": return formatActualizeEntry(entry, file);
+		case "schema_entry": return formatSchemaEntry(entry, file);
+	}
+}
+/**
+* Format an instance entry for hover
+*/
+function formatInstanceEntry(entry, file) {
+	const lines = [];
+	const title = entry.header.title?.value ?? "(no title)";
+	const timestamp = formatTimestamp(entry.header.timestamp);
+	lines.push(`### ${title}`);
+	lines.push("");
+	lines.push(`**${entry.header.directive}** ${entry.header.entity} • ${timestamp}`);
+	const tags = getEntryTags(entry);
+	if (tags.length > 0) {
+		lines.push("");
+		lines.push(`Tags: ${tags.map((t) => `\`#${t}\``).join(" ")}`);
+	}
+	if (entry.header.link) {
+		lines.push("");
+		lines.push(`Link: \`^${entry.header.link.id}\``);
+	}
+	const metadataToShow = [
+		"subject",
+		"type",
+		"confidence",
+		"status",
+		"ref-type"
+	];
+	const shownMetadata = [];
+	for (const key of metadataToShow) {
+		const meta = entry.metadata.find((m) => m.key.value === key);
+		if (meta) shownMetadata.push(`**${key}:** ${meta.value.raw}`);
+	}
+	if (shownMetadata.length > 0) {
+		lines.push("");
+		lines.push(shownMetadata.join(" • "));
+	}
+	lines.push("");
+	lines.push(`*${file}*`);
+	return lines.join("\n");
+}
+/**
+* Format a schema entry for hover
+*/
+function formatSchemaEntry(entry, file) {
+	const lines = [];
+	const title = entry.header.title?.value ?? "(no title)";
+	const timestamp = formatTimestamp(entry.header.timestamp);
+	const entityName = entry.header.entityName.value;
+	lines.push(`### ${title}`);
+	lines.push("");
+	lines.push(`**${entry.header.directive}** \`${entityName}\` • ${timestamp}`);
+	const tags = getEntryTags(entry);
+	if (tags.length > 0) {
+		lines.push("");
+		lines.push(`Tags: ${tags.map((t) => `\`#${t}\``).join(" ")}`);
+	}
+	const fields = entry.metadataBlock?.fields ?? [];
+	if (fields.length > 0) {
+		lines.push("");
+		lines.push(`**Fields:** ${fields.map((f) => `\`${f.name.value}\``).join(", ")}`);
+	}
+	const sections = entry.sectionsBlock?.sections ?? [];
+	if (sections.length > 0) {
+		lines.push("");
+		lines.push(`**Sections:** ${sections.map((s) => `\`${s.name.value}\``).join(", ")}`);
+	}
+	lines.push("");
+	lines.push(`*${file}*`);
+	return lines.join("\n");
+}
+/**
+* Format a synthesis entry for hover
+*/
+function formatSynthesisEntry(entry, file) {
+	const lines = [];
+	const title = entry.header.title?.value ?? "(no title)";
+	const timestamp = formatTimestamp(entry.header.timestamp);
+	lines.push(`### ${title}`);
+	lines.push("");
+	lines.push(`**define-synthesis** synthesis • ${timestamp}`);
+	const tags = getEntryTags(entry);
+	if (tags.length > 0) {
+		lines.push("");
+		lines.push(`Tags: ${tags.map((t) => `\`#${t}\``).join(" ")}`);
+	}
+	const sourcesMeta = entry.metadata.find((m) => m.key.value === "sources");
+	if (sourcesMeta && sourcesMeta.value.content.type === "query_value") {
+		lines.push("");
+		lines.push(`**Sources:** ${sourcesMeta.value.content.query.entity}`);
+	}
+	lines.push("");
+	lines.push(`*${file}*`);
+	return lines.join("\n");
+}
+/**
+* Format an actualize entry for hover
+*/
+function formatActualizeEntry(entry, file) {
+	const lines = [];
+	const timestamp = formatTimestamp(entry.header.timestamp);
+	lines.push(`### actualize-synthesis`);
+	lines.push("");
+	lines.push(`**actualize-synthesis** ^${entry.header.target.id} • ${timestamp}`);
+	const updated = entry.metadata.find((m) => m.key.value === "updated");
+	if (updated) {
+		lines.push("");
+		lines.push(`**Updated:** ${updated.value.raw}`);
+	}
+	lines.push("");
+	lines.push(`*${file}*`);
+	return lines.join("\n");
+}
+/**
+* Get documentation for a directive
+*/
+function getDirectiveDocumentation(directive) {
+	switch (directive) {
+		case "create": return [
+			"### `create` directive",
+			"",
+			"Creates a new instance entry.",
+			"",
+			"**Syntax:**",
+			"```",
+			"{timestamp} create {entity} \"Title\" [^link-id] [#tags...]",
+			"  {key}: {value}",
+			"  ...",
+			"```",
+			"",
+			"Add an explicit `^link-id` for cross-referencing.",
+			"",
+			"**Entities:** `journal`, `lore`, `opinion`, `reference`"
+		].join("\n");
+		case "update": return [
+			"### `update` directive",
+			"",
+			"Updates an existing entry, typically to revise opinions or add information.",
+			"",
+			"**Syntax:**",
+			"```",
+			"{timestamp} update {entity} \"Title\" [^link-id] [#tags...]",
+			"  supersedes: ^previous-entry",
+			"  ...",
+			"```",
+			"",
+			"Use `supersedes:` metadata to link to the entry being updated.",
+			"",
+			"**Entities:** `journal`, `lore`, `opinion`, `reference`"
+		].join("\n");
+		case "define-entity": return [
+			"### `define-entity` directive",
+			"",
+			"Defines a new entity schema with fields and sections.",
+			"",
+			"**Syntax:**",
+			"```",
+			"{timestamp} define-entity {name} \"Description\"",
+			"  # Metadata",
+			"  field-name: type ; \"description\"",
+			"  optional-field?: type = default ; \"description\"",
+			"  # Sections",
+			"  SectionName ; \"description\"",
+			"  OptionalSection? ; \"description\"",
+			"```",
+			"",
+			"**Field types:** `string`, `datetime`, `daterange`, `number`, `link`, `\"literal\"`, unions (`|`), arrays (`[]`)"
+		].join("\n");
+		case "alter-entity": return [
+			"### `alter-entity` directive",
+			"",
+			"Modifies an existing entity schema.",
+			"",
+			"**Syntax:**",
+			"```",
+			"{timestamp} alter-entity {name} \"Description of change\"",
+			"  # Metadata",
+			"  new-field: type ; \"add a field\"",
+			"  # Remove Metadata",
+			"  old-field ; \"reason for removal\"",
+			"  # Sections",
+			"  NewSection ; \"add a section\"",
+			"  # Remove Sections",
+			"  OldSection ; \"reason for removal\"",
+			"```",
+			"",
+			"All blocks are optional. Only include what you're changing."
+		].join("\n");
+		case "define-synthesis": return [
+			"### `define-synthesis` directive",
+			"",
+			"Defines a synthesis operation that queries entries and generates content via LLM.",
+			"",
+			"**Syntax:**",
+			"```",
+			"{timestamp} define-synthesis \"Title\" ^link-id [#tags...]",
+			"  sources: {entity} where {conditions}",
+			"",
+			"  # Prompt",
+			"  Instructions for the LLM...",
+			"```",
+			"",
+			"**Query language:**",
+			"- `{entity} where {conditions}` — Query entries",
+			"- Conditions: `field = value`, `#tag`, `^link`",
+			"- Multiple queries: comma-separated",
+			"",
+			"**Example:**",
+			"```",
+			"2026-01-05T10:00 define-synthesis \"Career Summary\" ^career-summary",
+			"  sources: lore where subject = ^self and #career",
+			"",
+			"  # Prompt",
+			"  Write a professional career summary from these lore entries.",
+			"```"
+		].join("\n");
+		case "actualize-synthesis": return [
+			"### `actualize-synthesis` directive",
+			"",
+			"Triggers a synthesis to regenerate its output based on current data.",
+			"",
+			"**Syntax:**",
+			"```",
+			"{timestamp} actualize-synthesis ^target-synthesis",
+			"  updated: {timestamp}",
+			"```",
+			"",
+			"**Required metadata:**",
+			"- `updated:` — Timestamp when the synthesis was actualized",
+			"",
+			"**Example:**",
+			"```",
+			"2026-01-05T15:30 actualize-synthesis ^career-summary",
+			"  updated: 2026-01-05T15:30",
+			"```"
+		].join("\n");
+		default: return null;
+	}
+}
+/**
+* Format an entity schema for hover display
+*/
+function formatEntitySchema(schema) {
+	const lines = [];
+	lines.push(`### Entity: \`${schema.name}\``);
+	lines.push("");
+	lines.push(schema.description);
+	lines.push("");
+	if (schema.fields.size > 0) {
+		lines.push("**Metadata Fields:**");
+		lines.push("");
+		for (const [, field] of schema.fields) {
+			const typeStr = TypeExpr.toString(field.type);
+			const opt = field.optional ? "?" : "";
+			const desc = field.description ? ` — ${field.description}` : "";
+			const def = field.defaultValue ? ` (default: \`${field.defaultValue}\`)` : "";
+			lines.push(`- \`${field.name}${opt}\`: \`${typeStr}\`${def}${desc}`);
+		}
+		lines.push("");
+	}
+	if (schema.sections.size > 0) {
+		lines.push("**Sections:**");
+		lines.push("");
+		for (const [, section] of schema.sections) {
+			const opt = section.optional ? " (optional)" : "";
+			const desc = section.description ? ` — ${section.description}` : "";
+			lines.push(`- \`# ${section.name}\`${opt}${desc}`);
+		}
+		lines.push("");
+	}
+	lines.push(`*Defined at ${schema.definedAt} in ${schema.definedIn}*`);
+	return lines.join("\n");
+}
+/**
+* Format a field schema for hover display
+*/
+function formatFieldHover(field, entityName) {
+	const lines = [];
+	const typeStr = TypeExpr.toString(field.type);
+	const opt = field.optional ? " (optional)" : " (required)";
+	lines.push(`### Field: \`${field.name}\``);
+	lines.push("");
+	lines.push(`**Type:** \`${typeStr}\`${opt}`);
+	if (field.defaultValue) {
+		lines.push("");
+		lines.push(`**Default:** \`${field.defaultValue}\``);
+	}
+	if (field.description) {
+		lines.push("");
+		lines.push(field.description);
+	}
+	lines.push("");
+	lines.push(`*From entity \`${entityName}\`*`);
+	return lines.join("\n");
+}
+/**
+* Format a section schema for hover display
+*/
+function formatSectionHover(section, entityName) {
+	const lines = [];
+	const opt = section.optional ? " (optional)" : " (required)";
+	lines.push(`### Section: \`# ${section.name}\``);
+	lines.push("");
+	lines.push(`**Status:** ${opt.trim()}`);
+	if (section.description) {
+		lines.push("");
+		lines.push(section.description);
+	}
+	lines.push("");
+	lines.push(`*From entity \`${entityName}\`*`);
+	return lines.join("\n");
+}
+/**
+* Get documentation for a primitive type
+*/
+function getPrimitiveTypeDocumentation(typeName) {
+	switch (typeName) {
+		case "string": return [
+			"### Type: `string`",
+			"",
+			"Any text value. Can be quoted or unquoted in metadata.",
+			"",
+			"**Examples:**",
+			"```",
+			"author: \"Jane Doe\"",
+			"author: Jane Doe",
+			"```"
+		].join("\n");
+		case "datetime": return [
+			"### Type: `datetime`",
+			"",
+			"A date in ISO format (YYYY-MM-DD).",
+			"",
+			"**Format:** `YYYY-MM-DD`",
+			"",
+			"**Example:**",
+			"```",
+			"published: 2024-05-11",
+			"```",
+			"",
+			"Note: For partial dates (YYYY or YYYY-MM), use `daterange` type."
+		].join("\n");
+		case "daterange": return [
+			"### Type: `daterange`",
+			"",
+			"A range between two dates, using `~` separator.",
+			"",
+			"**Format:** `{date} ~ {date}`",
+			"",
+			"**Examples:**",
+			"```",
+			"date: 2020 ~ 2021",
+			"date: 2022-05 ~ 2024",
+			"date: 2024-01-01 ~ 2024-12-31",
+			"```"
+		].join("\n");
+		case "link": return [
+			"### Type: `link`",
+			"",
+			"A reference to another entry using its link ID.",
+			"",
+			"**Format:** `^{link-id}`",
+			"",
+			"Link IDs can be:",
+			"- Timestamps (implicit): `^2026-01-05T15:30`",
+			"- Explicit IDs: `^opinion-ts-enums`",
+			"- Special: `^self` (reference to self/author)",
+			"",
+			"**Example:**",
+			"```",
+			"supersedes: ^2026-01-05T15:30",
+			"subject: ^self",
+			"```"
+		].join("\n");
+		case "number": return [
+			"### Type: `number`",
+			"",
+			"A numeric value (integer or decimal).",
+			"",
+			"**Examples:**",
+			"```",
+			"rating: 5",
+			"score: 4.5",
+			"count: -10",
+			"```"
+		].join("\n");
+		default: return null;
+	}
+}
+/**
+* Format tag hover information
+*/
+function formatTagHover(tag, entries) {
+	const lines = [];
+	lines.push(`### Tag: \`#${tag}\``);
+	lines.push("");
+	lines.push(`Used in **${entries.length}** ${entries.length === 1 ? "entry" : "entries"}:`);
+	lines.push("");
+	const toShow = entries.slice(0, 5);
+	for (const { entry } of toShow) {
+		let title;
+		let timestamp;
+		switch (entry.type) {
+			case "instance_entry":
+				title = entry.header.title?.value ?? "(no title)";
+				timestamp = formatTimestamp(entry.header.timestamp);
+				break;
+			case "synthesis_entry":
+				title = entry.header.title?.value ?? "(no title)";
+				timestamp = formatTimestamp(entry.header.timestamp);
+				break;
+			case "actualize_entry":
+				title = `actualize-synthesis ^${entry.header.target.id}`;
+				timestamp = formatTimestamp(entry.header.timestamp);
+				break;
+			case "schema_entry":
+				title = entry.header.title?.value ?? "(no title)";
+				timestamp = formatTimestamp(entry.header.timestamp);
+				break;
+		}
+		lines.push(`- ${title} *(${timestamp})*`);
+	}
+	if (entries.length > 5) lines.push(`- *...and ${entries.length - 5} more*`);
+	return lines.join("\n");
+}
+/**
+* Format timestamp hover
+*/
+function formatTimestampHover(timestamp, entry, _file) {
+	const lines = [];
+	lines.push(`### Timestamp: \`${timestamp}\``);
+	lines.push("");
+	if (entry) {
+		lines.push("This timestamp identifies an entry:");
+		lines.push("");
+		let title;
+		let directiveInfo;
+		switch (entry.type) {
+			case "instance_entry":
+				title = entry.header.title?.value ?? "(no title)";
+				directiveInfo = `\`${entry.header.directive}\` ${entry.header.entity}`;
+				break;
+			case "synthesis_entry":
+				title = entry.header.title?.value ?? "(no title)";
+				directiveInfo = "`define-synthesis` synthesis";
+				break;
+			case "actualize_entry":
+				title = `actualize-synthesis ^${entry.header.target.id}`;
+				directiveInfo = `\`actualize-synthesis\` ^${entry.header.target.id}`;
+				break;
+			case "schema_entry":
+				title = entry.header.title?.value ?? "(no title)";
+				directiveInfo = `\`${entry.header.directive}\` ${entry.header.entityName.value}`;
+				break;
+		}
+		lines.push(`**${title}**`);
+		lines.push("");
+		lines.push(directiveInfo);
+		lines.push("");
+		lines.push(`Reference with: \`^${timestamp}\``);
+	} else {
+		lines.push("Entry timestamp.");
+		lines.push("");
+		lines.push("Add an explicit `^link-id` after the title to enable cross-referencing.");
+	}
+	return lines.join("\n");
+}
+/**
+* Get hover information for a node context.
+*
+* This function takes a semantic node context (from findNodeAtPosition) and
+* returns hover information including markdown content and an optional range.
+*
+* @param workspace - The workspace to look up entries, schemas, etc.
+* @param context - The node context from findNodeAtPosition
+* @returns Hover result with markdown content, or null if no hover info
+*/
+function getHoverInfo(workspace, context) {
+	switch (context.kind) {
+		case "link": {
+			const definition = workspace.getLinkDefinition(context.linkId);
+			if (definition) return {
+				content: formatEntryHover(definition.entry, definition.file),
+				range: toFileLocation(context.sourceMap, context.node.location)
+			};
+			return {
+				content: `⚠️ **Unknown link:** \`^${context.linkId}\`\n\nNo entry found with this ID.`,
+				range: toFileLocation(context.sourceMap, context.node.location)
+			};
+		}
+		case "tag": {
+			const entries = [];
+			for (const model of workspace.allModels()) for (const entry of model.ast.entries) if (getEntryTags(entry).includes(context.tagName)) entries.push({
+				entry,
+				file: model.file
+			});
+			if (entries.length > 0) return {
+				content: formatTagHover(context.tagName, entries),
+				range: toFileLocation(context.sourceMap, context.node.location)
+			};
+			return null;
+		}
+		case "directive": {
+			const doc = getDirectiveDocumentation(context.directive);
+			if (doc) return {
+				content: doc,
+				range: toFileLocation(context.sourceMap, context.location)
+			};
+			return null;
+		}
+		case "entity": {
+			const schema = workspace.schemaRegistry.get(context.entityName);
+			if (schema) return {
+				content: formatEntitySchema(schema),
+				range: toFileLocation(context.sourceMap, context.location)
+			};
+			return {
+				content: `⚠️ **Unknown entity:** \`${context.entityName}\`\n\nNo schema found. Define with \`define-entity\`.`,
+				range: toFileLocation(context.sourceMap, context.location)
+			};
+		}
+		case "schema_entity": {
+			const schema = workspace.schemaRegistry.get(context.entityName);
+			if (schema) return {
+				content: formatEntitySchema(schema),
+				range: toFileLocation(context.sourceMap, context.node.location)
+			};
+			return {
+				content: `**Entity:** \`${context.entityName}\`\n\n*Being defined in this entry*`,
+				range: toFileLocation(context.sourceMap, context.node.location)
+			};
+		}
+		case "metadata_key":
+			if (context.entityContext) {
+				const schema = workspace.schemaRegistry.get(context.entityContext);
+				if (schema) {
+					const field = schema.fields.get(context.key);
+					if (field) return {
+						content: formatFieldHover(field, context.entityContext),
+						range: toFileLocation(context.sourceMap, context.node.location)
+					};
+				}
+			}
+			return {
+				content: `**Field:** \`${context.key}\`\n\n*Not defined in entity schema*`,
+				range: toFileLocation(context.sourceMap, context.node.location)
+			};
+		case "timestamp": {
+			let foundEntry;
+			let foundFile;
+			for (const model of workspace.allModels()) {
+				for (const entry of model.ast.entries) {
+					let ts;
+					switch (entry.type) {
+						case "instance_entry":
+							ts = entry.header.timestamp;
+							break;
+						case "schema_entry":
+							ts = entry.header.timestamp;
+							break;
+						case "synthesis_entry":
+							ts = entry.header.timestamp;
+							break;
+						case "actualize_entry":
+							ts = entry.header.timestamp;
+							break;
+					}
+					if (formatTimestamp(ts) === context.value || ts.value === context.value) {
+						foundEntry = entry;
+						foundFile = model.file;
+						break;
+					}
+				}
+				if (foundEntry) break;
+			}
+			return {
+				content: formatTimestampHover(context.value, foundEntry, foundFile),
+				range: toFileLocation(context.sourceMap, context.node.location)
+			};
+		}
+		case "type": {
+			const doc = getPrimitiveTypeDocumentation(context.typeName);
+			if (doc) return {
+				content: doc,
+				range: toFileLocation(context.sourceMap, context.node.location)
+			};
+			return null;
+		}
+		case "section_header":
+			if (context.entityContext) {
+				const schema = workspace.schemaRegistry.get(context.entityContext);
+				if (schema) {
+					const section = schema.sections.get(context.sectionName);
+					if (section) return {
+						content: formatSectionHover(section, context.entityContext),
+						range: toFileLocation(context.sourceMap, context.location)
+					};
+				}
+			}
+			return {
+				content: `**Section:** \`# ${context.sectionName}\`\n\n*Not defined in entity schema*`,
+				range: toFileLocation(context.sourceMap, context.location)
+			};
+		case "field_name":
+			if (context.entityContext) {
+				const schema = workspace.schemaRegistry.get(context.entityContext);
+				if (schema) {
+					const field = schema.fields.get(context.fieldName);
+					if (field) return {
+						content: formatFieldHover(field, context.entityContext),
+						range: toFileLocation(context.sourceMap, context.node.location)
+					};
+				}
+			}
+			return {
+				content: `**Field:** \`${context.fieldName}\`\n\n*Being defined in this schema*`,
+				range: toFileLocation(context.sourceMap, context.node.location)
+			};
+		case "section_name":
+			if (context.entityContext) {
+				const schema = workspace.schemaRegistry.get(context.entityContext);
+				if (schema) {
+					const section = schema.sections.get(context.sectionName);
+					if (section) return {
+						content: formatSectionHover(section, context.entityContext),
+						range: toFileLocation(context.sourceMap, context.node.location)
+					};
+				}
+			}
+			return {
+				content: `**Section:** \`# ${context.sectionName}\`\n\n*Being defined in this schema*`,
+				range: toFileLocation(context.sourceMap, context.node.location)
+			};
+		case "title": return {
+			content: `**Title:** "${context.title}"`,
+			range: toFileLocation(context.sourceMap, context.location)
+		};
+		default: return null;
+	}
+}
+
+//#endregion
+export { formatActualizeEntry, formatEntitySchema, formatEntryHover, formatFieldHover, formatInstanceEntry, formatSchemaEntry, formatSectionHover, formatSynthesisEntry, formatTagHover, formatTimestampHover, getDirectiveDocumentation, getHoverInfo, getPrimitiveTypeDocumentation };
+//# sourceMappingURL=hover.js.map