@zenithbuild/language-server 0.6.0 → 0.6.17

package/src/imports.ts

@@ -1,207 +0,0 @@
-/**
- * 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

@@ -1,163 +0,0 @@
-/**
- * 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;
-}

package/src/metadata/directive-metadata.ts

@@ -1,109 +0,0 @@
-/**
- * Directive Metadata
- * 
- * Compile-time directive definitions for Zenith.
- * These are compiler directives, not runtime attributes.
- */
-
-export interface DirectiveMetadata {
-    name: string;
-    category: 'control-flow' | 'iteration' | 'reactive-effect' | 'conditional-visibility';
-    description: string;
-    syntax: string;
-    placement: ('element' | 'component')[];
-    example: string;
-    createsScope?: boolean;
-    scopeVariables?: string[];
-}
-
-/**
- * All Zenith compiler directives
- * 
- * These are processed at compile-time and transformed into static DOM instructions.
- * The LSP must describe these directives without assuming runtime behavior.
- */
-export const DIRECTIVES: Record<string, DirectiveMetadata> = {
-    'zen:if': {
-        name: 'zen:if',
-        category: 'control-flow',
-        description: 'Compile-time conditional directive. Conditionally renders the element based on a boolean expression.',
-        syntax: 'zen:if="condition"',
-        placement: ['element', 'component'],
-        example: '<div zen:if="isVisible">Conditionally rendered</div>'
-    },
-    'zen:for': {
-        name: 'zen:for',
-        category: 'iteration',
-        description: 'Compile-time iteration directive. Repeats the element for each item in a collection.',
-        syntax: 'zen:for="item in items" or zen:for="item, index in items"',
-        placement: ['element', 'component'],
-        example: '<li zen:for="item in items">{item.name}</li>',
-        createsScope: true,
-        scopeVariables: ['item', 'index']
-    },
-    'zen:effect': {
-        name: 'zen:effect',
-        category: 'reactive-effect',
-        description: 'Compile-time reactive effect directive. Attaches a side effect to the element lifecycle.',
-        syntax: 'zen:effect="expression"',
-        placement: ['element', 'component'],
-        example: '<div zen:effect="console.log(\'rendered\')">Content</div>'
-    },
-    'zen:show': {
-        name: 'zen:show',
-        category: 'conditional-visibility',
-        description: 'Compile-time visibility directive. Toggles element visibility without removing from DOM.',
-        syntax: 'zen:show="condition"',
-        placement: ['element', 'component'],
-        example: '<div zen:show="isOpen">Toggle visibility</div>'
-    }
-};
-
-/**
- * Check if a string is a valid directive name
- */
-export function isDirective(name: string): name is keyof typeof DIRECTIVES {
-    return name in DIRECTIVES;
-}
-
-/**
- * Get directive metadata by name
- */
-export function getDirective(name: string): DirectiveMetadata | undefined {
-    return DIRECTIVES[name];
-}
-
-/**
- * Get all directive names
- */
-export function getDirectiveNames(): string[] {
-    return Object.keys(DIRECTIVES);
-}
-
-/**
- * Check if a directive can be placed on a specific element type
- */
-export function canPlaceDirective(directiveName: string, elementType: 'element' | 'component' | 'slot'): boolean {
-    const directive = DIRECTIVES[directiveName];
-    if (!directive) return false;
-    
-    // Directives cannot be placed on <slot>
-    if (elementType === 'slot') return false;
-    
-    return directive.placement.includes(elementType as 'element' | 'component');
-}
-
-/**
- * Parse a zen:for expression to extract variables
- */
-export function parseForExpression(expression: string): { itemVar: string; indexVar?: string; source: string } | null {
-    // Match: "item in items" or "item, index in items"
-    const match = expression.match(/^\s*([a-zA-Z_$][\w$]*)(?:\s*,\s*([a-zA-Z_$][\w$]*))?\s+in\s+(.+)\s*$/);
-    if (!match) return null;
-    
-    return {
-        itemVar: match[1],
-        indexVar: match[2],
-        source: match[3].trim()
-    };
-}

package/src/metadata/plugin-imports.ts

@@ -1,116 +0,0 @@
-/**
- * Plugin Import Metadata
- * 
- * Static metadata for Zenith plugin modules.
- * Plugin modules use the zenith:* namespace.
- * 
- * Important: The LSP must NOT assume plugin presence.
- * If a plugin is not installed, diagnostics should be soft warnings, not errors.
- */
-
-export interface PluginExport {
-    name: string;
-    kind: 'function' | 'type' | 'variable';
-    description: string;
-    signature?: string;
-}
-
-export interface PluginModuleMetadata {
-    module: string;
-    description: string;
-    exports: PluginExport[];
-    required: boolean;
-}
-
-/**
- * Known Zenith plugin modules
- */
-export const PLUGIN_MODULES: Record<string, PluginModuleMetadata> = {
-    'zenith:content': {
-        module: 'zenith:content',
-        description: 'Content collections plugin for Zenith. Provides type-safe content management for Markdown, MDX, and JSON files.',
-        exports: [
-            {
-                name: 'zenCollection',
-                kind: 'function',
-                description: 'Define a content collection with schema validation.',
-                signature: 'zenCollection<T>(options: { name: string; schema: T }): Collection<T>'
-            },
-            {
-                name: 'getCollection',
-                kind: 'function',
-                description: 'Get all entries from a content collection.',
-                signature: 'getCollection(name: string): Promise<CollectionEntry[]>'
-            },
-            {
-                name: 'getEntry',
-                kind: 'function',
-                description: 'Get a single entry from a content collection.',
-                signature: 'getEntry(collection: string, slug: string): Promise<CollectionEntry | undefined>'
-            },
-            {
-                name: 'useZenOrder',
-                kind: 'function',
-                description: 'Hook to sort collection entries by frontmatter order field.',
-                signature: 'useZenOrder(entries: CollectionEntry[]): CollectionEntry[]'
-            }
-        ],
-        required: false
-    },
-    'zenith:image': {
-        module: 'zenith:image',
-        description: 'Image optimization plugin for Zenith.',
-        exports: [
-            {
-                name: 'Image',
-                kind: 'function',
-                description: 'Optimized image component with automatic format conversion and lazy loading.',
-                signature: 'Image({ src: string; alt: string; width?: number; height?: number })'
-            },
-            {
-                name: 'getImage',
-                kind: 'function',
-                description: 'Get optimized image metadata.',
-                signature: 'getImage(src: string, options?: ImageOptions): Promise<ImageMetadata>'
-            }
-        ],
-        required: false
-    }
-};
-
-/**
- * Get a plugin module by name
- */
-export function getPluginModule(moduleName: string): PluginModuleMetadata | undefined {
-    return PLUGIN_MODULES[moduleName];
-}
-
-/**
- * Get all plugin module names
- */
-export function getPluginModuleNames(): string[] {
-    return Object.keys(PLUGIN_MODULES);
-}
-
-/**
- * Get an export from a plugin module
- */
-export function getPluginExport(moduleName: string, exportName: string): PluginExport | undefined {
-    const module = PLUGIN_MODULES[moduleName];
-    if (!module) return undefined;
-    return module.exports.find(e => e.name === exportName);
-}
-
-/**
- * Check if a module is a plugin module (zenith:* namespace)
- */
-export function isPluginModule(moduleName: string): boolean {
-    return moduleName.startsWith('zenith:');
-}
-
-/**
- * Check if a plugin module is known
- */
-export function isKnownPluginModule(moduleName: string): boolean {
-    return moduleName in PLUGIN_MODULES;
-}