@domainlang/language 0.1.20 → 0.1.82

package/src/lsp/domain-lang-workspace-manager.ts

@@ -1,104 +0,0 @@
-import path from 'node:path';
-import YAML from 'yaml';
-import { DefaultWorkspaceManager, URI, UriUtils, type FileSystemNode, type LangiumDocument, type LangiumSharedCoreServices, type WorkspaceFolder } from 'langium';
-import type { CancellationToken } from 'vscode-languageserver-protocol';
-import { ensureImportGraphFromDocument } from '../utils/import-utils.js';
-
-/**
- * Langium WorkspaceManager override implementing manifest-centric import loading per PRS-010.
- *
- * Behavior:
- * - Skips pre-loading *.dlang during workspace scan (only entry graph is loaded when manifest exists).
- * - Mode A (with manifest): find nearest model.yaml in folder, load entry (default index.dlang) and its import graph.
- * - Mode B (no manifest): no pre-loading; imports resolved on-demand when a document is opened.
- * - Never performs network fetches; relies on cached dependencies/lock files. Missing cache produces diagnostics upstream.
- */
-export class DomainLangWorkspaceManager extends DefaultWorkspaceManager {
-    constructor(services: LangiumSharedCoreServices) {
-        super(services);
-    }
-
-    override shouldIncludeEntry(entry: FileSystemNode): boolean {
-        // Prevent auto-including .dlang files; we'll load via entry/import graph
-        const name = UriUtils.basename(entry.uri);
-        if (name.toLowerCase().endsWith('.dlang')) {
-            return false;
-        }
-        return super.shouldIncludeEntry(entry);
-    }
-
-    override async initializeWorkspace(folders: WorkspaceFolder[], cancelToken?: CancellationToken): Promise<void> {
-        await super.initializeWorkspace(folders, cancelToken);
-    }
-
-    protected override async loadAdditionalDocuments(folders: WorkspaceFolder[], collector: (document: LangiumDocument) => void): Promise<void> {
-        const manifestInfo = await this.findManifestInFolders(folders);
-        if (!manifestInfo) {
-            return; // Mode B: no manifest
-        }
-
-        const entryUri = URI.file(manifestInfo.entryPath);
-        const entryDoc = await this.langiumDocuments.getOrCreateDocument(entryUri);
-        collector(entryDoc);
-
-        const uris = await ensureImportGraphFromDocument(entryDoc, this.langiumDocuments);
-        for (const uriString of uris) {
-            const uri = URI.parse(uriString);
-            const doc = await this.langiumDocuments.getOrCreateDocument(uri);
-            collector(doc);
-        }
-    }
-
-    private async findManifestInFolders(folders: WorkspaceFolder[]): Promise<{ manifestPath: string; entryPath: string } | undefined> {
-        for (const folder of folders) {
-            const manifestPath = await this.findNearestManifest(folder.uri);
-            if (manifestPath) {
-                const entry = await this.readEntryFromManifest(manifestPath) ?? 'index.dlang';
-                const entryPath = path.resolve(path.dirname(manifestPath), entry);
-                return { manifestPath, entryPath };
-            }
-        }
-        return undefined;
-    }
-
-    private async findNearestManifest(startUri: string): Promise<string | undefined> {
-        let current = path.resolve(URI.parse(startUri).fsPath);
-        const { root } = path.parse(current);
-
-        while (true) {
-            const candidate = path.join(current, 'model.yaml');
-            if (await this.pathExists(candidate)) {
-                return candidate;
-            }
-
-            if (current === root) {
-                return undefined;
-            }
-
-            const parent = path.dirname(current);
-            if (parent === current) {
-                return undefined;
-            }
-            current = parent;
-        }
-    }
-
-    private async readEntryFromManifest(manifestPath: string): Promise<string | undefined> {
-        try {
-            const content = await this.fileSystemProvider.readFile(URI.file(manifestPath));
-            const manifest = (YAML.parse(content) ?? {}) as { model?: { entry?: string } };
-            return manifest.model?.entry;
-        } catch {
-            return undefined;
-        }
-    }
-
-    private async pathExists(target: string): Promise<boolean> {
-        try {
-            await this.fileSystemProvider.stat(URI.file(target));
-            return true;
-        } catch {
-            return false;
-        }
-    }
-}

package/src/lsp/manifest-diagnostics.ts

@@ -1,290 +0,0 @@
-/**
- * Manifest Diagnostics Service for DomainLang.
- * 
- * Provides LSP diagnostics for model.yaml files by integrating the ManifestValidator
- * with the VS Code language server protocol.
- * 
- * This service:
- * - Validates model.yaml files using ManifestValidator
- * - Converts ManifestDiagnostic to LSP Diagnostic format
- * - Sends diagnostics to the LSP connection
- * 
- * @module
- */
-
-import type { Connection } from 'vscode-languageserver';
-import { Diagnostic, DiagnosticSeverity, Position, Range } from 'vscode-languageserver-types';
-import YAML, { type Document as YAMLDocument, type YAMLMap, type Pair, isMap, isPair, isScalar } from 'yaml';
-import { ManifestValidator, type ManifestDiagnostic, type ManifestSeverity } from '../validation/manifest.js';
-import type { ModelManifest } from '../services/types.js';
-
-/**
- * Service for validating model.yaml and sending diagnostics via LSP.
- */
-export class ManifestDiagnosticsService {
-    private readonly validator = new ManifestValidator();
-    private connection: Connection | undefined;
-
-    /**
-     * Sets the LSP connection for sending diagnostics.
-     * Must be called before validateAndSendDiagnostics.
-     */
-    setConnection(connection: Connection): void {
-        this.connection = connection;
-    }
-
-    /**
-     * Validates a model.yaml file and sends diagnostics to the LSP connection.
-     * 
-     * @param manifestUri - URI of the model.yaml file
-     * @param content - Raw YAML content of the file
-     * @param options - Validation options
-     */
-    async validateAndSendDiagnostics(
-        manifestUri: string,
-        content: string,
-        options?: { requirePublishable?: boolean }
-    ): Promise<void> {
-        if (!this.connection) {
-            return; // No connection, skip diagnostics
-        }
-
-        const diagnostics = this.validate(content, options);
-        
-        await this.connection.sendDiagnostics({
-            uri: manifestUri,
-            diagnostics
-        });
-    }
-
-    /**
-     * Validates manifest content and returns LSP diagnostics.
-     * 
-     * @param content - Raw YAML content
-     * @param options - Validation options
-     * @returns Array of LSP diagnostics
-     */
-    validate(
-        content: string,
-        options?: { requirePublishable?: boolean }
-    ): Diagnostic[] {
-        // Parse YAML to get both the manifest object and source map
-        let yamlDoc: YAMLDocument.Parsed;
-        let manifest: ModelManifest;
-        
-        try {
-            yamlDoc = YAML.parseDocument(content);
-            
-            // Check for YAML parse errors (they're in the errors array, not thrown)
-            if (yamlDoc.errors && yamlDoc.errors.length > 0) {
-                return yamlDoc.errors.map(err => ({
-                    severity: DiagnosticSeverity.Error,
-                    range: this.yamlErrorToRange(err, content),
-                    message: `YAML parse error: ${err.message}`,
-                    source: 'domainlang'
-                }));
-            }
-            
-            manifest = (yamlDoc.toJSON() ?? {}) as ModelManifest;
-        } catch (error) {
-            // Fallback for unexpected errors
-            const message = error instanceof Error ? error.message : 'Invalid YAML syntax';
-            return [{
-                severity: DiagnosticSeverity.Error,
-                range: Range.create(Position.create(0, 0), Position.create(0, 1)),
-                message: `YAML parse error: ${message}`,
-                source: 'domainlang'
-            }];
-        }
-
-        // Run manifest validation
-        const result = this.validator.validate(manifest, options);
-        
-        // Convert to LSP diagnostics with source locations
-        return result.diagnostics.map(diag => 
-            this.toVSCodeDiagnostic(diag, yamlDoc)
-        );
-    }
-
-    /**
-     * Converts a YAML error to an LSP Range.
-     */
-    private yamlErrorToRange(err: YAML.YAMLError, _content: string): Range {
-        if (err.linePos && err.linePos.length >= 1) {
-            const startPos = err.linePos[0];
-            const startLine = startPos.line - 1; // YAML uses 1-based lines
-            const startCol = startPos.col - 1;   // YAML uses 1-based columns
-            const endPos = err.linePos.length >= 2 ? err.linePos[1] : undefined;
-            const endLine = endPos ? endPos.line - 1 : startLine;
-            const endCol = endPos ? endPos.col - 1 : startCol + 1;
-            return Range.create(
-                Position.create(startLine, startCol),
-                Position.create(endLine, endCol)
-            );
-        }
-        return Range.create(Position.create(0, 0), Position.create(0, 1));
-    }
-
-    /**
-     * Clears diagnostics for a manifest file.
-     * Call this when the file is closed or deleted.
-     */
-    async clearDiagnostics(manifestUri: string): Promise<void> {
-        if (!this.connection) {
-            return;
-        }
-
-        await this.connection.sendDiagnostics({
-            uri: manifestUri,
-            diagnostics: []
-        });
-    }
-
-    /**
-     * Converts a ManifestDiagnostic to an LSP Diagnostic.
-     */
-    private toVSCodeDiagnostic(
-        diag: ManifestDiagnostic,
-        yamlDoc: YAMLDocument.Parsed
-    ): Diagnostic {
-        const range = this.findRangeForPath(diag.path, yamlDoc);
-        
-        let message = diag.message;
-        if (diag.hint) {
-            message += `\nHint: ${diag.hint}`;
-        }
-
-        return {
-            severity: this.toVSCodeSeverity(diag.severity),
-            range,
-            message,
-            source: 'domainlang',
-            code: diag.code
-        };
-    }
-
-    /**
-     * Converts ManifestSeverity to LSP DiagnosticSeverity.
-     */
-    private toVSCodeSeverity(severity: ManifestSeverity): DiagnosticSeverity {
-        switch (severity) {
-            case 'error':
-                return DiagnosticSeverity.Error;
-            case 'warning':
-                return DiagnosticSeverity.Warning;
-            case 'info':
-                return DiagnosticSeverity.Information;
-            default:
-                return DiagnosticSeverity.Warning;
-        }
-    }
-
-    /**
-     * Finds the source range for a YAML path like "dependencies.core.version".
-     * Returns a fallback range at start of file if path not found.
-     */
-    private findRangeForPath(path: string, yamlDoc: YAMLDocument.Parsed): Range {
-        const fallback = Range.create(Position.create(0, 0), Position.create(0, 1));
-        
-        if (!yamlDoc.contents || !isMap(yamlDoc.contents)) {
-            return fallback;
-        }
-
-        const parts = path.split('.');
-        let currentNode: unknown = yamlDoc.contents;
-
-        for (const part of parts) {
-            if (!isMap(currentNode)) {
-                return fallback;
-            }
-            
-            const mapNode = currentNode as YAMLMap;
-            const item = mapNode.items.find((pair): pair is Pair => 
-                isPair(pair) && isScalar(pair.key) && String(pair.key.value) === part
-            );
-
-            if (!item) {
-                return fallback;
-            }
-
-            // If this is the last part, return the range of the key
-            if (part === parts[parts.length - 1]) {
-                const keyNode = item.key;
-                if (isScalar(keyNode) && keyNode.range) {
-                    const [start, end] = keyNode.range;
-                    return this.offsetsToRange(start, end, yamlDoc.toString());
-                }
-            }
-
-            currentNode = item.value;
-        }
-
-        return fallback;
-    }
-
-    /**
-     * Converts byte offsets to a VS Code Range using line/column calculation.
-     */
-    private offsetsToRange(startOffset: number, endOffset: number, content: string): Range {
-        const lines = content.split('\n');
-        let currentOffset = 0;
-        let startLine = 0;
-        let startCol = 0;
-        let endLine = 0;
-        let endCol = 0;
-        let foundStart = false;
-        let foundEnd = false;
-
-        for (let lineNum = 0; lineNum < lines.length && !foundEnd; lineNum++) {
-            const lineLength = lines[lineNum].length + 1; // +1 for newline
-
-            if (!foundStart && currentOffset + lineLength > startOffset) {
-                startLine = lineNum;
-                startCol = startOffset - currentOffset;
-                foundStart = true;
-            }
-
-            if (!foundEnd && currentOffset + lineLength >= endOffset) {
-                endLine = lineNum;
-                endCol = endOffset - currentOffset;
-                foundEnd = true;
-            }
-
-            currentOffset += lineLength;
-        }
-
-        return Range.create(
-            Position.create(startLine, startCol),
-            Position.create(endLine, endCol)
-        );
-    }
-}
-
-/**
- * Singleton instance for use across the language server.
- */
-let manifestDiagnosticsService: ManifestDiagnosticsService | undefined;
-
-/**
- * Gets or creates the manifest diagnostics service singleton.
- */
-export function getManifestDiagnosticsService(): ManifestDiagnosticsService {
-    if (!manifestDiagnosticsService) {
-        manifestDiagnosticsService = new ManifestDiagnosticsService();
-    }
-    return manifestDiagnosticsService;
-}
-
-/**
- * Helper to validate a manifest URI with the given content.
- * Convenience function for use in file watchers.
- */
-export async function validateManifestFile(
-    connection: Connection,
-    manifestUri: string,
-    content: string
-): Promise<void> {
-    const service = getManifestDiagnosticsService();
-    service.setConnection(connection);
-    await service.validateAndSendDiagnostics(manifestUri, content);
-}

package/src/services/semver.ts

@@ -1,213 +0,0 @@
-/**
- * Semantic Versioning Utilities
- * 
- * Centralized SemVer parsing, comparison, and validation for the dependency system.
- * All version-related logic should use these utilities to ensure consistency.
- * 
- * Supported formats:
- * - "1.0.0" or "v1.0.0" (tags)
- * - "1.0.0-alpha.1" (pre-release)
- * - "main", "develop" (branches)
- * - "abc123def" (commit SHAs, 7-40 hex chars)
- */
-
-import type { SemVer, RefType, ParsedRef } from './types.js';
-
-// ============================================================================
-// Parsing
-// ============================================================================
-
-/**
- * Parses a version string into SemVer components.
- * Returns undefined if not a valid SemVer.
- * 
- * @example
- * parseSemVer("v1.2.3")       // { major: 1, minor: 2, patch: 3, original: "v1.2.3" }
- * parseSemVer("1.0.0-alpha")  // { major: 1, minor: 0, patch: 0, prerelease: "alpha", ... }
- * parseSemVer("main")         // undefined (not SemVer)
- */
-export function parseSemVer(version: string): SemVer | undefined {
-    // Strip leading 'v' if present
-    const normalized = version.startsWith('v') ? version.slice(1) : version;
-    
-    // Match semver pattern: major.minor.patch[-prerelease]
-    const match = normalized.match(/^(\d+)\.(\d+)\.(\d+)(?:-(.+))?$/);
-    if (!match) return undefined;
-    
-    return {
-        major: parseInt(match[1], 10),
-        minor: parseInt(match[2], 10),
-        patch: parseInt(match[3], 10),
-        preRelease: match[4],
-        original: version,
-    };
-}
-
-/**
- * Detects the type of a git ref based on its format.
- * 
- * @example
- * detectRefType("v1.0.0")    // 'tag'
- * detectRefType("1.2.3")     // 'tag'
- * detectRefType("main")      // 'branch'
- * detectRefType("abc123def") // 'commit'
- */
-export function detectRefType(ref: string): RefType {
-    // Commit SHA: 7-40 hex characters
-    if (/^[0-9a-f]{7,40}$/i.test(ref)) {
-        return 'commit';
-    }
-    // Tags typically start with 'v' followed by semver
-    if (/^v?\d+\.\d+\.\d+/.test(ref)) {
-        return 'tag';
-    }
-    // Everything else is treated as a branch
-    return 'branch';
-}
-
-/**
- * Parses a ref string into a structured ParsedRef with type and optional SemVer.
- */
-export function parseRef(ref: string): ParsedRef {
-    const type = detectRefType(ref);
-    const semver = type === 'tag' ? parseSemVer(ref) : undefined;
-    
-    return { original: ref, type, semver };
-}
-
-// ============================================================================
-// Comparison
-// ============================================================================
-
-/**
- * Compares two SemVer versions.
- * Returns: negative if a < b, positive if a > b, zero if equal.
- * 
- * @example
- * compareSemVer(parse("1.0.0"), parse("2.0.0")) // negative (a < b)
- * compareSemVer(parse("1.5.0"), parse("1.2.0")) // positive (a > b)
- * compareSemVer(parse("1.0.0-alpha"), parse("1.0.0")) // negative (prerelease < release)
- */
-export function compareSemVer(a: SemVer, b: SemVer): number {
-    if (a.major !== b.major) return a.major - b.major;
-    if (a.minor !== b.minor) return a.minor - b.minor;
-    if (a.patch !== b.patch) return a.patch - b.patch;
-    
-    // Pre-release versions are lower than release versions
-    if (a.preRelease && !b.preRelease) return -1;
-    if (!a.preRelease && b.preRelease) return 1;
-    if (a.preRelease && b.preRelease) {
-        return a.preRelease.localeCompare(b.preRelease);
-    }
-    
-    return 0;
-}
-
-/**
- * Picks the latest from a list of SemVer refs.
- * Returns the ref string (with original 'v' prefix if present).
- * 
- * @example
- * pickLatestSemVer(["v1.0.0", "v1.5.0", "v1.2.0"]) // "v1.5.0"
- */
-export function pickLatestSemVer(refs: string[]): string | undefined {
-    const parsed = refs
-        .map(ref => ({ ref, semver: parseSemVer(ref) }))
-        .filter((item): item is { ref: string; semver: SemVer } => item.semver !== undefined);
-    
-    if (parsed.length === 0) return undefined;
-    
-    parsed.sort((a, b) => compareSemVer(b.semver, a.semver)); // Descending
-    return parsed[0].ref;
-}
-
-/**
- * Sorts version strings in descending order (newest first).
- * Non-SemVer refs are sorted lexicographically at the end.
- * 
- * @example
- * sortVersionsDescending(["v1.0.0", "v2.0.0", "v1.5.0"]) // ["v2.0.0", "v1.5.0", "v1.0.0"]
- */
-export function sortVersionsDescending(versions: string[]): string[] {
-    return [...versions].sort((a, b) => {
-        const semverA = parseSemVer(a);
-        const semverB = parseSemVer(b);
-        
-        // Both are SemVer - compare semantically
-        if (semverA && semverB) {
-            return compareSemVer(semverB, semverA); // Descending
-        }
-        
-        // SemVer comes before non-SemVer
-        if (semverA && !semverB) return -1;
-        if (!semverA && semverB) return 1;
-        
-        // Both non-SemVer - lexicographic
-        return b.localeCompare(a);
-    });
-}
-
-// ============================================================================
-// Validation
-// ============================================================================
-
-/**
- * Checks if a version/ref is a pre-release.
- * 
- * Pre-release identifiers: alpha, beta, rc, pre, dev, snapshot
- * 
- * @example
- * isPreRelease("v1.0.0")       // false
- * isPreRelease("v1.0.0-alpha") // true
- * isPreRelease("v1.0.0-rc.1")  // true
- */
-export function isPreRelease(ref: string): boolean {
-    const semver = parseSemVer(ref);
-    if (semver?.preRelease) {
-        return true;
-    }
-    
-    // Also check for common pre-release patterns without proper SemVer
-    const clean = ref.replace(/^v/, '');
-    return /-(alpha|beta|rc|pre|dev|snapshot)/i.test(clean);
-}
-
-/**
- * Checks if two SemVer versions are compatible (same major version).
- * 
- * @example
- * areSameMajor(parse("1.0.0"), parse("1.5.0")) // true
- * areSameMajor(parse("1.0.0"), parse("2.0.0")) // false
- */
-export function areSameMajor(a: SemVer, b: SemVer): boolean {
-    return a.major === b.major;
-}
-
-/**
- * Gets the major version number from a ref string.
- * Returns undefined if not a valid SemVer.
- */
-export function getMajorVersion(ref: string): number | undefined {
-    return parseSemVer(ref)?.major;
-}
-
-// ============================================================================
-// Filtering
-// ============================================================================
-
-/**
- * Filters refs to only stable versions (excludes pre-releases).
- * 
- * @example
- * filterStableVersions(["v1.0.0", "v1.1.0-alpha", "v1.2.0"]) // ["v1.0.0", "v1.2.0"]
- */
-export function filterStableVersions(refs: string[]): string[] {
-    return refs.filter(ref => !isPreRelease(ref));
-}
-
-/**
- * Filters refs to only SemVer tags (excludes branches and commits).
- */
-export function filterSemVerTags(refs: string[]): string[] {
-    return refs.filter(ref => detectRefType(ref) === 'tag' && parseSemVer(ref) !== undefined);
-}