solidworks-mcp-server 3.0.8 → 3.1.3

package/dist/adapters/winax-adapter-enhanced.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Enhanced WinAx Adapter with Intelligent Feature Creation
+ *
+ * This adapter intelligently decides between direct COM calls and macro fallback
+ * based on parameter complexity analysis for ALL SolidWorks features.
+ */
+import type { SolidWorksFeature, SolidWorksModel } from '../solidworks/types.js';
+import type { AdapterHealth, AdapterResult, Command, ExtrusionParameters, ISolidWorksAdapter, LoftParameters, MassProperties, RevolveParameters, SweepParameters } from './types.js';
+export declare class EnhancedWinAxAdapter implements ISolidWorksAdapter {
+    private swApp;
+    private currentModel;
+    private macroGenerator;
+    private tempMacroPath;
+    private metrics;
+    constructor();
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    healthCheck(): Promise<AdapterHealth>;
+    private getSuccessRate;
+    createExtrusion(params: ExtrusionParameters): Promise<SolidWorksFeature>;
+    private createExtrusionDirect;
+    private createExtrusionViaMacro;
+    createRevolve(params: RevolveParameters): Promise<SolidWorksFeature>;
+    private createRevolveDirect;
+    private createRevolveViaMacro;
+    createSweep(params: SweepParameters): Promise<SolidWorksFeature>;
+    private createSweepViaMacro;
+    createLoft(params: LoftParameters): Promise<SolidWorksFeature>;
+    private createLoftDirect;
+    private createLoftViaMacro;
+    private selectSketchForFeature;
+    private updateResponseTime;
+    execute<T>(command: Command): Promise<AdapterResult<T>>;
+    executeRaw(method: string, args: any[]): Promise<any>;
+    openModel(filePath: string): Promise<SolidWorksModel>;
+    closeModel(save?: boolean): Promise<void>;
+    createPart(): Promise<SolidWorksModel>;
+    createAssembly(): Promise<SolidWorksModel>;
+    createDrawing(): Promise<SolidWorksModel>;
+    createSketch(plane: string): Promise<string>;
+    addLine(x1: number, y1: number, x2: number, y2: number): Promise<void>;
+    addCircle(centerX: number, centerY: number, radius: number): Promise<void>;
+    addRectangle(x1: number, y1: number, x2: number, y2: number): Promise<void>;
+    exitSketch(): Promise<void>;
+    getMassProperties(): Promise<MassProperties>;
+    exportFile(filePath: string, format: string): Promise<void>;
+    getDimension(name: string): Promise<number>;
+    setDimension(name: string, value: number): Promise<void>;
+}
+/**
+ * Factory function to create enhanced adapter
+ */
+export declare function createEnhancedWinAxAdapter(): Promise<EnhancedWinAxAdapter>;
+//# sourceMappingURL=winax-adapter-enhanced.d.ts.map

package/dist/adapters/winax-adapter-enhanced.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"winax-adapter-enhanced.d.ts","sourceRoot":"","sources":["../../src/adapters/winax-adapter-enhanced.ts"],"names":[],"mappings":"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"}

package/dist/adapters/winax-adapter-enhanced.js

@@ -0,0 +1,601 @@
+/**
+ * Enhanced WinAx Adapter with Intelligent Feature Creation
+ *
+ * This adapter intelligently decides between direct COM calls and macro fallback
+ * based on parameter complexity analysis for ALL SolidWorks features.
+ */
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import winax from 'winax';
+import { logger } from '../utils/logger.js';
+import { FeatureComplexityAnalyzer } from './feature-complexity-analyzer.js';
+import { MacroGenerator } from './macro-generator.js';
+export class EnhancedWinAxAdapter {
+    swApp;
+    currentModel;
+    macroGenerator;
+    tempMacroPath;
+    metrics = {
+        directCOMCalls: 0,
+        macroFallbacks: 0,
+        failures: 0,
+        averageResponseTime: 0,
+    };
+    constructor() {
+        this.swApp = null;
+        this.currentModel = null;
+        this.macroGenerator = new MacroGenerator();
+        this.tempMacroPath = process.env.TEMP || 'C:\\Temp';
+    }
+    // Connection Management
+    async connect() {
+        try {
+            this.swApp = new winax.Object('SldWorks.Application');
+            this.swApp.Visible = true;
+            logger.info('Connected to SolidWorks via Enhanced WinAx adapter');
+        }
+        catch (error) {
+            logger.error('Failed to connect to SolidWorks', error);
+            throw new Error(`Failed to connect to SolidWorks: ${error}`);
+        }
+    }
+    async disconnect() {
+        if (this.currentModel) {
+            this.currentModel = null;
+        }
+        if (this.swApp) {
+            this.swApp = null;
+        }
+        logger.info('Disconnected from SolidWorks');
+    }
+    isConnected() {
+        return this.swApp !== null;
+    }
+    async healthCheck() {
+        const healthy = this.isConnected();
+        return {
+            healthy,
+            lastCheck: new Date(),
+            errorCount: this.metrics.failures,
+            successCount: this.metrics.directCOMCalls + this.metrics.macroFallbacks,
+            averageResponseTime: this.metrics.averageResponseTime,
+            connectionStatus: healthy ? 'connected' : 'disconnected',
+            metrics: {
+                directCOMCalls: this.metrics.directCOMCalls,
+                macroFallbacks: this.metrics.macroFallbacks,
+                successRate: this.getSuccessRate(),
+            },
+        };
+    }
+    getSuccessRate() {
+        const total = this.metrics.directCOMCalls + this.metrics.macroFallbacks + this.metrics.failures;
+        if (total === 0)
+            return 100;
+        return ((this.metrics.directCOMCalls + this.metrics.macroFallbacks) / total) * 100;
+    }
+    // Feature Creation with Intelligent Fallback
+    async createExtrusion(params) {
+        if (!this.currentModel)
+            throw new Error('No active model');
+        const analysis = FeatureComplexityAnalyzer.analyzeExtrusion(params);
+        logger.info(`Extrusion analysis: ${JSON.stringify(analysis)}`);
+        if (analysis.strategy === 'direct-com') {
+            // Try direct COM call for simple extrusions
+            try {
+                return await this.createExtrusionDirect(params);
+            }
+            catch (error) {
+                logger.warn('Direct extrusion failed, falling back to macro', error);
+                return await this.createExtrusionViaMacro(params);
+            }
+        }
+        else {
+            // Complex extrusion - use macro directly
+            logger.info(`Using macro fallback: ${analysis.reason}`);
+            return await this.createExtrusionViaMacro(params);
+        }
+    }
+    async createExtrusionDirect(params) {
+        const startTime = Date.now();
+        try {
+            // Select sketch
+            this.selectSketchForFeature();
+            // Simple extrusion with limited parameters (max 12)
+            const feature = this.currentModel.FeatureManager.FeatureExtrusion2(true, // Sd
+            params.reverse || false, // Flip
+            params.bothDirections || false, // Dir
+            0, // T1 (blind)
+            0, // T2
+            params.depth / 1000, // D1 (convert mm to m)
+            0.0, // D2
+            false, // Dchk1
+            false, // Dchk2
+            params.draft || 0, // Dang1
+            0, // Dang2
+            false // OffsetReverse1
+            );
+            if (!feature) {
+                throw new Error('FeatureExtrusion2 returned null');
+            }
+            this.metrics.directCOMCalls++;
+            this.updateResponseTime(Date.now() - startTime);
+            return {
+                name: feature.Name || 'Boss-Extrude1',
+                type: 'Extrusion',
+                suppressed: false,
+            };
+        }
+        catch (error) {
+            this.metrics.failures++;
+            throw error;
+        }
+    }
+    async createExtrusionViaMacro(params) {
+        const startTime = Date.now();
+        const macroCode = this.macroGenerator.generateExtrusionMacro(params);
+        const macroPath = path.join(this.tempMacroPath, `extrusion_${Date.now()}.swp`);
+        await fs.writeFile(macroPath, macroCode);
+        try {
+            this.swApp.RunMacro2(macroPath, 'Module1', 'CreateExtrusion', 1, 0);
+            const feature = this.currentModel.FeatureByPositionReverse(0);
+            this.metrics.macroFallbacks++;
+            this.updateResponseTime(Date.now() - startTime);
+            return {
+                name: feature?.Name || 'Boss-Extrude1',
+                type: 'Extrusion',
+                suppressed: false,
+            };
+        }
+        finally {
+            await fs.unlink(macroPath).catch(() => { });
+        }
+    }
+    async createRevolve(params) {
+        if (!this.currentModel)
+            throw new Error('No active model');
+        const analysis = FeatureComplexityAnalyzer.determineStrategy('FeatureRevolve2', params);
+        logger.info(`Revolve analysis: ${JSON.stringify(analysis)}`);
+        if (analysis.strategy === 'direct-com') {
+            try {
+                return await this.createRevolveDirect(params);
+            }
+            catch (error) {
+                logger.warn('Direct revolve failed, falling back to macro', error);
+                return await this.createRevolveViaMacro(params);
+            }
+        }
+        else {
+            return await this.createRevolveViaMacro(params);
+        }
+    }
+    async createRevolveDirect(params) {
+        const startTime = Date.now();
+        try {
+            this.selectSketchForFeature();
+            // FeatureRevolve2 has exactly 12 parameters - right at the limit
+            const feature = this.currentModel.FeatureManager.FeatureRevolve2(true, // SingleDir
+            params.direction === 'Reverse', // IsSolid
+            params.direction === 'Both', // IsThin
+            false, // Cap
+            false, // MakeThinFeature
+            (params.angle * Math.PI) / 180, // Angle1
+            0, // Angle2
+            0, // OffsetDistance1
+            0, // OffsetDistance2
+            0, // OffsetReverse1
+            0, // OffsetReverse2
+            params.merge !== false // Merge
+            );
+            if (!feature) {
+                throw new Error('FeatureRevolve2 returned null');
+            }
+            this.metrics.directCOMCalls++;
+            this.updateResponseTime(Date.now() - startTime);
+            return {
+                name: feature.Name || 'Revolve1',
+                type: 'Revolution',
+                suppressed: false,
+            };
+        }
+        catch (error) {
+            this.metrics.failures++;
+            throw error;
+        }
+    }
+    async createRevolveViaMacro(params) {
+        const startTime = Date.now();
+        const macroCode = this.macroGenerator.generateRevolveMacro(params);
+        const macroPath = path.join(this.tempMacroPath, `revolve_${Date.now()}.swp`);
+        await fs.writeFile(macroPath, macroCode);
+        try {
+            this.swApp.RunMacro2(macroPath, 'Module1', 'CreateRevolve', 1, 0);
+            const feature = this.currentModel.FeatureByPositionReverse(0);
+            this.metrics.macroFallbacks++;
+            this.updateResponseTime(Date.now() - startTime);
+            return {
+                name: feature?.Name || 'Revolve1',
+                type: 'Revolution',
+                suppressed: false,
+            };
+        }
+        finally {
+            await fs.unlink(macroPath).catch(() => { });
+        }
+    }
+    async createSweep(params) {
+        if (!this.currentModel)
+            throw new Error('No active model');
+        // Sweep always requires macro due to high parameter count
+        const analysis = FeatureComplexityAnalyzer.determineStrategy('InsertProtrusionSwept4', params);
+        logger.info(`Sweep analysis: Always complex - strategy: ${analysis.strategy}`);
+        return await this.createSweepViaMacro(params);
+    }
+    async createSweepViaMacro(params) {
+        const startTime = Date.now();
+        const macroCode = this.macroGenerator.generateSweepMacro(params);
+        const macroPath = path.join(this.tempMacroPath, `sweep_${Date.now()}.swp`);
+        await fs.writeFile(macroPath, macroCode);
+        try {
+            this.swApp.RunMacro2(macroPath, 'Module1', 'CreateSweep', 1, 0);
+            const feature = this.currentModel.FeatureByPositionReverse(0);
+            this.metrics.macroFallbacks++;
+            this.updateResponseTime(Date.now() - startTime);
+            return {
+                name: feature?.Name || 'Sweep1',
+                type: 'Sweep',
+                suppressed: false,
+            };
+        }
+        finally {
+            await fs.unlink(macroPath).catch(() => { });
+        }
+    }
+    async createLoft(params) {
+        if (!this.currentModel)
+            throw new Error('No active model');
+        const analysis = FeatureComplexityAnalyzer.determineStrategy('InsertProtrusionLoft3', params);
+        logger.info(`Loft analysis: ${JSON.stringify(analysis)}`);
+        if (analysis.strategy === 'direct-com') {
+            try {
+                return await this.createLoftDirect(params);
+            }
+            catch (error) {
+                logger.warn('Direct loft failed, falling back to macro', error);
+                return await this.createLoftViaMacro(params);
+            }
+        }
+        else {
+            return await this.createLoftViaMacro(params);
+        }
+    }
+    async createLoftDirect(params) {
+        const startTime = Date.now();
+        try {
+            // Select profiles
+            for (const profile of params.profiles) {
+                this.currentModel.Extension.SelectByID2(profile, 'SKETCH', 0, 0, 0, true, 0, undefined, 0);
+            }
+            // Simple loft without guides (12 parameters max)
+            const feature = this.currentModel.FeatureManager.InsertProtrusionBlend2(false, // Closed
+            true, // KeepTangency
+            false, // ForceNonRational
+            true, // ThinFeature
+            true, // UseFeatScope
+            true, // AutoSelect
+            params.profiles.length, // NumberOfSections
+            0, // StartConditions
+            0, // EndConditions
+            0, // StartTangentType
+            0, // EndTangentType
+            params.merge !== false // Merge
+            );
+            if (!feature) {
+                throw new Error('InsertProtrusionBlend2 returned null');
+            }
+            this.metrics.directCOMCalls++;
+            this.updateResponseTime(Date.now() - startTime);
+            return {
+                name: feature.Name || 'Loft1',
+                type: 'Loft',
+                suppressed: false,
+            };
+        }
+        catch (error) {
+            this.metrics.failures++;
+            throw error;
+        }
+    }
+    async createLoftViaMacro(params) {
+        const startTime = Date.now();
+        const macroCode = this.macroGenerator.generateLoftMacro(params);
+        const macroPath = path.join(this.tempMacroPath, `loft_${Date.now()}.swp`);
+        await fs.writeFile(macroPath, macroCode);
+        try {
+            this.swApp.RunMacro2(macroPath, 'Module1', 'CreateLoft', 1, 0);
+            const feature = this.currentModel.FeatureByPositionReverse(0);
+            this.metrics.macroFallbacks++;
+            this.updateResponseTime(Date.now() - startTime);
+            return {
+                name: feature?.Name || 'Loft1',
+                type: 'Loft',
+                suppressed: false,
+            };
+        }
+        finally {
+            await fs.unlink(macroPath).catch(() => { });
+        }
+    }
+    // Helper Methods
+    selectSketchForFeature() {
+        // Method 1 (most reliable): Feature tree traversal
+        // Avoids SelectByID2 COM type mismatch issues
+        try {
+            const featureCount = this.currentModel.GetFeatureCount();
+            for (let i = 0; i < Math.min(10, featureCount); i++) {
+                const feat = this.currentModel.FeatureByPositionReverse(i);
+                if (feat) {
+                    const typeName = feat.GetTypeName2();
+                    if (typeName === 'ProfileFeature' || typeName?.toLowerCase().includes('sketch')) {
+                        feat.Select2(false, 0);
+                        logger.info(`Selected sketch by feature tree: ${feat.Name || feat.GetName()}`);
+                        return true;
+                    }
+                }
+            }
+        }
+        catch (e) {
+            logger.warn(`Feature tree search failed: ${e}`);
+        }
+        // Method 2 (fallback): SelectByID2 with undefined for optional params
+        const ext = this.currentModel.Extension;
+        const sketchNames = ['Sketch1', 'Sketch2', 'Sketch3', 'Sketch4', 'Sketch5'];
+        for (const name of sketchNames) {
+            try {
+                const selected = ext.SelectByID2(name, 'SKETCH', 0, 0, 0, false, 0, undefined, 0);
+                if (selected) {
+                    logger.info(`Selected sketch via SelectByID2: ${name}`);
+                    return true;
+                }
+            }
+            catch (_e) {
+                // Try next
+            }
+        }
+        return false;
+    }
+    updateResponseTime(duration) {
+        const total = this.metrics.directCOMCalls + this.metrics.macroFallbacks;
+        this.metrics.averageResponseTime = (this.metrics.averageResponseTime * (total - 1) + duration) / total;
+    }
+    // Standard adapter methods (implement remaining interface)
+    async execute(command) {
+        const startTime = Date.now();
+        try {
+            let result;
+            // Route commands to appropriate methods
+            switch (command.name) {
+                case 'CreateExtrusion':
+                    result = await this.createExtrusion(command.parameters);
+                    break;
+                case 'CreateRevolve':
+                    result = await this.createRevolve(command.parameters);
+                    break;
+                case 'CreateSweep':
+                    result = await this.createSweep(command.parameters);
+                    break;
+                case 'CreateLoft':
+                    result = await this.createLoft(command.parameters);
+                    break;
+                default:
+                    result = await this.executeRaw(command.name, [command.parameters]);
+            }
+            return {
+                success: true,
+                data: result,
+                timing: {
+                    start: new Date(startTime),
+                    end: new Date(),
+                    duration: Date.now() - startTime,
+                },
+                metadata: {
+                    adapter: 'EnhancedWinAx',
+                    metrics: this.metrics,
+                },
+            };
+        }
+        catch (error) {
+            this.metrics.failures++;
+            return {
+                success: false,
+                error: error?.toString() || 'Command execution failed',
+                timing: {
+                    start: new Date(startTime),
+                    end: new Date(),
+                    duration: Date.now() - startTime,
+                },
+            };
+        }
+    }
+    async executeRaw(method, args) {
+        if (!this.swApp)
+            throw new Error('Not connected to SolidWorks');
+        try {
+            const target = this.currentModel || this.swApp;
+            return target[method](...args);
+        }
+        catch (error) {
+            logger.error(`Raw execution failed: ${method}`, error);
+            throw error;
+        }
+    }
+    // Model operations
+    async openModel(filePath) {
+        if (!this.swApp)
+            throw new Error('Not connected to SolidWorks');
+        const errors = { value: 0 };
+        const warnings = { value: 0 };
+        const ext = filePath.toLowerCase().split('.').pop();
+        let docType = 1; // swDocPART
+        if (ext === 'sldasm')
+            docType = 2; // swDocASSEMBLY
+        if (ext === 'slddrw')
+            docType = 3; // swDocDRAWING
+        this.currentModel = this.swApp.OpenDoc6(filePath, docType, 1, '', errors, warnings);
+        if (!this.currentModel) {
+            throw new Error(`Failed to open model: ${filePath}`);
+        }
+        return {
+            path: filePath,
+            name: this.currentModel.GetTitle(),
+            type: ['Part', 'Assembly', 'Drawing'][docType - 1],
+            isActive: true,
+        };
+    }
+    async closeModel(save) {
+        if (!this.currentModel)
+            return;
+        if (save) {
+            this.currentModel.Save3(1, 0, 0);
+        }
+        const title = this.currentModel.GetTitle();
+        this.swApp.CloseDoc(title);
+        this.currentModel = null;
+    }
+    async createPart() {
+        if (!this.swApp)
+            throw new Error('Not connected to SolidWorks');
+        this.currentModel = this.swApp.NewPart();
+        return {
+            path: '',
+            name: this.currentModel.GetTitle(),
+            type: 'Part',
+            isActive: true,
+        };
+    }
+    async createAssembly() {
+        if (!this.swApp)
+            throw new Error('Not connected to SolidWorks');
+        this.currentModel = this.swApp.NewAssembly();
+        return {
+            path: '',
+            name: this.currentModel.GetTitle(),
+            type: 'Assembly',
+            isActive: true,
+        };
+    }
+    async createDrawing() {
+        if (!this.swApp)
+            throw new Error('Not connected to SolidWorks');
+        this.currentModel = this.swApp.NewDrawing();
+        return {
+            path: '',
+            name: this.currentModel.GetTitle(),
+            type: 'Drawing',
+            isActive: true,
+        };
+    }
+    // Sketch operations
+    async createSketch(plane) {
+        if (!this.currentModel)
+            throw new Error('No active model');
+        const ext = this.currentModel.Extension;
+        ext.SelectByID2(`${plane} Plane`, 'PLANE', 0, 0, 0, false, 0, undefined, 0);
+        this.currentModel.SketchManager.InsertSketch(true);
+        return this.currentModel.SketchManager.ActiveSketch.Name;
+    }
+    async addLine(x1, y1, x2, y2) {
+        if (!this.currentModel)
+            throw new Error('No active model');
+        this.currentModel.SketchManager.CreateLine(x1 / 1000, y1 / 1000, 0, x2 / 1000, y2 / 1000, 0);
+    }
+    async addCircle(centerX, centerY, radius) {
+        if (!this.currentModel)
+            throw new Error('No active model');
+        this.currentModel.SketchManager.CreateCircle(centerX / 1000, centerY / 1000, 0, (centerX + radius) / 1000, centerY / 1000, 0);
+    }
+    async addRectangle(x1, y1, x2, y2) {
+        if (!this.currentModel)
+            throw new Error('No active model');
+        const sketchMgr = this.currentModel.SketchManager;
+        sketchMgr.CreateLine(x1 / 1000, y1 / 1000, 0, x2 / 1000, y1 / 1000, 0);
+        sketchMgr.CreateLine(x2 / 1000, y1 / 1000, 0, x2 / 1000, y2 / 1000, 0);
+        sketchMgr.CreateLine(x2 / 1000, y2 / 1000, 0, x1 / 1000, y2 / 1000, 0);
+        sketchMgr.CreateLine(x1 / 1000, y2 / 1000, 0, x1 / 1000, y1 / 1000, 0);
+    }
+    async exitSketch() {
+        if (!this.currentModel)
+            throw new Error('No active model');
+        this.currentModel.SketchManager.InsertSketch(false);
+    }
+    // Analysis operations
+    async getMassProperties() {
+        if (!this.currentModel)
+            throw new Error('No active model');
+        const massProp = this.currentModel.Extension.CreateMassProperty();
+        return {
+            mass: massProp.Mass,
+            volume: massProp.Volume,
+            surfaceArea: massProp.SurfaceArea,
+            centerOfMass: {
+                x: massProp.CenterOfMass[0],
+                y: massProp.CenterOfMass[1],
+                z: massProp.CenterOfMass[2],
+            },
+            momentsOfInertia: {
+                Ixx: massProp.MomentOfInertia[0],
+                Iyy: massProp.MomentOfInertia[4],
+                Izz: massProp.MomentOfInertia[8],
+                Ixy: massProp.MomentOfInertia[1],
+                Iyz: massProp.MomentOfInertia[5],
+                Ixz: massProp.MomentOfInertia[2],
+            },
+        };
+    }
+    // Export operations
+    async exportFile(filePath, format) {
+        if (!this.currentModel)
+            throw new Error('No active model');
+        const formatMap = {
+            step: 203,
+            iges: 204,
+            stl: 216,
+            pdf: 217,
+            dwg: 218,
+            dxf: 219,
+        };
+        const exportType = formatMap[format.toLowerCase()] || 203;
+        const success = this.currentModel.Extension.SaveAs3(filePath, 0, exportType, undefined, undefined, 0, 0);
+        if (!success) {
+            throw new Error(`Failed to export to ${format}`);
+        }
+    }
+    // Dimension operations
+    async getDimension(name) {
+        if (!this.currentModel)
+            throw new Error('No active model');
+        const dim = this.currentModel.Parameter(name);
+        if (!dim) {
+            throw new Error(`Dimension ${name} not found`);
+        }
+        return dim.SystemValue * 1000; // Convert m to mm
+    }
+    async setDimension(name, value) {
+        if (!this.currentModel)
+            throw new Error('No active model');
+        const dim = this.currentModel.Parameter(name);
+        if (!dim) {
+            throw new Error(`Dimension ${name} not found`);
+        }
+        dim.SystemValue = value / 1000; // Convert mm to m
+        this.currentModel.EditRebuild3();
+    }
+}
+/**
+ * Factory function to create enhanced adapter
+ */
+export async function createEnhancedWinAxAdapter() {
+    const adapter = new EnhancedWinAxAdapter();
+    await adapter.connect();
+    return adapter;
+}
+//# sourceMappingURL=winax-adapter-enhanced.js.map