kibi-cli 0.14.0 → 0.17.0

package/src/schemas/entity.schema.json

@@ -2,6 +2,209 @@
   "$id": "entity.schema.json",
   "title": "Entity",
   "type": "object",
+  "$defs": {
+    "logicTerm": {
+      "oneOf": [
+        {
+          "type": "object",
+          "required": ["kind", "name", "type"],
+          "properties": {
+            "kind": { "const": "var" },
+            "name": { "type": "string", "pattern": "^[A-Z][A-Za-z0-9_]*$" },
+            "type": { "type": "string", "pattern": "^[a-z][a-z0-9_:.\\/-]*$" }
+          },
+          "additionalProperties": false
+        },
+        {
+          "type": "object",
+          "required": ["kind", "value"],
+          "properties": {
+            "kind": { "const": "const" },
+            "value": { "type": "string", "minLength": 1 },
+            "type": { "type": "string", "pattern": "^[a-z][a-z0-9_:.\\/-]*$" }
+          },
+          "additionalProperties": false
+        },
+        {
+          "type": "object",
+          "required": ["kind", "value"],
+          "properties": {
+            "kind": { "const": "number" },
+            "value": { "type": "number" },
+            "unit": { "type": "string", "pattern": "^[a-z][a-z0-9_:.\\/-]*$" }
+          },
+          "additionalProperties": false
+        },
+        {
+          "type": "object",
+          "required": ["kind", "value", "unit"],
+          "properties": {
+            "kind": { "const": "duration" },
+            "value": { "type": "number", "minimum": 0 },
+            "unit": {
+              "type": "string",
+              "enum": ["ms", "s", "m", "h", "d", "w"]
+            }
+          },
+          "additionalProperties": false
+        },
+        {
+          "type": "object",
+          "required": ["kind", "value"],
+          "properties": {
+            "kind": { "const": "timestamp" },
+            "value": { "type": "string" }
+          },
+          "additionalProperties": false
+        },
+        {
+          "type": "object",
+          "required": ["kind", "start", "end"],
+          "properties": {
+            "kind": { "const": "interval" },
+            "start": { "type": "string" },
+            "end": { "type": "string" }
+          },
+          "additionalProperties": false
+        }
+      ]
+    },
+    "logicAtom": {
+      "type": "object",
+      "required": ["kind", "name", "args"],
+      "properties": {
+        "kind": { "const": "atom" },
+        "namespace": { "type": "string", "pattern": "^[a-z][a-z0-9_:.\\/-]*$" },
+        "name": { "type": "string", "pattern": "^[a-z][a-z0-9_:.\\/-]*$" },
+        "args": {
+          "type": "array",
+          "maxItems": 8,
+          "items": { "$ref": "#/$defs/logicTerm" }
+        },
+        "polarity": { "enum": ["positive", "negative"] },
+        "closedWorld": { "type": "boolean" }
+      },
+      "additionalProperties": false
+    },
+    "logicExpression": {
+      "oneOf": [
+        { "$ref": "#/$defs/logicAtom" },
+        {
+          "type": "object",
+          "required": ["kind", "items"],
+          "properties": {
+            "kind": { "enum": ["all", "any"] },
+            "items": {
+              "type": "array",
+              "minItems": 1,
+              "maxItems": 32,
+              "items": { "$ref": "#/$defs/logicExpression" }
+            }
+          },
+          "additionalProperties": false
+        },
+        {
+          "type": "object",
+          "required": ["kind", "item"],
+          "properties": {
+            "kind": { "const": "not" },
+            "item": { "$ref": "#/$defs/logicAtom" }
+          },
+          "additionalProperties": false
+        },
+        {
+          "type": "object",
+          "required": ["kind", "operator", "left", "right"],
+          "properties": {
+            "kind": { "const": "compare" },
+            "operator": { "enum": ["eq", "neq", "lt", "lte", "gt", "gte"] },
+            "left": { "$ref": "#/$defs/logicTerm" },
+            "right": { "$ref": "#/$defs/logicTerm" }
+          },
+          "additionalProperties": false
+        },
+        {
+          "type": "object",
+          "required": ["kind", "atom", "operator", "value"],
+          "properties": {
+            "kind": { "const": "count" },
+            "atom": { "$ref": "#/$defs/logicAtom" },
+            "operator": { "enum": ["eq", "neq", "lt", "lte", "gt", "gte"] },
+            "value": { "type": "integer", "minimum": 0 }
+          },
+          "additionalProperties": false
+        },
+        {
+          "type": "object",
+          "required": ["kind", "relation", "left", "right"],
+          "properties": {
+            "kind": { "const": "temporal" },
+            "relation": {
+              "enum": [
+                "before",
+                "after",
+                "during",
+                "overlaps",
+                "starts",
+                "finishes"
+              ]
+            },
+            "left": { "$ref": "#/$defs/logicTerm" },
+            "right": { "$ref": "#/$defs/logicTerm" }
+          },
+          "additionalProperties": false
+        }
+      ]
+    },
+    "logicRule": {
+      "type": "object",
+      "required": ["version", "kind", "modality"],
+      "properties": {
+        "version": { "const": "kibi.logic.v1" },
+        "kind": { "enum": ["atom", "rule", "constraint"] },
+        "modality": {
+          "enum": ["assert", "deny", "oblige", "permit", "forbid"]
+        },
+        "head": { "$ref": "#/$defs/logicAtom" },
+        "body": { "$ref": "#/$defs/logicExpression" },
+        "variables": {
+          "type": "array",
+          "maxItems": 32,
+          "items": {
+            "type": "object",
+            "required": ["name", "type"],
+            "properties": {
+              "name": { "type": "string", "pattern": "^[A-Z][A-Za-z0-9_]*$" },
+              "type": {
+                "type": "string",
+                "pattern": "^[a-z][a-z0-9_:.\\/-]*$"
+              },
+              "quantifier": { "enum": ["forall", "exists"] }
+            },
+            "additionalProperties": false
+          }
+        },
+        "exceptions": {
+          "type": "array",
+          "maxItems": 16,
+          "items": { "$ref": "#/$defs/logicExpression" }
+        },
+        "scope": {
+          "type": "object",
+          "properties": {
+            "authority": { "type": "string" },
+            "name": { "type": "string" },
+            "tags": { "type": "array", "items": { "type": "string" } }
+          },
+          "additionalProperties": false
+        },
+        "validFrom": { "type": "string" },
+        "validTo": { "type": "string" },
+        "ruleSchemaId": { "type": "string", "minLength": 1 }
+      },
+      "additionalProperties": false
+    }
+  },
   "properties": {
     "id": { "type": "string" },
     "title": { "type": "string" },
@@ -38,6 +241,59 @@
     "severity": { "type": "string" },
     "links": { "type": "array", "items": { "type": "string" } },
     "text_ref": { "type": "string" },
+    "logic_claims": {
+      "type": "array",
+      "minItems": 1,
+      "uniqueItems": true,
+      "items": { "type": "string", "pattern": "^CLAIM-[A-F0-9]{16}$" }
+    },
+    "semantic_inventory": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "required": ["claim_key", "claim_text", "role", "status", "span"],
+        "properties": {
+          "claim_key": { "type": "string", "pattern": "^CLAIM-[A-F0-9]{16}$" },
+          "claim_text": { "type": "string", "minLength": 1 },
+          "role": {
+            "type": "string",
+            "enum": [
+              "normative",
+              "definition",
+              "descriptive",
+              "condition",
+              "exception",
+              "rationale",
+              "example",
+              "subjective"
+            ]
+          },
+          "status": {
+            "type": "string",
+            "enum": [
+              "modeled",
+              "ambiguous",
+              "ontology_gap",
+              "nonlogical",
+              "missing"
+            ]
+          },
+          "span": {
+            "type": "object",
+            "required": ["start", "end"],
+            "properties": {
+              "start": { "type": "integer", "minimum": 0 },
+              "end": { "type": "integer", "minimum": 0 }
+            },
+            "additionalProperties": false
+          },
+          "semantic_key": { "type": "string" },
+          "payload_hash": { "type": "string" },
+          "reason": { "type": "string" }
+        },
+        "additionalProperties": false
+      }
+    },
     "sourceFile": { "type": "string" },
     "granularity_reason": {
       "type": "string",
@@ -88,7 +344,9 @@
         "observation",
         "meta",
         "predicate_schema",
-        "predicate"
+        "predicate",
+        "rule_schema",
+        "rule"
       ]
     },
     "subject_key": { "type": "string" },
@@ -115,6 +373,8 @@
     "valid_from": { "type": "string" },
     "valid_to": { "type": "string" },
     "canonical_key": { "type": "string" },
+    "claim_key": { "type": "string", "pattern": "^CLAIM-[A-F0-9]{16}$" },
+    "claim_text": { "type": "string" },
     "predicate_name": { "type": "string" },
     "predicate_namespace": { "type": "string" },
     "predicate_arity": { "type": "integer", "minimum": 1 },
@@ -126,7 +386,14 @@
     },
     "aliases": { "type": "array", "items": { "type": "string" } },
     "examples": { "type": "array", "items": { "type": "string" } },
-    "predicate_args": { "type": "array", "items": { "type": "string" } }
+    "predicate_args": { "type": "array", "items": { "type": "string" } },
+    "rule_ir": { "$ref": "#/$defs/logicRule" },
+    "rule_hash": { "type": "string", "pattern": "^[a-f0-9]{64}$" },
+    "rule_schema_id": { "type": "string", "minLength": 1 },
+    "rule_name": { "type": "string", "minLength": 1 },
+    "semantic_key": { "type": "string", "pattern": "^SEM-[A-F0-9]{24}$" },
+    "claim_span_start": { "type": "integer", "minimum": 0 },
+    "claim_span_end": { "type": "integer", "minimum": 0 }
   },
   "required": [
     "id",
@@ -138,6 +405,19 @@
     "type"
   ],
   "allOf": [
+    {
+      "if": {
+        "properties": { "type": { "const": "req" } }
+      },
+      "then": {},
+      "else": { "not": { "required": ["logic_claims"] } }
+    },
+    {
+      "if": {
+        "anyOf": [{ "required": ["claim_key"] }, { "required": ["claim_text"] }]
+      },
+      "then": { "required": ["claim_key", "claim_text"] }
+    },
     {
       "if": {
         "properties": { "type": { "const": "test" } }
@@ -152,6 +432,36 @@
         }
       }
     },
+    {
+      "if": {
+        "properties": {
+          "type": { "const": "fact" },
+          "fact_kind": { "const": "rule_schema" }
+        },
+        "required": ["type", "fact_kind"]
+      },
+      "then": {
+        "required": ["rule_name", "argument_names", "argument_types"]
+      }
+    },
+    {
+      "if": {
+        "properties": {
+          "type": { "const": "fact" },
+          "fact_kind": { "const": "rule" }
+        },
+        "required": ["type", "fact_kind"]
+      },
+      "then": {
+        "required": [
+          "rule_ir",
+          "rule_hash",
+          "rule_schema_id",
+          "rule_name",
+          "semantic_key"
+        ]
+      }
+    },
     {
       "if": {
         "properties": { "type": { "const": "fact" } }
@@ -176,6 +486,8 @@
             { "required": ["valid_from"] },
             { "required": ["valid_to"] },
             { "required": ["canonical_key"] },
+            { "required": ["claim_key"] },
+            { "required": ["claim_text"] },
             { "required": ["predicate_name"] },
             { "required": ["predicate_namespace"] },
             { "required": ["predicate_arity"] },
@@ -184,11 +496,25 @@
             { "required": ["argument_descriptions"] },
             { "required": ["aliases"] },
             { "required": ["examples"] },
-            { "required": ["predicate_args"] }
+            { "required": ["predicate_args"] },
+            { "required": ["rule_ir"] },
+            { "required": ["rule_hash"] },
+            { "required": ["rule_schema_id"] },
+            { "required": ["rule_name"] },
+            { "required": ["semantic_key"] },
+            { "required": ["claim_span_start"] },
+            { "required": ["claim_span_end"] }
           ]
         }
       }
     },
+    {
+      "if": {
+        "properties": { "type": { "const": "req" } }
+      },
+      "then": {},
+      "else": { "not": { "required": ["semantic_inventory"] } }
+    },
     {
       "if": {
         "properties": {

package/src/schemas/relationship.schema.json

@@ -17,6 +17,7 @@
         "constrains",
         "requires_property",
         "requires_predicate",
+        "requires_rule",
         "guards",
         "publishes",
         "consumes",