plum

# Dev-loop tasks for iterating on tree-sitter-plum/plum-lsp without a full
# `cargo build -p plum-cli` (which re-embeds both into the `plum` binary via
# build.rs, then still needs a `plum editor <name>` re-run to pick them up).
# Run with `cargo make <task>` (needs https://github.com/sagiegurari/cargo-make:
# `cargo install cargo-make`).
#
# `plum editor helix`/`plum editor vscode` (the CLI's own install commands)
# remain the way to set editor support up the first time; `refresh-editors`
# here only updates whichever of those are already present.

[config]
default_to_workspace = false

[tasks.grammar-so]
description = "Compile the tree-sitter-plum grammar into a native shared library"
script_runner = "@shell"
script = '''
set -e
SRC=plum-tooling/tree-sitter-plum/src
OUT=target/plum-grammar.so
mkdir -p target
${CC:-cc} -shared -fPIC -O2 -I "$SRC" -o "$OUT" "$SRC/parser.c" "$SRC/scanner.c"
echo "compiled $OUT"
'''

[tasks.lsp-release]
description = "Build plum-lsp in release mode"
command = "cargo"
args = ["build", "--release", "-p", "plum-lsp"]

[tasks.refresh-editors]
description = "Recompile the grammar + plum-lsp from current source and refresh them in whichever editor configs `plum editor helix`/`plum editor vscode` already set up"
dependencies = ["grammar-so", "lsp-release"]
script_runner = "@shell"
script = '''
set -e
LSP_BIN=target/release/plum-lsp
GRAMMAR_SO=target/plum-grammar.so

HELIX_DIR="${HELIX_RUNTIME_CONFIG:-${XDG_CONFIG_HOME:-$HOME/.config}/helix}"
if [ -f "$HELIX_DIR/languages.toml" ]; then
  mkdir -p "$HELIX_DIR/runtime/grammars"
  cp "$GRAMMAR_SO" "$HELIX_DIR/runtime/grammars/plum.so"
  cp "$LSP_BIN" "$HELIX_DIR/plum-lsp"
  chmod +x "$HELIX_DIR/plum-lsp"
  echo "refreshed $HELIX_DIR/runtime/grammars/plum.so"
  echo "refreshed $HELIX_DIR/plum-lsp"
else
  echo "Helix not installed (run \`plum editor helix\` first) — skipping"
fi

# Extension id/version must match plum-cli/src/editor.rs's VSCODE_PUBLISHER /
# VSCODE_EXTENSION_NAME / VSCODE_EXTENSION_VERSION consts.
found_vscode=0
for dir_name in .vscode .vscode-insiders; do
  ext_dir="$HOME/$dir_name/extensions/plum-lang.plum-0.0.1"
  if [ -d "$ext_dir" ]; then
    mkdir -p "$ext_dir/server"
    cp "$LSP_BIN" "$ext_dir/server/plum-lsp"
    chmod +x "$ext_dir/server/plum-lsp"
    echo "refreshed $ext_dir/server/plum-lsp"
    found_vscode=1
  fi
done
if [ "$found_vscode" = "0" ]; then
  echo "VSCode not installed (run \`plum editor vscode\` first) — skipping"
fi
'''

# ---- release binaries -------------------------------------------------------
#
# Only the `plum` binary itself is distributed — `plum-lsp`, the tree-sitter
# grammar `.so`, and the VSCode extension bundle are all embedded INTO it by
# plum-cli/build.rs already, and `plum editor helix`/`vscode` extract them at
# install time. There's nothing separate to ship.
#
# Linux/Windows are cross-compiled via https://github.com/cross-rs/cross
# (`cargo install cross --git https://github.com/cross-rs/cross`, needs
# Docker) — it ships a proper per-target C toolchain (gcc-multilib for Linux,
# mingw-w64 for Windows), which a bare `cargo build --target ...` doesn't have
# and this project needs (tree-sitter's scanner.c/parser.c are compiled via
# the `cc` crate). macOS still builds natively since that's what's running
# this Makefile.
#
# `cargo make release` is the one-shot version: builds all 3 platforms, tags
# v<version> locally, regenerates README.md's download links, and uploads
# everything to R2. Version comes from plum-cli/Cargo.toml — bump that first.

[env]
PLUM_VERSION = { script = ["grep -m1 '^version' plum-cli/Cargo.toml | sed -E 's/version = \"(.*)\"/\\1/'"] }

[tasks.dist-macos]
description = "Build a release plum-cli binary for this Mac into dist/plum-cli/"
script_runner = "@shell"
script = '''
set -e
cargo build --release -p plum-cli
mkdir -p dist/plum-cli
ARCH=$(uname -m)
case "$ARCH" in
  arm64|aarch64) ARCH=arm64 ;;
  x86_64) ARCH=x86_64 ;;
esac
OUT="dist/plum-cli/plum-darwin-$ARCH"
cp target/release/plum "$OUT"
echo "built $OUT"
'''

[tasks.dist-linux]
description = "Cross-build a release plum-cli binary for Linux x86_64 (via `cross`) into dist/plum-cli/"
script_runner = "@shell"
script = '''
set -e
cross build --release -p plum-cli --target x86_64-unknown-linux-gnu
mkdir -p dist/plum-cli
cp target/x86_64-unknown-linux-gnu/release/plum dist/plum-cli/plum-linux-x86_64
echo "built dist/plum-cli/plum-linux-x86_64"
'''

[tasks.dist-windows]
description = "Cross-build a release plum-cli binary for Windows x86_64 (via `cross`) into dist/plum-cli/"
script_runner = "@shell"
script = '''
set -e
cross build --release -p plum-cli --target x86_64-pc-windows-gnu
mkdir -p dist/plum-cli
cp target/x86_64-pc-windows-gnu/release/plum.exe dist/plum-cli/plum-windows-x86_64.exe
echo "built dist/plum-cli/plum-windows-x86_64.exe"
'''

[tasks.dist-all]
description = "Build release plum-cli binaries for macOS, Linux, and Windows into dist/plum-cli/"
dependencies = ["dist-macos", "dist-linux", "dist-windows"]

[tasks.tag-release]
description = "Create a local git tag v<version> (from plum-cli/Cargo.toml) for this release, if it doesn't already exist"
script_runner = "@shell"
script = '''
set -e
TAG="v${PLUM_VERSION}"
if git rev-parse "$TAG" >/dev/null 2>&1; then
  echo "tag $TAG already exists, skipping"
else
  git tag -a "$TAG" -m "plum-cli $TAG"
  echo "created tag $TAG locally — push it yourself with: git push origin $TAG"
fi
'''

[tasks.update-readme]
description = "Rewrite README.md's prebuilt-binaries block (between the <!-- prebuilt-binaries:... --> markers) to point at the current version"
script_runner = "@shell"
script = '''
set -e
BASE="https://git.pyrossh.dev/releases/plum-cli/v${PLUM_VERSION}"
awk -v base="$BASE" '
  /<!-- prebuilt-binaries:start -->/ {
    print
    print "| Platform | Download |"
    print "| --- | --- |"
    print "| macOS (Apple Silicon) | [plum-darwin-arm64](" base "/plum-darwin-arm64) |"
    print "| Linux (x86_64) | [plum-linux-x86_64](" base "/plum-linux-x86_64) |"
    print "| Windows (x86_64) | [plum-windows-x86_64.exe](" base "/plum-windows-x86_64.exe) |"
    print ""
    print "Make it executable and put it on your `PATH`, e.g. on macOS/Linux:"
    print ""
    print "```sh"
    print "curl -L -o plum " base "/plum-darwin-arm64"
    print "chmod +x plum"
    print "mv plum ~/.cargo/bin/plum   # or anywhere else already on your PATH"
    print "```"
    in_block = 1
    next
  }
  /<!-- prebuilt-binaries:end -->/ { in_block = 0 }
  in_block == 1 { next }
  { print }
' README.md > README.md.tmp
mv README.md.tmp README.md
echo "updated README.md prebuilt-binaries links to v${PLUM_VERSION}"
'''

[tasks.release]
description = "Build macOS/Linux/Windows release binaries, tag v<version>, update README download links, and upload all 3 to R2 (requires the `git` rclone remote — see `rclone config show git`)"
dependencies = ["dist-all", "tag-release", "update-readme"]
script_runner = "@shell"
script = '''
set -e
# `--s3-no-check-bucket`: the R2 access token here is scoped to this one
# bucket with no ListBuckets/CreateBucket permission, so rclone's default
# "does this bucket exist?" preflight (which needs one of those) fails —
# skip it and assume the bucket (already created out-of-band) exists.
rclone copy dist/plum-cli/ "git:git/releases/plum-cli/v${PLUM_VERSION}/" --s3-no-check-bucket --progress
echo ""
echo "published v${PLUM_VERSION}. Remaining steps:"
echo "  git add README.md && git commit -m \"release v${PLUM_VERSION}\""
echo "  git push && git push origin v${PLUM_VERSION}"
'''