docs: add readme

.gitea/scripts/push-image.sh

@@ -0,0 +1,22 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+REGISTRY="${REGISTRY#https://}"
+REGISTRY="${REGISTRY#http://}"
+REGISTRY="${REGISTRY%/}"
+
+IMAGE="${REGISTRY}/${REPOSITORY}:${TAG}"
+
+echo "Pushing ${IMAGE}"
+
+skopeo copy \
+  --dest-creds "${USERNAME}:${PASSWORD}" \
+  "docker-archive:result" \
+  "docker://${IMAGE}"
+
+if [ "${REF_NAME:-}" = "main" ]; then
+  skopeo copy \
+    --dest-creds "${USERNAME}:${PASSWORD}" \
+    "docker-archive:result" \
+    "docker://${REGISTRY}/${REPOSITORY}:latest"
+fi

.gitea/workflows/docker.yaml

@@ -0,0 +1,47 @@
+name: Build docker images.
+
+on:
+  push:
+
+jobs:
+  build-wordle-solver-image:
+    runs-on: nixos
+
+    steps:
+      - name: Check out repository code
+        uses: actions/checkout@v4
+
+      - name: Build wordle-solver image
+        run: |
+          nix build .#wordle-solver-docker
+
+      - name: Push image
+        env:
+          REGISTRY: "${{ gitea.server_url }}"
+          REPOSITORY: "${{ gitea.repository }}"
+          USERNAME: "${{ secrets.REGISTRY_USER }}"
+          PASSWORD: "${{ secrets.REGISTRY_TOKEN }}"
+          REF_NAME: "${{ gitea.ref_name }}"
+          TAG: "${{ gitea.sha }}"
+        run: bash .gitea/scripts/push-image.sh
+
+  build-wordle-solver-web-image:
+    runs-on: nixos
+
+    steps:
+      - name: Check out repository code
+        uses: actions/checkout@v4
+
+      - name: Build wordle-solver-web image
+        run: |
+          nix build .#wordle-solver-web-docker
+
+      - name: Push image
+        env:
+          REGISTRY: "${{ gitea.server_url }}"
+          REPOSITORY: "${{ gitea.repository }}-web"
+          USERNAME: "${{ secrets.REGISTRY_USER }}"
+          PASSWORD: "${{ secrets.REGISTRY_TOKEN }}"
+          REF_NAME: "${{ gitea.ref_name }}"
+          TAG: "${{ gitea.sha }}"
+        run: bash .gitea/scripts/push-image.sh

README.md

@@ -0,0 +1,60 @@
+# Wordle Solver
+
+This wordle solver uses an information theory based approach to evaluate the next-best-guess. It's heavily inspired by [3b1b's approach](https://www.youtube.com/watch?v=v68zYyaEmEA) on solving wordle.
+
+There are two ways to use the wordle-solver.
+
+1. a CLI tool
+2. a web interface
+
+
+# Docker
+
+#### CLI
+```sh
+docker run --rm -it git.jroeger.de/jonas/wordle-solver-rs 
+```
+
+#### web
+``` sh
+docker run -p 8080:80 --rm -it git.jroeger.de/jonas/wordle-solver-rs-web
+```
+
+# Nix
+
+#### CLI
+
+``` sh
+nix run .
+```
+
+#### Static web site
+
+``` sh
+nix build git+http://git.jroeger.de/jonas/wordle-solver-rs#wordle-solver-web
+```
+
+# Native
+
+#### CLI
+
+you will need to have `cargo` installed.
+
+```sh
+cargo run --profile release
+```
+
+#### web
+
+you need the following tools:
+- `wasm-pack`
+- `wasm-bindgen`
+- `cargo`
+- `nodejs`
+- `yarn`
+
+``` sh
+cd web
+yarn install
+yarn serve # or yarn build
+```

flake.nix

@@ -16,7 +16,6 @@
 
   outputs = inputs @ {
     flake-parts,
-    crate2nix,
     rust-overlay,
     ...
   }:
@@ -28,33 +27,24 @@
         "x86_64-linux"
       ];
 
+      imports = [
+        ./nix/wasm-bindgen.nix
+        ./nix/wordle-solver-docker.nix
+        ./nix/wordle-solver-wasm-pkg.nix
+        ./nix/wordle-solver-wasm.nix
+        ./nix/wordle-solver-web-docker.nix
+        ./nix/wordle-solver-web.nix
+        ./nix/wordle-solver.nix
+      ];
+
       perSystem = {
         pkgs,
         system,
         self',
         ...
       }: let
-        # Use rust-bin to generate the toolchain from rust-toolchain.toml
+        utils = import ./nix/utils.nix;
-        rust-toolchain = pkgs.rust-bin.fromRustupToolchainFile ./rust-toolchain.toml;
+        rust-toolchain = utils.rust-toolchain pkgs;
-
-        cross-pkgs = pkgs.pkgsCross.wasm32-unknown-none;
-
-        toolchain = pkgs.callPackage ./nix/with-toolchain.nix {
-          cargo = rust-toolchain;
-          rustc = rust-toolchain;
-        };
-        crossToolchain = cross-pkgs.callPackage ./nix/with-toolchain.nix {
-          cargo = rust-toolchain;
-          rustc = rust-toolchain;
-        };
-
-        wasm-bindgen = toolchain.pkgs.callPackage ./nix/wasm-bindgen.nix {};
-
-        root-crate = pkgs.callPackage ./nix/root-crate.nix {
-          cargo = rust-toolchain;
-          rustc = rust-toolchain;
-          inherit crate2nix;
-        };
       in {
         # Overlay pkgs with rust-bin
         _module.args.pkgs = import inputs.nixpkgs {
@@ -63,22 +53,13 @@
           config.allowUnsupportedSystem = true;
         };
 
-        packages = {
+        packages.default = self'.packages.wordle-solver;
-          wordle-solver-web = pkgs.callPackage ./nix/wordle-solver-web.nix {inherit (self'.packages) wordle-solver-wasm-pkg;};
-          wordle-solver-wasm = crossToolchain.pkgs.callPackage ./nix/wordle-solver-wasm.nix {};
-          wordle-solver-wasm-pkg = pkgs.callPackage ./nix/wordle-solver-wasm-pkg.nix {
-            inherit wasm-bindgen root-crate;
-            inherit (self'.packages) wordle-solver-wasm;
-          };
-          wordle-solver = root-crate.build;
-          default = self'.packages.wordle-solver;
-        };
 
         devShells.default = pkgs.mkShell {
           RA_LOG = "rust_analyzer=info";
           buildInputs = [
             rust-toolchain
-            wasm-bindgen
+            self'.packages.wasm-bindgen
             pkgs.nodejs
             pkgs.svelte-language-server
             pkgs.typescript-language-server

nix/root-crate.nix

@@ -1,23 +0,0 @@
-{
-  crate2nix,
-  rustc,
-  cargo,
-  pkgs,
-  ...
-}: let
-  buildRustCrateForPkgs = _:
-    pkgs.buildRustCrate.override {
-      inherit cargo rustc;
-    };
-
-  # Cargo.nix for IFD
-  generatedCargoNix = crate2nix.tools.${pkgs.hostPlatform.system}.generatedCargoNix {
-    name = "rustnix";
-    src = ../.;
-  };
-
-  cargoNix = import generatedCargoNix {
-    inherit pkgs buildRustCrateForPkgs;
-  };
-in
-  cargoNix.rootCrate

nix/utils.nix

@@ -0,0 +1,21 @@
+rec {
+  rust-toolchain = pkgs: pkgs.rust-bin.fromRustupToolchainFile ../rust-toolchain.toml;
+
+  toolchain-pkgs = pkgs:
+    pkgs.extend (_: _: {
+      rustPlatform = pkgs.makeRustPlatform {
+        cargo = rust-toolchain pkgs;
+        rustc = rust-toolchain pkgs;
+      };
+    });
+
+  toolchain-crosspkgs = pkgs: let
+    crossPkgs = pkgs.pkgsCross.wasm32-unknown-none;
+  in
+    crossPkgs.extend (_: _: {
+      rustPlatform = crossPkgs.makeRustPlatform {
+        cargo = rust-toolchain pkgs;
+        rustc = rust-toolchain pkgs;
+      };
+    });
+}

nix/wasm-bindgen.nix

@@ -1,19 +1,27 @@
-{
+let
-  fetchCrate,
+  drv = {
-  buildWasmBindgenCli,
+    fetchCrate,
-  rustPlatform,
+    buildWasmBindgenCli,
-  ...
+    rustPlatform,
-}:
+    ...
-buildWasmBindgenCli rec {
+  }:
-  src = fetchCrate {
+    buildWasmBindgenCli rec {
-    pname = "wasm-bindgen-cli";
+      src = fetchCrate {
-    version = "0.2.127";
+        pname = "wasm-bindgen-cli";
-    hash = "sha256-di+qBAdd7pENLiIB9CoZoab+W5xeDoByMREcCGTSzWo=";
+        version = "0.2.127";
-  };
+        hash = "sha256-di+qBAdd7pENLiIB9CoZoab+W5xeDoByMREcCGTSzWo=";
+      };
 
-  cargoDeps = rustPlatform.fetchCargoVendor {
+      cargoDeps = rustPlatform.fetchCargoVendor {
-    inherit src;
+        inherit src;
-    inherit (src) pname version;
+        inherit (src) pname version;
-    hash = "sha256-FTv2GZIAQs0ePdIZXIXil7JbZ6kIT05VG6vqC1qNFxQ=";
+        hash = "sha256-FTv2GZIAQs0ePdIZXIXil7JbZ6kIT05VG6vqC1qNFxQ=";
+      };
+    };
+
+  utils = import ./utils.nix;
+in {
+  perSystem = {pkgs, ...}: {
+    packages.wasm-bindgen = (utils.toolchain-pkgs pkgs).callPackage drv {};
   };
 }

nix/with-toolchain.nix

@@ -1,16 +0,0 @@
-{
-  makeRustPlatform,
-  cargo,
-  rustc,
-  pkgs,
-  ...
-}: let
-  p = pkgs;
-in rec {
-  rustPlatform = makeRustPlatform {
-    inherit cargo rustc;
-  };
-  pkgs = p.extend (_: _: {
-    inherit rustPlatform;
-  });
-}

nix/wordle-solver-docker.nix

@@ -0,0 +1,39 @@
+let
+  drv = {
+    buildEnv,
+    dockerTools,
+    wordle-solver,
+    runCommand,
+    ...
+  }:
+    dockerTools.buildImage {
+      name = "wordle-solver";
+      created = "now";
+      copyToRoot = buildEnv {
+        name = "image-root";
+        paths = [
+          wordle-solver
+          (runCommand "wordle-data" {} ''
+            mkdir -p $out/pwd
+            cp ${../valid-words.txt} $out/pwd/valid-words.txt
+            cp ${../answers.txt} $out/pwd/answers.txt
+          '')
+        ];
+        pathsToLink = ["/bin" "/pwd"];
+      };
+      config = {
+        Cmd = ["/bin/wordle-solver"];
+        WorkingDir = "/pwd";
+      };
+    };
+in {
+  perSystem = {
+    pkgs,
+    self',
+    ...
+  }: {
+    packages.wordle-solver-docker = pkgs.callPackage drv {
+      inherit (self'.packages) wordle-solver;
+    };
+  };
+}

nix/wordle-solver-wasm-pkg.nix

@@ -1,39 +1,50 @@
 {
-  stdenvNoCC,
+  perSystem = {
-  wasm-bindgen,
+    pkgs,
-  wordle-solver-wasm,
+    self',
-  root-crate,
+    ...
-  ...
+  }: let
-}: let
+    drv = {
-  snake_name = "wordle_solver";
+      stdenvNoCC,
-  package-meta = {
+      wasm-bindgen,
-    name = "wordle-solver";
+      wordle-solver-wasm,
-    type = "module";
+      ...
-    description = "module";
+    }: let
-    version = root-crate.build.crateVersion;
+      snake_name = "wordle_solver";
-    files = [
+      package-meta = {
-      "${snake_name}_bg.wasm"
+        name = "wordle-solver";
-      "${snake_name}.js"
+        type = "module";
-      "${snake_name}_bg.js"
+        description = "module";
-      "${snake_name}.d.ts"
+        version = "0.1.0";
-    ];
+        files = [
-    main = "${snake_name}.js";
+          "${snake_name}_bg.wasm"
-    types = "${snake_name}.d.ts";
+          "${snake_name}.js"
-    sideEffects = [
+          "${snake_name}_bg.js"
-      "./${snake_name}.js"
+          "${snake_name}.d.ts"
-      "./snippets/*"
+        ];
-    ];
+        main = "${snake_name}.js";
+        types = "${snake_name}.d.ts";
+        sideEffects = [
+          "./${snake_name}.js"
+          "./snippets/*"
+        ];
+      };
+      package-json = builtins.toJSON package-meta;
+    in
+      stdenvNoCC.mkDerivation {
+        name = "wordle-solver-wasm-pkg";
+        nativeBuildInputs = [wasm-bindgen];
+        unpackPhase = "true";
+        buildPhase = ''
+          wasm-bindgen --target bundler --out-dir $out ${wordle-solver-wasm}/lib/wordle_solver.wasm
+          cat <<EOF > $out/package.json
+          ${package-json}
+          EOF
+        '';
+      };
+  in {
+    packages.wordle-solver-wasm-pkg = pkgs.callPackage drv {
+      inherit (self'.packages) wordle-solver-wasm wasm-bindgen;
+    };
   };
-  package-json = builtins.toJSON package-meta;
+}
-in
-  stdenvNoCC.mkDerivation {
-    name = "wordle-solver-wasm-pkg";
-    nativeBuildInputs = [wasm-bindgen];
-    unpackPhase = "true";
-    buildPhase = ''
-      wasm-bindgen --target bundler --out-dir $out ${wordle-solver-wasm}/lib/wordle_solver.wasm
-      cat <<EOF > $out/package.json
-      ${package-json}
-      EOF
-    '';
-  }

nix/wordle-solver-wasm.nix

@@ -1,39 +1,56 @@
 {
-  rustPlatform,
+  perSystem = {pkgs, ...}: let
-  buildPackages,
+    utils = import ./utils.nix;
-  lld,
+    rust-toolchain = utils.rust-toolchain pkgs;
-  name ? "wordle-solver",
+    toolchain-crosspkgs = utils.toolchain-crosspkgs pkgs;
-  ...
+    drv = {
-}:
+      rustPlatform,
-rustPlatform.buildRustPackage {
+      buildPackages,
-  inherit name;
+      lld,
+      name ? "wordle-solver",
+      removeReferencesTo,
+      ...
+    }:
+      rustPlatform.buildRustPackage {
+        inherit name;
 
-  src = ../.; # Or your source location
+        src = ../.; # Or your source location
-  cargoLock.lockFile = ../Cargo.lock;
+        cargoLock.lockFile = ../Cargo.lock;
 
-  # Disable tests since they can't run on WASM
+        # Disable tests since they can't run on WASM
-  doCheck = false;
+        doCheck = false;
 
-  # Required dependencies for WASM builds
+        # Required dependencies for WASM builds
-  depsBuildBuild = [
+        depsBuildBuild = [
-    buildPackages.stdenv.cc
+          buildPackages.stdenv.cc
-    lld # Needed for wasm-ld
+          lld # Needed for wasm-ld
-  ];
+        ];
+        nativeBuildInputs = [removeReferencesTo];
 
-  cargoBuildFlags = [
+        cargoBuildFlags = [
-    "--lib"
+          "--lib"
-    "--features"
+          "--features"
-    "wasm-bindgen"
+          "wasm-bindgen"
-  ];
+        ];
 
-  # Configure rustc for WASM
+        # Configure rustc for WASM
-  env = {
+        RUSTFLAGS = ''--cfg=web_sys_unstable_apis -C linker=wasm-ld -C strip=debuginfo -C debuginfo=0'';
-    RUSTFLAGS = ''--cfg=web_sys_unstable_apis -C linker=wasm-ld'';
+
+        # Copy the WASM file to the output
+        installPhase = ''
+          mkdir -p $out/lib
+          cp target/wasm32-unknown-unknown/release/*.wasm $out/lib/
+
+          runHook postInstall
+        '';
+
+        # Remove toolchain from closure (store paths are debug artifacts)
+        postInstall = ''
+          remove-references-to -t ${rust-toolchain} $out/lib/*.wasm
+        '';
+      };
+  in {
+    packages.toolchain = rust-toolchain;
+    packages.wordle-solver-wasm = toolchain-crosspkgs.callPackage drv {};
   };
-
-  # Copy the WASM file to the output
-  installPhase = ''
-    mkdir -p $out/lib
-    cp target/wasm32-unknown-unknown/release/*.wasm $out/lib/
-  '';
 }

nix/wordle-solver-web-docker.nix

@@ -0,0 +1,69 @@
+let
+  drv = {
+    buildEnv,
+    dockerTools,
+    fakeNss,
+    nginx,
+    runCommand,
+    wordle-solver-web,
+    writeShellScriptBin,
+    ...
+  }:
+    dockerTools.buildImage {
+      name = "wordle-solver-web";
+      created = "now";
+      copyToRoot = buildEnv {
+        name = "image-root";
+        paths = [
+          nginx
+          (fakeNss.override {
+            extraGroupLines = [
+              "nogroup:x:65534:"
+            ];
+          })
+          (writeShellScriptBin "start" ''
+            echo "Start serving worlde-solver at port 80..."
+            /bin/nginx -c /etc/nginx.conf
+          '')
+          (runCommand "nginx-conf" {} ''
+            mkdir -p $out/etc
+
+            cat <<EOF > $out/etc/nginx.conf
+            events {}
+
+            error_log /dev/stderr;
+
+            http {
+                include ${nginx}/conf/mime.types;
+
+                server {
+                        listen 80;
+                        root ${wordle-solver-web};
+                        access_log /dev/stdout;
+                }
+            }
+
+            daemon off;
+            EOF
+          '')
+        ];
+        pathsToLink = ["/bin" "/etc"];
+      };
+      runAsRoot = ''
+        mkdir -p /var/log/nginx
+      '';
+      config = {
+        Cmd = ["/bin/start"];
+      };
+    };
+in {
+  perSystem = {
+    pkgs,
+    self',
+    ...
+  }: {
+    packages.wordle-solver-web-docker = pkgs.callPackage drv {
+      inherit (self'.packages) wordle-solver-web;
+    };
+  };
+}

nix/wordle-solver-web.nix

@@ -1,37 +1,49 @@
 {
-  stdenv,
+  perSystem = {
-  fetchYarnDeps,
+    pkgs,
-  yarnConfigHook,
+    self',
-  yarnBuildHook,
+    ...
-  nodejs,
+  }: let
-  wordle-solver-wasm-pkg,
+    drv = {
-}:
+      stdenv,
-stdenv.mkDerivation (finalAttrs: {
+      fetchYarnDeps,
-  pname = "wordle-solver-web";
+      yarnConfigHook,
-  version = "0.1.0";
+      yarnBuildHook,
+      nodejs,
+      wordle-solver-wasm-pkg,
+    }:
+      stdenv.mkDerivation (finalAttrs: {
+        pname = "wordle-solver-web";
+        version = "0.1.0";
 
-  src = ../web;
+        src = ../web;
 
-  yarnOfflineCache = fetchYarnDeps {
+        yarnOfflineCache = fetchYarnDeps {
-    yarnLock = finalAttrs.src + "/yarn.lock";
+          yarnLock = finalAttrs.src + "/yarn.lock";
-    hash = "sha256-MTyHX2+/U7jRB1SJWbK9Td43zq+nclQwx7oDZbX0DqA=";
+          hash = "sha256-MTyHX2+/U7jRB1SJWbK9Td43zq+nclQwx7oDZbX0DqA=";
+        };
+
+        yarnBuildScript = "build-no-wasm";
+
+        postPatch = ''
+          ln -s ${wordle-solver-wasm-pkg} pkg
+        '';
+
+        installPhase = ''
+          mkdir $out
+          mv dist/* $out/
+        '';
+
+        nativeBuildInputs = [
+          yarnConfigHook
+          yarnBuildHook
+          # Needed for executing package.json scripts
+          nodejs
+        ];
+      });
+  in {
+    packages.wordle-solver-web = pkgs.callPackage drv {
+      inherit (self'.packages) wordle-solver-wasm-pkg;
+    };
   };
-
+}
-  yarnBuildScript = "build-no-wasm";
-
-  postPatch = ''
-    ln -s ${wordle-solver-wasm-pkg} pkg
-  '';
-
-  installPhase = ''
-    mkdir $out
-    mv dist/* $out/
-  '';
-
-  nativeBuildInputs = [
-    yarnConfigHook
-    yarnBuildHook
-    # Needed for executing package.json scripts
-    nodejs
-  ];
-})

nix/wordle-solver.nix

@@ -0,0 +1,27 @@
+{inputs, ...}: {
+  perSystem = {pkgs, ...}: let
+    # Cargo.nix for IFD
+    generatedCargoNix = inputs.crate2nix.tools.${pkgs.hostPlatform.system}.generatedCargoNix {
+      name = "rustnix";
+      src = ../.;
+    };
+
+    utils = import ./utils.nix;
+
+    rust-toolchain = utils.rust-toolchain pkgs;
+    toolchain-pkgs = utils.toolchain-pkgs pkgs;
+
+    buildRustCrateForPkgs = _:
+      pkgs.buildRustCrate.override {
+        cargo = rust-toolchain;
+        rustc = rust-toolchain;
+      };
+
+    cargoNix = import generatedCargoNix {
+      pkgs = toolchain-pkgs;
+      inherit buildRustCrateForPkgs;
+    };
+  in {
+    packages.wordle-solver = cargoNix.rootCrate.build;
+  };
+}

web/package.json

@@ -4,13 +4,14 @@
   "version": "0.0.0",
   "type": "module",
   "scripts": {
+    "serve": "run-s wasm-pack:release vite:serve",
     "build-no-wasm": "run-s tsc vite:build",
     "build": "run-s wasm-pack:release tsc vite:build",
     "dev": "run-s wasm-pack:dev vite:dev",
     "tsc": "tsc",
     "vite:build": "vite build",
     "vite:dev": "vite -c vite.config.dev.ts",
-    "vite:preview": "vite preview",
+    "vite:serve": "vite -c vite.config.ts",
     "wasm-pack:dev": "rm -rf pkg; wasm-pack build --dev --features wasm-bindgen --manifest-path ../Cargo.toml; mv ../pkg .",
     "wasm-pack:release": "rm -rf pkg; wasm-pack build --features wasm-bindgen --manifest-path ../Cargo.toml; mv ../pkg ."
   },