Dasemu
40631362b3
Establishes version control for the personal Logseq DB fork before starting the server-client architecture migration and domain features described in docs/agent-guide and the approved implementation plan. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
1151 lines
41 KiB
OCaml
1151 lines
41 KiB
OCaml
let is_option token = String.length token > 0 && token.[0] = '-'
|
|
let option_value key options =
|
|
Vec.find_map
|
|
(fun (candidate, value) -> if candidate = key then value else None)
|
|
options
|
|
let option_present key options = Vec.mem_assoc key options
|
|
|
|
let normalize_key = function
|
|
| "-g" -> Some "graph"
|
|
| "-o" -> Some "output"
|
|
| "-c" -> Some "content"
|
|
| "-e" -> Some "edn-options"
|
|
| "-f" -> Some "fields"
|
|
| "-h" -> Some "help"
|
|
| "-p" -> Some "pretty-print"
|
|
| "-s" -> Some "sort"
|
|
| "-t" -> Some "type"
|
|
| "-v" -> Some "verbose"
|
|
| token when String.length token > 2 && String.sub token 0 2 = "--" ->
|
|
Some (String.sub token 2 (String.length token - 2))
|
|
| _ -> None
|
|
|
|
let split_equals_option token =
|
|
match String.index_opt token '=' with
|
|
| None -> None
|
|
| Some index ->
|
|
let key = String.sub token 0 index in
|
|
let value =
|
|
String.sub token (index + 1) (String.length token - index - 1)
|
|
in
|
|
Option.map (fun key -> (key, value)) (normalize_key key)
|
|
|
|
let boolean_option = function
|
|
| "version" | "help" | "verbose" | "profile" | "enable-sync" | "expand"
|
|
| "fix"
|
|
| "include-built-in" | "include-journal" | "journal-only" | "include-hidden"
|
|
| "with-properties" | "with-extends" | "with-classes" | "with-type"
|
|
| "page-hierarchy" | "linked-references" | "ref-id-footer" | "progress"
|
|
| "upload-keys" | "pretty-print" ->
|
|
true
|
|
| _ -> false
|
|
|
|
let boolean_literal value =
|
|
match String.lowercase_ascii (String.trim value) with
|
|
| "true" | "false" -> true
|
|
| _ -> false
|
|
|
|
let parse_tokens argv =
|
|
let rec loop options positional remaining =
|
|
match Vec.pop_front remaining with
|
|
| None -> (options, positional)
|
|
| Some ("--", rest) -> (options, Vec.append positional rest)
|
|
| Some (token, rest) -> (
|
|
match split_equals_option token with
|
|
| Some (key, value) ->
|
|
loop (Vec.push_back options (key, Some value)) positional rest
|
|
| None -> (
|
|
match normalize_key token with
|
|
| Some key when boolean_option key -> (
|
|
match Vec.pop_front rest with
|
|
| Some (value, tail) when boolean_literal value ->
|
|
loop
|
|
(Vec.push_back options (key, Some value))
|
|
positional tail
|
|
| _ ->
|
|
loop
|
|
(Vec.push_back options (key, Some "true"))
|
|
positional rest)
|
|
| Some key -> (
|
|
match Vec.pop_front rest with
|
|
| Some (value, tail) when not (is_option value) ->
|
|
loop
|
|
(Vec.push_back options (key, Some value))
|
|
positional tail
|
|
| _ -> loop (Vec.push_back options (key, None)) positional rest)
|
|
| None -> loop options (Vec.push_back positional token) rest))
|
|
in
|
|
loop Vec.empty Vec.empty argv
|
|
|
|
let globals_of_options options =
|
|
Global_opts.create
|
|
?graph:
|
|
(Option.map Cli_primitive.create_graph (option_value "graph" options))
|
|
?root_dir:(option_value "root-dir" options)
|
|
?config_path:(option_value "config" options)
|
|
?timeout_span:
|
|
(Option.map Time.span_of_ms
|
|
(Option.bind (option_value "timeout-ms" options) Int64.of_string_opt))
|
|
?output_format:
|
|
(Option.bind (option_value "output" options) Output.Mode.of_string)
|
|
~verbose:(option_present "verbose" options)
|
|
~profile:(option_present "profile" options)
|
|
()
|
|
|
|
let parse_csv value =
|
|
Vec.split_on_char ',' value
|
|
|> Vec.map String.trim
|
|
|> Vec.filter (fun value -> value <> "")
|
|
|
|
let int_option key options =
|
|
Option.bind (option_value key options) int_of_string_opt
|
|
|
|
let int64_option key options =
|
|
Option.bind (option_value key options) Int64.of_string_opt
|
|
|
|
let time_option key options =
|
|
Option.bind (option_value key options) Time.parse_time
|
|
|
|
let bool_option_value key options =
|
|
match option_value key options with
|
|
| Some value -> Some (String.lowercase_ascii (String.trim value) = "true")
|
|
| None -> if option_present key options then Some true else None
|
|
|
|
|
|
let common_list_opts options =
|
|
{
|
|
List_command.fields = Option.map parse_csv (option_value "fields" options);
|
|
limit = int_option "limit" options;
|
|
offset = int_option "offset" options;
|
|
sort = option_value "sort" options;
|
|
order =
|
|
Option.bind (option_value "order" options) List_command.order_of_string;
|
|
}
|
|
|
|
let optional_flag key options = bool_option_value key options
|
|
|
|
let graph_export_type options =
|
|
Option.bind
|
|
(Option.map String.lowercase_ascii (option_value "type" options))
|
|
Graph.normalize_export_type
|
|
|
|
let graph_import_type options =
|
|
Option.bind
|
|
(Option.map String.lowercase_ascii (option_value "type" options))
|
|
Graph.normalize_import_type
|
|
|
|
let global_options =
|
|
Vec.of_array
|
|
[|
|
|
"graph";
|
|
"root-dir";
|
|
"config";
|
|
"timeout-ms";
|
|
"output";
|
|
"verbose";
|
|
"profile";
|
|
"help";
|
|
"version";
|
|
|]
|
|
|
|
let common_list_options =
|
|
Vec.of_array [| "fields"; "limit"; "offset"; "sort"; "order" |]
|
|
|
|
let option_names values = Vec.of_array values
|
|
let path1 path a = Vec.length path = 1 && Vec.nth path 0 = a
|
|
|
|
let path2 path a b =
|
|
Vec.length path = 2 && Vec.nth path 0 = a && Vec.nth path 1 = b
|
|
|
|
let path3 path a b c =
|
|
Vec.length path = 3
|
|
&& Vec.nth path 0 = a
|
|
&& Vec.nth path 1 = b
|
|
&& Vec.nth path 2 = c
|
|
|
|
let path2_any path a choices =
|
|
Vec.length path = 2 && Vec.nth path 0 = a && Vec.mem (Vec.nth path 1) choices
|
|
|
|
let path3_any path a b choices =
|
|
Vec.length path = 3
|
|
&& Vec.nth path 0 = a
|
|
&& Vec.nth path 1 = b
|
|
&& Vec.mem (Vec.nth path 2) choices
|
|
|
|
let allowed_options_for_path path =
|
|
if
|
|
path2_any path "graph"
|
|
(option_names [| "list"; "switch"; "remove"; "info" |])
|
|
|| path3 path "graph" "backup" "list"
|
|
then Vec.empty
|
|
else if path2 path "graph" "create" then
|
|
option_names [| "enable-sync"; "e2ee-password" |]
|
|
else if path2 path "graph" "validate" then option_names [| "fix" |]
|
|
else if path3 path "graph" "backup" "create" then option_names [| "name" |]
|
|
else if path3 path "graph" "backup" "restore" then
|
|
option_names [| "src"; "dst" |]
|
|
else if path3 path "graph" "backup" "remove" then option_names [| "src" |]
|
|
else if path2 path "graph" "export" then
|
|
option_names [| "type"; "file"; "edn-options"; "pretty-print" |]
|
|
else if path2 path "graph" "import" then option_names [| "type"; "input" |]
|
|
else if path2 path "list" "page" then
|
|
Vec.append common_list_options
|
|
(option_names
|
|
[|
|
|
"expand";
|
|
"include-built-in";
|
|
"include-journal";
|
|
"journal-only";
|
|
"include-hidden";
|
|
"updated-after";
|
|
"created-after";
|
|
|])
|
|
else if path2 path "list" "tag" then
|
|
Vec.append common_list_options
|
|
(option_names
|
|
[| "expand"; "include-built-in"; "with-properties"; "with-extends" |])
|
|
else if path2 path "list" "property" then
|
|
Vec.append common_list_options
|
|
(option_names
|
|
[| "expand"; "include-built-in"; "with-classes"; "with-type" |])
|
|
else if path2 path "list" "task" then
|
|
Vec.append common_list_options
|
|
(option_names [| "status"; "priority"; "content" |])
|
|
else if path2 path "list" "node" then
|
|
Vec.append common_list_options (option_names [| "tags"; "properties" |])
|
|
else if path2 path "list" "asset" then common_list_options
|
|
else if path2 path "remove" "block" then option_names [| "id"; "uuid" |]
|
|
else if path2 path "remove" "page" then option_names [| "id"; "page" |]
|
|
else if path2_any path "remove" (option_names [| "tag"; "property" |]) then
|
|
option_names [| "id"; "name" |]
|
|
else if path2 path "upsert" "block" then
|
|
option_names
|
|
[|
|
|
"id";
|
|
"uuid";
|
|
"target-id";
|
|
"target-uuid";
|
|
"target-page";
|
|
"pos";
|
|
"content";
|
|
"blocks";
|
|
"blocks-file";
|
|
"update-tags";
|
|
"update-properties";
|
|
"remove-tags";
|
|
"remove-properties";
|
|
|]
|
|
else if path2 path "upsert" "page" then
|
|
option_names
|
|
[|
|
|
"id";
|
|
"page";
|
|
"restore";
|
|
"update-tags";
|
|
"update-properties";
|
|
"remove-tags";
|
|
"remove-properties";
|
|
|]
|
|
else if path2 path "upsert" "asset" then
|
|
option_names
|
|
[|
|
|
"id";
|
|
"uuid";
|
|
"path";
|
|
"target-id";
|
|
"target-uuid";
|
|
"target-page";
|
|
"pos";
|
|
"content";
|
|
|]
|
|
else if path2 path "upsert" "task" then
|
|
option_names
|
|
[|
|
|
"id";
|
|
"uuid";
|
|
"page";
|
|
"content";
|
|
"target-id";
|
|
"target-uuid";
|
|
"target-page";
|
|
"pos";
|
|
"status";
|
|
"priority";
|
|
"scheduled";
|
|
"deadline";
|
|
"no-status";
|
|
"no-priority";
|
|
"no-scheduled";
|
|
"no-deadline";
|
|
|]
|
|
else if path2 path "upsert" "tag" then
|
|
option_names [| "id"; "name"; "add-properties"; "remove-properties" |]
|
|
else if path2 path "upsert" "property" then
|
|
option_names [| "id"; "name"; "type"; "cardinality"; "hide"; "public" |]
|
|
else if
|
|
path2_any path "search"
|
|
(option_names [| "block"; "page"; "property"; "tag" |])
|
|
then option_names [| "content" |]
|
|
else if path2 path "query" "list" then Vec.empty
|
|
else if path1 path "query" then option_names [| "query"; "name"; "inputs" |]
|
|
else if path1 path "show" then
|
|
option_names
|
|
[|
|
|
"id";
|
|
"uuid";
|
|
"page";
|
|
"page-hierarchy";
|
|
"linked-references";
|
|
"ref-id-footer";
|
|
"level";
|
|
|]
|
|
else if
|
|
path2_any path "server"
|
|
(option_names [| "list"; "cleanup"; "start"; "stop"; "restart" |])
|
|
then Vec.empty
|
|
else if
|
|
path2_any path "sync" (option_names [| "status"; "stop"; "remote-graphs" |])
|
|
|| path3_any path "sync" "config" (option_names [| "get"; "unset" |])
|
|
then Vec.empty
|
|
else if path2_any path "sync" (option_names [| "start"; "upload" |]) then
|
|
option_names [| "e2ee-password" |]
|
|
else if path2 path "sync" "download" then
|
|
option_names [| "progress"; "e2ee-password" |]
|
|
else if path3 path "sync" "asset" "download" then
|
|
option_names [| "id"; "uuid" |]
|
|
else if path2 path "sync" "ensure-keys" then
|
|
option_names [| "e2ee-password"; "upload-keys" |]
|
|
else if path2 path "sync" "grant-access" then
|
|
option_names [| "graph-id"; "email" |]
|
|
else if path3 path "sync" "config" "set" then Vec.empty
|
|
else if path2 path "debug" "pull" then
|
|
option_names [| "id"; "uuid"; "ident" |]
|
|
else if path1 path "doctor" then option_names [| "dev-script" |]
|
|
else if
|
|
path1 path "login" || path1 path "logout" || path2 path "skill" "show"
|
|
|| path1 path "example"
|
|
then Vec.empty
|
|
else if path1 path "completion" then option_names [| "shell" |]
|
|
else if path2 path "skill" "install" then option_names [| "global" |]
|
|
else Vec.empty
|
|
|
|
let validate_known_options path options =
|
|
let allowed =
|
|
Vec.sort_uniq String.compare
|
|
(Vec.append global_options (allowed_options_for_path path))
|
|
in
|
|
match Vec.find_opt (fun (key, _) -> not (Vec.mem key allowed)) options with
|
|
| Some (key, _) -> Error (Error.invalid_options ("Unknown option: :" ^ key))
|
|
| None -> Ok ()
|
|
|
|
let invalid_value key value message =
|
|
Error.invalid_options
|
|
("Invalid value for option :" ^ key ^ ": " ^ value ^ ". " ^ message)
|
|
|
|
let validate_integer_option key options =
|
|
match Vec.assoc_opt key options with
|
|
| Some (Some value) when Int64.of_string_opt value = None ->
|
|
Error (invalid_value key value "Expected integer")
|
|
| _ -> Ok ()
|
|
|
|
let validate_integer_options keys options =
|
|
Vec.fold_left
|
|
(fun result key ->
|
|
Error.bind result (fun () -> validate_integer_option key options))
|
|
(Ok ()) keys
|
|
|
|
let validate_boolean_option_values options =
|
|
match
|
|
Vec.find_opt
|
|
(fun (key, value) ->
|
|
boolean_option key
|
|
&&
|
|
match value with
|
|
| Some value -> not (boolean_literal value)
|
|
| None -> false)
|
|
options
|
|
with
|
|
| Some (key, Some value) ->
|
|
Error (invalid_value key value "Expected true or false")
|
|
| _ -> Ok ()
|
|
|
|
let validate_member_option key values options =
|
|
match option_value key options with
|
|
| Some value when not (Vec.mem value values) ->
|
|
Error
|
|
(invalid_value key value
|
|
("Available values: " ^ Vec.string_concat ", " values))
|
|
| _ -> Ok ()
|
|
|
|
let validate_csv_member_option key values options =
|
|
match option_value key options with
|
|
| Some value -> (
|
|
match
|
|
Vec.find_opt (fun field -> not (Vec.mem field values)) (parse_csv value)
|
|
with
|
|
| Some invalid ->
|
|
Error
|
|
(invalid_value key invalid
|
|
("Available values: " ^ Vec.string_concat ", " values))
|
|
| None -> Ok ())
|
|
| None -> Ok ()
|
|
|
|
let validate_time_option key options =
|
|
match option_value key options with
|
|
| Some value when Option.is_none (Time.parse_time value) ->
|
|
Error (invalid_value key value "Expected RFC3339 datetime or epoch ms")
|
|
| _ -> Ok ()
|
|
|
|
let list_page_sort_values =
|
|
Vec.of_array [| "id"; "ident"; "title"; "uuid"; "created-at"; "updated-at" |]
|
|
|
|
let list_tag_sort_values =
|
|
Vec.append_array list_page_sort_values
|
|
[| "properties"; "extends"; "description" |]
|
|
|
|
let list_property_sort_values =
|
|
Vec.append_array list_page_sort_values
|
|
[| "classes"; "type"; "cardinality"; "description" |]
|
|
|
|
let list_task_sort_values =
|
|
Vec.of_array
|
|
[|
|
|
"id";
|
|
"title";
|
|
"status";
|
|
"priority";
|
|
"scheduled";
|
|
"deadline";
|
|
"updated-at";
|
|
"created-at";
|
|
|]
|
|
|
|
let list_node_sort_values =
|
|
Vec.of_array
|
|
[|
|
|
"id"; "title"; "type"; "page-id"; "page-title"; "created-at"; "updated-at";
|
|
|]
|
|
|
|
let list_asset_sort_values =
|
|
Vec.of_array
|
|
[| "id"; "title"; "asset-type"; "size"; "updated-at"; "created-at" |]
|
|
|
|
let validate_list_common_values sort_values options =
|
|
Error.bind (validate_integer_option "limit" options) (fun () ->
|
|
Error.bind (validate_integer_option "offset" options) (fun () ->
|
|
Error.bind
|
|
(validate_member_option "order"
|
|
(Vec.of_array [| "asc"; "desc" |])
|
|
options)
|
|
(fun () ->
|
|
Error.bind (validate_member_option "sort" sort_values options)
|
|
(fun () ->
|
|
validate_csv_member_option "fields" sort_values options))))
|
|
|
|
let validate_global_values options =
|
|
Error.bind (validate_integer_option "timeout-ms" options) (fun () ->
|
|
validate_member_option "output"
|
|
(Vec.of_array [| "human"; "json"; "edn" |])
|
|
options)
|
|
|
|
let parse_graph_export_edn_options options =
|
|
match option_value "edn-options" options with
|
|
| None -> Ok None
|
|
| Some text -> (
|
|
try
|
|
let value = Melange_edn_melange.of_edn_string text in
|
|
match Edn_util.as_map value with
|
|
| Some _ -> Ok (Some value)
|
|
| None ->
|
|
Error
|
|
(Error.invalid_options
|
|
"graph export --edn-options must be an EDN map")
|
|
with Melange_edn_melange.Parse_error _ ->
|
|
Error
|
|
(Error.invalid_options "graph export --edn-options must be an EDN map")
|
|
)
|
|
|
|
let validate_non_empty_csv_option key message options =
|
|
match Vec.assoc_opt key options with
|
|
| Some (Some value) when Vec.is_empty (parse_csv value) ->
|
|
Error (Error.invalid_options message)
|
|
| Some None -> Error (Error.invalid_options message)
|
|
| _ -> Ok ()
|
|
|
|
let validate_list_node_values options =
|
|
Error.bind
|
|
(validate_non_empty_csv_option "tags"
|
|
"list node --tags must include at least one non-empty value" options)
|
|
(fun () ->
|
|
validate_non_empty_csv_option "properties"
|
|
"list node --properties must include at least one non-empty value"
|
|
options)
|
|
|
|
let validate_pos_value options =
|
|
validate_member_option "pos"
|
|
(Vec.of_array [| "first-child"; "last-child"; "sibling" |])
|
|
options
|
|
|
|
let validate_selector_integer_values path options =
|
|
if
|
|
path2_any path "remove" (option_names [| "page"; "tag"; "property" |])
|
|
|| path2_any path "upsert" (option_names [| "page"; "tag"; "property" |])
|
|
|| path3 path "sync" "asset" "download"
|
|
|| path2 path "debug" "pull"
|
|
then validate_integer_option "id" options
|
|
else if path2_any path "upsert" (option_names [| "block"; "asset"; "task" |])
|
|
then validate_integer_options (option_names [| "id"; "target-id" |]) options
|
|
else Ok ()
|
|
|
|
let validate_option_values path options =
|
|
Error.bind (validate_selector_integer_values path options) (fun () ->
|
|
if path2 path "graph" "export" then Ok ()
|
|
else if path2 path "list" "page" then
|
|
Error.bind (validate_list_common_values list_page_sort_values options)
|
|
(fun () ->
|
|
Error.bind (validate_time_option "updated-after" options) (fun () ->
|
|
validate_time_option "created-after" options))
|
|
else if path2 path "list" "tag" then
|
|
validate_list_common_values list_tag_sort_values options
|
|
else if path2 path "list" "property" then
|
|
validate_list_common_values list_property_sort_values options
|
|
else if path2 path "list" "task" then
|
|
validate_list_common_values list_task_sort_values options
|
|
else if path2 path "list" "node" then
|
|
Error.bind (validate_list_node_values options) (fun () ->
|
|
validate_list_common_values list_node_sort_values options)
|
|
else if path2 path "list" "asset" then
|
|
validate_list_common_values list_asset_sort_values options
|
|
else if path1 path "show" then validate_integer_option "level" options
|
|
else if path1 path "completion" then
|
|
validate_member_option "shell"
|
|
(Vec.of_array [| "zsh"; "bash" |])
|
|
options
|
|
else if path2 path "upsert" "task" then
|
|
Error.bind (validate_pos_value options) (fun () ->
|
|
Error.bind (validate_time_option "scheduled" options) (fun () ->
|
|
validate_time_option "deadline" options))
|
|
else if path2 path "upsert" "block" || path2 path "upsert" "asset" then
|
|
validate_pos_value options
|
|
else Ok ())
|
|
|
|
let validate_options path options =
|
|
Error.bind (validate_known_options path options) (fun () ->
|
|
Error.bind (validate_boolean_option_values options) (fun () ->
|
|
Error.bind (validate_global_values options) (fun () ->
|
|
validate_option_values path options)))
|
|
|
|
let sync_config_key_or_error = function
|
|
| None -> Ok None
|
|
| Some raw -> (
|
|
match
|
|
Sync.config_key_of_string (String.lowercase_ascii (String.trim raw))
|
|
with
|
|
| Some key -> Ok (Some key)
|
|
| None -> Error (Error.invalid_options ("unknown config key: " ^ raw)))
|
|
|
|
let parsed_remove_command options = function
|
|
| "block" ->
|
|
Some
|
|
(Cli_request.Remove
|
|
(Remove.Parsed_block
|
|
{
|
|
id_raw = option_value "id" options;
|
|
uuid = option_value "uuid" options;
|
|
}))
|
|
| "page" ->
|
|
Some
|
|
(Remove
|
|
(Parsed_page
|
|
{
|
|
id = int64_option "id" options;
|
|
page = option_value "page" options;
|
|
}))
|
|
| "tag" ->
|
|
Some
|
|
(Remove
|
|
(Parsed_tag
|
|
{
|
|
id = int64_option "id" options;
|
|
name = option_value "name" options;
|
|
}))
|
|
| "property" ->
|
|
Some
|
|
(Remove
|
|
(Parsed_property
|
|
{
|
|
id = int64_option "id" options;
|
|
name = option_value "name" options;
|
|
}))
|
|
| _ -> None
|
|
|
|
let content_option_or_args options args =
|
|
match option_value "content" options with
|
|
| Some _ as content -> content
|
|
| None when not (Vec.is_empty args) -> Some (Vec.string_concat " " args)
|
|
| None -> None
|
|
|
|
let parsed_upsert_command ?(args = Vec.empty) options = function
|
|
| "block" ->
|
|
Some
|
|
(Cli_request.Upsert
|
|
(Upsert.Parsed_block
|
|
{
|
|
id = int64_option "id" options;
|
|
uuid = option_value "uuid" options;
|
|
target_id = int64_option "target-id" options;
|
|
target_uuid = option_value "target-uuid" options;
|
|
target_page = option_value "target-page" options;
|
|
pos =
|
|
Option.bind
|
|
(option_value "pos" options)
|
|
Block.position_of_string;
|
|
content = content_option_or_args options args;
|
|
blocks_edn = option_value "blocks" options;
|
|
blocks_file = option_value "blocks-file" options;
|
|
update_tags_edn = option_value "update-tags" options;
|
|
update_properties_edn = option_value "update-properties" options;
|
|
remove_tags_edn = option_value "remove-tags" options;
|
|
remove_properties_edn = option_value "remove-properties" options;
|
|
}))
|
|
| "page" ->
|
|
Some
|
|
(Upsert
|
|
(Parsed_page
|
|
{
|
|
id = int64_option "id" options;
|
|
page = option_value "page" options;
|
|
restore = option_present "restore" options;
|
|
update_tags_edn = option_value "update-tags" options;
|
|
update_properties_edn = option_value "update-properties" options;
|
|
remove_tags_edn = option_value "remove-tags" options;
|
|
remove_properties_edn = option_value "remove-properties" options;
|
|
}))
|
|
| "asset" ->
|
|
Some
|
|
(Upsert
|
|
(Parsed_asset
|
|
{
|
|
id = int64_option "id" options;
|
|
uuid = option_value "uuid" options;
|
|
path = option_value "path" options;
|
|
target_id = int64_option "target-id" options;
|
|
target_uuid = option_value "target-uuid" options;
|
|
target_page = option_value "target-page" options;
|
|
pos =
|
|
Option.bind
|
|
(option_value "pos" options)
|
|
Block.position_of_string;
|
|
content = option_value "content" options;
|
|
}))
|
|
| "task" ->
|
|
Some
|
|
(Upsert
|
|
(Parsed_task
|
|
{
|
|
id = int64_option "id" options;
|
|
uuid = option_value "uuid" options;
|
|
page = option_value "page" options;
|
|
content = option_value "content" options;
|
|
target_id = int64_option "target-id" options;
|
|
target_uuid = option_value "target-uuid" options;
|
|
target_page = option_value "target-page" options;
|
|
pos =
|
|
Option.bind
|
|
(option_value "pos" options)
|
|
Block.position_of_string;
|
|
status = option_value "status" options;
|
|
priority = option_value "priority" options;
|
|
scheduled = time_option "scheduled" options;
|
|
deadline = time_option "deadline" options;
|
|
no_status = option_present "no-status" options;
|
|
no_priority = option_present "no-priority" options;
|
|
no_scheduled = option_present "no-scheduled" options;
|
|
no_deadline = option_present "no-deadline" options;
|
|
}))
|
|
| "tag" ->
|
|
Some
|
|
(Upsert
|
|
(Parsed_tag
|
|
{
|
|
id = int64_option "id" options;
|
|
name = option_value "name" options;
|
|
add_properties_edn = option_value "add-properties" options;
|
|
remove_properties_edn = option_value "remove-properties" options;
|
|
}))
|
|
| "property" ->
|
|
Some
|
|
(Upsert
|
|
(Parsed_property
|
|
{
|
|
id = int64_option "id" options;
|
|
name = option_value "name" options;
|
|
kind =
|
|
Option.bind
|
|
(option_value "type" options)
|
|
Property.kind_of_string;
|
|
cardinality =
|
|
Option.bind
|
|
(option_value "cardinality" options)
|
|
Property.cardinality_of_string;
|
|
hide = bool_option_value "hide" options;
|
|
public = bool_option_value "public" options;
|
|
}))
|
|
| _ -> None
|
|
|
|
let parsed_list_command options = function
|
|
| "page" ->
|
|
Some
|
|
(Cli_request.List
|
|
(List_command.Parsed_page
|
|
{
|
|
common = common_list_opts options;
|
|
expand = option_present "expand" options;
|
|
include_built_in = optional_flag "include-built-in" options;
|
|
include_journal = optional_flag "include-journal" options;
|
|
journal_only = option_present "journal-only" options;
|
|
include_hidden = option_present "include-hidden" options;
|
|
updated_after = time_option "updated-after" options;
|
|
created_after = time_option "created-after" options;
|
|
}))
|
|
| "tag" ->
|
|
Some
|
|
(List
|
|
(Parsed_tag
|
|
{
|
|
common = common_list_opts options;
|
|
expand = option_present "expand" options;
|
|
include_built_in = optional_flag "include-built-in" options;
|
|
with_properties = option_present "with-properties" options;
|
|
with_extends = option_present "with-extends" options;
|
|
}))
|
|
| "property" ->
|
|
Some
|
|
(List
|
|
(Parsed_property
|
|
{
|
|
common = common_list_opts options;
|
|
expand = option_present "expand" options;
|
|
include_built_in = optional_flag "include-built-in" options;
|
|
with_classes = option_present "with-classes" options;
|
|
with_type = true;
|
|
}))
|
|
| "task" ->
|
|
Some
|
|
(List
|
|
(Parsed_task
|
|
{
|
|
common = common_list_opts options;
|
|
status = option_value "status" options;
|
|
priority = option_value "priority" options;
|
|
content = option_value "content" options;
|
|
}))
|
|
| "node" ->
|
|
Some
|
|
(List
|
|
(Parsed_node
|
|
{
|
|
common = common_list_opts options;
|
|
tags =
|
|
Option.value
|
|
(Option.map parse_csv (option_value "tags" options))
|
|
~default:Vec.empty;
|
|
properties =
|
|
Option.value
|
|
(Option.map parse_csv (option_value "properties" options))
|
|
~default:Vec.empty;
|
|
}))
|
|
| "asset" -> Some (List (Parsed_asset { common = common_list_opts options }))
|
|
| _ -> None
|
|
|
|
(* normalize_key resolves short aliases globally (-f -> fields, -e ->
|
|
edn-options), but a few legacy aliases mean something else under specific
|
|
commands. Once the command path is known, rewrite those raw tokens and
|
|
re-parse so the alias lands on the right option. *)
|
|
let path_alias_overrides = function
|
|
| [| "graph"; "validate" |] -> [ ("-f", "--fix") ]
|
|
| [| "graph"; "export" |] -> [ ("-f", "--file") ]
|
|
| [| "list"; ("page" | "tag" | "property") |] -> [ ("-e", "--expand") ]
|
|
| _ -> []
|
|
|
|
(* rewrite a bare alias token, or its -x=value form *)
|
|
let apply_alias_override overrides token =
|
|
match List.assoc_opt token overrides with
|
|
| Some replacement -> replacement
|
|
| None -> (
|
|
match String.index_opt token '=' with
|
|
| None -> token
|
|
| Some index -> (
|
|
match List.assoc_opt (String.sub token 0 index) overrides with
|
|
| Some replacement ->
|
|
replacement
|
|
^ String.sub token index (String.length token - index)
|
|
| None -> token))
|
|
|
|
let parse ?stdin argv =
|
|
let options, positional = parse_tokens argv in
|
|
let positional_array = Vec.to_array positional in
|
|
let options =
|
|
match path_alias_overrides positional_array with
|
|
| [] -> options
|
|
| overrides ->
|
|
argv
|
|
|> Vec.map (apply_alias_override overrides)
|
|
|> parse_tokens |> fst
|
|
in
|
|
let positional_tail start =
|
|
Vec.init
|
|
(max 0 (Array.length positional_array - start))
|
|
(fun index -> positional_array.(index + start))
|
|
in
|
|
let make_vec path command =
|
|
Error.bind (validate_options path options) (fun () ->
|
|
let globals = globals_of_options options in
|
|
Ok (Cli_request.make ~globals ~path ~command ~raw_args:argv))
|
|
in
|
|
let make path command = make_vec (Vec.of_array path) command in
|
|
if option_present "version" options then make [||] Cli_request.Version
|
|
else if
|
|
Array.length positional_array >= 2
|
|
&& positional_array.(0) = "upsert"
|
|
&& positional_array.(1) = "block"
|
|
then
|
|
match parsed_upsert_command ~args:(positional_tail 2) options "block" with
|
|
| Some command -> make [| "upsert"; "block" |] command
|
|
| None -> Error (Error.unknown_command "unknown command: upsert block")
|
|
else if Array.length positional_array >= 1 && positional_array.(0) = "example"
|
|
then
|
|
let selector = positional_tail 1 in
|
|
make_vec
|
|
(Vec.push_front selector "example")
|
|
(Example (Example.Parsed_example { selector }))
|
|
else
|
|
match positional_array with
|
|
| [| "graph"; "list" |] ->
|
|
make [| "graph"; "list" |] (Graph Graph.Parsed_list)
|
|
| [| "graph"; "create" |] ->
|
|
make [| "graph"; "create" |]
|
|
(Graph
|
|
(Parsed_create
|
|
{
|
|
enable_sync = option_present "enable-sync" options;
|
|
e2ee_password = option_value "e2ee-password" options;
|
|
}))
|
|
| [| "graph"; "switch" |] ->
|
|
make [| "graph"; "switch" |] (Graph Parsed_switch)
|
|
| [| "graph"; "remove" |] ->
|
|
make [| "graph"; "remove" |] (Graph Parsed_remove)
|
|
| [| "graph"; "validate" |] ->
|
|
make [| "graph"; "validate" |]
|
|
(Graph
|
|
(Parsed_validate { fix = option_present "fix" options }))
|
|
| [| "graph"; "info" |] -> make [| "graph"; "info" |] (Graph Parsed_info)
|
|
| [| "graph"; "backup"; "list" |] ->
|
|
make [| "graph"; "backup"; "list" |] (Graph Parsed_backup_list)
|
|
| [| "graph"; "backup"; "create" |] ->
|
|
make
|
|
[| "graph"; "backup"; "create" |]
|
|
(Graph (Parsed_backup_create { name = option_value "name" options }))
|
|
| [| "graph"; "backup"; "restore" |] -> (
|
|
match (option_value "src" options, option_value "dst" options) with
|
|
| Some src, Some dst ->
|
|
make
|
|
[| "graph"; "backup"; "restore" |]
|
|
(Graph
|
|
(Parsed_backup_restore
|
|
{ src; dst = Cli_primitive.create_graph dst }))
|
|
| None, _ ->
|
|
Error
|
|
(Error.invalid_options "graph backup restore --src is required")
|
|
| _, None ->
|
|
Error
|
|
(Error.invalid_options "graph backup restore --dst is required"))
|
|
| [| "graph"; "backup"; "remove" |] -> (
|
|
match option_value "src" options with
|
|
| Some src ->
|
|
make
|
|
[| "graph"; "backup"; "remove" |]
|
|
(Graph (Parsed_backup_remove { src }))
|
|
| None ->
|
|
Error
|
|
(Error.invalid_options "graph backup remove --src is required"))
|
|
| [| "graph"; "export" |] -> (
|
|
match graph_export_type options with
|
|
| Some export_type ->
|
|
Error.bind (parse_graph_export_edn_options options)
|
|
(fun edn_options ->
|
|
make [| "graph"; "export" |]
|
|
(Graph
|
|
(Parsed_export
|
|
{
|
|
export_type;
|
|
file = option_value "file" options;
|
|
edn_options;
|
|
pretty_print = option_present "pretty-print" options;
|
|
include_timestamps = false;
|
|
exclude_built_in_pages = false;
|
|
exclude_namespaces = Vec.empty;
|
|
})))
|
|
| None ->
|
|
Error
|
|
(Error.invalid_options "graph export --type must be edn or sqlite")
|
|
)
|
|
| [| "graph"; "import" |] -> (
|
|
match (graph_import_type options, option_value "input" options) with
|
|
| Some import_type, Some input ->
|
|
make [| "graph"; "import" |]
|
|
(Graph (Parsed_import { import_type; input }))
|
|
| None, _ ->
|
|
Error
|
|
(Error.invalid_options "graph import --type must be edn or sqlite")
|
|
| _, None ->
|
|
Error (Error.invalid_options "graph import --input is required"))
|
|
| [| "list"; kind |] -> (
|
|
match parsed_list_command options kind with
|
|
| Some command -> make [| "list"; kind |] command
|
|
| None ->
|
|
Error (Error.unknown_command ("unknown command: list " ^ kind)))
|
|
| [| "remove"; kind |] -> (
|
|
match parsed_remove_command options kind with
|
|
| Some command -> make [| "remove"; kind |] command
|
|
| None ->
|
|
Error (Error.unknown_command ("unknown command: remove " ^ kind)))
|
|
| [| "upsert"; kind |] -> (
|
|
match parsed_upsert_command options kind with
|
|
| Some command -> make [| "upsert"; kind |] command
|
|
| None ->
|
|
Error (Error.unknown_command ("unknown command: upsert " ^ kind)))
|
|
| [| "search"; "block" |] ->
|
|
make [| "search"; "block" |]
|
|
(Search
|
|
(Search.Parsed_block
|
|
{
|
|
content =
|
|
Option.value (option_value "content" options) ~default:"";
|
|
}))
|
|
| [| "search"; "page" |] ->
|
|
make [| "search"; "page" |]
|
|
(Search
|
|
(Search.Parsed_page
|
|
{
|
|
content =
|
|
Option.value (option_value "content" options) ~default:"";
|
|
}))
|
|
| [| "search"; "property" |] ->
|
|
make [| "search"; "property" |]
|
|
(Search
|
|
(Search.Parsed_property
|
|
{
|
|
content =
|
|
Option.value (option_value "content" options) ~default:"";
|
|
}))
|
|
| [| "search"; "tag" |] ->
|
|
make [| "search"; "tag" |]
|
|
(Search
|
|
(Search.Parsed_tag
|
|
{
|
|
content =
|
|
Option.value (option_value "content" options) ~default:"";
|
|
}))
|
|
| [| "query"; "list" |] ->
|
|
make [| "query"; "list" |] (Query Query.Parsed_list)
|
|
| [| "query" |] ->
|
|
make [| "query" |]
|
|
(Query
|
|
(Query.Parsed_run
|
|
{
|
|
query_edn = option_value "query" options;
|
|
name = option_value "name" options;
|
|
inputs_edn = option_value "inputs" options;
|
|
}))
|
|
| [| "show" |] ->
|
|
let stdin_id =
|
|
if
|
|
option_present "id" options
|
|
&& Option.is_none (option_value "id" options)
|
|
then stdin
|
|
else None
|
|
in
|
|
make [| "show" |]
|
|
(Show
|
|
(Show.Parsed_show
|
|
{
|
|
id_raw = option_value "id" options;
|
|
uuid = option_value "uuid" options;
|
|
page = option_value "page" options;
|
|
page_hierarchy =
|
|
Option.value
|
|
(bool_option_value "page-hierarchy" options)
|
|
~default:false;
|
|
linked_references = optional_flag "linked-references" options;
|
|
ref_id_footer = optional_flag "ref-id-footer" options;
|
|
level = int_option "level" options;
|
|
stdin_id;
|
|
}))
|
|
| [| "server"; "list" |] ->
|
|
make [| "server"; "list" |] (Server Server_command.Parsed_list)
|
|
| [| "server"; "cleanup" |] ->
|
|
make [| "server"; "cleanup" |] (Server Parsed_cleanup)
|
|
| [| "server"; "start" |] ->
|
|
make [| "server"; "start" |] (Server Parsed_start)
|
|
| [| "server"; "stop" |] -> make [| "server"; "stop" |] (Server Parsed_stop)
|
|
| [| "server"; "restart" |] ->
|
|
make [| "server"; "restart" |] (Server Parsed_restart)
|
|
| [| "sync"; "status" |] ->
|
|
make [| "sync"; "status" |] (Sync Sync.Parsed_status)
|
|
| [| "sync"; "start" |] ->
|
|
make [| "sync"; "start" |]
|
|
(Sync
|
|
(Sync.Parsed_start
|
|
{ e2ee_password = option_value "e2ee-password" options }))
|
|
| [| "sync"; "stop" |] -> make [| "sync"; "stop" |] (Sync Sync.Parsed_stop)
|
|
| [| "sync"; "upload" |] ->
|
|
make [| "sync"; "upload" |]
|
|
(Sync
|
|
(Sync.Parsed_upload
|
|
{ e2ee_password = option_value "e2ee-password" options }))
|
|
| [| "sync"; "download" |] ->
|
|
make [| "sync"; "download" |]
|
|
(Sync
|
|
(Sync.Parsed_download
|
|
{
|
|
progress =
|
|
(if option_present "progress" options then Some true
|
|
else None);
|
|
e2ee_password = option_value "e2ee-password" options;
|
|
}))
|
|
| [| "sync"; "asset"; "download" |] ->
|
|
make
|
|
[| "sync"; "asset"; "download" |]
|
|
(Sync
|
|
(Sync.Parsed_asset_download
|
|
{
|
|
id = int64_option "id" options;
|
|
uuid = option_value "uuid" options;
|
|
}))
|
|
| [| "sync"; "remote-graphs" |] ->
|
|
make [| "sync"; "remote-graphs" |] (Sync Sync.Parsed_remote_graphs)
|
|
| [| "sync"; "ensure-keys" |] ->
|
|
make
|
|
[| "sync"; "ensure-keys" |]
|
|
(Sync
|
|
(Sync.Parsed_ensure_keys
|
|
{
|
|
e2ee_password = option_value "e2ee-password" options;
|
|
upload_keys = option_present "upload-keys" options;
|
|
}))
|
|
| [| "sync"; "grant-access" |] ->
|
|
make
|
|
[| "sync"; "grant-access" |]
|
|
(Sync
|
|
(Sync.Parsed_grant_access
|
|
{
|
|
graph_id = option_value "graph-id" options;
|
|
email = option_value "email" options;
|
|
}))
|
|
| [| "sync"; "config"; "get"; key |] -> (
|
|
match sync_config_key_or_error (Some key) with
|
|
| Ok key ->
|
|
make
|
|
[| "sync"; "config"; "get" |]
|
|
(Sync (Sync.Parsed_config_get { key }))
|
|
| Error err -> Error err)
|
|
| [| "sync"; "config"; "get" |] ->
|
|
make
|
|
[| "sync"; "config"; "get" |]
|
|
(Sync (Sync.Parsed_config_get { key = None }))
|
|
| [| "sync"; "config"; "set"; key; value |] -> (
|
|
match sync_config_key_or_error (Some key) with
|
|
| Ok key ->
|
|
make
|
|
[| "sync"; "config"; "set" |]
|
|
(Sync (Sync.Parsed_config_set { key; value = Some value }))
|
|
| Error err -> Error err)
|
|
| [| "sync"; "config"; "set"; key |] -> (
|
|
match sync_config_key_or_error (Some key) with
|
|
| Ok key ->
|
|
make
|
|
[| "sync"; "config"; "set" |]
|
|
(Sync (Sync.Parsed_config_set { key; value = None }))
|
|
| Error err -> Error err)
|
|
| [| "sync"; "config"; "set" |] ->
|
|
make
|
|
[| "sync"; "config"; "set" |]
|
|
(Sync (Sync.Parsed_config_set { key = None; value = None }))
|
|
| [| "sync"; "config"; "unset"; key |] -> (
|
|
match sync_config_key_or_error (Some key) with
|
|
| Ok key ->
|
|
make
|
|
[| "sync"; "config"; "unset" |]
|
|
(Sync (Sync.Parsed_config_unset { key }))
|
|
| Error err -> Error err)
|
|
| [| "sync"; "config"; "unset" |] ->
|
|
make
|
|
[| "sync"; "config"; "unset" |]
|
|
(Sync (Sync.Parsed_config_unset { key = None }))
|
|
| [| "debug"; "pull" |] -> (
|
|
match
|
|
Option.map Debug.parse_ident_option (option_value "ident" options)
|
|
with
|
|
| Some (Error err) -> Error err
|
|
| ident ->
|
|
make [| "debug"; "pull" |]
|
|
(Debug
|
|
(Debug.Parsed_pull
|
|
{
|
|
id = int64_option "id" options;
|
|
uuid = option_value "uuid" options;
|
|
ident =
|
|
Option.bind ident (function
|
|
| Ok ident -> Some ident
|
|
| Error _ -> None);
|
|
})))
|
|
| [| "agent"; "bridge" |] ->
|
|
make [| "agent"; "bridge" |] (Agent Agent.Parsed_bridge)
|
|
| [| "doctor" |] ->
|
|
make [| "doctor" |]
|
|
(Doctor
|
|
(Doctor.Parsed_doctor
|
|
{ dev_script = option_present "dev-script" options }))
|
|
| [| "login" |] -> make [| "login" |] (Auth Auth_command.Parsed_login)
|
|
| [| "logout" |] -> make [| "logout" |] (Auth Auth_command.Parsed_logout)
|
|
| [| "skill"; "show" |] ->
|
|
make [| "skill"; "show" |] (Skill Skill.Parsed_show)
|
|
| [| "skill"; "install" |] ->
|
|
make [| "skill"; "install" |]
|
|
(Skill
|
|
(Skill.Parsed_install { global = option_present "global" options }))
|
|
| [| "completion"; shell |] -> (
|
|
match Cli_primitive.shell_of_string shell with
|
|
| Some shell ->
|
|
make [| "completion" |]
|
|
(Completion (Completion.Parsed_completion { shell = Some shell }))
|
|
| None ->
|
|
Error
|
|
(Error.invalid_options
|
|
("unsupported shell: " ^ shell ^ "; expected zsh or bash")))
|
|
| [| "completion" |] ->
|
|
let shell =
|
|
match option_value "shell" options with
|
|
| None ->
|
|
Error
|
|
(Error.invalid_options
|
|
"completion shell is required; expected zsh or bash")
|
|
| Some shell -> (
|
|
match Cli_primitive.shell_of_string shell with
|
|
| Some shell -> Ok (Some shell)
|
|
| None ->
|
|
Error
|
|
(Error.invalid_options
|
|
("unsupported shell: " ^ shell ^ "; expected zsh or bash"))
|
|
)
|
|
in
|
|
Error.bind shell (fun shell ->
|
|
make [| "completion" |]
|
|
(Completion (Completion.Parsed_completion { shell })))
|
|
| [||] -> Error (Error.unknown_command "")
|
|
| _ ->
|
|
Error
|
|
(Error.unknown_command
|
|
("unknown command: " ^ Vec.string_concat " " positional))
|