gram:build

> ./config/nushell/gram.nu

Lenses
(coming soon!)

def "gram chec" [gram: record] {
  loop {
    try { (http get --full $"https://($gram.domain)/double-chec").status | print
    } catch { upsert clock (clock) | print }
    sleep 30sec;
  }
}

def "gram norm" [base: path] { {
  base: ($base | path expand),
  name: ($base | path basename),
  machine: $m.base,
} }

def "gram gleam" [base: path] { {
    base: ($base | path expand),
    name: ($base | path basename),
    machine: null, #$m.base,
    shares: [ doc README.md ],
    command: { preshare: ["nix develop --command gleam docs build"] },
} }

def "gram mix" [base: path, domain?: string] { {
    base: ($base | path expand),
    name: ($base | path basename),
    domain: $domain,
    machine: $m.base,
    shares: [ doc README.md share ],
    command: {
      basis: [
        "nix develop --command mix deps.get"
      ],
      preshare: [
        "nix develop --command mix docs"
        "nix develop --command git log --graph --all --format=format:'%h %G? (%ai) %aN: %s %d' --abbrev-commit --date=relative | save -f share/change.log"
      ],
    },
} }

let grams = {
  build: {
    base: ~/.build, name: build, machine: null,
    shares: [ README.md doc share ],
    command: { preshare: [
      "git log --graph --all --format=format:'%h %G? (%ai) %aN: %s %d' --abbrev-commit --date=relative | save -f share/change.log"
    ] },
  },

  share: {
    base: null,
    name: share,
    domain: "share.operand.space",
    machine: $m.base,
  },

  op:    ( gram mix ~/base/code/operand "operand.online" | upsert name "op"),
  blade: ( gram mix ~/base/code/blade | upsert machine null),
  cc:    ( gram mix ~/base/code/cc "command.college"),
  pain:  ( gram mix ~/base/code/pain "book.painawayofphilly.com"),

  gram:  ( gram gleam ~/base/code/gram),
  lens:  ( gram gleam ~/base/code/lens),
  panel: ( gram gleam ~/base/code/panel),
}; let g = $grams

# def "gram rebase" [gram: record] {
#   shell $machines.base $"close-($gram.name); do-($gram.name) daemon;"
# }

def "gram help" [gram: record] {
  let source = [ $grams.share.domain gram ($gram.base | path basename) ] | path join
  print ([
    "# Reload your copy quickly using:"
    "rm -r ./($gram.name);"
    "wget --accept-regex '($source | str replace '/' '\/')' -r https://($grams.share.domain)/($source)"
    "git -C ./($grams.share.domain)/($source) checkout main"
    "cd ./($grams.share.domain)/($source)"
  ] | str join "\n") }

def "gram share" [...gs: record] { $gs | each {|gram|
  let base = $gram.base | path expand
  let basis = try { $gram.command.basis } catch { [] }
  let preshare = try { $gram.command.preshare } catch { [] }
  let nodes = ($gram.shares | | each {|s| ([$base $s] | path join | path expand) })
  let share = [ / root share gram $gram.name ] | path join
  let aim = [ (machine address $grams.share.machine) $share ] | str join ':'

  let command = [
    'try { git clone . }'
    'git checkout main'
    'git reset --hard HEAD'
    'git status'
  ] | str join '; '

  cd $base
  $basis | each {|c| nu -c $c | print }
  $preshare | each {|c| nu -c $c | print }
  print $aim
  cd $base; code push share main
  shell $grams.share.machine $"mkdir '(dirname $aim)'"
  shell $m.base $"cd '($share)'; nix-shell -p git --command '($command)'"
  time rsync -av ...($nodes | path expand) $aim | print
} }

# shell $m.base (['"('
# $"mkdir '($share)';"
# (c-shell $share "init")
# (c-shell $share "bal --add safe.directory ($share)")
# (c-shell $share "branch -m main")
# (c-shell $share "config --add receive.denyCurrentBranch warn")
# ')"'] | str join "\n")

# if (code -C . remote | lines | filter {|a| $a == 'share'} | is-empty) {
#   code -C $base remote add share $aim } else {
#   code -C $base remote set-url share $aim }
# print (code -C $base remote -v)
# code -C $base push -f share
# print "pushed."
# gram help $gram

def "gram ply" [...gs: record] {
# deploy gram images on machine, compiled and managed by colmena
  $gs | group-by machine.name | transpose | get column1 | each {|machines|
    $machines | each {|mach| cd ~/.build/nixos
      colmena apply --on $mach.machine.name --build-on-target --impure switch } }

  $gs | par-each { |gram|
    let base = try { $gram.base | path basename } catch {  }
    let logs = "~/qu/log" | path expand; mkdir $logs;
    let log = [ $logs ([ (clock | str trim) $base deploy log ] | str join '.') ] | path join
    try { shell $gram.machine $"run-($gram.name)" | tee { save $log } | print }
    gram share $gram
  }

}