solidworks-mcp-server 3.0.8 → 3.1.3

package/dist/tools/sketch.js

@@ -17,71 +17,119 @@ export const sketchTools = [
             plane: z.enum(['Front', 'Top', 'Right', 'Custom']).default('Front').describe('Reference plane for sketch'),
             offset: z.number().default(0).describe('Offset distance from plane in mm'),
             reverse: z.boolean().default(false).describe('Reverse offset direction'),
-            customPlane: z.object({
+            customPlane: z
+                .object({
                 origin: z.object({
                     x: z.number().describe('X coordinate in mm'),
                     y: z.number().describe('Y coordinate in mm'),
-                    z: z.number().describe('Z coordinate in mm')
+                    z: z.number().describe('Z coordinate in mm'),
                 }),
                 normal: z.object({
                     x: z.number().describe('X component of normal vector'),
                     y: z.number().describe('Y component of normal vector'),
-                    z: z.number().describe('Z component of normal vector')
-                })
-            }).optional().describe('Custom plane definition')
+                    z: z.number().describe('Z component of normal vector'),
+                }),
+            })
+                .optional()
+                .describe('Custom plane definition'),
         }),
         handler: (args, swApi) => {
             try {
                 const model = swApi.getCurrentModel();
                 if (!model)
                     throw new Error('No active model');
-                // Select the appropriate plane
-                let planeRef;
+                // For now, let's use a simpler approach without SelectByID2
+                // SolidWorks will use the Front plane by default if no plane is selected
                 if (args.plane === 'Custom' && args.customPlane) {
                     // Create custom reference plane
-                    const { origin, normal } = args.customPlane;
-                    planeRef = model.FeatureManager.InsertRefPlane(8, // FirstConstraint: parallel to plane
+                    const { origin: _origin, normal: _normal } = args.customPlane;
+                    const planeRef = model.FeatureManager.InsertRefPlane(8, // FirstConstraint: parallel to plane
                     0, // FirstConstraintAngle
                     4, // SecondConstraint: distance
                     args.offset / 1000, // SecondConstraintAngle/Distance
                     0, // ThirdConstraint
                     0 // ThirdConstraintAngle
                     );
+                    if (!planeRef)
+                        throw new Error('Failed to create custom plane');
                 }
                 else {
-                    // Use standard plane
-                    planeRef = model.FeatureManager.GetPlane(args.plane);
-                }
-                if (!planeRef)
-                    throw new Error('Failed to get reference plane');
-                // Create offset plane if needed
-                if (args.offset !== 0) {
-                    model.SelectByID2(args.plane + ' Plane', 'PLANE', 0, 0, 0, false, 0, null, 0);
-                    planeRef = model.FeatureManager.InsertRefPlane(8, // Parallel to plane
-                    0, 4, // Distance
-                    args.offset / 1000, 0, 0);
+                    // Try to select plane by index
+                    // 0 = Front, 1 = Top, 2 = Right
+                    const planeIndex = args.plane === 'Front' ? 0 : args.plane === 'Top' ? 1 : 2;
+                    try {
+                        // Get reference geometry
+                        const refGeom = model.FeatureManager;
+                        if (refGeom) {
+                            // Try to get the plane directly
+                            const planes = ['Front Plane', 'Top Plane', 'Right Plane'];
+                            const planeName = planes[planeIndex];
+                            // Use simpler selection approach
+                            model.ClearSelection2(true);
+                            // Try selecting by feature name
+                            let selected = false;
+                            try {
+                                const feature = model.FeatureByName(planeName);
+                                if (feature) {
+                                    feature.Select2(false, 0);
+                                    selected = true;
+                                }
+                            }
+                            catch (_e) {
+                                // Feature selection failed, continue
+                            }
+                            // If feature selection didn't work, just proceed
+                            // SolidWorks often defaults to Front plane anyway
+                            if (!selected && args.plane !== 'Front') {
+                                console.log(`Note: Could not select ${args.plane} plane, using default`);
+                            }
+                        }
+                    }
+                    catch (_e) {
+                        // Plane selection failed, but continue anyway
+                        console.log('Note: Plane selection failed, using default');
+                    }
+                    // Create offset plane if needed
+                    if (args.offset !== 0) {
+                        const offsetPlane = model.FeatureManager.InsertRefPlane(8, // Parallel to plane
+                        0, 4, // Distance
+                        args.offset / 1000, 0, 0);
+                        if (!offsetPlane)
+                            throw new Error('Failed to create offset plane');
+                    }
                 }
-                // Insert sketch on plane
+                // Insert sketch - this should work even without plane selection
+                // as SolidWorks will use the currently selected plane or default to Front
                 model.SketchManager.InsertSketch(true);
-                const sketchName = model.SketchManager.ActiveSketch?.Name;
+                // Try to get the sketch name
+                let sketchName = 'Sketch';
+                try {
+                    const activeSketch = model.SketchManager.ActiveSketch;
+                    if (activeSketch?.Name) {
+                        sketchName = activeSketch.Name;
+                    }
+                }
+                catch (_e) {
+                    // Could not get sketch name, use default
+                }
                 return {
                     success: true,
                     sketchName,
                     plane: args.plane,
                     offset: args.offset,
-                    message: `Sketch created on ${args.plane} plane${args.offset ? ` with ${args.offset}mm offset` : ''}`
+                    message: `Sketch created on ${args.plane} plane${args.offset ? ` with ${args.offset}mm offset` : ''}`,
                 };
             }
             catch (error) {
                 return `Failed to create sketch: ${error}`;
             }
-        }
+        },
     },
     {
         name: 'edit_sketch',
         description: 'Enter sketch edit mode for an existing sketch',
         inputSchema: z.object({
-            sketchName: z.string().describe('Name of the sketch to edit')
+            sketchName: z.string().describe('Name of the sketch to edit'),
         }),
         handler: (args, swApi) => {
             try {
@@ -89,26 +137,26 @@ export const sketchTools = [
                 if (!model)
                     throw new Error('No active model');
                 // Select the sketch
-                const selected = model.SelectByID2(args.sketchName, 'SKETCH', 0, 0, 0, false, 0, null, 0);
+                const selected = model.Extension.SelectByID2(args.sketchName, 'SKETCH', 0, 0, 0, false, 0, undefined, 0);
                 if (!selected)
                     throw new Error('Sketch not found');
                 // Edit sketch
                 model.EditSketch();
                 return {
                     success: true,
-                    message: `Entered edit mode for sketch: ${args.sketchName}`
+                    message: `Entered edit mode for sketch: ${args.sketchName}`,
                 };
             }
             catch (error) {
                 return `Failed to edit sketch: ${error}`;
             }
-        }
+        },
     },
     {
         name: 'exit_sketch',
         description: 'Exit sketch edit mode and rebuild',
         inputSchema: z.object({
-            rebuild: z.boolean().default(true).describe('Rebuild model after exiting sketch')
+            rebuild: z.boolean().default(true).describe('Rebuild model after exiting sketch'),
         }),
         handler: (args, swApi) => {
             try {
@@ -123,13 +171,13 @@ export const sketchTools = [
                 }
                 return {
                     success: true,
-                    message: 'Exited sketch edit mode'
+                    message: 'Exited sketch edit mode',
                 };
             }
             catch (error) {
                 return `Failed to exit sketch: ${error}`;
             }
-        }
+        },
     },
     // ============================================
     // SKETCH GEOMETRY - LINES
@@ -141,14 +189,14 @@ export const sketchTools = [
             start: z.object({
                 x: z.number().describe('Start X coordinate in mm'),
                 y: z.number().describe('Start Y coordinate in mm'),
-                z: z.number().default(0).describe('Start Z coordinate in mm (for 3D sketches)')
+                z: z.number().default(0).describe('Start Z coordinate in mm (for 3D sketches)'),
             }),
             end: z.object({
                 x: z.number().describe('End X coordinate in mm'),
                 y: z.number().describe('End Y coordinate in mm'),
-                z: z.number().default(0).describe('End Z coordinate in mm (for 3D sketches)')
+                z: z.number().default(0).describe('End Z coordinate in mm (for 3D sketches)'),
             }),
-            construction: z.boolean().default(false).describe('Create as construction geometry')
+            construction: z.boolean().default(false).describe('Create as construction geometry'),
         }),
         handler: (args, swApi) => {
             try {
@@ -165,15 +213,13 @@ export const sketchTools = [
                 return {
                     success: true,
                     message: `Line created from (${args.start.x}, ${args.start.y}) to (${args.end.x}, ${args.end.y})`,
-                    length: Math.sqrt(Math.pow(args.end.x - args.start.x, 2) +
-                        Math.pow(args.end.y - args.start.y, 2) +
-                        Math.pow(args.end.z - args.start.z, 2))
+                    length: Math.sqrt((args.end.x - args.start.x) ** 2 + (args.end.y - args.start.y) ** 2 + (args.end.z - args.start.z) ** 2),
                 };
             }
             catch (error) {
                 return `Failed to create line: ${error}`;
             }
-        }
+        },
     },
     {
         name: 'sketch_centerline',
@@ -181,12 +227,12 @@ export const sketchTools = [
         inputSchema: z.object({
             start: z.object({
                 x: z.number().describe('Start X coordinate in mm'),
-                y: z.number().describe('Start Y coordinate in mm')
+                y: z.number().describe('Start Y coordinate in mm'),
             }),
             end: z.object({
                 x: z.number().describe('End X coordinate in mm'),
-                y: z.number().describe('End Y coordinate in mm')
-            })
+                y: z.number().describe('End Y coordinate in mm'),
+            }),
         }),
         handler: (args, swApi) => {
             try {
@@ -198,13 +244,13 @@ export const sketchTools = [
                     throw new Error('Failed to create centerline');
                 return {
                     success: true,
-                    message: `Centerline created from (${args.start.x}, ${args.start.y}) to (${args.end.x}, ${args.end.y})`
+                    message: `Centerline created from (${args.start.x}, ${args.start.y}) to (${args.end.x}, ${args.end.y})`,
                 };
             }
             catch (error) {
                 return `Failed to create centerline: ${error}`;
             }
-        }
+        },
     },
     // ============================================
     // SKETCH GEOMETRY - CIRCLES & ARCS
@@ -216,10 +262,10 @@ export const sketchTools = [
             center: z.object({
                 x: z.number().describe('Center X coordinate in mm'),
                 y: z.number().describe('Center Y coordinate in mm'),
-                z: z.number().default(0).describe('Center Z coordinate in mm (for 3D sketches)')
+                z: z.number().default(0).describe('Center Z coordinate in mm (for 3D sketches)'),
             }),
             radius: z.number().positive().describe('Circle radius in mm'),
-            construction: z.boolean().default(false).describe('Create as construction geometry')
+            construction: z.boolean().default(false).describe('Create as construction geometry'),
         }),
         handler: (args, swApi) => {
             try {
@@ -237,13 +283,13 @@ export const sketchTools = [
                     success: true,
                     message: `Circle created at (${args.center.x}, ${args.center.y}) with radius ${args.radius}mm`,
                     area: Math.PI * args.radius * args.radius,
-                    circumference: 2 * Math.PI * args.radius
+                    circumference: 2 * Math.PI * args.radius,
                 };
             }
             catch (error) {
                 return `Failed to create circle: ${error}`;
             }
-        }
+        },
     },
     {
         name: 'sketch_arc',
@@ -251,18 +297,18 @@ export const sketchTools = [
         inputSchema: z.object({
             center: z.object({
                 x: z.number().describe('Center X coordinate in mm'),
-                y: z.number().describe('Center Y coordinate in mm')
+                y: z.number().describe('Center Y coordinate in mm'),
             }),
             start: z.object({
                 x: z.number().describe('Start point X coordinate in mm'),
-                y: z.number().describe('Start point Y coordinate in mm')
+                y: z.number().describe('Start point Y coordinate in mm'),
             }),
             end: z.object({
                 x: z.number().describe('End point X coordinate in mm'),
-                y: z.number().describe('End point Y coordinate in mm')
+                y: z.number().describe('End point Y coordinate in mm'),
             }),
             direction: z.enum(['clockwise', 'counterclockwise']).default('counterclockwise'),
-            construction: z.boolean().default(false).describe('Create as construction geometry')
+            construction: z.boolean().default(false).describe('Create as construction geometry'),
         }),
         handler: (args, swApi) => {
             try {
@@ -278,19 +324,18 @@ export const sketchTools = [
                     arc.ConstructionGeometry = true;
                 }
                 // Calculate arc properties
-                const radius = Math.sqrt(Math.pow(args.start.x - args.center.x, 2) +
-                    Math.pow(args.start.y - args.center.y, 2));
+                const radius = Math.sqrt((args.start.x - args.center.x) ** 2 + (args.start.y - args.center.y) ** 2);
                 return {
                     success: true,
                     message: `Arc created with center at (${args.center.x}, ${args.center.y})`,
                     radius,
-                    direction: args.direction
+                    direction: args.direction,
                 };
             }
             catch (error) {
                 return `Failed to create arc: ${error}`;
             }
-        }
+        },
     },
     // ============================================
     // SKETCH GEOMETRY - RECTANGLES & POLYGONS
@@ -301,14 +346,14 @@ export const sketchTools = [
         inputSchema: z.object({
             corner1: z.object({
                 x: z.number().describe('First corner X coordinate in mm'),
-                y: z.number().describe('First corner Y coordinate in mm')
+                y: z.number().describe('First corner Y coordinate in mm'),
             }),
             corner2: z.object({
                 x: z.number().describe('Opposite corner X coordinate in mm'),
-                y: z.number().describe('Opposite corner Y coordinate in mm')
+                y: z.number().describe('Opposite corner Y coordinate in mm'),
             }),
             centered: z.boolean().default(false).describe('Create rectangle centered at corner1'),
-            construction: z.boolean().default(false).describe('Create as construction geometry')
+            construction: z.boolean().default(false).describe('Create as construction geometry'),
         }),
         handler: (args, swApi) => {
             try {
@@ -336,7 +381,7 @@ export const sketchTools = [
                 lines.push(model.SketchManager.CreateLine(x1 / 1000, y2 / 1000, 0, x1 / 1000, y1 / 1000, 0));
                 // Set construction if needed
                 if (args.construction) {
-                    lines.forEach(line => {
+                    lines.forEach((line) => {
                         if (line)
                             line.ConstructionGeometry = true;
                     });
@@ -349,13 +394,13 @@ export const sketchTools = [
                     width,
                     height,
                     area: width * height,
-                    perimeter: 2 * (width + height)
+                    perimeter: 2 * (width + height),
                 };
             }
             catch (error) {
                 return `Failed to create rectangle: ${error}`;
             }
-        }
+        },
     },
     {
         name: 'sketch_polygon',
@@ -363,13 +408,13 @@ export const sketchTools = [
         inputSchema: z.object({
             center: z.object({
                 x: z.number().describe('Center X coordinate in mm'),
-                y: z.number().describe('Center Y coordinate in mm')
+                y: z.number().describe('Center Y coordinate in mm'),
             }),
             sides: z.number().int().min(3).max(100).describe('Number of sides'),
             radius: z.number().positive().describe('Circumscribed circle radius in mm'),
             rotation: z.number().default(0).describe('Rotation angle in degrees'),
             inscribed: z.boolean().default(false).describe('Use inscribed circle radius instead'),
-            construction: z.boolean().default(false).describe('Create as construction geometry')
+            construction: z.boolean().default(false).describe('Create as construction geometry'),
         }),
         handler: (args, swApi) => {
             try {
@@ -386,8 +431,8 @@ export const sketchTools = [
                 // Create polygon lines
                 const lines = [];
                 for (let i = 0; i < args.sides; i++) {
-                    const angle1 = startAngle + (i * angleStep);
-                    const angle2 = startAngle + ((i + 1) * angleStep);
+                    const angle1 = startAngle + i * angleStep;
+                    const angle2 = startAngle + (i + 1) * angleStep;
                     const x1 = args.center.x + radius * Math.cos(angle1);
                     const y1 = args.center.y + radius * Math.sin(angle1);
                     const x2 = args.center.x + radius * Math.cos(angle2);
@@ -410,13 +455,13 @@ export const sketchTools = [
                     radius,
                     sideLength,
                     area,
-                    perimeter
+                    perimeter,
                 };
             }
             catch (error) {
                 return `Failed to create polygon: ${error}`;
             }
-        }
+        },
     },
     // ============================================
     // SKETCH GEOMETRY - SPLINES & CURVES
@@ -425,13 +470,16 @@ export const sketchTools = [
         name: 'sketch_spline',
         description: 'Draw a spline through points in the active sketch',
         inputSchema: z.object({
-            points: z.array(z.object({
+            points: z
+                .array(z.object({
                 x: z.number().describe('X coordinate in mm'),
                 y: z.number().describe('Y coordinate in mm'),
-                z: z.number().default(0).describe('Z coordinate in mm (for 3D sketches)')
-            })).min(2).describe('Array of points for the spline'),
+                z: z.number().default(0).describe('Z coordinate in mm (for 3D sketches)'),
+            }))
+                .min(2)
+                .describe('Array of points for the spline'),
             closed: z.boolean().default(false).describe('Close the spline'),
-            construction: z.boolean().default(false).describe('Create as construction geometry')
+            construction: z.boolean().default(false).describe('Create as construction geometry'),
         }),
         handler: (args, swApi) => {
             try {
@@ -464,13 +512,13 @@ export const sketchTools = [
                     message: `Spline created through ${args.points.length} points`,
                     pointCount: args.points.length,
                     approximateLength: length,
-                    closed: args.closed
+                    closed: args.closed,
                 };
             }
             catch (error) {
                 return `Failed to create spline: ${error}`;
             }
-        }
+        },
     },
     {
         name: 'sketch_ellipse',
@@ -478,14 +526,14 @@ export const sketchTools = [
         inputSchema: z.object({
             center: z.object({
                 x: z.number().describe('Center X coordinate in mm'),
-                y: z.number().describe('Center Y coordinate in mm')
+                y: z.number().describe('Center Y coordinate in mm'),
             }),
             majorAxis: z.object({
                 length: z.number().positive().describe('Major axis length in mm'),
-                angle: z.number().default(0).describe('Major axis angle in degrees')
+                angle: z.number().default(0).describe('Major axis angle in degrees'),
             }),
             minorAxis: z.number().positive().describe('Minor axis length in mm'),
-            construction: z.boolean().default(false).describe('Create as construction geometry')
+            construction: z.boolean().default(false).describe('Create as construction geometry'),
         }),
         handler: (args, swApi) => {
             try {
@@ -496,8 +544,8 @@ export const sketchTools = [
                 // Calculate major axis endpoints
                 const major1X = args.center.x + (args.majorAxis.length / 2) * Math.cos(angleRad);
                 const major1Y = args.center.y + (args.majorAxis.length / 2) * Math.sin(angleRad);
-                const major2X = args.center.x - (args.majorAxis.length / 2) * Math.cos(angleRad);
-                const major2Y = args.center.y - (args.majorAxis.length / 2) * Math.sin(angleRad);
+                const _major2X = args.center.x - (args.majorAxis.length / 2) * Math.cos(angleRad);
+                const _major2Y = args.center.y - (args.majorAxis.length / 2) * Math.sin(angleRad);
                 // Calculate minor axis point
                 const minorX = args.center.x + (args.minorAxis / 2) * Math.cos(angleRad + Math.PI / 2);
                 const minorY = args.center.y + (args.minorAxis / 2) * Math.sin(angleRad + Math.PI / 2);
@@ -514,7 +562,7 @@ export const sketchTools = [
                 const b = args.minorAxis / 2;
                 const area = Math.PI * a * b;
                 // Approximate perimeter using Ramanujan's formula
-                const h = Math.pow((a - b), 2) / Math.pow((a + b), 2);
+                const h = (a - b) ** 2 / (a + b) ** 2;
                 const perimeter = Math.PI * (a + b) * (1 + (3 * h) / (10 + Math.sqrt(4 - 3 * h)));
                 return {
                     success: true,
@@ -522,13 +570,13 @@ export const sketchTools = [
                     majorAxis: args.majorAxis.length,
                     minorAxis: args.minorAxis,
                     area,
-                    perimeter
+                    perimeter,
                 };
             }
             catch (error) {
                 return `Failed to create ellipse: ${error}`;
             }
-        }
+        },
     },
     // ============================================
     // SKETCH CONSTRAINTS
@@ -537,14 +585,25 @@ export const sketchTools = [
         name: 'add_sketch_constraint',
         description: 'Add constraints between sketch entities',
         inputSchema: z.object({
-            type: z.enum([
-                'coincident', 'parallel', 'perpendicular', 'tangent',
-                'concentric', 'horizontal', 'vertical', 'equal',
-                'symmetric', 'colinear', 'midpoint', 'fix'
-            ]).describe('Type of constraint to add'),
+            type: z
+                .enum([
+                'coincident',
+                'parallel',
+                'perpendicular',
+                'tangent',
+                'concentric',
+                'horizontal',
+                'vertical',
+                'equal',
+                'symmetric',
+                'colinear',
+                'midpoint',
+                'fix',
+            ])
+                .describe('Type of constraint to add'),
             entity1: z.string().describe('First entity selection'),
             entity2: z.string().optional().describe('Second entity selection (if required)'),
-            entity3: z.string().optional().describe('Third entity selection (for symmetric constraint)')
+            entity3: z.string().optional().describe('Third entity selection (for symmetric constraint)'),
         }),
         handler: (args, swApi) => {
             try {
@@ -553,28 +612,28 @@ export const sketchTools = [
                     throw new Error('No active model');
                 // Map constraint types to SolidWorks constants
                 const constraintMap = {
-                    'coincident': 0,
-                    'parallel': 1,
-                    'perpendicular': 2,
-                    'tangent': 3,
-                    'concentric': 4,
-                    'horizontal': 5,
-                    'vertical': 6,
-                    'equal': 7,
-                    'symmetric': 8,
-                    'colinear': 9,
-                    'midpoint': 10,
-                    'fix': 11
+                    coincident: 0,
+                    parallel: 1,
+                    perpendicular: 2,
+                    tangent: 3,
+                    concentric: 4,
+                    horizontal: 5,
+                    vertical: 6,
+                    equal: 7,
+                    symmetric: 8,
+                    colinear: 9,
+                    midpoint: 10,
+                    fix: 11,
                 };
                 const constraintType = constraintMap[args.type];
                 // Select entities
                 model.ClearSelection2(true);
-                model.SelectByID2(args.entity1, 'SKETCHSEGMENT', 0, 0, 0, false, 0, null, 0);
+                model.Extension.SelectByID2(args.entity1, 'SKETCHSEGMENT', 0, 0, 0, false, 0, undefined, 0);
                 if (args.entity2) {
-                    model.SelectByID2(args.entity2, 'SKETCHSEGMENT', 0, 0, 0, true, 0, null, 0);
+                    model.Extension.SelectByID2(args.entity2, 'SKETCHSEGMENT', 0, 0, 0, true, 0, undefined, 0);
                 }
                 if (args.entity3) {
-                    model.SelectByID2(args.entity3, 'SKETCHSEGMENT', 0, 0, 0, true, 0, null, 0);
+                    model.Extension.SelectByID2(args.entity3, 'SKETCHSEGMENT', 0, 0, 0, true, 0, undefined, 0);
                 }
                 // Add constraint
                 const success = model.SketchManager.AddConstraint(constraintType);
@@ -583,13 +642,13 @@ export const sketchTools = [
                 return {
                     success: true,
                     message: `${args.type} constraint added`,
-                    type: args.type
+                    type: args.type,
                 };
             }
             catch (error) {
                 return `Failed to add constraint: ${error}`;
             }
-        }
+        },
     },
     // ============================================
     // SKETCH DIMENSIONS
@@ -601,10 +660,13 @@ export const sketchTools = [
             type: z.enum(['linear', 'angular', 'radial', 'diameter']).describe('Type of dimension'),
             entity: z.string().describe('Entity to dimension'),
             value: z.number().describe('Dimension value in mm or degrees'),
-            position: z.object({
+            position: z
+                .object({
                 x: z.number().describe('Text position X in mm'),
-                y: z.number().describe('Text position Y in mm')
-            }).optional().describe('Text position')
+                y: z.number().describe('Text position Y in mm'),
+            })
+                .optional()
+                .describe('Text position'),
         }),
         handler: (args, swApi) => {
             try {
@@ -613,7 +675,7 @@ export const sketchTools = [
                     throw new Error('No active model');
                 // Select entity
                 model.ClearSelection2(true);
-                model.SelectByID2(args.entity, 'SKETCHSEGMENT', 0, 0, 0, false, 0, null, 0);
+                model.Extension.SelectByID2(args.entity, 'SKETCHSEGMENT', 0, 0, 0, false, 0, undefined, 0);
                 // Add dimension
                 const textX = args.position?.x || 0;
                 const textY = args.position?.y || 0;
@@ -635,20 +697,21 @@ export const sketchTools = [
                 if (!dimension)
                     throw new Error('Failed to add dimension');
                 // Set dimension value
-                dimension.SystemValue = args.type === 'angular'
-                    ? (args.value * Math.PI / 180) // Convert degrees to radians
-                    : (args.value / 1000); // Convert mm to meters
+                dimension.SystemValue =
+                    args.type === 'angular'
+                        ? (args.value * Math.PI) / 180 // Convert degrees to radians
+                        : args.value / 1000; // Convert mm to meters
                 return {
                     success: true,
                     message: `${args.type} dimension added with value ${args.value}${args.type === 'angular' ? '°' : 'mm'}`,
                     type: args.type,
-                    value: args.value
+                    value: args.value,
                 };
             }
             catch (error) {
                 return `Failed to add dimension: ${error}`;
             }
-        }
+        },
     },
     // ============================================
     // SKETCH PATTERNS
@@ -662,14 +725,17 @@ export const sketchTools = [
                 x: z.number().describe('Direction vector X'),
                 y: z.number().describe('Direction vector Y'),
                 count: z.number().int().min(2).describe('Number of instances'),
-                spacing: z.number().positive().describe('Spacing in mm')
+                spacing: z.number().positive().describe('Spacing in mm'),
             }),
-            direction2: z.object({
+            direction2: z
+                .object({
                 x: z.number().describe('Direction vector X'),
                 y: z.number().describe('Direction vector Y'),
                 count: z.number().int().min(2).describe('Number of instances'),
-                spacing: z.number().positive().describe('Spacing in mm')
-            }).optional().describe('Second direction for 2D pattern')
+                spacing: z.number().positive().describe('Spacing in mm'),
+            })
+                .optional()
+                .describe('Second direction for 2D pattern'),
         }),
         handler: (args, swApi) => {
             try {
@@ -679,7 +745,7 @@ export const sketchTools = [
                 // Select entities to pattern
                 model.ClearSelection2(true);
                 args.entities.forEach((entity) => {
-                    model.SelectByID2(entity, 'SKETCHSEGMENT', 0, 0, 0, true, 0, null, 0);
+                    model.Extension.SelectByID2(entity, 'SKETCHSEGMENT', 0, 0, 0, true, 0, undefined, 0);
                 });
                 // Create pattern
                 const totalInstances = args.direction1.count * (args.direction2?.count || 1);
@@ -689,13 +755,13 @@ export const sketchTools = [
                     message: `Linear pattern created with ${totalInstances} instances`,
                     direction1Count: args.direction1.count,
                     direction2Count: args.direction2?.count || 1,
-                    totalInstances
+                    totalInstances,
                 };
             }
             catch (error) {
                 return `Failed to create linear pattern: ${error}`;
             }
-        }
+        },
     },
     {
         name: 'sketch_circular_pattern',
@@ -704,11 +770,11 @@ export const sketchTools = [
             entities: z.array(z.string()).describe('Entities to pattern'),
             center: z.object({
                 x: z.number().describe('Center X coordinate in mm'),
-                y: z.number().describe('Center Y coordinate in mm')
+                y: z.number().describe('Center Y coordinate in mm'),
             }),
             count: z.number().int().min(2).describe('Number of instances'),
             angle: z.number().default(360).describe('Total angle in degrees'),
-            equalSpacing: z.boolean().default(true).describe('Equal spacing between instances')
+            equalSpacing: z.boolean().default(true).describe('Equal spacing between instances'),
         }),
         handler: (args, swApi) => {
             try {
@@ -718,7 +784,7 @@ export const sketchTools = [
                 // Select entities to pattern
                 model.ClearSelection2(true);
                 args.entities.forEach((entity) => {
-                    model.SelectByID2(entity, 'SKETCHSEGMENT', 0, 0, 0, true, 0, null, 0);
+                    model.Extension.SelectByID2(entity, 'SKETCHSEGMENT', 0, 0, 0, true, 0, undefined, 0);
                 });
                 // Calculate angular spacing
                 const angleStep = args.angle / (args.equalSpacing ? args.count : args.count - 1);
@@ -728,13 +794,13 @@ export const sketchTools = [
                     message: `Circular pattern created with ${args.count} instances`,
                     count: args.count,
                     totalAngle: args.angle,
-                    anglePerInstance: angleStep
+                    anglePerInstance: angleStep,
                 };
             }
             catch (error) {
                 return `Failed to create circular pattern: ${error}`;
             }
-        }
+        },
     },
     // ============================================
     // SKETCH TRANSFORMATIONS
@@ -745,7 +811,7 @@ export const sketchTools = [
         inputSchema: z.object({
             entities: z.array(z.string()).describe('Entities to mirror'),
             mirrorLine: z.string().describe('Mirror line (centerline or construction line)'),
-            copy: z.boolean().default(true).describe('Keep original entities')
+            copy: z.boolean().default(true).describe('Keep original entities'),
         }),
         handler: (args, swApi) => {
             try {
@@ -755,23 +821,23 @@ export const sketchTools = [
                 // Select entities to mirror
                 model.ClearSelection2(true);
                 args.entities.forEach((entity) => {
-                    model.SelectByID2(entity, 'SKETCHSEGMENT', 0, 0, 0, true, 0, null, 0);
+                    model.Extension.SelectByID2(entity, 'SKETCHSEGMENT', 0, 0, 0, true, 0, undefined, 0);
                 });
                 // Select mirror line
-                model.SelectByID2(args.mirrorLine, 'SKETCHSEGMENT', 0, 0, 0, true, 1, null, 0);
+                model.Extension.SelectByID2(args.mirrorLine, 'SKETCHSEGMENT', 0, 0, 0, true, 1, undefined, 0);
                 // Mirror entities
                 model.SketchManager.MirrorSketch();
                 return {
                     success: true,
                     message: `Mirrored ${args.entities.length} entities`,
                     entityCount: args.entities.length,
-                    keepOriginal: args.copy
+                    keepOriginal: args.copy,
                 };
             }
             catch (error) {
                 return `Failed to mirror entities: ${error}`;
             }
-        }
+        },
     },
     {
         name: 'sketch_offset',
@@ -781,7 +847,7 @@ export const sketchTools = [
             distance: z.number().describe('Offset distance in mm (positive = outward)'),
             side: z.enum(['both', 'left', 'right']).default('both').describe('Offset side'),
             corner: z.enum(['sharp', 'round', 'natural']).default('natural').describe('Corner treatment'),
-            cap: z.boolean().default(true).describe('Cap ends for open curves')
+            cap: z.boolean().default(true).describe('Cap ends for open curves'),
         }),
         handler: (args, swApi) => {
             try {
@@ -791,10 +857,10 @@ export const sketchTools = [
                 // Select entities to offset
                 model.ClearSelection2(true);
                 args.entities.forEach((entity) => {
-                    model.SelectByID2(entity, 'SKETCHSEGMENT', 0, 0, 0, true, 0, null, 0);
+                    model.Extension.SelectByID2(entity, 'SKETCHSEGMENT', 0, 0, 0, true, 0, undefined, 0);
                 });
                 // Create offset
-                const sideValue = args.side === 'both' ? 0 : (args.side === 'left' ? 1 : 2);
+                const sideValue = args.side === 'both' ? 0 : args.side === 'left' ? 1 : 2;
                 model.SketchManager.SketchOffset2(args.distance / 1000, // Convert to meters
                 sideValue, false, // Not chain
                 args.cap);
@@ -803,13 +869,13 @@ export const sketchTools = [
                     message: `Offset created at ${args.distance}mm`,
                     distance: args.distance,
                     side: args.side,
-                    corner: args.corner
+                    corner: args.corner,
                 };
             }
             catch (error) {
                 return `Failed to create offset: ${error}`;
             }
-        }
-    }
+        },
+    },
 ];
 //# sourceMappingURL=sketch.js.map