kibi-core 0.5.3 → 0.6.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kibi-core",
-  "version": "0.5.3",
+  "version": "0.6.1",
   "private": false,
   "description": "Core Prolog modules and RDF graph logic for Kibi",
   "type": "module",
@@ -9,10 +9,7 @@
     "bun": ">=1.0"
   },
   "main": "./src/kb.pl",
-  "files": [
-    "src/**/*.pl",
-    "schema/**/*.pl"
-  ],
+  "files": ["src/**/*.pl", "schema/**/*.pl"],
   "license": "AGPL-3.0-or-later",
   "author": "Piotr Franczyk",
   "repository": {

package/schema/entities.pl

@@ -47,6 +47,15 @@ entity_property(fact, closed_world, boolean).
 entity_property(fact, valid_from, datetime).
 entity_property(fact, valid_to, datetime).
 entity_property(fact, canonical_key, string).
+entity_property(fact, predicate_name, string).
+entity_property(fact, predicate_namespace, string).
+entity_property(fact, predicate_arity, integer).
+entity_property(fact, argument_names, list).
+entity_property(fact, argument_types, list).
+entity_property(fact, argument_descriptions, list).
+entity_property(fact, aliases, list).
+entity_property(fact, examples, list).
+entity_property(fact, predicate_args, list).
 
 % Typed test verification fields - only valid for test entities
 entity_property(test, verification_scope, atom).

package/schema/relationships.pl

@@ -18,6 +18,7 @@ relationship_type(relates_to).
 relationship_type(supersedes).
 relationship_type(constrains).
 relationship_type(requires_property).
+relationship_type(requires_predicate).
 
 % valid_relationship(RelType, FromType, ToType).
 valid_relationship(depends_on, req, req).
@@ -38,6 +39,7 @@ valid_relationship(publishes, symbol, event).
 valid_relationship(consumes, symbol, event).
 valid_relationship(constrains, req, fact).
 valid_relationship(requires_property, req, fact).
+valid_relationship(requires_predicate, req, fact).
 
 %% supersedes(+NewAdrId, +OldAdrId)
 %% NewAdrId is the decision that replaces OldAdrId.

package/schema/validation.pl

@@ -88,6 +88,15 @@ is_fact_only_field(closed_world).
 is_fact_only_field(valid_from).
 is_fact_only_field(valid_to).
 is_fact_only_field(canonical_key).
+is_fact_only_field(predicate_name).
+is_fact_only_field(predicate_namespace).
+is_fact_only_field(predicate_arity).
+is_fact_only_field(argument_names).
+is_fact_only_field(argument_types).
+is_fact_only_field(argument_descriptions).
+is_fact_only_field(aliases).
+is_fact_only_field(examples).
+is_fact_only_field(predicate_args).
 
 % is_test_only_field(+Key) - true if Key is a test-specific field
 is_test_only_field(verification_scope).
@@ -97,7 +106,7 @@ is_test_only_field(verification_perspective).
 validate_fact_shape(subject, Props) :-
     memberchk(subject_key=_Val, Props),
     valid_optional_fact_enums(Props),
-    valid_polarity_in_props(Props).
+    valid_strict_polarity_in_props(Props).
 validate_fact_shape(property_value, Props) :-
     memberchk(subject_key=_Subject, Props),
     memberchk(property_key=_Property, Props),
@@ -108,7 +117,7 @@ validate_fact_shape(property_value, Props) :-
     exactly_one_value_field(Props),
     value_type_matches_field(VT, Props),
     valid_optional_fact_enums(Props),
-    valid_polarity_in_props(Props).
+    valid_strict_polarity_in_props(Props).
 validate_fact_shape(observation, Props) :-
     valid_optional_fact_enums(Props),
     valid_polarity_in_props(Props).
@@ -116,9 +125,26 @@ validate_fact_shape(meta, Props) :-
     % Meta facts are allowed but don't require full strict property tuple yet
     valid_optional_fact_enums(Props),
     valid_polarity_in_props(Props).
+validate_fact_shape(predicate_schema, Props) :-
+    memberchk(predicate_name=_Name, Props),
+    memberchk(predicate_arity=Arity, Props),
+    Arity >= 1,
+    memberchk(argument_names=ArgumentNames, Props),
+    memberchk(argument_types=ArgumentTypes, Props),
+    same_length(ArgumentNames, ArgumentTypes),
+    length(ArgumentNames, Arity),
+    valid_optional_fact_enums(Props),
+    valid_polarity_in_props(Props).
+validate_fact_shape(predicate, Props) :-
+    memberchk(predicate_name=_Name, Props),
+    memberchk(predicate_args=Args, Props),
+    Args \= [],
+    memberchk(canonical_key=_CanonicalKey, Props),
+    valid_optional_fact_enums(Props),
+    valid_predicate_polarity_in_props(Props).
 validate_fact_shape(Kind, _Props) :-
     % Unknown fact_kind values fail validation
-    \+ memberchk(Kind, [subject, property_value, observation, meta]),
+    \+ memberchk(Kind, [subject, property_value, observation, meta, predicate_schema, predicate]),
     fail.
 
 % valid_operator(+Op)
@@ -140,6 +166,12 @@ valid_value_type(bool).
 valid_polarity_in_props(Props) :-
     ( memberchk(polarity=P, Props) -> valid_polarity(P) ; true ).
 
+valid_strict_polarity_in_props(Props) :-
+    ( memberchk(polarity=P, Props) -> valid_strict_polarity(P) ; true ).
+
+valid_predicate_polarity_in_props(Props) :-
+    ( memberchk(polarity=P, Props) -> valid_predicate_polarity(P) ; true ).
+
 % valid_optional_fact_enums(+Props)
 % Validates enum-typed fact fields whenever they are present
 valid_optional_fact_enums(Props) :-
@@ -155,6 +187,14 @@ valid_optional_test_enums(Props) :-
 % valid_polarity(+P)
 valid_polarity(require).
 valid_polarity(forbid).
+valid_polarity(assert).
+valid_polarity(deny).
+
+valid_strict_polarity(require).
+valid_strict_polarity(forbid).
+
+valid_predicate_polarity(assert).
+valid_predicate_polarity(deny).
 
 % valid_verification_scope(+Scope)
 valid_verification_scope(unit).

package/src/checks.pl

@@ -33,7 +33,7 @@ required_fields([id, title, status, created_at, updated_at, source]).
 % Relationship types to check for dangling references
 all_relationship_types([
     depends_on, verified_by, validates, specified_by,
-    constrains, requires_property, supersedes, relates_to
+    constrains, requires_property, requires_predicate, supersedes, relates_to
 ]).
 
 %% check_all(-ViolationsDict)
@@ -387,9 +387,25 @@ strict_fact_shape_violation(violation(
     ->  fail  % Observation facts have no required fields beyond fact_kind
     ;   Kind = meta
     ->  fail  % Meta facts have no required fields beyond fact_kind
+    ;   Kind = predicate_schema
+    ->  findall(Msg, predicate_schema_shape_error(Props, Msg), Errors),
+        (   Errors = []
+        ->  fail
+        ;   Errors = [First|_],
+            Description = First,
+            Suggestion = "Ensure predicate_schema facts have predicate_name, predicate_arity, argument_names, and argument_types with matching arity"
+        )
+    ;   Kind = predicate
+    ->  findall(Msg, predicate_shape_error(Props, Msg), Errors),
+        (   Errors = []
+        ->  fail
+        ;   Errors = [First|_],
+            Description = First,
+            Suggestion = "Ensure predicate facts have predicate_name, non-empty predicate_args, canonical_key, and assert/deny polarity when present"
+        )
     ;   % Unknown fact_kind - report as malformed
         format(string(Description), "Unknown fact_kind: ~w", [Kind]),
-        Suggestion = "Use one of: subject, property_value, observation, meta"
+        Suggestion = "Use one of: subject, property_value, observation, meta, predicate_schema, predicate"
     ),
     
     (   memberchk(source=Source0, Props)
@@ -435,6 +451,68 @@ value_type_matches_field(int, Props) :- memberchk(value_int=_, Props), !.
 value_type_matches_field(number, Props) :- memberchk(value_number=_, Props), !.
 value_type_matches_field(bool, Props) :- memberchk(value_bool=_, Props), !.
 
+predicate_schema_shape_error(Props, "Predicate schema fact missing required field: predicate_name") :-
+    \+ memberchk(predicate_name=_, Props).
+predicate_schema_shape_error(Props, "Predicate schema fact missing required field: predicate_arity") :-
+    memberchk(predicate_name=_, Props),
+    \+ memberchk(predicate_arity=_, Props).
+predicate_schema_shape_error(Props, "Predicate schema fact missing required field: argument_names") :-
+    memberchk(predicate_arity=_, Props),
+    \+ memberchk(argument_names=_, Props).
+predicate_schema_shape_error(Props, "Predicate schema fact missing required field: argument_types") :-
+    memberchk(argument_names=_, Props),
+    \+ memberchk(argument_types=_, Props).
+predicate_schema_shape_error(Props, "Predicate schema fact argument_names length must match predicate_arity") :-
+    memberchk(predicate_arity=RawArity, Props),
+    checks_normalize_integer(RawArity, Arity),
+    memberchk(argument_names=RawNames, Props),
+    checks_normalize_atom_list(RawNames, Names),
+    length(Names, Count),
+    Count =\= Arity.
+predicate_schema_shape_error(Props, "Predicate schema fact argument_types length must match predicate_arity") :-
+    memberchk(predicate_arity=RawArity, Props),
+    checks_normalize_integer(RawArity, Arity),
+    memberchk(argument_types=RawTypes, Props),
+    checks_normalize_atom_list(RawTypes, Types),
+    length(Types, Count),
+    Count =\= Arity.
+
+predicate_shape_error(Props, "Predicate fact missing required field: predicate_name") :-
+    \+ memberchk(predicate_name=_, Props).
+predicate_shape_error(Props, "Predicate fact missing required field: predicate_args") :-
+    memberchk(predicate_name=_, Props),
+    \+ memberchk(predicate_args=_, Props).
+predicate_shape_error(Props, "Predicate fact predicate_args must be non-empty") :-
+    memberchk(predicate_args=RawArgs, Props),
+    checks_normalize_atom_list(RawArgs, Args),
+    Args = [].
+predicate_shape_error(Props, "Predicate fact missing required field: canonical_key") :-
+    memberchk(predicate_args=_, Props),
+    \+ memberchk(canonical_key=_, Props).
+predicate_shape_error(Props, "Predicate fact polarity must be assert or deny") :-
+    memberchk(polarity=RawPolarity, Props),
+    normalize_term_atom(RawPolarity, Polarity),
+    \+ memberchk(Polarity, [assert, deny]).
+
+checks_normalize_integer(Raw, Integer) :-
+    (   Raw = ^^(Value, _Type)
+    ->  checks_normalize_integer(Value, Integer)
+    ;   integer(Raw)
+    ->  Integer = Raw
+    ;   atom(Raw)
+    ->  atom_number(Raw, Integer)
+    ;   string(Raw)
+    ->  number_string(Integer, Raw)
+    ).
+
+checks_normalize_atom_list(Raw, Atoms) :-
+    (   Raw = ^^(Value, _Type)
+    ->  checks_normalize_atom_list(Value, Atoms)
+    ;   is_list(Raw)
+    ->  maplist(normalize_term_atom, Raw, Atoms)
+    ;   Atoms = []
+    ).
+
 %% check_domain_contradictions(-Violations)
 % Finds all pairs of requirements with contradicting required properties.
 check_domain_contradictions(Violations) :-

package/src/derived_chr.pl

@@ -0,0 +1,65 @@
+% Module: derived_chr
+% Internal CHR pilot for bounded derived validation facts.
+
+:- module(derived_chr, [
+    derive_chr_facts/0,
+    clear_chr_facts/0,
+    derived_coverage_gap/2,
+    derived_symbol_gap/2
+]).
+
+:- use_module(library(chr)).
+:- use_module('kb.pl').
+
+:- chr_constraint seen_must_req/1, seen_scenario/1, seen_test/1,
+    seen_production_symbol/1, seen_symbol_req_coverage/1.
+
+:- dynamic derived_coverage_gap/2.
+:- dynamic derived_symbol_gap/2.
+:- dynamic snapshot_must_req/1.
+:- dynamic snapshot_scenario/1.
+:- dynamic snapshot_test/1.
+:- dynamic snapshot_production_symbol/1.
+:- dynamic snapshot_symbol_req_coverage/1.
+
+seen_must_req(Req) <=> assertz(snapshot_must_req(Req)).
+seen_scenario(Req) <=> assertz(snapshot_scenario(Req)).
+seen_test(Req) <=> assertz(snapshot_test(Req)).
+seen_production_symbol(Symbol) <=> assertz(snapshot_production_symbol(Symbol)).
+seen_symbol_req_coverage(Symbol) <=> assertz(snapshot_symbol_req_coverage(Symbol)).
+
+clear_chr_facts :-
+    retractall(derived_coverage_gap(_, _)),
+    retractall(derived_symbol_gap(_, _)),
+    retractall(snapshot_must_req(_)),
+    retractall(snapshot_scenario(_)),
+    retractall(snapshot_test(_)),
+    retractall(snapshot_production_symbol(_)),
+    retractall(snapshot_symbol_req_coverage(_)).
+
+derive_chr_facts :-
+    clear_chr_facts,
+    forall(kb:must_requirement(Req), seen_must_req(Req)),
+    forall(kb:has_scenario(Req), seen_scenario(Req)),
+    forall(kb:has_test(Req), seen_test(Req)),
+    forall(kb:production_symbol(Symbol), seen_production_symbol(Symbol)),
+    forall(kb:production_symbol_covered_for_requirement(Symbol, _), seen_symbol_req_coverage(Symbol)),
+    derive_coverage_gaps,
+    derive_symbol_gaps.
+
+derive_coverage_gaps :-
+    forall(
+        (   snapshot_must_req(Req),
+            \+ snapshot_scenario(Req),
+            \+ snapshot_test(Req)
+        ),
+        assertz(derived_coverage_gap(Req, missing_scenario_and_test))
+    ).
+
+derive_symbol_gaps :-
+    forall(
+        (   snapshot_production_symbol(Symbol),
+            \+ snapshot_symbol_req_coverage(Symbol)
+        ),
+        assertz(derived_symbol_gap(Symbol, no_qualifying_production_coverage))
+    ).

package/src/discovery.pl

@@ -8,6 +8,7 @@
 ]).
 
 :- use_module(library(http/json)).
+:- use_module(library(aggregate)).
 :- use_module('kb.pl').
 :- use_module('status.pl', [status_meta_dict/1]).
 :- use_module('../schema/relationships.pl', [relationship_type/1]).
@@ -90,10 +91,9 @@ relationship_counts(Id, CountsDict) :-
     dict_pairs(CountsDict, relationship_counts, Pairs).
 
 relationship_count(Id, Relationship, Count) :-
-    findall(1,
+    aggregate_all(count,
         (kb_relationship(Relationship, Id, _); kb_relationship(Relationship, _, Id)),
-        Matches),
-    length(Matches, Count).
+        Count).
 
 coverage_rows(req, Tags, IncludePassing, IncludeTransitive, Rows, Summary) :-
     !,

package/src/kb.pl

@@ -39,6 +39,8 @@
     adr_chain/2,
     deprecated_no_successor/1,
     symbol_no_req_coverage/2,
+    predicate_schema/6,
+    predicate_fact/5,
     contradicting_reqs/3,
     check_req_contradiction/1,
     normalize_term_atom/2,
@@ -962,6 +964,57 @@ fact_property_tuple(FactId, Subject, Property, Op, ValType, Value, Unit, Scope,
     ( memberchk(scope=ScopeRaw, Props) -> normalize_term_atom(ScopeRaw, Scope) ; Scope = '' ),
     ( memberchk(polarity=PolarityRaw, Props) -> normalize_term_atom(PolarityRaw, Polarity) ; Polarity = require ).
 
+%% predicate_schema(+FactId, -Namespace, -Name, -Arity, -ArgumentNames, -ArgumentTypes)
+% Read one project-local ontology predicate schema fact.
+predicate_schema(FactId, Namespace, Name, Arity, ArgumentNames, ArgumentTypes) :-
+    kb_entity(FactId, fact, Props),
+    memberchk(fact_kind=KindRaw, Props),
+    normalize_term_atom(KindRaw, predicate_schema),
+    memberchk(predicate_name=NameRaw, Props),
+    normalize_term_atom(NameRaw, Name),
+    ( memberchk(predicate_namespace=NamespaceRaw, Props) -> normalize_term_atom(NamespaceRaw, Namespace) ; Namespace = default ),
+    memberchk(predicate_arity=ArityRaw, Props),
+    normalize_term_integer(ArityRaw, Arity),
+    memberchk(argument_names=ArgumentNamesRaw, Props),
+    normalize_term_atom_list(ArgumentNamesRaw, ArgumentNames),
+    memberchk(argument_types=ArgumentTypesRaw, Props),
+    normalize_term_atom_list(ArgumentTypesRaw, ArgumentTypes).
+
+%% predicate_fact(+FactId, -Namespace, -Name, -Args, -Polarity)
+% Read one ground ontology predicate fact.
+predicate_fact(FactId, Namespace, Name, Args, Polarity) :-
+    kb_entity(FactId, fact, Props),
+    memberchk(fact_kind=KindRaw, Props),
+    normalize_term_atom(KindRaw, predicate),
+    memberchk(predicate_name=NameRaw, Props),
+    normalize_term_atom(NameRaw, Name),
+    ( memberchk(predicate_namespace=NamespaceRaw, Props) -> normalize_term_atom(NamespaceRaw, Namespace) ; Namespace = default ),
+    memberchk(predicate_args=ArgsRaw, Props),
+    normalize_term_atom_list(ArgsRaw, Args),
+    ( memberchk(polarity=PolarityRaw, Props) -> normalize_term_atom(PolarityRaw, Polarity) ; Polarity = assert ).
+
+normalize_term_atom_list(List, Atoms) :-
+    is_list(List),
+    !,
+    maplist(normalize_term_atom, List, Atoms).
+normalize_term_atom_list(Raw, Atoms) :-
+    unwrap_rdf_value(Raw, Value),
+    is_list(Value),
+    !,
+    maplist(normalize_term_atom, Value, Atoms).
+
+normalize_term_integer(Raw, Integer) :-
+    unwrap_rdf_value(Raw, Value),
+    (   integer(Value)
+    ->  Integer = Value
+    ;   atom(Value)
+    ->  atom_number(Value, Integer)
+    ;   string(Value)
+    ->  number_string(Integer, Value)
+    ;   Value = ^^(Nested, _Type)
+    ->  normalize_term_integer(Nested, Integer)
+    ).
+
 %% fact_valid_interval(+FactId, -ValidFrom, -ValidTo)
 % Extract optional validity bounds for property_value facts.
 fact_valid_interval(FactId, ValidFrom, ValidTo) :-

package/src/sparql_client.pl

@@ -0,0 +1,150 @@
+% Module: kibi_sparql_client
+% Explicit remote SPARQL client wrapper.
+
+:- module(kibi_sparql_client, [
+    remote_sparql_select_json/4
+]).
+
+:- use_module(library(error)).
+:- use_module(library(http/json)).
+:- use_module(library(semweb/sparql_client)).
+
+remote_sparql_select_json(Endpoint, Query, Options, JsonString) :-
+    validate_non_empty_atom(endpoint, Endpoint),
+    validate_non_empty_atom(query, Query),
+    validate_remote_endpoint(Endpoint),
+    validate_select_query(Query),
+    validate_sparql_options(Options, SparqlOptions),
+    sparql_query(Query, Rows, [endpoint(Endpoint), variable_names(Variables)|SparqlOptions]),
+    maplist(row_json(Variables), Rows, JsonRows),
+    with_output_to(string(JsonString), json_write_dict(current_output, _{rows: JsonRows}, [])).
+
+validate_non_empty_atom(Name, Value) :-
+    must_be(atom, Value),
+    (   Value == ''
+    ->  throw(error(domain_error(non_empty_atom, Name), _))
+    ;   true
+    ).
+
+validate_remote_endpoint(Endpoint) :-
+    (   sub_atom(Endpoint, 0, _, _, 'http://')
+    ;   sub_atom(Endpoint, 0, _, _, 'https://')
+    ),
+    endpoint_host(Endpoint, Host),
+    \+ local_or_private_host(Host),
+    !.
+validate_remote_endpoint(Endpoint) :-
+    (   sub_atom(Endpoint, 0, _, _, 'http://')
+    ;   sub_atom(Endpoint, 0, _, _, 'https://')
+    ),
+    !,
+    throw(error(domain_error(public_remote_endpoint, Endpoint), _)).
+validate_remote_endpoint(Endpoint) :-
+    throw(error(domain_error(remote_http_endpoint, Endpoint), _)).
+
+validate_select_query(Query) :-
+    normalize_space(atom(Normalized), Query),
+    downcase_atom(Normalized, Lower),
+    sub_atom(Lower, 0, 6, After, 'select'),
+    (   After =:= 0
+    ;   sub_atom(Lower, 6, 1, _, ' ')
+    ;   sub_atom(Lower, 6, 1, _, '*')
+    ),
+    !.
+validate_select_query(Query) :-
+    throw(error(domain_error(sparql_select_query, Query), _)).
+
+endpoint_host(Endpoint, Host) :-
+    strip_endpoint_scheme(Endpoint, WithoutScheme),
+    segment_before(WithoutScheme, '/', WithoutPath),
+    segment_before(WithoutPath, '?', WithoutQuery),
+    segment_before(WithoutQuery, '#', Authority),
+    strip_userinfo(Authority, HostWithPort),
+    strip_port(HostWithPort, Host0),
+    downcase_atom(Host0, Host).
+
+strip_endpoint_scheme(Endpoint, WithoutScheme) :-
+    sub_atom(Endpoint, 0, 7, _, 'http://'),
+    !,
+    sub_atom(Endpoint, 7, _, 0, WithoutScheme).
+strip_endpoint_scheme(Endpoint, WithoutScheme) :-
+    sub_atom(Endpoint, 0, 8, _, 'https://'),
+    sub_atom(Endpoint, 8, _, 0, WithoutScheme).
+
+segment_before(Atom, Delimiter, Segment) :-
+    sub_atom(Atom, Before, _, _, Delimiter),
+    !,
+    sub_atom(Atom, 0, Before, _, Segment).
+segment_before(Atom, _Delimiter, Atom).
+
+strip_userinfo(Authority, HostWithPort) :-
+    sub_atom(Authority, _, _, After, '@'),
+    !,
+    sub_atom(Authority, _, After, 0, HostWithPort).
+strip_userinfo(Authority, Authority).
+
+strip_port(HostWithPort, Host) :-
+    sub_atom(HostWithPort, 0, 1, _, '['),
+    sub_atom(HostWithPort, 1, Length, _, ']'),
+    !,
+    sub_atom(HostWithPort, 1, Length, _, Host).
+strip_port(HostWithPort, Host) :-
+    segment_before(HostWithPort, ':', Host).
+
+local_or_private_host(localhost).
+local_or_private_host('0.0.0.0').
+local_or_private_host('::1').
+local_or_private_host(Host) :-
+    sub_atom(Host, _, _, 0, '.localhost').
+local_or_private_host(Host) :-
+    sub_atom(Host, 0, _, _, '127.').
+local_or_private_host(Host) :-
+    sub_atom(Host, 0, _, _, '10.').
+local_or_private_host(Host) :-
+    sub_atom(Host, 0, _, _, '192.168.').
+local_or_private_host(Host) :-
+    sub_atom(Host, 0, _, _, '169.254.').
+local_or_private_host(Host) :-
+    sub_atom(Host, 0, _, _, 'fe80:').
+local_or_private_host(Host) :-
+    sub_atom(Host, 0, 2, _, Prefix),
+    memberchk(Prefix, ['fc', 'fd']).
+local_or_private_host(Host) :-
+    sub_atom(Host, 0, _, _, '172.'),
+    atomic_list_concat([_, SecondAtom|_], '.', Host),
+    atom_number(SecondAtom, Second),
+    Second >= 16,
+    Second =< 31.
+
+validate_sparql_options([], []).
+validate_sparql_options([result_format(json)|Rest], SparqlOptions) :-
+    !,
+    validate_sparql_options(Rest, SparqlOptions).
+validate_sparql_options([timeout(Timeout)|Rest], [timeout(Timeout)|SparqlOptions]) :-
+    !,
+    validate_sparql_options(Rest, SparqlOptions).
+validate_sparql_options([Option|_], _) :-
+    throw(error(domain_error(sparql_client_option, Option), _)).
+
+row_json(Variables, Row, Dict) :-
+    Row =.. [row|Values],
+    pairs_json(Variables, Values, Pairs),
+    dict_create(Dict, row, Pairs).
+
+pairs_json([], [], []).
+pairs_json([Variable|Variables], [Value|Values], [Variable-JsonValue|Pairs]) :-
+    sparql_value_json(Value, JsonValue),
+    pairs_json(Variables, Values, Pairs).
+
+sparql_value_json(Value, JsonValue) :-
+    atomic(Value),
+    !,
+    JsonValue = Value.
+sparql_value_json(literal(Value), JsonValue) :-
+    !,
+    sparql_value_json(Value, JsonValue).
+sparql_value_json(type(_Type, Value), JsonValue) :-
+    !,
+    sparql_value_json(Value, JsonValue).
+sparql_value_json(Value, JsonValue) :-
+    term_string(Value, JsonValue).