@domainlang/language 0.1.20 → 0.1.82

package/src/services/dependency-analyzer.ts

@@ -8,12 +8,42 @@
  * - Version policy enforcement
  */
 
-import type { LockFile, DependencyTreeNode, ReverseDependency, VersionPolicy } from './types.js';
+import type { LockFile } from './git-url-resolver.js';
 import path from 'node:path';
 import fs from 'node:fs/promises';
 import os from 'node:os';
 import YAML from 'yaml';
-import { sortVersionsDescending, isPreRelease } from './semver.js';
+
+export interface DependencyTreeNode {
+    /** Package identifier */
+    packageKey: string;
+    /** Locked version */
+    version: string;
+    /** Commit hash */
+    commit: string;
+    /** Direct dependencies */
+    dependencies: DependencyTreeNode[];
+    /** Depth in tree (0 = root) */
+    depth: number;
+}
+
+export interface ReverseDependency {
+    /** Package that depends on the target */
+    dependentPackage: string;
+    /** Version of the dependent package */
+    version: string;
+    /** Type: direct or transitive */
+    type: 'direct' | 'transitive';
+}
+
+export interface VersionPolicy {
+    /** Policy name: latest, stable, or specific version */
+    policy: 'latest' | 'stable' | 'pinned';
+    /** Resolved version */
+    version: string;
+    /** Available versions for policy */
+    availableVersions?: string[];
+}
 
 /**
  * Analyzes dependency relationships and provides visualization/analysis tools.
@@ -79,7 +109,7 @@ export class DependencyAnalyzer {
         if (visited.has(packageKey)) {
             return {
                 packageKey,
-                ref: locked.ref,
+                version: locked.version,
                 commit: locked.commit,
                 dependencies: [], // Don't recurse into already visited
                 depth,
@@ -103,7 +133,7 @@ export class DependencyAnalyzer {
 
         return {
             packageKey,
-            ref: locked.ref,
+            version: locked.version,
             commit: locked.commit,
             dependencies: children,
             depth,
@@ -138,7 +168,7 @@ export class DependencyAnalyzer {
                     if (dep.source === targetPackage) {
                         reverseDeps.push({
                             dependentPackage: 'root',
-                            ref: 'workspace',
+                            version: 'workspace',
                             type: 'direct',
                         });
                     }
@@ -160,7 +190,7 @@ export class DependencyAnalyzer {
             if (packageDeps[targetPackage]) {
                 reverseDeps.push({
                     dependentPackage: packageKey,
-                    ref: locked.ref,
+                    version: locked.version,
                     type: 'direct',
                 });
             }
@@ -177,11 +207,11 @@ export class DependencyAnalyzer {
 
         const formatNode = (node: DependencyTreeNode, prefix: string, isLast: boolean): void => {
             const branch = isLast ? '└── ' : '├── ';
-            const refStr = options.showCommits
-                ? `${node.ref} (${node.commit.substring(0, 7)})`
-                : node.ref;
+            const versionStr = options.showCommits
+                ? `${node.version} (${node.commit.substring(0, 7)})`
+                : node.version;
             
-            lines.push(`${prefix}${branch}${node.packageKey}@${refStr}`);
+            lines.push(`${prefix}${branch}${node.packageKey}@${versionStr}`);
 
             const childPrefix = prefix + (isLast ? '    ' : '│   ');
             node.dependencies.forEach((child, index) => {
@@ -243,38 +273,38 @@ export class DependencyAnalyzer {
     }
 
     /**
-     * Resolves ref policies (latest, stable) to concrete refs.
+     * Resolves version policies (latest, stable) to concrete versions.
      */
     async resolveVersionPolicy(
-        _packageKey: string,
+        packageKey: string,
         policy: string,
-        availableRefs: string[]
+        availableVersions: string[]
     ): Promise<VersionPolicy> {
         if (policy === 'latest') {
-            // Return the most recent ref
-            const sorted = sortVersionsDescending(availableRefs);
+            // Return the most recent version
+            const sorted = this.sortVersions(availableVersions);
             return {
                 policy: 'latest',
-                ref: sorted[0] || 'main',
-                availableRefs: sorted,
+                version: sorted[0] || 'main',
+                availableVersions: sorted,
             };
         }
 
         if (policy === 'stable') {
-            // Return the most recent stable ref (exclude pre-release)
-            const stable = availableRefs.filter(v => !isPreRelease(v));
-            const sorted = sortVersionsDescending(stable);
+            // Return the most recent stable version (exclude pre-release)
+            const stable = availableVersions.filter(v => !this.isPreRelease(v));
+            const sorted = this.sortVersions(stable);
             return {
                 policy: 'stable',
-                ref: sorted[0] || 'main',
-                availableRefs: sorted,
+                version: sorted[0] || 'main',
+                availableVersions: sorted,
             };
         }
 
-        // Pinned ref
+        // Pinned version
         return {
             policy: 'pinned',
-            ref: policy,
+            version: policy,
         };
     }
 
@@ -318,4 +348,34 @@ export class DependencyAnalyzer {
             return {};
         }
     }
+
+    /**
+     * Sorts versions in descending order (newest first).
+     */
+    private sortVersions(versions: string[]): string[] {
+        return versions.sort((a, b) => {
+            // Simple lexicographic sort (good enough for basic semver)
+            // Production: use semver library
+            const aParts = a.replace(/^v/, '').split('.').map(Number);
+            const bParts = b.replace(/^v/, '').split('.').map(Number);
+
+            for (let i = 0; i < Math.max(aParts.length, bParts.length); i++) {
+                const aNum = aParts[i] || 0;
+                const bNum = bParts[i] || 0;
+                if (aNum !== bNum) {
+                    return bNum - aNum; // Descending
+                }
+            }
+
+            return 0;
+        });
+    }
+
+    /**
+     * Checks if a version is a pre-release.
+     */
+    private isPreRelease(version: string): boolean {
+        const clean = version.replace(/^v/, '');
+        return /-(alpha|beta|rc|pre|dev)/.test(clean);
+    }
 }