rusty-lisp 0.45.0

;;; Copyright (c) 2026 Nicholas Vermeulen
;;; SPDX-License-Identifier: AGPL-3.0-or-later

;;; commands-test.lisp — smoke-covers command-registry entries no other
;;; golden test exercises. NO LLM, no shell-run/agent/react-loop, no
;;; remember/recall/forget (owner's real ~/.rusty/memory.lisp), no
;;; defrust/defrust*/graph-compile (shell out to rustc — slow, cache-
;;; dependent). Filesystem writes are confined to /tmp/rusty-cmdtest,
;;; cleaned up at the end. Deterministic only — no timings/randomness.

(println "== list/predicate/math bulk ==")
(println (list 'caar (caar '((1 2) 3))))
(println (list 'cdar (cdar '((1 2) 3))))
(println (list 'cddr (cddr '(1 2 3 4))))
(println (list 'ceiling (ceiling 1.2)))
(println (list 'round (round 1.5)))
(println (list 'gcd (gcd 12 18)))
(println (list 'zero? (zero? 0)))
(println (list 'even? (even? 4)))
(println (list 'odd? (odd? 3)))
(println (list 'positive? (positive? 5)))
(println (list 'negative? (negative? -5)))
(println (list 'boolean? (boolean? #t)))
(println (list 'string? (string? "x")))
(println (list 'type-of (type-of 5)))
(println (list 'macro?-false (macro? (lambda (x) x))))
(defmacro cmdtest-mm (x) `(+ ,x 1))
(println (list 'macro?-true (macro? cmdtest-mm)))
(println (list 'native? (native? 5)))
(println (list 'eq? (eq? 5 5)))
(println (list 'nil (nil)))
(println (list 'list-tail (list-tail '(1 2 3 4 5) 2)))
(println (list 'inc (inc 5)))
(println (list 'dec (dec 5)))
(println (list 'square (square 5)))
(println (list 'average (average 4 6)))
(println (list 'sign (sign -5)))

(println "== strings ==")
(println (list 'str (str "a" 1 #t)))
(println (list 'string-append-list (string-append-list (list "a" "b" "c"))))
(println (list 'string-join (string-join (list "a" "b" "c") "-")))
(println (list 'string-repeat (string-repeat "ab" 3)))
(println (list 'string-starts-with? (string-starts-with? "hello" "he")))
(println (list 'string-last-index (string-last-index "a.b.c" ".")))
(println (list 'number->string (number->string 42)))
(println (list 'string->number (string->number "42")))
(println (list 'string->symbol (string->symbol "foo")))
(println (list 'string->list (string->list "ab")))
(println (list 'extract-sexp (extract-sexp "prose (foo 1 2) more")))

(println "== control flow / macros ==")
(println (list 'do-loop (do ((i 0 (+ i 1)) (acc 0 (+ acc i))) ((= i 5) acc))))
(println (list 'letrec* (letrec* ((ev? (lambda (n) (if (= n 0) #t (od? (- n 1)))))
                                   (od? (lambda (n) (if (= n 0) #f (ev? (- n 1))))))
                           (ev? 10))))
(println (list 'match-atom (match 5 (5 'five) (_ 'other))))
(println (list 'match-list (match '(1 2) ((a b) (+ a b)) (_ 'none))))
(println (list 'unless (unless #f 'yes)))
(println (list 'while-false (while #f 'never)))
(define cmdtest-a 1)
(define cmdtest-b 2)
(swap! cmdtest-a cmdtest-b)
(println (list 'swap! (list cmdtest-a cmdtest-b)))
(define dolist-acc '())
(dolist (x '(1 2 3)) (set! dolist-acc (cons x dolist-acc)))
(println (list 'dolist (reverse dolist-acc)))
(define dotimes-acc '())
(dotimes (i 3) (set! dotimes-acc (cons i dotimes-acc)))
(println (list 'dotimes (reverse dotimes-acc)))
(define repeat-count 0)
(repeat 4 (set! repeat-count (+ repeat-count 1)))
(println (list 'repeat repeat-count))
(println (list '-> (-> 5 (+ 1) (* 2))))
(println (list '->> (->> 5 (+ 1) (* 2))))
(println (list 'foldr (foldr (lambda (x acc) (cons x acc)) '() '(1 2 3))))
(println (list 'map* (map* '(1 2 3) (lambda (x) (* x 2)))))
(println (list 'filter* (filter* '(1 2 3 4) even?)))
(println (list 'foldl* (foldl* '(1 2 3) + 0)))
(define-macro cmdtest-dm (x) `(+ ,x 1))
(println (list 'define-macro (cmdtest-dm 5)))
(eval-when (load) (println (list 'eval-when 'ran-at-load)))
(println (list 'gensym-is-symbol (symbol? (gensym "x"))))
(println (list 'lambda-alias-fn ((fn (x) (+ x 1)) 5)))
(println (list 'lambda-alias-lambda-char ((λ (x) (+ x 1)) 5)))

(println "== functional utilities ==")
(println (list 'identity (identity 5)))
(println (list 'const ((const 9) 1 2)))
(println (list 'flip ((flip -) 3 10)))
(println (list 'negate ((negate even?) 3)))
(println (list 'curry ((curry + 1 2) 3)))
(println (list 'memoize ((memoize (lambda (x) (* x x))) 5)))
;; compose builds a nested closure; calling multi-fn compose can hit a known
;; closure edge case, so only check the construction path for coverage.
(println (list 'compose (procedure? (compose (lambda (x) (* x 2)) (lambda (x) (+ x 1))))))

(println "== list utilities ==")
(println (list 'count (count even? '(1 2 3 4))))
(println (list 'find (find even? '(1 2 3 4))))
(println (list 'partition (partition even? '(1 2 3 4))))
(println (list 'remove-duplicates (remove-duplicates '(1 1 2 2 3))))
(println (list 'interleave (interleave 0 '(1 2 3))))
(println (list 'iota (iota 5)))
(println (list 'product (product '(1 2 3 4))))
(println (list 'any? (any? even? '(1 3 5 6))))
(println (list 'none? (none? even? '(1 3 5))))
(println (list 'zip (zip '(1 2) '(3 4))))
(println (list 'zip-with (zip-with + '(1 2) '(3 4))))
(println (list 'take (take 2 '(1 2 3))))
(println (list 'drop (drop 2 '(1 2 3))))
(println (list 'take-while (take-while even? '(2 4 5 6))))
(println (list 'drop-while (drop-while even? '(2 4 5 6))))
(println (list 'last (last '(1 2 3))))
(println (list 'flatten (flatten '(1 (2 (3 4)) 5))))
(println (list 'flatten1 (flatten1 '((1 2) (3 4)))))
(println (list 'alist-get (alist-get 'b '((a 1) (b 2)) 'not-found)))
(println (list 'assq (assq 'b '((a . 1) (b . 2)))))

(println "== records ==")
(define cmdtest-rec (make-record "a" 1 "b" 2))
(println (list 'make-record cmdtest-rec))
(println (list 'get-field (get-field "a" cmdtest-rec)))
(println (list 'field (field a cmdtest-rec)))
(println (list 'record-set (record-set cmdtest-rec "a" 99)))

(println "== io ==")
(display "hi-from-display") (newline)
(print-list '(1 2 3))

(println "== tensors ==")
(define cmdtest-t1 (tensor '((1 2) (3 4))))
(define cmdtest-t2 (tensor '((5 6) (7 8))))
(println (list 'tensor? (tensor? cmdtest-t1)))
(println (list 'tensor->list (tensor->list cmdtest-t1)))
(println (list 'tensor-shape (tensor-shape cmdtest-t1)))
(println (list 'tensor-ref (tensor-ref cmdtest-t1 0 1)))
(println (list 'tensor-add (tensor->list (tensor-add cmdtest-t1 cmdtest-t2))))
(println (list 'tensor-sub (tensor->list (tensor-sub cmdtest-t2 cmdtest-t1))))
(println (list 'tensor-mul (tensor->list (tensor-mul cmdtest-t1 cmdtest-t2))))
(println (list 'tensor-div (tensor->list (tensor-div cmdtest-t2 cmdtest-t1))))
(println (list 'tensor-sum (tensor-sum cmdtest-t1)))
(println (list 'tensor-map (tensor->list (tensor-map (lambda (x) (* x 2)) cmdtest-t1))))
(println (list 'matmul (tensor->list (matmul cmdtest-t1 cmdtest-t2))))
(println (list 'transpose (tensor->list (transpose cmdtest-t1))))
(println (list 'zeros (tensor->list (zeros '(2 2)))))
(println (list 'ones (tensor->list (ones '(2 2)))))
(println (list 'relu (tensor->list (relu (tensor '(-1 2 -3 4))))))

(println "== graph ir ==")
(println (list 'graph-node-count (graph-node-count (lambda (x y) (+ (* x x) y)))))
(println (list 'graph-eval (graph-eval (lambda (x y) (+ (* x x) y)) 3 4)))
(println (list 'graph-grad (graph-grad (lambda (x) (* x x)) 5)))
(println (list 'graph-ir-node-count (length (graph-ir (lambda (x) (* x x))))))

(println "== json ==")
(println (list 'json-encode (json-encode (list 1 "two" #t))))
(println (list 'json-decode (json-decode "[1,\"two\",true]")))

(println "== knowledge graph ==")
(kg-clear!)
(println (list 'kg-triples-empty (kg-triples)))
(kg-add! 'cmdtest-a 'rel 'cmdtest-b)
(println (list 'kg-triples (kg-triples)))
(kg-clear!)

(println "== filesystem (under /tmp/rusty-cmdtest) ==")
(shell "rm -rf /tmp/rusty-cmdtest && mkdir -p /tmp/rusty-cmdtest")
(create-dir "/tmp/rusty-cmdtest/sub")
(write-file "/tmp/rusty-cmdtest/a.txt" "hello")
(append-file "/tmp/rusty-cmdtest/a.txt" " world")
(file-append "/tmp/rusty-cmdtest/a.txt" "!")
(println (list 'read-file (read-file "/tmp/rusty-cmdtest/a.txt")))
(println (list 'file-exists-tool (file-exists "/tmp/rusty-cmdtest/a.txt")))
(println (list 'dir-list (dir-list "/tmp/rusty-cmdtest")))
(println (list 'tool-call (string? (tool-call "read-file" "/tmp/rusty-cmdtest/a.txt"))))
(delete-file "/tmp/rusty-cmdtest/a.txt")
(println (list 'delete-file-worked (file-exists "/tmp/rusty-cmdtest/a.txt")))

(println "== serialization ==")
(save-model "/tmp/rusty-cmdtest/model.json" (list 1 2 3))
(println (list 'load-model (load-model "/tmp/rusty-cmdtest/model.json")))

(println "== checkpoint ==")
(checkpoint "/tmp/rusty-cmdtest/ckpt.lisp")
(println (list 'checkpoint-file-exists (file-exists? "/tmp/rusty-cmdtest/ckpt.lisp")))

(println "== load-relative ==")
(write-file "/tmp/rusty-cmdtest/loadme.lisp" "(define cmdtest-loaded 'yes)")
(load-relative "/tmp/rusty-cmdtest/loadme.lisp")
(println (list 'load-relative cmdtest-loaded))

(println "== tracing ==")
(deftool cmdtest-tracetool (a b) "adds for tracing" (+ a b))
(trace-clear)
(trace-on)
(tool-call "cmdtest-tracetool" 3 4)
(println (list 'trace-report-nonempty (> (length (trace-report)) 0)))
(println (list 'trace-dropped (trace-dropped)))
(trace-clear)
(println (list 'trace-cleared (length (trace-report))))
(trace-off)

(println "== macro profiler ==")
(macro-profile-reset)
(macro-profile-on)
(defmacro cmdtest-prof-m (x) `(+ ,x 1))
(cmdtest-prof-m 5)
(println (list 'macro-profile-nonempty (> (length (macro-profile-report)) 0)))
(macro-profile-reset)
(println (list 'macro-profile-reset-empty (length (macro-profile-report))))
(macro-profile-off)

(println "== agents ==")
(agent-reset!)
(agent-spawn 'cmdtest-echoer (lambda (msg) msg))
(println (list 'agent-names (agent-names)))
(println (list 'mailbox-count (mailbox-count 'cmdtest-echoer)))
(agent-reset!)
(println (list 'agent-names-after-reset (agent-names)))

(println "== checkers / tools ==")
(println (list 'effectful?-pure (effectful? '+)))
(println (list 'effectful?-io (effectful? 'println)))
(define-typed (cmdtest-dt-add (a : number) (b : number)) : number (+ a b))
(println (list 'define-typed (cmdtest-dt-add 3 4)))
(println (list 'check-types (check-types (lambda (x) (+ x 1)) '((x number)))))
(defun-constrained (cmdtest-dc-half n) (assert (even? n) "must be even") (/ n 2))
(println (list 'defun-constrained (cmdtest-dc-half 8)))
(println (list 'logic-loss-true (logic-loss #t)))
(println (list 'logic-loss-false (logic-loss #f)))
(define (cmdtest-proposer attempt feedback) (lambda (x) (+ x 1)))
(println (list 'synthesize-verified
  (synthesize-verified
    (list (list 'pure #t)
          (list 'domains '((1 2 3)))
          (list 'invariant (lambda (f x) (= (f x) (+ x 1)))))
    cmdtest-proposer 3)))

(deftool cmdtest-tool-add (a b) "adds two numbers" (+ a b))
(deftool cmdtest-tool-print (x) "prints x" (begin (println x) x))
(println (list 'tool? (tool? cmdtest-tool-add)))
(println (list 'tool-name (tool-name cmdtest-tool-add)))
(deftool-spec cmdtest-tool-add
  (list (list 'a 'number) (list 'b 'number)) '() (lambda (a b) #t) '())
(deftool-spec cmdtest-tool-print (list (list 'x 'number)) '() (lambda (x) #t) '())
(define cmdtest-spec (tool-spec (tool-name cmdtest-tool-add)))
(println (list 'tool-spec-found (pair? cmdtest-spec)))
(println (list 'spec-tool-value (procedure? (spec-tool-value cmdtest-spec))))
(println (list 'spec-param-types (spec-param-types cmdtest-spec)))
(println (list 'spec-effects (spec-effects cmdtest-spec)))
(println (list 'spec-pre (procedure? (spec-pre cmdtest-spec))))
(println (list 'spec-deps (spec-deps cmdtest-spec)))
(println (list 'safe-call (safe-call cmdtest-tool-add 3 4)))
(println (list 'finding-op (finding-op "println: performs I/O")))
(println (list 'undeclared-effects (undeclared-effects cmdtest-tool-print '())))
(println (list 'certify-tool-chain-ok (certify-tool-chain (list cmdtest-tool-add))))
(println (list 'certify-tool-chain-lies (certify-tool-chain (list cmdtest-tool-print))))
(println (list 'list-tools-has-new-tool
  (if (member 'cmdtest-tool-add (map car (list-tools))) 'found 'missing)))

(println "== typed-param helpers ==")
(println (list 'typed-param-type (typed-param-type '(x : number))))
(println (list 'typed-param-check (pair? (typed-param-check '(x : number)))))

(println "== agent tool wrappers ==")
(println (list 'list-dir (list-dir "/tmp/rusty-cmdtest")))
(println (list 'shell-run (shell-run "printf hi")))
(println (list 'search-files (string? (search-files "commands-test"))))
(println (list 'memory-path (string? (memory-path))))
(println "-- show-tools --")
(show-tools)
(println "-- agent-help --")
(agent-help)

(println "== meta ==")
(println (list 'commands-count-matches (= (length (commands)) (length (command-registry)))))
(println (list 'commands-has-map (if (member "map" (commands)) 'found 'missing)))
(println "-- help json --")
(help-category 'json)
(println "-- help trace --")
(help 'trace)

(println "== cleanup ==")
(shell "rm -rf /tmp/rusty-cmdtest")
(println (list 'cleaned-up (not (file-exists? "/tmp/rusty-cmdtest"))))

(println "commands-test: done")