fix(wm): dynamically reserve monitor ring space

This commit makes a small change to dynamically keep reserving space in
the VecDeque that backs Ring<Monitor> until an index preference can be
contained within the current length.

.czrc

@@ -0,0 +1,3 @@
+{
+  "path": "cz-conventional-changelog"
+}

.github/FUNDING.yml

@@ -0,0 +1,2 @@
+github: LGUG2Z
+ko_fi: lgug2z

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,52 @@
+---
+name: Bug report
+about: Create a report to help us improve
+title: "[BUG]: Short descriptive title"
+labels: bug
+assignees: ''
+
+---
+
+**Describe the bug**
+A clear and concise description of what the bug is.
+
+**To Reproduce**
+Steps to reproduce the behavior:
+1. Go to '...'
+2. Click on '....'
+3. Scroll down to '....'
+4. See bug
+
+**Expected behavior**
+A clear and concise description of what you expected to happen.
+
+**Screenshots and Videos**
+Add screenshots and videos to help explain your problem.
+
+**Operating System**
+Provide the output of `systeminfo | grep "^OS Name\|^OS Version"`
+
+For example:
+```
+OS Name:                   Microsoft Windows 11 Pro
+OS Version:                10.0.22000 N/A Build 22000
+```
+
+**`komorebic check` Output**
+Provide the output of `komorebic check`
+
+For example:
+```
+No KOMOREBI_CONFIG_HOME detected, defaulting to C:\Users\LGUG2Z
+
+Looking for configuration files in C:\Users\LGUG2Z
+
+No komorebi configuration found in C:\Users\LGUG2Z
+
+If running 'komorebic start --await-configuration', you will manually have to call the following command to begin tiling: komorebic complete-configuration
+```
+
+**Additional context**
+Add any other context about the problem here.
+
+In particular, if you have any other AHK scripts or software running that handle any aspect of window management or manipulation

.github/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,20 @@
+---
+name: Feature request
+about: Suggest an idea for this project
+title: "[FEAT]: Short descriptive title"
+labels: enhancement
+assignees: ''
+
+---
+
+**Is your feature request related to a problem? Please describe.**
+A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
+
+**Describe the solution you'd like**
+A clear and concise description of what you want to happen.
+
+**Describe alternatives you've considered**
+A clear and concise description of any alternative solutions or features you've considered.
+
+**Additional context**
+Add any other context or screenshots about the feature request here.

.github/dependabot.yml

@@ -13,7 +13,7 @@ updates:
   - package-ecosystem: "cargo"
     directory: "/"
     schedule:
-      interval: "monthly"
+      interval: "weekly"
     assignees:
       - "LGUG2Z"
     commit-message:

.github/workflows/windows.yaml

@@ -28,7 +28,7 @@ jobs:
         target:
           - x86_64-pc-windows-msvc
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v4
         with:
           fetch-depth: 0
       - name: Prep cargo dirs
@@ -42,7 +42,7 @@ jobs:
           echo "TARGET=${{ matrix.target }}" | Out-File -Append -FilePath $env:GITHUB_ENV -Encoding utf8
           echo "SKIP_TESTS=" | Out-File -Append -FilePath $env:GITHUB_ENV -Encoding utf8
       - name: Cache cargo registry, git trees and binaries
-        uses: actions/cache@v2
+        uses: actions/cache@v4
         with:
           path: |
             ~/.cargo/registry
@@ -55,7 +55,7 @@ jobs:
           echo "::set-output name=rust_hash::$(rustc -Vv | grep commit-hash | awk '{print $2}')"
         shell: bash
       - name: Cache cargo build
-        uses: actions/cache@v2
+        uses: actions/cache@v4
         with:
           path: target
           key: ${{ github.base_ref }}-${{ github.head_ref }}-${{ matrix.target }}-cargo-target-dir-${{ steps.cargo-target-cache.outputs.rust_hash }}-${{ hashFiles('**/Cargo.lock') }}
@@ -66,7 +66,6 @@ jobs:
           $ProgressPreference = "SilentlyContinue"
           Invoke-WebRequest https://win.rustup.rs/ -OutFile rustup-init.exe
           .\rustup-init.exe -y --default-host=x86_64-pc-windows-msvc --profile=minimal
-          del rustup-init.exe
         shell: powershell
       - name: Ensure stable toolchain is up to date
         run: rustup update stable
@@ -74,29 +73,68 @@ jobs:
       - name: Install the target
         run: |
           rustup target install ${{ matrix.target }}
+      - name: Run Cargo checks
+        run: |
+          cargo fmt --check
+          cargo check
+          cargo clippy
       - name: Run a full build
         run: |
           cargo build --locked --release --target ${{ matrix.target }}
+      - name: Create MSI installer
+        run: |
+          cargo install cargo-wix
+          cargo wix -p komorebi --nocapture -I .\wix\main.wxs --target x86_64-pc-windows-msvc
       - name: Upload the built artifacts
-        uses: actions/upload-artifact@v2
+        uses: actions/upload-artifact@v4
         with:
           name: komorebi-${{ matrix.target }}
           path: |
             target/${{ matrix.target }}/release/komorebi.exe
             target/${{ matrix.target }}/release/komorebic.exe
+            target/${{ matrix.target }}/release/komorebic-no-console.exe
+            target/${{ matrix.target }}/release/komorebi-gui.exe
+            target/${{ matrix.target }}/release/komorebi.pdb
+            target/${{ matrix.target }}/release/komorebic.pdb
+            target/${{ matrix.target }}/release/komorebi-gui.pdb
+            target/wix/komorebi-*.msi
           retention-days: 7
+      - name: Check GoReleaser
+        uses: goreleaser/goreleaser-action@v3
+        with:
+          version: latest
+          args: build --skip=validate --clean
+
+      # Release
       - name: Generate changelog
-        if: startsWith(github.ref, 'refs/tags/')
+        if: startsWith(github.ref, 'refs/tags/v')
         shell: bash
         run: |
           if ! type kokai >/dev/null; then cargo install --locked kokai --force; fi
           kokai release --no-emoji --add-links github:commits,issues --ref "$(git tag --points-at HEAD)" >"CHANGELOG.md"
       - name: Run GoReleaser
-        uses: goreleaser/goreleaser-action@v2
-        if: startsWith(github.ref, 'refs/tags/')
+        uses: goreleaser/goreleaser-action@v3
+        if: startsWith(github.ref, 'refs/tags/v')
         with:
           version: latest
-          args: release --skip-validate --rm-dist --release-notes=CHANGELOG.md
+          args: release --skip=validate --clean --release-notes=CHANGELOG.md
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
           SCOOP_TOKEN: ${{ secrets.SCOOP_TOKEN }}
+      - name: Add MSI to release
+        uses: softprops/action-gh-release@v2
+        if: startsWith(github.ref, 'refs/tags/v')
+        with:
+          files: "target/wix/komorebi-*.msi"
+
+  winget:
+    name: Publish to WinGet
+    runs-on: ubuntu-latest
+    needs: build
+    if: startsWith(github.ref, 'refs/tags/v')
+
+    steps:
+      - uses: vedantmgoyal2009/winget-releaser@v2
+        with:
+          identifier: LGUG2Z.komorebi
+          token: ${{ secrets.WINGET_TOKEN }}

.gitignore

@@ -3,4 +3,5 @@
 /target
 CHANGELOG.md
 dummy.go
-komorebi.ahk
+komorebi.ahk
+komorebic/applications.yaml

.goreleaser.yml

@@ -10,32 +10,46 @@ before:
 builds:
   - id: komorebi
     main: dummy.go
-    goos: ["windows"]
-    goarch: ["amd64"]
+    goos: [ "windows" ]
+    goarch: [ "amd64" ]
     binary: komorebi
     hooks:
       post:
         - mkdir -p dist/windows_amd64
-        - cp ".\target\x86_64-pc-windows-msvc\release\komorebi.exe" ".\dist\komorebi_windows_amd64\komorebi.exe"
+        - cp ".\target\x86_64-pc-windows-msvc\release\komorebi.exe" ".\dist\komorebi_windows_amd64_v1\komorebi.exe"
   - id: komorebic
     main: dummy.go
-    goos: ["windows"]
-    goarch: ["amd64"]
+    goos: [ "windows" ]
+    goarch: [ "amd64" ]
     binary: komorebic
     hooks:
       post:
         - mkdir -p dist/windows_amd64
-        - cp ".\target\x86_64-pc-windows-msvc\release\komorebic.exe" ".\dist\komorebic_windows_amd64\komorebic.exe"
+        - cp ".\target\x86_64-pc-windows-msvc\release\komorebic.exe" ".\dist\komorebic_windows_amd64_v1\komorebic.exe"
+  - id: komorebic-no-console
+    main: dummy.go
+    goos: [ "windows" ]
+    goarch: [ "amd64" ]
+    binary: komorebic-no-console
+    hooks:
+      post:
+        - mkdir -p dist/windows_amd64
+        - cp ".\target\x86_64-pc-windows-msvc\release\komorebic-no-console.exe" ".\dist\komorebic-no-console_windows_amd64_v1\komorebic-no-console.exe"
+  - id: komorebi-gui
+    main: dummy.go
+    goos: [ "windows" ]
+    goarch: [ "amd64" ]
+    binary: komorebi-gui
+    hooks:
+      post:
+        - mkdir -p dist/windows_amd64
+        - cp ".\target\x86_64-pc-windows-msvc\release\komorebi-gui.exe" ".\dist\komorebi-gui_windows_amd64_v1\komorebi-gui.exe"
 
 archives:
-  - replacements:
-      windows: pc-windows-msvc
-      amd64: x86_64
+  - name_template: "{{ .ProjectName }}-{{ .Version }}-x86_64-pc-windows-msvc"
     format: zip
-    name_template: "{{ .ProjectName }}-{{ .Version }}-{{ .Arch }}-{{ .Os }}"
     files:
-      - LICENSE
-      - komorebi.sample.ahk
+      - LICENSE.md
       - CHANGELOG.md
 
 checksum:
@@ -43,17 +57,3 @@ checksum:
 
 changelog:
   sort: asc
-
-scoop:
-  bucket:
-    owner: LGUG2Z
-    name: komorebi-bucket
-    token: "{{ .Env.SCOOP_TOKEN }}"
-  homepage: https://github.com/LGUG2Z/komorebi
-  description: A tiling window manager for Windows
-  license: MIT
-  pre_install:
-    - if (Get-Process -Name komorebi -ErrorAction SilentlyContinue) { komorebic stop }
-  post_install:
-    - Write-Host "Run 'cp $original_dir\komorebi.sample.ahk $Env:UserProfile\komorebi.ahk' to get started with the sample configuration"
-    - Write-Host "Once you have a configuration file in place, you can run 'komorebic start' to start the window manager"

CONTRIBUTING.md

@@ -0,0 +1,45 @@
+# Contributing to the Project
+
+The project is a collection of contributions from both the project leaders and
+community members. There are many ways to contribute, this can include content
+in the project repositories, as well as contributing in public and private
+conversation, assisting users, writing blog posts, and many other ways.
+
+## How contributions are made
+
+Contributions to the project primarily happen in the project source
+repositories, but may also occur in other places, such as discussion forums and
+public and private discourse.
+
+## Contributing content to the Project
+
+In order for the project leaders to manage sustained progress toward the
+project goals and maintain project velocity, focus and quality, the project may
+adjust the license terms over time.
+
+Content contributed to the project must therefore be provided under
+sufficiently liberal terms to allow these operations to proceed unimpeded. As
+such contributions are accepted with the following understanding:
+
+* Contributed content is licensed under the terms of the 0-BSD license
+* Contributors accept the terms of the project license at the time of
+  contribution
+
+By making a contribution, you accept both the current project license terms,
+and that all contributions that you have made are provided under the terms of
+the 0-BSD license.
+
+## Zero-Clause BSD
+
+```
+Permission to use, copy, modify, and/or distribute this software for  
+any purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED “AS IS” AND THE AUTHOR DISCLAIMS ALL  
+WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES  
+OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE  
+FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY  
+DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN  
+AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT  
+OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+```

Cargo.toml

@@ -1,8 +1,44 @@
 [workspace]
 
+resolver = "2"
 members = [
-    "bindings",
+    "derive-ahk",
     "komorebi",
+    "komorebi-client",
     "komorebi-core",
-    "komorebic"
+    "komorebi-gui",
+    "komorebic",
+    "komorebic-no-console",
+]
+
+[workspace.dependencies]
+windows-interface = { version = "0.53" }
+windows-implement = { version = "0.53" }
+dunce = "1"
+dirs = "5"
+color-eyre = "0.6"
+serde_json = { package = "serde_json_lenient", version = "0.1" }
+sysinfo = "0.30"
+serde = { version = "1", features = ["derive"] }
+uds_windows = "1"
+
+[workspace.dependencies.windows]
+version = "0.54"
+features = [
+    "implement",
+    "Win32_System_Com",
+    "Win32_UI_Shell_Common", # for IObjectArray
+    "Win32_Foundation",
+    "Win32_Graphics_Dwm",
+    "Win32_Graphics_Gdi",
+    "Win32_System_LibraryLoader",
+    "Win32_System_RemoteDesktop",
+    "Win32_System_Threading",
+    "Win32_UI_Accessibility",
+    "Win32_UI_HiDpi",
+    "Win32_UI_Input_KeyboardAndMouse",
+    "Win32_UI_Shell",
+    "Win32_UI_Shell_Common",
+    "Win32_UI_WindowsAndMessaging",
+    "Win32_System_SystemServices"
 ]

LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2021 Jade Iqbal
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

LICENSE.md

@@ -0,0 +1,105 @@
+# PolyForm Strict License 1.0.0
+
+<https://polyformproject.org/licenses/strict/1.0.0>
+
+## Acceptance
+
+In order to get any license under these terms, you must agree
+to them as both strict obligations and conditions to all
+your licenses.
+
+## Copyright License
+
+The licensor grants you a copyright license for the software
+to do everything you might do with the software that would
+otherwise infringe the licensor's copyright in it for any
+permitted purpose, other than distributing the software or
+making changes or new works based on the software.
+
+## Patent License
+
+The licensor grants you a patent license for the software that
+covers patent claims the licensor can license, or becomes able
+to license, that you would infringe by using the software.
+
+## Noncommercial Purposes
+
+Any noncommercial purpose is a permitted purpose.
+
+## Personal Uses
+
+Personal use for research, experiment, and testing for
+the benefit of public knowledge, personal study, private
+entertainment, hobby projects, amateur pursuits, or religious
+observance, without any anticipated commercial application,
+is use for a permitted purpose.
+
+## Noncommercial Organizations
+
+Use by any charitable organization, educational institution,
+public research organization, public safety or health
+organization, environmental protection organization,
+or government institution is use for a permitted purpose
+regardless of the source of funding or obligations resulting
+from the funding.
+
+## Fair Use
+
+You may have "fair use" rights for the software under the
+law. These terms do not limit them.
+
+## No Other Rights
+
+These terms do not allow you to sublicense or transfer any of
+your licenses to anyone else, or prevent the licensor from
+granting licenses to anyone else.  These terms do not imply
+any other licenses.
+
+## Patent Defense
+
+If you make any written claim that the software infringes or
+contributes to infringement of any patent, your patent license
+for the software granted under these terms ends immediately. If
+your company makes such a claim, your patent license ends
+immediately for work on behalf of your company.
+
+## Violations
+
+The first time you are notified in writing that you have
+violated any of these terms, or done anything with the software
+not covered by your licenses, your licenses can nonetheless
+continue if you come into full compliance with these terms,
+and take practical steps to correct past violations, within
+32 days of receiving notice.  Otherwise, all your licenses
+end immediately.
+
+## No Liability
+
+***As far as the law allows, the software comes as is, without
+any warranty or condition, and the licensor will not be liable
+to you for any damages arising out of these terms or the use
+or nature of the software, under any kind of legal claim.***
+
+## Definitions
+
+The **licensor** is the individual or entity offering these
+terms, and the **software** is the software the licensor makes
+available under these terms.
+
+**You** refers to the individual or entity agreeing to these
+terms.
+
+**Your company** is any legal entity, sole proprietorship,
+or other kind of organization that you work for, plus all
+organizations that have control over, are under the control of,
+or are under common control with that organization.  **Control**
+means ownership of substantially all the assets of an entity,
+or the power to direct its management and policies by vote,
+contract, or otherwise.  Control can be direct or indirect.
+
+**Your licenses** are all the licenses granted to you for the
+software under these terms.
+
+**Use** means anything you do with the software requiring one
+of your licenses.
+

README.md

@@ -2,268 +2,202 @@
 
 Tiling Window Management for Windows.
 
-![screenshot](https://i.ibb.co/BTqNS45/komorebi.png)
+<p>
+  <a href="https://techforpalestine.org/learn-more">
+    <img alt="Tech for Palestine" src="https://badge.techforpalestine.org/default">
+  </a>
+  <img alt="GitHub Workflow Status" src="https://img.shields.io/github/actions/workflow/status/LGUG2Z/komorebi/.github/workflows/windows.yaml">
+  <img alt="GitHub" src="https://img.shields.io/github/license/LGUG2Z/komorebi">
+  <img alt="GitHub all releases" src="https://img.shields.io/github/downloads/LGUG2Z/komorebi/total">
+  <img alt="GitHub commits since latest release (by date) for a branch" src="https://img.shields.io/github/commits-since/LGUG2Z/komorebi/latest">
+  <a href="https://discord.gg/mGkn66PHkx">
+    <img alt="Discord" src="https://img.shields.io/discord/898554690126630914">
+  </a>
+  <a href="https://github.com/sponsors/LGUG2Z">
+    <img alt="GitHub Sponsors" src="https://img.shields.io/github/sponsors/LGUG2Z">
+  </a>
+  <a href="https://ko-fi.com/lgug2z">
+    <img alt="Ko-fi" src="https://img.shields.io/badge/kofi-tip-green">
+  </a>
+  <a href="https://notado.app/feeds/jado/software-development">
+    <img alt="Notado Feed" src="https://img.shields.io/badge/Notado-Subscribe-informational">
+  </a>
+  <a href="https://www.youtube.com/channel/UCeai3-do-9O4MNy9_xjO6mg?sub_confirmation=1">
+    <img alt="YouTube" src="https://img.shields.io/youtube/channel/subscribers/UCeai3-do-9O4MNy9_xjO6mg">
+  </a>
+</p>
 
-## About
+![screenshot](https://user-images.githubusercontent.com/13164844/184027064-f5a6cec2-2865-4d65-a549-a1f1da589abf.png)
 
-_komorebi_ is a tiling window manager that works as an extension to
-Microsoft's [Desktop Window Manager](https://docs.microsoft.com/en-us/windows/win32/dwm/dwm-overview) in Windows 10 and
-above.
+_komorebi_ is a tiling window manager that works as an extension to Microsoft's
+[Desktop Window
+Manager](https://docs.microsoft.com/en-us/windows/win32/dwm/dwm-overview) in
+Windows 10 and above.
 
 _komorebi_ allows you to control application windows, virtual workspaces and display monitors with a CLI which can be
-used with third-party software such as [AutoHotKey](https://github.com/Lexikos/AutoHotkey_L) to set user-defined
-keyboard shortcuts.
+used with third-party software such as [`whkd`](https://github.com/LGUG2Z/whkd)
+and [AutoHotKey](https://github.com/Lexikos/AutoHotkey_L) to set user-defined keyboard shortcuts.
 
-## Description
+_komorebi_ aims to make _as few modifications as possible_ to the operating
+system and desktop environment by default. Users are free to make such
+modifications in their own configuration files for _komorebi_, but these will
+remain opt-in and off-by-default for the foreseeable future.
 
-_komorebi_ only responds to [WinEvents](https://docs.microsoft.com/en-us/windows/win32/winauto/event-constants) and the
-messages it receives on a dedicated socket.
+Please refer to the [documentation](https://lgug2z.github.io/komorebi) for instructions on how
+to [install](https://lgug2z.github.io/komorebi/installation.html) and
+[configure](https://lgug2z.github.io/komorebi/example-configurations.html)
+_komorebi_, [common workflows](https://lgug2z.github.io/komorebi/common-workflows/komorebi-config-home.html), a complete
+[configuration schema reference](https://komorebi.lgug2z.com/schema) and a
+complete [CLI reference](https://lgug2z.github.io/komorebi/cli/quickstart.html).
 
-_komorebic_ is a CLI that writes messages on _komorebi_'s socket.
+There is a [Discord server](https://discord.gg/mGkn66PHkx) available for
+_komorebi_-related discussion, help, troubleshooting etc. If you have any
+specific feature requests or bugs to report, please create an issue in this
+repository.
 
-_komorebi_ doesn't handle any keyboard or mouse inputs; a third party program (e.g. AutoHotKey) is needed in order to
-translate keyboard and mouse events to _komorebic_ commands.
+There is a [YouTube
+channel](https://www.youtube.com/channel/UCeai3-do-9O4MNy9_xjO6mg) where I post
+_komorebi_ development videos. If you would like to be notified of upcoming
+videos please subscribe and turn on notifications.
 
-This architecture, popularised by [_bspwm_](https://github.com/baskerville/bspwm) on Linux and
-[_yabai_](https://github.com/koekeishiya/yabai) on macOS, is outlined as follows:
+_komorebi_ is a free and open-source project, and one that encourages you to
+make charitable donations if you find the software to be useful and have the
+financial means.
 
-```
-     PROCESS                SOCKET
-ahk  -------->  komorebic  <------>  komorebi
-```
+I encourage you to make a charitable donation to the [Palestine Children's
+Relief Fund](https://pcrf1.app.neoncrm.com/forms/gaza-recovery) before you
+consider sponsoring me on GitHub.
 
-## Design
+[GitHub Sponsors is enabled for this
+project](https://github.com/sponsors/LGUG2Z). Unfortunately I don't have
+anything specific to offer besides my gratitude and shout outs at the end of
+_komorebi_ live development videos and tutorials.
 
-_komorebi_ is the successor to [_yatta_](https://github.com/LGUG2Z/yatta) and as such aims to build on the learnings
-from that project.
+If you would like to tip or sponsor the project but are unable to use GitHub
+Sponsors, you may also sponsor through [Ko-fi](https://ko-fi.com/lgug2z).
 
-While _yatta_ was primary an attempt to learn how to work with and call Windows APIs from Rust, while secondarily
-implementing a minimal viable tiling window manager for my own needs (largely single monitor, single workspace),
-_komorebi_ has been redesigned from the ground-up to support more complex features that have become standard in tiling
-window managers on other platforms.
+# Installation
 
-_komorebi_ holds a list of physical monitors.
+A [detailed installation and quickstart
+guide](https://lgug2z.github.io/komorebi/installation.html) is available which shows how to get started
+using `scoop`, `winget` or building from source.
 
-A monitor is just a rectangle of the available work area which contains one or more virtual workspaces.
+[![Watch the quickstart walkthrough video](https://img.youtube.com/vi/H9-_c1egQ4g/hqdefault.jpg)](https://www.youtube.com/watch?v=H9-_c1egQ4g)
 
-A workspace holds a list of containers.
+# Comparison With Fancy Zones
 
-A container is just a rectangle where one or more application windows can be displayed.
+Community member [Olge](https://www.youtube.com/@polle5555) has created an
+excellent video which compares the default window management features of
+Windows 11, Fancy Zones and komorebi.
 
-This means that:
+If you are not familiar with tiling window managers or if you are looking at
+komorebi and wondering "how is this different from Fancy Zones? 🤔", this short
+video will answer the majority of your questions.
 
-- Every monitor has its own collection of virtual workspaces
-- Workspaces only know about containers and their dimensions, not about individual application windows
-- Every application window must belong to a container, even if that container only contains one application window
-- Many application windows can be stacked and cycled through in the same container within a workspace
+[![Watch the comparison video](https://img.youtube.com/vi/0LCbS_gm0RA/hqdefault.jpg)](https://www.youtube.com/watch?v=0LCbS_gm0RA)
 
-## Getting Started
 
-### GitHub Releases
+# Demonstrations
 
-Prebuilt binaries are available on the [releases page](https://github.com/LGUG2Z/komorebi/releases) in a `zip` archive.
-Once downloaded, you will need to move the `komorebi.exe` and `komorebic.exe` binaries to a directory in your `Path` (
-you can see these directories by running `$Env:Path.split(";")` at a PowerShell prompt).
+[@haxibami](https://github.com/haxibami) showing _komorebi_ running on Windows
+11 with a terminal emulator, a web browser and a code editor. The original
+video can be viewed
+[here](https://twitter.com/haxibami/status/1501560766578659332).
 
-Alternatively, you may add a new directory to your `Path`
-using [`setx`](https://docs.microsoft.com/en-us/windows-server/administration/windows-commands/setx) or the Environment
-Variables pop up in System Properties Advanced (which can be launched with `SystemPropertiesAdvanced.exe` at a
-PowerShell prompt), and then move the binaries to that directory.
+https://user-images.githubusercontent.com/13164844/163496447-20c3ff0a-c5d8-40d1-9cc8-156c4cebf12e.mp4
 
-### Scoop
+[@aik2mlj](https://github.com/aik2mlj) showing _komorebi_ running on Windows 11
+with multiple workspaces, terminal emulators, a web browser, and the
+[yasb](https://github.com/DenBot/yasb) status bar with the _komorebi_ workspace
+widget enabled. The original video can be viewed
+[here](https://zhuanlan.zhihu.com/p/455064481).
 
-If you use the [Scoop](https://scoop.sh/) command line installer, you can run the following commands to install the
-binaries from the latest GitHub Release:
+https://user-images.githubusercontent.com/13164844/163496414-a9cde3d1-b8a7-4a7a-96fb-a8985380bc70.mp4
 
-```
-scoop bucket add komorebi https://github.com/LGUG2Z/komorebi-bucket
-scoop install komorebi
-```
+# Contribution Guidelines
 
-If you install _komorebi_ using Scoop, the binaries will automatically be added to your `Path` and a command will be
-shown for you to run in order to get started using the sample configuration file.
+If you would like to contribute to `komorebi` please take the time to carefully read the guidelines below.
 
-### Building from Source
-
-If you prefer to compile _komorebi_ from source, you will need
-a [working Rust development environment on Windows 10](https://rustup.rs/). The `x86_64-pc-windows-msvc` toolchain is
-required, so make sure you have also installed
-the [Build Tools for Visual Studio 2019](https://stackoverflow.com/a/55603112).
-
-You can then clone this repo and compile the source code to install the binaries for `komorebi` and `komorebic`:
-
-```powershell
-cargo install --path komorebi --locked
-cargo install --path komorebic --locked
-```
-
-### Running
-
-Once you have either the prebuilt binaries in your `Path`, or have compiled the binaries from source (these will already
-be in your `Path` if you installed Rust with [rustup](https://rustup.rs), which you absolutely should), you can
-run `komorebic start` at a Powershell prompt, and you will see the following output:
-
-```
-Start-Process komorebi -WindowStyle hidden
-```
-
-This means that `komorebi` is now running in the background, tiling all your windows, and listening for commands sent to
-it by `komorebic`. You can similarly stop the process by running `komorebic stop`.
-
-### Configuring
-
-Once `komorebi` is running, you can execute the `komorebi.sample.ahk` script to set up the default keybindings via AHK
-(the file includes comments to help you start building your own configuration).
-
-If you have AutoHotKey installed and a `komorebi.ahk` file in your home directory (run `$Env:UserProfile` at a
-PowerShell prompt to find your home directory), `komorebi` will automatically try to load it when starting.
-
-There is also tentative support for loading a AutoHotKey v2 files, if the file is named `komorebi.ahk2` and
-the `AutoHotKey64.exe` executable for AutoHotKey v2 is in your `Path`. If both `komorebi.ahk` and `komorebi.ahk2` files
-exist in your home directory, only `komorebi.ahk` will be loaded. An example of an AutoHotKey v2 configuration file
-for _komorebi_ can be found [here](https://gist.github.com/crosstyan/dafacc0778dabf693ce9236c57b201cd).
-
-### Common First-Time Tips
-
-#### Floating Windows
-
-Sometimes you will want a specific application to never be tiled, and instead float all the time. You add add rules to
-enforce this behaviour:
-
-```powershell
-komorebic.exe float-rule title "Control Panel"
-# komorebic.exe float-rule exe [EXE NAME]
-# komorebic.exe float-rule class [CLASS NAME]
-```
-
-#### Windows Not Getting Managed
-
-In some rare cases, a window may not automatically be registered to be managed by `komorebi`. When this happens, you can
-manually add a rule to force `komorebi` to manage it:
-
-```powershell
-komorebic.exe manage-rule exe TIM.exe
-# komorebic.exe manage-rule class [CLASS NAME]
-# komorebic.exe manage-rule title [TITLE]
-```
-
-#### Tray Applications
-
-If you are experiencing behaviour where
-[closing a window leaves a blank tile, but minimizing the same window does not](https://github.com/LGUG2Z/komorebi/issues/6)
-, you have probably enabled a 'close/minimize to tray' option for that application. You can tell _komorebi_ to handle
-this application appropriately by identifying it via the executable name or the window class:
-
-```powershell
-komorebic.exe identify-tray-application exe Discord.exe
-# komorebic.exe identify-tray-application class [CLASS NAME]
-# komorebic.exe identify-tray-application title [TITLE]
-```
-
-## Configuration with `komorebic`
-
-As previously mentioned, this project does not handle anything related to keybindings and shortcuts directly. I
-personally use AutoHotKey to manage my window management shortcuts, and have provided a
-sample [komorebi.ahk](komorebi.sample.ahk) AHK script that you can use as a starting point for your own.
-
-You can run `komorebic.exe` to get a full list of the commands that you can use to customise `komorebi` and create
-keybindings with. You can run `komorebic.exe <COMMAND> --help` to get a full explanation of the arguments required for
-each command.
-
-```
-start                        Start komorebi.exe as a background process
-stop                         Stop the komorebi.exe process and restore all hidden windows
-state                        Show a JSON representation of the current window manager state
-log                          Tail komorebi.exe's process logs (cancel with Ctrl-C)
-focus                        Change focus to the window in the specified direction
-move                         Move the focused window in the specified direction
-stack                        Stack the focused window in the specified direction
-resize                       Resize the focused window in the specified direction
-unstack                      Unstack the focused window
-cycle-stack                  Cycle the focused stack in the specified cycle direction
-move-to-monitor              Move the focused window to the specified monitor
-move-to-workspace            Move the focused window to the specified workspace
-focus-monitor                Focus the specified monitor
-focus-workspace              Focus the specified workspace on the focused monitor
-new-workspace                Create and append a new workspace on the focused monitor
-adjust-container-padding     Adjust container padding on the focused workspace
-adjust-workspace-padding     Adjust workspace padding on the focused workspace
-change-layout                Set the layout on the focused workspace
-flip-layout                  Flip the layout on the focused workspace (BSP only)
-promote                      Promote the focused window to the top of the tree
-retile                       Force the retiling of all managed windows
-ensure-workspaces            Create at least this many workspaces for the specified monitor
-container-padding            Set the container padding for the specified workspace
-workspace-padding            Set the workspace padding for the specified workspace
-workspace-layout             Set the layout for the specified workspace
-workspace-tiling             Enable or disable window tiling for the specified workspace
-workspace-name               Set the workspace name for the specified workspace
-toggle-pause                 Toggle the window manager on and off across all monitors
-toggle-tiling                Toggle window tiling on the focused workspace
-toggle-float                 Toggle floating mode for the focused window
-toggle-monocle               Toggle monocle mode for the focused container
-toggle-maximize              Toggle native maximization for the focused window
-restore-windows              Restore all hidden windows (debugging command)
-manage                       Force komorebi to manage the focused window
-unmanage                     Unmanage a window that was forcibly managed
-reload-configuration         Reload ~/komorebi.ahk (if it exists)
-watch-configuration          Toggle the automatic reloading of ~/komorebi.ahk (if it exists)
-float-rule                   Add a rule to always float the specified application
-manage-rule                  Add a rule to always manage the specified application
-workspace-rule               Add a rule to associate an application with a workspace
-identify-tray-application    Identify an application that closes to the system tray
-focus-follows-mouse          Enable or disable focus follows mouse for the operating system
-help                         Print this message or the help of the given subcommand(s)
-```
-
-## Features
-
-- [x] Multi-monitor
-- [x] Virtual workspaces
-- [x] Window stacks
-- [x] Cycle through stacked windows
-- [x] Change focused window by direction
-- [x] Move focused window container in direction
-- [x] Move focused window container to monitor
-- [x] Move focused window container to workspace
-- [x] Mouse follows focused container
-- [x] Resize window container in direction
-- [ ] Resize child window containers by split ratio
-- [x] Mouse drag to swap window container position
-- [x] Mouse drag to resize window container
-- [x] Configurable workspace and container gaps
-- [x] BSP tree layout
-- [x] Flip BSP tree layout horizontally or vertically
-- [x] Equal-width, max-height column layout
-- [x] Floating rules based on exe name, window title and class
-- [x] Workspace rules based on exe name and window class
-- [x] Additional manage rules based on exe name and window class
-- [x] Identify 'close/minimize to tray' applications by exe name and class
-- [x] Toggle floating windows
-- [x] Toggle monocle window
-- [x] Toggle native maximization
-- [x] Toggle focus follows mouse
-- [x] Toggle automatic tiling
-- [x] Pause all window management
-- [x] Load configuration on startup
-- [x] Manually reload configuration
-- [x] Watch configuration for changes
-- [x] View window manager state
-
-## Development
-
-If you would like to contribute code to this repository, there are a few requests that I have to ensure a foundation of
-code quality, consistency and commit hygiene:
+## Commit hygiene
 
 - Flatten all `use` statements
-- Run `cargo +nightly clippy` and ensure that all lints and suggestions have been addressed before committing
+- Run `cargo +stable clippy` and ensure that all lints and suggestions have been addressed before committing
 - Run `cargo +nightly fmt --all` to ensure consistent formatting before committing
 - Use `git cz` with
   the [Commitizen CLI](https://github.com/commitizen/cz-cli#conventional-commit-messages-as-a-global-utility) to prepare
   commit messages
-- Provide at least one short sentence or paragraph in your commit message body to describe your thought process for the
+- Provide **at least** one short sentence or paragraph in your commit message body to describe your thought process for the
   changes being committed
 
+## PRs should contain only a single feature or bug fix
+
+It is very difficult to review pull requests which touch multiple unrelated features and parts of the codebase.
+
+Please do not submit pull requests like this; you will be asked to separate them into smaller PRs that deal only with
+one feature or bug fix at a time.
+
+If you are working on multiple features and bug fixes, I suggest that you cut a branch called `local-trunk`
+from `master` which you keep up to date, and rebase the various independent branches you are working on onto that branch
+if you want to test them together or create a build with everything integrated.
+
+## Refactors to the codebase must have prior approval
+
+`komorebi` is a mature codebase with an internal consistency and structure that has developed organically over close to
+half a decade.
+
+There are [countless hours of live coding videos](https://youtube.com/@LGUG2Z) demonstrating work on this project and
+showing new contributors how to do everything from basic tasks like implementing new `komorebic` commands to
+distinguishing monitors by manufacturer hardware identifiers and video card ports.
+
+Refactors to the structure of the codebase are not taken lightly and require prior discussion and approval.
+
+Please do not start refactoring the codebase with the expectation of having your changes integrated until you receive an
+explicit approval or a request to do so.
+
+Similarly, when implementing features and bug fixes, please stick to the structure of the codebase as much as possible
+and do not take this as an opportunity to do some "refactoring along the way".
+
+It is extremely difficult to review PRs for features and bug fixes if they are lost in sweeping changes to the structure
+of the codebase.
+
+## Breaking changes to user-facing interfaces are unacceptable
+
+This includes but is not limited to:
+
+- All `komorebic` commands
+- The `komorebi.json` schema
+- The [`komorebi-application-specific-configuration`](https://github.com/LGUG2Z/komorebi-application-specific-configuration)
+  schema
+
+No user should ever find that their configuration file has stopped working after upgrading to a new version
+of `komorebi`.
+
+More often than not there are ways to reformulate changes that may initially seem like they require breaking user-facing
+interfaces into additive changes.
+
+For some inspiration please take a look
+at [this commit](https://github.com/LGUG2Z/komorebi/commit/e7d928a065eb63bb4ea1fb864c69c1cae8cc763b) which added the
+ability for users to specify colours in `komorebi.json` in Hex format alongside RGB.
+
+There is also a process in place for graceful, non-breaking, deprecation of configuration options that are no longer
+required.
+
+## License
+
+`komorebi` is licensed under the [PolyForm Strict 1.0.0
+license](https://polyformproject.org/licenses/strict/1.0.0). On a high level
+this means that you are free to do whatever you want with `komorebi` other than
+redistribution, or distribution of new works (ie. hard-forks) based on the
+software.
+
+Anyone is free to make their own fork of `komorebi` with changes intended
+either for personal use or for integration back upstream via pull requests.
+
+Please see [CONTRIBUTING.md](./CONTRIBUTING.md) for more information about how
+code contributions to `komorebi` are licensed.
+
+# Development
+
 If you use IntelliJ, you should enable the following settings to ensure that code generated by macros is recognised by
 the IDE for completions and navigation:
 
@@ -273,23 +207,23 @@ the IDE for completions and navigation:
   - `org.rust.cargo.evaluate.build.scripts`
   - `org.rust.macros.proc`
 
-## Logs and Debugging
+# Logs and Debugging
 
-Logs from `komorebi` will be appended to `~/komorebi.log`; this file is never rotated or overwritten, so it will keep
+Logs from `komorebi` will be appended to `%LOCALAPPDATA%/komorebi/komorebi.log`; this file is never rotated or overwritten, so it will keep
 growing until it is deleted by the user.
 
 Whenever running the `komorebic stop` command or sending a Ctrl-C signal to `komorebi` directly, the `komorebi` process
 ensures that all hidden windows are restored before termination.
 
 If however, you ever end up with windows that are hidden and cannot be restored, a list of window handles known
-to `komorebi` are stored and continuously updated in `~/komorebi.hwnd.json`.
+to `komorebi` are stored and continuously updated in `%LOCALAPPDATA%/komorebi//komorebi.hwnd.json`.
 
-### Restoring Windows
+## Restoring Windows
 
 Running `komorebic restore-windows` will read the list of window handles and forcibly restore them, regardless of
 whether the main `komorebi` process is running.
 
-### Panics and Deadlocks
+## Panics and Deadlocks
 
 If `komorebi` ever stops responding, it is most likely either due to either a panic or a deadlock. In the case of a
 panic, this will be reported in the log. In the case of a deadlock, there will not be any errors in the log, but the
@@ -297,13 +231,207 @@ process and the log will appear frozen.
 
 If you believe you have encountered a deadlock, you can compile `komorebi` with `--features deadlock_detection` and try
 reproducing the deadlock again. This will check for deadlocks every 5 seconds in the background, and if a deadlock is
-found, information about it will appear in the log which can be shared when opening an issu which can be shared when
-opening an issue.
+found, information about it will appear in the log which can be shared when opening an issue.
 
-## Window Manager State and Integrations
+# Window Manager State and Integrations
 
 The current state of the window manager can be queried using the `komorebic state` command, which returns a JSON
-representation of the `State` struct, which includes the current state of `WindowManager`.
+representation of the `State` struct.
 
-This may also be polled to build further integrations and widgets on top of (if you ever wanted to build something
-like [Stackline](https://github.com/AdamWagner/stackline) for Windows, you could do it by polling this command).
+This may also be polled to build further integrations and widgets on top of.
+
+# Window Manager Event Subscriptions
+
+## Named Pipes
+
+It is possible to subscribe to notifications of every `WindowManagerEvent` and `SocketMessage` handled
+by `komorebi` using [Named Pipes](https://docs.microsoft.com/en-us/windows/win32/ipc/named-pipes).
+
+First, your application must create a named pipe. Once the named pipe has been created, run the following command:
+
+```powershell
+komorebic.exe subscribe-pipe <your pipe name>
+```
+
+Note that you do not have to include the full path of the named pipe, just the name.
+
+If the named pipe exists, `komorebi` will start pushing JSON data of successfully handled events and messages:
+
+```json lines
+{"event":{"type":"AddSubscriber","content":"yasb"},"state":{}}
+{"event":{"type":"FocusWindow","content":"Left"},"state":{}}
+{"event":{"type":"FocusChange","content":["SystemForeground",{"hwnd":131444,"title":"komorebi – README.md","exe":"idea64.exe","class":"SunAwtFrame","rect":{"left":13,"top":60,"right":1520,"bottom":1655}}]},"state":{}}
+{"event":{"type":"MonitorPoll","content":["ObjectCreate",{"hwnd":5572450,"title":"OLEChannelWnd","exe":"explorer.exe","class":"OleMainThreadWndClass","rect":{"left":0,"top":0,"right":0,"bottom":0}}]},"state":{}}
+{"event":{"type":"FocusWindow","content":"Right"},"state":{}}
+{"event":{"type":"FocusChange","content":["SystemForeground",{"hwnd":132968,"title":"Windows PowerShell","exe":"WindowsTerminal.exe","class":"CASCADIA_HOSTING_WINDOW_CLASS","rect":{"left":1539,"top":60,"right":1520,"bottom":821}}]},"state":{}}
+{"event":{"type":"FocusWindow","content":"Down"},"state":{}}
+{"event":{"type":"FocusChange","content":["SystemForeground",{"hwnd":329264,"title":"den — Mozilla Firefox","exe":"firefox.exe","class":"MozillaWindowClass","rect":{"left":1539,"top":894,"right":1520,"bottom":821}}]},"state":{}}
+{"event":{"type":"FocusWindow","content":"Up"},"state":{}}
+{"event":{"type":"FocusChange","content":["SystemForeground",{"hwnd":132968,"title":"Windows PowerShell","exe":"WindowsTerminal.exe","class":"CASCADIA_HOSTING_WINDOW_CLASS","rect":{"left":1539,"top":60,"right":1520,"bottom":821}}]},"state":{}}
+```
+
+You may then filter on the `type` key to listen to the events that you are interested in. For a full list of possible
+notification types, refer to the enum variants of `WindowManagerEvent` in `komorebi` and `SocketMessage`
+in `komorebi-core`.
+
+Below is an example of how you can subscribe to and filter on events using a named pipe in `nodejs`.
+
+```javascript
+const { exec } = require("child_process");
+const net = require("net");
+
+const pipeName = "\\\\.\\pipe\\komorebi-js";
+const server = net.createServer((stream) => {
+  console.log("Client connected");
+
+  // Every time there is a workspace-related event, let's log the names of all
+  // workspaces on the currently focused monitor, and then log the name of the
+  // currently focused workspace on that monitor
+
+  stream.on("data", (data) => {
+    let json = JSON.parse(data.toString());
+    let event = json.event;
+
+    if (event.type.includes("Workspace")) {
+      let monitors = json.state.monitors;
+      let current_monitor = monitors.elements[monitors.focused];
+      let workspaces = monitors.elements[monitors.focused].workspaces;
+      let current_workspace = workspaces.elements[workspaces.focused];
+
+      console.log(
+        workspaces.elements
+          .map((workspace) => workspace.name)
+          .filter((name) => name !== null)
+      );
+      console.log(current_workspace.name);
+    }
+  });
+
+  stream.on("end", () => {
+    console.log("Client disconnected");
+  });
+});
+
+server.listen(pipeName, () => {
+  console.log("Named pipe server listening");
+});
+
+const command = "komorebic subscribe-pipe komorebi-js";
+
+exec(command, (error, stdout, stderr) => {
+  if (error) {
+    console.error(`Error executing command: ${error}`);
+    return;
+  }
+});
+```
+
+## Unix Domain Sockets
+
+It is possible to subscribe to notifications of every `WindowManagerEvent` and `SocketMessage` handled
+by `komorebi` using [Unix Domain Sockets](https://devblogs.microsoft.com/commandline/af_unix-comes-to-windows/).
+
+UDS are also the only mode of communication between `komorebi` and `komorebic`.
+
+First, your application must create a socket in `$ENV:LocalAppData\komorebi`. Once the socket has been created, run the
+following command:
+
+```powershell
+komorebic.exe subscribe-socket <your socket name>
+```
+
+If the socket exists, komorebi will start pushing JSON data of successfully handled events and messages as in the
+example above in the Named Pipes section.
+
+## Rust Client
+
+As of `v0.1.22` it is possible to use the `komorebi-client` crate to subscribe to notifications of
+every `WindowManagerEvent` and `SocketMessage` handled by `komorebi` in a Rust codebase.
+
+Below is a simple example of how to use `komorebi-client` in a basic Rust application.
+
+```rust
+// komorebi-client = { git = "https://github.com/LGUG2Z/komorebi", tag = "v0.1.25"}
+
+use anyhow::Result;
+use komorebi_client::Notification;
+use komorebi_client::NotificationEvent;
+use komorebi_client::UnixListener;
+use komorebi_client::WindowManagerEvent;
+use std::io::BufRead;
+use std::io::BufReader;
+use std::io::Read;
+
+pub fn main() -> anyhow::Result<()> {
+  let socket = komorebi_client::subscribe(NAME)?;
+
+  for incoming in socket.incoming() {
+    match incoming {
+      Ok(data) => {
+        let reader = BufReader::new(data.try_clone()?);
+
+        for line in reader.lines().flatten() {
+          let notification: Notification = match serde_json::from_str(&line) {
+            Ok(notification) => notification,
+            Err(error) => {
+              log::debug!("discarding malformed komorebi notification: {error}");
+              continue;
+            }
+          };
+
+          // match and filter on desired notifications
+        }
+      }
+      Err(error) => {
+        log::debug!("{error}");
+      }
+    }
+  }
+
+}
+```
+
+A read-world example can be found
+in [komokana](https://github.com/LGUG2Z/komokana/blob/feature/komorebi-uds/src/main.rs).
+
+## Subscription Event Notification Schema
+
+A [JSON Schema](https://json-schema.org/) of the event notifications emitted to subscribers can be generated with
+the `komorebic notification-schema` command. The output of this command can be redirected to the clipboard or a file,
+which can be used with services such as [Quicktype](https://app.quicktype.io/) to generate type definitions in different
+programming languages.
+
+## Communication over TCP
+
+A TCP listener can optionally be exposed on a port of your choosing with the `--tcp-port=N` flag. If this flag is not
+provided to `komorebi` or `komorebic start`, no TCP listener will be created.
+
+Once created, your client may send
+any [SocketMessage](https://github.com/LGUG2Z/komorebi/blob/master/komorebi-core/src/lib.rs#L37) to `komorebi` in the
+same way that `komorebic` would.
+
+This can be used if you would like to create your own alternative to `komorebic` which incorporates scripting and
+various middleware layers, and similarly it can be used if you would like to integrate `komorebi` with
+a [custom input handler](https://github.com/LGUG2Z/komorebi/issues/176#issue-1302643961).
+
+If a client sends an unrecognized message, it will be disconnected and have to reconnect before trying to communicate
+again.
+
+## Socket Message Schema
+
+A [JSON Schema](https://json-schema.org/) of socket messages used to send instructions to `komorebi` can be generated
+with the `komorebic socket-schema` command. The output of this command can be redirected to the clipboard or a file,
+which can be used with services such as [Quicktype](https://app.quicktype.io/) to generate type definitions in different
+programming languages.
+
+# Appreciations
+
+- First and foremost, thank you to my wife, both for naming this project and for her patience throughout its never-ending development
+
+- Thank you to [@sitiom](https://github.com/sitiom) for being [an exemplary open source community leader](https://jeezy.substack.com/p/the-open-source-contributions-i-appreciate)
+
+- Thank you to the developers of [nog](https://github.com/TimUntersberger/nog) who came before me and whose work taught me more than I can ever hope to repay
+
+- Thank you to the developers of [GlazeWM](https://github.com/lars-berger/GlazeWM) for pushing the boundaries of tiling window management on Windows with me and having an excellent spirit of collaboration
+
+- Thank you to [@Ciantic](https://github.com/Ciantic) for helping me bring the [hidden Virtual Desktops cloaking function](https://github.com/Ciantic/AltTabAccessor/issues/1) to `komorebi`

bindings/Cargo.toml

@@ -1,13 +0,0 @@
-[package]
-name = "bindings"
-version = "0.1.0"
-authors = ["Jade Iqbal"]
-edition = "2018"
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
-[dependencies]
-windows = "0.18"
-
-[build-dependencies]
-windows = "0.18"

bindings/build.rs

@@ -1,26 +0,0 @@
-fn main() {
-    windows::build!(
-        Windows::Win32::Foundation::RECT,
-        Windows::Win32::Foundation::POINT,
-        Windows::Win32::Foundation::BOOL,
-        Windows::Win32::Foundation::PWSTR,
-        Windows::Win32::Foundation::HWND,
-        Windows::Win32::Foundation::LPARAM,
-        // error: `Windows.Win32.Graphics.Dwm.DWMWA_CLOAKED` not found in metadata
-        Windows::Win32::Graphics::Dwm::*,
-        // error: `Windows.Win32.Graphics.Gdi.MONITOR_DEFAULTTONEAREST` not found in metadata
-        Windows::Win32::Graphics::Gdi::*,
-        Windows::Win32::System::Threading::PROCESS_ACCESS_RIGHTS,
-        Windows::Win32::System::Threading::PROCESS_NAME_FORMAT,
-        Windows::Win32::System::Threading::OpenProcess,
-        Windows::Win32::System::Threading::QueryFullProcessImageNameW,
-        Windows::Win32::System::Threading::GetCurrentThreadId,
-        Windows::Win32::System::Threading::AttachThreadInput,
-        Windows::Win32::System::Threading::GetCurrentProcessId,
-        Windows::Win32::UI::KeyboardAndMouseInput::SetFocus,
-        Windows::Win32::UI::Accessibility::SetWinEventHook,
-        Windows::Win32::UI::Accessibility::HWINEVENTHOOK,
-        // error: `Windows.Win32.UI.WindowsAndMessaging.GWL_EXSTYLE` not found in metadata
-        Windows::Win32::UI::WindowsAndMessaging::*,
-    );
-}

bindings/src/lib.rs

@@ -1 +0,0 @@
-::windows::include_bindings!();

derive-ahk/Cargo.toml

@@ -0,0 +1,14 @@
+[package]
+name = "derive-ahk"
+version = "0.1.1"
+edition = "2021"
+
+[lib]
+proc-macro = true
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+proc-macro2 = "1.0"
+syn = "1.0"
+quote = "1.0"

derive-ahk/src/lib.rs

@@ -0,0 +1,225 @@
+#![warn(clippy::all, clippy::nursery, clippy::pedantic)]
+#![allow(clippy::missing_errors_doc)]
+#![no_implicit_prelude]
+
+use ::std::clone::Clone;
+use ::std::convert::From;
+use ::std::convert::Into;
+use ::std::format;
+use ::std::iter::Extend;
+use ::std::iter::Iterator;
+use ::std::matches;
+use ::std::option::Option::Some;
+use ::std::string::String;
+use ::std::string::ToString;
+use ::std::unreachable;
+use ::std::vec::Vec;
+
+use ::quote::quote;
+use ::syn::parse_macro_input;
+use ::syn::Data;
+use ::syn::DataEnum;
+use ::syn::DeriveInput;
+use ::syn::Fields;
+use ::syn::FieldsNamed;
+use ::syn::FieldsUnnamed;
+use ::syn::Meta;
+use ::syn::NestedMeta;
+
+#[allow(clippy::too_many_lines)]
+#[proc_macro_derive(AhkFunction)]
+pub fn ahk_function(input: ::proc_macro::TokenStream) -> ::proc_macro::TokenStream {
+    let input = parse_macro_input!(input as DeriveInput);
+    let name = input.ident;
+
+    match input.data {
+        Data::Struct(s) => match s.fields {
+            Fields::Named(FieldsNamed { named, .. }) => {
+                let argument_idents = named
+                    .iter()
+                    // Filter out the flags
+                    .filter(|&f| {
+                        let mut include = true;
+                        for attribute in &f.attrs {
+                            if let ::std::result::Result::Ok(Meta::List(list)) =
+                                attribute.parse_meta()
+                            {
+                                for nested in list.nested {
+                                    if let NestedMeta::Meta(Meta::Path(path)) = nested {
+                                        if path.is_ident("long") {
+                                            include = false;
+                                        }
+                                    }
+                                }
+                            }
+                        }
+
+                        include
+                    })
+                    .map(|f| &f.ident);
+
+                let argument_idents_clone = argument_idents.clone();
+
+                let called_arguments = quote! {#(%#argument_idents_clone%) *}
+                    .to_string()
+                    .replace(" %", "%")
+                    .replace("% ", "%")
+                    .replace("%%", "% %");
+
+                let flag_idents = named
+                    .iter()
+                    // Filter only the flags
+                    .filter(|f| {
+                        let mut include = false;
+
+                        for attribute in &f.attrs {
+                            if let ::std::result::Result::Ok(Meta::List(list)) =
+                                attribute.parse_meta()
+                            {
+                                for nested in list.nested {
+                                    if let NestedMeta::Meta(Meta::Path(path)) = nested {
+                                        // Identify them using the --long flag name
+                                        if path.is_ident("long") {
+                                            include = true;
+                                        }
+                                    }
+                                }
+                            }
+                        }
+
+                        include
+                    })
+                    .map(|f| &f.ident);
+
+                let has_flags = flag_idents.clone().count() != 0;
+
+                if has_flags {
+                    let flag_idents_concat = flag_idents.clone();
+                    let argument_idents_concat = argument_idents.clone();
+
+                    // Concat the args and flag args if there are flags
+                    let all_arguments =
+                        quote! {#(#argument_idents_concat,) * #(#flag_idents_concat), *}
+                            .to_string();
+
+                    let flag_idents_clone = flag_idents.clone();
+                    let flags = quote! {#(--#flag_idents_clone) *}
+                        .to_string()
+                        .replace("- - ", "--")
+                        .replace('_', "-");
+
+                    let called_flag_arguments = quote! {#(%#flag_idents%) *}
+                        .to_string()
+                        .replace(" %", "%")
+                        .replace("% ", "%")
+                        .replace("%%", "% %");
+
+                    let flags_split: Vec<_> = flags.split(' ').collect();
+                    let flag_args_split: Vec<_> = called_flag_arguments.split(' ').collect();
+                    let mut consolidated_flags: Vec<String> = Vec::new();
+
+                    for (idx, flag) in flags_split.iter().enumerate() {
+                        consolidated_flags.push(format!("{} {}", flag, flag_args_split[idx]));
+                    }
+
+                    let all_flags = consolidated_flags.join(" ");
+
+                    quote! {
+                        impl AhkFunction for #name {
+                            fn generate_ahk_function() -> String {
+                                ::std::format!(r#"
+{}({}) {{
+    RunWait, komorebic.exe {} {} {}, , Hide
+}}"#,
+                                    ::std::stringify!(#name),
+                                    #all_arguments,
+                                    ::std::stringify!(#name).to_kebab_case(),
+                                    #called_arguments,
+                                    #all_flags,
+                                )
+                           }
+                        }
+                    }
+                } else {
+                    let arguments = quote! {#(#argument_idents), *}.to_string();
+
+                    quote! {
+                        impl AhkFunction for #name {
+                            fn generate_ahk_function() -> String {
+                                ::std::format!(r#"
+{}({}) {{
+    RunWait, komorebic.exe {} {}, , Hide
+}}"#, 
+                                    ::std::stringify!(#name),
+                                    #arguments,
+                                    ::std::stringify!(#name).to_kebab_case(),
+                                    #called_arguments
+                                )
+                           }
+                        }
+                    }
+                }
+            }
+            _ => unreachable!("only to be used on structs with named fields"),
+        },
+        _ => unreachable!("only to be used on structs"),
+    }
+    .into()
+}
+
+#[proc_macro_derive(AhkLibrary)]
+pub fn ahk_library(input: ::proc_macro::TokenStream) -> ::proc_macro::TokenStream {
+    let input = parse_macro_input!(input as DeriveInput);
+    let name = input.ident;
+
+    match input.data {
+        Data::Enum(DataEnum { variants, .. }) => {
+            let enums = variants.iter().filter(|&v| {
+                matches!(v.fields, Fields::Unit) || matches!(v.fields, Fields::Unnamed(..))
+            });
+
+            let mut stream = ::proc_macro2::TokenStream::new();
+
+            for variant in enums.clone() {
+                match &variant.fields {
+                    Fields::Unnamed(FieldsUnnamed { unnamed, .. }) => {
+                        for field in unnamed {
+                            stream.extend(quote! {
+                                v.push(#field::generate_ahk_function());
+                            });
+                        }
+                    }
+                    Fields::Unit => {
+                        let name = &variant.ident;
+                        stream.extend(quote! {
+                            v.push(::std::format!(r#"
+{}() {{
+    RunWait, komorebic.exe {}, , Hide
+}}"#, 
+                                ::std::stringify!(#name),
+                                ::std::stringify!(#name).to_kebab_case()
+                            ));
+                        });
+                    }
+                    Fields::Named(_) => {
+                        unreachable!("only to be used with unnamed and unit fields");
+                    }
+                }
+            }
+
+            quote! {
+                impl #name {
+                    fn generate_ahk_library() -> String {
+                        let mut v: Vec<String> = vec![String::from("; Generated by komorebic.exe")];
+
+                        #stream
+
+                        v.join("\n")
+                    }
+               }
+            }
+        }
+        _ => unreachable!("only to be used on enums"),
+    }
+    .into()
+}

docs/cli/adjust-container-padding.md

@@ -0,0 +1,19 @@
+# adjust-container-padding
+
+```
+Adjust container padding on the focused workspace
+
+Usage: komorebic.exe adjust-container-padding <SIZING> <ADJUSTMENT>
+
+Arguments:
+  <SIZING>
+          [possible values: increase, decrease]
+
+  <ADJUSTMENT>
+          Pixels to adjust by as an integer
+
+Options:
+  -h, --help
+          Print help
+
+```

docs/cli/adjust-workspace-padding.md

@@ -0,0 +1,19 @@
+# adjust-workspace-padding
+
+```
+Adjust workspace padding on the focused workspace
+
+Usage: komorebic.exe adjust-workspace-padding <SIZING> <ADJUSTMENT>
+
+Arguments:
+  <SIZING>
+          [possible values: increase, decrease]
+
+  <ADJUSTMENT>
+          Pixels to adjust by as an integer
+
+Options:
+  -h, --help
+          Print help
+
+```

docs/cli/ahk-app-specific-configuration.md

@@ -0,0 +1,19 @@
+# ahk-app-specific-configuration
+
+```
+Generate common app-specific configurations and fixes to use in komorebi.ahk
+
+Usage: komorebic.exe ahk-app-specific-configuration <PATH> [OVERRIDE_PATH]
+
+Arguments:
+  <PATH>
+          YAML file from which the application-specific configurations should be loaded
+
+  [OVERRIDE_PATH]
+          Optional YAML file of overrides to apply over the first file
+
+Options:
+  -h, --help
+          Print help
+
+```

docs/cli/ahk-library.md

@@ -0,0 +1,12 @@
+# ahk-library
+
+```
+Generate a library of AutoHotKey helper functions
+
+Usage: komorebic.exe ahk-library
+
+Options:
+  -h, --help
+          Print help
+
+```

docs/cli/application-specific-configuration-schema.md

@@ -0,0 +1,12 @@
+# application-specific-configuration-schema
+
+```
+Generate a JSON Schema for applications.yaml
+
+Usage: komorebic.exe application-specific-configuration-schema
+
+Options:
+  -h, --help
+          Print help
+
+```

docs/cli/border-colour.md

@@ -0,0 +1,26 @@
+# border-colour
+
+```
+Set the colour for a window border kind
+
+Usage: komorebic.exe border-colour [OPTIONS] <R> <G> <B>
+
+Arguments:
+  <R>
+          Red
+
+  <G>
+          Green
+
+  <B>
+          Blue
+
+Options:
+  -w, --window-kind <WINDOW_KIND>
+          [default: single]
+          [possible values: single, stack, monocle, unfocused]
+
+  -h, --help
+          Print help
+
+```

docs/cli/border-offset.md

@@ -0,0 +1,16 @@
+# border-offset
+
+```
+Set the border offset
+
+Usage: komorebic.exe border-offset <OFFSET>
+
+Arguments:
+  <OFFSET>
+          Desired offset of the window border
+
+Options:
+  -h, --help
+          Print help
+
+```

docs/cli/border-width.md

@@ -0,0 +1,16 @@
+# border-width
+
+```
+Set the border width
+
+Usage: komorebic.exe border-width <WIDTH>
+
+Arguments:
+  <WIDTH>
+          Desired width of the window border
+
+Options:
+  -h, --help
+          Print help
+
+```

docs/cli/border.md

@@ -0,0 +1,16 @@
+# border
+
+```
+Enable or disable borders
+
+Usage: komorebic.exe border <BOOLEAN_STATE>
+
+Arguments:
+  <BOOLEAN_STATE>
+          [possible values: enable, disable]
+
+Options:
+  -h, --help
+          Print help
+
+```

docs/cli/change-layout.md

@@ -0,0 +1,16 @@
+# change-layout
+
+```
+Set the layout on the focused workspace
+
+Usage: komorebic.exe change-layout <DEFAULT_LAYOUT>
+
+Arguments:
+  <DEFAULT_LAYOUT>
+          [possible values: bsp, columns, rows, vertical-stack, horizontal-stack, ultrawide-vertical-stack, grid, right-main-vertical-stack]
+
+Options:
+  -h, --help
+          Print help
+
+```

docs/cli/check.md

@@ -0,0 +1,12 @@
+# check
+
+```
+Check komorebi configuration and related files for common errors
+
+Usage: komorebic.exe check
+
+Options:
+  -h, --help
+          Print help
+
+```

docs/cli/clear-named-workspace-layout-rules.md

@@ -0,0 +1,16 @@
+# clear-named-workspace-layout-rules
+
+```
+Clear all dynamic layout rules for the specified workspace
+
+Usage: komorebic.exe clear-named-workspace-layout-rules <WORKSPACE>
+
+Arguments:
+  <WORKSPACE>
+          Target workspace name
+
+Options:
+  -h, --help
+          Print help
+
+```

docs/cli/clear-workspace-layout-rules.md

@@ -0,0 +1,19 @@
+# clear-workspace-layout-rules
+
+```
+Clear all dynamic layout rules for the specified workspace
+
+Usage: komorebic.exe clear-workspace-layout-rules <MONITOR> <WORKSPACE>
+
+Arguments:
+  <MONITOR>
+          Monitor index (zero-indexed)
+
+  <WORKSPACE>
+          Workspace index on the specified monitor (zero-indexed)
+
+Options:
+  -h, --help
+          Print help
+
+```

docs/cli/close.md

@@ -0,0 +1,12 @@
+# close
+
+```
+Close the focused window
+
+Usage: komorebic.exe close
+
+Options:
+  -h, --help
+          Print help
+
+```

docs/cli/complete-configuration.md

@@ -0,0 +1,12 @@
+# complete-configuration
+
+```
+Signal that the final configuration option has been sent
+
+Usage: komorebic.exe complete-configuration
+
+Options:
+  -h, --help
+          Print help
+
+```

docs/cli/configuration.md

@@ -0,0 +1,12 @@
+# configuration
+
+```
+Show the path to komorebi.json
+
+Usage: komorebic.exe configuration
+
+Options:
+  -h, --help
+          Print help
+
+```

docs/cli/container-padding.md

@@ -0,0 +1,22 @@
+# container-padding
+
+```
+Set the container padding for the specified workspace
+
+Usage: komorebic.exe container-padding <MONITOR> <WORKSPACE> <SIZE>
+
+Arguments:
+  <MONITOR>
+          Monitor index (zero-indexed)
+
+  <WORKSPACE>
+          Workspace index on the specified monitor (zero-indexed)
+
+  <SIZE>
+          Pixels to pad with as an integer
+
+Options:
+  -h, --help
+          Print help
+
+```

docs/cli/cross-monitor-move-behaviour.md

@@ -0,0 +1,19 @@
+# cross-monitor-move-behaviour
+
+```
+Set the behaviour when moving windows across monitor boundaries
+
+Usage: komorebic.exe cross-monitor-move-behaviour <MOVE_BEHAVIOUR>
+
+Arguments:
+  <MOVE_BEHAVIOUR>
+          Possible values:
+          - swap:   Swap the window container with the window container at the edge of the adjacent monitor
+          - insert: Insert the window container into the focused workspace on the adjacent monitor
+          - no-op:  Do nothing if trying to move a window container in the direction of an adjacent monitor
+
+Options:
+  -h, --help
+          Print help (see a summary with '-h')
+
+```

docs/cli/cycle-focus.md

@@ -0,0 +1,16 @@
+# cycle-focus
+
+```
+Change focus to the window in the specified cycle direction
+
+Usage: komorebic.exe cycle-focus <CYCLE_DIRECTION>
+
+Arguments:
+  <CYCLE_DIRECTION>
+          [possible values: previous, next]
+
+Options:
+  -h, --help
+          Print help
+
+```

docs/cli/cycle-layout.md

@@ -0,0 +1,16 @@
+# cycle-layout
+
+```
+Cycle between available layouts
+
+Usage: komorebic.exe cycle-layout <CYCLE_DIRECTION>
+
+Arguments:
+  <CYCLE_DIRECTION>
+          [possible values: previous, next]
+
+Options:
+  -h, --help
+          Print help
+
+```

docs/cli/cycle-monitor.md

@@ -0,0 +1,16 @@
+# cycle-monitor
+
+```
+Focus the monitor in the given cycle direction
+
+Usage: komorebic.exe cycle-monitor <CYCLE_DIRECTION>
+
+Arguments:
+  <CYCLE_DIRECTION>
+          [possible values: previous, next]
+
+Options:
+  -h, --help
+          Print help
+
+```

docs/cli/cycle-move-to-monitor.md

@@ -0,0 +1,16 @@
+# cycle-move-to-monitor
+
+```
+Move the focused window to the monitor in the given cycle direction
+
+Usage: komorebic.exe cycle-move-to-monitor <CYCLE_DIRECTION>
+
+Arguments:
+  <CYCLE_DIRECTION>
+          [possible values: previous, next]
+
+Options:
+  -h, --help
+          Print help
+
+```

docs/cli/cycle-move-to-workspace.md

@@ -0,0 +1,16 @@
+# cycle-move-to-workspace
+
+```
+Move the focused window to the workspace in the given cycle direction
+
+Usage: komorebic.exe cycle-move-to-workspace <CYCLE_DIRECTION>
+
+Arguments:
+  <CYCLE_DIRECTION>
+          [possible values: previous, next]
+
+Options:
+  -h, --help
+          Print help
+
+```

docs/cli/cycle-move-workspace-to-monitor.md

@@ -0,0 +1,16 @@
+# cycle-move-workspace-to-monitor
+
+```
+Move the focused workspace monitor in the given cycle direction
+
+Usage: komorebic.exe cycle-move-workspace-to-monitor <CYCLE_DIRECTION>
+
+Arguments:
+  <CYCLE_DIRECTION>
+          [possible values: previous, next]
+
+Options:
+  -h, --help
+          Print help
+
+```

docs/cli/cycle-move.md

@@ -0,0 +1,16 @@
+# cycle-move
+
+```
+Move the focused window in the specified cycle direction
+
+Usage: komorebic.exe cycle-move <CYCLE_DIRECTION>
+
+Arguments:
+  <CYCLE_DIRECTION>
+          [possible values: previous, next]
+
+Options:
+  -h, --help
+          Print help
+
+```

docs/cli/cycle-send-to-monitor.md

@@ -0,0 +1,16 @@
+# cycle-send-to-monitor
+
+```
+Send the focused window to the monitor in the given cycle direction
+
+Usage: komorebic.exe cycle-send-to-monitor <CYCLE_DIRECTION>
+
+Arguments:
+  <CYCLE_DIRECTION>
+          [possible values: previous, next]
+
+Options:
+  -h, --help
+          Print help
+
+```

docs/cli/cycle-send-to-workspace.md

@@ -0,0 +1,16 @@
+# cycle-send-to-workspace
+
+```
+Send the focused window to the workspace in the given cycle direction
+
+Usage: komorebic.exe cycle-send-to-workspace <CYCLE_DIRECTION>
+
+Arguments:
+  <CYCLE_DIRECTION>
+          [possible values: previous, next]
+
+Options:
+  -h, --help
+          Print help
+
+```

docs/cli/cycle-stack.md

@@ -0,0 +1,16 @@
+# cycle-stack
+
+```
+Cycle the focused stack in the specified cycle direction
+
+Usage: komorebic.exe cycle-stack <CYCLE_DIRECTION>
+
+Arguments:
+  <CYCLE_DIRECTION>
+          [possible values: previous, next]
+
+Options:
+  -h, --help
+          Print help
+
+```

docs/cli/cycle-workspace.md

@@ -0,0 +1,16 @@
+# cycle-workspace
+
+```
+Focus the workspace in the given cycle direction
+
+Usage: komorebic.exe cycle-workspace <CYCLE_DIRECTION>
+
+Arguments:
+  <CYCLE_DIRECTION>
+          [possible values: previous, next]
+
+Options:
+  -h, --help
+          Print help
+
+```

docs/cli/disable-autostart.md

@@ -0,0 +1,12 @@
+# disable-autostart
+
+```
+Deletes the komorebi.lnk shortcut in shell:startup to disable autostart
+
+Usage: komorebic.exe disable-autostart
+
+Options:
+  -h, --help
+          Print help
+
+```

docs/cli/display-index-preference.md

@@ -0,0 +1,19 @@
+# display-index-preference
+
+```
+Set the display index preference for a monitor identified using its display name
+
+Usage: komorebic.exe display-index-preference <INDEX_PREFERENCE> <DISPLAY>
+
+Arguments:
+  <INDEX_PREFERENCE>
+          Preferred monitor index (zero-indexed)
+
+  <DISPLAY>
+          Display name as identified in komorebic state
+
+Options:
+  -h, --help
+          Print help
+
+```

docs/cli/enable-autostart.md

@@ -0,0 +1,24 @@
+# enable-autostart
+
+```
+Generates the komorebi.lnk shortcut in shell:startup to autostart komorebi
+
+Usage: komorebic.exe enable-autostart [OPTIONS]
+
+Options:
+  -c, --config <CONFIG>
+          Path to a static configuration JSON file
+
+  -f, --ffm
+          Enable komorebi's custom focus-follows-mouse implementation
+
+      --whkd
+          Enable autostart of whkd
+
+      --ahk
+          Enable autostart of ahk
+
+  -h, --help
+          Print help
+
+```

docs/cli/ensure-named-workspaces.md

@@ -0,0 +1,19 @@
+# ensure-named-workspaces
+
+```
+Create these many named workspaces for the specified monitor
+
+Usage: komorebic.exe ensure-named-workspaces <MONITOR> [NAMES]...
+
+Arguments:
+  <MONITOR>
+          Monitor index (zero-indexed)
+
+  [NAMES]...
+          Names of desired workspaces
+
+Options:
+  -h, --help
+          Print help
+
+```

docs/cli/ensure-workspaces.md

@@ -0,0 +1,19 @@
+# ensure-workspaces
+
+```
+Create at least this many workspaces for the specified monitor
+
+Usage: komorebic.exe ensure-workspaces <MONITOR> <WORKSPACE_COUNT>
+
+Arguments:
+  <MONITOR>
+          Monitor index (zero-indexed)
+
+  <WORKSPACE_COUNT>
+          Number of desired workspaces
+
+Options:
+  -h, --help
+          Print help
+
+```

docs/cli/fetch-app-specific-configuration.md

@@ -0,0 +1,12 @@
+# fetch-app-specific-configuration
+
+```
+Fetch the latest version of applications.yaml from komorebi-application-specific-configuration
+
+Usage: komorebic.exe fetch-app-specific-configuration
+
+Options:
+  -h, --help
+          Print help
+
+```

docs/cli/flip-layout.md

@@ -0,0 +1,16 @@
+# flip-layout
+
+```
+Flip the layout on the focused workspace (BSP only)
+
+Usage: komorebic.exe flip-layout <AXIS>
+
+Arguments:
+  <AXIS>
+          [possible values: horizontal, vertical, horizontal-and-vertical]
+
+Options:
+  -h, --help
+          Print help
+
+```

docs/cli/float-rule.md

@@ -0,0 +1,19 @@
+# float-rule
+
+```
+Add a rule to always float the specified application
+
+Usage: komorebic.exe float-rule <IDENTIFIER> <ID>
+
+Arguments:
+  <IDENTIFIER>
+          [possible values: exe, class, title, path]
+
+  <ID>
+          Identifier as a string
+
+Options:
+  -h, --help
+          Print help
+
+```

docs/cli/focus-follows-mouse.md

@@ -0,0 +1,23 @@
+# focus-follows-mouse
+
+```
+Enable or disable focus follows mouse for the operating system
+
+Usage: komorebic.exe focus-follows-mouse [OPTIONS] <BOOLEAN_STATE>
+
+Arguments:
+  <BOOLEAN_STATE>
+          [possible values: enable, disable]
+
+Options:
+  -i, --implementation <IMPLEMENTATION>
+          [default: windows]
+
+          Possible values:
+          - komorebi: A custom FFM implementation (slightly more CPU-intensive)
+          - windows:  The native (legacy) Windows FFM implementation
+
+  -h, --help
+          Print help (see a summary with '-h')
+
+```

docs/cli/focus-last-workspace.md

@@ -0,0 +1,12 @@
+# focus-last-workspace
+
+```
+Focus the last focused workspace on the focused monitor
+
+Usage: komorebic.exe focus-last-workspace
+
+Options:
+  -h, --help
+          Print help
+
+```

docs/cli/focus-monitor-workspace.md

@@ -0,0 +1,19 @@
+# focus-monitor-workspace
+
+```
+Focus the specified workspace on the target monitor
+
+Usage: komorebic.exe focus-monitor-workspace <TARGET_MONITOR> <TARGET_WORKSPACE>
+
+Arguments:
+  <TARGET_MONITOR>
+          Target monitor index (zero-indexed)
+
+  <TARGET_WORKSPACE>
+          Workspace index on the target monitor (zero-indexed)
+
+Options:
+  -h, --help
+          Print help
+
+```

docs/cli/focus-monitor.md

@@ -0,0 +1,16 @@
+# focus-monitor
+
+```
+Focus the specified monitor
+
+Usage: komorebic.exe focus-monitor <TARGET>
+
+Arguments:
+  <TARGET>
+          Target index (zero-indexed)
+
+Options:
+  -h, --help
+          Print help
+
+```

docs/cli/focus-named-workspace.md

@@ -0,0 +1,16 @@
+# focus-named-workspace
+
+```
+Focus the specified workspace
+
+Usage: komorebic.exe focus-named-workspace <WORKSPACE>
+
+Arguments:
+  <WORKSPACE>
+          Target workspace name
+
+Options:
+  -h, --help
+          Print help
+
+```

docs/cli/focus-workspace.md

@@ -0,0 +1,16 @@
+# focus-workspace
+
+```
+Focus the specified workspace on the focused monitor
+
+Usage: komorebic.exe focus-workspace <TARGET>
+
+Arguments:
+  <TARGET>
+          Target index (zero-indexed)
+
+Options:
+  -h, --help
+          Print help
+
+```

docs/cli/focus-workspaces.md

@@ -0,0 +1,16 @@
+# focus-workspaces
+
+```
+Focus the specified workspace on all monitors
+
+Usage: komorebic.exe focus-workspaces <TARGET>
+
+Arguments:
+  <TARGET>
+          Target index (zero-indexed)
+
+Options:
+  -h, --help
+          Print help
+
+```

docs/cli/focus.md

@@ -0,0 +1,16 @@
+# focus
+
+```
+Change focus to the window in the specified direction
+
+Usage: komorebic.exe focus <OPERATION_DIRECTION>
+
+Arguments:
+  <OPERATION_DIRECTION>
+          [possible values: left, right, up, down]
+
+Options:
+  -h, --help
+          Print help
+
+```

docs/cli/focused-workspace-container-padding.md

@@ -0,0 +1,16 @@
+# focused-workspace-container-padding
+
+```
+Set container padding on the focused workspace
+
+Usage: komorebic.exe focused-workspace-container-padding <SIZE>
+
+Arguments:
+  <SIZE>
+          Pixels size to set as an integer
+
+Options:
+  -h, --help
+          Print help
+
+```

docs/cli/focused-workspace-padding.md

@@ -0,0 +1,16 @@
+# focused-workspace-padding
+
+```
+Set workspace padding on the focused workspace
+
+Usage: komorebic.exe focused-workspace-padding <SIZE>
+
+Arguments:
+  <SIZE>
+          Pixels size to set as an integer
+
+Options:
+  -h, --help
+          Print help
+
+```

docs/cli/force-focus.md

@@ -0,0 +1,12 @@
+# force-focus
+
+```
+Forcibly focus the window at the cursor with a left mouse click
+
+Usage: komorebic.exe force-focus
+
+Options:
+  -h, --help
+          Print help
+
+```

docs/cli/format-app-specific-configuration.md

@@ -0,0 +1,16 @@
+# format-app-specific-configuration
+
+```
+Format a YAML file for use with the 'ahk-app-specific-configuration' command
+
+Usage: komorebic.exe format-app-specific-configuration <PATH>
+
+Arguments:
+  <PATH>
+          YAML file from which the application-specific configurations should be loaded
+
+Options:
+  -h, --help
+          Print help
+
+```

docs/cli/generate-static-config.md

@@ -0,0 +1,12 @@
+# generate-static-config
+
+```
+Generates a static configuration JSON file based on the current window manager state
+
+Usage: komorebic.exe generate-static-config
+
+Options:
+  -h, --help
+          Print help
+
+```

docs/cli/global-state.md

@@ -0,0 +1,12 @@
+# global-state
+
+```
+Show a JSON representation of the current global state
+
+Usage: komorebic.exe global-state
+
+Options:
+  -h, --help
+          Print help
+
+```

docs/cli/global-work-area-offset.md

@@ -0,0 +1,25 @@
+# global-work-area-offset
+
+```
+Set offsets to exclude parts of the work area from tiling
+
+Usage: komorebic.exe global-work-area-offset <LEFT> <TOP> <RIGHT> <BOTTOM>
+
+Arguments:
+  <LEFT>
+          Size of the left work area offset (set right to left * 2 to maintain right padding)
+
+  <TOP>
+          Size of the top work area offset (set bottom to the same value to maintain bottom padding)
+
+  <RIGHT>
+          Size of the right work area offset
+
+  <BOTTOM>
+          Size of the bottom work area offset
+
+Options:
+  -h, --help
+          Print help
+
+```

docs/cli/gui.md

@@ -0,0 +1,12 @@
+# gui
+
+```
+Launch the komorebi-gui debugging tool
+
+Usage: komorebic.exe gui
+
+Options:
+  -h, --help
+          Print help
+
+```

docs/cli/identify-layered-application.md

@@ -0,0 +1,19 @@
+# identify-layered-application
+
+```
+Identify an application that has WS_EX_LAYERED, but should still be managed
+
+Usage: komorebic.exe identify-layered-application <IDENTIFIER> <ID>
+
+Arguments:
+  <IDENTIFIER>
+          [possible values: exe, class, title, path]
+
+  <ID>
+          Identifier as a string
+
+Options:
+  -h, --help
+          Print help
+
+```

docs/cli/identify-object-name-change-application.md

@@ -0,0 +1,19 @@
+# identify-object-name-change-application
+
+```
+Identify an application that sends EVENT_OBJECT_NAMECHANGE on launch
+
+Usage: komorebic.exe identify-object-name-change-application <IDENTIFIER> <ID>
+
+Arguments:
+  <IDENTIFIER>
+          [possible values: exe, class, title, path]
+
+  <ID>
+          Identifier as a string
+
+Options:
+  -h, --help
+          Print help
+
+```

docs/cli/identify-tray-application.md

@@ -0,0 +1,19 @@
+# identify-tray-application
+
+```
+Identify an application that closes to the system tray
+
+Usage: komorebic.exe identify-tray-application <IDENTIFIER> <ID>
+
+Arguments:
+  <IDENTIFIER>
+          [possible values: exe, class, title, path]
+
+  <ID>
+          Identifier as a string
+
+Options:
+  -h, --help
+          Print help
+
+```

docs/cli/initial-named-workspace-rule.md

@@ -0,0 +1,22 @@
+# initial-named-workspace-rule
+
+```
+Add a rule to associate an application with a named workspace on first show
+
+Usage: komorebic.exe initial-named-workspace-rule <IDENTIFIER> <ID> <WORKSPACE>
+
+Arguments:
+  <IDENTIFIER>
+          [possible values: exe, class, title, path]
+
+  <ID>
+          Identifier as a string
+
+  <WORKSPACE>
+          Name of a workspace
+
+Options:
+  -h, --help
+          Print help
+
+```

docs/cli/initial-workspace-rule.md

@@ -0,0 +1,25 @@
+# initial-workspace-rule
+
+```
+Add a rule to associate an application with a workspace on first show
+
+Usage: komorebic.exe initial-workspace-rule <IDENTIFIER> <ID> <MONITOR> <WORKSPACE>
+
+Arguments:
+  <IDENTIFIER>
+          [possible values: exe, class, title, path]
+
+  <ID>
+          Identifier as a string
+
+  <MONITOR>
+          Monitor index (zero-indexed)
+
+  <WORKSPACE>
+          Workspace index on the specified monitor (zero-indexed)
+
+Options:
+  -h, --help
+          Print help
+
+```

docs/cli/invisible-borders.md

@@ -0,0 +1,25 @@
+# invisible-borders
+
+```
+Set the invisible border dimensions around each window
+
+Usage: komorebic.exe invisible-borders <LEFT> <TOP> <RIGHT> <BOTTOM>
+
+Arguments:
+  <LEFT>
+          Size of the left invisible border
+
+  <TOP>
+          Size of the top invisible border (usually 0)
+
+  <RIGHT>
+          Size of the right invisible border (usually left * 2)
+
+  <BOTTOM>
+          Size of the bottom invisible border (usually the same as left)
+
+Options:
+  -h, --help
+          Print help
+
+```

docs/cli/load-custom-layout.md

@@ -0,0 +1,16 @@
+# load-custom-layout
+
+```
+Load a custom layout from file for the focused workspace
+
+Usage: komorebic.exe load-custom-layout <PATH>
+
+Arguments:
+  <PATH>
+          JSON or YAML file from which the custom layout definition should be loaded
+
+Options:
+  -h, --help
+          Print help
+
+```

docs/cli/load-resize.md

@@ -0,0 +1,16 @@
+# load-resize
+
+```
+Load the resize layout dimensions from a file
+
+Usage: komorebic.exe load-resize <PATH>
+
+Arguments:
+  <PATH>
+          File from which the resize layout dimensions should be loaded
+
+Options:
+  -h, --help
+          Print help
+
+```

docs/cli/log.md

@@ -0,0 +1,12 @@
+# log
+
+```
+Tail komorebi.exe's process logs (cancel with Ctrl-C)
+
+Usage: komorebic.exe log
+
+Options:
+  -h, --help
+          Print help
+
+```

docs/cli/manage-rule.md

@@ -0,0 +1,19 @@
+# manage-rule
+
+```
+Add a rule to always manage the specified application
+
+Usage: komorebic.exe manage-rule <IDENTIFIER> <ID>
+
+Arguments:
+  <IDENTIFIER>
+          [possible values: exe, class, title, path]
+
+  <ID>
+          Identifier as a string
+
+Options:
+  -h, --help
+          Print help
+
+```

docs/cli/manage.md

@@ -0,0 +1,12 @@
+# manage
+
+```
+Force komorebi to manage the focused window
+
+Usage: komorebic.exe manage
+
+Options:
+  -h, --help
+          Print help
+
+```

docs/cli/minimize.md

@@ -0,0 +1,12 @@
+# minimize
+
+```
+Minimize the focused window
+
+Usage: komorebic.exe minimize
+
+Options:
+  -h, --help
+          Print help
+
+```

docs/cli/monitor-index-preference.md

@@ -0,0 +1,28 @@
+# monitor-index-preference
+
+```
+Set the monitor index preference for a monitor identified using its size
+
+Usage: komorebic.exe monitor-index-preference <INDEX_PREFERENCE> <LEFT> <TOP> <RIGHT> <BOTTOM>
+
+Arguments:
+  <INDEX_PREFERENCE>
+          Preferred monitor index (zero-indexed)
+
+  <LEFT>
+          Left value of the monitor's size Rect
+
+  <TOP>
+          Top value of the monitor's size Rect
+
+  <RIGHT>
+          Right value of the monitor's size Rect
+
+  <BOTTOM>
+          Bottom value of the monitor's size Rect
+
+Options:
+  -h, --help
+          Print help
+
+```

docs/cli/monitor-work-area-offset.md

@@ -0,0 +1,28 @@
+# monitor-work-area-offset
+
+```
+Set offsets for a monitor to exclude parts of the work area from tiling
+
+Usage: komorebic.exe monitor-work-area-offset <MONITOR> <LEFT> <TOP> <RIGHT> <BOTTOM>
+
+Arguments:
+  <MONITOR>
+          Monitor index (zero-indexed)
+
+  <LEFT>
+          Size of the left work area offset (set right to left * 2 to maintain right padding)
+
+  <TOP>
+          Size of the top work area offset (set bottom to the same value to maintain bottom padding)
+
+  <RIGHT>
+          Size of the right work area offset
+
+  <BOTTOM>
+          Size of the bottom work area offset
+
+Options:
+  -h, --help
+          Print help
+
+```

docs/cli/mouse-follows-focus.md

@@ -0,0 +1,16 @@
+# mouse-follows-focus
+
+```
+Enable or disable mouse follows focus on all workspaces
+
+Usage: komorebic.exe mouse-follows-focus <BOOLEAN_STATE>
+
+Arguments:
+  <BOOLEAN_STATE>
+          [possible values: enable, disable]
+
+Options:
+  -h, --help
+          Print help
+
+```

docs/cli/move-to-monitor-workspace.md

@@ -0,0 +1,19 @@
+# move-to-monitor-workspace
+
+```
+Move the focused window to the specified monitor workspace
+
+Usage: komorebic.exe move-to-monitor-workspace <TARGET_MONITOR> <TARGET_WORKSPACE>
+
+Arguments:
+  <TARGET_MONITOR>
+          Target monitor index (zero-indexed)
+
+  <TARGET_WORKSPACE>
+          Workspace index on the target monitor (zero-indexed)
+
+Options:
+  -h, --help
+          Print help
+
+```

docs/cli/move-to-monitor.md

@@ -0,0 +1,16 @@
+# move-to-monitor
+
+```
+Move the focused window to the specified monitor
+
+Usage: komorebic.exe move-to-monitor <TARGET>
+
+Arguments:
+  <TARGET>
+          Target index (zero-indexed)
+
+Options:
+  -h, --help
+          Print help
+
+```

docs/cli/move-to-named-workspace.md

@@ -0,0 +1,16 @@
+# move-to-named-workspace
+
+```
+Move the focused window to the specified workspace
+
+Usage: komorebic.exe move-to-named-workspace <WORKSPACE>
+
+Arguments:
+  <WORKSPACE>
+          Target workspace name
+
+Options:
+  -h, --help
+          Print help
+
+```

docs/cli/move-to-workspace.md

@@ -0,0 +1,16 @@
+# move-to-workspace
+
+```
+Move the focused window to the specified workspace
+
+Usage: komorebic.exe move-to-workspace <TARGET>
+
+Arguments:
+  <TARGET>
+          Target index (zero-indexed)
+
+Options:
+  -h, --help
+          Print help
+
+```

docs/cli/move-workspace-to-monitor.md

@@ -0,0 +1,16 @@
+# move-workspace-to-monitor
+
+```
+Move the focused workspace to the specified monitor
+
+Usage: komorebic.exe move-workspace-to-monitor <TARGET>
+
+Arguments:
+  <TARGET>
+          Target index (zero-indexed)
+
+Options:
+  -h, --help
+          Print help
+
+```

docs/cli/move.md

@@ -0,0 +1,16 @@
+# move
+
+```
+Move the focused window in the specified direction
+
+Usage: komorebic.exe move <OPERATION_DIRECTION>
+
+Arguments:
+  <OPERATION_DIRECTION>
+          [possible values: left, right, up, down]
+
+Options:
+  -h, --help
+          Print help
+
+```

docs/cli/named-workspace-container-padding.md

@@ -0,0 +1,19 @@
+# named-workspace-container-padding
+
+```
+Set the container padding for the specified workspace
+
+Usage: komorebic.exe named-workspace-container-padding <WORKSPACE> <SIZE>
+
+Arguments:
+  <WORKSPACE>
+          Target workspace name
+
+  <SIZE>
+          Pixels to pad with as an integer
+
+Options:
+  -h, --help
+          Print help
+
+```

docs/cli/named-workspace-custom-layout-rule.md

@@ -0,0 +1,22 @@
+# named-workspace-custom-layout-rule
+
+```
+Add a dynamic custom layout for the specified workspace
+
+Usage: komorebic.exe named-workspace-custom-layout-rule <WORKSPACE> <AT_CONTAINER_COUNT> <PATH>
+
+Arguments:
+  <WORKSPACE>
+          Target workspace name
+
+  <AT_CONTAINER_COUNT>
+          The number of window containers on-screen required to trigger this layout rule
+
+  <PATH>
+          JSON or YAML file from which the custom layout definition should be loaded
+
+Options:
+  -h, --help
+          Print help
+
+```

docs/cli/named-workspace-custom-layout.md

@@ -0,0 +1,19 @@
+# named-workspace-custom-layout
+
+```
+Set a custom layout for the specified workspace
+
+Usage: komorebic.exe named-workspace-custom-layout <WORKSPACE> <PATH>
+
+Arguments:
+  <WORKSPACE>
+          Target workspace name
+
+  <PATH>
+          JSON or YAML file from which the custom layout definition should be loaded
+
+Options:
+  -h, --help
+          Print help
+
+```

docs/cli/named-workspace-layout-rule.md

@@ -0,0 +1,22 @@
+# named-workspace-layout-rule
+
+```
+Add a dynamic layout rule for the specified workspace
+
+Usage: komorebic.exe named-workspace-layout-rule <WORKSPACE> <AT_CONTAINER_COUNT> <LAYOUT>
+
+Arguments:
+  <WORKSPACE>
+          Target workspace name
+
+  <AT_CONTAINER_COUNT>
+          The number of window containers on-screen required to trigger this layout rule
+
+  <LAYOUT>
+          [possible values: bsp, columns, rows, vertical-stack, horizontal-stack, ultrawide-vertical-stack, grid, right-main-vertical-stack]
+
+Options:
+  -h, --help
+          Print help
+
+```

docs/cli/named-workspace-layout.md

@@ -0,0 +1,19 @@
+# named-workspace-layout
+
+```
+Set the layout for the specified workspace
+
+Usage: komorebic.exe named-workspace-layout <WORKSPACE> <VALUE>
+
+Arguments:
+  <WORKSPACE>
+          Target workspace name
+
+  <VALUE>
+          [possible values: bsp, columns, rows, vertical-stack, horizontal-stack, ultrawide-vertical-stack, grid, right-main-vertical-stack]
+
+Options:
+  -h, --help
+          Print help
+
+```

docs/cli/named-workspace-padding.md

@@ -0,0 +1,19 @@
+# named-workspace-padding
+
+```
+Set the workspace padding for the specified workspace
+
+Usage: komorebic.exe named-workspace-padding <WORKSPACE> <SIZE>
+
+Arguments:
+  <WORKSPACE>
+          Target workspace name
+
+  <SIZE>
+          Pixels to pad with as an integer
+
+Options:
+  -h, --help
+          Print help
+
+```

docs/cli/named-workspace-rule.md

@@ -0,0 +1,22 @@
+# named-workspace-rule
+
+```
+Add a rule to associate an application with a named workspace
+
+Usage: komorebic.exe named-workspace-rule <IDENTIFIER> <ID> <WORKSPACE>
+
+Arguments:
+  <IDENTIFIER>
+          [possible values: exe, class, title, path]
+
+  <ID>
+          Identifier as a string
+
+  <WORKSPACE>
+          Name of a workspace
+
+Options:
+  -h, --help
+          Print help
+
+```