kp_loader.pl

:- module(_,[
    loaded_kp/1, all_kps_loaded/0, all_kps_loaded/1, kp_dir/1, taxkb_dir/1, kp_location/3, kp/1, must_succeed/2, must_succeed/1,
    shouldMapModule/2, module_api_hack/1, moduleMapping/2, myDeclaredModule/1, system_predicate/1,
    discover_kps_in_dir/1, discover_kps_in_dir/0, discover_kps_gitty/0, setup_kp_modules/0, load_kps/0,
    load_gitty_files/1, load_gitty_files/0, save_gitty_files/1, save_gitty_files/0, delete_gitty_file/1, update_gitty_file/3,
    xref_all/0, xref_clean/0, print_kp_predicates/0, print_kp_predicates/1, reset_errors/0, my_xref_defined/3, url_simple/2,
    kp_predicate_mention/3, predicate_literal/2,load_named_file/3, 
    edit_kp/1, swish_editor_path/2, knowledgePagesGraph/1, knowledgePagesGraph/2]).

:- use_module(library(prolog_xref)).
:- use_module(library(broadcast)).

:- multifile prolog:message//1.

:- dynamic kp_dir/1, taxkb_dir/1.
:- prolog_load_context(directory, D), 
    retractall(taxkb_dir(_)), assert(taxkb_dir(D)), 
    retractall(kp_dir(_)), atomic_list_concat([D,'/kb'], KD), assert(kp_dir(KD)), 
    print_message(informational,"KB directory is ~a"-[KD]).

/** <module> Dynamic module loader.

Scans a given set of Prolog files in SWISH storage or in a file system directpry, and identifies "knowledge pages", files which:
- are modules named with an URL
Can also export and import SWISH storage to/from a file system directory.
*/

:- dynamic kp_location/4. % URL,File,ModifiedTime,InGitty
kp_location(URL,File,InGitty) :- kp_location(URL,File,_,InGitty).

kp(URL_) :- 
    (nonvar(URL_) -> atom_string(URL,URL_);URL=URL_),
    kp_location(URL,_,_).

%! discover_kps_in_dir(+Dir) is det.
%
discover_kps_in_dir(Dir) :-
    retractall(kp_location(_,_,_,false)),
    forall(directory_member(Dir,File,[extensions([pl])]), (
        time_file(File,Modified),
        open(File,read,In),
        process_file(In,File,Modified,false)
    )).

% This also RELOADS modules already loaded
discover_kps_in_dir :-
    kp_dir(D), discover_kps_in_dir(D).

process_file(In,File,Modified,InGitty) :-
    must_be(boolean,InGitty),
    setup_call_cleanup( true, (
        process_terms(In, LastTerm),
        % (LastTerm=at(Name) -> (
        (LastTerm=(:-module(Name,_)) -> (
            ((kp_location(Name,PreviousFile,PreviousMod,InGitty), PreviousMod>=Modified) -> 
                print_message(warning,ignored_older_module(Name,PreviousFile,File)) ; 
                (
                    (kp_location(Name,PreviousFile,_,InGitty) -> 
                        print_message(warning,using_newer_module(Name,PreviousFile,File)) 
                        ; true),
                    retractall(kp_location(Name,_,_,InGitty)),
                    assert(kp_location(Name,File,Modified,InGitty)),
                    % reload the module if it already exists:
                    (current_module(Name) -> load_named_file(File,Name,InGitty) ; true)
                ))
            ); true)
    ), close(In)).

prolog:message(ignored_older_module(Module,PreviousFile,File)) --> 
    ['Ignored older file ~a for module ~w; sticking to ~a'-[File,Module,PreviousFile]].
prolog:message(using_newer_module(Module,PreviousFile,File)) --> 
    ['Forgot older file ~a for module ~w; using instead ~a'-[PreviousFile,Module,File]].

process_terms(In,Term) :- % actually gets only the first term, where the module declaration must be:
    %repeat, 
    read_term(In, Term, [syntax_errors(fail)]),
    ( Term==end_of_file, ! ; 
        Term= (:- module(URL,_)), is_absolute_url(URL), ! ; 
        true
        %Term=at(Name), (ground(Name)->true; print_message(warning,'ignored'(at(Name))), fail) 
    ).


declare_our_metas(Module) :-
    Module:meta_predicate(mainGoal(0,+)),
    Module:meta_predicate(on(0,?)),
    Module:meta_predicate(because(0,-)).

% load_named_file(+File,+Module,+InGittyStorage)
load_named_file(File,Module,InGittyStorage) :-
    load_named_file_(File,Module,InGittyStorage),
    kp_file_modified(Module,Modified,InGittyStorage),
    retractall(kp_location(Module,File,_,InGittyStorage)),
    assert(kp_location(Module,File,Modified,InGittyStorage)),
    (xref_source(Module,[silent(true)]) -> true ; print_message(warning,"failed xref_source"-[])).

load_named_file_(File,Module,true) :- !,
    %print_message(informational, "load File into Module ~w ~w\n"-[File, Module]), 
    use_gitty_file(Module:File,[/* useless: module(Module)*/]).
load_named_file_(File,Module,false) :- 
    load_files(File,[module(Module)]).

load_kps :- 
    forall(kp_location(URL,File,InGitty), (
        load_named_file(File,URL,InGitty)
    )).

setup_kp_modules :- forall(kp(M), setup_kp_module(M) ).

setup_kp_module(M) :-
    M:discontiguous((if)/2),
    M:discontiguous((on)/2),
    M:discontiguous((because)/2),
    M:discontiguous(question/2), M:discontiguous(question/3),
    declare_our_metas(M).

all_kps_loaded :- all_kps_loaded(_).

all_kps_loaded(KP):-
    print_message(informational,"Loading Knowledge Page(s)..(~w)"-[KP]),
    forall(kp(KP),loaded_kp(KP)).

:- thread_local module_api_hack/1.

%! loaded_kp(++KnowledgePageName) is nondet.
%
%  loads the knowledge page, failing if it cannot
loaded_kp(Name) :- module_api_hack(Name), !.
loaded_kp(Name) :- must_be(nonvar,Name), shouldMapModule(_,Name), !. % SWISH module already loaded 
loaded_kp(Name) :- \+ kp_location(Name,_,_), !, 
    (\+ reported_missing_kp(Name) -> (
        assert(reported_missing_kp(Name)), print_message(error,"Unknown knowledge page: ~w"-[Name])) 
        ; true), 
    fail.
loaded_kp(Name) :- % some version already loaded:
    module_property(Name,last_modified_generation(T)), T>0, 
    !,
    once(( kp_file_modified(Name,FT,InGitty), kp_location(Name,File,LastModified,InGitty) )), 
    (FT>LastModified -> (
        load_named_file(File,Name,InGitty), 
        print_message(informational,"Reloaded ~w"-[Name])
        ) ; true).
loaded_kp(Name) :- kp_location(Name,File,InGitty), !, % first load:
    load_named_file(File,Name,InGitty),
    (\+ reported_loaded_kp(Name) -> (
        print_message(informational,loaded(Name,File)), assert(reported_loaded_kp(Name))) 
        ; true).
loaded_kp(Name) :- 
    \+ reported_missing_kp(Name), 
    print_message(error,no_kp(Name)), 
    assert(reported_missing_kp(Name)), fail.

kp_file_modified(Name,Time,InGitty) :- 
    kp_location(Name,File,InGitty),
    (InGitty==true -> (storage_meta_data(File, Meta), Time=Meta.time) ; time_file(File,Time)).


:-thread_local reported_missing_kp/1.
:-thread_local reported_loaded_kp/1.

reset_errors :- 
    retractall(reported_missing_kp(_)), retractall(reported_loaded_kp(_)).

prolog:message(loaded(Module,Path)) --> ['Loaded ~w from ~a'-[Module,Path]].


% Support xref for gitty and file system files
:- multifile
	prolog:xref_source_identifier/2,
	prolog:xref_open_source/2,
    prolog:xref_close_source/2,
    prolog:xref_source_time/2,
    prolog:meta_goal/2.

prolog:xref_source_identifier(URL, URL) :- kp_location(URL,_,_).

prolog:xref_open_source(URL, Stream) :-
    kp_location(URL,File,InGitty),
    (InGitty==true -> (storage_file(File,Data,_Meta), open_string(Data, Stream))
        ; (open(File,read,Stream))).

prolog:xref_close_source(_, Stream) :-
	close(Stream).

prolog:xref_source_time(URL, Modified) :-
    kp_location(URL,_File,Modified,_InGitty).


%! xref_all is det
%
% refresh xref database for all knowledge pages %TODO: report syntax errors properly
xref_all :- 
    forall(kp_location(URL,File,_), (
        print_message(informational,xreferencing(URL,File)), 
        xref_source(URL,[silent(true)]) % to avoid spurious warnings for mainGoal singleton vars
    )).

prolog:message(xreferencing(URL,File)) --> ['Xreferencing module ~w in file ~w'-[URL,File]].
prolog:message(no_kp(Name)) --> ["Could not find knowledge page ~w"-[Name]].

xref_clean :-
    forall(kp_location(URL,_,_), xref_clean(URL)).


% kp_predicate_mention(?Module,?PredicateTemplate,?How) How is called_by(KP)/defined
% Considers undefined predicates too; ignores mentions from example scenarios
kp_predicate_mention(KP,G,How) :-
    (nonvar(KP) -> true ; kp(KP)),
    ( xref_defined(KP,G,_), How=defined ; 
      xref_called(KP, Called, _By), (Called=_:G->true;Called=G), How=called_by(KP)
      ),
    \+ prolog:meta_goal(G,_), \+ system_predicate(G).

%! predicate_argnames(+KP,?PredicateTemplate) is nondet.
%  Grounds argument variables with their source names AS MUCH AS POSSIBLE, using system meta information from the clauses mentioning the predicate
%  KP must be already loaded. Anonymous variables are not ground.
predicate_literal(M,Pred) :- must_be(nonvar,M),
    (M:clause(Pred,Body,Ref) ; my_xref_called(M,Pred,By), clause(M:By,Body,Ref), \+ \+ contains_term(Pred,Body)), 
    clause_info(Ref,_,_,_,[variable_names(Names)]),
    bind_vars_with_names(Pred:-Body,Names).
%TODO: should use a contains_term with variant/2 instead

%! bind_vars_with_names(?Term,+VarNames)
% VarNames is a list of Name=Var
bind_vars_with_names(T,VN) :- bind_vars_with_names(T,VN,_).

bind_vars_with_names(_,[],[]) :- !.
bind_vars_with_names(V,[Name=Var|VN],NewVN) :- var(V), !, 
    (var(Var) -> (Var=V,Name=Var,NewVN=VN) ; (bind_vars_with_names(V,VN,NewVN))).
bind_vars_with_names(X,VN,VN) :- atomic(X), !.
bind_vars_with_names([X1|Xn],VN1,VNn) :- !, bind_vars_with_names(X1,VN1,VN2), bind_vars_with_names(Xn,VN2,VNn).
bind_vars_with_names(X,VN1,VNn) :- compound_name_arguments(X,_,Args), bind_vars_with_names(Args,VN1,VNn).

print_kp_predicates :- print_kp_predicates(_).

% This also LOADS the modules, to access the examples:
print_kp_predicates(KP) :- %TODO: ignore subtrees of because/2
    all_kps_loaded,
    forall(kp(KP),(
        format("---~nKP: ~w~n",[KP]),
        format("  Examples:~n"),
        forall(catch(KP:example(Name,Scenarios),_,fail),(
            aggregate(sum(N),( member(scenario(Facts,_Assertion),Scenarios), length(Facts,N)), Total),
            format("    ~w: ~w facts~n",[Name,Total])
            )),
        format("  Instance data:~n"),
        forall(xref_defined(KP,G,thread_local(_)), (
            functor(G,F,N), format("    ~w~n",[F/N])
            )),
        format("  Defined predicates:~n"),
        forall((xref_defined(KP,G,How),How\=thread_local(_)), (
            functor(G,F,N), format("    ~w~n",[F/N])
        )),
        format("  External predicates called:~n"),
        forall((
            xref_called(KP, Called, _By),
            Called=Other:G, Other\=KP,
            (\+ prolog:meta_goal(G,_))
            ), 
            (functor(G,F,N), format("    ~w (~w)~n",[F/N,Other]))
        ),
        format("  UNDEFINED predicates:~n"),
        forall((
            xref_called(KP, Called, _), 
            (Called=Other:G -> Other\=KP ; (Called=G,Other=KP)),
            (\+ prolog:meta_goal(G,_)),
            \+ my_xref_defined(Other,G,_),
            \+ system_predicate(G)
            ), 
            (functor(G,F,N), format("    ~w (~w)~n",[F/N,Other]))
        )

    )). 

% check that the source has already been xref'ed, otherwise xref would try to load it and cause an "iri_scheme" error:
my_xref_defined(M,G,Class) :- 
    xref_current_source(M), xref_defined(M,G,Class).
my_xref_called(M,Pred,By) :-
    xref_current_source(M), xref_called(M,Pred,By).

system_predicate(G) :- predicate_property(G,built_in). 
system_predicate(G) :- kp_dir(D), predicate_property(G,file(F)), \+ sub_atom(F,_,_,_,D).
system_predicate(example(_,_)).
system_predicate(mainGoal(_,_)).
system_predicate(query(_,_)).
system_predicate(question(_,_)).
system_predicate(question(_,_,_)).
system_predicate(irrelevant_explanation(_)).
system_predicate(function(_,_)).

url_simple(URL,Simple) :- \+ sub_atom(URL,_,_,_,'/'), !, 
    Simple=URL.
url_simple(URL,Simple) :- 
    parse_url(URL,L), memberchk(path(P),L), atomics_to_string(LL,'/',P), 
    ((last(LL,Simple),Simple\='') -> true ;
        LL = [Simple] -> true;
        append(_,[Simple,_],LL)),
    !.
url_simple(URL,URL).
    
:- meta_predicate(must_succeed(0,+)).
must_succeed(G,_) :- G, !.
must_succeed(G,M) :- throw("weird_failure_of of ~w: ~w"-[G,M]).

must_succeed(G) :- must_succeed(G,'').

:- thread_local myDeclaredModule_/1. % remembers the module declared in the last SWISH window loaded
% filters the SWISH declared module with known KPs; the term_expansion hack catches a lot of other modules too, such as 'http_stream'
myDeclaredModule(M) :- myDeclaredModule_(M), kp(M), !.

swish_editor_path(KP,Path) :- must_be(nonvar,KP),
    (kp_location(KP,File,true)->true;File=not_on_swish_storage),
    format(string(Path),"/p/~a",[File]), !.


:- if(current_module(swish)). %%% only when running with the SWISH web server:
:- use_module(swish(lib/storage)).
:- use_module(swish(lib/gitty)).
:- use_module(library(pengines)).

%! discover_kps_gitty is det.
%
%  Scans all Prolog files in SWISH's gitty storage for knowledge pages. RELOADS
%  already loaded modules, but does not delete "orphans" (modules no longer in gitty)
%  TODO: use '$destroy_module'(M) on those?
discover_kps_gitty :-
    retractall(kp_location(_,_,_,true)),
    forall(storage_file_extension(File,pl),(
        storage_file(File,Data,Meta),
        open_string(Data, In),
        process_file(In,File,Meta.time,true)
    )).

%! save_gitty_files(+ToDirectory) is det
%
%  ERASES the directory and copies all gitty Prolog files into it
%  MAKE SURE ToDirectory has source versioning control!
save_gitty_files(_ToDirectory) :- \+ storage_file_extension(_File,pl), !, 
    print_message(warning,"No gitty files to save"-[]).
save_gitty_files(ToDirectory) :-
    (exists_directory(ToDirectory)->true; make_directory(ToDirectory)),
    delete_directory_contents(ToDirectory),
    forall(storage_file_extension(File,pl),(
        storage_file(File,Data,Meta),
        directory_file_path(ToDirectory,File,Path),
        open(Path,write,S), write_term(S,Data,[]), close(S),
        set_time_file(Path, _OldTimes, [modified(Meta.time)])
        )).

save_gitty_files :- 
    kp_dir(D), save_gitty_files(D).

%! load_gitty_files(+FromDirectory) is det
%
%  Updates or creates (in gitty storage) all Prolog files from the given file system directory; sub-directories are ignored.
%  Does not delete the other (pre-existing) gitty files
% Example: load_gitty_files('/Users/mc/git/TaxKB/kb').
load_gitty_files(From) :- 
    forall(directory_member(From,Path,[extensions([pl])]),(
        read_file_to_string(Path,Data,[]),
        time_file(Path,Modified),
        directory_file_path(_,File,Path),
        update_gitty_file(File,Modified,From,Data)
    )).

load_gitty_files :-
    kp_dir(D), load_gitty_files(D).

% update_gitty_file(+Filename,+ModifiedTime,+Origin,+Text)
update_gitty_file(File,Modified,Origin,Data) :-
    web_storage:open_gittystore(Store),
    current_user(User,_Email),
    (gitty_file(Store, File, OldHead) -> (
        storage_meta_data(File, Meta), 
        NewMeta = Meta.put([previous=OldHead, modify=[any, login, owner], (public)=true, time=Modified, author=User]),
        gitty_update(Store, File, Data, NewMeta, _CommitRet)
        ) ; (
        gitty_create(Store, File, Data, _{update_gitty_file:Origin, modify:[any, login, owner], public:true, time:Modified, author:User }, _CommitRet)
        )
    ).

update_gitty_file(File,Origin,Data) :- 
    get_time(Now), update_gitty_file(File,Now,Origin,Data).

%! delete_gitty_file(+GittyFile) is det
%
% makes the file empty, NOT a proper delete
delete_gitty_file(File) :-
    must_be(nonvar,File),
    web_storage:open_gittystore(Store),
    gitty_file(Store, File, OldHead),
    % I was unable to effectively delete:
    % gitty:delete_head(Store, OldHead), gitty:delete_object(Store, OldHead), % this is only effective after a SWISH restart
    % broadcast(swish(deleted(File, OldHead))). % not doing anything, possibly missing something on the JS end
    % ... instead this does roughly what the DELETE REST SWISH endpoint in storage.pl does:
    storage_meta_data(File, Meta),
    NewMeta = Meta.put([previous=OldHead]),
    gitty_update(Store, File, "", NewMeta, _CommitRet).

:- listen(swish(X),reactToSaved(X)). % note: do NOT use writes!, they would interfere with SWISH's internal REST API
/*
reactToSaved(created(GittyFile,Commit)) :- % discover and xref
    storage_file(GittyFile,Data,Meta), process_file(Data,GittyFile,Meta.time,true), 
    reactToSaved(updated(GittyFile,Commit)).
reactToSaved(updated(GittyFile,_Commit)) :- % xref
    kp_location(URL,GittyFile,true), 
    xref_source(URL,[silent(true)]).
*/

reactToSaved(created(GittyFile,Commit)) :-
    reactToSaved(updated(GittyFile,Commit)).
reactToSaved(updated(GittyFile,_Commit)) :- % discover (module name may have changed...) and xref
    %mylog(updated(GittyFile,_Commit)),
    storage_file(GittyFile,Data,Meta), 
    open_string(Data,In),
    must_succeed(process_file(In,GittyFile,Meta.time,true)), 
    (kp_location(URL,GittyFile,true) -> xref_source(URL,[silent(true)]) ; 
        print_message(warning,"Could not find URL for ~w"-[GittyFile])).

%! edit_kp(URL) is det
%
% Open the current gitty version of the knowledge page in SWISH's editor
edit_kp(KP) :-
    kp_location(KP,_File,InGitty),
    (InGitty==(false) -> print_message(error,"~w is not in SWISH storage"-[KP]);(
        swish_editor_path(KP,Path),
        format(string(URL),"http://localhost:3050~a",[Path]), www_open_url(URL)
        )).

%%%% Knowledge pages graph

:- multifile user:'swish renderer'/2. % to avoid SWISH warnings in other files
:- use_rendering(user:graphviz).

knowledgePagesGraph(KP,dot(digraph([rankdir='LR'|Graph]))) :- 
    % xref_defined(KP, Goal, ?How)
    setof(edge(From->To,[]), KP^Called^By^ByF^ByN^OtherKP^G^CalledF^CalledN^How^(
        kp(KP), xref_called(KP, Called, By),
        functor(By,ByF,ByN), From = at(ByF/ByN,KP),
        (Called=OtherKP:G -> true ; ( once(xref_defined(KP,Called,How)), OtherKP=KP, G=Called)),
        \+ prolog:meta_goal(G,_),
        functor(G,CalledF,CalledN), To = at(CalledF/CalledN,OtherKP) 
        %term_string(From_,From,[quoted(false)]), term_string(To_,To,[quoted(false)]), url_simple(ArcRole_,ArcRole)
        ),Edges), 
    setof(node(ID,[/*shape=Shape*/label=Label]), KP^Goal^How^GF^GN^From^EA^Pred^Abrev^(
        (
            kp(KP), xref_defined(KP, Goal, How),
            functor(Goal,GF,GN),
            ID = at(GF/GN,KP)
            ;
            member(edge(From->ID,EA),Edges) % calls to undefined predicates
        ),
        ID=at(Pred,KP), url_simple(KP,Abrev),
        format(string(Label),"~w at ~w",[Pred,Abrev])
        %(hypercube(R,ID) -> Shape=box3d ; Shape=ellipse)
        ), Nodes),
    append(Nodes,Edges,Items),
    Graph=Items.
    %(var(SizeInches) -> Graph=Items ; Graph = [size=SizeInches|Items]).

knowledgePagesGraph(G) :- knowledgePagesGraph(_,G).

:- multifile sandbox:safe_primitive/1.
sandbox:safe_primitive(kp_loader:knowledgePagesGraph(_,_)).
sandbox:safe_primitive(kp_loader:print_kp_predicates(_)).
sandbox:safe_primitive(kp_loader:load_gitty_files). %TODO: this should be restricted to power users
sandbox:safe_primitive(kp_loader:save_gitty_files).
sandbox:safe_primitive(kp_loader:all_kps_loaded).
sandbox:safe_primitive(web_storage:open_gittystore(_)).
sandbox:safe_primitive(gitty:gitty_file(_, _, _)).
sandbox:safe_primitive(gitty:load_commit(_,_,_)). 
sandbox:safe_primitive(gitty:gitty_update(_, _, _, _, _)). 
sandbox:safe_primitive(gitty:size_in_bytes(_,_)). 
sandbox:safe_primitive(gitty:save_object(_,_,_,_)).
sandbox:safe_primitive(gitty:gitty_create(_,_,_,_,_)).

%%%% assist editor navigation; cf. swish/web/js/codemirror/mode/prolog/prolog_server.js

:- use_module(library(http/http_json)).
:- use_module(library(http/http_dispatch)).
:- use_module(library(http/http_parameters)).

:- http_handler(codemirror(xref),   token_references,        []).
token_references(Request) :-
    %http_read_json_dict(Request, Query, [value_string_as(atom)]),
    http_parameters(Request, [arity(Arity,[integer]),text(Text,[]),type(Type,[]),file(Module,[optional(true)]),uuid(UUID,[optional(true)])]),
    % UUID is the SWISH internal module for our current editor's text
    % mylog(gotQuery/Type/Text/Arity/Module/UUID),
    % asserta(my_request(Query)), % for debugging
    (nonvar(UUID) -> (xref_module(UUID,MyModule), Ignorable=[UUID,MyModule]); Ignorable=[]),
    catch(term_string(Term_,Text),_,fail), 
    functor(Term_,Functor,_),
    (atom(Term_) -> functor(Term,Functor,Arity); Term=Term_), % hack to fix longclicks on body goals
    (sub_atom(Type, 0, _, _, head) -> ( % a clause head
        must_be(var,Module),
        findall( _{title:Title,line:Line,file:File,target:Functor}, ( % regex built on the Javascript side from target
            xref_called(OtherModule,_Mine:Term,By,_Cond,Line), functor(By,F,N), format(string(Title),"A call from ~w",[F/N]),
            \+ member(OtherModule,Ignorable),
            kp_location(OtherModule,File,_InGitty) 
            ),Locations)
        ) ; 
        sub_atom(Type, 0, _, _, goal) -> ( % a goal in a clause body
            findall( _{title:Title,line:Line,file:File,target:Functor}, ( 
            xref_defined(Module,Term,How), arg(1,How,Line), format(string(Title),"A definition for ~a",[Text]),
            kp_location(Module,File,_InGitty) 
            ),Locations)
        ) ; 
        throw(weird_token_type(Type))
    ),
    %Solution = _{hello: "Good Afternoon!", functor:Functor, arity:Arity, module:File},
    reply_json_dict(Locations).

% This at the end, as it activates the term expansion (no harm done otherwise, just some performance..):
user:term_expansion((:-module(M,L)),(:-module(M,L))) :- !, assert(myDeclaredModule_(M)). 
:- multifile pengines:prepare_module/3.
:- thread_local myCurrentModule/1. % the new temporary SWISH module where our query runs
pengines:prepare_module(Module, swish, _Options) :- 
    % this seems to hold always, but commenting it out just in case...: assertion( \+ myCurrentModule(_)),
    setup_kp_module(Module),
    assert(myCurrentModule(Module)).
    % should we perhaps use this_capsule...??
% there is (just arrived from the SWISH editor) a fresher version To of the declared module From
% ...OR there WAS,  although it no longer exists
shouldMapModule(From,To) :- myDeclaredModule(From), kp(From), myCurrentModule(To), !, 
    (moduleMapping(From,To)->true;(assert(moduleMapping(From,To)))).

:- dynamic moduleMapping/2. % Nice module->transient SWISH module; remembers previous mappings, to support UI navigation later, e.g. from explanations


current_user(User,Email) :- 
    pengine_user(U), get_dict(user,U,User), Email=U.user_info.email, 
    !.
current_user(unknown_user,unknown_email).

:- else. % vanilla SWI-Prolog

current_user(unknown_user,unknown_email).

shouldMapModule(_,_) :- fail.
moduleMapping(_,_) :- fail.

%! edit_kp(URL) is det
%
% Open the filed version of the knowledge page in the user editor
edit_kp(URL) :-
    kp_location(URL,File,InGitty),
    (InGitty==(true) -> print_message(error,"That is in SWISH storage, not in the file system!");(
        edit(file(File))
        )).

discover_kps_gitty :- print_message(informational,'this only works on SWISH'-[]).
load_gitty_files :- throw('this only works on SWISH ').
load_gitty_files(_) :- throw('this only works on SWISH ').
save_gitty_files(_) :- throw('this only works on SWISH ').
save_gitty_files :- throw('this only works on SWISH ').
delete_gitty_file(_) :- throw('this only works on SWISH ').
update_gitty_file(_,_,_) :- throw('this only works on SWISH ').

knowledgePagesGraph(_,_) :- throw('this only works on SWISH').
knowledgePagesGraph(_) :- throw('this only works on SWISH').
gitty_file(_,_,_) :- throw('this only works in SWISH gitty'). 
gitty_update(_, _, _, _, _) :- throw('this only works in SWISH gitty'). 
:- endif.