@zenithbuild/language-server 0.2.7 → 0.5.0-beta.2.19

package/src/project.ts

@@ -22,40 +22,156 @@ export interface ProjectGraph {
     pages: Map<string, ComponentInfo>;
 }
 
+const ZENITH_CONFIG_CANDIDATES = [
+    'zenith.config.ts',
+    'zenith.config.js',
+    'zenith.config.mjs',
+    'zenith.config.cjs',
+    'zenith.config.json'
+];
+
+function hasZenithConfig(dir: string): boolean {
+    return ZENITH_CONFIG_CANDIDATES.some((fileName) => fs.existsSync(path.join(dir, fileName)));
+}
+
+function hasZenithCliDependency(dir: string): boolean {
+    const packageJsonPath = path.join(dir, 'package.json');
+    if (!fs.existsSync(packageJsonPath)) {
+        return false;
+    }
+
+    try {
+        const raw = fs.readFileSync(packageJsonPath, 'utf-8');
+        const pkg = JSON.parse(raw) as {
+            dependencies?: Record<string, string>;
+            devDependencies?: Record<string, string>;
+            peerDependencies?: Record<string, string>;
+            optionalDependencies?: Record<string, string>;
+        };
+
+        const deps = [
+            pkg.dependencies || {},
+            pkg.devDependencies || {},
+            pkg.peerDependencies || {},
+            pkg.optionalDependencies || {}
+        ];
+
+        return deps.some((group) => Object.prototype.hasOwnProperty.call(group, '@zenithbuild/cli'));
+    } catch {
+        return false;
+    }
+}
+
+function hasZenithStructure(dir: string): boolean {
+    const srcDir = path.join(dir, 'src');
+    if (fs.existsSync(srcDir)) {
+        const hasPages = fs.existsSync(path.join(srcDir, 'pages'));
+        const hasLayouts = fs.existsSync(path.join(srcDir, 'layouts'));
+        if (hasPages || hasLayouts) {
+            return true;
+        }
+    }
+
+    const appDir = path.join(dir, 'app');
+    if (fs.existsSync(appDir)) {
+        const hasPages = fs.existsSync(path.join(appDir, 'pages'));
+        const hasLayouts = fs.existsSync(path.join(appDir, 'layouts'));
+        if (hasPages || hasLayouts) {
+            return true;
+        }
+    }
+
+    return false;
+}
+
+function findNearestByRule(startPath: string, predicate: (dir: string) => boolean): string | null {
+    let current = path.resolve(startPath);
+    if (!fs.existsSync(current)) {
+        current = path.dirname(current);
+    }
+
+    while (!fs.existsSync(current) && current !== path.dirname(current)) {
+        current = path.dirname(current);
+    }
+
+    if (!fs.existsSync(current)) {
+        return null;
+    }
+
+    if (!fs.statSync(current).isDirectory()) {
+        current = path.dirname(current);
+    }
+
+    while (current !== path.dirname(current)) {
+        if (predicate(current)) {
+            return current;
+        }
+        current = path.dirname(current);
+    }
+
+    if (predicate(current)) {
+        return current;
+    }
+
+    return null;
+}
+
+function findFallbackRoot(startPath: string): string | null {
+    return findNearestByRule(startPath, (dir) => {
+        if (fs.existsSync(path.join(dir, 'package.json'))) {
+            return true;
+        }
+        if (hasZenithStructure(dir)) {
+            return true;
+        }
+        return false;
+    });
+}
+
 /**
  * Detect Zenith project root
- * Looks for zenith.config.ts, src/, or app/
+ * Priority:
+ * 1) nearest zenith.config.*
+ * 2) nearest package.json with @zenithbuild/cli
+ * 3) nearest Zenith structure (src/pages|layouts or app/pages|layouts)
+ * 4) workspace folder fallbacks (if provided)
+ * 5) nearest package.json or Zenith structure
  */
-export function detectProjectRoot(startPath: string): string | null {
-    let current = startPath;
+export function detectProjectRoot(startPath: string, workspaceFolders: string[] = []): string | null {
+    const localConfigRoot = findNearestByRule(startPath, hasZenithConfig);
+    if (localConfigRoot) {
+        return localConfigRoot;
+    }
 
-    while (current !== path.dirname(current)) {
-        // Check for zenith.config.ts
-        if (fs.existsSync(path.join(current, 'zenith.config.ts'))) {
-            return current;
+    const localCliRoot = findNearestByRule(startPath, hasZenithCliDependency);
+    if (localCliRoot) {
+        return localCliRoot;
+    }
+
+    const localStructureRoot = findNearestByRule(startPath, hasZenithStructure);
+    if (localStructureRoot) {
+        return localStructureRoot;
+    }
+
+    const absoluteStart = path.resolve(startPath);
+    const matchingWorkspaceFolders = workspaceFolders
+        .map((workspacePath) => path.resolve(workspacePath))
+        .filter((workspacePath) => absoluteStart === workspacePath || absoluteStart.startsWith(`${workspacePath}${path.sep}`))
+        .sort((a, b) => b.length - a.length);
+
+    for (const workspaceRoot of matchingWorkspaceFolders) {
+        if (hasZenithConfig(workspaceRoot)) {
+            return workspaceRoot;
         }
-        // Check for src/ directory with Zenith files
-        const srcDir = path.join(current, 'src');
-        if (fs.existsSync(srcDir)) {
-            const hasPages = fs.existsSync(path.join(srcDir, 'pages'));
-            const hasLayouts = fs.existsSync(path.join(srcDir, 'layouts'));
-            if (hasPages || hasLayouts) {
-                return current;
-            }
+        if (hasZenithCliDependency(workspaceRoot)) {
+            return workspaceRoot;
         }
-        // Check for app/ directory
-        const appDir = path.join(current, 'app');
-        if (fs.existsSync(appDir)) {
-            const hasPages = fs.existsSync(path.join(appDir, 'pages'));
-            const hasLayouts = fs.existsSync(path.join(appDir, 'layouts'));
-            if (hasPages || hasLayouts) {
-                return current;
-            }
+        if (hasZenithStructure(workspaceRoot)) {
+            return workspaceRoot;
         }
-        current = path.dirname(current);
     }
 
-    return null;
+    return findFallbackRoot(startPath);
 }
 
 /**

package/src/server.ts

@@ -15,9 +15,12 @@ import {
     TextDocuments,
     ProposedFeatures,
     InitializeParams,
+    DidChangeConfigurationNotification,
     CompletionItem,
     CompletionItemKind,
     TextDocumentPositionParams,
+    CodeActionParams,
+    CodeAction,
     TextDocumentSyncKind,
     InitializeResult,
     Hover,
@@ -35,27 +38,27 @@ import {
     ProjectGraph
 } from './project';
 
-import { 
-    DIRECTIVES, 
-    isDirective, 
-    getDirective, 
+import {
+    DIRECTIVES,
+    isDirective,
+    getDirective,
     getDirectiveNames,
     canPlaceDirective,
-    parseForExpression 
+    parseForExpression
 } from './metadata/directive-metadata';
 
-import { 
-    parseZenithImports, 
-    hasRouterImport, 
-    resolveModule, 
+import {
+    parseZenithImports,
+    hasRouterImport,
+    resolveModule,
     resolveExport,
     getAllModules,
-    getModuleExports 
+    getModuleExports
 } from './imports';
 
-import { 
-    ROUTER_HOOKS, 
-    ZENLINK_PROPS, 
+import {
+    ROUTER_HOOKS,
+    ZENLINK_PROPS,
     ROUTE_FIELDS,
     getRouterHook,
     isRouterHook,
@@ -63,6 +66,8 @@ import {
 } from './router';
 
 import { collectDiagnostics } from './diagnostics';
+import { buildEventBindingCodeActions } from './code-actions';
+import { DEFAULT_SETTINGS, normalizeSettings, ZenithServerSettings } from './settings';
 
 // Create connection and document manager
 const connection = createConnection(ProposedFeatures.all);
@@ -70,6 +75,8 @@ const documents = new TextDocuments(TextDocument);
 
 // Project graph cache
 let projectGraphs: Map<string, ProjectGraph> = new Map();
+let workspaceFolders: string[] = [];
+let globalSettings: ZenithServerSettings = DEFAULT_SETTINGS;
 
 // Lifecycle hooks with documentation
 const LIFECYCLE_HOOKS = [
@@ -87,7 +94,7 @@ const HTML_ELEMENTS = [
     { tag: 'span', doc: 'Inline container element' },
     { tag: 'p', doc: 'Paragraph element' },
     { tag: 'a', doc: 'Anchor/link element', attrs: 'href="$1"' },
-    { tag: 'button', doc: 'Button element', attrs: 'onclick={$1}' },
+    { tag: 'button', doc: 'Button element', attrs: 'on:click={$1}' },
     { tag: 'input', doc: 'Input element', attrs: 'type="$1"', selfClosing: true },
     { tag: 'img', doc: 'Image element', attrs: 'src="$1" alt="$2"', selfClosing: true },
     { tag: 'h1', doc: 'Heading level 1' },
@@ -133,7 +140,7 @@ const HTML_ATTRIBUTES = [
     'placeholder', 'disabled', 'checked', 'readonly', 'required', 'hidden'
 ];
 
-// DOM events for @event and onclick handlers
+// DOM events for on:event handlers
 const DOM_EVENTS = [
     'click', 'change', 'input', 'submit', 'keydown', 'keyup', 'keypress',
     'focus', 'blur', 'mouseover', 'mouseout', 'mouseenter', 'mouseleave'
@@ -190,7 +197,7 @@ function extractLoopVariables(text: string): string[] {
     const vars: string[] = [];
     const loopPattern = /zen:for\s*=\s*["']([^"']+)["']/g;
     let match;
-    
+
     while ((match = loopPattern.exec(text)) !== null) {
         const parsed = parseForExpression(match[1]);
         if (parsed) {
@@ -198,7 +205,7 @@ function extractLoopVariables(text: string): string[] {
             if (parsed.indexVar) vars.push(parsed.indexVar);
         }
     }
-    
+
     return vars;
 }
 
@@ -257,7 +264,7 @@ function getPositionContext(text: string, offset: number): {
     // Get current word being typed
     const wordMatch = before.match(/[a-zA-Z_$:@][a-zA-Z0-9_$:-]*$/);
     const currentWord = wordMatch ? wordMatch[0] : '';
-    
+
     // Check for @ or : prefix for event/binding completion
     const afterAt = before.endsWith('@') || currentWord.startsWith('@');
     const afterColon = before.endsWith(':') || (currentWord.startsWith(':') && !currentWord.startsWith(':'));
@@ -268,7 +275,7 @@ function getPositionContext(text: string, offset: number): {
 // Get project graph for a document
 function getProjectGraph(docUri: string): ProjectGraph | null {
     const filePath = docUri.replace('file://', '');
-    const projectRoot = detectProjectRoot(path.dirname(filePath));
+    const projectRoot = detectProjectRoot(path.dirname(filePath), workspaceFolders);
 
     if (!projectRoot) {
         return null;
@@ -284,13 +291,19 @@ function getProjectGraph(docUri: string): ProjectGraph | null {
 // Invalidate project graph on file changes
 function invalidateProjectGraph(uri: string) {
     const filePath = uri.replace('file://', '');
-    const projectRoot = detectProjectRoot(path.dirname(filePath));
+    const projectRoot = detectProjectRoot(path.dirname(filePath), workspaceFolders);
     if (projectRoot) {
         projectGraphs.delete(projectRoot);
     }
 }
 
 connection.onInitialize((params: InitializeParams): InitializeResult => {
+    workspaceFolders = (params.workspaceFolders || [])
+        .map((folder) => folder.uri.replace('file://', ''));
+    if (workspaceFolders.length === 0 && params.rootUri) {
+        workspaceFolders = [params.rootUri.replace('file://', '')];
+    }
+
     return {
         capabilities: {
             textDocumentSync: TextDocumentSyncKind.Incremental,
@@ -298,11 +311,16 @@ connection.onInitialize((params: InitializeParams): InitializeResult => {
                 resolveProvider: true,
                 triggerCharacters: ['{', '<', '"', "'", '=', '.', ' ', ':', '(', '@']
             },
-            hoverProvider: true
+            hoverProvider: true,
+            codeActionProvider: true
         }
     };
 });
 
+connection.onInitialized(() => {
+    connection.client.register(DidChangeConfigurationNotification.type);
+});
+
 connection.onCompletion((params: TextDocumentPositionParams): CompletionItem[] => {
     const document = documents.get(params.textDocument.uri);
     if (!document) return [];
@@ -529,7 +547,7 @@ connection.onCompletion((params: TextDocumentPositionParams): CompletionItem[] =
     if (ctx.inTag && ctx.tagName && !ctx.inAttributeValue) {
         // Directives (zen:if, zen:for, etc.)
         const elementType = ctx.tagName === 'slot' ? 'slot' : (/^[A-Z]/.test(ctx.tagName) ? 'component' : 'element');
-        
+
         for (const directiveName of getDirectiveNames()) {
             if (canPlaceDirective(directiveName, elementType as 'element' | 'component' | 'slot')) {
                 if (!ctx.currentWord || directiveName.toLowerCase().startsWith(ctx.currentWord.toLowerCase())) {
@@ -549,17 +567,17 @@ connection.onCompletion((params: TextDocumentPositionParams): CompletionItem[] =
             }
         }
 
-        // @event completions
-        if (ctx.afterAt || ctx.currentWord.startsWith('@')) {
+        // on:event completions
+        if (!ctx.currentWord || ctx.currentWord.startsWith('on:') || ctx.currentWord === 'on') {
             for (const event of DOM_EVENTS) {
                 completions.push({
-                    label: `@${event}`,
+                    label: `on:${event}`,
                     kind: CompletionItemKind.Event,
                     detail: 'event binding',
                     documentation: `Bind to ${event} event`,
-                    insertText: `@${event}={$1}`,
+                    insertText: `on:${event}={$1}`,
                     insertTextFormat: InsertTextFormat.Snippet,
-                    sortText: `1_@${event}`
+                    sortText: `1_on:${event}`
                 });
             }
         }
@@ -613,22 +631,6 @@ connection.onCompletion((params: TextDocumentPositionParams): CompletionItem[] =
             }
         }
 
-        // Standard event handlers (onclick, onchange, etc.)
-        for (const event of DOM_EVENTS) {
-            const onEvent = `on${event}`;
-            if (!ctx.currentWord || onEvent.startsWith(ctx.currentWord.toLowerCase())) {
-                completions.push({
-                    label: onEvent,
-                    kind: CompletionItemKind.Event,
-                    detail: 'event handler',
-                    documentation: `Bind to ${event} event`,
-                    insertText: `${onEvent}={$1}`,
-                    insertTextFormat: InsertTextFormat.Snippet,
-                    sortText: `2_${onEvent}`
-                });
-            }
-        }
-
         // HTML attributes
         for (const attr of HTML_ATTRIBUTES) {
             if (!ctx.currentWord || attr.startsWith(ctx.currentWord.toLowerCase())) {
@@ -647,7 +649,7 @@ connection.onCompletion((params: TextDocumentPositionParams): CompletionItem[] =
     // === INSIDE ATTRIBUTE VALUE ===
     if (ctx.inAttributeValue) {
         // Event handler: offer functions
-        const eventMatch = lineBefore.match(/(?:on\w+|@\w+)=["'{][^"'{}]*$/);
+        const eventMatch = lineBefore.match(/on:[a-zA-Z][a-zA-Z0-9_-]*=["'{][^"'{}]*$/);
         if (eventMatch) {
             for (const func of functions) {
                 completions.push({
@@ -667,6 +669,15 @@ connection.onCompletionResolve((item: CompletionItem): CompletionItem => {
     return item;
 });
 
+connection.onCodeAction((params: CodeActionParams): CodeAction[] => {
+    const document = documents.get(params.textDocument.uri);
+    if (!document) {
+        return [];
+    }
+
+    return buildEventBindingCodeActions(document, params.context.diagnostics);
+});
+
 connection.onHover((params: TextDocumentPositionParams): Hover | null => {
     const document = documents.get(params.textDocument.uri);
     if (!document) return null;
@@ -693,7 +704,7 @@ connection.onHover((params: TextDocumentPositionParams): Hover | null => {
             } else {
                 notes = '- Compile-time directive\n- No runtime assumptions\n- Processed at build time';
             }
-            
+
             return {
                 contents: {
                     kind: MarkupKind.Markdown,
@@ -822,10 +833,21 @@ documents.onDidOpen(event => {
 
 async function validateDocument(document: TextDocument) {
     const graph = getProjectGraph(document.uri);
-    const diagnostics = collectDiagnostics(document, graph);
+    const filePath = document.uri.replace('file://', '');
+    const projectRoot = detectProjectRoot(path.dirname(filePath), workspaceFolders);
+    const diagnostics = await collectDiagnostics(document, graph, globalSettings, projectRoot);
     connection.sendDiagnostics({ uri: document.uri, diagnostics });
 }
 
+connection.onDidChangeConfiguration((change) => {
+    const config = (change.settings?.zenith ?? change.settings) as unknown;
+    globalSettings = normalizeSettings(config);
+
+    for (const doc of documents.all()) {
+        validateDocument(doc);
+    }
+});
+
 // Watch for file changes
 connection.onDidChangeWatchedFiles(params => {
     for (const change of params.changes) {

package/src/settings.ts

@@ -0,0 +1,15 @@
+export type ComponentScriptsMode = 'forbid' | 'allow';
+
+export interface ZenithServerSettings {
+    componentScripts: ComponentScriptsMode;
+}
+
+export const DEFAULT_SETTINGS: ZenithServerSettings = Object.freeze({
+    componentScripts: 'forbid'
+});
+
+export function normalizeSettings(input: unknown): ZenithServerSettings {
+    const maybe = (input || {}) as { componentScripts?: unknown };
+    const mode = maybe.componentScripts === 'allow' ? 'allow' : 'forbid';
+    return { componentScripts: mode };
+}

package/src/types/zenith-compiler.d.ts

@@ -0,0 +1,3 @@
+declare module '@zenithbuild/compiler' {
+  export function compile(source: string, filePath: string): Promise<unknown>;
+}

package/test/contracts.spec.ts

@@ -0,0 +1,37 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import path from 'node:path';
+
+import {
+    stripImportSuffix,
+    isCssContractImportSpecifier,
+    isLocalCssSpecifier,
+    resolveCssImportPath
+} from '../src/contracts';
+
+test('stripImportSuffix removes query/hash suffixes deterministically', () => {
+    assert.equal(stripImportSuffix('./styles/output.css?v=1#hash'), './styles/output.css');
+    assert.equal(stripImportSuffix('./styles/output.css#hash?v=1'), './styles/output.css');
+    assert.equal(stripImportSuffix('./styles/output.css'), './styles/output.css');
+});
+
+test('css contract identifies local and bare css import shapes', () => {
+    assert.equal(isCssContractImportSpecifier('./styles/output.css?v=1'), true);
+    assert.equal(isCssContractImportSpecifier('tailwindcss'), true);
+    assert.equal(isCssContractImportSpecifier('@scope/css'), true);
+    assert.equal(isLocalCssSpecifier('./styles/output.css'), true);
+    assert.equal(isLocalCssSpecifier('../styles/output.css#hash'), true);
+    assert.equal(isLocalCssSpecifier('/src/styles/output.css'), true);
+    assert.equal(isLocalCssSpecifier('tailwindcss'), false);
+});
+
+test('resolveCssImportPath flags project-root traversal escape', () => {
+    const projectRoot = path.join('/tmp', 'zenith-site');
+    const importer = path.join(projectRoot, 'src', 'pages', 'index.zen');
+
+    const ok = resolveCssImportPath(importer, '../styles/output.css?v=1#hash', projectRoot);
+    assert.equal(ok.escapesProjectRoot, false);
+
+    const escaped = resolveCssImportPath(importer, '../../../../outside.css', projectRoot);
+    assert.equal(escaped.escapesProjectRoot, true);
+});

package/test/diagnostics.spec.ts

@@ -0,0 +1,101 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import { collectContractDiagnostics, CONTRACT_MESSAGES } from '../src/diagnostics';
+import { buildEventBindingCodeActions } from '../src/code-actions';
+import { DEFAULT_SETTINGS } from '../src/settings';
+
+const PROJECT_ROOT = '/tmp/zenith-site';
+
+function doc(uri: string, content: string) {
+    return {
+        uri,
+        getText() {
+            return content;
+        },
+        positionAt(offset: number) {
+            const bounded = Math.max(0, Math.min(offset, content.length));
+            const before = content.slice(0, bounded);
+            const lines = before.split('\n');
+            return {
+                line: lines.length - 1,
+                character: lines[lines.length - 1]?.length || 0
+            };
+        }
+    };
+}
+
+test('component script contract is enforced for components when mode=forbid', () => {
+    const document = doc(
+        'file:///tmp/zenith-site/src/components/Hero.zen',
+        '<section><script>const x = 1;</script><h1>Hero</h1></section>'
+    );
+
+    const diagnostics = collectContractDiagnostics(document, null, DEFAULT_SETTINGS, PROJECT_ROOT);
+    const messageSet = diagnostics.map((item) => item.message);
+    assert.ok(messageSet.includes(CONTRACT_MESSAGES.componentScript));
+});
+
+test('component script contract allows scripts when mode=allow', () => {
+    const document = doc(
+        'file:///tmp/zenith-site/src/components/Hero.zen',
+        '<section><script>const x = 1;</script><h1>Hero</h1></section>'
+    );
+
+    const diagnostics = collectContractDiagnostics(document, null, { componentScripts: 'allow' }, PROJECT_ROOT);
+    const messageSet = diagnostics.map((item) => item.message);
+    assert.ok(!messageSet.includes(CONTRACT_MESSAGES.componentScript));
+});
+
+test('route scripts are allowed by component script contract', () => {
+    const document = doc(
+        'file:///tmp/zenith-site/src/pages/index.zen',
+        '<RootLayout><script>const x = 1;</script><h1>Home</h1></RootLayout>'
+    );
+
+    const diagnostics = collectContractDiagnostics(document, null, DEFAULT_SETTINGS, PROJECT_ROOT);
+    const messageSet = diagnostics.map((item) => item.message);
+    assert.ok(!messageSet.includes(CONTRACT_MESSAGES.componentScript));
+});
+
+test('event binding diagnostics flag onclick and @click and provide quick fixes', () => {
+    const document = doc(
+        'file:///tmp/zenith-site/src/pages/index.zen',
+        '<button onclick="submitForm">Save</button><button @click={submitForm}>Save</button>'
+    );
+
+    const diagnostics = collectContractDiagnostics(document, null, DEFAULT_SETTINGS, PROJECT_ROOT)
+        .filter((item) => String(item.code || '') === 'zenith.event.binding.syntax');
+
+    assert.equal(diagnostics.length, 2);
+    assert.equal(diagnostics[0]?.data?.replacement, 'on:click={submitForm}');
+    assert.equal(diagnostics[1]?.data?.replacement, 'on:click={submitForm}');
+
+    const actions = buildEventBindingCodeActions(document, diagnostics);
+    assert.equal(actions.length, 2);
+    assert.equal(actions[0]?.title, 'Convert to on:click={submitForm}');
+});
+
+test('css import contract flags bare imports and path escapes', () => {
+    const document = doc(
+        'file:///tmp/zenith-site/src/pages/index.zen',
+        '<RootLayout><script>import \"tailwindcss\"; import \"../../../../outside.css\";</script></RootLayout>'
+    );
+
+    const diagnostics = collectContractDiagnostics(document, null, DEFAULT_SETTINGS, PROJECT_ROOT);
+    const messages = diagnostics.map((item) => item.message);
+    assert.ok(messages.includes(CONTRACT_MESSAGES.cssBareImport));
+    assert.ok(messages.includes(CONTRACT_MESSAGES.cssEscape));
+});
+
+test('css import contract allows local precompiled css with suffixes', () => {
+    const document = doc(
+        'file:///tmp/zenith-site/src/pages/index.zen',
+        '<RootLayout><script>import \"../styles/output.css?v=1#hash\";</script></RootLayout>'
+    );
+
+    const diagnostics = collectContractDiagnostics(document, null, DEFAULT_SETTINGS, PROJECT_ROOT);
+    const messages = diagnostics.map((item) => item.message);
+    assert.ok(!messages.includes(CONTRACT_MESSAGES.cssBareImport));
+    assert.ok(!messages.includes(CONTRACT_MESSAGES.cssEscape));
+});

package/test/project-root.spec.ts

@@ -0,0 +1,44 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+import { detectProjectRoot } from '../src/project';
+
+function createTempDir(prefix: string): string {
+    return fs.mkdtempSync(path.join(os.tmpdir(), prefix));
+}
+
+test('detectProjectRoot prefers nearest zenith.config.*', () => {
+    const root = createTempDir('zenith-lsp-root-');
+    const nested = path.join(root, 'apps', 'site', 'src', 'pages');
+    fs.mkdirSync(nested, { recursive: true });
+    fs.writeFileSync(path.join(root, 'zenith.config.ts'), 'export default {}\n');
+
+    const detected = detectProjectRoot(path.join(nested, 'index.zen'));
+    assert.equal(detected, root);
+});
+
+test('detectProjectRoot prefers nearest package.json with @zenithbuild/cli', () => {
+    const root = createTempDir('zenith-lsp-pkg-');
+    const nested = path.join(root, 'src', 'components');
+    fs.mkdirSync(nested, { recursive: true });
+    fs.writeFileSync(
+        path.join(root, 'package.json'),
+        JSON.stringify({ dependencies: { '@zenithbuild/cli': '^1.0.0' } }, null, 2)
+    );
+
+    const detected = detectProjectRoot(path.join(nested, 'Hero.zen'));
+    assert.equal(detected, root);
+});
+
+test('detectProjectRoot falls back to matching workspace folder structure', () => {
+    const workspace = createTempDir('zenith-lsp-workspace-');
+    const siteRoot = path.join(workspace, 'site-a');
+    const nested = path.join(siteRoot, 'src', 'pages', 'blog');
+    fs.mkdirSync(nested, { recursive: true });
+
+    const detected = detectProjectRoot(path.join(nested, 'first-post.zen'), [workspace, siteRoot]);
+    assert.equal(detected, siteRoot);
+});

package/tsconfig.test.json

@@ -0,0 +1,25 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "./.test-dist",
+    "rootDir": ".",
+    "declaration": false,
+    "sourceMap": false
+  },
+  "include": [
+    "src/contracts.ts",
+    "src/project.ts",
+    "src/settings.ts",
+    "src/diagnostics.ts",
+    "src/code-actions.ts",
+    "src/imports.ts",
+    "src/metadata/**/*.ts",
+    "src/**/*.d.ts",
+    "test/**/*.ts"
+  ],
+  "exclude": [
+    "node_modules",
+    "dist",
+    ".test-dist"
+  ]
+}