Add skater profiles data handling to translate2js.py; update prompt construction for JSON integration

Author: nazroll

src/wzrdbrain/wzrdbrain.js

@@ -3,60 +3,107 @@
  * @license Apache-2.0
  */
 
-// Data from tricks.json, embedded directly as constants
-const DIRECTIONS = ["front", "back"];
-const STANCES = ["open", "closed"];
-const MOVES = [
-  "predator", "predator one", "parallel", "tree", "gazelle", "gazelle s",
-  "lion", "lion s", "toe press", "heel press", "toe roll", "heel roll",
-  "360", "180", "540", "parallel slide", "soul slide", "acid slide",
-  "mizu slide", "star slide", "fast slide", "back slide", "stunami",
-  "ufo swivel", "toe pivot", "heel pivot"
-];
+// Data from tricks.json, embedded directly as a constant
+const TRICK_DATA = {
+  "DIRECTIONS": ["front", "back"],
+  "STANCES": ["open", "closed"],
+  "MOVES": [
+    "predator", "predator one", "parallel", "tree", "gazelle", "gazelle s",
+    "lion", "lion s", "toe press", "heel press", "toe roll", "heel roll",
+    "360", "180", "540", "parallel slide", "soul slide", "acid slide",
+    "mizu slide", "star slide", "fast slide", "back slide", "stunami",
+    "ufo swivel", "toe pivot", "heel pivot"
+  ],
+  "RULES": {
+    "ONLY_FIRST": ["predator", "predator one", "parallel"],
+    "USE_FAKIE": [
+      "toe press", "toe roll", "heel press", "heel roll", "360", "180", "540",
+      "parallel slide", "soul slide", "acid slide", "mizu slide", "star slide",
+      "fast slide", "back slide"
+    ],
+    "EXCLUDE_STANCE_BASE": ["predator", "predator one"],
+    "ROTATING_MOVES": ["gazelle", "lion", "180", "540", "stunami", "ufo swivel"]
+  }
+};
+
+// Data from skater_profiles.json, embedded directly as a constant
+const SKATER_PROFILES = [{
+  "name": "Flow Purist",
+  "traits": ["Process", "Intrinsic", "Adaptive", "Solo", "Risk-averse", "Flow", "Subtle", "Flatland"]
+}, {
+  "name": "Spot Hunter",
+  "traits": ["Process", "Intrinsic", "Adaptive", "Solo", "Flow", "Risk-tolerant", "Physical", "3D"]
+}, {
+  "name": "Precision Builder",
+  "traits": ["Process", "Intrinsic", "Solo", "Risk-averse", "Subtle", "Flatland", "Structured", "Trick"]
+}, {
+  "name": "Creative Connector",
+  "traits": ["Process", "Intrinsic", "Adaptive", "Flow", "Flatland", "Risk-tolerant", "Physical", "3D", "Social"]
+}, {
+  "name": "Social Flow Rider",
+  "traits": ["Process", "Intrinsic", "Adaptive", "Risk-averse", "Flow", "Subtle", "Flatland", "Social"]
+}, {
+  "name": "Performer",
+  "traits": ["Process", "Adaptive", "Flow", "Flatland", "Risk-tolerant", "Physical", "3D", "Social", "Extrinsic"]
+}, {
+  "name": "Urban Technician",
+  "traits": ["Intrinsic", "Solo", "Subtle", "Risk-tolerant", "3D", "Structured", "Trick", "Result"]
+}, {
+  "name": "Goal Chaser",
+  "traits": ["Intrinsic", "Solo", "Risk-averse", "Subtle", "Flatland", "Structured", "Trick", "Result"]
+}, {
+  "name": "Gearhead",
+  "traits": ["Process", "Intrinsic", "Risk-averse", "Subtle", "Flatland", "3D", "Structured", "Trick", "Social"]
+}, {
+  "name": "Competitive Stylist",
+  "traits": ["Adaptive", "Flow", "Flatland", "Risk-tolerant", "Physical", "3D", "Social", "Extrinsic", "Result"]
+}, ];
+
+
+const DIRECTIONS = TRICK_DATA.DIRECTIONS;
+const STANCES = TRICK_DATA.STANCES;
+const MOVES = TRICK_DATA.MOVES;
 
 // Rules converted to Set for efficient lookups, mirroring Python's set usage
-/** @type {Set<string>} */
-const onlyFirst = new Set(["predator", "predator one", "parallel"]);
-/** @type {Set<string>} */
-const useFakie = new Set([
-  "toe press", "toe roll", "heel press", "heel roll", "360", "180", "540",
-  "parallel slide", "soul slide", "acid slide", "mizu slide", "star slide",
-  "fast slide", "back slide"
-]);
-/** @type {Set<string>} */
-const excludeStanceBase = new Set(["predator", "predator one"]);
-/** @type {Set<string>} */
-const rotatingMoves = new Set(["gazelle", "lion", "180", "540", "stunami", "ufo swivel"]);
-
-
-// Derived rules, mirroring Python's `exclude_stance` and `SUBSEQUENT_MOVES`
-/**
- * A set of moves that exclude an automatically determined stance.
- * This is the union of EXCLUDE_STANCE_BASE and USE_FAKIE from the JSON rules,
- * directly translating Python's `exclude_stance_base.union(use_fakie)`.
- * @type {Set<string>}
- */
-const excludeStance = new Set([...excludeStanceBase, ...useFakie]);
+const onlyFirst = new Set(TRICK_DATA.RULES.ONLY_FIRST);
+const useFakie = new Set(TRICK_DATA.RULES.USE_FAKIE);
+const rotatingMoves = new Set(TRICK_DATA.RULES.ROTATING_MOVES);
+const excludeStanceBase = new Set(TRICK_DATA.RULES.EXCLUDE_STANCE_BASE);
 
-/**
- * An array of moves that are valid for subsequent tricks (i.e., not "ONLY_FIRST").
- * This is pre-calculated for efficiency, directly translating Python's `set(MOVES) - only_first`.
- * @type {string[]}
- */
+// Derived rules, mirroring Python's logic
+const excludeStance = new Set([...excludeStanceBase, ...useFakie]);
 const subsequentMoves = MOVES.filter(move => !onlyFirst.has(move));
 
 
 /**
  * @typedef {'front' | 'back'} Direction
  * @typedef {'open' | 'closed'} Stance
  * @typedef {string} Move
+ * @typedef {object} TrickObject
+ * @property {Direction | null} direction
+ * @property {Stance | null} stance
+ * @property {Move | null} move
+ * @property {Direction | null} enterIntoTrick
+ * @property {Direction | null} exitFromTrick
+ * @property {string} name
+ * @typedef {object} SkaterProfile
+ * @property {string} name
+ * @property {string[]} traits
+ * @typedef {object} ProfileMatch
+ * @property {string} name
+ * @property {number} score
+ * @property {string[]} matched_traits
+ * @typedef {object} ClarifyingQuestion
+ * @property {string} question
+ * @property {Object<string, string[]>} choices
  */
 
+
 /**
  * Represents a single trick with its direction, stance, and move.
  * Automatically generates random values for unspecified properties
  * and adjusts properties like exit direction based on the move,
- * directly translating the Python `Trick` dataclass logic, especially its `__post_init__` method.
+ * directly translating the Python `Trick` dataclass logic.
  */
 export class Trick {
   /** @type {Direction | null} */
@@ -89,7 +136,7 @@ export class Trick {
     enterIntoTrick = null,
     exitFromTrick = null,
   } = {}) {
-    // 1. Input validation, mirroring Python's `__post_init__` validation
+    // 1. Input validation
     if (direction !== null && !DIRECTIONS.includes(direction)) {
       throw new Error(`Invalid direction: '${direction}'. Must be one of ${DIRECTIONS.join(', ')}`);
     }
@@ -107,7 +154,7 @@ export class Trick {
     this.enterIntoTrick = enterIntoTrick;
     this.exitFromTrick = exitFromTrick;
 
-    // 3. Generate default values if not provided, mirroring Python's `__post_init__`
+    // 3. Generate default values if not provided
     if (this.direction === null) {
       this.direction = DIRECTIONS[Math.floor(Math.random() * DIRECTIONS.length)];
     }
@@ -142,14 +189,12 @@ export class Trick {
   /**
    * Returns a human-readable string representation of the trick,
    * directly translating the Python `__str__` method.
-   * This handles "fakie" / "forward" display names for relevant moves.
    * @returns {string} The formatted name of the trick.
    */
   getName() {
     const parts = [];
     let displayDirection = this.direction;
 
-    // Handle fakie/forward display name, mirroring Python's `__str__`
     if (this.move !== null && useFakie.has(this.move)) {
       if (this.direction === "back") {
         displayDirection = "fakie";
@@ -173,9 +218,8 @@ export class Trick {
 
   /**
    * Returns a plain JavaScript object representation of the trick,
-   * including all its properties and its full display name,
    * directly translating the Python `to_dict` method.
-   * @returns {object} An object containing the trick's properties and its name.
+   * @returns {TrickObject} An object containing the trick's properties and its name.
    */
   toObject() {
     return {
@@ -190,46 +234,39 @@ export class Trick {
 }
 
 /**
- * Generates a combination (combo) of tricks,
- * directly translating the Python `generate_combo` function.
- *
- * @param {number | null} [numTricks=null] - The number of tricks to generate in the combo.
- *   If null, a random number between 2 and 5 (inclusive) will be chosen, mirroring Python's `random.randint(2, 5)`.
- * @returns {object[]} A list of trick objects, each with their properties and a 'name' field.
- *   Returns an empty array if numTricks is 0 or less.
+ * Generates a combination (combo) of tricks.
+ * @param {number | null} [numTricks=null] - The number of tricks to generate.
+ *   If null, a random number between 2 and 5 will be chosen.
+ * @returns {TrickObject[]} An array of trick objects.
  */
 export function generateCombo(numTricks = null) {
-  // Mirroring Python's default num_of_tricks = random.randint(2, 5)
-  if (numTricks === null) {
-    numTricks = Math.floor(Math.random() * (5 - 2 + 1)) + 2;
+  let count = numTricks;
+  if (count === null) {
+    count = Math.floor(Math.random() * (5 - 2 + 1)) + 2;
   }
 
-  if (numTricks <= 0) {
+  if (count <= 0) {
     return [];
   }
 
-  /** @type {Trick[]} */
   const trickObjects = [];
-  /** @type {Trick | null} */
   let previousTrick = null;
 
-  for (let i = 0; i < numTricks; i++) {
-    /** @type {Trick} */
+  for (let i = 0; i < count; i++) {
     let newTrick;
 
     if (i === 0) {
-      // First trick: choose from all moves, mirroring Python's logic
+      // First trick: choose from all moves
       const move = MOVES[Math.floor(Math.random() * MOVES.length)];
-      newTrick = new Trick({ move });
+      newTrick = new Trick({
+        move
+      });
     } else {
-      // Subsequent tricks: respect exit direction of previous trick
-      // and choose from moves not marked as ONLY_FIRST.
+      // Subsequent tricks: respect exit direction and choose from allowed moves
       if (!previousTrick) {
-        // This case should ideally not be reached, mirroring Python's `assert`
         throw new Error("Previous trick is undefined for subsequent trick generation.");
       }
       const requiredDirection = previousTrick.exitFromTrick;
-      // Choose from the pre-filtered array of subsequent moves for efficiency
       const move = subsequentMoves[Math.floor(Math.random() * subsequentMoves.length)];
       newTrick = new Trick({
         direction: requiredDirection,
@@ -241,6 +278,118 @@ export function generateCombo(numTricks = null) {
     previousTrick = newTrick;
   }
 
-  // Mirroring Python's `[trick.to_dict() for trick in trick_objects]`
   return trickObjects.map(trick => trick.toObject());
+}
+
+/**
+ * Finds and ranks skater profiles based on user-provided traits.
+ * @param {string[]} userTraits - A list of strings representing the user's skating style.
+ * @returns {ProfileMatch[]} A list of profile match objects, sorted by score descending.
+ */
+export function findProfileMatches(userTraits) {
+  if (!SKATER_PROFILES || SKATER_PROFILES.length === 0) {
+    return [];
+  }
+
+  const normalizedUserTraits = new Set(userTraits.map(t => t.toLowerCase()));
+
+  const matches = SKATER_PROFILES.map(profile => {
+    const profileTraitsLower = new Set(profile.traits.map(t => t.toLowerCase()));
+    const matchedSet = new Set([...normalizedUserTraits].filter(trait => profileTraitsLower.has(trait)));
+    const score = matchedSet.size;
+
+    return {
+      name: profile.name,
+      score: score,
+      matched_traits: Array.from(matchedSet).sort(),
+    };
+  });
+
+  return matches.sort((a, b) => b.score - a.score);
+}
+
+/**
+ * Finds a single skater profile by its name (case-insensitive).
+ * @param {string} name - The name of the profile to find.
+ * @returns {SkaterProfile | undefined} The profile object if found, otherwise undefined.
+ */
+export function getProfileByName(name) {
+  return SKATER_PROFILES.find(profile => profile.name.toLowerCase() === name.toLowerCase());
+}
+
+/**
+ * Gets a unique, sorted list of all traits available across all profiles.
+ * @returns {string[]} A sorted list of unique trait strings.
+ */
+export function getAllTraits() {
+  const allTraits = new Set(SKATER_PROFILES.flatMap(p => p.traits));
+  return Array.from(allTraits).sort();
+}
+
+/**
+ * Generates a clarifying question to differentiate between closely matched profiles.
+ * @param {ProfileMatch[]} topProfiles - A list of the top profile matches from `findProfileMatches`.
+ * @returns {ClarifyingQuestion | null} An object with a question and choices, or null if a question cannot be generated.
+ */
+export function generateClarifyingQuestion(topProfiles) {
+  if (!topProfiles || topProfiles.length < 2) {
+    return null;
+  }
+
+  const OPPOSING_TRAITS_MAP = {
+    "Solo": "Social",
+    "Social": "Solo",
+    "Risk-averse": "Risk-tolerant",
+    "Risk-tolerant": "Risk-averse",
+    "Flatland": "3D",
+    "3D": "Flatland",
+    "Subtle": "Physical",
+    "Physical": "Subtle",
+    "Structured": "Adaptive",
+    "Adaptive": "Structured",
+    "Process": "Result",
+    "Result": "Process"
+  };
+
+  const profileA_full = getProfileByName(topProfiles[0].name);
+  const profileB_full = getProfileByName(topProfiles[1].name);
+
+  if (!profileA_full || !profileB_full) {
+    return null;
+  }
+
+  const traitsA = new Set(profileA_full.traits);
+  const traitsB = new Set(profileB_full.traits);
+
+  const uniqueToA = new Set([...traitsA].filter(x => !traitsB.has(x)));
+  const uniqueToB = new Set([...traitsB].filter(x => !traitsA.has(x)));
+
+  // 1. Prioritize finding a clear opposing pair
+  for (const trait of uniqueToA) {
+    const opposite = OPPOSING_TRAITS_MAP[trait];
+    if (opposite && uniqueToB.has(opposite)) {
+      return {
+        question: `Which is more important to you: '${trait}' or '${opposite}'?`,
+        choices: {
+          [trait]: [trait],
+          [opposite]: [opposite],
+        },
+      };
+    }
+  }
+
+  // 2. If no direct opposites, use the most significant unique traits
+  if (uniqueToA.size > 0 && uniqueToB.size > 0) {
+    const traitA = [...uniqueToA][0];
+    const traitB = [...uniqueToB][0];
+    return {
+      question: `To help narrow it down, which sounds more like you: '${traitA}' or '${traitB}'?`,
+      choices: {
+        [traitA]: [traitA],
+        [traitB]: [traitB]
+      },
+    };
+  }
+
+  return null;
 }