@faiezhares/source-code-highlighter 0.0.0-stage → 0.0.17-beta

package/index.js

@@ -0,0 +1,4686 @@
+#!/usr/bin/env node
+import{createRequire as __cr}from"module";import{fileURLToPath as __fup}from"url";import{dirname as __dn}from"path";const require=__cr(import.meta.url);const __filename=__fup(import.meta.url);const __dirname=__dn(__filename);
+
+// server/index.js
+import express from "express";
+import path8 from "path";
+
+// server/ws/WebSocketServerLuncher.js
+import { createRequire } from "module";
+
+// server/constants.js
+var LOCAL_OPENCODE_BASE_URL = "http://127.0.0.1:4096";
+var DEFAULT_OPENCODE_TIMEOUT = 6e4;
+var MAX_FILE_SIZE = 1024 * 20;
+var MAX_LINES_PER_FILE_CHUNK = 20;
+var ANNOTABLE_EXTENSIONS = /\.(js|ts|jsx|tsx|vue)$/i;
+var VUE_JS_EXTENSIONS = /\.(vue)$/i;
+var ENV_PATH_VARIABLE_NAME = "TODIDO_STORAGE_PATH";
+var HOME_SUBDIR_NAME = ".@faiezhares_source-code-highlighter/";
+var APP_NAME = "@faiezhares/source-code-highlighter";
+var INLINE_APP_NAME = "todido-io";
+var APP_WEB_URLS = {
+  UpgradeGuide: "https://substack.com/home/post/p-188695237",
+  Troubleshooting: "https://substack.com/home/post/p-188695237",
+  ConnectionErrorTroubleshooting: "https://substack.com/home/post/p-188695237",
+  ReportIssuesUrl: "https://github.com/haresfaiez/todido-issues/issues"
+};
+var READABLE_EXTENSIONS = [
+  ".txt",
+  ".md",
+  ".js",
+  ".ts",
+  ".jsx",
+  ".tsx",
+  ".json",
+  ".css",
+  ".scss",
+  ".html",
+  ".xml",
+  ".yml",
+  ".yaml",
+  ".csv",
+  ".log",
+  ".py",
+  ".java",
+  ".c",
+  ".cpp",
+  ".h",
+  ".hpp",
+  ".rb",
+  ".go",
+  ".rs",
+  ".php",
+  ".sh",
+  ".bat",
+  ".pl",
+  ".ini",
+  ".conf",
+  ".env",
+  ".vue"
+];
+
+// server/ws/WebSocketServerLuncher.js
+var _require = createRequire(import.meta.url);
+var { Server: WebSocketServer } = _require("ws");
+var MAX_RESTART_ATTEMPTS = 5;
+var RESTART_ATTEMPTS_INTERVAL = 2e3;
+var WebSocketServerLuncher = class {
+  start(startWebServer2) {
+    this.startWebServer = startWebServer2;
+    this.restartAttempts = 0;
+    this.attemptStart();
+  }
+  attemptStart() {
+    try {
+      const webServer = this.startWebServer();
+      this.webSocket = new WebSocketServer({ server: webServer });
+      this.webSocket.on("connection", (ws) => {
+        this.restartAttempts = 0;
+        ws.on("message", async (chunk) => {
+          await this.handle(ws, chunk);
+        });
+      });
+      this.webSocket.on("error", (error) => {
+        this.restart(error);
+      });
+    } catch (error) {
+      this.restart(error);
+    }
+  }
+  restart(error) {
+    this.restartAttempts++;
+    if (this.restartAttempts > MAX_RESTART_ATTEMPTS) {
+      console.error(MESSAGES.giveUp(MAX_RESTART_ATTEMPTS, error));
+      return;
+    }
+    console.error(MESSAGES.retry(this.restartAttempts, MAX_RESTART_ATTEMPTS, error));
+    setTimeout(() => {
+      this.attemptStart();
+    }, RESTART_ATTEMPTS_INTERVAL);
+  }
+  handle() {
+    throw new Error("handle() method must be implemented by subclass");
+  }
+};
+var MESSAGES = {
+  giveUp: (attempts, error) => `
+[${APP_NAME}]: GIVING UP
+
+[${APP_NAME}]: Failed to restart server after ${attempts} attempts.
+[${APP_NAME}]: Please check the error message and restart manually.
+
+[${APP_NAME}]: Error details:
+${error?.message || error || "Unknown error"}
+
+[${APP_NAME}]: If this issue persists, please check:
+[${APP_NAME}]: ${APP_WEB_URLS.Troubleshooting}`,
+  retry: (currentAttempt, maxAttempts, error) => `
+[${APP_NAME}]: Automatic Restart (Attempt ${currentAttempt}/${maxAttempts})
+[${APP_NAME}]: Error: ${error?.message || error || "Unknown error"}
+[${APP_NAME}]: Restarting WebSocket server in 2 seconds...
+`
+};
+
+// server/ws/MessageTypes.js
+var MessageTypes = {
+  GET_FILE_METADATA: "GET_FILE_METADATA",
+  CHECK_UPDATE: "CHECK_UPDATE",
+  PROJECT_METADATA: "PROJECT_METADATA",
+  FIND_TOKEN_USAGES: "FIND_TOKEN_USAGES",
+  ROOT: "ROOT",
+  GET_NOTES: "GET_NOTES",
+  SET_NOTES: "SET_NOTES",
+  SEARCH_FILES: "SEARCH_FILES",
+  RECENTLY_MODIFIED_FILES: "RECENTLY_MODIFIED_FILES",
+  MODIFIED_FILES: "MODIFIED_FILES",
+  DIR_CONTENT: "DIR_CONTENT",
+  SET_STORAGE_FILE_PATH: "SET_STORAGE_FILE_PATH",
+  SET_DARK_MODE: "SET_DARK_MODE",
+  DEBUG_TIMELINE: "DEBUG_TIMELINE",
+  GET_DEBUG_EVENT_BY_ID: "GET_DEBUG_EVENT_BY_ID",
+  // AI
+  CHECK_AI_SERVER: "CHECK_AI_SERVER",
+  PROMPT_AI: "PROMPT_AI",
+  // file view
+  FETCH_TEXT: "FETCH_TEXT",
+  FETCH_TOKENS: "FETCH_TOKENS",
+  FETCH_NOTES_HIGHLIGHTS: "FETCH_NOTES_HIGHLIGHTS",
+  FETCH_FOCUSED_NOTE_HIGHLIGHTS: "FETCH_FOCUSED_NOTE_HIGHLIGHTS",
+  FETCH_TEMPORAL_NOTES_HIGHLIGHTS: "FETCH_TEMPORAL_NOTES_HIGHLIGHTS",
+  EXPAND_TOKEN: "EXPAND_TOKEN",
+  // session
+  CREATE_SESSION: "CREATE_SESSION",
+  GET_SESSIONS: "GET_SESSIONS",
+  RENAME_SESSION: "RENAME_SESSION",
+  EXPORT_SESSION: "EXPORT_SESSION",
+  IMPORT_SESSION: "IMPORT_SESSION",
+  // diff
+  GET_COMMITS: "GET_COMMITS",
+  GET_COMMIT_NOTE: "GET_COMMIT_NOTE",
+  DIFF_RANGES: "DIFF_RANGES",
+  GET_RANGE_IN_COMMIT: "GET_RANGE_IN_COMMIT"
+};
+var MessageTypes_default = MessageTypes;
+
+// server/ws/WebSocketServer.js
+var WebSocketServer2 = class extends WebSocketServerLuncher {
+  constructor(messageHandlerFactory2, storage2, cache2) {
+    super();
+    this.messageHandlerFactory = messageHandlerFactory2;
+    this.storage = storage2;
+    this.cache = cache2;
+  }
+  async handle(ws, chunk) {
+    this.ws = ws;
+    const message = JSON.parse(chunk);
+    const handler = this.messageHandlerFactory.create(message, ws);
+    this.storage.registerDebugEvent("request/fe->be", message);
+    try {
+      if (message.TYPE === MessageTypes_default.GET_FILE_METADATA) {
+        handler.getFileMetadata();
+        return;
+      }
+      if (message.TYPE === MessageTypes_default.CHECK_UPDATE) {
+        handler.checkUpdate();
+        return;
+      }
+      if (message.TYPE === MessageTypes_default.PROJECT_METADATA) {
+        handler.projectMetadata();
+        return;
+      }
+      if (message.TYPE === MessageTypes_default.FIND_TOKEN_USAGES) {
+        handler.findTokenUsages();
+        return;
+      }
+      if (message.TYPE === MessageTypes_default.ROOT) {
+        handler.root();
+        return;
+      }
+      if (message.TYPE === MessageTypes_default.GET_NOTES) {
+        handler.getNotes();
+        return;
+      }
+      if (message.TYPE === MessageTypes_default.SET_NOTES) {
+        await handler.setNotes();
+        return;
+      }
+      if (message.TYPE === MessageTypes_default.SEARCH_FILES) {
+        handler.searchFiles();
+        return;
+      }
+      if (message.TYPE === MessageTypes_default.RECENTLY_MODIFIED_FILES) {
+        handler.recentlyModifiedFiles();
+        return;
+      }
+      if (message.TYPE === MessageTypes_default.MODIFIED_FILES) {
+        handler.gitModifiedFiles();
+        return;
+      }
+      if (message.TYPE === MessageTypes_default.DIR_CONTENT) {
+        handler.dirContent();
+        return;
+      }
+      if (message.TYPE === MessageTypes_default.SET_STORAGE_FILE_PATH) {
+        handler.setStorageFilePath();
+        return;
+      }
+      if (message.TYPE === MessageTypes_default.SET_DARK_MODE) {
+        handler.setDarkMode();
+        return;
+      }
+      if (message.TYPE === MessageTypes_default.DEBUG_TIMELINE) {
+        handler.debugTimeline();
+        return;
+      }
+      if (message.TYPE === MessageTypes_default.GET_DEBUG_EVENT_BY_ID) {
+        handler.getDebugEventById(message.eventId);
+        return;
+      }
+      if (message.TYPE === MessageTypes_default.CHECK_AI_SERVER) {
+        await handler.checkAiServer();
+        return;
+      }
+      if (message.TYPE === MessageTypes_default.PROMPT_AI) {
+        await handler.promptAi();
+        return;
+      }
+      if (message.TYPE === MessageTypes_default.FETCH_TEXT) {
+        handler.fetchText();
+        return;
+      }
+      if (message.TYPE === MessageTypes_default.FETCH_TOKENS) {
+        handler.fetchTokens();
+        return;
+      }
+      if (message.TYPE === MessageTypes_default.FETCH_NOTES_HIGHLIGHTS) {
+        handler.fetchNotesHighlights();
+        return;
+      }
+      if (message.TYPE === MessageTypes_default.FETCH_FOCUSED_NOTE_HIGHLIGHTS) {
+        handler.fetchFocusedNoteHighlights();
+        return;
+      }
+      if (message.TYPE === MessageTypes_default.FETCH_TEMPORAL_NOTES_HIGHLIGHTS) {
+        handler.fetchTemporalNotesHighlights();
+        return;
+      }
+      if (message.TYPE === MessageTypes_default.EXPAND_TOKEN) {
+        handler.expandToken();
+        return;
+      }
+      if (message.TYPE === MessageTypes_default.CREATE_SESSION) {
+        handler.createSession();
+        return;
+      }
+      if (message.TYPE === MessageTypes_default.GET_SESSIONS) {
+        handler.getSessions();
+        return;
+      }
+      if (message.TYPE === MessageTypes_default.RENAME_SESSION) {
+        handler.renameSession();
+        return;
+      }
+      if (message.TYPE === MessageTypes_default.EXPORT_SESSION) {
+        handler.exportSession();
+        return;
+      }
+      if (message.TYPE === MessageTypes_default.IMPORT_SESSION) {
+        handler.importSession();
+        return;
+      }
+      if (message.TYPE === MessageTypes_default.GET_COMMITS) {
+        handler.getCommits();
+        return;
+      }
+      if (message.TYPE === MessageTypes_default.GET_COMMIT_NOTE) {
+        handler.getCommitNote();
+        return;
+      }
+      if (message.TYPE === MessageTypes_default.DIFF_RANGES) {
+        handler.diffs();
+        return;
+      }
+      if (message.TYPE === MessageTypes_default.GET_RANGE_IN_COMMIT) {
+        handler.getRangeInCommit();
+        return;
+      }
+    } catch (error) {
+      const errorObject = {
+        TYPE: message.TYPE,
+        id: message.id,
+        error: error.message || error || `Unknown error while processing ${message.TYPE}.`,
+        callStack: error.stack
+      };
+      this.storage.registerDebugEvent("errormessage/be->fe", errorObject);
+      ws.send(JSON.stringify(errorObject));
+    }
+  }
+};
+
+// server/os/FileReader.js
+import fs2 from "fs";
+import { createPatch, applyPatch } from "diff";
+
+// server/os/FileCommandLine.js
+import { execSync } from "child_process";
+var FileCommandLine = class {
+  gitShow(absoluteFilePath, commitHash) {
+    const lastSlash = absoluteFilePath.lastIndexOf("/");
+    const dir = absoluteFilePath.slice(0, lastSlash);
+    const fileName = absoluteFilePath.slice(lastSlash + 1);
+    const command = `git show ${commitHash}:./${fileName}`;
+    const content = execSync(command, {
+      cwd: dir,
+      encoding: "utf8"
+    }).toString();
+    return content;
+  }
+  linesCount(absoluteFilePath, commitHash) {
+    if (commitHash) {
+      const content = this.gitShow(absoluteFilePath, commitHash);
+      return content.split("\n").length;
+    }
+    let output;
+    if (process.platform === "win32") {
+      output = execSync(`find /c /v "" "${absoluteFilePath}"`, {
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "ignore"]
+      });
+      const match = output.match(/:\s*(\d+)/);
+      return match ? parseInt(match[1], 10) : 0;
+    } else {
+      output = execSync(`wc -l < "${absoluteFilePath}"`, {
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "ignore"]
+      });
+      return parseInt(output.trim(), 10) || 0;
+    }
+  }
+};
+
+// server/parser/token/ASTTokensPlaceholder.js
+var ASTTokensPlaceholder = class {
+  constructor(startLine, endLine) {
+    this.className = "ASTTokensPlaceholder";
+    this.startLine = startLine;
+    this.endLine = endLine;
+  }
+};
+
+// server/os/TextReader.js
+import fs from "fs";
+import path from "path";
+var NEW_LINE_CHARACTER = "\n";
+var LINE_BREAK_REGEX = /\r\n|\r|\n/;
+var EACH_LINE_CONTENT_REGEX = /.*?(?=\r\n|\r|\n|$)/g;
+var isNewLine = (str) => LINE_BREAK_REGEX.test(str);
+var endsWithNewLine = (str) => /[\s\r\n]+$/.test(str);
+var TextReader = class {
+  constructor(content) {
+    this.content = content;
+  }
+  cleanLines() {
+    this.content = this.content.trim();
+    return this.lines().filter(Boolean);
+  }
+  lines() {
+    return this.content.split(LINE_BREAK_REGEX);
+  }
+  toEmptyLines() {
+    return this.content.replace(EACH_LINE_CONTENT_REGEX, "");
+  }
+  // TODO: Merge this 3 methods (Make this class mutable)
+  toDirOrFileList() {
+    return this.lines().filter((line) => line.trim().length > 0 && line.trim() !== "." && line.trim() !== "..").map((line) => {
+      const parts = line.split(" ");
+      const timestamp = parseFloat(parts[0]);
+      const fullPath = parts.slice(1).join(" ");
+      const name = path.basename(fullPath);
+      const stat = fs.statSync(fullPath);
+      const isDir = stat.isDirectory();
+      return {
+        name,
+        type: isDir ? "dir" : "file",
+        path: name,
+        size: isDir ? null : stat.size,
+        modified: Math.floor(timestamp * 1e3)
+        // Convert to milliseconds
+      };
+    });
+  }
+  formatFilesList(absoluteProjectRoot, transformation = (e) => e) {
+    return this.lines().filter(
+      (file) => file.trim().length > 0 && (READABLE_EXTENSIONS.some((ext) => file.toLowerCase().endsWith(ext)) || CONFIG_FILES.some((cfg) => path.basename(file).toLowerCase() === cfg))
+    ).map((file) => {
+      const result = transformation(file.replace(/^(\s*\.\/|\s+)/g, ""));
+      const resultAbsolutePath = path.join(absoluteProjectRoot, result);
+      const stat = fs.statSync(resultAbsolutePath);
+      return {
+        path: resultAbsolutePath,
+        type: "file",
+        size: stat.size,
+        modified: stat.mtime.getTime()
+      };
+    });
+  }
+  toGitRootRelativeFilesList(absoluteProjectRoot, gitRoot) {
+    const gitRelativePathLength = absoluteProjectRoot.length - gitRoot.length;
+    return this.formatFilesList(absoluteProjectRoot, (line) => {
+      const prePathLength = line.lastIndexOf(" ") + 1;
+      return line.substring(prePathLength + gitRelativePathLength);
+    });
+  }
+};
+
+// server/os/SourceCodeFileReader.js
+var SourceCode = class {
+  constructor(content, lines, linesStarts, tokensPlaceholders, longestLineLength) {
+    this.content = content;
+    this.lines = lines;
+    this.linesStarts = linesStarts;
+    this.tokensPlaceholders = tokensPlaceholders;
+    this.longestLineLength = longestLineLength;
+  }
+  get linesCount() {
+    return this.lines.length;
+  }
+  calculateContent() {
+    this.content = this.lines.join("\n");
+  }
+  calculateLines() {
+    this.lines = this.content.split(LINE_BREAK_REGEX);
+  }
+  calculateTokensPlaceholders() {
+    this.tokensPlaceholders = [];
+    for (let start = 0; start < this.lines.length; start += MAX_LINES_PER_FILE_CHUNK) {
+      const end = Math.min(start + MAX_LINES_PER_FILE_CHUNK - 1, this.lines.length - 1);
+      this.tokensPlaceholders.push(new ASTTokensPlaceholder(start + 1, end + 1));
+    }
+  }
+  // TODO: Improve perfs of this
+  calculateLinesStart() {
+    this.linesStarts = /* @__PURE__ */ new Map();
+    let currentIndex = 0;
+    for (let i = 0; i < this.lines.length; i++) {
+      this.linesStarts.set(i + 1, currentIndex);
+      currentIndex += this.lines[i].length + 1;
+    }
+  }
+  // TODO: Improve perfs of this
+  calculateLongestLineLength() {
+    this.longestLineLength = 0;
+    for (const line of this.lines) {
+      if (line.length > this.longestLineLength) {
+        this.longestLineLength = line.length;
+      }
+    }
+  }
+};
+var SourceCodeFileReader = class {
+  readFileRange(fileObject, startLine, endLine) {
+    const lines = fileObject.lines.slice(startLine - 1, endLine);
+    const result = new SourceCode(null, lines, fileObject.linesStarts);
+    result.calculateContent();
+    return result;
+  }
+  createReadResult(content) {
+    const result = new SourceCode(content);
+    result.calculateLines();
+    result.calculateLinesStart();
+    result.calculateTokensPlaceholders();
+    result.calculateLongestLineLength();
+    return result;
+  }
+};
+
+// server/os/FileReader.js
+var FileReader = class _FileReader {
+  constructor(environment2) {
+    this.environment = environment2;
+  }
+  get absoluteProjectRoot() {
+    return this.environment.absoluteProjectRoot || ".";
+  }
+  withEnvironment(environment2) {
+    return new _FileReader(environment2);
+  }
+  calculateRevision(filePath) {
+    const { base, current } = this.environment.gitChangeStatus(this.environment.commitHash);
+    const baseContent = this.fileContent(filePath, base);
+    const currentContent = this.fileContent(filePath, current);
+    const diff = createPatch("source", baseContent, currentContent, base, "working-tree");
+    return {
+      commitHash: base,
+      diff
+    };
+  }
+  readFileRange(absoluteFilePath, startLine, endLine) {
+    const fileObject = this.read(absoluteFilePath);
+    return new SourceCodeFileReader().readFileRange(fileObject, startLine, endLine);
+  }
+  readFileRangeFromSourceFile(fileObject, startLine, endLine) {
+    return new SourceCodeFileReader().readFileRange(fileObject, startLine, endLine);
+  }
+  // TODO: Add try/catch for commit no longer reachable
+  readRevision(absoluteFilePath, revision) {
+    const baseContent = this.fileContent(absoluteFilePath, revision.commitHash);
+    const content = applyPatch(baseContent, revision.diff);
+    return new SourceCodeFileReader().createReadResult(content);
+  }
+  // TODO: Make it async
+  fileContent(absoluteFilePath, commitHash) {
+    if (commitHash) {
+      return new FileCommandLine().gitShow(absoluteFilePath, commitHash);
+    }
+    const content = fs2.readFileSync(absoluteFilePath, "utf-8");
+    return content;
+  }
+  read(absoluteFilePath) {
+    const fileContent = this.fileContent(absoluteFilePath, this.environment.commitHash);
+    return new SourceCodeFileReader().createReadResult(fileContent);
+  }
+  readCurrent(absoluteFilePath) {
+    const fileContent = this.fileContent(absoluteFilePath);
+    return new SourceCodeFileReader().createReadResult(fileContent);
+  }
+  lineAt(absoluteFilePath, lineNumber) {
+    const file = this.read(absoluteFilePath);
+    const line = file.lines.at(lineNumber - 1);
+    return {
+      text: line.trim(),
+      start: file.linesStarts.get(lineNumber)
+    };
+  }
+  timeStamp(absoluteFilePath) {
+    return fs2.statSync(absoluteFilePath).mtimeMs;
+  }
+};
+var FileReader_default = FileReader;
+
+// server/storage/Storage.js
+import fs3 from "fs";
+import path2 from "path";
+import Database from "better-sqlite3";
+var StorageStrategy = {
+  FilePath: "FilePath",
+  InMemory: "InMemory",
+  TestingEnvInMemory: "TestingEnvInMemory"
+};
+var DB_FILE_EXTENSION = "db";
+var Storage = class {
+  constructor(absoluteProjectRoot, storageStrategy = StorageStrategy.InMemory) {
+    this.absoluteProjectRoot = absoluteProjectRoot;
+    this.storagePath = null;
+    this.storageStrategy = storageStrategy;
+    this.db = null;
+    this.statements = null;
+    if (this.isInMemoryStorage) {
+      this.delegate = new InMemoryStorage();
+    }
+    this.events = [];
+  }
+  get isInMemoryStorage() {
+    return this.storageStrategy !== StorageStrategy.FilePath;
+  }
+  initStoragePath(customPath) {
+    const dirPath = path2.dirname(customPath);
+    fs3.mkdirSync(dirPath, { recursive: true });
+    this.init(customPath);
+  }
+  getNotes(fileName = null, sessionId) {
+    if (this.isInMemoryStorage) {
+      return this.delegate.getNotes(fileName, sessionId);
+    }
+    if (!fileName) {
+      const list2 = this.statements.notesQuery.all(String(sessionId));
+      const listData2 = list2.map((row) => JSON.parse(row.data));
+      const removedList = this.statements.removedQuery.all(String(sessionId)).map((row) => JSON.parse(row.data));
+      return { list: listData2, removedList };
+    }
+    const list = this.statements.notesFileQuery.all(fileName, String(sessionId));
+    const listData = list.map((row) => JSON.parse(row.data));
+    return { list: listData };
+  }
+  getNoteByIdx(idx, sessionId) {
+    if (this.isInMemoryStorage) {
+      return this.delegate.getNoteByIdx(idx, sessionId);
+    }
+    const row = this.statements.noteByIdxQuery.get(String(idx), String(sessionId));
+    if (row) {
+      return JSON.parse(row.data);
+    }
+    const allRows = this.statements.notesQuery.all(String(sessionId));
+    for (const noteRow of allRows) {
+      const note = JSON.parse(noteRow.data);
+      const subnote = note.subNotes?.find((s) => String(s.idx) === String(idx));
+      if (subnote) return subnote;
+    }
+    return null;
+  }
+  setNotes(list, removedList, sessionId) {
+    if (this.isInMemoryStorage) {
+      this.delegate.setNotes(list, removedList, sessionId);
+      return;
+    }
+    const transaction = this.db.transaction(() => {
+      this.statements.deleteNotes.run(String(sessionId));
+      this.statements.deleteRemoved.run(String(sessionId));
+      for (const note of list) {
+        this.statements.notesInsert.run(
+          String(note.idx),
+          note.file,
+          String(sessionId),
+          JSON.stringify(note)
+        );
+      }
+      for (const note of removedList) {
+        this.statements.removedInsert.run(
+          String(note.idx),
+          note.file,
+          String(sessionId),
+          JSON.stringify(note)
+        );
+      }
+    });
+    transaction();
+  }
+  init(storagePath) {
+    const initialData = {
+      list: [],
+      removedList: [],
+      consentTimestamp: Date.now()
+    };
+    if (this.storageStrategy === StorageStrategy.TestingEnvInMemory) {
+      this.delegate.init(initialData);
+      return;
+    }
+    this.storagePath = storagePath || this.findStoragePath();
+    if (!this.storagePath || this.storageStrategy === StorageStrategy.InMemory) {
+      return;
+    }
+    const isDatabaseExisting = fs3.existsSync(this.storagePath);
+    this.db = new Database(this.storagePath);
+    this.db.pragma("journal_mode = WAL");
+    this.db.exec(SQL.createTables);
+    try {
+      if (!isDatabaseExisting) {
+        const metaInsert = this.db.prepare(SQL.metaInsert);
+        metaInsert.run("consentTimestamp", String(initialData.consentTimestamp));
+        metaInsert.run("isDarkMode", "false");
+      }
+    } catch (e) {
+      console.error("Storage init error:", e);
+    }
+    this.statements = {
+      notesQuery: this.db.prepare(SQL.notesQuery),
+      notesFileQuery: this.db.prepare(SQL.notesFileQuery),
+      noteByIdxQuery: this.db.prepare(SQL.noteByIdxQuery),
+      notesInsert: this.db.prepare(SQL.notesInsert),
+      deleteNotes: this.db.prepare(SQL.deleteNotes),
+      removedQuery: this.db.prepare(SQL.removedQuery),
+      removedInsert: this.db.prepare(SQL.removedInsert),
+      deleteRemoved: this.db.prepare(SQL.deleteRemoved),
+      metadataQuery: this.db.prepare(SQL.metadataQuery),
+      metaUpdate: this.db.prepare(SQL.metaUpdate),
+      sessionInsert: this.db.prepare(SQL.sessionInsert),
+      sessionsQuery: this.db.prepare(SQL.sessionsQuery),
+      sessionRename: this.db.prepare(SQL.sessionRename),
+      sessionByIdQuery: this.db.prepare(SQL.sessionByIdQuery)
+    };
+  }
+  consentTimestamp() {
+    if (this.isInMemoryStorage) {
+      return this.delegate.consentTimestamp();
+    }
+    const row = this.statements.metadataQuery.get("consentTimestamp");
+    return row ? parseInt(row.value) : Date.now();
+  }
+  isDarkMode() {
+    if (this.isInMemoryStorage) {
+      return this.delegate.isDarkMode();
+    }
+    const row = this.statements.metadataQuery.get("isDarkMode");
+    return row ? row.value === "true" : false;
+  }
+  setIsDarkMode(isDarkMode) {
+    if (this.isInMemoryStorage) {
+      this.delegate.setIsDarkMode(isDarkMode);
+      return;
+    }
+    this.statements.metaUpdate.run("isDarkMode", isDarkMode ? "true" : "false");
+  }
+  createSession(sessionName) {
+    const now = Date.now();
+    const id = Date.now().toString(36) + Math.random().toString(36).substr(2);
+    if (this.isInMemoryStorage) return { id, name: sessionName, lastModified: now };
+    this.statements.sessionInsert.run(id, sessionName, now, now);
+    return { id, name: sessionName, lastModified: now };
+  }
+  getSessions() {
+    if (this.isInMemoryStorage) return [];
+    return this.statements.sessionsQuery.all();
+  }
+  getSessionById(sessionId) {
+    if (this.isInMemoryStorage) return null;
+    return this.statements.sessionByIdQuery.get(String(sessionId)) || null;
+  }
+  renameSession(sessionId, name) {
+    if (this.isInMemoryStorage) return null;
+    const now = Date.now();
+    this.statements.sessionRename.run(name, now, String(sessionId));
+    return { id: sessionId, name, lastModified: now };
+  }
+  //
+  storageFileName() {
+    if (!this.absoluteProjectRoot) {
+      return `${INLINE_APP_NAME}-default.${DB_FILE_EXTENSION}`;
+    }
+    let hash = 0;
+    for (let i = 0; i < this.absoluteProjectRoot.length; i++) {
+      const char = this.absoluteProjectRoot.charCodeAt(i);
+      hash = (hash << 5) - hash + char;
+      hash = hash & hash;
+    }
+    const shortHash = Math.abs(hash).toString(36).substring(0, 8);
+    return `${INLINE_APP_NAME}-${shortHash}.${DB_FILE_EXTENSION}`;
+  }
+  findStoragePath(onlyIfExists = true) {
+    const envPath = process.env[ENV_PATH_VARIABLE_NAME];
+    if (envPath) {
+      let resolvedPath;
+      if (envPath.endsWith(`.${DB_FILE_EXTENSION}`)) {
+        resolvedPath = path2.resolve(envPath);
+      } else {
+        resolvedPath = path2.resolve(envPath, this.storageFileName());
+      }
+      return !onlyIfExists || fs3.existsSync(resolvedPath) ? resolvedPath : null;
+    }
+    const possiblePaths = [
+      path2.resolve(process.env.HOME, HOME_SUBDIR_NAME + this.storageFileName())
+    ];
+    for (const eachPossiblePath of possiblePaths) {
+      if (!onlyIfExists || fs3.existsSync(eachPossiblePath)) {
+        return eachPossiblePath;
+      }
+    }
+    return null;
+  }
+  setStorageStrategy(storageStrategy) {
+    this.storageStrategy = storageStrategy;
+  }
+  // Debug events
+  registerDebugEvent(scope, event) {
+    if (process.env.NODE_ENV === "development") {
+      this.events.push({
+        time: /* @__PURE__ */ new Date(),
+        scope,
+        eventType: event.TYPE,
+        id: event.id,
+        event: JSON.stringify(event)
+      });
+    }
+  }
+  debugTimeline() {
+    return this.events.map((eachEntry) => ({
+      time: eachEntry.time,
+      scope: eachEntry.scope,
+      eventType: eachEntry.eventType,
+      id: eachEntry.id
+    })).reverse();
+  }
+  getDebugEventById(id) {
+    return this.events.filter((eachEntry) => eachEntry.id === id);
+  }
+};
+var InMemoryStorage = class {
+  constructor() {
+    this.data = { list: [], removedList: [] };
+  }
+  getNotes(fileName = null) {
+    if (!fileName) return this.data;
+    return { list: this.data.list.filter((note) => note.file === fileName) };
+  }
+  getNoteByIdx(idx) {
+    for (let i = 0; i < this.data.list.length; i++) {
+      const eachNote = this.data.list[i];
+      if (eachNote.idx === idx) {
+        return eachNote;
+      }
+      if (eachNote.subNotes) {
+        for (let j = 0; j < eachNote.subNotes.length; j++) {
+          if (eachNote.subNotes[j].idx === idx) {
+            return eachNote.subNotes[j];
+          }
+        }
+      }
+    }
+  }
+  setNotes(list, removedList) {
+    this.data = { ...this.data || {}, list, removedList };
+  }
+  init(initialData) {
+    this.data = initialData;
+  }
+  consentTimestamp() {
+    return this.data?.consentTimestamp;
+  }
+  isDarkMode() {
+    return !!this.data?.isDarkMode;
+  }
+  setIsDarkMode(isDarkMode) {
+    this.data.isDarkMode = isDarkMode;
+  }
+};
+var SQL = {
+  createTables: `
+    CREATE TABLE IF NOT EXISTS sessions (
+      id TEXT PRIMARY KEY,
+      name TEXT UNIQUE NOT NULL,
+      created_at INTEGER NOT NULL,
+      last_modified INTEGER NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS notes (
+      idx TEXT PRIMARY KEY,
+      file TEXT,
+      session_id TEXT NOT NULL,
+      data TEXT NOT NULL,
+      FOREIGN KEY (session_id) REFERENCES sessions(id)
+    );
+
+    CREATE TABLE IF NOT EXISTS removed_notes (
+      idx TEXT PRIMARY KEY,
+      file TEXT,
+      session_id TEXT NOT NULL,
+      data TEXT NOT NULL,
+      FOREIGN KEY (session_id) REFERENCES sessions(id)
+    );
+
+    CREATE TABLE IF NOT EXISTS metadata (
+      key TEXT PRIMARY KEY,
+      value TEXT
+    );
+  `,
+  notesQuery: "SELECT * FROM notes WHERE session_id = ?",
+  notesFileQuery: "SELECT * FROM notes WHERE file = ? AND session_id = ?",
+  noteByIdxQuery: "SELECT * FROM notes WHERE idx = ? AND session_id = ?",
+  notesInsert: "INSERT OR REPLACE INTO notes (idx, file, session_id, data) VALUES (?, ?, ?, ?)",
+  deleteNotes: "DELETE FROM notes WHERE session_id = ?",
+  removedQuery: "SELECT data FROM removed_notes WHERE session_id = ? ",
+  removedInsert: "INSERT OR REPLACE INTO removed_notes (idx, file, session_id, data) VALUES (?, ?, ?, ?)",
+  deleteRemoved: "DELETE FROM removed_notes WHERE session_id = ?",
+  metadataQuery: "SELECT value FROM metadata WHERE key = ?",
+  metaUpdate: "INSERT OR REPLACE INTO metadata (key, value) VALUES (?, ?)",
+  metaInsert: "INSERT INTO metadata (key, value) VALUES (?, ?)",
+  sessionInsert: "INSERT INTO sessions (id, name, created_at, last_modified) VALUES (?, ?, ?, ?)",
+  sessionRename: "UPDATE sessions SET name = ?, last_modified = ? WHERE id = ?",
+  sessionsQuery: "SELECT id, name, created_at, last_modified FROM sessions ORDER BY last_modified DESC",
+  sessionByIdQuery: "SELECT id, name, created_at, last_modified FROM sessions WHERE id = ?"
+};
+
+// server/controllers/FsMetadataController.js
+var FsMetadataController = class {
+  constructor(environment2, fileCommandLine2, storage2, myPackage2) {
+    this.environment = environment2;
+    this.fileCommandLine = fileCommandLine2;
+    this.storage = storage2;
+    this.myPackage = myPackage2;
+  }
+  getCurrentAndLatestVersions() {
+    return {
+      currentVersion: this.myPackage.currentVersion(),
+      latestVersion: this.myPackage.latestVersion(),
+      isDevBuild: process.env.NODE_ENV === "development"
+    };
+  }
+  getProjectMetadata() {
+    return {
+      projectMetadata: {
+        root: this.environment.absoluteProjectRoot,
+        revision: this.environment.gitRevision()
+      },
+      links: {
+        connectionErrorTroubleshooting: APP_WEB_URLS.ConnectionErrorTroubleshooting,
+        upgradeGuide: APP_WEB_URLS.UpgradeGuide,
+        reportIssuesUrl: APP_WEB_URLS.ReportIssuesUrl
+      },
+      appName: APP_NAME,
+      packageVersion: this.myPackage.currentVersion(),
+      consentTimestamp: this.storage.consentTimestamp(),
+      storageFilePath: this.storage.findStoragePath(false),
+      isDarkMode: this.storage.isDarkMode()
+    };
+  }
+};
+
+// server/os/Environment.js
+import path3 from "path";
+import { execSync as execSync2 } from "child_process";
+var Environment = class _Environment {
+  constructor(absoluteProjectRoot, port, gitRoot, commitHash) {
+    this.absoluteProjectRoot = absoluteProjectRoot;
+    this.port = port;
+    this.gitRoot = gitRoot;
+    this.commitHash = commitHash;
+  }
+  static parse(args2, launchDir2, defaultPort2) {
+    const result = new _Environment(launchDir2, defaultPort2);
+    result.parseArguments(args2);
+    result.setGitRoot();
+    return result;
+  }
+  withCommitHash(commitHash) {
+    return new _Environment(this.absoluteProjectRoot, this.port, this.gitRoot, commitHash);
+  }
+  parseArguments(args2) {
+    let projectRootArgument = ".";
+    for (let i = 0; i < args2.length; i++) {
+      if (args2[i] === "--root" && i + 1 < args2.length) {
+        projectRootArgument = args2[i + 1];
+        i++;
+      } else if (args2[i] === "--port" && i + 1 < args2.length) {
+        this.port = parseInt(args2[i + 1], 10) || this.port;
+        i++;
+      }
+    }
+    this.absoluteProjectRoot = path3.resolve(projectRootArgument);
+  }
+  commitMessages(commitHashes = []) {
+    const output = execSync2(`git show -s --format=%H%x00%s ${commitHashes.join(" ")}`, {
+      cwd: this.gitRoot,
+      encoding: "utf8"
+    });
+    const commits = new TextReader(output).cleanLines().map((line) => {
+      const [hash, message] = line.split("\0");
+      return { hash, message };
+    });
+    return commits;
+  }
+  setGitRoot() {
+    try {
+      this.gitRoot = execSync2("git rev-parse --show-toplevel", {
+        cwd: this.absoluteProjectRoot,
+        encoding: "utf8"
+      }).trim();
+    } catch (error) {
+      this.gitRoot = null;
+    }
+  }
+  gitRevision() {
+    if (!this.gitRoot) {
+      return "";
+    }
+    const branchName = execSync2("git rev-parse --abbrev-ref HEAD", {
+      cwd: this.absoluteProjectRoot,
+      encoding: "utf8"
+    }).trim();
+    const commitHash = execSync2("git rev-parse --short HEAD", {
+      cwd: this.absoluteProjectRoot,
+      encoding: "utf8"
+    }).trim();
+    return `${branchName}/${commitHash}`;
+  }
+  headCommitHash() {
+    return execSync2("git rev-parse HEAD", { cwd: this.absoluteProjectRoot, encoding: "utf8" }).toString().trim();
+  }
+  gitChangeStatus(commitHash) {
+    const head = this.headCommitHash();
+    const base = !commitHash || commitHash === "HEAD" ? head : commitHash;
+    const current = base === head ? void 0 : base;
+    return { base, current };
+  }
+  // TODO: Test these 2 methods on windows
+  recentlyModifiedFiles() {
+    const filesCount = 8;
+    const filesList = execSync2(
+      `find . -type f -not -path '*/.*' -exec ls -lt {} + 2>/dev/null | head -${filesCount} | awk '{print $NF}' || echo ""`,
+      {
+        cwd: this.absoluteProjectRoot,
+        encoding: "utf8"
+      }
+    );
+    return new TextReader(filesList).formatFilesList(this.absoluteProjectRoot);
+  }
+  changedFilesRelativePaths(commitHash, comparedToCommitHash) {
+    const command = `git diff --diff-filter=AMR --name-only --relative ${comparedToCommitHash} ${commitHash} -- .`;
+    const output = execSync2(command, {
+      cwd: this.absoluteProjectRoot,
+      encoding: "utf8"
+    });
+    return output.split("\n").map((line) => line.trim()).filter(Boolean);
+  }
+  gitModifiedFiles() {
+    if (!this.gitRoot) {
+      return [];
+    }
+    const filesList = execSync2(`git status --porcelain . | grep -E "^ *[AM][^D]" || echo ""`, {
+      cwd: this.absoluteProjectRoot,
+      encoding: "utf8"
+    });
+    return new TextReader(filesList).toGitRootRelativeFilesList(
+      this.absoluteProjectRoot,
+      this.gitRoot
+    );
+  }
+};
+
+// server/os/DirCommandLine.js
+import fs4 from "fs";
+import path4 from "path";
+import { execSync as execSync3, spawnSync } from "child_process";
+var IGNORED_DIRS = ["node_modules", ".git", "dist", "build", "out"];
+var DirCommandLine = class {
+  constructor(environment2) {
+    this.setEnvironment(environment2);
+  }
+  setEnvironment(environment2) {
+    this.environment = environment2;
+    this.backend = process.platform === "win32" ? new WindowsDirCommandLine(this.environment) : new UnixDirCommandLine(this.environment);
+  }
+  search(query, isRegex, isCaseSensitive) {
+    return this.backend.search(query, isRegex, isCaseSensitive);
+  }
+  dirContent(absolutePath) {
+    return this.backend.dirContent(absolutePath);
+  }
+  // TODO: Use command line for this (dir / find)
+  // TODO: Remove this (search with purpose instead)
+  findAllFilesPathsRecursively(dir = this.environment.absoluteProjectRoot, fileList = [], rootDir = dir) {
+    const files = fs4.readdirSync(dir);
+    files.forEach((file) => {
+      const filePath = path4.join(dir, file);
+      const stat = fs4.statSync(filePath);
+      if (stat.isDirectory()) {
+        if (!IGNORED_DIRS.includes(file)) {
+          this.findAllFilesPathsRecursively(filePath, fileList, rootDir);
+        }
+      } else {
+        fileList.push(filePath);
+      }
+    });
+    return fileList;
+  }
+};
+var WindowsDirCommandLine = class {
+  constructor(environment2) {
+    this.absoluteProjectRoot = environment2.absoluteProjectRoot;
+  }
+  search(query, isRegex, isCaseSensitive) {
+    let files;
+    function walk(dir, fileList = []) {
+      fs4.readdirSync(dir).forEach((file) => {
+        const filePath = path4.join(dir, file);
+        if (fs4.statSync(filePath).isDirectory()) {
+          walk(filePath, fileList);
+        } else {
+          fileList.push(path4.relative(this.absoluteProjectRoot, filePath));
+        }
+      });
+      return fileList;
+    }
+    files = walk(this.absoluteProjectRoot);
+    files = files.filter((file) => {
+      let matches;
+      if (isRegex) {
+        const regex = new RegExp(query, isCaseSensitive ? "" : "i");
+        matches = regex.test(file);
+      } else {
+        const searchFile = isCaseSensitive ? file : file.toLowerCase();
+        const searchQuery = isCaseSensitive ? query : query.toLowerCase();
+        matches = searchFile.includes(searchQuery);
+      }
+      const isValidFileType = READABLE_EXTENSIONS.some((ext) => file.toLowerCase().endsWith(ext)) || CONFIG_FILES2.some((cfg) => path4.basename(file).toLowerCase() === cfg);
+      return matches && isValidFileType;
+    });
+    return files.map((file) => path4.join(this.absoluteProjectRoot, file));
+  }
+  dirContent(absolutePath) {
+    const fullPath = absolutePath;
+    const items = fs4.readdirSync(fullPath);
+    const content = items.map((item) => {
+      const stat = fs4.statSync(path4.join(fullPath, item));
+      return {
+        name: item,
+        type: stat.isDirectory() ? "dir" : "file",
+        relativePath: path4.join(relativePath, item),
+        size: stat.isFile() ? stat.size : null,
+        modified: stat.mtime.getTime()
+      };
+    });
+    content.sort((a, b) => {
+      if (a.type !== b.type) {
+        return a.type === "dir" ? -1 : 1;
+      }
+      return a.name.localeCompare(b.name);
+    });
+    return content;
+  }
+};
+var UnixDirCommandLine = class {
+  constructor(environment2) {
+    this.absoluteProjectRoot = environment2.absoluteProjectRoot;
+  }
+  search(query, isRegex, isCaseSensitive) {
+    const extPredicates = READABLE_EXTENSIONS.flatMap((ext) => ["-o", "-name", `*${ext}`]);
+    extPredicates.shift();
+    const cfgPredicates = CONFIG_FILES2.flatMap((cfg) => ["-o", "-name", cfg]);
+    const namePredicates = ["(", ...extPredicates, ...cfgPredicates, ")"];
+    const ignorePredicates = IGNORED_DIRS.flatMap((dir) => [
+      "-not",
+      "(",
+      "-type",
+      "d",
+      "-name",
+      dir,
+      ")"
+    ]);
+    const findArgs = [".", "-type", "f", ...ignorePredicates, ...namePredicates];
+    const result = spawnSync("find", findArgs, {
+      encoding: "utf8",
+      cwd: this.absoluteProjectRoot,
+      maxBuffer: 10 * 1024 * 1024
+    });
+    const lines = (result.stdout || "").split("\n").filter(Boolean);
+    const filtered = lines.filter((line) => {
+      if (isRegex) {
+        try {
+          return new RegExp(query, isCaseSensitive ? "" : "i").test(line);
+        } catch {
+          return false;
+        }
+      }
+      const haystack = isCaseSensitive ? line : line.toLowerCase();
+      const needle = isCaseSensitive ? query : query.toLowerCase();
+      return haystack.includes(needle);
+    });
+    return new TextReader(filtered.join("\n")).formatFilesList(this.absoluteProjectRoot);
+  }
+  dirContent(absolutePath) {
+    let stdout;
+    if (process.platform === "darwin") {
+      stdout = execSync3(
+        `find "${absolutePath}" -maxdepth 1 -not -path "${absolutePath}" -exec stat -f "%m %N" {} + 2>/dev/null | sort || echo ""`,
+        {
+          encoding: "utf8"
+        }
+      );
+    } else {
+      const command = `find "${absolutePath}" -maxdepth 1 -not -path "${absolutePath}" -printf "%T@ %p\\n" 2>/dev/null | sort || echo ""`;
+      stdout = execSync3(command, {
+        encoding: "utf8"
+      });
+    }
+    return new TextReader(stdout).toDirOrFileList();
+  }
+};
+var CONFIG_FILES2 = [
+  ".editorconfig",
+  ".env",
+  ".gitignore",
+  ".npmrc",
+  ".babelrc",
+  ".eslintrc",
+  ".prettierrc",
+  ".stylelintrc",
+  ".dockerignore",
+  ".gitattributes",
+  ".eslintignore",
+  ".prettierignore"
+];
+
+// server/parser/ast/ASTBuilder.js
+import ts5 from "typescript";
+
+// server/parser/range/ASTTokensRange.js
+var ASTTokensRange = class _ASTTokensRange {
+  constructor(startToken, endToken) {
+    this.startToken = startToken;
+    this.endToken = endToken;
+  }
+  // TODO: Duplicated in src/
+  containsToken(childToken) {
+    return this.startToken.rawToken.getStart() <= childToken.rawToken.getStart() && this.endToken.rawToken.getEnd() >= childToken.rawToken.getEnd();
+  }
+  equalsBoundaries(other) {
+    return other.startToken.rawToken.getStart() === this.startToken.rawToken.getStart() && other.endToken.rawToken.getEnd() === this.endToken.rawToken.getEnd();
+  }
+  toResponseJSON() {
+    return {
+      startToken: this.startToken.toResponseJSON(),
+      endToken: this.endToken.toResponseJSON()
+    };
+  }
+  static copy(object) {
+    if (object.ranges) {
+      return new ASTTokensRangeSet(
+        object.ranges.map((eachRange) => _ASTTokensRange.copy(eachRange))
+      );
+    }
+    return new _ASTTokensRange(object.startToken, object.endToken);
+  }
+};
+var ASTTokensRangeSet = class {
+  constructor(ranges = []) {
+    this.ranges = ranges;
+  }
+  get startToken() {
+    throw new Error("ASTTokensRangeSet does not have startToken");
+  }
+  get endToken() {
+    throw new Error("ASTTokensRangeSet does not have endToken");
+  }
+  containsToken(childToken) {
+    return this.ranges.some((range) => range.containsToken(childToken));
+  }
+  toResponseJSON() {
+    return { ranges: this.ranges.map((eachTokensRange) => eachTokensRange.toResponseJSON()) };
+  }
+};
+
+// server/parser/token/ASTRawToken.js
+var rawTokenToJSON = (rawToken) => {
+  return {
+    start: rawToken.getStart(),
+    end: rawToken.getEnd(),
+    kind: rawToken.kind,
+    name: rawToken.name && rawTokenToJSON(rawToken.name)
+  };
+};
+var rawTokenFromJSON = (json) => {
+  return {
+    ...json,
+    name: json.name && rawTokenFromJSON(json.name),
+    getStart() {
+      return json.start;
+    },
+    getEnd() {
+      return json.end;
+    }
+  };
+};
+var createCommentRawToken = (token, fullText) => {
+  return {
+    ...token,
+    start: token.pos,
+    end: token.end,
+    fullText,
+    getStart() {
+      return this.start;
+    },
+    getEnd() {
+      return this.end;
+    },
+    getFullText() {
+      return this.fullText;
+    }
+  };
+};
+
+// server/parser/token/ASTToken.js
+var ASTToken = class {
+  constructor(rawToken, collapsionBlock, isHidden = false, isManuallyExpanded = false) {
+    this.rawToken = rawToken;
+    this.collapsionBlock = collapsionBlock;
+    this.isHidden = isHidden;
+    this.isManuallyExpanded = isManuallyExpanded;
+  }
+  equals(otherToken) {
+    if (!otherToken?.rawToken || !this.rawToken) return false;
+    return this.rawToken.kind === otherToken.rawToken.kind && this.rawToken.getStart() === otherToken.rawToken.getStart();
+  }
+  compareCoordinates(other) {
+    return this.rawToken.getStart() === other.rawToken.getStart() ? other.rawToken.getEnd() - this.rawToken.getEnd() : this.rawToken.getStart() - other.rawToken.getStart();
+  }
+  range() {
+    return new ASTTokensRange(this, this);
+  }
+  get start() {
+    return this.rawToken?.getStart();
+  }
+  get end() {
+    return this.rawToken?.getEnd();
+  }
+  toResponseJSON() {
+    const rawTokenJson = this.rawToken && rawTokenToJSON(this.rawToken);
+    return {
+      className: this.className,
+      text: this.text,
+      isNewLine: this.isNewLine,
+      isSecondNewLine: this.isSecondNewLine,
+      isHidden: this.isHidden,
+      isManuallyExpanded: this.isManuallyExpanded,
+      lineNumber: this.lineNumber,
+      rawToken: rawTokenJson,
+      collapsionBlock: this.collapsionBlock?.toResponseJSON(),
+      type: this.type,
+      coordinates: this.coordinates
+    };
+  }
+};
+
+// server/parser/token/ASTImportToken.js
+var ASTImportToken = class _ASTImportToken extends ASTToken {
+  constructor(rawToken, absoluteFilePath = null, importString = null, identifierToken = null, importedIdentifiersNames = []) {
+    super(rawToken);
+    this.absoluteFilePath = absoluteFilePath;
+    this.importString = importString;
+    this.importedIdentifiersNames = importedIdentifiersNames;
+    this.identifierToken = identifierToken;
+  }
+  withAbsoluteFilePath(absoluteFilePath) {
+    return new _ASTImportToken(
+      this.rawToken,
+      absoluteFilePath,
+      this.importString,
+      this.identifierToken,
+      this.importedIdentifiersNames
+    );
+  }
+  withImportString(importString) {
+    return new _ASTImportToken(
+      this.rawToken,
+      this.absoluteFilePath,
+      importString,
+      this.identifierToken,
+      this.importedIdentifiersNames
+    );
+  }
+  withQueryToken(identifierToken) {
+    return new _ASTImportToken(
+      this.rawToken,
+      this.absoluteFilePath,
+      this.importString,
+      identifierToken,
+      this.importedIdentifiersNames
+    );
+  }
+  withImportedIdentifiersNames(importedIdentifiersNames) {
+    return new _ASTImportToken(
+      this.rawToken,
+      this.absoluteFilePath,
+      this.importString,
+      this.identifierToken,
+      importedIdentifiersNames
+    );
+  }
+  isImporting(absoluteFilePath, identifierToken) {
+    if (this.absoluteFilePath !== absoluteFilePath) {
+      return false;
+    }
+    return this.isImportingIdentifier(identifierToken);
+  }
+  isImportingIdentifier(identifierToken) {
+    const identifierName = identifierToken.text;
+    return this.importedIdentifiersNames.includes(identifierName);
+  }
+};
+
+// server/parser/token/ASTCollapsionBlock.js
+import ts from "typescript";
+
+// server/parser/range/ASTCoordinatesRange.js
+var ASTCoordinatesRange = class {
+  constructor(coordinates) {
+    this.coordinates = coordinates;
+  }
+  containsLineColumn(line, column) {
+    const startsBefore = this.coordinates.startLine < line || this.coordinates.startLine === line && this.coordinates.startColumn <= column;
+    const endsAfter = this.coordinates.endLine > line || this.coordinates.endLine === line && this.coordinates.endColumn > column;
+    return startsBefore && endsAfter;
+  }
+  containsCoordinates(childCoordinates) {
+    const { startLine, startColumn, endLine, endColumn } = childCoordinates;
+    const result = (this.coordinates.startLine < startLine || this.coordinates.startLine === startLine && this.coordinates.startColumn <= startColumn) && (this.coordinates.endLine > endLine || this.coordinates.endLine === endLine && this.coordinates.endColumn >= endColumn);
+    return result;
+  }
+  containsOrContainedBy(otherCoordinatesRange) {
+    return this.containsCoordinates(otherCoordinatesRange.coordinates) || otherCoordinatesRange.containsCoordinates(this.coordinates);
+  }
+  isEndLineAfter(line) {
+    return this.coordinates.endLine > line;
+  }
+  // TODO: Remove this after removing its usage
+  startsAt(line, column) {
+    return this.coordinates.startLine === line && this.coordinates.startColumn === column;
+  }
+};
+var ASTCoordinatesRangeSet = class {
+  constructor(ranges = []) {
+    this.ranges = ranges;
+  }
+  containsLineColumn(line, column) {
+    return this.ranges.some((range) => range.containsLineColumn(line, column));
+  }
+  containsCoordinates(childCoordinates) {
+    return this.ranges.some((range) => range.containsCoordinates(childCoordinates));
+  }
+  containsOrContainedBy(otherCoordinatesRange) {
+    return this.ranges.some((range) => range.containsOrContainedBy(otherCoordinatesRange));
+  }
+  isEndLineAfter(line) {
+    return this.ranges.some((range) => range.isEndLineAfter(line));
+  }
+  // TODO: Remove this after removing its usage
+  startsAt(line, column) {
+    return this.ranges.some((range) => range.startsAt(line, column));
+  }
+};
+
+// server/parser/token/ASTCollapsionBlock.js
+var COLLAPSABLE_NODES_TYPES = [
+  ts.SyntaxKind.FunctionDeclaration,
+  ts.SyntaxKind.PropertyDeclaration,
+  ts.SyntaxKind.PropertyAssignment,
+  ts.SyntaxKind.MethodDeclaration,
+  ts.SyntaxKind.ClassDeclaration,
+  ts.SyntaxKind.VariableDeclaration,
+  ts.SyntaxKind.ImportDeclaration,
+  ts.SyntaxKind.SourceFile,
+  // Additional function types
+  // ts.SyntaxKind.FunctionExpression,
+  // ts.SyntaxKind.ArrowFunction,
+  // Additional class/method types
+  ts.SyntaxKind.MethodSignature,
+  ts.SyntaxKind.Constructor,
+  ts.SyntaxKind.GetAccessor,
+  ts.SyntaxKind.SetAccessor,
+  ts.SyntaxKind.ClassExpression,
+  // TypeScript declarations
+  ts.SyntaxKind.InterfaceDeclaration,
+  ts.SyntaxKind.EnumDeclaration,
+  ts.SyntaxKind.TypeAliasDeclaration,
+  ts.SyntaxKind.ModuleDeclaration,
+  // Variable and import/export
+  // ts.SyntaxKind.VariableStatement,
+  ts.SyntaxKind.ExportDeclaration
+  // Control flow statements
+  // ts.SyntaxKind.IfStatement,
+  // ts.SyntaxKind.ForStatement,
+  // ts.SyntaxKind.ForInStatement,
+  // ts.SyntaxKind.ForOfStatement,
+  // ts.SyntaxKind.WhileStatement,
+  // ts.SyntaxKind.DoStatement,
+  // ts.SyntaxKind.SwitchStatement,
+  // ts.SyntaxKind.TryStatement,
+  // ts.SyntaxKind.CatchClause,
+  // Other
+  // ts.SyntaxKind.Block,
+  // ts.SyntaxKind.FunctionExpression,
+  // ts.SyntaxKind.ArrowFunction,
+];
+var ASTCollapsionBlock = class _ASTCollapsionBlock extends ASTToken {
+  constructor(rawToken, coordinates, text, lineNumber, isExpanded = false, type = null, idToken = null) {
+    super(rawToken);
+    this.coordinates = coordinates;
+    this.text = text;
+    this.lineNumber = lineNumber;
+    this.isExpanded = isExpanded;
+    this.type = type;
+    this.idToken = idToken;
+    this.className = "ASTCollapsionBlock";
+  }
+  isCollapsable() {
+    return COLLAPSABLE_NODES_TYPES.includes(this.rawToken.kind);
+  }
+  static fromJSON(json) {
+    return new _ASTCollapsionBlock(
+      rawTokenFromJSON(json.rawToken),
+      json.coordinates,
+      json.text,
+      json.lineNumber,
+      json.isExpanded,
+      json.type,
+      json.idToken ? ASTMatchedToken.fromJSON(json.idToken) : null
+    );
+  }
+  withType(type) {
+    return new _ASTCollapsionBlock(
+      this.rawToken,
+      this.coordinates,
+      this.text,
+      this.lineNumber,
+      this.isExpanded,
+      type,
+      this.idToken
+    );
+  }
+  toResponseJSON() {
+    return {
+      ...super.toResponseJSON(),
+      coordinates: this.coordinates,
+      isExpanded: this.isExpanded,
+      idToken: this.idToken?.toResponseJSON(),
+      type: this.type
+    };
+  }
+  coordinatesRange() {
+    return new ASTCoordinatesRange(this.coordinates);
+  }
+  isOneLine() {
+    return this.coordinates.startLine === this.coordinates.endLine;
+  }
+  expanded() {
+    return new _ASTCollapsionBlock(
+      this.rawToken,
+      this.coordinates,
+      this.text,
+      this.lineNumber,
+      true,
+      this.type,
+      this.idToken
+    );
+  }
+  findHeadIn(expandedTokens) {
+    return expandedTokens.find((token) => this.isHead(token));
+  }
+  // TODO: Duplicated in src/
+  isHead(token) {
+    if (this.rawToken.kind === ts.SyntaxKind.Constructor) {
+      return this.equals(token);
+    }
+    return this.idToken?.equals(token);
+  }
+};
+
+// server/parser/token/ASTMatchedToken.js
+import ts2 from "typescript";
+var VIEWABLE_TOKENS_TYPES = [
+  ts2.SyntaxKind.Identifier,
+  ts2.SyntaxKind.PrivateIdentifier,
+  ts2.SyntaxKind.NumericLiteral,
+  ts2.SyntaxKind.StringLiteral,
+  ts2.SyntaxKind.BigIntLiteral,
+  ts2.SyntaxKind.TrueKeyword,
+  ts2.SyntaxKind.FalseKeyword,
+  ts2.SyntaxKind.NullKeyword,
+  ts2.SyntaxKind.UndefinedKeyword,
+  ts2.SyntaxKind.ThisKeyword,
+  ts2.SyntaxKind.SuperKeyword,
+  ts2.SyntaxKind.JsxText,
+  ts2.SyntaxKind.JsxTextAllWhiteSpaces,
+  ts2.SyntaxKind.RegularExpressionLiteral,
+  ts2.SyntaxKind.NoSubstitutionTemplateLiteral,
+  ts2.SyntaxKind.TemplateHead,
+  ts2.SyntaxKind.TemplateMiddle,
+  ts2.SyntaxKind.TemplateTail
+];
+var ContextTokenType = {
+  Parent: "Parent",
+  Neighbor: "Neighbor",
+  DirectParent: "DirectParent",
+  FirstOnLine: "FirstOnLine",
+  LastOnLine: "LastOnLine"
+};
+var ASTMatchedToken = class _ASTMatchedToken extends ASTToken {
+  constructor(rawToken, view, type, collapsionBlock, isHidden = false, isManuallyExpanded = false, text = "", lineNumber = 0, parents = null) {
+    super(rawToken, collapsionBlock, isHidden, isManuallyExpanded);
+    this.className = "ASTMatchedToken";
+    this.view = view;
+    this.type = type;
+    this.text = text;
+    this.lineNumber = lineNumber;
+    this.parents = parents;
+  }
+  isViewable() {
+    return VIEWABLE_TOKENS_TYPES.includes(this.rawToken.kind);
+  }
+  withLineNumber(lineNumber) {
+    return new _ASTMatchedToken(
+      this.rawToken,
+      this.view,
+      this.type,
+      this.collapsionBlock,
+      this.isHidden,
+      this.isManuallyExpanded,
+      this.text,
+      lineNumber,
+      this.parents
+    );
+  }
+  withParents(parents) {
+    return new _ASTMatchedToken(
+      this.rawToken,
+      this.view,
+      this.type,
+      this.collapsionBlock,
+      this.isHidden,
+      this.isManuallyExpanded,
+      this.text,
+      this.lineNumber,
+      parents
+    );
+  }
+  withType(type) {
+    return new _ASTMatchedToken(
+      this.rawToken,
+      this.view,
+      type,
+      this.collapsionBlock,
+      this.isHidden,
+      this.isManuallyExpanded,
+      this.text,
+      this.lineNumber,
+      this.parents
+    );
+  }
+  withCollapsionBlock(collapsionBlock) {
+    return new _ASTMatchedToken(
+      this.rawToken,
+      this.view,
+      this.type,
+      collapsionBlock,
+      this.isHidden,
+      this.isManuallyExpanded,
+      this.text,
+      this.lineNumber,
+      this.parents
+    );
+  }
+  withRawToken(rawToken) {
+    return new _ASTMatchedToken(
+      rawToken,
+      this.view,
+      this.type,
+      this.collapsionBlock,
+      this.isHidden,
+      this.isManuallyExpanded,
+      this.text,
+      this.lineNumber,
+      this.parents
+    );
+  }
+  withText(text) {
+    return new _ASTMatchedToken(
+      this.rawToken,
+      this.view,
+      this.type,
+      this.collapsionBlock,
+      this.isHidden,
+      this.isManuallyExpanded,
+      text,
+      this.lineNumber,
+      this.parents
+    );
+  }
+  hidden() {
+    return new _ASTMatchedToken(
+      this.rawToken,
+      this.view,
+      this.type,
+      this.collapsionBlock,
+      true,
+      this.isManuallyExpanded,
+      this.text,
+      this.lineNumber,
+      this.parents
+    );
+  }
+  visible() {
+    return new _ASTMatchedToken(
+      this.rawToken,
+      this.view,
+      this.type,
+      this.collapsionBlock,
+      false,
+      this.isManuallyExpanded,
+      this.text,
+      this.lineNumber,
+      this.parents
+    );
+  }
+  manuallyExpanded() {
+    return new _ASTMatchedToken(
+      this.rawToken,
+      this.view,
+      this.type,
+      this.collapsionBlock,
+      this.isHidden,
+      true,
+      this.text,
+      this.lineNumber,
+      this.parents
+    );
+  }
+  // TODO: Instanciate this properly
+  toASTImportToken() {
+    return new ASTImportToken(this.rawToken);
+  }
+  static fromJSON(json) {
+    return new _ASTMatchedToken(
+      rawTokenFromJSON(json.rawToken),
+      json.view,
+      json.type,
+      json.collapsionBlock && ASTCollapsionBlock.fromJSON(json.collapsionBlock),
+      json.isHidden,
+      json.isManuallyExpanded,
+      json.text,
+      json.lineNumber,
+      json.parents
+    );
+  }
+};
+
+// server/parser/token/ASTCommentToken.js
+var ASTCommentToken = class _ASTCommentToken extends ASTMatchedToken {
+  constructor(rawToken, view, type, collapsionBlock, isHidden, isManuallyExpanded, text, lineNumber, parents) {
+    super(
+      rawToken,
+      view,
+      type,
+      collapsionBlock,
+      isHidden,
+      isManuallyExpanded,
+      text,
+      lineNumber,
+      parents
+    );
+    this.className = "ASTCommentToken";
+  }
+  withCollapsionBlock(collapsionBlock) {
+    return new _ASTCommentToken(
+      this.rawToken,
+      this.view,
+      this.type,
+      collapsionBlock,
+      this.isHidden,
+      this.isManuallyExpanded,
+      this.text,
+      this.lineNumber,
+      this.parents
+    );
+  }
+  withRawToken(rawToken) {
+    return new _ASTCommentToken(
+      rawToken,
+      this.view,
+      this.type,
+      this.collapsionBlock,
+      this.isHidden,
+      this.isManuallyExpanded,
+      this.text,
+      this.lineNumber,
+      this.parents
+    );
+  }
+  withParents(parents) {
+    return new _ASTCommentToken(
+      this.rawToken,
+      this.view,
+      this.type,
+      this.collapsionBlock,
+      this.isHidden,
+      this.isManuallyExpanded,
+      this.text,
+      this.lineNumber,
+      parents
+    );
+  }
+  createIdRawToken() {
+    return {
+      type: "BlockCommentId",
+      start: this.rawToken.start,
+      end: this.rawToken.start + 1,
+      loc: {
+        start: {
+          line: this.rawToken.loc.start.line,
+          column: this.rawToken.loc.start.column
+        },
+        end: {
+          line: this.rawToken.loc.start.line,
+          column: this.rawToken.loc.start.column + 1
+        }
+      }
+    };
+  }
+  endsAt(end) {
+    return this.rawToken.end === end && endsWithNewLine(this.rawToken.value);
+  }
+  endsAtCoordinates(line, column) {
+    return this.rawToken.loc.end.line === line && this.rawToken.loc.end.column === column && endsWithNewLine(this.rawToken.value);
+  }
+  startsAtCoordinates(line, column) {
+    return this.rawToken.loc.start.line === line && this.rawToken.loc.start.column === column;
+  }
+  static chainItem(rawToken, collapsionBlock, text, lineNumber) {
+    return new _ASTCommentToken(
+      rawToken,
+      null,
+      null,
+      collapsionBlock,
+      false,
+      true,
+      text,
+      lineNumber
+    );
+  }
+  static build(token, fullText) {
+    return new _ASTCommentToken(createCommentRawToken(token, fullText));
+  }
+};
+
+// server/parser/ast/ASTTokenResolver.js
+var STRATEGIES = {
+  NewLineToken: "NewLineToken"
+};
+var ASTTokenResolver = class {
+  constructor(ast, linesToTokens) {
+    this.ast = ast;
+    this.linesToTokens = linesToTokens;
+    this.line = 0;
+    this.column = 0;
+    this.type = null;
+  }
+  coordinates(rawToken) {
+    const startLoc = this.ast.getLineAndCharacterOfPosition(rawToken.getStart());
+    const endLoc = this.ast.getLineAndCharacterOfPosition(rawToken.getEnd());
+    return {
+      startLine: startLoc.line + 1,
+      startColumn: startLoc.character,
+      endLine: endLoc.line + 1,
+      endColumn: endLoc.character,
+      type: rawToken.kind
+    };
+  }
+  _searchContainerInLine(lineNumber) {
+    const lineTokens = this.linesToTokens.get(lineNumber);
+    if (!lineTokens) {
+      return;
+    }
+    for (let i = lineTokens.length - 1; i >= 0; i--) {
+      const token = lineTokens[i];
+      const coordinatesRange = new ASTCoordinatesRange(this.coordinates(token.rawToken));
+      if (coordinatesRange.containsLineColumn(this.line, this.column)) {
+        if (!this.strategy) {
+          return token;
+        }
+        const isEqual = token.rawToken.kind === this.type && coordinatesRange.startsAt(this.line, this.column);
+        if (isEqual) {
+          continue;
+        }
+        if (this.strategy === STRATEGIES.NewLineToken && coordinatesRange.isEndLineAfter(this.line)) {
+          return token;
+        }
+      }
+    }
+  }
+  _tokenIndexInLine() {
+    let searchLine = this.line;
+    let tokenIndex = null;
+    while (searchLine >= 0 && !tokenIndex) {
+      tokenIndex = this._searchContainerInLine(searchLine);
+      searchLine--;
+    }
+    return this.linesToTokens.get(searchLine + 1)?.indexOf(tokenIndex);
+  }
+  newLineToken(token) {
+    const tokenCoordinates = this.coordinates(token.rawToken);
+    this.line = tokenCoordinates.startLine;
+    this.column = tokenCoordinates.startColumn;
+    this.type = tokenCoordinates.type;
+    this.strategy = STRATEGIES.NewLineToken;
+    return this.token(this.line, this.column);
+  }
+  // TODO: what if target location outside file boundaries
+  token(line, column) {
+    this.line = line;
+    this.column = column;
+    let searchLine = this.line;
+    let token = null;
+    while (searchLine >= 0 && !token) {
+      token = this._searchContainerInLine(searchLine);
+      searchLine--;
+    }
+    return token;
+  }
+  tokenAtStart(start) {
+    const coordinates = this.ast.getLineAndCharacterOfPosition(start);
+    return this.token(coordinates.line + 1, coordinates.character);
+  }
+  tokensInBetween(range) {
+    const tokenCoordinates = this.coordinates(range.startToken.rawToken);
+    this.line = tokenCoordinates.startLine;
+    this.column = tokenCoordinates.startColumn;
+    this.type = tokenCoordinates.type;
+    let searchLine = this.line;
+    let lineTokens = this.linesToTokens.get(searchLine);
+    let tokenIndexCursorIndex = this._tokenIndexInLine();
+    let token = lineTokens?.at(tokenIndexCursorIndex);
+    const result = [];
+    while (token?.rawToken.getStart() <= range.endToken.rawToken.getEnd()) {
+      if (range.containsToken(token)) {
+        result.push(token);
+      }
+      tokenIndexCursorIndex = (tokenIndexCursorIndex + 1) % lineTokens?.length;
+      if (tokenIndexCursorIndex === 0) {
+        searchLine = searchLine + 1;
+        lineTokens = this.linesToTokens.get(searchLine);
+      }
+      token = lineTokens?.at(tokenIndexCursorIndex);
+    }
+    return result;
+  }
+};
+
+// server/parser/ast/AST.js
+import ts4 from "typescript";
+
+// server/parser/token/ASTCollapsionBlockFactory.js
+import ts3 from "typescript";
+var ASTCollapsionBlockFactory = class {
+  constructor(resolver) {
+    this.resolver = resolver;
+  }
+  isCollapsable(node) {
+    return COLLAPSABLE_NODES_TYPES.includes(node.kind);
+  }
+  createInDirectChildren(token) {
+    const result = [];
+    const addCollapsionBlock = (node) => {
+      switch (node.kind) {
+        case ts3.SyntaxKind.ImportDeclaration:
+          if (node.importClause?.name) {
+            result.push(this.createFrom(node));
+          }
+          break;
+        case ts3.SyntaxKind.VariableStatement:
+          ts3.forEachChild(node.declarationList, addCollapsionBlock);
+          break;
+        case ts3.SyntaxKind.ExportDeclaration:
+          if (node.exportClause && node.exportClause.kind === ts3.SyntaxKind.NamedExports) {
+            result.push(this.createFrom(node));
+          }
+          break;
+        case ts3.SyntaxKind.VariableDeclaration:
+        case ts3.SyntaxKind.FunctionDeclaration:
+        case ts3.SyntaxKind.ClassDeclaration:
+        case ts3.SyntaxKind.ClassExpression:
+        case ts3.SyntaxKind.PropertyDeclaration:
+        case ts3.SyntaxKind.PropertyAssignment:
+        case ts3.SyntaxKind.MethodDeclaration:
+        case ts3.SyntaxKind.MethodSignature:
+        case ts3.SyntaxKind.GetAccessor:
+        case ts3.SyntaxKind.SetAccessor:
+        case ts3.SyntaxKind.InterfaceDeclaration:
+        case ts3.SyntaxKind.EnumDeclaration:
+        case ts3.SyntaxKind.TypeAliasDeclaration:
+        case ts3.SyntaxKind.ModuleDeclaration:
+          if (node.name && node.pos !== token.rawToken.pos) {
+            result.push(this.createFrom(node));
+          }
+          break;
+      }
+    };
+    ts3.forEachChild(token.rawToken, addCollapsionBlock);
+    return result;
+  }
+  createIdToken(node) {
+    let result;
+    switch (node.kind) {
+      case ts3.SyntaxKind.VariableDeclaration:
+      case ts3.SyntaxKind.FunctionDeclaration:
+      case ts3.SyntaxKind.ClassDeclaration:
+      case ts3.SyntaxKind.ClassExpression:
+      case ts3.SyntaxKind.PropertyDeclaration:
+      case ts3.SyntaxKind.PropertyAssignment:
+      case ts3.SyntaxKind.MethodDeclaration:
+      case ts3.SyntaxKind.MethodSignature:
+      case ts3.SyntaxKind.GetAccessor:
+      case ts3.SyntaxKind.SetAccessor:
+      case ts3.SyntaxKind.InterfaceDeclaration:
+      case ts3.SyntaxKind.EnumDeclaration:
+      case ts3.SyntaxKind.TypeAliasDeclaration:
+      case ts3.SyntaxKind.ModuleDeclaration:
+        if (node.name) {
+          result = node.name;
+        }
+        break;
+      // TODO: can we collapse the constructor?
+      case ts3.SyntaxKind.Constructor:
+        result = node.getFirstToken();
+        break;
+      case ts3.SyntaxKind.ImportDeclaration:
+        if (node.importClause?.name) {
+          result = node.importClause.name;
+        } else {
+          result = node.importClause?.namedBindings?.elements?.[0]?.name;
+        }
+        break;
+      case ts3.SyntaxKind.ExportDeclaration:
+        if (node.moduleSpecifier) {
+          result = node.moduleSpecifier;
+        }
+        break;
+      case ts3.SyntaxKind.SourceFile:
+        result = null;
+        break;
+      case "Block": {
+        result = new ASTCommentToken(node).createIdRawToken();
+        break;
+      }
+    }
+    if (!result) {
+      return null;
+    }
+    return new ASTMatchedToken(result);
+  }
+  // TODO: Implement this properly
+  createFrom(node) {
+    return new ASTCollapsionBlock(
+      node,
+      this.resolver.coordinates(node),
+      null,
+      0,
+      false,
+      null,
+      this.createIdToken(node)
+    );
+  }
+};
+
+// server/parser/ast/AST.js
+var AST = class {
+  constructor(ast, linesToTokens, collapsionBlocks, collapsableCollapsionBlocks) {
+    this.ast = ast;
+    this.linesToTokens = linesToTokens;
+    this.collapsionBlocks = collapsionBlocks;
+    this.collapsableCollapsionBlocks = collapsableCollapsionBlocks;
+    this.resolver = new ASTTokenResolver(this.ast, this.linesToTokens);
+    this.collapsionBlockFactory = new ASTCollapsionBlockFactory(this.resolver);
+  }
+  // TODO: Duplicated in ASTBuilder.js
+  nodeId(token) {
+    const node = token.rawToken;
+    return `${node.getStart()}-${node.getEnd()}-${node.kind}`;
+  }
+  // TODO: Remove second arg flag, only for testing now
+  contextTokens(range, includeNonCollapsable = false) {
+    const tokensInBetween = this.resolver.tokensInBetween(range);
+    const rawResult = /* @__PURE__ */ new Map();
+    for (let i = 0; i < tokensInBetween.length; i++) {
+      const eachToken = tokensInBetween[i];
+      for (let j = 0; j < eachToken.parents.length; j++) {
+        const eachParent = eachToken.parents[j];
+        if (eachParent.isCollapsable() || includeNonCollapsable)
+          rawResult.set(this.nodeId(eachParent), eachParent);
+        const collapsionBlocks = this.collapsionBlockFactory.createInDirectChildren(eachParent);
+        for (let k = 0; k < collapsionBlocks.length; k++) {
+          const eachNeighobor = collapsionBlocks[k];
+          if ((eachNeighobor.isCollapsable() || includeNonCollapsable) && !rawResult.has(this.nodeId(eachNeighobor))) {
+            rawResult.set(
+              this.nodeId(eachNeighobor),
+              eachNeighobor.withType(ContextTokenType.Neighbor)
+            );
+          }
+        }
+      }
+    }
+    return Array.from(rawResult.values());
+  }
+  findIdentifierTokenIn(node, identifierName) {
+    switch (node.kind) {
+      case ts4.SyntaxKind.Identifier:
+        if (node.getText() === identifierName) {
+          return this.resolver.tokenAtStart(node.getStart());
+        }
+        break;
+    }
+    return null;
+  }
+  // TODO: Improve this
+  findImportTokenIn(node) {
+    let importString = null, importedIdentifiersNames = [];
+    switch (node.kind) {
+      // TODO: Handle default import: import * as X from 'module'
+      // TODO: export { X } from 'module'
+      case ts4.SyntaxKind.ImportDeclaration:
+        if (this.isImportDeclarationForIdentifier(node)) {
+          importString = node.moduleSpecifier.text;
+          importedIdentifiersNames.push(
+            ...node.importClause.namedBindings.elements.map((el) => el.name.text)
+          );
+        }
+        break;
+      // TODO: Test this well
+      case ts4.SyntaxKind.CallExpression:
+        if (this.isImportExpressionForIdentifier(node)) {
+          importString = node.arguments[0].text;
+          importedIdentifiersNames.push(node.parent.name.text);
+        }
+        break;
+    }
+    if (!importString) {
+      return null;
+    }
+    const token = this.resolver.tokenAtStart(node.getStart());
+    return token.toASTImportToken().withImportString(importString).withImportedIdentifiersNames(importedIdentifiersNames);
+  }
+  // TODO: Improve this
+  isImportDeclarationForIdentifier(node) {
+    let result = false;
+    if (node.importClause && node.moduleSpecifier) {
+      if (node.importClause.namedBindings?.kind === ts4.SyntaxKind.NamedImports) {
+        result = node.importClause.namedBindings.elements.length > 0;
+      }
+    }
+    return result;
+  }
+  // TODO: Handle import() calls
+  // TODO: Improve this
+  isImportExpressionForIdentifier(node) {
+    if (node.expression.kind === ts4.SyntaxKind.Identifier && node.expression.text === "require" && node.arguments.length > 0 && node.arguments[0].kind === ts4.SyntaxKind.StringLiteral) {
+      if (node.parent && node.parent.kind === ts4.SyntaxKind.VariableDeclaration) {
+        const varDecl = node.parent;
+        if (varDecl.name && varDecl.name.kind === ts4.SyntaxKind.Identifier) {
+          return !!varDecl.name.text;
+        }
+      }
+    }
+  }
+};
+
+// server/parser/range/ASTTokenRangeFactory.js
+var ASTTokenRangeFactory = class {
+  constructor(astTokensRange, ast) {
+    this.astTokensRange = astTokensRange;
+    this.ast = ast;
+  }
+  correctBoundaries() {
+    return this.astTokensRange instanceof ASTTokensRangeSet ? new ASTTokensRangeSet(
+      this.astTokensRange.ranges.map(
+        (each) => new ASTTokensRange(
+          this.ast.resolver.tokenAtStart(each.startToken.rawToken.getStart()),
+          this.ast.resolver.tokenAtStart(each.endToken.rawToken.getEnd())
+        )
+      )
+    ) : new ASTTokensRange(
+      this.ast.resolver.tokenAtStart(this.astTokensRange.startToken.rawToken.getStart()),
+      this.ast.resolver.tokenAtStart(this.astTokensRange.endToken.rawToken.getEnd())
+    );
+  }
+  createContextTokens() {
+    return this.astTokensRange instanceof ASTTokensRangeSet ? this.astTokensRange.ranges.flatMap((each) => this.ast.contextTokens(each)) : this.ast.contextTokens(this.astTokensRange);
+  }
+  fromJson() {
+    return this.astTokensRange.ranges ? new ASTTokensRangeSet(
+      this.astTokensRange.ranges.map(
+        (each) => new ASTTokensRange(
+          ASTMatchedToken.fromJSON(each.startToken),
+          ASTMatchedToken.fromJSON(each.endToken)
+        )
+      )
+    ) : new ASTTokensRange(
+      ASTMatchedToken.fromJSON(this.astTokensRange.startToken),
+      ASTMatchedToken.fromJSON(this.astTokensRange.endToken)
+    );
+  }
+};
+
+// server/note/ASTNote.js
+var ASTNote = class _ASTNote {
+  constructor(idx, file, selection, contextTokens = []) {
+    if (!idx) {
+      this.idx = Math.floor(Math.random() * 999999) + 1;
+    } else {
+      this.idx = idx;
+    }
+    this.file = file;
+    this.selection = selection;
+    this.contextTokens = contextTokens;
+  }
+  recreate() {
+    return new _ASTNote(null, this.file, this.selection, this.contextTokens);
+  }
+  takeBoundaryTokensFrom(ast) {
+    const selection = new ASTTokenRangeFactory(this.selection, ast).correctBoundaries();
+    return new _ASTNote(this.idx, this.file, selection, this.contextTokens);
+  }
+  takeContextTokensFrom(ast) {
+    const contextTokens = new ASTTokenRangeFactory(this.selection, ast).createContextTokens();
+    return new _ASTNote(this.idx, this.file, this.selection, contextTokens);
+  }
+  toStorageJSON() {
+    return {
+      idx: this.idx,
+      file: this.file,
+      selection: this.selection.toResponseJSON(),
+      contextTokens: this.contextTokens.map((token) => token.toResponseJSON())
+    };
+  }
+  toResponseJSON() {
+    return {
+      idx: this.idx,
+      file: this.file,
+      selection: this.selection.toResponseJSON(),
+      contextTokens: this.contextTokens.map((token) => token.toResponseJSON())
+    };
+  }
+  static fromJSON(noteObject) {
+    if (!noteObject?.selection && !noteObject?.subNotes?.length) {
+      throw new Error("ASTNote.fromJSON: missing selection: " + JSON.stringify(noteObject));
+    }
+    const selection = new ASTTokenRangeFactory(noteObject.selection).fromJson();
+    return new _ASTNote(noteObject.idx, noteObject.file, selection, noteObject.contextTokens);
+  }
+};
+var ASTNote_default = ASTNote;
+
+// server/note/ASTSelectionBuilder.js
+var ASTSelectionBuilder = class {
+  constructor(astResolver) {
+    this.astResolver = astResolver;
+    this.startLine = null;
+    this.startColumn = null;
+    this.endLine = null;
+    this.endColumn = null;
+  }
+  startLineIndex() {
+    return this.startLine - 1;
+  }
+  setResolver(astResolver) {
+    this.astResolver = astResolver;
+  }
+  // 2. After parse(), before analyse(), called for new note
+  setCoordinatesFrom(selection) {
+    const resolvedStartCoordinates = this.astResolver.coordinates(selection.startToken.rawToken);
+    const resolvedEndCoordinates = this.astResolver.coordinates(selection.endToken.rawToken);
+    this.startLine = resolvedStartCoordinates.startLine;
+    this.startColumn = resolvedStartCoordinates.startColumn;
+    this.endLine = resolvedEndCoordinates.startLine;
+    this.endColumn = resolvedEndCoordinates.endColumn - 1;
+  }
+  // 2. After parse(), before analyse()
+  shiftCoordinates(oldCoordinates, lineIndex) {
+    this.startLine = lineIndex + 1;
+    this.endLine = lineIndex + 1 + (oldCoordinates.endLine - oldCoordinates.startLine);
+    this.startColumn = oldCoordinates.startColumn;
+    this.endColumn = oldCoordinates.endColumn;
+  }
+  // 4. After analyse()
+  createSelection() {
+    return new ASTTokensRange(
+      this.astResolver.token(this.startLine, this.startColumn),
+      this.astResolver.token(this.endLine, this.endColumn)
+    );
+  }
+  //
+  createCoordinatesJSON() {
+    return {
+      startLine: this.startLine,
+      startColumn: this.startColumn,
+      endLine: this.endLine,
+      endColumn: this.endColumn
+    };
+  }
+};
+var ASTSelectionBuilderSet = class {
+  constructor(astResolver) {
+    this.astResolver = astResolver;
+    this.ranges = [];
+  }
+  startLineIndex() {
+    return this.ranges.map((each) => each.startLine);
+  }
+  setResolver(astResolver) {
+    this.astResolver = astResolver;
+    this.ranges.forEach((builder) => builder.setResolver(astResolver));
+  }
+  setCoordinatesFrom(selection) {
+    this.ranges = selection.ranges.map((range) => {
+      const builder = new ASTSelectionBuilder(this.astResolver);
+      builder.setCoordinatesFrom(range);
+      return builder;
+    });
+  }
+  shiftCoordinates(oldCoordinates, lineIndex) {
+    this.ranges = oldCoordinates.ranges.map((rangeCoordinates, i) => {
+      const builder = new ASTSelectionBuilder(this.astResolver);
+      builder.shiftCoordinates(rangeCoordinates, lineIndex[i]);
+      return builder;
+    });
+  }
+  createSelection() {
+    return new ASTTokensRangeSet(this.ranges.map((builder) => builder.createSelection()));
+  }
+  createCoordinatesJSON() {
+    return {
+      ranges: this.ranges.map((builder) => builder.createCoordinatesJSON())
+    };
+  }
+};
+
+// server/text/SourceCodeLine.js
+import { distance } from "fastest-levenshtein";
+var SourceCodeLine = class {
+  constructor(content) {
+    this.content = content;
+  }
+  isSameAs(otherLineContent) {
+    return this.content === otherLineContent;
+  }
+  isApproxiametly(otherLineContent) {
+    if (this.content.replace(/\s/g, "") === otherLineContent.replace(/\s/g, "")) {
+      return true;
+    }
+    const maxLen = Math.max(this.content.length, otherLineContent.length);
+    if (maxLen === 0) return true;
+    return distance(this.content, otherLineContent) / maxLen <= 0.1;
+  }
+};
+
+// server/note/LinesWindow.js
+var LinesWindow = class _LinesWindow {
+  constructor(coordinates, fileLines, revision) {
+    this.coordinates = coordinates;
+    this.fileLines = fileLines;
+    this.revision = revision;
+    this.linesBefore = [];
+    this.currentLines = [];
+    this.linesAfter = [];
+  }
+  shouldAddLinesContext() {
+    const isNewNote = !this.coordinates;
+    return !isNewNote && !this.currentLines.length;
+  }
+  linesBeforeStartIndex() {
+    return Math.max(0, this.coordinates.startLine - 6);
+  }
+  addLinesContext() {
+    this.linesBefore = this.calculateLinesBefore();
+    this.currentLines = this.calculateCurrentLines();
+    this.linesAfter = this.calculateLinesAfter();
+  }
+  calculateLinesBefore() {
+    return this.fileLines.slice(this.linesBeforeStartIndex(), this.coordinates.startLine - 1);
+  }
+  calculateLinesAfter() {
+    return this.fileLines.slice(this.coordinates.endLine, this.coordinates.endLine + 5);
+  }
+  calculateCurrentLines() {
+    return this.fileLines.slice(this.coordinates.startLine - 1, this.coordinates.endLine);
+  }
+  areCurrentLinesUnchanged() {
+    const newCurrentLines = this.calculateCurrentLines();
+    return Array.isArray(this.currentLines) && Array.isArray(newCurrentLines) && this.currentLines.length === newCurrentLines.length && this.currentLines.every(
+      (line, idx) => new SourceCodeLine(line).isApproxiametly(newCurrentLines[idx])
+    );
+  }
+  newStartLineIndex() {
+    let startIndexOffset = [
+      ...this.calculateLinesBefore(),
+      ...this.calculateCurrentLines(),
+      ...this.calculateLinesAfter()
+    ].indexOf(this.currentLines[0]);
+    if (this.currentLines.length > 0 && startIndexOffset === -1) {
+      return null;
+    }
+    const startIndex = this.linesBeforeStartIndex() + startIndexOffset;
+    const isSame = this.currentLines.every(
+      (line, idx) => new SourceCodeLine(line).isApproxiametly(this.fileLines[startIndex + idx])
+    );
+    if (isSame) {
+      return startIndex;
+    }
+    return null;
+  }
+  setCoordinates(coordinates) {
+    this.coordinates = coordinates;
+  }
+  //
+  toStorageJSON() {
+    return {
+      linesBefore: this.linesBefore,
+      currentLines: this.currentLines,
+      linesAfter: this.linesAfter,
+      revision: this.revision
+    };
+  }
+  static fromJSON(storageJSON, fileLines) {
+    if (storageJSON.startLine) {
+      return new _LinesWindow(storageJSON, fileLines);
+    }
+    const result = new _LinesWindow(storageJSON.coordinates, fileLines, storageJSON.revision);
+    result.linesBefore = storageJSON.linesBefore;
+    result.currentLines = storageJSON.currentLines;
+    result.linesAfter = storageJSON.linesAfter;
+    return result;
+  }
+};
+var MultiRangeLinesWindows = class _MultiRangeLinesWindows {
+  constructor(ranges = [], fileLines, revision) {
+    this.ranges = ranges;
+    this.fileLines = fileLines;
+    this.revision = revision;
+  }
+  setFileLines(fileLines) {
+    this.fileLines = fileLines;
+    this.ranges.forEach((each) => each.fileLines = fileLines);
+  }
+  setCoordinates(coordinatesWithRanges) {
+    this.ranges = coordinatesWithRanges.ranges.map((each) => new LinesWindow(each, this.fileLines));
+  }
+  shouldAddLinesContext() {
+    return this.ranges.some((w) => w.shouldAddLinesContext());
+  }
+  addLinesContext() {
+    this.ranges.forEach((each) => each.addLinesContext());
+  }
+  areCurrentLinesUnchanged() {
+    return this.ranges.every((each) => each.areCurrentLinesUnchanged());
+  }
+  newStartLineIndex() {
+    const result = this.ranges.map((each) => each.newStartLineIndex());
+    if (result.every((each) => !each)) {
+      return null;
+    }
+    return result;
+  }
+  toStorageJSON() {
+    return {
+      ranges: this.ranges.map((each) => each.toStorageJSON()),
+      revision: this.revision
+    };
+  }
+  static fromCoordinates(coordinates, fileLines) {
+    return new _MultiRangeLinesWindows(
+      coordinates?.ranges.map((eachCoodinates) => new LinesWindow(eachCoodinates, fileLines)),
+      fileLines
+    );
+  }
+  static fromJSON(storageJSON, fileLines) {
+    const result = new _MultiRangeLinesWindows(
+      storageJSON.coordinates?.ranges.map((each) => LinesWindow.fromJSON(each, fileLines)) ?? [],
+      fileLines,
+      storageJSON.revision
+    );
+    return result;
+  }
+};
+
+// server/storage/StoredNote.js
+var NOTES_TYPES = {
+  NOTE: "NOTE",
+  OUTDATED_NOTE: "OUTDATED_NOTE"
+};
+var StoredNote = class _StoredNote {
+  constructor(note, fileLines, shouldRecalculateSelection = false, newLineIndex = 0, subNotes = [], coordinates = null, diff = null) {
+    this.note = note;
+    this.fileLines = fileLines;
+    this.shouldRecalculateSelection = shouldRecalculateSelection;
+    this.newLineIndex = newLineIndex;
+    this.subNotes = subNotes;
+    this.coordinates = coordinates;
+    this.diff = diff;
+    this.type = NOTES_TYPES.NOTE;
+    this.inputValue = null;
+    this.inputPosition = null;
+    const isMultiSelection = this.note.selection instanceof ASTTokensRangeSet;
+    this.linesWindow = isMultiSelection ? MultiRangeLinesWindows.fromCoordinates(coordinates, fileLines) : new LinesWindow(coordinates, fileLines);
+  }
+  get isOutdated() {
+    return this.type === NOTES_TYPES.OUTDATED_NOTE;
+  }
+  // 1. before parse()
+  checkIfUpToDate() {
+    if (!this.coordinates) {
+      this.shouldRecalculateSelection = true;
+      return;
+    }
+    if (this.linesWindow.areCurrentLinesUnchanged()) {
+      this.linesWindow.addLinesContext();
+      return;
+    }
+    const newIndex = this.linesWindow.newStartLineIndex();
+    if (newIndex === null) {
+      this.toOutdatedNote();
+      return;
+    }
+    this.shouldRecalculateSelection = true;
+    this.newLineIndex = newIndex;
+  }
+  // 2. After parse(), before analyse(), called if shouldRecalculateSelection is true
+  createSelectionBuilderFrom(astResolver) {
+    const isNewNote = !this.newLineIndex;
+    if (!isNewNote && !this.coordinates) {
+      throw new Error(
+        "StoredNote#createSelectionBuilderFrom: Coordinates must be provided for existing note"
+      );
+    }
+    const oldCoordinates = this.coordinates;
+    const isMultiSelection = isNewNote ? this.note.selection instanceof ASTTokensRangeSet : oldCoordinates.ranges;
+    this.coordinates = isMultiSelection ? new ASTSelectionBuilderSet(astResolver) : new ASTSelectionBuilder(astResolver);
+    if (isNewNote) {
+      this.coordinates.setCoordinatesFrom(this.note.selection);
+      this.newLineIndex = this.coordinates.startLineIndex();
+    } else {
+      this.coordinates.shiftCoordinates(oldCoordinates, this.newLineIndex);
+    }
+    this.linesWindow.setCoordinates(this.coordinates);
+  }
+  // 3. During analyse(), after parse()
+  coordinatesRange() {
+    const rangeJSON = this.shouldRecalculateSelection ? this.coordinates.createCoordinatesJSON() : this.coordinates;
+    return rangeJSON.ranges ? new ASTCoordinatesRangeSet(rangeJSON.ranges.map((range) => new ASTCoordinatesRange(range))) : new ASTCoordinatesRange(rangeJSON);
+  }
+  // 4. After both analyse() and parse(), called if shouldRecalculateSelection is true
+  recalculateSelectionAndLines(resolver, currentRevision) {
+    this.coordinates.setResolver(resolver);
+    this.note.selection = this.coordinates.createSelection();
+    this.linesWindow.addLinesContext();
+    this.linesWindow.revision = currentRevision;
+  }
+  //
+  toOutdatedNote() {
+    this.type = NOTES_TYPES.OUTDATED_NOTE;
+  }
+  //
+  toStorageJSON() {
+    const isSelectionBuilder = this.coordinates instanceof ASTSelectionBuilder || this.coordinates instanceof ASTSelectionBuilderSet;
+    const coordinates = isSelectionBuilder ? this.coordinates.createCoordinatesJSON() : this.coordinates;
+    return {
+      ...this.note.toStorageJSON(),
+      ...this.linesWindow.toStorageJSON(),
+      coordinates,
+      inputValue: this.inputValue,
+      inputPosition: this.inputPosition,
+      diff: this.diff,
+      subNotes: this.subNotes?.map((eachSubNote) => eachSubNote.toStorageJSON()),
+      type: this.type
+    };
+  }
+  toResponseJSON() {
+    return {
+      ...this.note.toResponseJSON(),
+      inputValue: this.inputValue,
+      inputPosition: this.inputPosition,
+      diff: this.diff,
+      subNotes: this.subNotes.map((eachSubNote) => eachSubNote.toResponseJSON())
+    };
+  }
+  // TODO: Fix this
+  createChildFromDiff(diff) {
+    const note = this.note.recreate();
+    const result = new _StoredNote(note);
+    result.inputValue = diff.title.trim() || "AI suggestion [Diff]";
+    result.diff = diff;
+    return result;
+  }
+  // TODO: Fix this
+  createChildFromAnnotation(annotation) {
+    const note = this.note.recreate();
+    const result = new _StoredNote(note);
+    result.coordinates = this.coordinates;
+    result.inputValue = annotation.title.trim() || "AI suggestion [Annotation]";
+    return result;
+  }
+  static fromJSON(storageJSON, fileLines) {
+    const result = new _StoredNote(ASTNote_default.fromJSON(storageJSON), fileLines);
+    const isMultiSelectionNote = result.linesWindow instanceof MultiRangeLinesWindows;
+    result.linesWindow = isMultiSelectionNote ? MultiRangeLinesWindows.fromJSON(storageJSON, fileLines) : LinesWindow.fromJSON(storageJSON, fileLines);
+    if (fileLines && result.linesWindow.shouldAddLinesContext()) {
+      result.linesWindow.addLinesContext();
+    }
+    result.coordinates = storageJSON.coordinates;
+    result.inputValue = storageJSON.inputValue;
+    result.inputPosition = storageJSON.inputPosition;
+    result.diff = storageJSON.diff;
+    result.subNotes = storageJSON.subNotes?.map(
+      (eachSubNote) => _StoredNote.fromJSON(eachSubNote, fileLines)
+    );
+    return result;
+  }
+};
+
+// server/parser/ast/ASTBuilder.js
+var ASTBuilder = class {
+  constructor(filePath, content, focused) {
+    this.filePath = filePath;
+    this.content = content;
+    this.focused = focused;
+    this.ast = null;
+    this.astTokenResolver = null;
+    this.astCollapsionBlockFactory = null;
+    this.tsCompilerAST = null;
+    this.linesToTokens = /* @__PURE__ */ new Map();
+    this.nodeIdToCollapsionBlock = /* @__PURE__ */ new Map();
+    this.collapsableCollapsionBlocks = /* @__PURE__ */ new Set();
+    this.nodeIdToComment = /* @__PURE__ */ new Map();
+  }
+  // TODO: Duplicated in AST.js
+  nodeId(node) {
+    return `${node.getStart()}-${node.getEnd()}-${node.kind}`;
+  }
+  // TODO: Generalize this, parse <script .../> blocks for all HTML files too
+  extractCodeFromVueFile() {
+    let content = this.content;
+    const scriptMatch = content.match(/<script[^>]*>([\s\S]*?)<\/script>/i);
+    let beforeScript = "";
+    let afterScript = "";
+    if (scriptMatch) {
+      const scriptStart = scriptMatch.index;
+      const scriptEnd = scriptStart + scriptMatch[0].length;
+      const scriptTagStart = content.indexOf("<script", scriptStart);
+      beforeScript = content.slice(0, scriptTagStart + "<script".length);
+      const scriptTagEnd = content.indexOf("</script>", scriptEnd - "</script>".length);
+      afterScript = content.slice(scriptTagEnd);
+      const beforeLines = new TextReader(beforeScript).toEmptyLines();
+      const afterLines = new TextReader(afterScript).toEmptyLines();
+      return beforeLines + scriptMatch[1] + afterLines;
+    }
+  }
+  // TODO: Optimize this (it's called by every node from this.parentsTokens())
+  createCollapsionBlock(node) {
+    const nodeId = this.nodeId(node);
+    let collapsionBlock;
+    if (this.nodeIdToCollapsionBlock.has(nodeId)) {
+      collapsionBlock = this.nodeIdToCollapsionBlock.get(nodeId);
+    } else {
+      collapsionBlock = this.astCollapsionBlockFactory.createFrom(node);
+    }
+    const isExpanded = !this.focused || this.focused.type === NOTES_TYPES.OUTDATED_NOTE || this.focused.coordinatesRange().containsOrContainedBy(collapsionBlock.coordinatesRange());
+    const result = isExpanded ? collapsionBlock.expanded() : collapsionBlock;
+    this.nodeIdToCollapsionBlock.set(nodeId, result);
+    return result;
+  }
+  tokenContext(ancestors) {
+    const node = ancestors.at(-1);
+    let collapsionBlock = node.kind === ts5.SyntaxKind.SourceFile ? this.createCollapsionBlock(node) : null, parents = [];
+    for (let i = ancestors.length - 2; i >= 0; i--) {
+      const eachAncestor = ancestors[i];
+      const ancestorCollapsionBlock = this.createCollapsionBlock(eachAncestor);
+      if (!!collapsionBlock || !this.astCollapsionBlockFactory.isCollapsable(eachAncestor)) {
+        parents.push(ancestorCollapsionBlock.withType(ContextTokenType.Parent));
+      }
+      if (!collapsionBlock && this.astCollapsionBlockFactory.isCollapsable(eachAncestor)) {
+        collapsionBlock = ancestorCollapsionBlock;
+        parents.unshift(ancestorCollapsionBlock.withType(ContextTokenType.DirectParent));
+        this.collapsableCollapsionBlocks.add(ancestorCollapsionBlock);
+      }
+    }
+    return { collapsionBlock, parents };
+  }
+  parse() {
+    let content = "";
+    if (!ANNOTABLE_EXTENSIONS.test(this.filePath)) {
+      content = "";
+    } else if (VUE_JS_EXTENSIONS.test(this.filePath)) {
+      content = this.extractCodeFromVueFile() || this.content;
+    } else {
+      content = this.content;
+    }
+    this.tsCompilerAST = ts5.createSourceFile(
+      this.filePath,
+      content,
+      ts5.ScriptTarget.Latest,
+      true,
+      // TODO: inject these
+      this.filePath.endsWith(".jsx") || this.filePath.endsWith(".tsx") ? ts5.ScriptKind.JSX : this.filePath.endsWith(".ts") || this.filePath.endsWith(".tsx") ? ts5.ScriptKind.TS : ts5.ScriptKind.JS
+    );
+    this.astTokenResolver = new ASTTokenResolver(this.tsCompilerAST);
+    this.astCollapsionBlockFactory = new ASTCollapsionBlockFactory(this.astTokenResolver);
+  }
+  insert(token, lineNumber) {
+    let lineMap = this.linesToTokens.get(lineNumber);
+    if (!lineMap) {
+      lineMap = [];
+    }
+    lineMap.push(token);
+    this.linesToTokens.set(
+      lineNumber,
+      lineMap.sort((a, b) => a.compareCoordinates(b))
+    );
+  }
+  analyse() {
+    const visit = (node, ancestors = []) => {
+      const currentAncestors = [...ancestors, node];
+      const isOwnDirectParent = node.kind === ts5.SyntaxKind.Constructor && ancestors.at(-1)?.kind === ts5.SyntaxKind.ClassDeclaration;
+      const tokenContextAncestors = isOwnDirectParent ? [...currentAncestors, node] : currentAncestors;
+      const tokenContext = this.tokenContext(tokenContextAncestors);
+      const sourceText = this.tsCompilerAST.getFullText();
+      const leading = ts5.getLeadingCommentRanges(sourceText, node.pos) || [];
+      const trailing = ts5.getTrailingCommentRanges(sourceText, node.end) || [];
+      for (const comment of [...leading, ...trailing]) {
+        const start = this.tsCompilerAST.getLineAndCharacterOfPosition(comment.pos);
+        const commentToken = ASTCommentToken.build(
+          comment,
+          sourceText.slice(comment.pos, comment.end)
+        ).withCollapsionBlock(tokenContext.collapsionBlock).withParents(tokenContext.parents);
+        const commentNodeId = this.nodeId(commentToken.rawToken);
+        if (!this.nodeIdToComment.has(commentNodeId)) {
+          this.nodeIdToComment.set(commentNodeId, commentToken);
+          this.insert(commentToken, start.line + 1);
+        }
+      }
+      const lineNumber = this.tsCompilerAST.getLineAndCharacterOfPosition(node.getStart()).line + 1;
+      const token = new ASTMatchedToken(node).withCollapsionBlock(tokenContext.collapsionBlock).withLineNumber(lineNumber).withParents(tokenContext.parents);
+      this.insert(token, lineNumber);
+      ts5.forEachChild(node, (child) => visit(child, currentAncestors));
+    };
+    visit(this.tsCompilerAST, []);
+    this.ast = this.tsCompilerAST;
+  }
+  createAST() {
+    return new AST(
+      this.ast,
+      this.linesToTokens,
+      this.nodeIdToCollapsionBlock.values().toArray(),
+      Array.from(this.collapsableCollapsionBlocks)
+    );
+  }
+  // Used only by tests, does not update focused coordinates
+  buildAST() {
+    this.parse();
+    this.focused?.createSelectionBuilderFrom(this.astTokenResolver);
+    this.analyse();
+    return this.createAST();
+  }
+};
+
+// server/linker/ASTs.js
+var ASTs = class {
+  constructor(absoluteFilePathToASTMap = /* @__PURE__ */ new Map(), fileReader2) {
+    this.absoluteFilePathToASTMap = absoluteFilePathToASTMap;
+    this.fileReader = fileReader2;
+  }
+  get(absoluteFilePath) {
+    const key = `${absoluteFilePath}:${this.fileReader.timeStamp(absoluteFilePath)}`;
+    let result = this.absoluteFilePathToASTMap.get(key);
+    if (!result) {
+      const content = this.fileReader.fileContent(absoluteFilePath);
+      const astBuilder = new ASTBuilder(absoluteFilePath, content);
+      astBuilder.parse();
+      astBuilder.analyse();
+      result = astBuilder.createAST();
+      this.absoluteFilePathToASTMap.set(key, result);
+    }
+    return result;
+  }
+};
+
+// server/linker/ASTDependencies.js
+import path5 from "path";
+import { cruise } from "dependency-cruiser";
+var ASTDependencies = class {
+  constructor(environment2, fileCommandLine2, dirCommandLine2) {
+    this.environment = environment2;
+    this.fileCommandLine = fileCommandLine2;
+    this.dirCommandLine = dirCommandLine2;
+    this.dependenciesMap = /* @__PURE__ */ new Map();
+  }
+  // TODO: re-run vs. what to do when files change/added/deleted
+  // TODO: Use try/cach around cruise()
+  async init() {
+    const rootPath = this.environment.absoluteProjectRoot;
+    const ARRAY_OF_FILES_AND_DIRS_TO_CRUISE = ["."];
+    const cruiseOptions = {
+      // includeOnly: 'src',
+      exclude: [...CONFIG_FILES2, ...IGNORED_DIRS],
+      baseDir: rootPath
+    };
+    this.dependenciesMap = /* @__PURE__ */ new Map();
+    const cruiseResult = await cruise(ARRAY_OF_FILES_AND_DIRS_TO_CRUISE, cruiseOptions);
+    await cruiseResult.output.modules.forEach((module) => {
+      this.dependenciesMap.set(
+        path5.join(rootPath, module.source),
+        module.dependencies.map((dep) => ({
+          absolutePath: path5.join(rootPath, dep.resolved),
+          importString: dep.module
+        }))
+      );
+    });
+  }
+  // TODO: Test this well
+  importedFileAbsolutePath(sourceFileAbsolutePath, importString) {
+    return this.dependenciesMap.get(sourceFileAbsolutePath).find((eachDependency) => eachDependency.importString === importString).absolutePath;
+  }
+  // TODO: Test this well
+  ofAbsolutePath(absolutePath) {
+    return Array.from(this.dependenciesMap.keys()).filter(
+      (eachFilePath) => this.dependenciesMap.get(eachFilePath).map((eachDependency) => eachDependency.absolutePath).includes(absolutePath)
+    );
+  }
+};
+
+// server/ws/MessageHandler.js
+import path6 from "path";
+
+// server/storage/StoredNotes.js
+var StoredNotes = class {
+  constructor(storedList = [], requestList = []) {
+    this.storedList = storedList;
+    this.requestList = requestList;
+    this.responseList = [];
+    this.newNoteIndex = null;
+  }
+  get newNote() {
+    return this.responseList[this.newNoteIndex];
+  }
+  setNewNote(newNote) {
+    this.responseList[this.newNoteIndex] = newNote;
+  }
+  updateStoredNote(storedNoteJSON, eachRequestNoteJSON) {
+    const result = StoredNote.fromJSON(storedNoteJSON);
+    result.inputValue = eachRequestNoteJSON.inputValue;
+    result.inputPosition = eachRequestNoteJSON.inputPosition;
+    result.diff = eachRequestNoteJSON.diff;
+    result.subNotes = eachRequestNoteJSON.subNotes?.map((eachRequestSubNoteJSON, i) => {
+      if (eachRequestSubNoteJSON.idx === storedNoteJSON.subNotes[i]?.idx) {
+        return this.updateStoredNote(storedNoteJSON.subNotes[i], eachRequestSubNoteJSON);
+      }
+      return StoredNote.fromJSON(eachRequestSubNoteJSON);
+    });
+    return result;
+  }
+  evaluateRequestList() {
+    this.responseList = this.requestList.map((eachRequestNoteJSON, i) => {
+      const storedNoteJSON = this.storedList.find(
+        (eachStoredNoteJSON) => eachStoredNoteJSON.idx === eachRequestNoteJSON.idx
+      );
+      if (storedNoteJSON) {
+        return this.updateStoredNote(storedNoteJSON, eachRequestNoteJSON);
+      }
+      this.newNoteIndex = i;
+      return StoredNote.fromJSON(eachRequestNoteJSON);
+    });
+  }
+  updateNote(newStoredNoteJSON) {
+    return this.storedList.map((eachStoredNoteJSON) => {
+      let isSubNoteFocused = false;
+      const updatedSubNotes = eachStoredNoteJSON.subNotes.map((eachStoredSubNoteJSON) => {
+        if (eachStoredSubNoteJSON.idx === newStoredNoteJSON.idx) {
+          isSubNoteFocused = true;
+          return newStoredNoteJSON;
+        }
+        return eachStoredSubNoteJSON;
+      });
+      if (isSubNoteFocused) {
+        return {
+          ...eachStoredNoteJSON,
+          subNotes: updatedSubNotes
+        };
+      }
+      if (eachStoredNoteJSON.idx !== newStoredNoteJSON.idx) {
+        return eachStoredNoteJSON;
+      }
+      return newStoredNoteJSON;
+    });
+  }
+};
+
+// server/controllers/FilesExplorerController.js
+var FilesExplorerController = class {
+  constructor(environment2, dirCommandLine2) {
+    this.environment = environment2;
+    this.dirCommandLine = dirCommandLine2;
+  }
+  search(query, isRegex, isCaseSensitive) {
+    const files = this.dirCommandLine.search(query, isRegex, isCaseSensitive);
+    return files;
+  }
+  gitModifiedFiles() {
+    return this.environment.gitModifiedFiles();
+  }
+  recentlyModifiedFiles() {
+    return this.environment.recentlyModifiedFiles();
+  }
+  dirContent(absolutePath) {
+    return this.dirCommandLine.dirContent(absolutePath);
+  }
+};
+
+// server/linker/ASTFindUsages.js
+import ts6 from "typescript";
+var ASTFindUsages = class _ASTFindUsages {
+  constructor(absoluteFilePath, aSTs2, dependencies2) {
+    this.absoluteFilePath = absoluteFilePath;
+    this.aSTs = aSTs2;
+    this.dependencies = dependencies2;
+    this.queryToken = null;
+  }
+  // TODO: Make it immutable
+  withQueryToken(queryToken) {
+    this.queryToken = queryToken;
+    return this;
+  }
+  get ast() {
+    return this.aSTs.get(this.absoluteFilePath);
+  }
+  createFor(absoluteFilePath) {
+    return new _ASTFindUsages(absoluteFilePath, this.aSTs, this.dependencies);
+  }
+  // TODO: Pass tokens instead of strings
+  // TODO: when imported file not identified?
+  // TODO: Improve this
+  // TODO: Improve package from node_modules?
+  // TODO: Test this well
+  referencesTo(importToken) {
+    const firstOrderReferences = this.createFor(importToken.absoluteFilePath).withQueryToken(importToken).references();
+    const transitiveFindUsages = this.dependencies.ofAbsolutePath(importToken.absoluteFilePath).filter((eachAbsolutePath) => eachAbsolutePath !== this.absoluteFilePath).map((eachAbsolutePath) => this.createFor(eachAbsolutePath));
+    let transitiveReferences = /* @__PURE__ */ new Map();
+    for (let eachFindUsages of transitiveFindUsages) {
+      transitiveReferences = [
+        ...transitiveReferences,
+        ...eachFindUsages.withQueryToken(importToken).references()
+      ];
+    }
+    return new Map([...firstOrderReferences, ...transitiveReferences]);
+  }
+  // TODO: Improve this
+  references() {
+    const isImportLookup = this.queryToken instanceof ASTImportToken;
+    const identifierToken = isImportLookup ? this.queryToken.identifierToken : this.queryToken;
+    const identifierName = identifierToken.text;
+    let result = /* @__PURE__ */ new Map();
+    let currentFileReferences = [];
+    let importReferenceFound = isImportLookup && this.absoluteFilePath === this.queryToken.absoluteFilePath;
+    const findReferences = (node) => {
+      const foundIdentifierToken = this.ast.findIdentifierTokenIn(node, identifierName);
+      if (foundIdentifierToken) {
+        currentFileReferences.push(foundIdentifierToken);
+      }
+      let importToken = this.ast.findImportTokenIn(node);
+      if (importToken && importToken.isImportingIdentifier(identifierToken)) {
+        const absoluteFilePath = this.dependencies.importedFileAbsolutePath(
+          this.absoluteFilePath,
+          importToken.importString
+        );
+        if (!isImportLookup) {
+          importToken = importToken.withAbsoluteFilePath(absoluteFilePath).withQueryToken(identifierToken);
+          result = new Map([...result, ...this.referencesTo(importToken)]);
+        } else if (this.queryToken.isImporting(absoluteFilePath, identifierToken)) {
+          importReferenceFound = true;
+        }
+      }
+      ts6.forEachChild(node, (child) => findReferences(child));
+    };
+    findReferences(this.ast.ast);
+    result.set(this.absoluteFilePath, currentFileReferences);
+    if (isImportLookup && !importReferenceFound) {
+      return /* @__PURE__ */ new Map();
+    }
+    return result;
+  }
+};
+
+// server/controllers/UsagesController.js
+var UsagesController = class {
+  constructor(requestToken, absolutePath, dependencies2, aSTs2, fileReader2, dirCommandLine2) {
+    this.requestToken = requestToken;
+    this.absolutePath = absolutePath;
+    this.dependencies = dependencies2;
+    this.aSTs = aSTs2;
+    this.fileReader = fileReader2;
+    this.dirCommandLine = dirCommandLine2;
+  }
+  findASTUsages() {
+    const findUsages = new ASTFindUsages(this.absolutePath, this.aSTs, this.dependencies);
+    const references = findUsages.withQueryToken(this.requestToken).references();
+    return Array.from(references, ([file, tokens]) => [
+      file,
+      tokens.map((eachToken) => ({
+        fileName: file,
+        line: this.fileReader.lineAt(file, eachToken.lineNumber),
+        token: eachToken.toResponseJSON()
+      }))
+    ]);
+  }
+  findTextUsages() {
+    const requestTokenText = this.requestToken.text;
+    const results = /* @__PURE__ */ new Map();
+    const files = this.dirCommandLine.findAllFilesPathsRecursively();
+    for (const file of files) {
+      if (ANNOTABLE_EXTENSIONS.test(file)) {
+        const fileRead = this.fileReader.readCurrent(file);
+        const lines = fileRead.lines;
+        let start = 0;
+        const fileResults = [];
+        lines.forEach((line, idx) => {
+          const lineLeadingSpaceCount = line.length - line.trimStart().length;
+          let col = line.indexOf(requestTokenText);
+          while (col !== -1) {
+            fileResults.push({
+              fileName: file,
+              lineNumber: idx + 1,
+              lineText: line.trim(),
+              lineStart: col - lineLeadingSpaceCount,
+              lineEnd: col - lineLeadingSpaceCount + requestTokenText.length,
+              lineLeadingSpaceCount,
+              start
+            });
+            col = line.indexOf(requestTokenText, col + requestTokenText.length);
+          }
+          start += line.length + 1;
+        });
+        if (fileResults.length > 0) {
+          results.set(file, fileResults);
+        }
+      }
+    }
+    return Array.from(results);
+  }
+};
+
+// server/parser/token/ASTUnmatchedText.js
+var ASTUnmatchedText = class _ASTUnmatchedText extends ASTToken {
+  constructor(text, previousCharacter, view, rawToken, collapsionBlock, isHidden = false, isManuallyExpanded = false, lineNumber = 0, coordinates = null) {
+    super(rawToken, collapsionBlock, isHidden, isManuallyExpanded);
+    this.className = "ASTUnmatchedText";
+    this.text = text;
+    this.previousCharacter = previousCharacter;
+    this.isNewLine = isNewLine(text);
+    this.isSecondNewLine = this.isNewLine && isNewLine(this.previousCharacter);
+    this.view = view;
+    this.lineNumber = lineNumber;
+    this.coordinates = coordinates;
+  }
+  hidden() {
+    return new _ASTUnmatchedText(
+      this.text,
+      this.previousCharacter,
+      this.view,
+      this.rawToken,
+      this.collapsionBlock,
+      true,
+      this.isManuallyExpanded,
+      this.lineNumber,
+      this.coordinates
+    );
+  }
+  visible() {
+    return new _ASTUnmatchedText(
+      this.text,
+      this.previousCharacter,
+      this.view,
+      this.rawToken,
+      this.collapsionBlock,
+      false,
+      this.isManuallyExpanded,
+      this.lineNumber,
+      this.coordinates
+    );
+  }
+  manuallyExpanded() {
+    return new _ASTUnmatchedText(
+      this.text,
+      this.previousCharacter,
+      this.view,
+      this.rawToken,
+      this.collapsionBlock,
+      this.isHidden,
+      true,
+      this.lineNumber,
+      this.coordinates
+    );
+  }
+  static highlightableChainItem(text, rawToken, collapsionBlock, lineNumber, coordinates) {
+    return new _ASTUnmatchedText(
+      text,
+      null,
+      null,
+      rawToken,
+      collapsionBlock,
+      false,
+      false,
+      lineNumber,
+      coordinates
+    );
+  }
+  static nonParsableChainItem(text, lineNumber, coordinates) {
+    return new _ASTUnmatchedText(
+      text,
+      null,
+      null,
+      null,
+      null,
+      false,
+      false,
+      lineNumber,
+      coordinates
+    );
+  }
+  static newLine(previousCharacter, rawToken, collapsionBlock, lineNumber) {
+    return new _ASTUnmatchedText(
+      NEW_LINE_CHARACTER,
+      previousCharacter,
+      null,
+      rawToken,
+      collapsionBlock,
+      false,
+      false,
+      lineNumber
+    );
+  }
+};
+
+// server/parser/chain/ASTChain.js
+var ASTChain = class _ASTChain {
+  constructor(chain, tokensToExpand = [], rawCollapsedBlocks = []) {
+    this.chain = chain;
+    this.tokensToExpand = tokensToExpand;
+    this.rawCollapsedBlocks = rawCollapsedBlocks;
+    this.collapsedBlocks = this.rawCollapsedBlocks.filter(
+      (eachCollapsionBlock) => (
+        // !eachCollapsionBlock.findHeadIn(this.tokensToExpand) &&
+        !this.tokensToExpand.find(
+          (eachToken) => new ASTTokensRange(eachCollapsionBlock, eachCollapsionBlock).containsToken(eachToken)
+        )
+      )
+    );
+  }
+  withExpanded(expandedToken) {
+    return new _ASTChain(
+      this.chain,
+      [...this.tokensToExpand, expandedToken],
+      this.rawCollapsedBlocks
+    );
+  }
+  expand(expandedTokens) {
+    return new _ASTChain(this.chain, expandedTokens, this.rawCollapsedBlocks);
+  }
+  matchingCollapsionBlock(token) {
+    return this.collapsedBlocks.filter((eachCollapsionBlock) => eachCollapsionBlock.range().containsToken(token)).filter((eachCollapsionBlock) => !eachCollapsionBlock.isExpanded).sort((a, b) => a.rawToken.start - b.rawToken.start).at(0);
+  }
+  // TODO: Add tests for cases here
+  tokens() {
+    const result = [];
+    for (const eachToken of this.chain) {
+      const collapsionBlock = this.matchingCollapsionBlock(eachToken);
+      if (collapsionBlock && !collapsionBlock.isHead(eachToken)) {
+        if (collapsionBlock.isOneLine()) {
+          result.push(eachToken);
+        }
+        continue;
+      }
+      if (collapsionBlock && collapsionBlock.isHead(eachToken)) {
+        if (collapsionBlock.isOneLine()) {
+          result.push(eachToken.manuallyExpanded());
+        } else {
+          result.push(eachToken.visible());
+        }
+        continue;
+      }
+      if (eachToken.isHidden || this.tokensToExpand.find((eachTokenToExpand) => eachTokenToExpand.equals(eachToken))) {
+        result.push(eachToken.manuallyExpanded());
+        continue;
+      }
+      result.push(eachToken);
+    }
+    return result;
+  }
+};
+
+// server/parser/chain/ASTChainBuilder.js
+import ts7 from "typescript";
+
+// server/parser/chain/Chars.js
+var TRIVIA_CHARS = [
+  "'",
+  '"',
+  "(",
+  ")",
+  "{",
+  "}",
+  ">",
+  "<",
+  "=",
+  ";",
+  ":",
+  ",",
+  ".",
+  "[",
+  "]",
+  "+",
+  "-",
+  "*",
+  "/",
+  "%",
+  "&",
+  "|",
+  "^",
+  "!",
+  "?",
+  "~"
+];
+
+// server/parser/chain/ASTChainBuilder.js
+var ASTChainBuilder = class {
+  constructor(ast, sourceFile, startLineNumber = 1) {
+    this.ast = ast;
+    this.sourceFile = sourceFile;
+    this.content = sourceFile.content;
+    this.lines = sourceFile.lines;
+    this.linesStarts = sourceFile.linesStarts;
+    this.programTokenInstance = this.findProgramToken();
+    this.start = (this.linesStarts.get(startLineNumber) ?? 0) - 1;
+    this.lineNumber = startLineNumber - 1;
+    this.startToken = this.programTokenInstance;
+    this.lineStart = 0;
+    this.cursor = null;
+  }
+  findProgramToken() {
+    if (!this.ast) return null;
+    let programToken = null;
+    const sortedLineNumbers = this.ast.linesToTokens.keys().toArray().sort((a, b) => Number(a) - Number(b));
+    for (const lineNumber of sortedLineNumbers) {
+      const tokens = this.ast.linesToTokens.get(lineNumber);
+      for (const token of tokens) {
+        if (token.rawToken.kind === ts7.SyntaxKind.SourceFile) {
+          programToken = token;
+          break;
+        }
+      }
+      if (programToken) break;
+    }
+    return programToken;
+  }
+  setCursor(token) {
+    this.cursor = token;
+  }
+  create() {
+    const chain = [];
+    if (this.lineNumber > 0) {
+      this.startToken = this.ast?.resolver.token(this.lineNumber + 1, 0) || this.programTokenInstance;
+      chain.push(this.createNewLineChainItem(true));
+    }
+    this.lines.forEach((eachLine, i) => {
+      this.moveAfterLine();
+      const lineTokens = eachLine.match(/(\s+|[\w$]+|[^\w\s])/g) || [];
+      lineTokens.forEach((eachToken) => {
+        this.setCursor(eachToken);
+        chain.push(this.createChainItem());
+        this.moveAfterToken();
+      });
+      this.setCursor(NEW_LINE_CHARACTER);
+      if (i < this.lines.length - 1) {
+        chain.push(this.createNewLineChainItem());
+      }
+    });
+    return new ASTChain(chain, [], this.ast?.collapsableCollapsionBlocks);
+  }
+  createChainItem() {
+    const coordinates = { start: this.start, end: this.start + this.cursor.length };
+    if (!this.startToken) {
+      return ASTUnmatchedText.nonParsableChainItem(this.cursor, this.lineNumber, coordinates);
+    }
+    if (this.startToken instanceof ASTCommentToken) {
+      return ASTCommentToken.chainItem(
+        this.startToken.rawToken,
+        this.startToken.collapsionBlock,
+        this.cursor,
+        this.lineNumber
+      );
+    }
+    if (TRIVIA_CHARS.includes(this.cursor) || /^\s+$/.test(this.cursor)) {
+      return ASTUnmatchedText.highlightableChainItem(
+        this.cursor,
+        this.startToken.rawToken,
+        this.startToken.collapsionBlock,
+        this.lineNumber,
+        coordinates
+      );
+    }
+    if (this.startToken.isViewable()) {
+      return this.startToken.withText(this.cursor);
+    }
+    return ASTUnmatchedText.highlightableChainItem(
+      this.cursor,
+      this.startToken.rawToken,
+      this.startToken.collapsionBlock,
+      this.lineNumber,
+      coordinates
+    );
+  }
+  createNewLineChainItem(ignorePreviousCharacter = false) {
+    const previousCharacter = ignorePreviousCharacter ? null : this.content[this.start - 1];
+    let token = null;
+    if (this.startToken) {
+      const endLine = this.ast?.ast.getLineAndCharacterOfPosition(this.startToken.rawToken.getEnd()).line + 1;
+      const isTokenEnding = endLine === this.lineNumber;
+      token = isTokenEnding ? this.ast?.resolver.newLineToken(this.startToken) || this.programTokenInstance : this.startToken;
+    }
+    return ASTUnmatchedText.newLine(
+      previousCharacter,
+      token?.rawToken,
+      token?.collapsionBlock,
+      this.lineNumber + 1
+    );
+  }
+  moveAfterToken() {
+    this.start += this.cursor.length;
+    this.lineStart += this.cursor.length;
+    this.startToken = this.ast?.resolver.token(this.lineNumber, this.lineStart) || this.programTokenInstance;
+  }
+  moveAfterLine() {
+    this.lineNumber++;
+    this.start += 1;
+    this.startToken = this.ast?.resolver.token(this.lineNumber, 0) || this.programTokenInstance;
+    this.lineStart = 0;
+  }
+};
+
+// server/controllers/parse/ParseFileWorkflow.js
+var ParseFileWorkflow = class {
+  constructor(filePath, focusedNoteId, sessionId, storage2, fileReader2) {
+    this.filePath = filePath;
+    this.focusedNoteId = focusedNoteId;
+    this.sessionId = sessionId;
+    this.storage = storage2;
+    this.fileReader = fileReader2;
+    this.focused = null;
+    this.ast = null;
+    this.sourceFile = null;
+    this.notes = null;
+    this.storedRemovedNotes = [];
+  }
+  get shouldRecalculateFocusedNote() {
+    return this.focused?.shouldRecalculateSelection;
+  }
+  run() {
+    this.sourceFile = this.fileReader.read(this.filePath);
+    this.loadNotes();
+    this.loadFocusedNote();
+    this.focused?.checkIfUpToDate();
+    if (this.focused?.isOutdated) {
+      this.sourceFile = this.fileReader.readRevision(
+        this.filePath,
+        this.focused.linesWindow.revision
+      );
+    }
+    this.buildAST();
+    if (this.shouldRecalculateFocusedNote) {
+      this.focused.recalculateSelectionAndLines(
+        this.ast.resolver,
+        this.fileReader.calculateRevision(this.filePath)
+      );
+    }
+    this.persistFocusedNote();
+  }
+  loadNotes() {
+    const { list: storedNotes, removedList: storedRemovedNotes } = this.storage.getNotes(
+      null,
+      this.sessionId
+    );
+    this.notes = new StoredNotes(storedNotes);
+    this.storedRemovedNotes = storedRemovedNotes;
+  }
+  loadFocusedNote() {
+    if (!this.focusedNoteId) return;
+    const noteJSON = this.storage.getNoteByIdx(this.focusedNoteId, this.sessionId);
+    this.focused = StoredNote.fromJSON(noteJSON, this.sourceFile.lines);
+  }
+  // TODO: Reuse ASTs.get() to avoid reparsing
+  buildAST() {
+    const astBuilder = new ASTBuilder(this.filePath, this.sourceFile.content, this.focused);
+    astBuilder.parse();
+    if (this.shouldRecalculateFocusedNote) {
+      const astResolver = new ASTTokenResolver(astBuilder.tsCompilerAST);
+      this.focused.createSelectionBuilderFrom(astResolver);
+    }
+    astBuilder.analyse();
+    this.ast = astBuilder.createAST();
+  }
+  // TODO: Why doing this separately (not inside previous if block)?
+  persistFocusedNote() {
+    if (!this.focusedNoteId) return;
+    const toStoreList = this.notes.updateNote(this.focused.toStorageJSON());
+    this.storage.setNotes(toStoreList, this.storedRemovedNotes, this.sessionId);
+  }
+};
+
+// server/controllers/parse/ParseFileController.js
+var ParseFileController = class {
+  constructor(filePath, focusedNoteId, sessionId, storage2, fileReader2) {
+    this.filePath = filePath;
+    this.focusedNoteId = focusedNoteId;
+    this.sessionId = sessionId;
+    this.storage = storage2;
+    this.fileReader = fileReader2;
+    this.focused = null;
+    this.ast = null;
+    this.sourceFile = null;
+  }
+  parse() {
+    const workflow = new ParseFileWorkflow(
+      this.filePath,
+      this.focusedNoteId,
+      this.sessionId,
+      this.storage,
+      this.fileReader
+    );
+    workflow.run();
+    this.focused = workflow.focused;
+    this.ast = workflow.ast;
+    this.sourceFile = workflow.sourceFile;
+  }
+  createNotesContextTokens(_notes) {
+    const notes = _notes || this.storage.getNotes(this.filePath, this.sessionId).list;
+    return notes.filter((eachNote) => eachNote.type !== NOTES_TYPES.OUTDATED_NOTE).map(
+      (eachNote) => eachNote.file === this.filePath ? ASTNote_default.fromJSON(eachNote).takeContextTokensFrom(this.ast) : ASTNote_default.fromJSON(eachNote)
+    );
+  }
+  createFocusedContextTokens() {
+    return this.focused?.note.takeContextTokensFrom(this.ast) ?? null;
+  }
+  tokenizeTextRange(startLine, endLine) {
+    const sourceFile = this.fileReader.readFileRangeFromSourceFile(
+      this.sourceFile,
+      startLine,
+      endLine
+    );
+    const chain = new ASTChainBuilder(null, sourceFile, startLine).create();
+    return chain.tokens();
+  }
+  tokenizeRange(startLine, endLine) {
+    const sourceFile = this.fileReader.readFileRangeFromSourceFile(
+      this.sourceFile,
+      startLine,
+      endLine
+    );
+    const chain = new ASTChainBuilder(this.ast, sourceFile, startLine).create();
+    return chain.tokens();
+  }
+  expandToken(expandedToken, startLine, endLine) {
+    const sourceFile = this.fileReader.readFileRange(this.filePath, startLine, endLine);
+    const chain = new ASTChainBuilder(this.ast, sourceFile, startLine).create();
+    const expandedMatchedToken = ASTMatchedToken.fromJSON(expandedToken);
+    return chain.withExpanded(expandedMatchedToken).tokens();
+  }
+};
+
+// server/controllers/parse/ParseFileCache.js
+var ParseFileCache = class _ParseFileCache {
+  constructor(environment2, cache2, storage2, fileReader2, controllerAsync, fileViewId, filePath, sessionId, focusedNoteId) {
+    this.environment = environment2;
+    this.cache = cache2;
+    this.storage = storage2;
+    this.fileReader = fileReader2;
+    this.controllerAsync = controllerAsync;
+    this.fileViewId = fileViewId;
+    this.filePath = filePath;
+    this.sessionId = sessionId;
+    this.focusedNoteId = focusedNoteId;
+  }
+  // TODO: Make this session-agnostic (now session notes are cached inside the controller between sessions)
+  createCachedFileKey() {
+    return `${this.environment.commitHash || ""}:${this.filePath}:${this.fileReader.timeStamp(this.filePath) || ""}:${this.focusedNoteId || ""}:${this.sessionId}`;
+  }
+  onDoneParsing(cachedFile, fileViewId) {
+    for (const [_, requests] of cachedFile.requestedTextRanges.entries()) {
+      requests.forEach((message) => this.controllerAsync.sendTextResponse(message, cachedFile));
+    }
+    for (const [_, requests] of cachedFile.requestedRanges.entries()) {
+      requests.forEach((message) => this.controllerAsync.sendTokensResponse(message, cachedFile));
+    }
+    const requestsCache = this.cache.get(fileViewId);
+    if (!requestsCache) {
+      return;
+    }
+    if (requestsCache.fileMetadataRequest) {
+      this.controllerAsync.sendFileMetadataResponse(requestsCache.fileMetadataRequest, cachedFile);
+    }
+    if (requestsCache.notesRequest) {
+      this.controllerAsync.sendNotesResponse(requestsCache.notesRequest, cachedFile);
+    }
+    if (requestsCache.focusedNoteRequest) {
+      this.controllerAsync.sendFocusedNoteResponse(requestsCache.focusedNoteRequest, cachedFile);
+    }
+    if (requestsCache.temporalNotesRequest) {
+      this.controllerAsync.sendTemporalNotesResponse(
+        requestsCache.temporalNotesRequest,
+        cachedFile
+      );
+    }
+  }
+  getOrStartParsing() {
+    const key = this.createCachedFileKey();
+    let cachedFile = this.cache.get(key);
+    if (cachedFile) {
+      return cachedFile;
+    }
+    cachedFile = {
+      controller: null,
+      isParsing: false,
+      isParsed: false,
+      requestedRanges: /* @__PURE__ */ new Map(),
+      resolvedRanges: /* @__PURE__ */ new Map(),
+      requestedTextRanges: /* @__PURE__ */ new Map(),
+      resolvedTextRanges: /* @__PURE__ */ new Map()
+    };
+    this.cache.set(key, cachedFile);
+    cachedFile.isParsing = true;
+    cachedFile.controller = new ParseFileController(
+      this.filePath,
+      this.focusedNoteId,
+      this.sessionId,
+      this.storage,
+      this.fileReader
+    );
+    try {
+      cachedFile.controller.parse();
+    } catch (e) {
+      console.error("Error parsing file", this.filePath, e);
+      this.cache.delete(key);
+      return cachedFile;
+    }
+    cachedFile.isParsing = false;
+    cachedFile.isParsed = true;
+    this.onDoneParsing(cachedFile, this.fileViewId);
+    cachedFile.requestedRanges.clear();
+    return cachedFile;
+  }
+  // requests cache
+  requestsCache() {
+    let requestsCache = this.cache.get(this.fileViewId);
+    if (!requestsCache) {
+      requestsCache = {
+        notesRequest: null,
+        focusedNoteRequest: null,
+        temporalNotesRequest: null,
+        fileMetadataRequest: null
+      };
+      this.cache.set(this.fileViewId, requestsCache);
+    }
+    return requestsCache;
+  }
+  setFileMetadataRequest(message) {
+    const requestsCache = this.requestsCache();
+    requestsCache.fileMetadataRequest = message;
+    this.cache.set(this.fileViewId, requestsCache);
+  }
+  setNotesRequest(message) {
+    const requestsCache = this.requestsCache();
+    requestsCache.notesRequest = message;
+    this.cache.set(this.fileViewId, requestsCache);
+  }
+  setFocusedNoteRequest(message) {
+    const requestsCache = this.requestsCache();
+    requestsCache.focusedNoteRequest = message;
+    this.cache.set(this.fileViewId, requestsCache);
+  }
+  setTemporalNotesRequest(message) {
+    const requestsCache = this.requestsCache();
+    requestsCache.temporalNotesRequest = message;
+    this.cache.set(this.fileViewId, requestsCache);
+  }
+  // factories
+  static from(controllerAsync, fileViewId, filePath, sessionId, focusedNoteId) {
+    return new _ParseFileCache(
+      controllerAsync.environment,
+      controllerAsync.cache,
+      controllerAsync.storage,
+      controllerAsync.fileReader,
+      controllerAsync,
+      fileViewId,
+      filePath,
+      sessionId,
+      focusedNoteId
+    );
+  }
+};
+
+// server/controllers/parse/ParseFileControllerAsync.js
+function getRangeKey(startLine, endLine) {
+  return `${startLine}:${endLine}`;
+}
+var ParseFileControllerAsync = class {
+  constructor(environment2, send, cache2, storage2, fileReader2) {
+    this.environment = environment2;
+    this.send = send;
+    this.cache = cache2;
+    this.storage = storage2;
+    this.fileReader = fileReader2;
+  }
+  //
+  sendFileMetadataResponse(message, cacheEntry) {
+    const response = {
+      focusedNoteType: cacheEntry.controller.focused?.type || null,
+      linesCount: cacheEntry.controller.sourceFile.linesCount,
+      tokens: cacheEntry.controller.sourceFile.tokensPlaceholders,
+      longestLineLength: cacheEntry.controller.sourceFile.longestLineLength
+    };
+    this.send({ TYPE: MessageTypes_default.GET_FILE_METADATA, id: message.id, data: response });
+  }
+  sendNotesResponse(message, cacheEntry) {
+    const notesWithContext = cacheEntry.controller.createNotesContextTokens();
+    this.send({
+      TYPE: MessageTypes_default.FETCH_NOTES_HIGHLIGHTS,
+      id: message.id,
+      data: {
+        notes: notesWithContext.map((note) => note.toResponseJSON())
+      }
+    });
+  }
+  sendFocusedNoteResponse(message, cacheEntry) {
+    const noteWithContext = cacheEntry.controller.createFocusedContextTokens();
+    this.send({
+      TYPE: MessageTypes_default.FETCH_FOCUSED_NOTE_HIGHLIGHTS,
+      id: message.id,
+      data: {
+        focusedNote: noteWithContext.toResponseJSON()
+      }
+    });
+  }
+  sendTemporalNotesResponse(message, cacheEntry) {
+    const notesWithContext = cacheEntry.controller.createNotesContextTokens(message.temporalNotes);
+    this.send({
+      TYPE: MessageTypes_default.FETCH_TEMPORAL_NOTES_HIGHLIGHTS,
+      id: message.id,
+      data: {
+        notes: notesWithContext.map((note) => note.toResponseJSON())
+      }
+    });
+  }
+  sendTextResponse(message, cacheEntry) {
+    const { startLine, endLine } = message;
+    const rangeKey = getRangeKey(startLine, endLine);
+    let filteredTokens = cacheEntry.resolvedTextRanges.get(rangeKey);
+    if (!filteredTokens) {
+      filteredTokens = cacheEntry.controller.tokenizeTextRange(startLine, endLine);
+      cacheEntry.resolvedTextRanges.set(rangeKey, filteredTokens);
+    }
+    this.send({
+      TYPE: MessageTypes_default.FETCH_TEXT,
+      id: message.id,
+      data: {
+        tokens: filteredTokens.map((token) => token.toResponseJSON())
+      }
+    });
+  }
+  sendTokensResponse(message, cacheEntry) {
+    const { startLine, endLine } = message;
+    const rangeKey = getRangeKey(startLine, endLine);
+    let filteredTokens = cacheEntry.resolvedRanges.get(rangeKey);
+    if (!filteredTokens) {
+      filteredTokens = cacheEntry.controller.tokenizeRange(startLine, endLine);
+      cacheEntry.resolvedRanges.set(rangeKey, filteredTokens);
+    }
+    this.send({
+      TYPE: MessageTypes_default.FETCH_TOKENS,
+      id: message.id,
+      data: {
+        tokens: filteredTokens.map((token) => token.toResponseJSON())
+      }
+    });
+  }
+  // Message handlers
+  onFetchFileMetadataRequest(message) {
+    const { filePath, fileViewId, sessionId, focusedNoteId } = message;
+    const cache2 = ParseFileCache.from(this, fileViewId, filePath, sessionId, focusedNoteId);
+    const cacheEntry = cache2.getOrStartParsing();
+    if (cacheEntry.isParsed) {
+      this.sendFileMetadataResponse(message, cacheEntry);
+    } else {
+      cache2.setFileMetadataRequest(message);
+    }
+  }
+  onFetchTextRequest(message) {
+    const { startLine, endLine, filePath, focusedNoteId, fileViewId, sessionId } = message;
+    const cacheEntry = ParseFileCache.from(
+      this,
+      fileViewId,
+      filePath,
+      sessionId,
+      focusedNoteId
+    ).getOrStartParsing();
+    const rangeKey = getRangeKey(startLine, endLine);
+    if (cacheEntry.isParsed) {
+      this.sendTextResponse(message, cacheEntry);
+    } else {
+      if (!cacheEntry.requestedTextRanges.has(rangeKey)) {
+        cacheEntry.requestedTextRanges.set(rangeKey, []);
+      }
+      cacheEntry.requestedTextRanges.get(rangeKey).push(message);
+    }
+  }
+  onFetchTokensRequest(message) {
+    const { startLine, endLine, filePath, focusedNoteId, fileViewId, sessionId } = message;
+    const cacheEntry = ParseFileCache.from(
+      this,
+      fileViewId,
+      filePath,
+      sessionId,
+      focusedNoteId
+    ).getOrStartParsing();
+    const rangeKey = getRangeKey(startLine, endLine);
+    if (cacheEntry.isParsed) {
+      this.sendTokensResponse(message, cacheEntry);
+    } else {
+      if (!cacheEntry.requestedRanges.has(rangeKey)) {
+        cacheEntry.requestedRanges.set(rangeKey, []);
+      }
+      cacheEntry.requestedRanges.get(rangeKey).push(message);
+    }
+  }
+  onNotesRequest(message) {
+    const { filePath, fileViewId, sessionId, focusedNoteId } = message;
+    const cache2 = ParseFileCache.from(this, fileViewId, filePath, sessionId, focusedNoteId);
+    const cacheEntry = cache2.getOrStartParsing();
+    if (cacheEntry.isParsed) {
+      this.sendNotesResponse(message, cacheEntry);
+    } else {
+      cache2.setNotesRequest(message);
+    }
+  }
+  onFocusedNoteRequest(message) {
+    const { filePath, fileViewId, focusedNoteId, sessionId } = message;
+    const cache2 = ParseFileCache.from(this, fileViewId, filePath, sessionId, focusedNoteId);
+    const cacheEntry = cache2.getOrStartParsing();
+    if (cacheEntry.isParsed) {
+      this.sendFocusedNoteResponse(message, cacheEntry);
+    } else {
+      cache2.setFocusedNoteRequest(message);
+    }
+  }
+  onTemporalNotesRequest(message) {
+    const { filePath, fileViewId, sessionId, focusedNoteId } = message;
+    const cache2 = ParseFileCache.from(this, fileViewId, filePath, sessionId, focusedNoteId);
+    const cacheEntry = cache2.getOrStartParsing();
+    if (cacheEntry.isParsed) {
+      this.sendTemporalNotesResponse(message, cacheEntry);
+    } else {
+      cache2.setTemporalNotesRequest(message);
+    }
+  }
+  onExpandTokenRequest(message) {
+    const { fileViewId, filePath, expandedToken, startLine, endLine, sessionId, focusedNoteId } = message;
+    const cachedEntry = ParseFileCache.from(
+      this,
+      fileViewId,
+      filePath,
+      sessionId,
+      focusedNoteId
+    ).getOrStartParsing();
+    const tokens = cachedEntry.controller.expandToken(expandedToken, startLine, endLine);
+    this.send({
+      TYPE: MessageTypes_default.EXPAND_TOKEN,
+      id: message.id,
+      data: {
+        tokens: tokens.map((token) => token.toResponseJSON())
+      }
+    });
+  }
+};
+
+// server/controllers/DiffController.js
+import { diffLines } from "diff";
+var DiffController = class {
+  oldContent = null;
+  newContent = null;
+  changes = null;
+  oldContentLinesCount = null;
+  newContentLinesCount = null;
+  ranges = /* @__PURE__ */ new Map();
+  constructor(fileReader2, absoluteFilePath, comparedToHash, currentHash) {
+    this.fileReader = fileReader2;
+    this.absoluteFilePath = absoluteFilePath;
+    this.comparedToHash = comparedToHash;
+    this.currentHash = currentHash;
+  }
+  readContent() {
+    this.oldContent = this.fileReader.fileContent(this.absoluteFilePath, this.comparedToHash);
+    this.newContent = this.fileReader.fileContent(this.absoluteFilePath, this.currentHash);
+  }
+  calculateDiffs() {
+    this.changes = diffLines(this.oldContent, this.newContent);
+    this.oldContentLinesCount = this.oldContent.split("\n").length;
+    this.newContentLinesCount = this.newContent.split("\n").length;
+    this.putChangedRanges();
+  }
+  createRange(oldLine, newLine) {
+    return {
+      [this.currentHash]: { startLine: newLine, endLine: newLine },
+      [this.comparedToHash]: { startLine: oldLine, endLine: oldLine }
+    };
+  }
+  put(range) {
+    const cur = this.currentHash;
+    const comp = this.comparedToHash;
+    range[cur].linesCount = range[cur].endLine - range[cur].startLine + 1;
+    range[comp].linesCount = range[comp].endLine - range[comp].startLine + 1;
+    for (let line = range[cur].startLine; line <= range[cur].endLine; line++) {
+      this.ranges.set(line, range);
+    }
+  }
+  putChangedRanges() {
+    let currentRange = null;
+    let oldLine = 1;
+    let newLine = 1;
+    for (const change of this.changes) {
+      if (!change.added && !change.removed) {
+        if (currentRange) {
+          this.put(currentRange);
+          currentRange = null;
+        }
+        oldLine += change.count;
+        newLine += change.count;
+        continue;
+      }
+      currentRange ??= this.createRange(oldLine, newLine);
+      if (change.removed) {
+        currentRange[this.comparedToHash].endLine = Math.min(
+          oldLine + change.count,
+          this.oldContentLinesCount
+        );
+        oldLine += change.count;
+      }
+      if (change.added) {
+        currentRange[this.currentHash].endLine = Math.min(
+          newLine + change.count,
+          this.newContentLinesCount
+        );
+        newLine += change.count;
+      }
+    }
+    if (currentRange) {
+      this.put(currentRange);
+    }
+  }
+};
+
+// server/controllers/ai/CheckAiServerController.js
+import { createOpencodeClient } from "@opencode-ai/sdk";
+var CheckAiServerController = class {
+  constructor(agentId = "local_opencode") {
+    this.agentId = agentId;
+    this.baseUrl = LOCAL_OPENCODE_BASE_URL;
+    this.timeout = DEFAULT_OPENCODE_TIMEOUT;
+  }
+  async check() {
+    try {
+      return await this.checkOpenCode();
+    } catch (error) {
+      return {
+        isConnected: false,
+        message: error?.message || "AI server unreachable"
+      };
+    }
+  }
+  async checkOpenCode() {
+    const client = createOpencodeClient({
+      baseUrl: this.baseUrl,
+      responseStyle: "data",
+      throwOnError: true
+    });
+    const session = await client.session.create({
+      body: {
+        title: `${APP_NAME} health check`
+      }
+    });
+    try {
+      await client.session.delete({ path: { id: session.id } });
+    } catch {
+    }
+    return {
+      isConnected: true,
+      message: "OpenCode server reachable"
+    };
+  }
+};
+
+// server/controllers/ai/PromptController.js
+import { createOpencodeClient as createOpencodeClient2 } from "@opencode-ai/sdk";
+
+// server/ai/PromptResponse.js
+import { createPatch as createPatch2, parsePatch } from "diff";
+var PromptResponse = class {
+  constructor(response = {}) {
+    this.response = response;
+  }
+  toJSON() {
+    return {
+      summary: this.response.summary,
+      diffs: this.normalizeDiffs(),
+      annotations: this.normalizeAnnotations()
+    };
+  }
+  normalizeDiffs() {
+    return this.response.diffs?.filter((eachDiff) => eachDiff.description && eachDiff?.diff && eachDiff.updatedCode).map((entry) => {
+      const filePath = entry.filePath || this.request.filePath || "code";
+      const originalCode = this.request.code;
+      const diff = createPatch2(filePath, originalCode, entry.updatedCode, "current", "ai");
+      return { filePath, title: entry.description, diff };
+    });
+  }
+  normalizeAnnotations() {
+    return this.response.annotations?.filter((eachAnnotation) => eachAnnotation?.title).map((annotation) => ({
+      filePath: annotation.filePath || this.request.filePath,
+      title: annotation.title,
+      startLine: Number(annotation.startLine || 1),
+      endLine: Number(annotation.endLine || annotation.startLine || 1)
+    }));
+  }
+};
+
+// server/controllers/ai/PromptController.js
+var PromptController = class {
+  constructor(storage2) {
+    this.storage = storage2;
+  }
+  async evaluate() {
+    throw new Error("PromptController#evaluate must be implemented by subclasses");
+  }
+  systemPrompt() {
+    return [
+      "You are a senior software engineer.",
+      "You help generate safe, production-quality code changes or code annotations that explain.",
+      "Rules:",
+      "- Prefer minimal targeted changes",
+      "- Preserve formatting and conventions",
+      "- Do not remove unrelated code",
+      "- Never include markdown",
+      "- Never include code fences",
+      "- Never explain outside schema",
+      "- Return structured output only",
+      "- If code is unchanged return empty diffs",
+      "Annotations should describe important code changes."
+    ].join("\n");
+  }
+  static create(storage2, agentId) {
+    return new OpenCodePromptController(storage2);
+  }
+};
+var OpenCodePromptController = class extends PromptController {
+  constructor(storage2) {
+    super(storage2);
+    this.baseUrl = LOCAL_OPENCODE_BASE_URL;
+    this.timeout = DEFAULT_OPENCODE_TIMEOUT;
+  }
+  async evaluate(request) {
+    const client = createOpencodeClient2({
+      baseUrl: this.baseUrl,
+      responseStyle: "data",
+      throwOnError: true
+    });
+    const session = await client.session.create({
+      body: {
+        title: `${APP_NAME} prompt`
+      }
+    });
+    const sessionId = session.id;
+    const result = await client.session.prompt({
+      path: { id: sessionId },
+      body: {
+        system: this.systemPrompt(),
+        parts: [{ type: "text", text: JSON.stringify(request, null, 2) }],
+        format: {
+          type: "json_schema",
+          schema: openCodePromptResponse
+        }
+      }
+    });
+    client.session.delete({ path: { id: sessionId } });
+    if (result.info.error) {
+      throw new Error(`OpenCode error: ${JSON.stringify(result.info.error)}`);
+    }
+    return new PromptResponse(result.info.structured).toJSON();
+  }
+};
+var openCodePromptResponse = {
+  type: "object",
+  properties: {
+    summary: { type: "string", default: "" },
+    diffs: {
+      type: "array",
+      items: {
+        type: "object",
+        properties: {
+          filePath: { type: ["string", "null"] },
+          description: { type: "string", default: "" },
+          diff: { type: ["string", "null"] }
+        },
+        required: ["description"],
+        additionalProperties: true
+      },
+      default: []
+    },
+    annotations: {
+      type: "array",
+      items: {
+        type: "object",
+        properties: {
+          filePath: { type: ["string", "null"] },
+          startLine: { type: "number" },
+          endLine: { type: "number" },
+          title: { type: "string" }
+        },
+        required: ["startLine", "endLine", "title"],
+        additionalProperties: true
+      },
+      default: []
+    }
+  },
+  required: ["summary", "diffs", "annotations"],
+  additionalProperties: true
+};
+
+// server/controllers/ai/AugmentNoteController.js
+var AugmentNoteController = class {
+  constructor(storage2, agentId) {
+    this.storage = storage2;
+    this.agentId = agentId;
+    this.promptController = PromptController.create(storage2, agentId);
+  }
+  buildSubNotes(parentNote, summary = parentNote.inputValue, diffs = [], annotations = []) {
+    const result = [];
+    if (summary) {
+    }
+    for (const eachDiff of diffs) {
+      result.push(parentNote.createChildFromDiff(eachDiff));
+    }
+    for (const eachAnnotation of annotations) {
+      result.push(parentNote.createChildFromAnnotation(eachAnnotation));
+    }
+    return result;
+  }
+  // prompt
+  sanitizeCode(input) {
+    if (typeof input !== "string") {
+      return input;
+    }
+    return input.replace(/(?<=API_KEY\s*=\s*).+/gi, "[REDACTED]").replace(/(?<=SECRET\s*=\s*).+/gi, "[REDACTED]").replace(/(?<=TOKEN\s*=\s*).+/gi, "[REDACTED]").replace(/(?<=PASSWORD\s*=\s*).+/gi, "[REDACTED]");
+  }
+  limitInput(input) {
+    if (input.length <= MAX_INPUT_CHARS) {
+      return input;
+    }
+    return input.slice(0, MAX_INPUT_CHARS) + "\n\n[TRUNCATED]";
+  }
+  // TODO: Fine tune and improve this
+  normalizeRequest(storedNote) {
+    return {
+      filePath: storedNote.note.file,
+      prompt: storedNote.inputValue
+      // currentLines: this.limitInput(this.sanitizeCode(currentLines)),
+      // code: this.limitInput(this.sanitizeCode(request.code)),
+      // language: String(request.language),
+      // selection: this.limitInput(String(request.selection)),
+      // context: this.limitInput(String(request.context)),
+    };
+  }
+  // action
+  async augment(storedNote) {
+    const request = this.normalizeRequest(storedNote);
+    const { summary, diffs, annotations } = await this.promptController.evaluate(
+      request,
+      this.agentId
+    );
+    const subNotes = this.buildSubNotes(storedNote, summary, diffs, annotations);
+    storedNote.subNotes = [...storedNote.subNotes, ...subNotes];
+    return storedNote;
+  }
+};
+
+// server/session/SessionNameGenerator.js
+var SESSION_NAME_ADJECTIVES = [
+  "Bright",
+  "Bold",
+  "Brisk",
+  "Calm",
+  "Cheery",
+  "Clever",
+  "Cosmic",
+  "Cozy",
+  "Curious",
+  "Eager",
+  "Gentle",
+  "Glowing",
+  "Jazzy",
+  "Lucky",
+  "Mellow",
+  "Merry",
+  "Nimble",
+  "Peppy",
+  "Plucky",
+  "Quirky",
+  "Sunny",
+  "Swift",
+  "Zesty"
+];
+var SESSION_NAME_NOUNS = [
+  "Badger",
+  "Comet",
+  "Dolphin",
+  "Falcon",
+  "Fern",
+  "Firefly",
+  "Fox",
+  "Harbor",
+  "Koala",
+  "Lantern",
+  "Lynx",
+  "Meadow",
+  "Otter",
+  "Panda",
+  "Pebble",
+  "Pine",
+  "Robin",
+  "Sparrow",
+  "Star",
+  "Tiger",
+  "Trail",
+  "Willow",
+  "Wren",
+  "Yeti"
+];
+var SESSION_NAME_COMBINATIONS_COUNT = SESSION_NAME_ADJECTIVES.length * SESSION_NAME_NOUNS.length;
+var SessionNameGenerator = class {
+  constructor(existingNames = /* @__PURE__ */ new Set()) {
+    this.existingNames = existingNames;
+  }
+  generate() {
+    if (this.existingNames.size >= SESSION_NAME_COMBINATIONS_COUNT) {
+      return `Session ${Date.now()}`;
+    }
+    let attempts = 0;
+    while (attempts < SESSION_NAME_COMBINATIONS_COUNT) {
+      const adjectiveIndex = Math.floor(Math.random() * SESSION_NAME_ADJECTIVES.length);
+      const nounIndex = Math.floor(Math.random() * SESSION_NAME_NOUNS.length);
+      const nextName = `${SESSION_NAME_ADJECTIVES[adjectiveIndex]} ${SESSION_NAME_NOUNS[nounIndex]}`;
+      if (!this.existingNames.has(nextName)) {
+        return nextName;
+      }
+      attempts += 1;
+    }
+    return `Session ${Date.now()}`;
+  }
+};
+
+// server/ws/MessageHandler.js
+var MessageHandlerFactory = class {
+  constructor(environment2, dependencies2, cache2, fileCommandLine2, dirCommandLine2, aSTs2, storage2, fileReader2, myPackage2) {
+    this.environment = environment2;
+    this.dependencies = dependencies2;
+    this.cache = cache2;
+    this.fileCommandLine = fileCommandLine2;
+    this.dirCommandLine = dirCommandLine2;
+    this.aSTs = aSTs2;
+    this.storage = storage2;
+    this.fileReader = fileReader2;
+    this.myPackage = myPackage2;
+  }
+  create(message, ws) {
+    return new MessageHandler(
+      message,
+      ws,
+      this.environment,
+      this.dependencies,
+      this.cache,
+      this.fileCommandLine,
+      this.dirCommandLine,
+      this.aSTs,
+      this.storage,
+      this.fileReader,
+      this.myPackage
+    );
+  }
+};
+var MessageHandler = class {
+  constructor(message, ws, environment2, dependencies2, cache2, fileCommandLine2, dirCommandLine2, aSTs2, storage2, fileReader2, myPackage2) {
+    this.message = message;
+    this.ws = ws;
+    this.environment = environment2;
+    this.dependencies = dependencies2;
+    this.cache = cache2;
+    this.fileCommandLine = fileCommandLine2;
+    this.dirCommandLine = dirCommandLine2;
+    this.aSTs = aSTs2;
+    this.storage = storage2;
+    this.fileReader = fileReader2;
+    this.myPackage = myPackage2;
+  }
+  send(response) {
+    this.storage.registerDebugEvent("response/be->fe", response);
+    this.ws.send(JSON.stringify(response));
+  }
+  createSession() {
+    const existingSessionNames = new Set(
+      (this.storage.getSessions?.() || []).map((session2) => session2.name)
+    );
+    const sessionNameGenerator = new SessionNameGenerator(existingSessionNames);
+    const defaultSessionName = sessionNameGenerator.generate();
+    const session = this.storage.createSession(defaultSessionName);
+    this.send({ TYPE: MessageTypes_default.CREATE_SESSION, id: this.message.id, data: { session } });
+  }
+  // TODO: infinite scroll, pagination, filtering...
+  getSessions() {
+    this.send({
+      TYPE: MessageTypes_default.GET_SESSIONS,
+      id: this.message.id,
+      data: this.storage.getSessions().slice(0, 10)
+    });
+  }
+  renameSession() {
+    const session = this.storage.renameSession(this.message.sessionId, this.message.name);
+    this.send({ TYPE: MessageTypes_default.RENAME_SESSION, id: this.message.id, data: { session } });
+  }
+  exportSession() {
+    const sessionId = this.message.sessionId;
+    const session = this.storage.getSessionById(sessionId);
+    const { list, removedList } = this.storage.getNotes(null, sessionId);
+    this.send({
+      TYPE: MessageTypes_default.EXPORT_SESSION,
+      id: this.message.id,
+      data: { session, notes: list, removedNotes: removedList }
+    });
+  }
+  importSession() {
+    const { session: sessionData, notes, removedNotes } = this.message;
+    const newSession = this.storage.createSession(sessionData.name);
+    this.storage.setNotes(notes || [], removedNotes || [], newSession.id);
+    this.send({
+      TYPE: MessageTypes_default.IMPORT_SESSION,
+      id: this.message.id,
+      data: { session: newSession }
+    });
+  }
+  checkUpdate() {
+    const response = new FsMetadataController(
+      this.environment,
+      this.fileCommandLine,
+      this.storage,
+      this.myPackage
+    ).getCurrentAndLatestVersions();
+    this.send({ TYPE: MessageTypes_default.CHECK_UPDATE, id: this.message.id, data: response });
+  }
+  findTokenUsages() {
+    const controller = new UsagesController(
+      ASTMatchedToken.fromJSON(this.message.token),
+      this.message.filePath,
+      this.dependencies,
+      this.aSTs,
+      this.fileReader,
+      this.dirCommandLine
+    );
+    const data = {
+      astUsages: controller.findASTUsages(),
+      textUsages: controller.findTextUsages()
+    };
+    this.send({ TYPE: MessageTypes_default.FIND_TOKEN_USAGES, id: this.message.id, data });
+  }
+  projectMetadata() {
+    const response = new FsMetadataController(
+      this.environment,
+      this.fileCommandLine,
+      this.storage,
+      this.myPackage
+    ).getProjectMetadata();
+    this.send({ TYPE: MessageTypes_default.PROJECT_METADATA, id: this.message.id, data: response });
+  }
+  root() {
+    const response = path6.resolve(this.environment.absoluteProjectRoot);
+    this.send({ TYPE: MessageTypes_default.ROOT, id: this.message.id, data: response });
+  }
+  getNotes() {
+    const { list, removedList } = this.storage.getNotes(null, this.message.sessionId);
+    this.send({
+      TYPE: MessageTypes_default.GET_NOTES,
+      id: this.message.id,
+      data: {
+        list: list.map((eachNote) => StoredNote.fromJSON(eachNote).toResponseJSON()),
+        removedList
+      }
+    });
+  }
+  debugTimeline() {
+    this.send({
+      TYPE: MessageTypes_default.DEBUG_TIMELINE,
+      id: this.message.id,
+      data: this.storage.debugTimeline()
+    });
+  }
+  getDebugEventById(id) {
+    this.send({
+      TYPE: MessageTypes_default.GET_DEBUG_EVENT_BY_ID,
+      id: this.message.id,
+      data: this.storage.getDebugEventById(id)
+    });
+  }
+  async promptAi() {
+    try {
+      const promptController = PromptController.create(this.storage, this.message.agentId);
+      const data = await promptController.evaluate(
+        this.message.promptRequest,
+        this.message.agentId
+      );
+      this.send({ TYPE: MessageTypes_default.PROMPT_AI, id: this.message.id, data });
+    } catch (error) {
+      this.send({
+        TYPE: MessageTypes_default.PROMPT_AI,
+        id: this.message.id,
+        error: error.message,
+        callStack: error.stack
+      });
+    }
+  }
+  async checkAiServer() {
+    const data = await new CheckAiServerController(this.message.agentId).check();
+    this.send({ TYPE: MessageTypes_default.CHECK_AI_SERVER, id: this.message.id, data });
+  }
+  async setNotes() {
+    const requestList = this.message.list;
+    const requestRemovedList = this.message.removedList;
+    const sessionId = this.message.sessionId;
+    const { list: storedList } = this.storage.getNotes(null, sessionId);
+    const storedNotes = new StoredNotes(storedList, requestList);
+    storedNotes.evaluateRequestList();
+    if (this.message.agentId) {
+      const augmentController = new AugmentNoteController(this.storage, this.message.agentId);
+      const augmentedNewNote = await augmentController.augment(storedNotes.newNote);
+      storedNotes.setNewNote(augmentedNewNote);
+    }
+    this.storage.setNotes(
+      storedNotes.responseList.map((eachNote) => eachNote.toStorageJSON()),
+      requestRemovedList,
+      sessionId
+    );
+    this.send({ TYPE: MessageTypes_default.SET_NOTES, id: this.message.id });
+  }
+  searchFiles() {
+    const query = this.message.query;
+    const isRegex = this.message.isRegex;
+    const isCaseSensitive = this.message.isCaseSensitive;
+    const response = new FilesExplorerController(this.environment, this.dirCommandLine).search(
+      query,
+      isRegex,
+      isCaseSensitive
+    );
+    this.send({ TYPE: MessageTypes_default.SEARCH_FILES, id: this.message.id, data: response });
+  }
+  recentlyModifiedFiles() {
+    const recentFiles = new FilesExplorerController(
+      this.environment,
+      this.dirCommandLine
+    ).recentlyModifiedFiles();
+    this.send({
+      TYPE: MessageTypes_default.RECENTLY_MODIFIED_FILES,
+      id: this.message.id,
+      data: recentFiles
+    });
+  }
+  gitModifiedFiles() {
+    const gitModifiedFiles = new FilesExplorerController(
+      this.environment,
+      this.dirCommandLine
+    ).gitModifiedFiles();
+    this.send({
+      TYPE: MessageTypes_default.MODIFIED_FILES,
+      id: this.message.id,
+      data: gitModifiedFiles
+    });
+  }
+  dirContent() {
+    const absolutePath = path6.join(this.environment.absoluteProjectRoot, this.message.path);
+    const content = new FilesExplorerController(this.environment, this.dirCommandLine).dirContent(
+      absolutePath
+    );
+    this.send({
+      TYPE: MessageTypes_default.DIR_CONTENT,
+      id: this.message.id,
+      data: content
+    });
+  }
+  setStorageFilePath() {
+    this.storage.setStorageStrategy(this.message.storageStrategy);
+    if (this.message.storageStrategy === StorageStrategy.FilePath) {
+      this.storage.initStoragePath(this.message.storageFilePath);
+    }
+    this.send({
+      TYPE: MessageTypes_default.SET_STORAGE_FILE_PATH,
+      id: this.message.id,
+      data: this.storage.storagePath
+    });
+  }
+  setDarkMode() {
+    const isDarkMode = this.message.isDarkMode;
+    this.storage.setIsDarkMode(isDarkMode);
+    this.send({
+      TYPE: MessageTypes_default.SET_DARK_MODE,
+      id: this.message.id,
+      data: { value: isDarkMode }
+    });
+  }
+  //
+  getFileMetadata() {
+    const environment2 = this.environment.withCommitHash(this.message.commitHash);
+    new ParseFileControllerAsync(
+      environment2,
+      this.send.bind(this),
+      this.cache,
+      this.storage,
+      this.fileReader.withEnvironment(environment2)
+    ).onFetchFileMetadataRequest(this.message);
+  }
+  fetchText() {
+    const environment2 = this.environment.withCommitHash(this.message.commitHash);
+    new ParseFileControllerAsync(
+      environment2,
+      this.send.bind(this),
+      this.cache,
+      this.storage,
+      this.fileReader.withEnvironment(environment2)
+    ).onFetchTextRequest(this.message);
+  }
+  fetchTokens() {
+    const environment2 = this.environment.withCommitHash(this.message.commitHash);
+    new ParseFileControllerAsync(
+      environment2,
+      this.send.bind(this),
+      this.cache,
+      this.storage,
+      this.fileReader.withEnvironment(environment2)
+    ).onFetchTokensRequest(this.message);
+  }
+  fetchNotesHighlights() {
+    const environment2 = this.environment.withCommitHash(this.message.commitHash);
+    new ParseFileControllerAsync(
+      environment2,
+      this.send.bind(this),
+      this.cache,
+      this.storage,
+      this.fileReader.withEnvironment(environment2)
+    ).onNotesRequest(this.message);
+  }
+  fetchFocusedNoteHighlights() {
+    const environment2 = this.environment.withCommitHash(this.message.commitHash);
+    new ParseFileControllerAsync(
+      environment2,
+      this.send.bind(this),
+      this.cache,
+      this.storage,
+      this.fileReader.withEnvironment(environment2)
+    ).onFocusedNoteRequest(this.message);
+  }
+  fetchTemporalNotesHighlights() {
+    const environment2 = this.environment.withCommitHash(this.message.commitHash);
+    new ParseFileControllerAsync(
+      environment2,
+      this.send.bind(this),
+      this.cache,
+      this.storage,
+      this.fileReader.withEnvironment(environment2)
+    ).onTemporalNotesRequest(this.message);
+  }
+  expandToken() {
+    const environment2 = this.environment.withCommitHash(this.message.commitHash);
+    new ParseFileControllerAsync(
+      environment2,
+      this.send.bind(this),
+      this.cache,
+      this.storage,
+      this.fileReader.withEnvironment(environment2)
+    ).onExpandTokenRequest(this.message);
+  }
+  //
+  getCommits() {
+    const data = this.environment.commitMessages(this.message.commitsHashes);
+    this.send({ TYPE: MessageTypes_default.GET_COMMITS, id: this.message.id, data });
+  }
+  getCommitNote() {
+    const { commitHash, comparedToCommitHash } = this.message;
+    const currentCommit = this.environment.commitMessages([commitHash])[0];
+    const changedFiles = this.environment.changedFilesRelativePaths(
+      commitHash,
+      comparedToCommitHash
+    );
+    const data = {
+      inputValue: currentCommit.message,
+      subNotes: changedFiles.map((filePath) => ({
+        inputValue: filePath,
+        file: path6.join(this.environment.absoluteProjectRoot, filePath)
+      }))
+    };
+    this.send({ TYPE: MessageTypes_default.GET_COMMIT_NOTE, id: this.message.id, data });
+  }
+  //
+  diffs() {
+    const controller = new DiffController(
+      this.fileReader,
+      this.message.filePath,
+      this.message.comparedToCommitHash,
+      this.message.currentCommitHash
+    );
+    controller.readContent();
+    controller.calculateDiffs();
+    const data = Array.from(controller.ranges);
+    this.send({ TYPE: MessageTypes_default.DIFF_RANGES, id: this.message.id, data });
+  }
+  getRangeInCommit() {
+    const targetEnvironment = this.environment.withCommitHash(this.message.commitHash);
+    new ParseFileControllerAsync(
+      targetEnvironment,
+      // TODO: Improve this
+      (response) => {
+        this.send({
+          ...response,
+          TYPE: MessageTypes_default.GET_RANGE_IN_COMMIT
+        });
+      },
+      this.cache,
+      this.storage,
+      this.fileReader.withEnvironment(targetEnvironment)
+    ).onFetchTokensRequest(this.message);
+  }
+};
+
+// server/index.js
+import { fileURLToPath } from "url";
+import { dirname } from "path";
+
+// server/os/Package.js
+import path7 from "path";
+import fs5 from "fs";
+import { execSync as execSync4 } from "child_process";
+var Package = class {
+  constructor(environment2, packageDirName2) {
+    this.environment = environment2;
+    this.packageDirName = packageDirName2;
+  }
+  currentVersion() {
+    const pkgPath = path7.join(this.packageDirName, "package.json");
+    const pkg = JSON.parse(fs5.readFileSync(pkgPath, "utf-8"));
+    const currentVersion = pkg.version;
+    return currentVersion;
+  }
+  latestVersion() {
+    if (process.env.NODE_ENV === "development") {
+      return "1";
+    }
+    try {
+      const latestVersion = execSync4(`npm view ${APP_NAME} version`, {
+        encoding: "utf8"
+      }).trim();
+      return latestVersion;
+    } catch (error) {
+      return this.currentVersion();
+    }
+  }
+};
+
+// server/storage/Cache.js
+import { LRUCache } from "lru-cache";
+var DEFAULT_MAX_SIZE_MB = 200;
+var DEFAULT_MAX_ITEMS_COUNT = 1e3;
+var BYTES_PER_MB = 1024 * 1024;
+var FALLBACK_ITEM_SIZE = 1;
+var Cache = class {
+  constructor(options = {}) {
+    const maxSizeBytes = (options.maxSizeMB || DEFAULT_MAX_SIZE_MB) * BYTES_PER_MB;
+    this.maxMemoryMB = options.maxSizeMB || DEFAULT_MAX_SIZE_MB;
+    this.lruCache = new LRUCache({
+      max: options.max || DEFAULT_MAX_ITEMS_COUNT,
+      maxSize: maxSizeBytes,
+      // TODO: Why needing this?
+      sizeCalculation: (value) => {
+        try {
+          return JSON.stringify(value).length;
+        } catch {
+          return FALLBACK_ITEM_SIZE;
+        }
+      },
+      updateAgeOnGet: true,
+      updateAgeOnHas: false,
+      allowStale: false
+      // TODO: should we add this?
+      // ttl: 1000 * 60 * 5,
+    });
+  }
+  //
+  set(key, value) {
+    this.lruCache.set(key, value);
+  }
+  get(key) {
+    return this.lruCache.get(key);
+  }
+  has(key) {
+    return this.lruCache.has(key);
+  }
+  delete(key) {
+    this.lruCache.delete(key);
+  }
+  clear() {
+    this.lruCache.clear();
+  }
+  // stats
+  getStats() {
+    const heapUsed = process.memoryUsage().heapUsed;
+    const memoryUsageMB = Math.round(heapUsed / BYTES_PER_MB * 100) / 100;
+    return {
+      size: this.lruCache.size,
+      memoryUsageMB,
+      maxMemoryMB: this.maxMemoryMB,
+      calculatedSizeMB: Math.round(this.lruCache.calculatedSize / BYTES_PER_MB)
+    };
+  }
+};
+var Cache_default = Cache;
+
+// server/index.js
+console.log(`[${APP_NAME}]:  [init...]`);
+var args = process.argv.slice(2);
+var packageDirName;
+if (process.env.NODE_ENV === "development") {
+  const __filename = fileURLToPath(import.meta.url);
+  packageDirName = dirname(__filename);
+  packageDirName = dirname(packageDirName);
+} else {
+  packageDirName = __dirname;
+}
+var launchDir = process.cwd();
+var defaultPort = 8080;
+var environment = Environment.parse(args, launchDir, defaultPort);
+var myPackage = new Package(environment, packageDirName);
+var fileReader = new FileReader_default(environment);
+var storage = new Storage(environment.absoluteProjectRoot);
+var fileCommandLine = new FileCommandLine();
+var dirCommandLine = new DirCommandLine(environment);
+var aSTs = new ASTs(/* @__PURE__ */ new Map(), fileReader);
+var cache = new Cache_default();
+if (storage.findStoragePath()) {
+  storage.setStorageStrategy(StorageStrategy.FilePath);
+}
+storage.init();
+var storageFilePath = storage.findStoragePath();
+if (storageFilePath) {
+  console.log(`[${APP_NAME}]:  Storage file path: ${storageFilePath}`);
+}
+var dependencies = new ASTDependencies(environment, fileCommandLine, dirCommandLine);
+dependencies.init();
+var startWebServer = () => {
+  const app = express();
+  app.use(express.static(path8.join(packageDirName)));
+  app.get("/", (req, res) => {
+    res.sendFile(path8.join(packageDirName, "index.html"));
+  });
+  const result = app.listen(environment.port, () => {
+    console.log(`[${APP_NAME}]:  [ON]`);
+    const upgradeInfo = new FsMetadataController(
+      environment,
+      fileCommandLine,
+      storage,
+      myPackage
+    ).getCurrentAndLatestVersions();
+    console.log(`[version]:  [${upgradeInfo.currentVersion}]`);
+    if (upgradeInfo.currentVersion !== upgradeInfo.latestVersion) {
+      console.log("\n===========================================");
+      console.log("New version available!\n");
+      console.log("Please upgrade to the latest version for new features and bug fixes.");
+      console.log(`Check our upgrade guide at: ${APP_WEB_URLS.UpgradeGuide}`);
+      console.log("===========================================\n");
+    }
+    console.log(`[${APP_NAME}]: Start here: http://localhost:${environment.port}/`);
+  });
+  return result;
+};
+var messageHandlerFactory = new MessageHandlerFactory(
+  environment,
+  dependencies,
+  cache,
+  fileCommandLine,
+  dirCommandLine,
+  aSTs,
+  storage,
+  fileReader,
+  myPackage
+);
+var webSocketServer = new WebSocketServer2(messageHandlerFactory, storage, cache);
+webSocketServer.start(startWebServer);