@rejot-dev/thalo 0.0.0

package/dist/services/change-tracker/git-tracker.d.ts

@@ -0,0 +1,59 @@
+import { Workspace } from "../../model/workspace.js";
+import { Query } from "../query.js";
+import { ChangeMarker, ChangeTracker, ChangeTrackerOptions, ChangedEntriesResult } from "./change-tracker.js";
+
+//#region src/services/change-tracker/git-tracker.d.ts
+
+/**
+ * Git-based change tracker.
+ *
+ * Uses git to determine which entries have changed since the last actualization.
+ * This allows detection of in-place edits, not just new entries.
+ *
+ * Algorithm:
+ * 1. Get files modified since the marker commit
+ * 2. For each modified .thalo file:
+ *    - Get file content at the marker commit
+ *    - Parse both versions
+ *    - Compare entries by identity (linkId or timestamp)
+ *    - Mark entries as changed if they're new or content differs
+ */
+declare class GitChangeTracker implements ChangeTracker {
+  readonly type: "git";
+  private cwd;
+  private force;
+  private blameIgnoreRevs;
+  constructor(options?: ChangeTrackerOptions);
+  private getIgnoreRevs;
+  getCurrentMarker(): Promise<ChangeMarker>;
+  getChangedEntries(workspace: Workspace, queries: Query[], marker: ChangeMarker | null): Promise<ChangedEntriesResult>;
+  /**
+   * Get all files that contain entries matching the queries.
+   */
+  private getSourceFiles;
+  /**
+   * Get all entries matching the queries (for first run or fallback)
+   */
+  private getAllMatchingEntries;
+  /**
+   * Get changed entries in a specific file.
+   *
+   * Note: This method only returns entries that exist in the current version of the file.
+   * Deleted entries are intentionally not tracked because for the actualization use case,
+   * we want entries to include in the synthesis prompt - deleted entries don't exist
+   * and therefore don't need to be synthesized.
+   */
+  private getChangedEntriesInFile;
+  /**
+   * Find a model in the workspace by relative path.
+   * Normalizes path separators for cross-platform compatibility.
+   *
+   * Handles cases where:
+   * - Git returns paths relative to repo root (e.g., "project/entries.thalo")
+   * - Workspace has files relative to cwd (e.g., "entries.thalo")
+   */
+  private findModelByRelativePath;
+}
+//#endregion
+export { GitChangeTracker };
+//# sourceMappingURL=git-tracker.d.ts.map

package/dist/services/change-tracker/git-tracker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"git-tracker.d.ts","names":[],"sources":["../../../src/services/change-tracker/git-tracker.ts"],"sourcesContent":[],"mappings":";;;;;;;;AA0CA;;;;;;;;;;;;cAAa,gBAAA,YAA4B;;;;;wBAMlB;;sBAaK,QAAQ;+BAYrB,oBACF,iBACD,sBACP,QAAQ"}

package/dist/services/change-tracker/git-tracker.js

@@ -0,0 +1,218 @@
+import { entryMatchesQuery } from "../query.js";
+import { UncommittedChangesError } from "./change-tracker.js";
+import { extractSourceFile } from "../../ast/extract.js";
+import { parseDocument } from "../../parser.js";
+import { getEntryIdentity, serializeIdentity } from "../../merge/entry-matcher.js";
+import { entriesEqual } from "../../merge/entry-merger.js";
+import { commitExists, detectGitContext, getBlameCommitsForLineRange, getBlameIgnoreRevs, getCurrentCommit, getFileAtCommit, getFilesChangedSince, getUncommittedFiles, isCommitAncestorOf } from "../../git/git.js";
+
+//#region src/services/change-tracker/git-tracker.ts
+/**
+* Git-based change tracker.
+*
+* Uses git to determine which entries have changed since the last actualization.
+* This allows detection of in-place edits, not just new entries.
+*
+* Algorithm:
+* 1. Get files modified since the marker commit
+* 2. For each modified .thalo file:
+*    - Get file content at the marker commit
+*    - Parse both versions
+*    - Compare entries by identity (linkId or timestamp)
+*    - Mark entries as changed if they're new or content differs
+*/
+var GitChangeTracker = class {
+	type = "git";
+	cwd;
+	force;
+	blameIgnoreRevs;
+	constructor(options = {}) {
+		this.cwd = options.cwd ?? process.cwd();
+		this.force = options.force ?? false;
+	}
+	async getIgnoreRevs() {
+		if (this.blameIgnoreRevs !== void 0) return this.blameIgnoreRevs;
+		this.blameIgnoreRevs = await getBlameIgnoreRevs(this.cwd);
+		return this.blameIgnoreRevs;
+	}
+	async getCurrentMarker() {
+		const commit = await getCurrentCommit(this.cwd);
+		if (!commit) throw new Error("Not in a git repository");
+		return {
+			type: "git",
+			value: commit
+		};
+	}
+	async getChangedEntries(workspace, queries, marker) {
+		if (!(await detectGitContext(this.cwd)).isGitRepo) throw new Error("Not in a git repository");
+		const currentMarker = await this.getCurrentMarker();
+		const sourceFiles = this.getSourceFiles(workspace, queries);
+		if (!this.force && sourceFiles.length > 0) {
+			const uncommitted = await getUncommittedFiles(this.cwd, sourceFiles);
+			if (uncommitted.length > 0) throw new UncommittedChangesError(uncommitted);
+		}
+		if (!marker) return {
+			entries: this.getAllMatchingEntries(workspace, queries),
+			currentMarker
+		};
+		if (marker.type === "ts") return {
+			entries: this.getAllMatchingEntries(workspace, queries),
+			currentMarker
+		};
+		if (!await commitExists(marker.value, this.cwd)) return {
+			entries: this.getAllMatchingEntries(workspace, queries),
+			currentMarker
+		};
+		const thaloChanges = (await getFilesChangedSince(marker.value, this.cwd)).filter((f) => f.path.endsWith(".thalo") || f.path.endsWith(".md"));
+		if (thaloChanges.length === 0) return {
+			entries: [],
+			currentMarker
+		};
+		const changedEntries = [];
+		const seenKeys = /* @__PURE__ */ new Set();
+		for (const change of thaloChanges) {
+			const entries = await this.getChangedEntriesInFile(workspace, change, marker.value, queries);
+			for (const entry of entries) {
+				const key = `${change.path}:${serializeIdentity(getEntryIdentity(entry))}`;
+				if (!seenKeys.has(key)) {
+					seenKeys.add(key);
+					changedEntries.push(entry);
+				}
+			}
+		}
+		return {
+			entries: changedEntries,
+			currentMarker
+		};
+	}
+	/**
+	* Get all files that contain entries matching the queries.
+	*/
+	getSourceFiles(workspace, queries) {
+		const files = /* @__PURE__ */ new Set();
+		for (const model of workspace.allModels()) for (const entry of model.ast.entries) {
+			if (entry.type !== "instance_entry") continue;
+			for (const query of queries) if (entryMatchesQuery(entry, query)) {
+				files.add(model.file);
+				break;
+			}
+		}
+		return Array.from(files);
+	}
+	/**
+	* Get all entries matching the queries (for first run or fallback)
+	*/
+	getAllMatchingEntries(workspace, queries) {
+		const results = [];
+		const seen = /* @__PURE__ */ new Set();
+		for (const model of workspace.allModels()) for (const entry of model.ast.entries) {
+			if (entry.type !== "instance_entry") continue;
+			const key = `${model.file}:${serializeIdentity(getEntryIdentity(entry))}`;
+			if (seen.has(key)) continue;
+			for (const query of queries) if (entryMatchesQuery(entry, query)) {
+				results.push(entry);
+				seen.add(key);
+				break;
+			}
+		}
+		return results;
+	}
+	/**
+	* Get changed entries in a specific file.
+	*
+	* Note: This method only returns entries that exist in the current version of the file.
+	* Deleted entries are intentionally not tracked because for the actualization use case,
+	* we want entries to include in the synthesis prompt - deleted entries don't exist
+	* and therefore don't need to be synthesized.
+	*/
+	async getChangedEntriesInFile(workspace, change, markerCommit, queries) {
+		const model = this.findModelByRelativePath(workspace, change.path);
+		if (!model) return [];
+		const currentEntries = model.ast.entries.filter((e) => e.type === "instance_entry");
+		const ignoreRevs = await this.getIgnoreRevs();
+		if (ignoreRevs) {
+			const changed$1 = [];
+			function locationToLineRange(entry) {
+				const startRow = entry.location.startPosition.row;
+				const endRow = entry.location.endPosition.row;
+				const endCol = entry.location.endPosition.column;
+				const startLine = startRow + 1;
+				const endLine = endCol === 0 ? endRow : endRow + 1;
+				return {
+					startLine,
+					endLine: Math.max(startLine, endLine)
+				};
+			}
+			for (const entry of currentEntries) {
+				let matchesQuery = false;
+				for (const query of queries) if (entryMatchesQuery(entry, query)) {
+					matchesQuery = true;
+					break;
+				}
+				if (!matchesQuery) continue;
+				const { startLine, endLine } = locationToLineRange(entry);
+				const blamedCommits = await getBlameCommitsForLineRange(change.path, startLine, endLine, this.cwd, ignoreRevs);
+				let isChanged = false;
+				for (const commit of blamedCommits) if (!await isCommitAncestorOf(commit, markerCommit, this.cwd)) {
+					isChanged = true;
+					break;
+				}
+				if (isChanged) changed$1.push(entry);
+			}
+			return changed$1;
+		}
+		const pathAtCommit = change.oldPath ?? change.path;
+		const oldContent = await getFileAtCommit(pathAtCommit, markerCommit, this.cwd);
+		const oldEntryMap = /* @__PURE__ */ new Map();
+		if (oldContent) try {
+			const oldDoc = parseDocument(oldContent, { fileType: pathAtCommit.endsWith(".md") ? "markdown" : "thalo" });
+			for (const block of oldDoc.blocks) {
+				const oldAst = extractSourceFile(block.tree.rootNode);
+				for (const entry of oldAst.entries) {
+					const key = serializeIdentity(getEntryIdentity(entry));
+					oldEntryMap.set(key, entry);
+				}
+			}
+		} catch {}
+		const changed = [];
+		for (const entry of currentEntries) {
+			let matchesQuery = false;
+			for (const query of queries) if (entryMatchesQuery(entry, query)) {
+				matchesQuery = true;
+				break;
+			}
+			if (!matchesQuery) continue;
+			const key = serializeIdentity(getEntryIdentity(entry));
+			const oldEntry = oldEntryMap.get(key);
+			if (!oldEntry || !entriesEqual(oldEntry, entry)) changed.push(entry);
+		}
+		return changed;
+	}
+	/**
+	* Find a model in the workspace by relative path.
+	* Normalizes path separators for cross-platform compatibility.
+	*
+	* Handles cases where:
+	* - Git returns paths relative to repo root (e.g., "project/entries.thalo")
+	* - Workspace has files relative to cwd (e.g., "entries.thalo")
+	*/
+	findModelByRelativePath(workspace, relativePath) {
+		const normalizedRelative = relativePath.replace(/\\/g, "/");
+		const relativeParts = normalizedRelative.split("/");
+		for (const model of workspace.allModels()) {
+			const normalizedModel = model.file.replace(/\\/g, "/");
+			if (normalizedModel === normalizedRelative) return model;
+			const modelParts = normalizedModel.split("/");
+			if (relativeParts.length >= modelParts.length) {
+				if (relativeParts.slice(-modelParts.length).join("/") === normalizedModel) return model;
+			}
+			if (modelParts.length >= relativeParts.length) {
+				if (modelParts.slice(-relativeParts.length).join("/") === normalizedRelative) return model;
+			}
+		}
+	}
+};
+
+//#endregion
+export { GitChangeTracker };
+//# sourceMappingURL=git-tracker.js.map

package/dist/services/change-tracker/git-tracker.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"git-tracker.js","names":["changedEntries: InstanceEntry[]","results: InstanceEntry[]","changed: InstanceEntry[]","changed"],"sources":["../../../src/services/change-tracker/git-tracker.ts"],"sourcesContent":["import type { Entry, InstanceEntry } from \"../../ast/ast-types.js\";\nimport type { Query } from \"../query.js\";\nimport type { Workspace } from \"../../model/workspace.js\";\nimport {\n  detectGitContext,\n  getCurrentCommit,\n  getFilesChangedSince,\n  getFileAtCommit,\n  commitExists,\n  getUncommittedFiles,\n  getBlameIgnoreRevs,\n  getBlameCommitsForLineRange,\n  isCommitAncestorOf,\n  type FileChange,\n} from \"../../git/git.js\";\nimport { getEntryIdentity, serializeIdentity } from \"../../merge/entry-matcher.js\";\nimport { entriesEqual } from \"../../merge/entry-merger.js\";\nimport { entryMatchesQuery } from \"../query.js\";\nimport { parseDocument } from \"../../parser.js\";\nimport { extractSourceFile } from \"../../ast/extract.js\";\nimport type {\n  ChangeTracker,\n  ChangeMarker,\n  ChangedEntriesResult,\n  ChangeTrackerOptions,\n} from \"./change-tracker.js\";\nimport { UncommittedChangesError } from \"./change-tracker.js\";\n\n/**\n * Git-based change tracker.\n *\n * Uses git to determine which entries have changed since the last actualization.\n * This allows detection of in-place edits, not just new entries.\n *\n * Algorithm:\n * 1. Get files modified since the marker commit\n * 2. For each modified .thalo file:\n *    - Get file content at the marker commit\n *    - Parse both versions\n *    - Compare entries by identity (linkId or timestamp)\n *    - Mark entries as changed if they're new or content differs\n */\nexport class GitChangeTracker implements ChangeTracker {\n  readonly type = \"git\" as const;\n  private cwd: string;\n  private force: boolean;\n  private blameIgnoreRevs: string[] | null | undefined;\n\n  constructor(options: ChangeTrackerOptions = {}) {\n    this.cwd = options.cwd ?? process.cwd();\n    this.force = options.force ?? false;\n  }\n\n  private async getIgnoreRevs(): Promise<string[] | null> {\n    if (this.blameIgnoreRevs !== undefined) {\n      return this.blameIgnoreRevs;\n    }\n    this.blameIgnoreRevs = await getBlameIgnoreRevs(this.cwd);\n    return this.blameIgnoreRevs;\n  }\n\n  async getCurrentMarker(): Promise<ChangeMarker> {\n    const commit = await getCurrentCommit(this.cwd);\n    if (!commit) {\n      throw new Error(\"Not in a git repository\");\n    }\n    return {\n      type: \"git\",\n      value: commit,\n    };\n  }\n\n  async getChangedEntries(\n    workspace: Workspace,\n    queries: Query[],\n    marker: ChangeMarker | null,\n  ): Promise<ChangedEntriesResult> {\n    // Validate git context\n    const gitContext = await detectGitContext(this.cwd);\n    if (!gitContext.isGitRepo) {\n      throw new Error(\"Not in a git repository\");\n    }\n\n    const currentMarker = await this.getCurrentMarker();\n\n    // Find files that contain matching entries (source files for the queries)\n    const sourceFiles = this.getSourceFiles(workspace, queries);\n\n    // Check for uncommitted changes in source files (unless force is set)\n    if (!this.force && sourceFiles.length > 0) {\n      const uncommitted = await getUncommittedFiles(this.cwd, sourceFiles);\n      if (uncommitted.length > 0) {\n        throw new UncommittedChangesError(uncommitted);\n      }\n    }\n\n    // If no marker, return all matching entries (first run)\n    if (!marker) {\n      return {\n        entries: this.getAllMatchingEntries(workspace, queries),\n        currentMarker,\n      };\n    }\n\n    // If marker is a timestamp, we can still handle it by returning all entries\n    // (graceful fallback - user switched from timestamp to git tracking)\n    if (marker.type === \"ts\") {\n      return {\n        entries: this.getAllMatchingEntries(workspace, queries),\n        currentMarker,\n      };\n    }\n\n    // Validate the commit exists\n    const exists = await commitExists(marker.value, this.cwd);\n    if (!exists) {\n      // Commit doesn't exist (maybe rebased or squashed)\n      // Return all matching entries as fallback\n      return {\n        entries: this.getAllMatchingEntries(workspace, queries),\n        currentMarker,\n      };\n    }\n\n    // Get files changed since the marker commit (with rename detection)\n    const changedFiles = await getFilesChangedSince(marker.value, this.cwd);\n    const thaloChanges = changedFiles.filter(\n      (f) => f.path.endsWith(\".thalo\") || f.path.endsWith(\".md\"),\n    );\n\n    // If no thalo files changed, return empty\n    if (thaloChanges.length === 0) {\n      return {\n        entries: [],\n        currentMarker,\n      };\n    }\n\n    // Find changed entries\n    const changedEntries: InstanceEntry[] = [];\n    const seenKeys = new Set<string>();\n\n    for (const change of thaloChanges) {\n      const entries = await this.getChangedEntriesInFile(workspace, change, marker.value, queries);\n\n      for (const entry of entries) {\n        // Include file path in dedup key to handle timestamp-based identities across files\n        // (Link IDs are globally unique, but timestamps can collide across files)\n        const key = `${change.path}:${serializeIdentity(getEntryIdentity(entry))}`;\n        if (!seenKeys.has(key)) {\n          seenKeys.add(key);\n          changedEntries.push(entry);\n        }\n      }\n    }\n\n    return {\n      entries: changedEntries,\n      currentMarker,\n    };\n  }\n\n  /**\n   * Get all files that contain entries matching the queries.\n   */\n  private getSourceFiles(workspace: Workspace, queries: Query[]): string[] {\n    const files = new Set<string>();\n\n    for (const model of workspace.allModels()) {\n      for (const entry of model.ast.entries) {\n        if (entry.type !== \"instance_entry\") {\n          continue;\n        }\n\n        for (const query of queries) {\n          if (entryMatchesQuery(entry, query)) {\n            files.add(model.file);\n            break;\n          }\n        }\n      }\n    }\n\n    return Array.from(files);\n  }\n\n  /**\n   * Get all entries matching the queries (for first run or fallback)\n   */\n  private getAllMatchingEntries(workspace: Workspace, queries: Query[]): InstanceEntry[] {\n    const results: InstanceEntry[] = [];\n    const seen = new Set<string>();\n\n    for (const model of workspace.allModels()) {\n      for (const entry of model.ast.entries) {\n        if (entry.type !== \"instance_entry\") {\n          continue;\n        }\n\n        const key = `${model.file}:${serializeIdentity(getEntryIdentity(entry))}`;\n\n        if (seen.has(key)) {\n          continue;\n        }\n\n        for (const query of queries) {\n          if (entryMatchesQuery(entry, query)) {\n            results.push(entry);\n            seen.add(key);\n            break;\n          }\n        }\n      }\n    }\n\n    return results;\n  }\n\n  /**\n   * Get changed entries in a specific file.\n   *\n   * Note: This method only returns entries that exist in the current version of the file.\n   * Deleted entries are intentionally not tracked because for the actualization use case,\n   * we want entries to include in the synthesis prompt - deleted entries don't exist\n   * and therefore don't need to be synthesized.\n   */\n  private async getChangedEntriesInFile(\n    workspace: Workspace,\n    change: FileChange,\n    markerCommit: string,\n    queries: Query[],\n  ): Promise<InstanceEntry[]> {\n    // Find the model for this file in the workspace (use current path)\n    const model = this.findModelByRelativePath(workspace, change.path);\n    if (!model) {\n      return [];\n    }\n\n    // Get current entries\n    const currentEntries = model.ast.entries.filter(\n      (e): e is InstanceEntry => e.type === \"instance_entry\",\n    );\n\n    // If a blame ignore-revs file exists, use blame-based change detection.\n    // This allows users to ignore formatting-only commits (e.g. via `.git-blame-ignore-revs`)\n    // so they don't retrigger syntheses.\n    const ignoreRevs = await this.getIgnoreRevs();\n    if (ignoreRevs) {\n      const changed: InstanceEntry[] = [];\n\n      // Normalize end line: tree-sitter endPosition is exclusive.\n      function locationToLineRange(entry: InstanceEntry): { startLine: number; endLine: number } {\n        const startRow = entry.location.startPosition.row;\n        const endRow = entry.location.endPosition.row;\n        const endCol = entry.location.endPosition.column;\n        const startLine = startRow + 1;\n        const endLine = endCol === 0 ? endRow : endRow + 1;\n        return { startLine, endLine: Math.max(startLine, endLine) };\n      }\n\n      for (const entry of currentEntries) {\n        // Check if entry matches any query\n        let matchesQuery = false;\n        for (const query of queries) {\n          if (entryMatchesQuery(entry, query)) {\n            matchesQuery = true;\n            break;\n          }\n        }\n        if (!matchesQuery) {\n          continue;\n        }\n\n        const { startLine, endLine } = locationToLineRange(entry);\n        const blamedCommits = await getBlameCommitsForLineRange(\n          change.path,\n          startLine,\n          endLine,\n          this.cwd,\n          ignoreRevs,\n        );\n\n        let isChanged = false;\n        for (const commit of blamedCommits) {\n          // If the blamed commit is not an ancestor of the marker, then the entry\n          // has changes \"after\" the marker (including merges), after applying ignore-revs.\n          const isBeforeMarker = await isCommitAncestorOf(commit, markerCommit, this.cwd);\n          if (!isBeforeMarker) {\n            isChanged = true;\n            break;\n          }\n        }\n\n        if (isChanged) {\n          changed.push(entry);\n        }\n      }\n\n      return changed;\n    }\n\n    // Get old file content - use oldPath for renames, otherwise current path\n    const pathAtCommit = change.oldPath ?? change.path;\n    const oldContent = await getFileAtCommit(pathAtCommit, markerCommit, this.cwd);\n\n    // Build map of old entries\n    const oldEntryMap = new Map<string, Entry>();\n    if (oldContent) {\n      try {\n        // Detect file type from extension (markdown files contain embedded thalo blocks)\n        const fileType = pathAtCommit.endsWith(\".md\") ? \"markdown\" : \"thalo\";\n        const oldDoc = parseDocument(oldContent, { fileType });\n\n        // Iterate all blocks (markdown files may have multiple thalo blocks)\n        for (const block of oldDoc.blocks) {\n          const oldAst = extractSourceFile(block.tree.rootNode);\n          for (const entry of oldAst.entries) {\n            const key = serializeIdentity(getEntryIdentity(entry));\n            oldEntryMap.set(key, entry);\n          }\n        }\n      } catch {\n        // Parse error in old content - treat all current entries as changed\n      }\n    }\n\n    // Find changed entries\n    const changed: InstanceEntry[] = [];\n\n    for (const entry of currentEntries) {\n      // Check if entry matches any query\n      let matchesQuery = false;\n      for (const query of queries) {\n        if (entryMatchesQuery(entry, query)) {\n          matchesQuery = true;\n          break;\n        }\n      }\n\n      if (!matchesQuery) {\n        continue;\n      }\n\n      const key = serializeIdentity(getEntryIdentity(entry));\n      const oldEntry = oldEntryMap.get(key);\n\n      // Entry is changed if:\n      // 1. It didn't exist at the marker commit (new entry)\n      // 2. Its content differs from the marker commit (modified entry)\n      if (!oldEntry || !entriesEqual(oldEntry, entry)) {\n        changed.push(entry);\n      }\n    }\n\n    return changed;\n  }\n\n  /**\n   * Find a model in the workspace by relative path.\n   * Normalizes path separators for cross-platform compatibility.\n   *\n   * Handles cases where:\n   * - Git returns paths relative to repo root (e.g., \"project/entries.thalo\")\n   * - Workspace has files relative to cwd (e.g., \"entries.thalo\")\n   */\n  private findModelByRelativePath(\n    workspace: Workspace,\n    relativePath: string,\n  ): ReturnType<typeof workspace.getModel> {\n    // Normalize to forward slashes for comparison (git always uses forward slashes)\n    const normalizedRelative = relativePath.replace(/\\\\/g, \"/\");\n    const relativeParts = normalizedRelative.split(\"/\");\n\n    for (const model of workspace.allModels()) {\n      const normalizedModel = model.file.replace(/\\\\/g, \"/\");\n\n      // Exact match\n      if (normalizedModel === normalizedRelative) {\n        return model;\n      }\n\n      const modelParts = normalizedModel.split(\"/\");\n\n      // Check if git path ends with model path (user running from subdirectory)\n      // e.g., git returns \"project/entries.thalo\", model is \"entries.thalo\"\n      if (relativeParts.length >= modelParts.length) {\n        const relativeSuffix = relativeParts.slice(-modelParts.length).join(\"/\");\n        if (relativeSuffix === normalizedModel) {\n          return model;\n        }\n      }\n\n      // Check if model path ends with git path (model has absolute/longer path)\n      // e.g., model is \"/repo/project/entries.thalo\", git returns \"entries.thalo\"\n      if (modelParts.length >= relativeParts.length) {\n        const modelSuffix = modelParts.slice(-relativeParts.length).join(\"/\");\n        if (modelSuffix === normalizedRelative) {\n          return model;\n        }\n      }\n    }\n    return undefined;\n  }\n}\n"],"mappings":"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"}

package/dist/services/change-tracker/timestamp-tracker.d.ts

@@ -0,0 +1,22 @@
+import { Workspace } from "../../model/workspace.js";
+import { Query } from "../query.js";
+import { ChangeMarker, ChangeTracker, ChangedEntriesResult } from "./change-tracker.js";
+
+//#region src/services/change-tracker/timestamp-tracker.d.ts
+
+/**
+ * Timestamp-based change tracker.
+ *
+ * This is the fallback implementation that uses entry timestamps
+ * to determine which entries are "new" since the last actualization.
+ *
+ * Simple but limited - can't detect in-place edits, only new entries.
+ */
+declare class TimestampChangeTracker implements ChangeTracker {
+  readonly type: "ts";
+  getCurrentMarker(): Promise<ChangeMarker>;
+  getChangedEntries(workspace: Workspace, queries: Query[], marker: ChangeMarker | null): Promise<ChangedEntriesResult>;
+}
+//#endregion
+export { TimestampChangeTracker };
+//# sourceMappingURL=timestamp-tracker.d.ts.map

package/dist/services/change-tracker/timestamp-tracker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"timestamp-tracker.d.ts","names":[],"sources":["../../../src/services/change-tracker/timestamp-tracker.ts"],"sourcesContent":[],"mappings":";;;;;;;;AA4CA;;;;;;AAca,cAdA,sBAAA,YAAkC,aAclC,CAAA;EAAR,SAAA,IAAA,EAAA,IAAA;EAd0C,gBAAA,CAAA,CAAA,EAGnB,OAHmB,CAGX,YAHW,CAAA;EAAa,iBAAA,CAAA,SAAA,EAW7C,SAX6C,EAAA,OAAA,EAY/C,KAZ+C,EAAA,EAAA,MAAA,EAahD,YAbgD,GAAA,IAAA,CAAA,EAcvD,OAduD,CAc/C,oBAd+C,CAAA"}

package/dist/services/change-tracker/timestamp-tracker.js

@@ -0,0 +1,74 @@
+import { entryMatchesQuery } from "../query.js";
+import { formatTimestamp } from "../../formatters.js";
+
+//#region src/services/change-tracker/timestamp-tracker.ts
+/**
+* Convert a timestamp to epoch milliseconds for correct comparison across timezones
+*/
+function timestampToEpoch(ts) {
+	const isoStr = formatTimestamp(ts);
+	return Date.parse(isoStr);
+}
+/**
+* Parse an ISO timestamp string to epoch milliseconds
+*/
+function parseTimestampToEpoch(isoStr) {
+	return Date.parse(isoStr);
+}
+/**
+* Get current ISO timestamp
+*/
+function getCurrentTimestamp() {
+	const now = /* @__PURE__ */ new Date();
+	return `${now.getUTCFullYear()}-${String(now.getUTCMonth() + 1).padStart(2, "0")}-${String(now.getUTCDate()).padStart(2, "0")}T${String(now.getUTCHours()).padStart(2, "0")}:${String(now.getUTCMinutes()).padStart(2, "0")}Z`;
+}
+/**
+* Timestamp-based change tracker.
+*
+* This is the fallback implementation that uses entry timestamps
+* to determine which entries are "new" since the last actualization.
+*
+* Simple but limited - can't detect in-place edits, only new entries.
+*/
+var TimestampChangeTracker = class {
+	type = "ts";
+	async getCurrentMarker() {
+		return {
+			type: "ts",
+			value: getCurrentTimestamp()
+		};
+	}
+	async getChangedEntries(workspace, queries, marker) {
+		const afterTimestamp = marker?.type === "ts" ? marker.value : null;
+		const afterEpoch = afterTimestamp ? parseTimestampToEpoch(afterTimestamp) : null;
+		const results = [];
+		const seen = /* @__PURE__ */ new Set();
+		for (const model of workspace.allModels()) for (const entry of model.ast.entries) {
+			if (entry.type !== "instance_entry") continue;
+			const timestampEpoch = timestampToEpoch(entry.header.timestamp);
+			const timestampStr = formatTimestamp(entry.header.timestamp);
+			const entityType = entry.header.entity ?? "unknown";
+			const linkId = entry.header.link?.id ?? "";
+			const key = `${model.file}:${timestampStr}:${entityType}:${linkId}`;
+			if (seen.has(key)) continue;
+			if (afterEpoch !== null && timestampEpoch <= afterEpoch) continue;
+			for (const query of queries) if (entryMatchesQuery(entry, query)) {
+				results.push({
+					entry,
+					timestampEpoch
+				});
+				seen.add(key);
+				break;
+			}
+		}
+		results.sort((a, b) => a.timestampEpoch - b.timestampEpoch);
+		return {
+			entries: results.map((r) => r.entry),
+			currentMarker: await this.getCurrentMarker()
+		};
+	}
+};
+
+//#endregion
+export { TimestampChangeTracker };
+//# sourceMappingURL=timestamp-tracker.js.map

package/dist/services/change-tracker/timestamp-tracker.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"timestamp-tracker.js","names":["results: { entry: InstanceEntry; timestampEpoch: number }[]"],"sources":["../../../src/services/change-tracker/timestamp-tracker.ts"],"sourcesContent":["import type { Timestamp, InstanceEntry } from \"../../ast/ast-types.js\";\nimport type { Query } from \"../query.js\";\nimport type { Workspace } from \"../../model/workspace.js\";\nimport { entryMatchesQuery } from \"../query.js\";\nimport { formatTimestamp } from \"../../formatters.js\";\nimport type { ChangeTracker, ChangeMarker, ChangedEntriesResult } from \"./change-tracker.js\";\n\n/**\n * Convert a timestamp to epoch milliseconds for correct comparison across timezones\n */\nfunction timestampToEpoch(ts: Timestamp): number {\n  const isoStr = formatTimestamp(ts);\n  // Date.parse handles timezone offsets correctly\n  return Date.parse(isoStr);\n}\n\n/**\n * Parse an ISO timestamp string to epoch milliseconds\n */\nfunction parseTimestampToEpoch(isoStr: string): number {\n  return Date.parse(isoStr);\n}\n\n/**\n * Get current ISO timestamp\n */\nfunction getCurrentTimestamp(): string {\n  const now = new Date();\n  const year = now.getUTCFullYear();\n  const month = String(now.getUTCMonth() + 1).padStart(2, \"0\");\n  const day = String(now.getUTCDate()).padStart(2, \"0\");\n  const hour = String(now.getUTCHours()).padStart(2, \"0\");\n  const minute = String(now.getUTCMinutes()).padStart(2, \"0\");\n  return `${year}-${month}-${day}T${hour}:${minute}Z`;\n}\n\n/**\n * Timestamp-based change tracker.\n *\n * This is the fallback implementation that uses entry timestamps\n * to determine which entries are \"new\" since the last actualization.\n *\n * Simple but limited - can't detect in-place edits, only new entries.\n */\nexport class TimestampChangeTracker implements ChangeTracker {\n  readonly type = \"ts\" as const;\n\n  async getCurrentMarker(): Promise<ChangeMarker> {\n    return {\n      type: \"ts\",\n      value: getCurrentTimestamp(),\n    };\n  }\n\n  async getChangedEntries(\n    workspace: Workspace,\n    queries: Query[],\n    marker: ChangeMarker | null,\n  ): Promise<ChangedEntriesResult> {\n    // Only use the marker if it's a timestamp type\n    // If marker is git type (from switching modes), return all entries\n    const afterTimestamp = marker?.type === \"ts\" ? marker.value : null;\n    // Convert to epoch for correct comparison across timezones\n    const afterEpoch = afterTimestamp ? parseTimestampToEpoch(afterTimestamp) : null;\n\n    const results: { entry: InstanceEntry; timestampEpoch: number }[] = [];\n    const seen = new Set<string>();\n\n    for (const model of workspace.allModels()) {\n      for (const entry of model.ast.entries) {\n        if (entry.type !== \"instance_entry\") {\n          continue;\n        }\n\n        const timestampEpoch = timestampToEpoch(entry.header.timestamp);\n        const timestampStr = formatTimestamp(entry.header.timestamp);\n        // Include entity type and link in key to avoid collisions for same-minute entries\n        const entityType = entry.header.entity ?? \"unknown\";\n        const linkId = entry.header.link?.id ?? \"\";\n        const key = `${model.file}:${timestampStr}:${entityType}:${linkId}`;\n\n        // Skip if we've already seen this entry\n        if (seen.has(key)) {\n          continue;\n        }\n\n        // Skip if entry is before or at the cutoff (use epoch for correct timezone comparison)\n        if (afterEpoch !== null && timestampEpoch <= afterEpoch) {\n          continue;\n        }\n\n        // Check if entry matches any of the queries\n        for (const query of queries) {\n          if (entryMatchesQuery(entry, query)) {\n            results.push({ entry, timestampEpoch });\n            seen.add(key);\n            break;\n          }\n        }\n      }\n    }\n\n    // Sort by timestamp (epoch for correct ordering)\n    results.sort((a, b) => a.timestampEpoch - b.timestampEpoch);\n\n    return {\n      entries: results.map((r) => r.entry),\n      currentMarker: await this.getCurrentMarker(),\n    };\n  }\n}\n"],"mappings":";;;;;;;AAUA,SAAS,iBAAiB,IAAuB;CAC/C,MAAM,SAAS,gBAAgB,GAAG;AAElC,QAAO,KAAK,MAAM,OAAO;;;;;AAM3B,SAAS,sBAAsB,QAAwB;AACrD,QAAO,KAAK,MAAM,OAAO;;;;;AAM3B,SAAS,sBAA8B;CACrC,MAAM,sBAAM,IAAI,MAAM;AAMtB,QAAO,GALM,IAAI,gBAAgB,CAKlB,GAJD,OAAO,IAAI,aAAa,GAAG,EAAE,CAAC,SAAS,GAAG,IAAI,CAIpC,GAHZ,OAAO,IAAI,YAAY,CAAC,CAAC,SAAS,GAAG,IAAI,CAGtB,GAFlB,OAAO,IAAI,aAAa,CAAC,CAAC,SAAS,GAAG,IAAI,CAEhB,GADxB,OAAO,IAAI,eAAe,CAAC,CAAC,SAAS,GAAG,IAAI,CACV;;;;;;;;;;AAWnD,IAAa,yBAAb,MAA6D;CAC3D,AAAS,OAAO;CAEhB,MAAM,mBAA0C;AAC9C,SAAO;GACL,MAAM;GACN,OAAO,qBAAqB;GAC7B;;CAGH,MAAM,kBACJ,WACA,SACA,QAC+B;EAG/B,MAAM,iBAAiB,QAAQ,SAAS,OAAO,OAAO,QAAQ;EAE9D,MAAM,aAAa,iBAAiB,sBAAsB,eAAe,GAAG;EAE5E,MAAMA,UAA8D,EAAE;EACtE,MAAM,uBAAO,IAAI,KAAa;AAE9B,OAAK,MAAM,SAAS,UAAU,WAAW,CACvC,MAAK,MAAM,SAAS,MAAM,IAAI,SAAS;AACrC,OAAI,MAAM,SAAS,iBACjB;GAGF,MAAM,iBAAiB,iBAAiB,MAAM,OAAO,UAAU;GAC/D,MAAM,eAAe,gBAAgB,MAAM,OAAO,UAAU;GAE5D,MAAM,aAAa,MAAM,OAAO,UAAU;GAC1C,MAAM,SAAS,MAAM,OAAO,MAAM,MAAM;GACxC,MAAM,MAAM,GAAG,MAAM,KAAK,GAAG,aAAa,GAAG,WAAW,GAAG;AAG3D,OAAI,KAAK,IAAI,IAAI,CACf;AAIF,OAAI,eAAe,QAAQ,kBAAkB,WAC3C;AAIF,QAAK,MAAM,SAAS,QAClB,KAAI,kBAAkB,OAAO,MAAM,EAAE;AACnC,YAAQ,KAAK;KAAE;KAAO;KAAgB,CAAC;AACvC,SAAK,IAAI,IAAI;AACb;;;AAOR,UAAQ,MAAM,GAAG,MAAM,EAAE,iBAAiB,EAAE,eAAe;AAE3D,SAAO;GACL,SAAS,QAAQ,KAAK,MAAM,EAAE,MAAM;GACpC,eAAe,MAAM,KAAK,kBAAkB;GAC7C"}

package/dist/services/definition.d.ts

@@ -0,0 +1,37 @@
+import { Location } from "../ast/ast-types.js";
+import { LinkDefinition } from "../semantic/analyzer.js";
+import { Workspace } from "../model/workspace.js";
+
+//#region src/services/definition.d.ts
+
+/**
+ * Result of a find-definition query
+ */
+interface DefinitionResult {
+  /** The file containing the definition */
+  file: string;
+  /** Location of the definition (file-absolute) */
+  location: Location;
+  /** The link definition details */
+  definition: LinkDefinition;
+}
+/**
+ * Find the definition for a link ID
+ *
+ * @param workspace - The workspace to search in
+ * @param linkId - The link ID to find (without ^ prefix)
+ * @returns The definition result with file-absolute location, or undefined if not found
+ */
+declare function findDefinition(workspace: Workspace, linkId: string): DefinitionResult | undefined;
+/**
+ * Find the definition at a given position in a file
+ *
+ * @param workspace - The workspace to search in
+ * @param file - The file path
+ * @param offset - The character offset in the file
+ * @returns The definition result, or undefined if no link at position or not found
+ */
+declare function findDefinitionAtPosition(workspace: Workspace, file: string, offset: number): DefinitionResult | undefined;
+//#endregion
+export { DefinitionResult, findDefinition, findDefinitionAtPosition };
+//# sourceMappingURL=definition.d.ts.map

package/dist/services/definition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"definition.d.ts","names":[],"sources":["../../src/services/definition.ts"],"sourcesContent":[],"mappings":";;;;;;;;AASA;AAgBgB,UAhBC,gBAAA,CAgByB;EA8B1B;;;YA1CJ;;cAEE;;;;;;;;;iBAUE,cAAA,YAA0B,4BAA4B;;;;;;;;;iBA8BtD,wBAAA,YACH,0CAGV"}

package/dist/services/definition.js

@@ -0,0 +1,43 @@
+import { positionFromOffset, toFileLocation } from "../source-map.js";
+import { findNodeAtPosition } from "../ast/node-at-position.js";
+
+//#region src/services/definition.ts
+/**
+* Find the definition for a link ID
+*
+* @param workspace - The workspace to search in
+* @param linkId - The link ID to find (without ^ prefix)
+* @returns The definition result with file-absolute location, or undefined if not found
+*/
+function findDefinition(workspace, linkId) {
+	const definition = workspace.getLinkDefinition(linkId);
+	if (!definition) return;
+	const model = workspace.getModel(definition.file);
+	if (!model) return;
+	const fileLocation = toFileLocation(model.sourceMap, definition.location);
+	return {
+		file: definition.file,
+		location: fileLocation,
+		definition
+	};
+}
+/**
+* Find the definition at a given position in a file
+*
+* @param workspace - The workspace to search in
+* @param file - The file path
+* @param offset - The character offset in the file
+* @returns The definition result, or undefined if no link at position or not found
+*/
+function findDefinitionAtPosition(workspace, file, offset) {
+	const model = workspace.getModel(file);
+	if (!model) return;
+	const position = positionFromOffset(model.source, offset);
+	const context = findNodeAtPosition({ blocks: model.blocks }, position);
+	if (context.kind !== "link") return;
+	return findDefinition(workspace, context.linkId);
+}
+
+//#endregion
+export { findDefinition, findDefinitionAtPosition };
+//# sourceMappingURL=definition.js.map

package/dist/services/definition.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"definition.js","names":[],"sources":["../../src/services/definition.ts"],"sourcesContent":["import type { Workspace } from \"../model/workspace.js\";\nimport type { Location } from \"../ast/ast-types.js\";\nimport type { LinkDefinition } from \"../semantic/analyzer.js\";\nimport { toFileLocation, positionFromOffset } from \"../source-map.js\";\nimport { findNodeAtPosition } from \"../ast/node-at-position.js\";\n\n/**\n * Result of a find-definition query\n */\nexport interface DefinitionResult {\n  /** The file containing the definition */\n  file: string;\n  /** Location of the definition (file-absolute) */\n  location: Location;\n  /** The link definition details */\n  definition: LinkDefinition;\n}\n\n/**\n * Find the definition for a link ID\n *\n * @param workspace - The workspace to search in\n * @param linkId - The link ID to find (without ^ prefix)\n * @returns The definition result with file-absolute location, or undefined if not found\n */\nexport function findDefinition(workspace: Workspace, linkId: string): DefinitionResult | undefined {\n  const definition = workspace.getLinkDefinition(linkId);\n  if (!definition) {\n    return undefined;\n  }\n\n  // Get the model to access the source map\n  const model = workspace.getModel(definition.file);\n  if (!model) {\n    return undefined;\n  }\n\n  // Convert block-relative location to file-absolute location\n  const fileLocation = toFileLocation(model.sourceMap, definition.location);\n\n  return {\n    file: definition.file,\n    location: fileLocation,\n    definition,\n  };\n}\n\n/**\n * Find the definition at a given position in a file\n *\n * @param workspace - The workspace to search in\n * @param file - The file path\n * @param offset - The character offset in the file\n * @returns The definition result, or undefined if no link at position or not found\n */\nexport function findDefinitionAtPosition(\n  workspace: Workspace,\n  file: string,\n  offset: number,\n): DefinitionResult | undefined {\n  const model = workspace.getModel(file);\n  if (!model) {\n    return undefined;\n  }\n\n  // Convert offset to position\n  const position = positionFromOffset(model.source, offset);\n\n  // Use AST-based node detection\n  const context = findNodeAtPosition({ blocks: model.blocks }, position);\n\n  // Only handle link contexts\n  if (context.kind !== \"link\") {\n    return undefined;\n  }\n\n  return findDefinition(workspace, context.linkId);\n}\n"],"mappings":";;;;;;;;;;;AAyBA,SAAgB,eAAe,WAAsB,QAA8C;CACjG,MAAM,aAAa,UAAU,kBAAkB,OAAO;AACtD,KAAI,CAAC,WACH;CAIF,MAAM,QAAQ,UAAU,SAAS,WAAW,KAAK;AACjD,KAAI,CAAC,MACH;CAIF,MAAM,eAAe,eAAe,MAAM,WAAW,WAAW,SAAS;AAEzE,QAAO;EACL,MAAM,WAAW;EACjB,UAAU;EACV;EACD;;;;;;;;;;AAWH,SAAgB,yBACd,WACA,MACA,QAC8B;CAC9B,MAAM,QAAQ,UAAU,SAAS,KAAK;AACtC,KAAI,CAAC,MACH;CAIF,MAAM,WAAW,mBAAmB,MAAM,QAAQ,OAAO;CAGzD,MAAM,UAAU,mBAAmB,EAAE,QAAQ,MAAM,QAAQ,EAAE,SAAS;AAGtE,KAAI,QAAQ,SAAS,OACnB;AAGF,QAAO,eAAe,WAAW,QAAQ,OAAO"}