@prorigo/protrak-forge 0.4.1 → 0.4.2

package/bin/protrak-forge.js

@@ -15672,6 +15672,14 @@ var LocalSchemaProvider = class {
   invalidateRules() {
     this._rules = null;
   }
+  /** Force a re-read of types on next access. */
+  invalidateTypes() {
+    this._types = null;
+  }
+  /** Force a re-read of attributes on next access. */
+  invalidateAttributes() {
+    this._attributes = null;
+  }
   // ── Public API ────────────────────────────────────────────────────────────
   listTypes() {
     return Object.entries(this.types).map(([name, typeData]) => ({
@@ -17948,7 +17956,7 @@ function getClient() {
 }
 
 // src/version.ts
-var PACKAGE_VERSION = "0.4.1";
+var PACKAGE_VERSION = "0.4.2";
 
 // src/tools/_schema-write-utils.ts
 var fs4 = __toESM(require("fs"));
@@ -22596,6 +22604,50 @@ var EXAMPLES = [
         }
       ]
     }
+  },
+  {
+    intent: "Current user's roles include 'Manager'. UserRoles context: attributeName is omitted entirely; Contains takes only firstValue.",
+    rule: {
+      name: "CurrentUserIsManager",
+      attributeFilterGroup: [
+        {
+          operator: "None",
+          attributeFilterConditions: [
+            {
+              attributeContext: "UserRoles",
+              condition: "Contains",
+              firstValue: { valueType: "Static", value: "Manager" },
+              operator: "None"
+            }
+          ]
+        }
+      ]
+    }
+  },
+  {
+    intent: "Visible when current user is the Creator OR has the 'Manager' role. Mixes UserRoles + Instance contexts in a single group joined by Or.",
+    rule: {
+      name: "VisibleToManagerOrCreator",
+      attributeFilterGroup: [
+        {
+          operator: "None",
+          attributeFilterConditions: [
+            {
+              attributeContext: "UserRoles",
+              condition: "Contains",
+              firstValue: { valueType: "Static", value: "Manager" },
+              operator: "Or"
+            },
+            {
+              attributeName: "Creator",
+              attributeContext: "Instance",
+              condition: "ContextUser",
+              operator: "None"
+            }
+          ]
+        }
+      ]
+    }
   }
 ];
 var DYNAMIC_VALUE_RULES = {
@@ -22709,7 +22761,7 @@ var CONDITION_INPUT_SCHEMA = {
     },
     attribute_name: {
       type: "string",
-      description: "PascalCase attribute name. Required for Instance and User contexts. Omit for UserRoles context (it evaluates the current user's roles)."
+      description: "PascalCase attribute name. Required for Instance and User contexts. OMIT this key entirely for UserRoles context (it evaluates the current user's roles). Do NOT send empty string '' \u2014 leave the key out."
     },
     condition: {
       type: "string",
@@ -22717,11 +22769,11 @@ var CONDITION_INPUT_SCHEMA = {
     },
     first_value: {
       ...VALUE_INPUT_SCHEMA,
-      description: "First value. Required when the condition takes a value; omit for IsEmpty/Today/ContextUser/etc."
+      description: "First value of the condition. Required for value-bearing conditions (Equals, Contains, GreaterThan, Between, In, etc.). OMIT this key entirely for valueless conditions: IsEmpty, IsNotEmpty, Today, LastOneWeek, LastOneMonth, LastOneYear, NextWeek, NextOneMonth, NextOneYear, ContextUser. Do NOT send `null` or `{value: ''}` \u2014 leave the key out of the JSON object."
     },
     second_value: {
       ...VALUE_INPUT_SCHEMA,
-      description: "Second value. Required only for 'Between' conditions."
+      description: "Second value. Only valid for 'Between'. OMIT this key entirely for every other condition (including Contains, Equals, In, IsEmpty, ContextUser, etc.). Do NOT send `null` or `{value: ''}` \u2014 leave the key out of the JSON object."
     },
     operator: {
       type: "string",
@@ -22777,6 +22829,49 @@ var TOOL_DEF29 = {
     required: ["name", "attribute_filter_groups"]
   }
 };
+function normalizeValue(v) {
+  if (v === void 0 || v === null) return void 0;
+  if (typeof v !== "object") return v;
+  const obj = v;
+  if (typeof obj["value"] === "string" && obj["value"].length === 0) return void 0;
+  return obj;
+}
+function normalizeCondition(rc) {
+  const attrName = rc["attribute_name"];
+  return {
+    attribute_context: rc["attribute_context"],
+    attribute_name: typeof attrName === "string" && attrName.length > 0 ? attrName : void 0,
+    condition: rc["condition"],
+    first_value: normalizeValue(rc["first_value"]),
+    second_value: normalizeValue(rc["second_value"]),
+    operator: rc["operator"]
+  };
+}
+function expectedConditionShape(cond) {
+  const shape = {
+    attribute_context: cond.attribute_context
+  };
+  if (cond.attribute_context !== "UserRoles") {
+    shape["attribute_name"] = cond.attribute_name ?? "<AttributeName>";
+  }
+  shape["condition"] = cond.condition;
+  if (RANGE_CONDITIONS.has(cond.condition)) {
+    shape["first_value"] = { value_type: "Static", value: "<from>" };
+    shape["second_value"] = { value_type: "Static", value: "<to>" };
+  } else if (!VALUE_LESS_CONDITIONS.has(cond.condition)) {
+    shape["first_value"] = { value_type: "Static", value: "<value>" };
+  }
+  shape["operator"] = cond.operator;
+  return shape;
+}
+function conditionShapeHints(cond) {
+  return {
+    expected_shape: expectedConditionShape(cond),
+    valueless_conditions: [...VALUE_LESS_CONDITIONS].sort(),
+    range_conditions: [...RANGE_CONDITIONS].sort(),
+    hint: 'Send the value-bearing keys ONLY when needed. To "omit" a key, leave it out of the JSON entirely \u2014 do not send null or { value: "" }.'
+  };
+}
 function validateValueShape(value, label) {
   if (value === void 0) return null;
   if (typeof value !== "object" || value === null) {
@@ -22805,36 +22900,42 @@ function validateDynamicValue(provider, value, label) {
 }
 function validateCondition(provider, cond, prefix) {
   if (!ATTRIBUTE_CONTEXTS.includes(cond.attribute_context)) {
-    return `${prefix}.attribute_context must be one of: ${ATTRIBUTE_CONTEXTS.join(", ")}.`;
+    return { error: `${prefix}.attribute_context must be one of: ${ATTRIBUTE_CONTEXTS.join(", ")}.` };
   }
   if (!GROUP_OPERATORS.includes(cond.operator)) {
-    return `${prefix}.operator must be one of: ${GROUP_OPERATORS.join(", ")}.`;
+    return { error: `${prefix}.operator must be one of: ${GROUP_OPERATORS.join(", ")}.` };
   }
   if (typeof cond.condition !== "string" || !cond.condition) {
-    return `${prefix}.condition is required.`;
+    return { error: `${prefix}.condition is required.` };
   }
   if (cond.attribute_context === "UserRoles") {
     if (cond.attribute_name) {
-      return `${prefix}.attribute_name must be omitted when attribute_context is 'UserRoles'.`;
+      return { error: `${prefix}.attribute_name must be omitted when attribute_context is 'UserRoles'.` };
     }
     if (!USER_ROLES_CONDITIONS.includes(cond.condition)) {
-      return `${prefix}.condition '${cond.condition}' is not valid for UserRoles context. Valid: ${USER_ROLES_CONDITIONS.join(", ")}.`;
+      return {
+        error: `${prefix}.condition '${cond.condition}' is not valid for UserRoles context. Valid: ${USER_ROLES_CONDITIONS.join(", ")}.`
+      };
     }
   } else {
     if (!cond.attribute_name) {
-      return `${prefix}.attribute_name is required for attribute_context='${cond.attribute_context}'.`;
+      return { error: `${prefix}.attribute_name is required for attribute_context='${cond.attribute_context}'.` };
     }
     if (!isPascalCase(cond.attribute_name)) {
-      return `${prefix}.${pascalCaseError("attribute_name", cond.attribute_name)}`;
+      return { error: `${prefix}.${pascalCaseError("attribute_name", cond.attribute_name)}` };
     }
     if (cond.attribute_context === "Instance") {
       const attrType = resolveInstanceAttributeType(provider, cond.attribute_name);
       if (!attrType) {
-        return `${prefix} references Instance attribute '${cond.attribute_name}' which does not exist in the workspace. Add the attribute (or use a basic attribute name like Name/State/Created/Creator) before generating this rule.`;
+        return {
+          error: `${prefix} references Instance attribute '${cond.attribute_name}' which does not exist in the workspace. Add the attribute (or use a basic attribute name like Name/State/Created/Creator) before generating this rule.`
+        };
       }
       const validConditions = CONDITIONS_BY_ATTR_TYPE[attrType] ?? CONDITIONS_BY_ATTR_TYPE["Text"];
       if (!validConditions.includes(cond.condition)) {
-        return `${prefix}.condition '${cond.condition}' is not valid for Instance attribute '${cond.attribute_name}' (type=${attrType}). Valid conditions: ${validConditions.join(", ")}.`;
+        return {
+          error: `${prefix}.condition '${cond.condition}' is not valid for Instance attribute '${cond.attribute_name}' (type=${attrType}). Valid conditions: ${validConditions.join(", ")}.`
+        };
       }
     } else {
       const acceptable = /* @__PURE__ */ new Set([
@@ -22845,7 +22946,9 @@ function validateCondition(provider, cond, prefix) {
         ...CONDITIONS_BY_ATTR_TYPE["Boolean"]
       ]);
       if (!acceptable.has(cond.condition)) {
-        return `${prefix}.condition '${cond.condition}' is not recognised for User-context conditions.`;
+        return {
+          error: `${prefix}.condition '${cond.condition}' is not recognised for User-context conditions.`
+        };
       }
     }
   }
@@ -22855,18 +22958,30 @@ function validateCondition(provider, cond, prefix) {
   const hasSecond = cond.second_value !== void 0;
   if (valueless) {
     if (hasFirst || hasSecond) {
-      return `${prefix}.condition '${cond.condition}' takes no value(s); remove first_value/second_value.`;
+      return {
+        error: `${prefix}.condition '${cond.condition}' takes no value(s); omit first_value and second_value entirely.`,
+        extras: conditionShapeHints(cond)
+      };
     }
   } else if (ranged) {
     if (!hasFirst || !hasSecond) {
-      return `${prefix}.condition '${cond.condition}' requires BOTH first_value and second_value.`;
+      return {
+        error: `${prefix}.condition '${cond.condition}' requires BOTH first_value and second_value.`,
+        extras: conditionShapeHints(cond)
+      };
     }
   } else {
     if (!hasFirst) {
-      return `${prefix}.condition '${cond.condition}' requires first_value.`;
+      return {
+        error: `${prefix}.condition '${cond.condition}' requires first_value.`,
+        extras: conditionShapeHints(cond)
+      };
     }
     if (hasSecond) {
-      return `${prefix}.condition '${cond.condition}' takes only first_value; remove second_value.`;
+      return {
+        error: `${prefix}.condition '${cond.condition}' takes only first_value; omit second_value entirely (do not send null or empty value).`,
+        extras: conditionShapeHints(cond)
+      };
     }
   }
   for (const [v, lbl] of [
@@ -22874,10 +22989,10 @@ function validateCondition(provider, cond, prefix) {
     [cond.second_value, `${prefix}.second_value`]
   ]) {
     const shapeErr = validateValueShape(v, lbl);
-    if (shapeErr) return shapeErr;
+    if (shapeErr) return { error: shapeErr };
     if (v) {
       const dynErr = validateDynamicValue(provider, v, lbl);
-      if (dynErr) return dynErr;
+      if (dynErr) return { error: dynErr };
     }
   }
   return null;
@@ -22936,16 +23051,9 @@ function handle29(provider, args) {
       if (typeof rc !== "object" || rc === null) {
         return errorResponse(`attribute_filter_groups[${gi}].conditions[${ci}] must be an object.`);
       }
-      const cond = {
-        attribute_context: rc["attribute_context"],
-        attribute_name: rc["attribute_name"],
-        condition: rc["condition"],
-        first_value: rc["first_value"],
-        second_value: rc["second_value"],
-        operator: rc["operator"]
-      };
+      const cond = normalizeCondition(rc);
       const err = validateCondition(provider, cond, `attribute_filter_groups[${gi}].conditions[${ci}]`);
-      if (err) return errorResponse(err);
+      if (err) return errorResponse(err.error, err.extras);
       conditions.push(cond);
     }
     groups.push({ operator: raw["operator"], conditions });
@@ -23058,6 +23166,8 @@ var TOOL_DEF30 = {
   }
 };
 function ruleExists(provider, ruleName) {
+  if (provider.rules[ruleName]) return true;
+  provider.invalidateRules();
   return !!provider.rules[ruleName];
 }
 function findFormField(formData, attrName, containerId) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prorigo/protrak-forge",
-  "version": "0.4.1",
+  "version": "0.4.2",
   "description": "Protrak domain context for coding agents — MCP server for GitHub Copilot, Claude, and Cursor",
   "bin": {
     "protrak-forge": "./bin/protrak-forge.js"