Taskfile.yml

version: '3'

vars:
  APP_NAME: "anime-image-viewer"
  VERSION: 0.1.0
  BIN_DIR: "bin"
  VITE_PORT: '{{.WAILS_VITE_PORT | default 9245}}'

tasks:

  ## -------------------------- Build -------------------------- ##

  build:
    summary: Builds the application
    cmds:
      # Build for current OS
      - task: build:{{OS}}

      # Uncomment to build for specific OSes
      # - task: build:linux
      # - task: build:windows
      # - task: build:darwin


  ## ------> Windows <-------
  build:wsl:
    summary: Builds the application for Windows
    deps:
      - task: go:mod:tidy
      - task: build:frontend
        vars:
          BUILD_FLAGS: '{{.BUILD_FLAGS}}'
      - task: generate:icons
      - task: generate:syso
        vars:
          ARCH: '{{.ARCH}}'
    cmds:
      - go build {{.BUILD_FLAGS}} -o {{.BIN_DIR}}/anime-image-viewer.exe
    vars:
      BUILD_FLAGS: '{{if eq .PRODUCTION "true"}}-tags production -trimpath -ldflags="-w -s -H windowsgui"{{else}}-gcflags=all="-l"{{end}}'
    env:
      # Enable to build for Window on Linux
      # https://stackoverflow.com/questions/41566495/golang-how-to-cross-compile-on-linux-for-windows
      GOOS: windows
      CGO_ENABLED: 1
      CXX: "x86_64-w64-mingw32-g++"
      CC: "x86_64-w64-mingw32-gcc"
      GOARCH: '{{.ARCH | default ARCH}}'
      PRODUCTION: '{{.PRODUCTION | default "false"}}'

  build:wsl:debug:amd64:
    summary: Creates a debug build of the application
    cmds:
      - task: build:wsl
        vars:
          ARCH: amd64

  build:wsl:prod:
    summary: Creates a production build of the application
    cmds:
      - task: build:wsl
        vars:
          ARCH: '{{.ARCH | default ARCH}}'
          PRODUCTION: "true"

  build:wsl:prod:amd64:
    summary: Creates a production build of the application
    cmds:
      - task: build:wsl
        vars:
          ARCH: amd64
          PRODUCTION: "true"

  build:windows:
    summary: Builds the application for Windows
    deps:
      - task: go:mod:tidy
      - task: build:frontend
        vars:
          BUILD_FLAGS: '{{.BUILD_FLAGS}}'
      - task: generate:icons
      - task: generate:syso
        vars:
          ARCH: '{{.ARCH}}'
    cmds:
      - go build {{.BUILD_FLAGS}} -o {{.BIN_DIR}}/anime-image-viewer.exe
    vars:
      BUILD_FLAGS: '{{if eq .PRODUCTION "true"}}-tags production -trimpath -ldflags="-w -s -H windowsgui"{{else}}-gcflags=all="-l"{{end}}'
    env:
      GOOS: windows
      CGO_ENABLED: 0
      GOARCH: '{{.ARCH | default ARCH}}'
      PRODUCTION: '{{.PRODUCTION | default "false"}}'

  build:windows:prod:arm64:
    summary: Creates a production build of the application
    cmds:
      - task: build:windows
        vars:
          ARCH: arm64
          PRODUCTION: "true"

  build:windows:prod:amd64:
    summary: Creates a production build of the application
    cmds:
      - task: build:windows
        vars:
          ARCH: amd64
          PRODUCTION: "true"

  build:windows:debug:arm64:
    summary: Creates a debug build of the application
    cmds:
      - task: build:windows
        vars:
          ARCH: arm64

  build:windows:debug:amd64:
    summary: Creates a debug build of the application
    cmds:
      - task: build:windows
        vars:
          ARCH: amd64

  ## ------> Darwin <-------

  build:darwin:
    summary: Creates a production build of the application
    deps:
      - task: go:mod:tidy
      - task: build:frontend
        vars:
          BUILD_FLAGS: '{{.BUILD_FLAGS}}'
      - task: generate:icons
    cmds:
      - go build {{.BUILD_FLAGS}} -o {{.BIN_DIR}}/{{.APP_NAME}}
    vars:
      BUILD_FLAGS: '{{if eq .PRODUCTION "true"}}-tags production -trimpath -ldflags="-w -s"{{else}}-gcflags=all="-l"{{end}}'
    env:
      GOOS: darwin
      CGO_ENABLED: 1
      GOARCH: '{{.ARCH | default ARCH}}'
      CGO_CFLAGS: "-mmacosx-version-min=10.15"
      CGO_LDFLAGS: "-mmacosx-version-min=10.15"
      MACOSX_DEPLOYMENT_TARGET: "10.15"
      PRODUCTION: '{{.PRODUCTION | default "false"}}'

  build:darwin:prod:arm64:
    summary: Creates a production build of the application
    cmds:
      - task: build:darwin
        vars:
          ARCH: arm64
          PRODUCTION: "true"

  build:darwin:prod:amd64:
    summary: Creates a production build of the application
    cmds:
      - task: build:darwin
        vars:
          ARCH: amd64
          PRODUCTION: "true"

  build:darwin:debug:arm64:
    summary: Creates a debug build of the application
    cmds:
      - task: build:darwin
        vars:
          ARCH: arm64

  build:darwin:debug:amd64:
    summary: Creates a debug build of the application
    cmds:
      - task: build:darwin
        vars:
          ARCH: amd64


  ## ------> Linux <-------

  build:linux:
    summary: Builds the application for Linux
    deps:
      - task: go:mod:tidy
      - task: build:frontend
        vars:
          BUILD_FLAGS: '{{.BUILD_FLAGS}}'
      - task: generate:icons
        vars:
          ARCH: '{{.ARCH}}'
    cmds:
      - go build {{.BUILD_FLAGS}} -o {{.BIN_DIR}}/anime-image-viewer
    vars:
      BUILD_FLAGS: '{{if eq .PRODUCTION "true"}}-tags production -trimpath -ldflags="-w -s"{{else}}-gcflags=all="-l"{{end}}'
    env:
      GOOS: linux
      CGO_ENABLED: 1
      GOARCH: '{{.ARCH | default ARCH}}'
      PRODUCTION: '{{.PRODUCTION | default "false"}}'

  build:linux:prod:arm64:
    summary: Creates a production build of the application
    cmds:
      - task: build:linux
        vars:
          ARCH: arm64
          PRODUCTION: "true"

  build:linux:prod:amd64:
    summary: Creates a production build of the application
    cmds:
      - task: build:linux
        vars:
          ARCH: amd64
          PRODUCTION: "true"

  build:linux:debug:arm64:
    summary: Creates a debug build of the application
    cmds:
      - task: build:linux
        vars:
          ARCH: arm64

  build:linux:debug:amd64:
    summary: Creates a debug build of the application
    cmds:
      - task: build:linux
        vars:
          ARCH: amd64

  ## -------------------------- Package -------------------------- ##

  package:
    summary: Packages a production build of the application into a bundle
    cmds:

      # Package for current OS
      - task: package:{{OS}}

      # Package for specific os/arch
      # - task: package:darwin:arm64
      # - task: package:darwin:amd64
      # - task: package:windows:arm64
      # - task: package:windows:amd64

  ## ------>  Windows <------

  package:windows:
    summary: Packages a production build of the application into a `.exe` bundle
    cmds:
      - task: create:nsis:installer
        vars:
          ARCH: '{{.ARCH}}'
    vars:
        ARCH: '{{.ARCH | default ARCH}}'

  package:windows:arm64:
    summary: Packages a production build of the application into a `.exe` bundle
    cmds:
      - task: package:windows
        vars:
          ARCH: arm64

  package:windows:amd64:
    summary: Packages a production build of the application into a `.exe` bundle
    cmds:
      - task: package:windows
        vars:
          ARCH: amd64

  generate:syso:
    summary: Generates Windows `.syso` file
    dir: build
    cmds:
      - wails3 generate syso -arch {{.ARCH}} -icon icon.ico -manifest wails.exe.manifest -info info.json -out ../wails.syso
    vars:
      ARCH: '{{.ARCH | default ARCH}}'

  generate:assets:
    summary: Generates assets
    cmds:
      - |
        wails3 generate build-assets \
          -name "{{.APP_NAME}}" \
          -productname "{{.APP_NAME}}" \
          -productcomments "The viewer for anime images" \
          -productdescription "" \
          -productidentifier "io.michael-freling.{{.APP_NAME}}" \
          -productcompany "" \
          -productcopyright "Copyright © 2025" \
          -productversion "{{ .VERSION }}"
      # For some reasons, icons were reset
      - git checkout build/appicon.png
      - task: generate:icons

  create:nsis:installer:
    summary: Creates an NSIS installer
    label: "NSIS Installer ({{.ARCH}})"
    dir: build/nsis
    sources:
      - "{{.ROOT_DIR}}\\bin\\{{.APP_NAME}}.exe"
    generates:
      - "{{.ROOT_DIR}}\\bin\\{{.APP_NAME}}-{{.ARCH}}-installer.exe"
    deps:
      - task: build:windows
        vars:
          PRODUCTION: "true"
          ARCH: '{{.ARCH}}'
    cmds:
      - makensis -DARG_WAILS_'{{.ARG_FLAG}}'_BINARY="{{.ROOT_DIR}}\{{.BIN_DIR}}\{{.APP_NAME}}.exe" project.nsi
    vars:
      ARCH: '{{.ARCH | default ARCH}}'
      ARG_FLAG: '{{if eq .ARCH "amd64"}}AMD64{{else}}ARM64{{end}}'

  ## ------>  Darwin <------

  package:darwin:
    summary: Packages a production build of the application into a `.app` bundle
    platforms: [ darwin ]
    deps:
      - task: build:darwin
        vars:
          PRODUCTION: "true"
    cmds:
      - task: create:app:bundle

  package:darwin:arm64:
    summary: Packages a production build of the application into a `.app` bundle
    platforms: [ darwin/arm64 ]
    deps:
      - task: package:darwin
        vars:
          ARCH: arm64

  package:darwin:amd64:
    summary: Packages a production build of the application into a `.app` bundle
    platforms: [ darwin/amd64 ]
    deps:
      - task: package:darwin
        vars:
          ARCH: amd64

  create:app:bundle:
    summary: Creates an `.app` bundle
    cmds:
      - mkdir -p {{.BIN_DIR}}/{{.APP_NAME}}.app/Contents/{MacOS,Resources}
      - cp build/icons.icns {{.BIN_DIR}}/{{.APP_NAME}}.app/Contents/Resources
      - cp {{.BIN_DIR}}/{{.APP_NAME}} {{.BIN_DIR}}/{{.APP_NAME}}.app/Contents/MacOS
      - cp build/Info.plist {{.BIN_DIR}}/{{.APP_NAME}}.app/Contents

  ## ------>  Linux <------

  package:linux:
    summary: Packages a production build of the application for Linux
    platforms: [ linux ]
    deps:
      - task: build:linux
        vars:
          PRODUCTION: "true"
    cmds:
      - task: create:appimage

  create:appimage:
    summary: Creates an AppImage
    dir: build/appimage
    platforms: [ linux ]
    deps:
      - task: build:linux
        vars:
          PRODUCTION: "true"
      - task: generate:linux:dotdesktop
    cmds:
      # Copy binary + icon to appimage dir
      - cp {{.APP_BINARY}} {{.APP_NAME}}
      - cp ../appicon.png appicon.png
      # Generate AppImage
      - wails3 generate appimage -binary {{.APP_NAME}} -icon {{.ICON}} -desktopfile {{.DESKTOP_FILE}} -outputdir {{.OUTPUT_DIR}} -builddir {{.ROOT_DIR}}/build/appimage
    vars:
      APP_NAME: '{{.APP_NAME}}'
      APP_BINARY: '../../bin/{{.APP_NAME}}'
      ICON: '../appicon.png'
      DESKTOP_FILE: '{{.APP_NAME}}.desktop'
      OUTPUT_DIR: '../../bin'

  generate:linux:dotdesktop:
    summary: Generates a `.desktop` file
    dir: build
    sources:
        - "appicon.png"
    generates:
        - '{{.ROOT_DIR}}/build/appimage/{{.APP_NAME}}.desktop'
    cmds:
      - mkdir -p {{.ROOT_DIR}}/build/appimage
      # Run `wails3 generate .desktop -help` for all the options
      - wails3 generate .desktop -name "{{.APP_NAME}}" -exec "{{.EXEC}}" -icon "{{.ICON}}" -outputfile {{.ROOT_DIR}}/build/appimage/{{.APP_NAME}}.desktop -categories "{{.CATEGORIES}}"
      # -comment "A comment"
      # -terminal "true"
      # -version "1.0"
      # -genericname "Generic Name"
      # -keywords "keyword1;keyword2;"
      # -startupnotify "true"
      # -mimetype "application/x-extension1;application/x-extension2;"

    vars:
      APP_NAME: '{{.APP_NAME}}'
      EXEC: '{{.APP_NAME}}'
      ICON: 'appicon'
      CATEGORIES: 'Development;'
      OUTPUTFILE: '{{.ROOT_DIR}}/build/appimage/{{.APP_NAME}}.desktop'

  ## -------------------------- Misc -------------------------- ##


  generate:icons:
    summary: Generates Windows `.ico` and Mac `.icns` files from an image
    dir: build
    sources:
      - "appicon.png"
    generates:
      - "icons.icns"
      - "icons.ico"
    cmds:
      # Generates both .ico and .icns files
      - wails3 generate icons -input appicon.png

  install:frontend:deps:
    summary: Install frontend dependencies
    dir: frontend
    sources:
      - package.json
      - package-lock.json
    generates:
      - node_modules/*
    preconditions:
      - sh: npm version
        msg: "Looks like npm isn't installed. Npm is part of the Node installer: https://nodejs.org/en/download/"
    cmds:
      # - npm install --silent --no-progress
      - npm install

  build:frontend:
    summary: Build the frontend project
    dir: frontend
    sources:
      - "**/*"
    generates:
      - dist/*
    deps:
      - install:frontend:deps
      - task: generate:bindings
        vars:
          BUILD_FLAGS: '{{.BUILD_FLAGS}}'
    cmds:
      - npm run build -q

  generate:bindings:
    summary: Generates bindings for the frontend
    sources:
      - "**/*.go"
      - go.mod
      - go.sum
    generates:
      - "frontend/bindings/**/*"
    cmds:
      # For a complete list of options, run `wails3 generate bindings -help`
      - wails3 generate bindings -f '{{.BUILD_FLAGS}}' -ts

  go:mod:tidy:
    summary: Runs `go mod tidy`
    internal: true
    generates:
      - go.sum
    sources:
      - go.mod
    cmds:
      - go mod tidy

# ----------------------- dev ----------------------- #


  run:
    summary: Runs the application
    cmds:
      - task: run:{{OS}}

  run:wsl:
    summary: Runs the application
    cmds:
      - '{{.BIN_DIR}}/{{.APP_NAME}}.exe'

  run:windows:
    cmds:
      - '{{.BIN_DIR}}\\{{.APP_NAME}}.exe'

  run:linux:
    cmds:
      - '{{.BIN_DIR}}/{{.APP_NAME}}'

  run:darwin:
    cmds:
      - '{{.BIN_DIR}}/{{.APP_NAME}}'

  run:export:datasets:
    summary: Exports
    cmds:
      - go run {{ .BUILD_FLAGS }} ./cmd/pluginctl/ export --config pluginctl-config.{{.ENVIRONMENT}}.toml datasets
    vars:
      BUILD_FLAGS: '{{if eq .PRODUCTION "true"}}-tags production{{end}}'
      ENVIRONMENT: '{{if eq .PRODUCTION "true"}}production{{else}}development{{end}}'
    env:
      PRODUCTION: '{{.PRODUCTION | default "false"}}'

  run:export:datasets:prod:
    summary: Exports
    cmds:
      - task: run:export:datasets
        vars:
          PRODUCTION: "true"

  dev:frontend:
    summary: Runs the frontend in development mode
    dir: frontend
    deps:
      - task: install:frontend:deps
    cmds:
      - npm run dev -- --port {{.VITE_PORT}} --strictPort

  dev:plugins:
    summary: Runs the plugins in development mode
    dir: plugins/tag-suggestion
    cmds:
      - pdm run server &

  dev:
    summary: Runs the application in development mode
    cmds:
      - task: dev:plugins

      - wails3 dev -config ./build/devmode.config.yaml -port {{.VITE_PORT}}

  dev:reload:
    summary: Reloads the application
    cmds:
      - task: run

  train:debug:
    summary: Train the model
    cmds:
      - rm -rf datasets
      - task: run:export:datasets
      - rm -rf ./plugins/tag-suggestion/source
      - mv datasets ./plugins/tag-suggestion/source
      - task: suggestion:train:debug

  train:prod:
    summary: Export data and train a ML model
    cmds:
      - rm -rf datasets
      - task: run:export:datasets:prod
      - rm -rf ./plugins/tag-suggestion/source
      - mv datasets ./plugins/tag-suggestion/source
      - task: suggestion:train:prod

  suggestion:train:debug:
    dir: plugins/tag-suggestion
    summary: Trains the model
    cmds:
      - pdm run preprocess
      - pdm run train

  suggestion:train:prod:
    dir: plugins/tag-suggestion
    summary: Trains the model
    cmds:
      - pdm run preprocess
      - pdm run train