micro-models-agent 0.63.3 → 1.1.0

package/dist/modules/indexer/symbols.js

@@ -0,0 +1,189 @@
+/**
+ * Language registry and symbol extraction for the project index.
+ *
+ * Adding a language = one entry in `RULES` + one or more extensions in
+ * `EXT_TO_LANGUAGE`. Each rule declares whether the language is source code
+ * (used for map ranking) and how to pull public/exported symbol names out of
+ * a file. Extraction is regex-based on purpose (no parser dependency): it is
+ * cheap, runs on every indexed file, and only needs enough structure to make
+ * the project map useful — not a full AST.
+ */
+/** Cap per file so a single generated file cannot blow up the map. */
+export const MAX_SYMBOLS_PER_FILE = 40;
+/** Unique preserved-order names. */
+function dedupe(names) {
+    const seen = new Set();
+    const out = [];
+    for (const name of names) {
+        if (name && !seen.has(name)) {
+            seen.add(name);
+            out.push(name);
+        }
+    }
+    return out;
+}
+/** Collect captured group 1 from a list of global (multiline) regexes. */
+function collect(content, patterns) {
+    const names = [];
+    for (const re of patterns) {
+        re.lastIndex = 0;
+        let match;
+        while ((match = re.exec(content)) !== null) {
+            if (match[1])
+                names.push(match[1]);
+            if (match.index === re.lastIndex)
+                re.lastIndex++;
+        }
+    }
+    return names;
+}
+/** Names from `export { a, b as c }` / `export type { X }` clauses. */
+function collectExportClauses(content) {
+    const names = [];
+    const re = /export\s+(?:type\s+)?\{([^}]*)\}/g;
+    let match;
+    while ((match = re.exec(content)) !== null) {
+        for (const part of match[1].split(",")) {
+            const cleaned = part.trim().replace(/^type\s+/, "");
+            if (!cleaned || cleaned.startsWith("//"))
+                continue;
+            const alias = cleaned.split(/\s+as\s+/);
+            const exported = (alias.length > 1 ? alias[1] : alias[0]).trim();
+            if (/^\w+$/.test(exported))
+                names.push(exported);
+        }
+    }
+    return names;
+}
+const TS_JS_PATTERNS = [
+    /^export\s+(?:default\s+)?(?:declare\s+)?(?:abstract\s+)?(?:async\s+)?(?:const|let|var|function|class|interface|type|enum)\s+(\w+)/gm,
+    /^export\s+default\s+(?:class|function)\s+(\w+)/gm,
+];
+function tsLike(content) {
+    return dedupe([...collect(content, TS_JS_PATTERNS), ...collectExportClauses(content)]);
+}
+const PYTHON_PATTERNS = [/^(?:async\s+)?def\s+(\w+)/gm, /^class\s+(\w+)/gm];
+const RUST_PATTERNS = [
+    /^\s*pub(?:\([^)]*\))?\s+(?:async\s+)?(?:unsafe\s+)?(?:fn|struct|enum|trait|const|static|type|mod)\s+(\w+)/gm,
+    /macro_rules!\s+(\w+)/g,
+];
+const GO_PATTERNS = [
+    /^func\s+(\w+)\s*[([]/gm,
+    /^func\s+\([^)]*\)\s+(\w+)\s*[([]/gm,
+    /^type\s+(\w+)/gm,
+    /^(?:var|const)\s+(\w+)/gm,
+];
+const JAVA_PATTERNS = [
+    /^\s*(?:(?:public|protected|private|final|abstract|static|sealed|non-sealed|strictfp)\s+)*(?:class|interface|enum|record)\s+(\w+)/gm,
+];
+const KOTLIN_PATTERNS = [
+    /^\s*(?:(?:public|internal|private|protected|open|abstract|sealed|data|enum|annotation|value|inline)\s+)*(?:class|interface|object)\s+(\w+)/gm,
+    /^\s*(?:(?:public|internal|private|protected|open|override|suspend|inline|operator|infix|tailrec|external)\s+)*fun\s+(\w+)/gm,
+];
+const CSHARP_PATTERNS = [
+    /^\s*(?:(?:public|internal|private|protected|static|sealed|abstract|partial|readonly|unsafe|new|record)\s+)*(?:class|interface|struct|enum|record)\s+(\w+)/gm,
+];
+const RUBY_PATTERNS = [/^\s*(?:def|class|module)\s+([A-Za-z_]\w*[?!]?)/gm];
+const PHP_PATTERNS = [/\b(?:function|class|interface|trait|enum)\s+(\w+)/g];
+const SWIFT_PATTERNS = [/\b(?:func|class|struct|enum|protocol|extension)\s+(\w+)/g];
+const SCALA_PATTERNS = [
+    /^\s*(?:(?:private|protected|final|abstract|sealed|implicit|lazy|override)\s+)*(?:def|class|object|trait)\s+(\w+)/gm,
+];
+const C_CPP_PATTERNS = [
+    /^\s*(?:typedef\s+)?(?:class|struct|enum|union|namespace)\s+(\w+)/gm,
+    /\}\s*(\w+)\s*;/g,
+];
+const SHELL_PATTERNS = [/^\s*(?:function\s+)?(\w+)\s*\(\s*\)\s*\{/gm];
+const LUA_PATTERNS = [/^\s*(?:local\s+)?function\s+([\w.:]+)/gm];
+const NO_SYMBOLS = () => [];
+const RULES = {
+    typescript: { code: true, extract: tsLike },
+    "typescript-react": { code: true, extract: tsLike },
+    javascript: { code: true, extract: tsLike },
+    "javascript-react": { code: true, extract: tsLike },
+    python: { code: true, extract: (c) => collect(c, PYTHON_PATTERNS) },
+    rust: { code: true, extract: (c) => collect(c, RUST_PATTERNS) },
+    go: { code: true, extract: (c) => collect(c, GO_PATTERNS) },
+    java: { code: true, extract: (c) => collect(c, JAVA_PATTERNS) },
+    kotlin: { code: true, extract: (c) => collect(c, KOTLIN_PATTERNS) },
+    csharp: { code: true, extract: (c) => collect(c, CSHARP_PATTERNS) },
+    ruby: { code: true, extract: (c) => collect(c, RUBY_PATTERNS) },
+    php: { code: true, extract: (c) => collect(c, PHP_PATTERNS) },
+    swift: { code: true, extract: (c) => collect(c, SWIFT_PATTERNS) },
+    scala: { code: true, extract: (c) => collect(c, SCALA_PATTERNS) },
+    c: { code: true, extract: (c) => collect(c, C_CPP_PATTERNS) },
+    cpp: { code: true, extract: (c) => collect(c, C_CPP_PATTERNS) },
+    shell: { code: true, extract: (c) => collect(c, SHELL_PATTERNS) },
+    lua: { code: true, extract: (c) => collect(c, LUA_PATTERNS) },
+    json: { code: false, extract: NO_SYMBOLS },
+    markdown: { code: false, extract: NO_SYMBOLS },
+    yaml: { code: false, extract: NO_SYMBOLS },
+    toml: { code: false, extract: NO_SYMBOLS },
+    xml: { code: false, extract: NO_SYMBOLS },
+    html: { code: false, extract: NO_SYMBOLS },
+    css: { code: false, extract: NO_SYMBOLS },
+};
+const EXT_TO_LANGUAGE = {
+    ".ts": "typescript",
+    ".mts": "typescript",
+    ".cts": "typescript",
+    ".tsx": "typescript-react",
+    ".js": "javascript",
+    ".mjs": "javascript",
+    ".cjs": "javascript",
+    ".jsx": "javascript-react",
+    ".py": "python",
+    ".pyi": "python",
+    ".rs": "rust",
+    ".go": "go",
+    ".java": "java",
+    ".kt": "kotlin",
+    ".kts": "kotlin",
+    ".cs": "csharp",
+    ".rb": "ruby",
+    ".php": "php",
+    ".swift": "swift",
+    ".scala": "scala",
+    ".c": "c",
+    ".h": "c",
+    ".cpp": "cpp",
+    ".cc": "cpp",
+    ".cxx": "cpp",
+    ".hpp": "cpp",
+    ".hxx": "cpp",
+    ".sh": "shell",
+    ".bash": "shell",
+    ".zsh": "shell",
+    ".lua": "lua",
+    ".json": "json",
+    ".md": "markdown",
+    ".markdown": "markdown",
+    ".yaml": "yaml",
+    ".yml": "yaml",
+    ".toml": "toml",
+    ".xml": "xml",
+    ".html": "html",
+    ".htm": "html",
+    ".css": "css",
+    ".scss": "css",
+    ".less": "css",
+};
+/** Language id for a file extension (lowercase, with dot), or null if not indexed. */
+export function languageIdForExt(ext) {
+    return EXT_TO_LANGUAGE[ext.toLowerCase()] ?? null;
+}
+/** True when the language is source code (affects project-map ranking). */
+export function isCodeLanguage(languageId) {
+    return RULES[languageId]?.code ?? false;
+}
+/** Extract public/exported symbol names from file content. */
+export function extractSymbols(content, languageId) {
+    const rule = RULES[languageId];
+    if (!rule)
+        return [];
+    return dedupe(rule.extract(content)).slice(0, MAX_SYMBOLS_PER_FILE);
+}
+/** All indexed extensions (for docs/tests). */
+export function indexedExtensions() {
+    return Object.keys(EXT_TO_LANGUAGE).sort();
+}

package/dist/modules/indexer/walker.js

@@ -1,19 +1,72 @@
-import { readdirSync, readFileSync, statSync, existsSync, watch } from "fs";
+import { readdirSync, readFileSync, statSync, lstatSync, existsSync, watch } from "fs";
 import { join, relative, extname } from "path";
-const LANGUAGES = {
-    ".ts": "typescript",
-    ".tsx": "typescript-react",
-    ".js": "javascript",
-    ".jsx": "javascript-react",
-    ".json": "json",
-    ".md": "markdown",
-    ".yaml": "yaml",
-    ".yml": "yaml",
-    ".py": "python",
-    ".rs": "rust",
-    ".go": "go",
-};
-const IGNORE_DIRS = new Set(["node_modules", ".git", "dist", "build", ".mma", "coverage"]);
+import { Logger } from "../../logger/app-logger";
+import { languageIdForExt, extractSymbols } from "./symbols";
+import { t } from "../../i18n/index";
+const logger = new Logger("warn", "indexer");
+/**
+ * Directories that never hold project source but would flood the index:
+ * VCS/build output, package caches and virtual environments across
+ * ecosystems (Node, Python, Rust, Go/PHP/Ruby, JVM, .NET, Apple, IDE).
+ * Stored lowercase — matching is case-insensitive (Windows/macOS).
+ */
+const IGNORE_DIRS = new Set([
+    // VCS / MMA
+    ".git",
+    ".hg",
+    ".svn",
+    ".mma",
+    // Node / JS bundlers
+    "node_modules",
+    "dist",
+    "build",
+    "coverage",
+    ".next",
+    ".nuxt",
+    ".svelte-kit",
+    ".turbo",
+    ".parcel-cache",
+    ".cache",
+    // Python
+    "venv",
+    ".venv",
+    "env",
+    "virtualenv",
+    "__pycache__",
+    ".pytest_cache",
+    ".mypy_cache",
+    ".ruff_cache",
+    ".tox",
+    "site-packages",
+    // Rust
+    "target",
+    // Go / PHP / Ruby
+    "vendor",
+    ".bundle",
+    // JVM
+    ".gradle",
+    "out",
+    // .NET
+    "obj",
+    // Apple
+    "pods",
+    "deriveddata",
+    // IDE / editor
+    ".idea",
+    ".vscode",
+]);
+/** True when a directory name is ignored (case-insensitive). */
+export function isIgnoredDirName(name) {
+    return IGNORE_DIRS.has(name.toLowerCase());
+}
+/**
+ * True when any path SEGMENT is an ignored directory. Segment-based (not a
+ * substring) so short names like `env`/`out`/`obj` do not black out
+ * `environment.ts` or `about/`.
+ */
+function isIgnoredPath(filename) {
+    return filename.split(/[\\/]/).some((segment) => isIgnoredDirName(segment));
+}
 export class Indexer {
     baseDir;
     MAX_FILES = 1000;
@@ -23,7 +76,7 @@ export class Indexer {
     }
     watch(callback) {
         this.watcher = watch(this.baseDir, { recursive: true }, (event, filename) => {
-            if (filename && !Array.from(IGNORE_DIRS).some((dir) => filename.includes(dir))) {
+            if (filename && !isIgnoredPath(filename)) {
                 callback(event, filename);
             }
         });
@@ -53,40 +106,41 @@ export class Indexer {
                     return;
                 const fullPath = join(dir, entry);
                 const relPath = relative(this.baseDir, fullPath);
-                const stat = statSync(fullPath);
-                if (stat.isDirectory()) {
-                    if (!IGNORE_DIRS.has(entry)) {
-                        walkDir(fullPath);
+                // Per-entry isolation: a file deleted (or unreadable) between readdir
+                // and stat must not kill the whole walk. Symlinks are skipped — they
+                // can point outside the project or create directory cycles.
+                try {
+                    const lst = lstatSync(fullPath, { throwIfNoEntry: false });
+                    if (!lst || lst.isSymbolicLink())
+                        continue;
+                    const stat = statSync(fullPath);
+                    if (stat.isDirectory()) {
+                        if (!isIgnoredDirName(entry)) {
+                            walkDir(fullPath);
+                        }
                     }
-                }
-                else if (stat.isFile()) {
-                    const ext = extname(entry).toLowerCase();
-                    const language = LANGUAGES[ext];
-                    if (language) {
-                        const content = readFileSync(fullPath, "utf-8");
-                        const exports = this.extractExports(content, language);
-                        files.push({ path: relPath, language, exports, size: stat.size });
-                        totalSize += stat.size;
-                        count++;
+                    else if (stat.isFile()) {
+                        const ext = extname(entry).toLowerCase();
+                        const language = languageIdForExt(ext);
+                        if (language) {
+                            const content = readFileSync(fullPath, "utf-8");
+                            const exports = extractSymbols(content, language);
+                            files.push({ path: relPath, language, exports, size: stat.size });
+                            totalSize += stat.size;
+                            count++;
+                        }
                     }
                 }
+                catch (e) {
+                    // Entry vanished or is unreadable — skip it, keep indexing the rest.
+                    logger.warn(t("env.index_skip_unreadable", { path: relPath }), { error: String(e) });
+                    continue;
+                }
             }
         };
         walkDir(this.baseDir);
         return { files, totalSize };
     }
-    extractExports(content, language) {
-        if (language === "typescript" || language === "javascript") {
-            const exports = [];
-            const exportRegex = /export\s+(?:const|function|class|interface|type|enum|default\s+(?:class|function))\s+(\w+)/g;
-            let match;
-            while ((match = exportRegex.exec(content)) !== null) {
-                exports.push(match[1]);
-            }
-            return exports;
-        }
-        return [];
-    }
     summarize(result) {
         const byLang = {};
         for (const f of result.files) {

package/dist/modules/lsp/check-tool.js

@@ -1,6 +1,7 @@
 import { readdir, stat } from "fs/promises";
 import { resolve, relative } from "path";
 import { getServerForFile } from "./config";
+import { toForwardSlash } from "../../tools/path-utils";
 /** lsp_check directory mode: walk depth and per-call file cap. */
 export const MAX_LSP_CHECK_FILES = 15;
 const MAX_LSP_WALK_DEPTH = 4;
@@ -48,7 +49,7 @@ export function formatCheckDiagnostics(items, baseDir) {
     return items
         .slice(0, 40)
         .map(({ file, diag }) => {
-        const rel = relative(baseDir, file).replace(/\\/g, "/");
+        const rel = toForwardSlash(relative(baseDir, file));
         const line = diag.range.start.line + 1;
         const col = diag.range.start.character + 1;
         const sev = severityLabels[diag.severity] ?? "unknown";

package/dist/modules/lsp/client.js

@@ -3,6 +3,8 @@ import { resolve } from "path";
 import { platform } from "os";
 import { resolveSpawnCommand, buildWinCommandLine } from "./command";
 import { killTree } from "../processes/registry";
+import { toForwardSlash } from "../../tools/path-utils";
+import { errMsg } from "../../utils";
 /**
  * Logger adapter that writes LSP diagnostics to app.jsonl only — never to
  * console/terminal. LSP warnings are noisy (timeout on first run, npx
@@ -36,7 +38,7 @@ export class LspClient {
     process = null;
     requestId = 0;
     pending = new Map();
-    buffer = "";
+    buffer = Buffer.alloc(0);
     contentLength = -1;
     diagnostics = [];
     diagnosticsResolve = null;
@@ -103,7 +105,7 @@ export class LspClient {
             await this.sendRequest("initialize", initParams, timeout);
         }
         catch (e) {
-            const msg = e instanceof Error ? e.message : String(e);
+            const msg = errMsg(e);
             this.logger?.warn(`LSP initialize failed (attempt 1): ${msg}`, {
                 command: config.command,
                 projectRoot,
@@ -117,7 +119,7 @@ export class LspClient {
                 await this.sendRequest("initialize", initParams, timeout);
             }
             catch (retryErr) {
-                const retryMsg = retryErr instanceof Error ? retryErr.message : String(retryErr);
+                const retryMsg = errMsg(retryErr);
                 this.logger?.error(`LSP initialize failed (attempt 2, giving up): ${retryMsg}`, {
                     command: config.command,
                     projectRoot,
@@ -167,6 +169,11 @@ export class LspClient {
                 stdio: ["pipe", "pipe", "pipe"],
                 env: { ...process.env, ...config.env },
                 cwd: projectRoot,
+                // POSIX: make the child a process-group leader so killTree()'s
+                // `kill(-pid)` reaches the whole chain (npx → node → tsserver).
+                // Without it the group kill fails with ESRCH and grandchildren
+                // survive as orphans. Windows relies on taskkill /T instead.
+                detached: !isWin,
             };
             if (isWin) {
                 // A `.cmd` shim can't be spawned directly under Node (`spawn npx EINVAL`) — run via cmd.exe.
@@ -187,14 +194,14 @@ export class LspClient {
             setTimeout(() => {
                 if (!this.initialized && this.process) {
                     const msg = "LSP server start timeout";
-                    this.logger?.error(msg, { command: config.command, projectRoot, timeout: config.timeout ?? 10000 });
+                    this.logger?.error(msg, { command: config.command, projectRoot, timeout: config.timeout ?? DEFAULT_TIMEOUT });
                     reject(new Error(msg));
                 }
-            }, config.timeout ?? 10000);
+            }, config.timeout ?? DEFAULT_TIMEOUT);
         });
     }
     handleData(chunk) {
-        this.buffer += chunk.toString();
+        this.buffer = Buffer.concat([this.buffer, chunk]);
         this.parseMessages();
     }
     parseMessages() {
@@ -203,33 +210,36 @@ export class LspClient {
                 const headerEnd = this.buffer.indexOf("\r\n\r\n");
                 if (headerEnd === -1)
                     return;
-                const header = this.buffer.slice(0, headerEnd);
+                // Headers are ASCII — decode just the header slice.
+                const header = this.buffer.subarray(0, headerEnd).toString("utf8");
                 const match = header.match(/Content-Length: (\d+)/i);
                 if (!match) {
-                    this.buffer = this.buffer.slice(headerEnd + 4);
-                    this.contentLength = -1;
+                    this.buffer = this.buffer.subarray(headerEnd + 4);
                     continue;
                 }
                 this.contentLength = parseInt(match[1], 10);
                 // Guard against malicious/buggy servers sending absurd Content-Length
                 if (this.contentLength > 10 * 1024 * 1024) {
-                    this.buffer = this.buffer.slice(headerEnd + 4);
+                    this.buffer = this.buffer.subarray(headerEnd + 4);
                     this.contentLength = -1;
                     continue;
                 }
-                this.buffer = this.buffer.slice(headerEnd + 4);
+                this.buffer = this.buffer.subarray(headerEnd + 4);
             }
+            // Content-Length counts BYTES, not JS characters. Slicing a decoded
+            // string by character count corrupts frames containing multi-byte
+            // UTF-8 (e.g. Cyrillic diagnostics) — keep the remainder as raw bytes.
             if (this.buffer.length < this.contentLength)
                 return;
-            const body = this.buffer.slice(0, this.contentLength);
-            this.buffer = this.buffer.slice(this.contentLength);
+            const body = this.buffer.subarray(0, this.contentLength).toString("utf8");
+            this.buffer = this.buffer.subarray(this.contentLength);
             this.contentLength = -1;
             try {
                 const msg = JSON.parse(body);
                 this.handleMessage(msg);
             }
             catch (e) {
-                this.logger?.debug(`LSP JSON parse error: ${e instanceof Error ? e.message : String(e)}`);
+                this.logger?.debug(`LSP JSON parse error: ${errMsg(e)}`);
             }
         }
     }
@@ -290,7 +300,7 @@ export class LspClient {
             this.process.stdin.write(header + message);
         }
         catch (e) {
-            this.logger?.debug(`LSP write error: ${e instanceof Error ? e.message : String(e)}`);
+            this.logger?.debug(`LSP write error: ${errMsg(e)}`);
         }
     }
     async shutdown() {
@@ -304,14 +314,14 @@ export class LspClient {
                     await this.sendRequest("shutdown", null, 3000);
                 }
                 catch (e) {
-                    this.logger?.debug(`LSP shutdown request failed: ${e instanceof Error ? e.message : String(e)}`);
+                    this.logger?.debug(`LSP shutdown request failed: ${errMsg(e)}`);
                 }
                 this.sendNotification("exit", null);
                 await new Promise((r) => setTimeout(r, 200));
             }
         }
         catch (e) {
-            this.logger?.debug(`LSP shutdown error: ${e instanceof Error ? e.message : String(e)}`);
+            this.logger?.debug(`LSP shutdown error: ${errMsg(e)}`);
         }
         finally {
             if (this.process) {
@@ -322,12 +332,12 @@ export class LspClient {
                     killTree(this.process);
                 }
                 catch (e) {
-                    this.logger?.debug(`LSP killTree error: ${e instanceof Error ? e.message : String(e)}`);
+                    this.logger?.debug(`LSP killTree error: ${errMsg(e)}`);
                 }
                 this.process = null;
             }
             this.initialized = false;
-            this.buffer = "";
+            this.buffer = Buffer.alloc(0);
             this.contentLength = -1;
             if (this.diagnosticsTimer) {
                 clearTimeout(this.diagnosticsTimer);
@@ -336,7 +346,7 @@ export class LspClient {
         }
     }
     pathToUri(filePath) {
-        const normalized = filePath.replace(/\\/g, "/");
+        const normalized = toForwardSlash(filePath);
         return /^[a-zA-Z]:/.test(normalized) ? `file:///${normalized}` : `file://${normalized}`;
     }
     languageFromPath(filePath) {
@@ -364,23 +374,30 @@ export class LspClient {
         return map[ext ?? ""] ?? "plaintext";
     }
     /**
-     * Extract the actual binary name from npx args.
-     * For `npx --yes --package typescript-language-server --package typescript@5 typescript-language-server --stdio`
-     * returns `typescript-language-server` (the last non-flag arg before `--stdio`).
+     * Extract the actual binary name from npx args — only for the strict layout
+     * `[--yes] [--package X]... <binary> --stdio`. Servers with trailing server
+     * arguments (e.g. angular's `ngserver --stdio --tsProbeLocations …`) return
+     * null and always run through npx, so their flags are never mistaken for the
+     * binary or stripped.
      */
     extractBinaryFromNpxArgs(args) {
-        // Find the binary: last arg that doesn't start with -- and isn't a package version
-        for (let i = args.length - 1; i >= 0; i--) {
-            const arg = args[i];
-            if (arg === "--stdio")
+        const stdioIdx = args.lastIndexOf("--stdio");
+        if (stdioIdx !== args.length - 1 || stdioIdx < 1)
+            return null;
+        const binary = args[stdioIdx - 1];
+        if (!binary || binary.startsWith("-") || this.isPackageVersion(binary))
+            return null;
+        for (let i = 0; i < stdioIdx - 1; i++) {
+            const a = args[i];
+            if (a === "--yes")
                 continue;
-            if (arg.startsWith("--"))
-                return null; // unexpected format
-            if (this.isPackageVersion(arg))
+            if (a === "--package") {
+                i++;
                 continue;
-            return arg;
+            }
+            return null;
         }
-        return null;
+        return binary;
     }
     /** Check if a string looks like a package version specifier (e.g. "typescript@5"). */
     isPackageVersion(s) {

package/dist/modules/lsp/config.js

@@ -1,3 +1,5 @@
+import { existsSync } from "fs";
+import { dirname, join } from "path";
 /**
  * LSP server defaults.
  *
@@ -101,6 +103,25 @@ export const DEFAULT_LSP_CONFIG = {
             autoInstall: true,
             workspaceMarkers: ["package.json"],
         },
+        angular: {
+            command: "npx",
+            args: [
+                "--yes",
+                "--package",
+                "@angular/language-server",
+                "--package",
+                "typescript@5",
+                "ngserver",
+                "--stdio",
+                "--tsProbeLocations",
+                "./node_modules",
+                "--ngProbeLocations",
+                "./node_modules",
+            ],
+            timeout: 60000,
+            autoInstall: true,
+            workspaceMarkers: ["angular.json"],
+        },
     },
 };
 const LANGUAGE_MAP = {
@@ -127,9 +148,41 @@ export function getLanguageForFile(filePath) {
         return null;
     return LANGUAGE_MAP[ext] ?? null;
 }
-export function getServerForFile(filePath, config) {
+const ANGULAR_MARKER = "angular.json";
+const ANGULAR_LOOKUP_DEPTH = 10;
+/**
+ * True when the file lives inside an Angular workspace (an `angular.json`
+ * marker exists in one of its ancestor directories, bounded lookup).
+ */
+function isAngularProject(filePath) {
+    let dir = dirname(filePath);
+    for (let i = 0; i < ANGULAR_LOOKUP_DEPTH; i++) {
+        if (existsSync(join(dir, ANGULAR_MARKER)))
+            return true;
+        const parent = dirname(dir);
+        if (parent === dir)
+            return false;
+        dir = parent;
+    }
+    return false;
+}
+/**
+ * Config key of the LSP server for a file. `.html` routes to the `angular`
+ * server inside Angular workspaces (templates with bindings need the Angular
+ * language service) and to the generic `html` server everywhere else.
+ */
+export function getServerKeyForFile(filePath, config) {
     const lang = getLanguageForFile(filePath);
     if (!lang)
         return null;
-    return config.servers[lang] ?? null;
+    if (lang === "html" && config.servers.angular && isAngularProject(filePath)) {
+        return "angular";
+    }
+    return lang;
+}
+export function getServerForFile(filePath, config) {
+    const key = getServerKeyForFile(filePath, config);
+    if (!key)
+        return null;
+    return config.servers[key] ?? null;
 }