Make naming more consistent with engine

src/lib/commandBarConfigs/modelingCommandConfig.ts

@@ -43,8 +43,8 @@ export type ModelingCommandSchema = {
     distance: KclCommandValue
   }
   Sweep: {
-    path: Selections
-    profile: Selections
+    target: Selections
+    trajectory: Selections
   }
   Loft: {
     selection: Selections
@@ -311,7 +311,7 @@ export const modelingMachineCommandConfig: StateMachineCommandSetConfig<
     status: 'development',
     needsReview: false,
     args: {
-      profile: {
+      target: {
         inputType: 'selection',
         selectionTypes: ['solid2D'],
         required: true,
@@ -320,7 +320,7 @@ export const modelingMachineCommandConfig: StateMachineCommandSetConfig<
         warningMessage:
           'The sweep workflow is new and under tested. Please break it and report issues.',
       },
-      path: {
+      trajectory: {
         inputType: 'selection',
         selectionTypes: ['segment', 'path'],
         required: true,

src/lib/commandBarConfigs/validators.ts

@@ -213,15 +213,15 @@ export const sweepValidator = async ({
   data,
 }: {
   context: CommandBarContext
-  data: { path: Selections }
+  data: { trajectory: Selections }
 }): Promise<boolean | string> => {
-  if (!isSelections(data.path)) {
+  if (!isSelections(data.trajectory)) {
     console.log('Unable to sweep, selections are missing')
     return 'Unable to sweep, selections are missing'
   }
 
   // Retrieve the parent path from the segment selection directly
-  const trajectoryArtifact = data.path.graphSelections[0].artifact
+  const trajectoryArtifact = data.trajectory.graphSelections[0].artifact
   if (!trajectoryArtifact) {
     return "Unable to sweep, couldn't find the trajectory artifact"
   }
@@ -231,15 +231,15 @@ export const sweepValidator = async ({
   const trajectory = trajectoryArtifact.pathId
 
   // Get the former arg in the command bar flow, and retrieve the path from the solid2d directly
-  const profileArg = context.argumentsToSubmit['profile'] as Selections
-  const profileArtifact = profileArg.graphSelections[0].artifact
-  if (!profileArtifact) {
+  const targetArg = context.argumentsToSubmit['target'] as Selections
+  const targetArtifact = targetArg.graphSelections[0].artifact
+  if (!targetArtifact) {
     return "Unable to sweep, couldn't find the profile artifact"
   }
-  if (profileArtifact.type !== 'solid2D') {
+  if (targetArtifact.type !== 'solid2D') {
     return "Unable to sweep, couldn't find the target from a non-solid2d selection"
   }
-  const target = profileArtifact.pathId
+  const target = targetArtifact.pathId
 
   const sweepCommand = async () => {
     // TODO: second look on defaults here

src/machines/modelingMachine.ts

@@ -1561,40 +1561,40 @@ export const modelingMachine = setup({
         if (!input) return new Error('No input provided')
         // Extract inputs
         const ast = kclManager.ast
-        const { profile, path } = input
+        const { target, trajectory } = input
 
         // Find the profile declaration
-        const profileNodePath = getNodePathFromSourceRange(
+        const targetNodePath = getNodePathFromSourceRange(
           ast,
-          profile.graphSelections[0].codeRef.range
+          target.graphSelections[0].codeRef.range
         )
-        const profileNode = getNodeFromPath<VariableDeclarator>(
+        const targetNode = getNodeFromPath<VariableDeclarator>(
           ast,
-          profileNodePath,
+          targetNodePath,
           'VariableDeclarator'
         )
-        if (err(profileNode)) {
+        if (err(targetNode)) {
           return new Error("Couldn't parse profile selection")
         }
-        const profileDeclarator = profileNode.node
+        const targetDeclarator = targetNode.node
 
         // Find the path declaration
-        const pathNodePath = getNodePathFromSourceRange(
+        const trajectoryNodePath = getNodePathFromSourceRange(
           ast,
-          path.graphSelections[0].codeRef.range
+          trajectory.graphSelections[0].codeRef.range
         )
-        const pathNode = getNodeFromPath<VariableDeclarator>(
+        const trajectoryNode = getNodeFromPath<VariableDeclarator>(
           ast,
-          pathNodePath,
+          trajectoryNodePath,
           'VariableDeclarator'
         )
-        if (err(pathNode)) {
+        if (err(trajectoryNode)) {
           return new Error("Couldn't parse path selection")
         }
-        const pathDeclarator = pathNode.node
+        const trajectoryDeclarator = trajectoryNode.node
 
         // Perform the sweep
-        const sweepRes = addSweep(ast, profileDeclarator, pathDeclarator)
+        const sweepRes = addSweep(ast, targetDeclarator, trajectoryDeclarator)
         const updateAstResult = await kclManager.updateAst(
           sweepRes.modifiedAst,
           true,