trigger_system 1.0.0

package/dist/lsp/domain/validator.d.ts.map

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

package/dist/lsp/domain/validator.js

@@ -0,0 +1,225 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TriggerValidator = exports.TriggerRuleSchema = exports.ActionGroupSchema = exports.ActionSchema = exports.RuleConditionSchema = exports.ConditionGroupSchema = exports.ConditionSchema = exports.ComparisonOperatorSchema = void 0;
+// src/domain/validator.ts
+const arktype_1 = require("arktype");
+// --- ArkType Scope & Schemas ---
+// Define a Validation Scope to handle recursive types and mutual dependencies
+const types = (0, arktype_1.scope)({
+    // List of allowed operators
+    Operator: "'EQ' | '==' | 'NEQ' | '!=' | 'GT' | '>' | 'GTE' | '>=' | 'LT' | '<' | 'LTE' | '<=' | 'IN' | 'NOT_IN' | 'CONTAINS' | 'MATCHES' | 'RANGE' | 'SINCE' | 'AFTER' | 'BEFORE' | 'UNTIL'",
+    // Discriminated union for better value validation based on operator
+    Condition: "RangeCondition | ListCondition | ContainsCondition | NumericCondition | RegexCondition | BasicCondition",
+    RangeCondition: {
+        field: "string > 0",
+        operator: "'RANGE'",
+        value: "unknown[] == 2" // Requires an array of exactly 2 items
+    },
+    ListCondition: {
+        field: "string > 0",
+        operator: "'IN' | 'NOT_IN'",
+        value: "unknown[]" // Requires an array
+    },
+    ContainsCondition: {
+        field: "string > 0",
+        operator: "'CONTAINS'",
+        value: "string | unknown[]" // Can be string (substring) or array (includes)
+    },
+    NumericCondition: {
+        field: "string > 0",
+        operator: "'>' | '>=' | '<' | '<=' | 'GT' | 'GTE' | 'LT' | 'LTE'",
+        value: "number | string" // Numbers or expressions
+    },
+    RegexCondition: {
+        field: "string > 0",
+        operator: "'MATCHES'",
+        value: "string" // Regex pattern must be a string
+    },
+    BasicCondition: {
+        field: "string > 0",
+        operator: "Operator",
+        value: "unknown"
+    },
+    ConditionGroup: {
+        operator: "'AND' | 'OR'",
+        // Recursive reference to Condition or ConditionGroup
+        conditions: "(Condition | ConditionGroup)[] >= 1" // Must have at least 1 condition
+    },
+    RuleCondition: "Condition | ConditionGroup",
+    Action: {
+        type: "string > 0", // Must define a type
+        "params?": "object", // Must be an object if present
+        "delay?": "number.integer >= 0", // Integer check for milliseconds
+        "probability?": "0 <= number <= 1"
+    },
+    ActionGroup: {
+        "mode?": "'ALL' | 'EITHER' | 'SEQUENCE'",
+        actions: "(Action | ActionGroup)[] >= 1" // Recursive
+    },
+    RuleAction: "Action | ActionGroup",
+    TriggerRule: {
+        id: "string > 0",
+        "name?": "string",
+        "description?": "string",
+        "priority?": "number.integer", // Priority is integer
+        "enabled?": "boolean",
+        "cooldown?": "number.integer >= 0", // Milliseconds
+        "tags?": "string[]",
+        on: "string > 0", // Non-empty event name
+        "if?": "RuleCondition | RuleCondition[]",
+        do: "RuleAction | RuleAction[]",
+        "comment?": "string"
+    }
+}).export();
+// Export individual schemas for external usage if needed
+exports.ComparisonOperatorSchema = types.Operator;
+exports.ConditionSchema = types.Condition;
+exports.ConditionGroupSchema = types.ConditionGroup;
+exports.RuleConditionSchema = types.RuleCondition;
+exports.ActionSchema = types.Action;
+exports.ActionGroupSchema = types.ActionGroup;
+exports.TriggerRuleSchema = types.TriggerRule;
+// --- Validator Class ---
+class TriggerValidator {
+    static validate(data) {
+        // ArkType validation
+        const out = (0, exports.TriggerRuleSchema)(data);
+        if (out instanceof arktype_1.type.errors) {
+            const issues = [];
+            // Iterate over problems (ArkType specific)
+            for (const problem of out) {
+                const path = problem.path.join(".");
+                let message = problem.message;
+                let suggestion = undefined;
+                // Custom Error Enhancements (replicating Zod logic)
+                // ArkType error for missing string might differ, typically says "must be a string"
+                if (path.endsWith("on") && (message.includes("string") || message.includes("must be"))) {
+                    // Heuristic check if it failed because it was interpretted as boolean 'true' in YAML
+                    // We can't see the original value easily here without checking 'data' at path
+                    // But we can just suggest it generally.
+                    if (typeof data === 'object' && data && data.on === true) {
+                        message = "The 'on' field is incorrect (boolean true found).";
+                        suggestion = "In YAML, 'on' is a boolean keyword (true). Quote it: \"on\": \"EventName\"";
+                    }
+                    else {
+                        // Generic suggestion
+                        suggestion = "Ensure 'on' is a string event name.";
+                    }
+                }
+                issues.push({
+                    path,
+                    message,
+                    suggestion,
+                    severity: "error"
+                });
+            }
+            return { valid: false, issues };
+        }
+        // Structural validation passed. Now perform Semantic Validation (Value Types)
+        const rule = out;
+        const semanticIssues = [];
+        this.validateConditionsRecursive(rule.if, semanticIssues, 'if');
+        if (semanticIssues.length > 0) {
+            return { valid: false, issues: semanticIssues };
+        }
+        return { valid: true, rule };
+    }
+    static validateConditionsRecursive(condition, issues, path) {
+        if (!condition)
+            return;
+        if (Array.isArray(condition)) {
+            condition.forEach((c, idx) => {
+                this.validateConditionsRecursive(c, issues, `${path}.${idx}`);
+            });
+            return;
+        }
+        // Check if it's a ConditionGroup (has 'conditions')
+        if ('conditions' in condition && Array.isArray(condition.conditions)) {
+            condition.conditions.forEach((c, idx) => {
+                this.validateConditionsRecursive(c, issues, `${path}.conditions.${idx}`);
+            });
+            return;
+        }
+        // It must be a Condition
+        if ('operator' in condition && 'value' in condition) {
+            this.validateConditionValue(condition, issues, path);
+        }
+    }
+    static validateConditionValue(condition, issues, path) {
+        const { operator, value } = condition;
+        // 1. List/Collection Operators (IN, NOT_IN, RANGE, CONTAINS)
+        if (['IN', 'NOT_IN', 'RANGE', 'CONTAINS'].includes(operator)) {
+            if (operator === 'CONTAINS') {
+                if (typeof value !== 'string' && !Array.isArray(value)) {
+                    issues.push({
+                        path: `${path}.value`,
+                        message: `Incorrect value type: Operator 'CONTAINS' expects a String or List (Array), but received ${typeof value}.`,
+                        suggestion: "Use a substring or a list of items.",
+                        severity: "error"
+                    });
+                }
+                return;
+            }
+            if (!Array.isArray(value)) {
+                issues.push({
+                    path: `${path}.value`,
+                    message: `Incorrect value type: Operator '${operator}' expects a List (Array), but received ${typeof value}.`,
+                    suggestion: operator === 'RANGE' ? "Use format [min, max]" : "Use format [item1, item2]",
+                    severity: "error"
+                });
+                return;
+            }
+            if (operator === 'RANGE') {
+                if (value.length !== 2) {
+                    issues.push({
+                        path: `${path}.value`,
+                        message: `Invalid Range: Operator 'RANGE' requires exactly 2 values (min and max).`,
+                        suggestion: "Use format [min, max], e.g. [1, 10]",
+                        severity: "error"
+                    });
+                }
+                else if (typeof value[0] !== 'number' && typeof value[0] !== 'string') {
+                    issues.push({
+                        path: `${path}.value`,
+                        message: `Incorrect range type: Range values must be numbers or expression strings.`,
+                        severity: "error"
+                    });
+                }
+            }
+        }
+        // 2. Regex
+        else if (operator === 'MATCHES') {
+            if (typeof value !== 'string') {
+                issues.push({
+                    path: `${path}.value`,
+                    message: `Incorrect value type: Operator 'MATCHES' expects a string (regex pattern), but received ${typeof value}.`,
+                    severity: "error"
+                });
+            }
+            else {
+                try {
+                    new RegExp(value);
+                }
+                catch (e) {
+                    issues.push({
+                        path: `${path}.value`,
+                        message: `Invalid Regex pattern: ${e.message}`,
+                        severity: "error"
+                    });
+                }
+            }
+        }
+        // 3. Numeric Comparisons (GT, LT, etc)
+        else if (['GT', 'GTE', 'LT', 'LTE', '>', '>=', '<', '<='].includes(operator)) {
+            if (typeof value !== 'number' && typeof value !== 'string') {
+                issues.push({
+                    path: `${path}.value`,
+                    message: `Incorrect value type: Operator '${operator}' expects a number or expression string, but received ${typeof value}.`,
+                    severity: "error"
+                });
+            }
+        }
+    }
+}
+exports.TriggerValidator = TriggerValidator;
+//# sourceMappingURL=validator.js.map

package/dist/lsp/domain/validator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"validator.js","sourceRoot":"","sources":["../../../src/domain/validator.ts"],"names":[],"mappings":"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"}

package/dist/lsp/hover.d.ts

@@ -0,0 +1,7 @@
+import type { Hover, Position } from 'vscode-languageserver/node';
+import type { TextDocument } from 'vscode-languageserver-textdocument';
+/**
+ * Get hover information for a position in the document
+ */
+export declare function getHover(document: TextDocument, position: Position): Hover | null;
+//# sourceMappingURL=hover.d.ts.map

package/dist/lsp/hover.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hover.d.ts","sourceRoot":"","sources":["../../src/lsp/hover.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAiB,QAAQ,EAAE,MAAM,4BAA4B,CAAC;AACjF,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oCAAoC,CAAC;AA8NvE;;GAEG;AACH,wBAAgB,QAAQ,CAAC,QAAQ,EAAE,YAAY,EAAE,QAAQ,EAAE,QAAQ,GAAG,KAAK,GAAG,IAAI,CAwEjF"}