@zenithbuild/language-server 0.2.2

package/src/diagnostics.ts

@@ -0,0 +1,260 @@
+/**
+ * Diagnostics
+ * 
+ * Compile-time validation mirroring the Zenith compiler.
+ * The LSP must surface compiler-level errors early.
+ * 
+ * Important: No runtime execution. Pure static analysis only.
+ */
+
+import { Diagnostic, DiagnosticSeverity } from 'vscode-languageserver/node';
+import { TextDocument } from 'vscode-languageserver-textdocument';
+import { isDirective, parseForExpression } from './metadata/directive-metadata';
+import { parseZenithImports, resolveModule, isPluginModule } from './imports';
+import type { ProjectGraph } from './project';
+
+export interface ValidationContext {
+    document: TextDocument;
+    text: string;
+    graph: ProjectGraph | null;
+}
+
+/**
+ * Collect all diagnostics for a document
+ */
+export function collectDiagnostics(document: TextDocument, graph: ProjectGraph | null): Diagnostic[] {
+    const diagnostics: Diagnostic[] = [];
+    const text = document.getText();
+
+    // Validate component references
+    collectComponentDiagnostics(document, text, graph, diagnostics);
+
+    // Validate directive usage
+    collectDirectiveDiagnostics(document, text, diagnostics);
+
+    // Validate imports
+    collectImportDiagnostics(document, text, diagnostics);
+
+    // Validate expressions
+    collectExpressionDiagnostics(document, text, diagnostics);
+
+    return diagnostics;
+}
+
+/**
+ * Validate component references
+ */
+function collectComponentDiagnostics(
+    document: TextDocument,
+    text: string,
+    graph: ProjectGraph | null,
+    diagnostics: Diagnostic[]
+): void {
+    if (!graph) return;
+
+    // Strip script and style blocks to avoid matching PascalCase names in TS generics
+    // We use a simplified version that preserves indices by replacing content with spaces
+    const strippedText = text
+        .replace(/<(script|style)[^>]*>([\s\S]*?)<\/\1>/gi, (match, tag, content) => {
+            return match.replace(content, ' '.repeat(content.length));
+        });
+
+    // Match component tags (PascalCase)
+    const componentPattern = /<([A-Z][a-zA-Z0-9]*)(?=[\s/>])/g;
+    let match;
+
+    while ((match = componentPattern.exec(strippedText)) !== null) {
+        const componentName = match[1];
+
+        // Skip known router components
+        if (componentName === 'ZenLink') continue;
+
+        // Check if component exists in project graph
+        const inLayouts = graph.layouts.has(componentName);
+        const inComponents = graph.components.has(componentName);
+
+        if (!inLayouts && !inComponents) {
+            const startPos = document.positionAt(match.index + 1);
+            const endPos = document.positionAt(match.index + 1 + componentName.length);
+
+            diagnostics.push({
+                severity: DiagnosticSeverity.Warning,
+                range: { start: startPos, end: endPos },
+                message: `Unknown component: '<${componentName}>'. Ensure it exists in src/layouts/ or src/components/`,
+                source: 'zenith'
+            });
+        }
+    }
+}
+
+/**
+ * Validate directive usage
+ */
+function collectDirectiveDiagnostics(
+    document: TextDocument,
+    text: string,
+    diagnostics: Diagnostic[]
+): void {
+    // Match zen:* directives
+    const directivePattern = /(zen:(?:if|for|effect|show))\s*=\s*["']([^"']*)["']/g;
+    let match;
+
+    while ((match = directivePattern.exec(text)) !== null) {
+        const directiveName = match[1];
+        const directiveValue = match[2];
+
+        // Validate zen:for syntax
+        if (directiveName === 'zen:for') {
+            const parsed = parseForExpression(directiveValue);
+            if (!parsed) {
+                const startPos = document.positionAt(match.index);
+                const endPos = document.positionAt(match.index + match[0].length);
+
+                diagnostics.push({
+                    severity: DiagnosticSeverity.Error,
+                    range: { start: startPos, end: endPos },
+                    message: `Invalid zen:for syntax. Expected: "item in items" or "item, index in items"`,
+                    source: 'zenith'
+                });
+            }
+        }
+
+        // Check for empty directive values
+        if (!directiveValue.trim()) {
+            const startPos = document.positionAt(match.index);
+            const endPos = document.positionAt(match.index + match[0].length);
+
+            diagnostics.push({
+                severity: DiagnosticSeverity.Error,
+                range: { start: startPos, end: endPos },
+                message: `${directiveName} requires a value`,
+                source: 'zenith'
+            });
+        }
+    }
+
+    // Check for zen:for on slot elements (forbidden)
+    const slotForPattern = /<slot[^>]*zen:for/g;
+    while ((match = slotForPattern.exec(text)) !== null) {
+        const startPos = document.positionAt(match.index);
+        const endPos = document.positionAt(match.index + match[0].length);
+
+        diagnostics.push({
+            severity: DiagnosticSeverity.Error,
+            range: { start: startPos, end: endPos },
+            message: `zen:for cannot be used on <slot> elements`,
+            source: 'zenith'
+        });
+    }
+}
+
+/**
+ * Validate imports
+ */
+function collectImportDiagnostics(
+    document: TextDocument,
+    text: string,
+    diagnostics: Diagnostic[]
+): void {
+    // Extract script content
+    const scriptMatch = text.match(/<script[^>]*>([\s\S]*?)<\/script>/i);
+    if (!scriptMatch) return;
+
+    const scriptContent = scriptMatch[1];
+    const scriptStart = scriptMatch.index! + scriptMatch[0].indexOf(scriptContent);
+
+    const imports = parseZenithImports(scriptContent);
+
+    for (const imp of imports) {
+        const resolved = resolveModule(imp.module);
+
+        // Warn about unknown plugin modules (soft diagnostic)
+        if (isPluginModule(imp.module) && !resolved.isKnown) {
+            // Find the import line in the document
+            const importPattern = new RegExp(`import[^'"]*['"]${imp.module.replace(':', '\\:')}['"]`);
+            const importMatch = scriptContent.match(importPattern);
+
+            if (importMatch) {
+                const importOffset = scriptStart + (importMatch.index || 0);
+                const startPos = document.positionAt(importOffset);
+                const endPos = document.positionAt(importOffset + importMatch[0].length);
+
+                diagnostics.push({
+                    severity: DiagnosticSeverity.Information,
+                    range: { start: startPos, end: endPos },
+                    message: `Unknown plugin module: '${imp.module}'. Make sure the plugin is installed.`,
+                    source: 'zenith'
+                });
+            }
+        }
+
+        // Check for invalid specifiers in known modules
+        if (resolved.isKnown && resolved.metadata) {
+            const validExports = resolved.metadata.exports.map(e => e.name);
+
+            for (const specifier of imp.specifiers) {
+                if (!validExports.includes(specifier)) {
+                    const specPattern = new RegExp(`\\b${specifier}\\b`);
+                    const specMatch = scriptContent.match(specPattern);
+
+                    if (specMatch) {
+                        const specOffset = scriptStart + (specMatch.index || 0);
+                        const startPos = document.positionAt(specOffset);
+                        const endPos = document.positionAt(specOffset + specifier.length);
+
+                        diagnostics.push({
+                            severity: DiagnosticSeverity.Warning,
+                            range: { start: startPos, end: endPos },
+                            message: `'${specifier}' is not exported from '${imp.module}'`,
+                            source: 'zenith'
+                        });
+                    }
+                }
+            }
+        }
+    }
+}
+
+/**
+ * Validate expressions for dangerous patterns
+ */
+function collectExpressionDiagnostics(
+    document: TextDocument,
+    text: string,
+    diagnostics: Diagnostic[]
+): void {
+    // Match expressions in templates
+    const expressionPattern = /\{([^}]+)\}/g;
+    let match;
+
+    while ((match = expressionPattern.exec(text)) !== null) {
+        const expression = match[1];
+        const offset = match.index;
+
+        // Check for dangerous patterns
+        if (expression.includes('eval(') || expression.includes('Function(')) {
+            const startPos = document.positionAt(offset);
+            const endPos = document.positionAt(offset + match[0].length);
+
+            diagnostics.push({
+                severity: DiagnosticSeverity.Error,
+                range: { start: startPos, end: endPos },
+                message: `Dangerous pattern detected: eval() and Function() are not allowed in expressions`,
+                source: 'zenith'
+            });
+        }
+
+        // Check for with statement
+        if (/\bwith\s*\(/.test(expression)) {
+            const startPos = document.positionAt(offset);
+            const endPos = document.positionAt(offset + match[0].length);
+
+            diagnostics.push({
+                severity: DiagnosticSeverity.Error,
+                range: { start: startPos, end: endPos },
+                message: `'with' statement is not allowed in expressions`,
+                source: 'zenith'
+            });
+        }
+    }
+}

package/src/imports.ts

@@ -0,0 +1,207 @@
+/**
+ * Import Resolution & Awareness
+ * 
+ * Handles recognition and resolution of Zenith imports.
+ * - zenith/* imports are core modules (virtual, symbolic resolution)
+ * - zenith:* imports are plugin modules (soft diagnostics if missing)
+ */
+
+import { 
+    CORE_MODULES, 
+    getCoreModule, 
+    getCoreExport, 
+    isCoreModule,
+    type CoreModuleMetadata,
+    type ModuleExport 
+} from './metadata/core-imports';
+
+import { 
+    PLUGIN_MODULES, 
+    getPluginModule, 
+    getPluginExport, 
+    isPluginModule, 
+    isKnownPluginModule,
+    type PluginModuleMetadata,
+    type PluginExport 
+} from './metadata/plugin-imports';
+
+export interface ParsedImport {
+    module: string;
+    specifiers: string[];
+    isType: boolean;
+    line: number;
+}
+
+export interface ResolvedImport {
+    module: string;
+    kind: 'core' | 'plugin' | 'external';
+    metadata?: CoreModuleMetadata | PluginModuleMetadata;
+    isKnown: boolean;
+}
+
+/**
+ * Parse Zenith imports from script content
+ */
+export function parseZenithImports(script: string): ParsedImport[] {
+    const imports: ParsedImport[] = [];
+    const lines = script.split('\n');
+    
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        
+        // Match: import { x, y } from 'module' or import type { x } from 'module'
+        const importMatch = line.match(/import\s+(type\s+)?(?:\{([^}]+)\}|(\*\s+as\s+\w+)|(\w+))\s+from\s+['"]([^'"]+)['"]/);
+        
+        if (importMatch) {
+            const isType = !!importMatch[1];
+            const namedImports = importMatch[2];
+            const namespaceImport = importMatch[3];
+            const defaultImport = importMatch[4];
+            const moduleName = importMatch[5];
+            
+            // Only track zenith imports
+            if (moduleName.startsWith('zenith') || moduleName.startsWith('zenith:')) {
+                const specifiers: string[] = [];
+                
+                if (namedImports) {
+                    // Parse named imports: { a, b as c, d }
+                    const parts = namedImports.split(',');
+                    for (const part of parts) {
+                        const cleaned = part.trim().split(/\s+as\s+/)[0].trim();
+                        if (cleaned) specifiers.push(cleaned);
+                    }
+                } else if (namespaceImport) {
+                    specifiers.push(namespaceImport.trim());
+                } else if (defaultImport) {
+                    specifiers.push(defaultImport);
+                }
+                
+                imports.push({
+                    module: moduleName,
+                    specifiers,
+                    isType,
+                    line: i + 1
+                });
+            }
+        }
+        
+        // Match: import 'module' (side-effect import)
+        const sideEffectMatch = line.match(/import\s+['"]([^'"]+)['"]/);
+        if (sideEffectMatch && !importMatch) {
+            const moduleName = sideEffectMatch[1];
+            if (moduleName.startsWith('zenith') || moduleName.startsWith('zenith:')) {
+                imports.push({
+                    module: moduleName,
+                    specifiers: [],
+                    isType: false,
+                    line: i + 1
+                });
+            }
+        }
+    }
+    
+    return imports;
+}
+
+/**
+ * Resolve a module name to its metadata
+ */
+export function resolveModule(moduleName: string): ResolvedImport {
+    if (isCoreModule(moduleName)) {
+        return {
+            module: moduleName,
+            kind: 'core',
+            metadata: getCoreModule(moduleName),
+            isKnown: true
+        };
+    }
+    
+    if (isPluginModule(moduleName)) {
+        return {
+            module: moduleName,
+            kind: 'plugin',
+            metadata: getPluginModule(moduleName),
+            isKnown: isKnownPluginModule(moduleName)
+        };
+    }
+    
+    return {
+        module: moduleName,
+        kind: 'external',
+        isKnown: false
+    };
+}
+
+/**
+ * Get export metadata for a specific import
+ */
+export function resolveExport(moduleName: string, exportName: string): ModuleExport | PluginExport | undefined {
+    if (isCoreModule(moduleName)) {
+        return getCoreExport(moduleName, exportName);
+    }
+    
+    if (isKnownPluginModule(moduleName)) {
+        return getPluginExport(moduleName, exportName);
+    }
+    
+    return undefined;
+}
+
+/**
+ * Check if router is imported in the given imports
+ */
+export function hasRouterImport(imports: ParsedImport[]): boolean {
+    return imports.some(i => i.module === 'zenith/router');
+}
+
+/**
+ * Check if a specific export is imported
+ */
+export function hasImport(imports: ParsedImport[], exportName: string): boolean {
+    return imports.some(i => i.specifiers.includes(exportName));
+}
+
+/**
+ * Get all available modules for completion
+ */
+export function getAllModules(): Array<{ module: string; kind: 'core' | 'plugin'; description: string }> {
+    const modules: Array<{ module: string; kind: 'core' | 'plugin'; description: string }> = [];
+    
+    for (const [name, meta] of Object.entries(CORE_MODULES)) {
+        modules.push({
+            module: name,
+            kind: 'core',
+            description: meta.description
+        });
+    }
+    
+    for (const [name, meta] of Object.entries(PLUGIN_MODULES)) {
+        modules.push({
+            module: name,
+            kind: 'plugin',
+            description: meta.description
+        });
+    }
+    
+    return modules;
+}
+
+/**
+ * Get exports for completion from a module
+ */
+export function getModuleExports(moduleName: string): Array<ModuleExport | PluginExport> {
+    const coreModule = getCoreModule(moduleName);
+    if (coreModule) return coreModule.exports;
+    
+    const pluginModule = getPluginModule(moduleName);
+    if (pluginModule) return pluginModule.exports;
+    
+    return [];
+}
+
+// Re-export utilities
+export { isPluginModule } from './metadata/plugin-imports';
+
+// Re-export types
+export type { CoreModuleMetadata, ModuleExport } from './metadata/core-imports';
+export type { PluginModuleMetadata, PluginExport } from './metadata/plugin-imports';

package/src/metadata/core-imports.ts

@@ -0,0 +1,163 @@
+/**
+ * Core Import Metadata
+ * 
+ * Static metadata for Zenith core modules.
+ * These are virtual modules resolved symbolically (no FS probing).
+ */
+
+export interface ModuleExport {
+    name: string;
+    kind: 'function' | 'component' | 'type' | 'variable';
+    description: string;
+    signature?: string;
+}
+
+export interface CoreModuleMetadata {
+    module: string;
+    description: string;
+    exports: ModuleExport[];
+}
+
+/**
+ * Core Zenith module exports
+ */
+export const CORE_MODULES: Record<string, CoreModuleMetadata> = {
+    'zenith': {
+        module: 'zenith',
+        description: 'Core Zenith runtime primitives and lifecycle hooks.',
+        exports: [
+            {
+                name: 'zenEffect',
+                kind: 'function',
+                description: 'Reactive effect that re-runs when dependencies change.',
+                signature: 'zenEffect(callback: () => void | (() => void)): void'
+            },
+            {
+                name: 'zenOnMount',
+                kind: 'function',
+                description: 'Called when component is mounted to the DOM.',
+                signature: 'zenOnMount(callback: () => void | (() => void)): void'
+            },
+            {
+                name: 'zenOnDestroy',
+                kind: 'function',
+                description: 'Called when component is removed from the DOM.',
+                signature: 'zenOnDestroy(callback: () => void): void'
+            },
+            {
+                name: 'zenOnUpdate',
+                kind: 'function',
+                description: 'Called after any state update causes a re-render.',
+                signature: 'zenOnUpdate(callback: () => void): void'
+            },
+            {
+                name: 'zenRef',
+                kind: 'function',
+                description: 'Create a reactive reference.',
+                signature: 'zenRef<T>(initial: T): { value: T }'
+            },
+            {
+                name: 'zenState',
+                kind: 'function',
+                description: 'Create reactive state.',
+                signature: 'zenState<T>(initial: T): [T, (value: T) => void]'
+            },
+            {
+                name: 'zenMemo',
+                kind: 'function',
+                description: 'Memoize a computed value.',
+                signature: 'zenMemo<T>(compute: () => T): T'
+            },
+            {
+                name: 'zenBatch',
+                kind: 'function',
+                description: 'Batch multiple state updates.',
+                signature: 'zenBatch(callback: () => void): void'
+            },
+            {
+                name: 'zenUntrack',
+                kind: 'function',
+                description: 'Run code without tracking dependencies.',
+                signature: 'zenUntrack<T>(callback: () => T): T'
+            }
+        ]
+    },
+    'zenith/router': {
+        module: 'zenith/router',
+        description: 'File-based SPA router for Zenith framework.',
+        exports: [
+            {
+                name: 'ZenLink',
+                kind: 'component',
+                description: 'Declarative navigation component for routes.',
+                signature: '<ZenLink to="/path" preload?>{children}</ZenLink>'
+            },
+            {
+                name: 'useRoute',
+                kind: 'function',
+                description: 'Provides reactive access to the current route. Must be called at top-level script scope.',
+                signature: 'useRoute(): { path: string; params: Record<string, string>; query: Record<string, string> }'
+            },
+            {
+                name: 'useRouter',
+                kind: 'function',
+                description: 'Provides programmatic navigation methods.',
+                signature: 'useRouter(): { navigate: (to: string, options?: { replace?: boolean }) => void; back: () => void; forward: () => void }'
+            },
+            {
+                name: 'navigate',
+                kind: 'function',
+                description: 'Navigate to a route programmatically.',
+                signature: 'navigate(to: string, options?: { replace?: boolean }): void'
+            },
+            {
+                name: 'prefetch',
+                kind: 'function',
+                description: 'Prefetch a route for faster navigation.',
+                signature: 'prefetch(path: string): Promise<void>'
+            },
+            {
+                name: 'isActive',
+                kind: 'function',
+                description: 'Check if a route is currently active.',
+                signature: 'isActive(path: string, exact?: boolean): boolean'
+            },
+            {
+                name: 'getRoute',
+                kind: 'function',
+                description: 'Get the current route state.',
+                signature: 'getRoute(): { path: string; params: Record<string, string>; query: Record<string, string> }'
+            }
+        ]
+    }
+};
+
+/**
+ * Get a core module by name
+ */
+export function getCoreModule(moduleName: string): CoreModuleMetadata | undefined {
+    return CORE_MODULES[moduleName];
+}
+
+/**
+ * Get all core module names
+ */
+export function getCoreModuleNames(): string[] {
+    return Object.keys(CORE_MODULES);
+}
+
+/**
+ * Get an export from a core module
+ */
+export function getCoreExport(moduleName: string, exportName: string): ModuleExport | undefined {
+    const module = CORE_MODULES[moduleName];
+    if (!module) return undefined;
+    return module.exports.find(e => e.name === exportName);
+}
+
+/**
+ * Check if a module is a core Zenith module
+ */
+export function isCoreModule(moduleName: string): boolean {
+    return moduleName in CORE_MODULES;
+}