Merge pull request #208 from elpatron68/master

Windows port

Author: naggie

.github/workflows/ci.yml

@@ -48,3 +48,37 @@ jobs:
         run: |
           go test -v -mod=vendor ./...
           ./integrationtest.sh
+
+  windows-test:
+    runs-on: windows-latest
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 50
+
+      - name: Set up Go
+        uses: actions/setup-go@v5
+        with:
+          go-version-file: go.mod
+
+      - name: Go mod vendor
+        shell: pwsh
+        run: go mod vendor
+
+      - name: Configure Git User
+        shell: pwsh
+        run: |
+          git config --global user.name "GitHub Actions Bot"
+          git config --global user.email "actions@github.com"
+
+      - name: Run Go tests
+        shell: pwsh
+        run: go test -v -mod=vendor ./...
+
+      - name: Build Windows binaries
+        shell: pwsh
+        run: |
+          go build -mod=vendor -o dstask.exe ./cmd/dstask
+          go build -mod=vendor -o dstask-import.exe ./cmd/dstask-import

README.md

@@ -45,7 +45,7 @@ Features:
 - Task listing won't break with long task text
 - `note` command -- edit a **full markdown note** for each task. **Checklists are useful here.**
 - `open` command -- **open URLs found in specified task** (including notes) in the browser
-- zsh/bash completion (including tags and projects in current context) for speed
+- zsh/bash completion (including tags and projects in current context) for speed; PowerShell completion on Windows
 - A single statically-linked binary
 - [import tool](doc/dstask-import.md) which can import GitHub issues or taskwarrior tasks.
 
@@ -105,10 +105,53 @@ Requirements:
 
 # Installation
 
-1. Copy the executable (from the [releases page][releases]) to somewhere in your path, named `dstask` and mark it executable. `/usr/local/bin/` is suggested.
-1. Enable bash completions by copying `source <(dstask bash-completion)` into your `.bashrc`. There's also a `zsh-completion` subcommand.
+1. Copy the executable (from the [releases page][releases]) to somewhere in your PATH.
+   - Linux/macOS: name it `dstask` and mark it executable (e.g. `/usr/local/bin/`).
+   - Windows: use `dstask.exe` and place it in a directory on `PATH` (e.g. `%USERPROFILE%\bin`).
+1. Enable shell completions:
+   - Bash: add `source <(dstask bash-completion)` to your `.bashrc`.
+   - Zsh: add `dstask zsh-completion > /usr/local/share/zsh/site-functions/_dstask` or source `completions/zsh.sh` in your `~/.zshrc`.
+   - PowerShell (Windows): see section "PowerShell completion" below.
 1. Set up an alias in your `.bashrc`: `alias task=dstask` or `alias t=dstask` to make task management slightly faster.
-1. Create or clone a ~/.dstask git repository for the data, if you haven't already: `mkdir ~/.dstask && git -C ~/.dstask init`.
+1. Create or clone a `~/.dstask` git repository for the data, if you haven't already:
+   - Linux/macOS: `mkdir ~/.dstask && git -C ~/.dstask init`
+   - Windows: `mkdir %USERPROFILE%\.dstask` then `git -C %USERPROFILE%\.dstask init`
+
+## Windows notes
+
+- Default data location: `%USERPROFILE%\.dstask` (can be overridden via `DSTASK_GIT_REPO`).
+- On first run, dstask may prompt to create the repository if it doesn't exist; answer `y`/`yes` to proceed.
+- Terminal: use Windows Terminal or PowerShell with a 256-color capable profile for best results.
+- Shell completions: PowerShell completion is supported; see next section.
+
+### PowerShell completion
+
+To enable PowerShell tab completion for `dstask` on Windows, use the embedded script in `completions/powershell.ps1`.
+
+One-off for the current session:
+
+```powershell
+. ./completions/powershell.ps1
+```
+
+Enable permanently by dot-sourcing from your PowerShell profile:
+
+```powershell
+# Create a profile if it doesn't exist
+if (!(Test-Path -LiteralPath $PROFILE)) { New-Item -ItemType File -Path $PROFILE -Force | Out-Null }
+
+# Open your profile for editing
+notepad $PROFILE
+
+# Add the following line (adjust path if needed):
+. "$PSScriptRoot/completions/powershell.ps1"
+```
+
+Alternatively, hardcode the absolute path to the repository if `PSScriptRoot` is not suitable for your setup, e.g.:
+
+```powershell
+. "C:\\Users\\<you>\\source\\repos\\dstask-win-port\\completions\\powershell.ps1"
+```
 
 There are also unofficial packages for:
 
@@ -288,8 +331,12 @@ See [etc/PERFORMANCE.md](etc/PERFORMANCE.md)
 
 See [etc/DATABASE_FORMAT.md](etc/DATABASE_FORMAT.md)
 
-The default database location is `~/.dstask/`, but can be configured by the
-environment variable `DSTASK_GIT_REPO`.
+The default database location is:
+
+- Linux/macOS: `~/.dstask/`
+- Windows: `%USERPROFILE%\\.dstask`
+
+It can be configured by the environment variable `DSTASK_GIT_REPO`.
 
 # Alternatives
 

cmd/dstask-import/main.go

@@ -3,6 +3,7 @@ package main
 import (
 	"fmt"
 	"os"
+	"path/filepath"
 
 	"github.com/naggie/dstask"
 	"github.com/naggie/dstask/pkg/imp/config"
@@ -49,8 +50,13 @@ func main() {
 			dstask.ExitFail(err.Error())
 		}
 	case "github":
-		repo := getEnv("DSTASK_GIT_REPO", os.ExpandEnv("$HOME/.dstask"))
-		configFile := os.ExpandEnv("$HOME/.dstask-import.toml")
+		// Determine platform-safe default paths
+		home, err := os.UserHomeDir()
+		if err != nil {
+			home = os.Getenv("HOME")
+		}
+		repo := getEnv("DSTASK_GIT_REPO", filepath.Join(home, ".dstask"))
+		configFile := filepath.Join(home, ".dstask-import.toml")
 
 		cfg, err := config.Load(configFile, repo)
 		if err != nil {

completions/embed.go

@@ -17,3 +17,8 @@ var Bash string
 //
 //go:embed completions.fish
 var Fish string
+
+// PowerShell completion script
+//
+//go:embed powershell.ps1
+var PowerShell string

completions/powershell.ps1

@@ -0,0 +1,27 @@
+# Register PowerShell argument completer for dstask using the built-in completion engine.
+# It invokes `dstask _completions` with the current command line to get suggestions.
+
+Register-ArgumentCompleter -Native -CommandName dstask,task -ScriptBlock {
+    param($wordToComplete, $commandAst, $cursorPosition)
+
+    try {
+        # Build args: dstask _completions <user command line>
+        # We collect only argument tokens (ignore command name itself)
+        $tokens = [System.Management.Automation.PSParser]::Tokenize($commandAst.Extent.Text, [ref]$null)
+        $argTokens = $tokens | Where-Object { $_.Type -eq 'CommandArgument' } | ForEach-Object { $_.Content }
+        $args = @('_completions') + $argTokens
+
+        $completions = & dstask @args 2>$null
+        if (-not $completions) { return }
+
+        foreach ($c in $completions) {
+            if ($c -like "$wordToComplete*") {
+                [System.Management.Automation.CompletionResult]::new($c, $c, 'ParameterValue', $c)
+            }
+        }
+    } catch {
+        # no-op on errors to avoid noisy completion failures
+    }
+}
+
+

config.go

@@ -2,7 +2,7 @@ package dstask
 
 import (
 	"os"
-	"path"
+	"path/filepath"
 )
 
 // Config models the dstask application's required configuration. All paths
@@ -23,9 +23,16 @@ func NewConfig() Config {
 	var conf Config
 
 	conf.CtxFromEnvVar = getEnv("DSTASK_CONTEXT", "")
-	conf.Repo = getEnv("DSTASK_GIT_REPO", os.ExpandEnv("$HOME/.dstask"))
-	conf.StateFile = path.Join(conf.Repo, ".git", "dstask", "state.bin")
-	conf.IDsFile = path.Join(conf.Repo, ".git", "dstask", "ids.bin")
+	// Determine home directory in a platform-independent way
+	home, err := os.UserHomeDir()
+	if err != nil {
+		// Fallback: use $HOME if present
+		home = os.Getenv("HOME")
+	}
+	defaultRepo := filepath.Join(home, ".dstask")
+	conf.Repo = getEnv("DSTASK_GIT_REPO", defaultRepo)
+	conf.StateFile = filepath.Join(conf.Repo, ".git", "dstask", "state.bin")
+	conf.IDsFile = filepath.Join(conf.Repo, ".git", "dstask", "ids.bin")
 
 	return conf
 }

integration/main_test.go

@@ -6,20 +6,23 @@ import (
 	"log"
 	"os"
 	"os/exec"
+	"runtime"
 	"testing"
 
 	"github.com/naggie/dstask"
 	"gotest.tools/assert"
 )
 
 func TestMain(m *testing.M) {
-	if err := compile(); err != nil {
+	binary := binaryPath()
+
+	if err := compile(binary); err != nil {
 		log.Fatalf("compile error: %v", err)
 	}
 
 	cleanup := func() {
-		if err := os.Remove("dstask"); err != nil {
-			log.Panic("could not remove integration test binary")
+		if err := os.Remove(binary); err != nil {
+			log.Panicf("could not remove integration test binary %s", binary)
 		}
 	}
 
@@ -29,20 +32,28 @@ func TestMain(m *testing.M) {
 	os.Exit(exitCode)
 }
 
-func compile() error {
+func compile(outputPath string) error {
 	// We expect to execute in the ./integration directory, and we will output
 	// our test binary there.
-	cmd := exec.Command("go", "build", "-mod=vendor", "-o", "./dstask", "../cmd/dstask/main.go")
+	cmd := exec.Command("go", "build", "-mod=vendor", "-o", outputPath, "../cmd/dstask/main.go")
 
 	return cmd.Run()
 }
 
+func binaryPath() string {
+	if runtime.GOOS == "windows" {
+		return "./dstask.exe"
+	}
+
+	return "./dstask"
+}
+
 // Create a callable closure that will run our test binary against a
 // particular repository path. Any variables set in the environment will be
 // passed to the test subprocess.
 func testCmd(repoPath string) func(args ...string) ([]byte, *exec.ExitError, bool) {
 	return func(args ...string) ([]byte, *exec.ExitError, bool) {
-		cmd := exec.Command("./dstask", args...)
+		cmd := exec.Command(binaryPath(), args...)
 		env := os.Environ()
 		cmd.Env = append(env, "DSTASK_GIT_REPO="+repoPath)
 		output, err := cmd.Output()
@@ -77,7 +88,11 @@ func setEnv(key, value string) func() {
 func logFailure(t *testing.T, output []byte, exiterr *exec.ExitError) {
 	t.Helper()
 	t.Logf("stdout: %s", string(output))
-	t.Logf("stderr: %v", string(exiterr.Stderr))
+	if exiterr != nil {
+		t.Logf("stderr: %s", string(exiterr.Stderr))
+	} else {
+		t.Log("stderr: <nil>")
+	}
 }
 
 func unmarshalTaskArray(t *testing.T, data []byte) []dstask.Task {
@@ -134,6 +149,9 @@ func assertProgramResult(
 
 	if exiterr != nil || !successExpected {
 		logFailure(t, output, exiterr)
-		t.Fatalf("%v", exiterr)
+		if exiterr != nil {
+			t.Fatalf("%v", exiterr)
+		}
+		t.Fatalf("command exited unsuccessfully")
 	}
 }

util.go

@@ -14,7 +14,6 @@ import (
 
 	"github.com/gofrs/uuid"
 	"github.com/mattn/go-isatty"
-	"golang.org/x/sys/unix"
 )
 
 func ExitFail(format string, a ...any) {
@@ -32,7 +31,9 @@ func ConfirmOrAbort(format string, a ...any) {
 		panic(err)
 	}
 
-	if input == "y\n" {
+	// Normalize input: remove CR/LF/whitespace and compare in lowercase
+	normalized := strings.ToLower(strings.TrimSpace(input))
+	if normalized == "y" || normalized == "yes" {
 		return
 	}
 
@@ -268,18 +269,7 @@ func DeduplicateStrings(s []string) []string {
 	return s[:j]
 }
 
-func MustGetTermSize() (int, int) {
-	if FAKE_PTY {
-		return 80, 24
-	}
-
-	ws, err := unix.IoctlGetWinsize(int(os.Stdout.Fd()), unix.TIOCGWINSZ)
-	if err != nil {
-		ExitFail("Not a TTY")
-	}
-
-	return int(ws.Col), int(ws.Row)
-}
+// MustGetTermSize is implemented per-OS in util_unix.go and util_windows.go
 
 func StdoutIsTTY() bool {
 	isTTY := isatty.IsTerminal(os.Stdout.Fd()) || isatty.IsCygwinTerminal(os.Stdout.Fd())

util_unix.go

@@ -0,0 +1,22 @@
+//go:build !windows
+
+package dstask
+
+import (
+	"os"
+
+	"golang.org/x/sys/unix"
+)
+
+func MustGetTermSize() (int, int) {
+	if FAKE_PTY {
+		return 80, 24
+	}
+
+	ws, err := unix.IoctlGetWinsize(int(os.Stdout.Fd()), unix.TIOCGWINSZ)
+	if err != nil {
+		ExitFail("Not a TTY")
+	}
+
+	return int(ws.Col), int(ws.Row)
+}

util_windows.go

@@ -0,0 +1,24 @@
+//go:build windows
+
+package dstask
+
+import (
+	"os"
+
+	"github.com/mattn/go-isatty"
+)
+
+func MustGetTermSize() (int, int) {
+	if FAKE_PTY {
+		return 80, 24
+	}
+
+	// Fallback: if not a TTY, fail as vorher
+	if !(isatty.IsTerminal(os.Stdout.Fd()) || isatty.IsCygwinTerminal(os.Stdout.Fd())) {
+		ExitFail("Not a TTY")
+	}
+
+	// On Windows, golang.org/x/sys/unix is unavailable; use conservative default
+	// Many Windows terminals handle wrapping; we pick a reasonable width
+	return 80, 24
+}