fix: menu refreshes

now there's no flicker *and* its not bugged with
leaving the text on exit

.editorconfig

@@ -0,0 +1,6 @@
+root = true
+
+[*]
+charset = utf-8
+indent_size = 4
+indent_style = tab

.github/pull_request_template.md

@@ -1,5 +1,5 @@
 ---
 - [ ] I have reviewed CONTRIBUTING.md.
 - [ ] My commits and title use the [Conventional Commit](https://www.conventionalcommits.org/en/v1.0.0/) format.
-- [ ] I have documented any breaking changes according to [SemVer](https://semver.org/).
+- [ ] I have documented changes and additions in the CHANGELOG.md.
 ---

.github/workflows/build.yml

@@ -1,31 +1,64 @@
 name: Build
 
 on:
-  - push
-  - pull_request
+  push:
+    branches:
+    - master
+  pull_request:
+    branches:
+    - master
 
 jobs:
   build:
-    name: ${{ matrix.build }}
-    runs-on: ${{ matrix.os }}
+    name: ${{ matrix.goos }}-${{ matrix.goarch }}
+    runs-on: ubuntu-latest
     strategy:
       matrix:
-        include:
-          - build: linux-amd64
-            os: ubuntu-latest
+        goos: [linux, windows, darwin]
+        goarch: ["386", amd64, arm64]
+        exclude:
+          - goarch: "386"
+            goos: darwin
+          - goarch: arm64
+            goos: windows
     steps:
       - name: Checkout sources
-        uses: actions/checkout@v2
+        uses: actions/checkout@v4
         with:
-          fetch-depth: 0
+          submodules: true
       - name: Setup Go
-        uses: actions/setup-go@v2
+        uses: actions/setup-go@v5
         with:
-          go-version: '1.16.2'
+          go-version: '1.18.8'
+      - name: Download Task
+        run: 'sh -c "$(curl --location https://taskfile.dev/install.sh)" -- -d'
       - name: Build
-        run: make hilbiline
-      - uses: actions/upload-artifact@v2
+        run: GOOS=${{ matrix.goos }} GOARCH=${{ matrix.goarch }} ./bin/task
+      - uses: actions/upload-artifact@v4
+        if: matrix.goos == 'windows'
         with:
-          name: hilbish-${{ matrix.build }}
-          path: hilbish
-
+          name: hilbish-${{ matrix.goos }}-${{ matrix.goarch }}
+          path: |
+            hilbish.exe
+            LICENSE
+            README.md
+            CHANGELOG.md
+            .hilbishrc.lua
+            nature
+            libs
+            docs
+            emmyLuaDocs
+      - uses: actions/upload-artifact@v4
+        if: matrix.goos != 'windows'
+        with:
+          name: hilbish-${{ matrix.goos }}-${{ matrix.goarch }}
+          path: |
+            hilbish
+            LICENSE
+            README.md
+            CHANGELOG.md
+            .hilbishrc.lua
+            nature
+            libs
+            docs
+            emmyLuaDocs

.github/workflows/codeql-analysis.yml

@@ -0,0 +1,60 @@
+name: CodeQL
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    # The branches below must be a subset of the branches above
+    branches: [ master ]
+  schedule:
+    - cron: '38 2 * * 4'
+
+jobs:
+  analyze:
+    name: Analyze
+    runs-on: ubuntu-latest
+    permissions:
+      actions: read
+      contents: read
+      security-events: write
+
+    strategy:
+      fail-fast: false
+      matrix:
+        language: [ 'go' ]
+        # CodeQL supports [ 'cpp', 'csharp', 'go', 'java', 'javascript', 'python', 'ruby' ]
+        # Learn more about CodeQL language support at https://aka.ms/codeql-docs/language-support
+
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v4
+
+    # Initializes the CodeQL tools for scanning.
+    - name: Initialize CodeQL
+      uses: github/codeql-action/init@v2
+      with:
+        languages: ${{ matrix.language }}
+        # If you wish to specify custom queries, you can do so here or in a config file.
+        # By default, queries listed here will override any specified in a config file.
+        # Prefix the list here with "+" to use these queries and those in the config file.
+        
+        # Details on CodeQL's query packs refer to : https://docs.github.com/en/code-security/code-scanning/automatically-scanning-your-code-for-vulnerabilities-and-errors/configuring-code-scanning#using-queries-in-ql-packs
+        # queries: security-extended,security-and-quality
+
+        
+    # Autobuild attempts to build any compiled languages  (C/C++, C#, or Java).
+    # If this step fails, then you should remove it and run the build manually (see below)
+    - name: Autobuild
+      uses: github/codeql-action/autobuild@v2
+
+    # ℹ️ Command-line programs to run using the OS shell.
+    # 📚 See https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions#jobsjob_idstepsrun
+
+    #   If the Autobuild fails above, remove it and uncomment the following three lines. 
+    #   modify them (or add more) to build your code if your project, please refer to the EXAMPLE below for guidance.
+
+    # - run: |
+    #   echo "Run, Build Application using script"
+    #   ./location_of_script_within_repo/buildscript.sh
+
+    - name: Perform CodeQL Analysis
+      uses: github/codeql-action/analyze@v2

.github/workflows/docs.yml

@@ -0,0 +1,20 @@
+name: Generate docs
+
+on:
+  push:
+    branches:
+      - master
+
+jobs:
+  gen:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-go@v5
+      - name: Run docgen
+        run: go run cmd/docgen/docgen.go
+      - name: Commit new docs
+        uses: stefanzweifel/git-auto-commit-action@v4
+        with:
+          commit_message: "docs: [ci] generate new docs"
+          file_pattern: docs/ emmyLuaDocs/

.github/workflows/release.yml

@@ -0,0 +1,46 @@
+name: Release
+
+on:
+  push:
+    tags:
+      - v[0-9]+.*
+
+jobs:
+  create-release:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: taiki-e/create-gh-release-action@v1
+        with:
+          title: Hilbish $tag
+          changelog: CHANGELOG.md
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+  releases-matrix:
+    name: Build Release Binary
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        goos: [linux, windows, darwin]
+        goarch: ["386", amd64, arm64]
+        exclude:
+          - goarch: "386"
+            goos: darwin
+          - goarch: arm64
+            goos: windows
+    steps:
+    - uses: actions/checkout@v4
+      with:
+        submodules: true
+        fetch-depth: 0
+    - name: Download Task
+      run: 'sh -c "$(curl --location https://taskfile.dev/install.sh)" -- -d'
+    - uses: wangyoucao577/go-release-action@v1
+      with:
+        github_token: ${{ secrets.GITHUB_TOKEN }}
+        goos: ${{ matrix.goos }}
+        goarch: ${{ matrix.goarch }}
+        ldflags: '-s -w'
+        binary_name: hilbish
+        extra_files: LICENSE README.md CHANGELOG.md .hilbishrc.lua nature libs docs emmyLuaDocs

.github/workflows/website.yml

@@ -0,0 +1,51 @@
+name: Build website
+
+on:
+  push:
+    branches:
+    - master
+  pull_request:
+    branches:
+    - master
+
+jobs:
+  deploy:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: true
+          fetch-depth: 0
+
+      - name: Setup Hugo
+        uses: peaceiris/actions-hugo@v3
+        with:
+          hugo-version: '0.111.3'
+          extended: true
+
+      - name: Set branch name
+        id: branch
+        run: echo "BRANCH_NAME=${GITHUB_HEAD_REF:-${GITHUB_REF#refs/heads/}}" >> "$GITHUB_ENV"
+
+      - name: Fix base URL
+        if: env.BRANCH_NAME != 'master' && github.repository_owner == 'Rosettea'      
+        run: sed -i "s%baseURL = 'https://rosettea.github.io/Hilbish/'%baseURL = 'https://rosettea.github.io/Hilbish/versions/${{ env.BRANCH_NAME }}'%" website/config.toml
+
+      - name: Build
+        run: 'cd website && hugo --minify'
+
+      - name: Deploy
+        if: env.BRANCH_NAME == 'master' && github.repository_owner == 'Rosettea'
+        uses: peaceiris/actions-gh-pages@v4
+        with:
+          github_token: ${{ secrets.GITHUB_TOKEN }}
+          publish_dir: ./website/public
+          keep_files: true
+      - name: Deploy
+        if: env.BRANCH_NAME != 'master' && github.repository_owner == 'Rosettea'
+        uses: peaceiris/actions-gh-pages@v4
+        with:
+          github_token: ${{ secrets.GITHUB_TOKEN }}
+          publish_dir: ./website/public
+          destination_dir: versions/${{ env.BRANCH_NAME }}
+          keep_files: true

.gitignore

@@ -1,6 +1,9 @@
 *.exe
 hilbish
+!docs/api/hilbish
 docgen
+!cmd/docgen
 
 .vim
 petals/
+.hugo_build.lock

.gitmodules

@@ -1,6 +1,6 @@
 [submodule "libs/lunacolors"]
 	path = libs/lunacolors
-	url = https://github.com/Hilbis/Lunacolors
+	url = https://github.com/Rosettea/Lunacolors
 [submodule "libs/succulent"]
 	path = libs/succulent
 	url = https://github.com/Rosettea/Succulent

.hilbishrc.lua

@@ -1,19 +1,49 @@
 -- Default Hilbish config
-lunacolors = require 'lunacolors'
-bait = require 'bait'
+local hilbish = require 'hilbish'
+local lunacolors = require 'lunacolors'
+local bait = require 'bait'
+local ansikit = require 'ansikit'
 
-function doPrompt(fail)
-	prompt(lunacolors.format(
+local unreadCount = 0
+local running = false
+local function doPrompt(fail)
+	hilbish.prompt(lunacolors.format(
 		'{blue}%u {cyan}%d ' .. (fail and '{red}' or '{green}') .. '∆ '
 	))
 end
 
-print(lunacolors.format('Welcome to {magenta}Hilbish{reset}, {cyan}' .. hilbish.user
-.. '{reset}.\n' .. 'The nice lil shell for {blue}Lua{reset} fanatics!\n'))
+local function doNotifyPrompt()
+	if running or unreadCount == hilbish.messages.unreadCount() then return end
+
+	local notifPrompt = string.format('• %s unread notification%s', hilbish.messages.unreadCount(), hilbish.messages.unreadCount() > 1 and 's' or '')
+	unreadCount = hilbish.messages.unreadCount()
+	hilbish.prompt(lunacolors.blue(notifPrompt), 'right')
+
+	hilbish.timeout(function()
+		hilbish.prompt('', 'right')
+	end, 3000)
+end
 
 doPrompt()
 
-bait.catch('command.exit', function(code)
-	doPrompt(code ~= 0)
+bait.catch('command.preexec', function()
+	running = true
 end)
 
+bait.catch('command.exit', function(code)
+	running = false
+	doPrompt(code ~= 0)
+	doNotifyPrompt()
+end)
+
+bait.catch('hilbish.vimMode', function(mode)
+	if mode ~= 'insert' then
+		ansikit.cursorStyle(ansikit.blockCursor)
+	else
+		ansikit.cursorStyle(ansikit.lineCursor)
+	end
+end)
+
+bait.catch('hilbish.notification', function(notif)
+	doNotifyPrompt()
+end)

CHANGELOG.md

@@ -1,6 +1,469 @@
 # 🎀 Changelog
 
-This is the changelog for the Hilbish shell made in Go and Lua.
+## Unreleased
+### Added
+- `fs.pipe` function to get a pair of connected files (a pipe).
+- Added an alternative 2nd parameter to `hilbish.run`, which is `streams`.
+`streams` is a table of input and output streams to run the command with.
+It uses these 3 keys:
+  - `input` as standard input for the command
+  - `out` as standard output
+  - `err` as standard error
+
+Here is a minimal example of the new usage which allows users to now pipe commands
+directly via Lua functions:
+  
+```lua
+local fs = require 'fs'
+local pr, pw = fs.pipe()
+hilbish.run('ls -l', {
+	stdout = pw,
+	stderr = pw,
+})
+
+pw:close()
+
+hilbish.run('wc -l', {
+	stdin = pr
+})
+```
+
+### Fixed
+- Fix ansi attributes causing issues with text when cut off in greenhouse
+
+## [2.2.3] - 2024-04-27
+### Fixed
+- Highligher and hinter work now, since it was regressed from the previous minor release.
+- `cat` command no longer prints extra newline at end of each file
+
+### Added
+- `cat` command now reads files in chunks, allowing for reading large files
+
+## [2.2.2] - 2024-04-16
+### Fixed
+- Line refresh fixes (less flicker)
+- Do more checks for a TTY
+  - Panic if ENOTTY is thrown from readline
+  - use `x/term` function to check if a terminal
+
+### Added
+- Page Up/Down keybinds for Greenhouse will now scroll up and down the size of the region (a page)
+
+### Changed
+- Remove usage of `hilbish.goro` in Greenhouse.
+- Values in `hilbish` table are no longer protected. This means
+they can be overridden. (#287)
+
+## [2.2.1] - 2023-12-26
+### Fixed
+- Removed a left over debug print
+- Recover panic in `hilbish.goro`
+
+## [2.2.0] - 2023-12-25
+### Added
+- [Native Modules](https://rosettea.github.io/Hilbish/docs/api/hilbish/hilbish.module/)
+- Made a few additions to the sink type:
+  - `read()` method for retrieving input (so now the `in` sink of commanders is useful)
+  - `flush()` and `autoFlush()` related to flushing outputs
+  - `pipe` property to check if a sink with input is a pipe (like stdin)
+- Add fuzzy search to history search (enable via `hilbish.opts.fuzzy = true`)
+- Show indexes on cdr list and use ~ for home directory.
+- Fix doc command not displaying correct subdocs when using shorthand api doc access (`doc api hilbish.jobs` as an example)
+- `hilbish.messages` interface (details in [#219])
+- `hilbish.notification` signal when a message/notification is sent
+- `notifyJobFinish` opt to send a notification when background jobs are
+- `hilbish.goVersion` for the version of Go used to compile Hilbish.
+completed.
+- Allow numbered arg substitutions in aliases.
+  - Example: `hilbish.alias('hello', 'echo %1 says hello')` allows the user to run `hello hilbish`
+  which will output `hilbish says hello`.
+- Greenhouse
+  - Greenhouse is a pager library and program. Basic usage is `greenhouse <file>`
+  - Using this also brings enhancements to the `doc` command like easy
+  navigation of neighboring doc files.
+  Ctrl-N can be used for the table of contents, which views adjacent documentation.
+
+### Changed
+- Documentation for EVERYTHING has been improved, with more
+information added, code example, parameter details, etc.
+You can see the improvements!
+- Documentation has gotten an uplift in the `doc` command.
+This includes:
+  - Proper highlighting of code
+  - Paging (via Greenhouse)
+  - Highlighting more markdown things
+
+### Fixed
+- Fix panic when runner doesn't return a table
+- Fix edge case of crash on empty alias resolve
+- File completion on Windows
+- Job management commands work now
+- Fix infinite loop when navigating history without any history. [#252](https://github.com/Rosettea/Hilbish/issues/252)
+- Return the prefix when calling `hilbish.completions.call`. [#219](https://github.com/Rosettea/Hilbish/issues/219)
+- Replaced `sed` in-place editing with `grep` and `mv` for compatibility with BSD utils
+
+## [2.1.2] - 2022-04-10
+### Removed
+- Bad april fools code ;(
+
+## [2.1.1] - 2022-04-01
+### Added
+- Validation checks for command input
+- Improved runtime performance
+- Validate Lua code
+
+## [2.1.0] - 2022-02-10
+### Added
+- Documented custom userdata types (Job and Timer Objects)
+  - Coming with this fix is also adding the return types for some functions that were missing it
+- Added a dedicated input and dedicated outputs for commanders (sinks - info at `doc api commander`).
+- Local docs is used if one of Hilbish's branches is found
+- Return 1 exit code on doc not found
+- `hilbish.runner.getCurrent()` to get the current runner
+- Initialize Hilbish Lua API before handling signals
+
+### Fixed
+- `index` or `_index` subdocs should not show up anymore
+- `hilbish.which` not working correctly with aliases
+- Commanders not being able to pipe with commands or any related operator.
+- Resolve symlinks in completions
+- Updated `runner-mode` docs
+- Fix `hilbish.completion` functions panicking when empty input is provided
+
+## [2.0.1] - 2022-12-28
+### Fixed
+- Corrected documentation for hooks, removing outdated `command.no-perm`
+- Fixed an issue where `cd` with no args would not update the old pwd
+- Tiny documentation enhancements for the `hilbish.timer` interface
+
+## [2.0.0] - 2022-12-20
+**NOTES FOR USERS/PACKAGERS UPDATING:**
+- Hilbish now uses [Task] insead of Make for builds.
+- The doc format has been changed from plain text to markdown.
+**YOU MUST reinstall Hilbish to remove the duplicate, old docs.**
+- Hilbish will by default install to **`/usr/local`** instead of just `/usr/`
+when building via Task. This is mainly to avoid conflict of distro packages
+and local installs, and is the correct place when building from git either way.
+To keep Hilbish in `/usr`, you must have `PREFIX="/usr/"` when running `task build` or `task install`
+- Windows is no longer supported. It will build and run, but **will** have problems.
+If you want to help fix the situation, start a discussion or open an issue and contribute.
+
+[Task]: https://taskfile.dev/#/
+
+### Added
+- Inline hints, akin to fish and the others.
+To make a handler for hint text, you can set the `hilbish.hinter` function.
+For more info, look at its docs with the `doc hilbish` command.
+- Syntax highlighting function. To make a handler for it, set
+`hilbish.highlighter`. Same thing as the hinter, check `doc hilbish` for
+more info/docs.
+- Ctrl+K deletes from the cursor to the end of the line. ([#128](https://github.com/Rosettea/Hilbish/pull/128))
+- Alt+Backspace as an alternative of Ctrl+W to delete a word. ([#132](https://github.com/Rosettea/Hilbish/pull/132))
+- Enhanced timer API (`doc timers`)
+- Don't exit until intervals are stopped/finished when running a non interactive script.
+- Ctrl+D deletes character below cursor if line isn't empty instead of exiting.
+- Ctrl+Delete to forward delete a word.
+- Right prompt ([#140](https://github.com/Rosettea/Hilbish/pull/140))
+- Ctrl+_ to undo in Emacs input mode.
+- Emacs style forward/backward word keybinds ([#139](https://github.com/Rosettea/Hilbish/pull/139))
+- `hilbish.completion.call` to call a completion handler (`doc completions`)
+- `hilbish.completion.handler` to set a custom handler for completions. This
+is for everything/anything as opposed to just adding a single command completion. 
+[#122](https://github.com/Rosettea/Hilbish/issues/122)
+- `fs.abs(path)` to get absolute path.
+- Nature module (`doc nature`)
+- `hilbish.jobs.add(cmdstr, args, execPath)` to add a job to the job table.
+`cmdstr` would be user input, `args` is the args for the command (includes arg0)
+and `execPath` is absolute path to command executable
+- `job.add` hook is thrown when a job is added. acts as a unique hook for
+jobs
+- `hilbish.jobs.disown(id)` and `disown` builtin to disown a job. `disown`
+without arguments will disown the last job.
+- `hilbish.jobs.last()` returns the last added job.
+- Job output (stdout/stderr) can now be obtained via the `stdout` and `stderr`
+fields on a job object.
+- Documentation for jobs is now available via `doc jobs`.
+- `hilbish.alias.resolve(cmdstr)` to resolve a command alias.
+- `hilbish.opts` for shell options.
+- `hilbish.editor` interface for interacting with the line editor that
+Hilbish uses.
+- `hilbish.vim` interface to dynamically get/set vim registers.
+Example usage: `hilbish.vim.registers['a'] = 'hello'`. You can also
+get the mode with it via `hilbish.vim.mode`
+- `hilbish.version` interface for more info about Hilbish's version. This
+includes git commit, branch, and (new!!) release name.
+- Added `fg` and `bg` builtins
+- `job.foreground()` and `job.background()`, when `job` is a job object,
+foreground and backgrounds a job respectively.
+- Friendlier functions to the `hilbish.runner` interface, which also allow
+having and using multiple runners.
+- A few new functions to the `fs` module:
+  - `fs.basename(path)` gets the basename of path
+  - `fs.dir(path)` gets the directory part of path
+  - `fs.glob(pattern)` globs files and directories based on patterns
+  - `fs.join(dirs...)` joins directories by OS dir separator
+- .. and 2 properties
+  - `fs.pathSep` is the separator for filesystem paths and directories
+  - `fs.pathListSep` is the separator for $PATH env entries
+- Lua modules located in `hilbish.userDir.data .. '/hilbish/start'` (like `~/.local/share/hilbish/start/foo/init.lua`)
+will be ran on startup
+- `hilbish.init` hook, thrown after Hilbish has initialized Lua side
+- Message of the day on startup (`hilbish.motd`), mainly intended as quick
+small news pieces for releases. It is printed by default. To disable it,
+set `hilbish.opts.motd` to false.
+- `history` opt has been added and is true by default. Setting it to false
+disables commands being added to history.
+- `hilbish.rawInput` hook for input from the readline library
+- Completion of files in quotes
+- A new and "safer" event emitter has been added. This causes a performance deficit, but avoids a lot of
+random errors introduced with the new Lua runtime (see [#197])
+- `bait.release(name, catcher)` removes `handler` for the named `event`
+- `exec`, `clear` and `cat` builtin commands
+- `hilbish.cancel` hook thrown when user cancels input with Ctrl-C
+- 1st item on history is now inserted when history search menu is opened ([#148])
+- Documentation has been improved vastly!
+
+[#148]: https://github.com/Rosettea/Hilbish/issues/148
+[#197]: https://github.com/Rosettea/Hilbish/issues/197
+
+### Changed
+- **Breaking Change:** Upgraded to Lua 5.4.
+This is probably one of (if not the) biggest things in this release.
+To recap quickly on what matters (mostly):
+  - `os.execute` returns 3 values instead of 1 (but you should be using `hilbish.run`)
+  - I/O operations must be flushed (`io.flush()`)
+- **Breaking Change:** MacOS config paths now match Linux.
+- Overrides on the `hilbish` table are no longer permitted.
+- **Breaking Change:** Runner functions are now required to return a table.
+It can (at the moment) have 4 variables:
+  - `input` (user input)
+  - `exitCode` (exit code)
+  - `error` (error message)
+  - `continue` (whether to prompt for more input)
+User input has been added to the return to account for runners wanting to
+prompt for continued input, and to add it properly to history. `continue`
+got added so that it would be easier for runners to get continued input
+without having to actually handle it at all.  
+- **Breaking Change:** Job objects and timers are now Lua userdata instead
+of a table, so their functions require you to call them with a colon instead
+of a dot. (ie. `job.stop()` -> `job:stop()`)
+- All `fs` module functions which take paths now implicitly expand ~ to home.
+- **Breaking Change:** `hilbish.greeting` has been moved to an opt (`hilbish.opts.greeting`) and is
+always printed by default. To disable it, set the opt to false.
+- **Breaking Change:** `command.no-perm` hook has been replaced with `command.not-executable`
+- History is now fetched from Lua, which means users can override `hilbish.history`
+methods to make it act how they want.
+- `guide` has been removed. See the [website](https://rosettea.github.io/Hilbish/)
+for general tips and documentation
+
+### Fixed
+- If in Vim replace mode, input at the end of the line inserts instead of
+replacing the last character.
+- Make forward delete work how its supposed to.
+- Prompt refresh not working properly.
+- Crashing on input in xterm. ([#131](https://github.com/Rosettea/Hilbish/pull/131))
+- Make delete key work on st ([#131](https://github.com/Rosettea/Hilbish/pull/131))
+- `hilbish.login` being the wrong value.
+- Put full input in history if prompted for continued input
+- Don't put alias expanded command in history (sound familiar?)
+- Handle cases of stdin being nonblocking (in the case of [#136](https://github.com/Rosettea/Hilbish/issues/136))
+- Don't prompt for continued input if non interactive
+- Don't insert unhandled control keys.
+- Handle sh syntax error in alias
+- Use invert for completion menu selection highlight instead of specific
+colors. Brings an improvement on light themes, or themes that don't follow
+certain color rules.
+- Home/End keys now go to the actual start/end of the input.
+- Input getting cut off on enter in certain cases.
+- Go to the next line properly if input reaches end of terminal width.
+- Cursor position with CJK characters has been corrected ([#145](https://github.com/Rosettea/Hilbish/pull/145))
+- Files with same name as parent folder in completions getting cut off [#130](https://github.com/Rosettea/Hilbish/issues/130))
+- `hilbish.which` now works with commanders and aliases.
+- Background jobs no longer take stdin so they do not interfere with shell
+input.
+- Full name of completion entry is used instead of being cut off
+- Completions are fixed in cases where the query/line is an alias alone
+where it can also resolve to the beginning of command names.
+(reference [this commit](https://github.com/Rosettea/Hilbish/commit/2790982ad123115c6ddbc5764677fdca27668cea))
+for explanation.
+- Jobs now throw `job.done` and set running to false when stopped via
+Lua `job.stop` function.
+- Jobs are always started in sh exec handler now instead of only successful start.
+- SIGTERM is handled properly now, which means stopping jobs and timers.
+- Fix panic on trailing newline on pasted multiline text.
+- Completions will no longer be refreshed if the prompt refreshes while the
+menu is open.
+- Print error on search fail instead of panicking
+- Windows related fixes:
+  - `hilbish.dataDir` now has tilde (`~`) expanded.
+  - Arrow keys now work on Windows terminals.
+  - Escape codes now work.
+- Escape percentage symbols in completion entries, so you will no longer see
+an error of missing format variable
+- Fix an error with sh syntax in aliases
+- Prompt now works with east asian characters (CJK)
+- Set back the prompt to normal after exiting the continue prompt with ctrl-d
+- Take into account newline in input when calculating input width. Prevents
+extra reprinting of the prompt, but input with newlines inserted is still a problem
+- Put cursor at the end of input when exiting $EDITOR with Vim mode bind
+- Calculate width of virtual input properly (completion candidates)
+- Users can now tab complete files with spaces while quoted or with escaped spaces.
+This means a query of `Files\ to\ ` with file names of `Files to tab complete` and `Files to complete`
+will result in the files being completed.
+- Fixed grid menu display if cell width ends up being the width of the terminal
+- Cut off item names in grid menu if its longer than cell width
+- Fix completion search menu disappearing
+- Make binary completion work with bins that have spaces in the name
+- Completion paths having duplicated characters if it's escaped
+- Get custom completion command properly to call from Lua
+- Put proper command on the line when using up and down arrow keys to go through command history
+- Don't do anything if length of input rune slice is 0 ([commit for explanation](https://github.com/Rosettea/Hilbish/commit/8d40179a73fe5942707cd43f9c0463dee53eedd8))
+
+## [2.0.0-rc1] - 2022-09-14
+This is a pre-release version of Hilbish for testing. To see the changelog,
+refer to the `Unreleased` section of the [full changelog](CHANGELOG.md)
+(version 2.0.0 for future reference).
+
+## [1.2.0] - 2022-03-17
+### Added
+- Job Management additions
+  - `job.start` and `job.done` hooks (`doc hooks job`)
+  - `hilbish.jobs` interface (`get(id)` function gets a job object via `id`, `all()` gets all)
+- Customizable runner/exec mode
+  - However Hilbish runs interactive user input can now be changed Lua side (`doc runner-mode`)
+
+### Changed
+- `vimMode` doc is now `vim-mode`
+
+### Fixed
+- Make sure input which is supposed to go in history goes there
+- Cursor is right at the end of input on history search
+
+## [1.1.0] - 2022-03-17
+### Added
+- `hilbish.vimAction` hook (`doc vimMode actions`)
+- `command.not-executable` hook (will replace `command.no-perm` in a future release)
+
+### Fixed
+- Check if interactive before adding to history
+- Escape in vim mode exits all modes and not only insert
+- Make 2nd line in prompt empty if entire prompt is 1 line
+- Completion menu doesnt appear if there is only 1 result
+- Ignore SIGQUIT, which caused a panic unhandled
+- Remove hostname in greeting on Windows
+- Handle PATH binaries properly on Windows
+- Fix removal of dot in the beginning of folders/files that have them for file complete
+- Fix prompt being set to the continue prompt even when exited
+
+## [1.0.4] - 2022-03-12
+### Fixed
+- Panic when history directory doesn't exist
+
+## [1.0.3] - 2022-03-12
+### Fixed
+- Removed duplicate executable suggestions
+- User input is added to history now instead of what's ran by Hilbish
+- Formatting issue with prompt on no input
+
+## [1.0.2] - 2022-03-06
+### Fixed
+- Cases where Hilbish's history directory doesn't exist will no longer cause a panic
+
+## [1.0.1] - 2022-03-06
+### Fixed
+- Using `hilbish.appendPath` will no longer result in string spam (debugging thing left being)
+- Prompt gets set properly on startup
+
+## [1.0.0] - 2022-03-06
+### Added
+- MacOS is now officialy supported, default compile time vars have been added
+for it
+- Windows is properly supported as well
+- `catchOnce()` to bait - catches a hook once
+- `hilbish.aliases` interface - allows you to add, delete and list all aliases
+with Lua
+- `hilbish.appendPath()` can now take a table of arguments for ease of use
+- `hilbish.which(binName)` acts as the which builtin for other shells,
+it finds the path to `binName` in $PATH
+- Signal hooks `sigusr1` and `sigusr2` (unavailable on Windows)
+- Commands starting with a space won't be added to history
+- Vim input mode
+  - Hilbish's input mode for text can now be changed to either Emacs
+  (like it always was) or Vim via `hilbish.inputMode()`
+  - Changing Vim mode throws a `hilbish.vimMode` hook
+  - The current Vim mode is also accessible with the `hilbish.vimMode` property
+- Print errors in `hilbish.timeout()` and `hilbish.goro()` callbacks
+- `hilbish.exit` hook is thrown when Hilbish is going to exit
+- `hilbish.exitCode` property to get the exit code of the last executed command
+- `screenMain` and `screenAlt` functions have been added to Ansikit to switch
+to the terminal's main and alt buffer respectively
+
+### Fixed
+- Tab completion for executables
+- Stop interval (`hilbish.interval()`) when an error occurs
+- Errors in bait hooks no longer cause a panic, and remove the handler for the hook as well
+- Formatting of home dir to ~
+- Check if Hilbish is in interactive before trying to use its handlers for signals
+- Global `args` table when running as script is no longer userdata
+- Home dir is now added to recent dirs (the case of cd with no arg)
+- `index` subdoc will no longer appear
+- Alias expansion with quotes
+- Add full command to history in the case of incomplete input
+- `hilbish.exec()` now has a windows substitute
+- Fixed case of successful command after prompted for more input not writing to history
+- `command.exit` is thrown when sh input is incorrect and when command executed after continue
+prompt exits successfully
+
+### Changed
+- The minimal config is truly minimal now
+- Default config is no longer copied to user's config and is instead ran its location
+#### Breaking Changes
+(there were a lot...)
+- Change default SHLVL to 0 instead of 1
+- ~/.hilbishrc.lua will no longer be run by default, it now
+only uses the paths mentioned below.
+- Changed Hilbish's config path to something more suited
+according to the OS (`$XDG_CONFIG_HOME/hilbish/init.lua` on Linux,
+`~/Library/Application Support/hilbish/init.lua` on MacOS and
+(`%APPDATA%/hilbish/init.lua` on Windows). Previously on Unix-like it was
+`$XDG_CONFIG_HOME/hilbish/hilbishrc.lua`
+- The history path has been changed to a better suited path.
+On Linux, it is `$XDG_DATA_HOME/hilbish/.hilbish-history` and for others it is
+the config path.
+- `hilbish.xdg` no longer exists, use `hilbish.userDir` instead,
+as it functions the same but is OS agnostic
+- `hilbish.flag()` has been removed
+- `~/.hprofile.lua` has been removed, instead check in your config if `hilbish.login`
+is true
+- `hilbish.complete()` has had a slight refactor to fit with the new readline library.
+It now expects a table of "completion groups" which are just tables with the
+`type` and `items` keys. Here is a (more or less) complete example of how it works now:
+	```lua
+	hilbish.complete('command.git', function()
+		return {
+			{
+				items = {
+					'add',
+					'clone'
+				},
+				type = 'grid'
+			},
+			{
+				items = {
+					['--git-dir'] = {'Description of flag'},
+					'-c'
+				},
+				type = 'list'
+			}
+		}
+	end)
+	```
+	Completer functions are now also expected to handle subcommands/subcompletions
+
+## [0.7.1] - 2021-11-22
+### Fixed
+- Tab complete absolute paths to binaries properly
+- Allow execution of absolute paths to binaries (https://github.com/Rosettea/Hilbish/commit/06272778f85dad04e0e7abffc78a5b9b0cebd067 regression)
 
 ## [0.7.0] - 2021-11-22
 ### Added
@@ -104,9 +567,9 @@ An absolutely massive release. Probably the biggest yet, includes a bunch of fix
 ### Added
 
 - `-n` flag, which checks Lua for syntax errors without running it
-- `exec(command)` function, acts like the `exec` builtin in sh 
+- `exec(command)` function, acts like the `exec` builtin in sh
     - Example: `exec 'awesome'` in an .xinitrc file with Hilbish as shebang
-- Commands from commander can now `return` an exit code 
+- Commands from commander can now `return` an exit code
 ```lua
 commander.register('false', function()
 return 1
@@ -119,7 +582,7 @@ When `false` is run, it will have the exit code of `1`, this is shorter/easier t
 - Recursive aliases
     - At the moment this only works for the first argument
 - Hilbish can now be used with Hilbiline if compiled to do so (currently only for testing purposes)
-- `goro(func)` runs a `func`tion in a goroutine. With channels that gopher-lua also provides, one can do parallelism and concurrency in Lua (but go style). 
+- `goro(func)` runs a `func`tion in a goroutine. With channels that gopher-lua also provides, one can do parallelism and concurrency in Lua (but go style).
     - `coroutine` no those dont exist they dont matter `goro` is easier
 - `cd -` will change to the previous directory
 - `hilbish.cwd()` gets the current working directory
@@ -158,7 +621,7 @@ When `false` is run, it will have the exit code of `1`, this is shorter/easier t
 
 ### Added
 - Ctrl C in the prompt now cancels/clear input (I've needed this for so long also)
-- Made Hilbish act like a login shell on login 
+- Made Hilbish act like a login shell on login
     - If Hilbish is the login shell, or the `-l`/`--login` flags are used, Hilbish will use an additional `~/.hprofile.lua` file, you can use this to set environment variables once on login
 - `-c` has been added to run a single command (this works exactly like being in the prompt would, so Lua works as well)
 - `-i` (also `--interactive`) has been added to force Hilbish to be an interactive shell in cases where it usually wont be (like with `-c`)
@@ -166,13 +629,13 @@ When `false` is run, it will have the exit code of `1`, this is shorter/easier t
 - Added a `mulitline` hook that's thrown when in the continue/multiline prompt
 - Added `appendPath` function to append a directory to `$PATH`
     - `~` will be expanded to `$HOME` as well
-- A utility `string.split` function is now added 
+- A utility `string.split` function is now added
     - `string.split(str, delimiter)`
 - Added a `_user` variable to easily get current user's name
 
 ### Changed
 
-- **BREAKING Change**: [Lunacolors](https://github.com/Hilbis/Lunacolors) has replaced ansikit for formatting colors, which means the format function has been removed from ansikit and moved to Lunacolors. 
+- **BREAKING Change**: [Lunacolors](https://github.com/Hilbis/Lunacolors) has replaced ansikit for formatting colors, which means the format function has been removed from ansikit and moved to Lunacolors.
     - Users must replace ansikit with `lunacolors` in their config files
 - A getopt-like library is now used for command line flag parsing
 - `cd` builtin now supports using environment variables
@@ -284,6 +747,24 @@ This input for example will prompt for more input to complete:
 
 First "stable" release of Hilbish.
 
+[2.2.3]: https://github.com/Rosettea/Hilbish/compare/v2.2.2...v2.2.3
+[2.2.2]: https://github.com/Rosettea/Hilbish/compare/v2.2.1...v2.2.2
+[2.2.1]: https://github.com/Rosettea/Hilbish/compare/v2.2.0...v2.2.1
+[2.2.0]: https://github.com/Rosettea/Hilbish/compare/v2.1.0...v2.2.0
+[2.1.2]: https://github.com/Rosettea/Hilbish/compare/v2.1.1...v2.1.2
+[2.1.1]: https://github.com/Rosettea/Hilbish/compare/v2.1.0...v2.1.1
+[2.1.0]: https://github.com/Rosettea/Hilbish/compare/v2.0.1...v2.1.0
+[2.0.1]: https://github.com/Rosettea/Hilbish/compare/v2.0.0...v2.0.1
+[2.0.0]: https://github.com/Rosettea/Hilbish/compare/v1.2.0...v2.0.0
+[2.0.0-rc1]: https://github.com/Rosettea/Hilbish/compare/v1.2.0...v2.0.0-rc1
+[1.2.0]: https://github.com/Rosettea/Hilbish/compare/v1.1.4...v1.2.0
+[1.1.0]: https://github.com/Rosettea/Hilbish/compare/v1.0.4...v1.1.0
+[1.0.4]: https://github.com/Rosettea/Hilbish/compare/v1.0.3...v1.0.4
+[1.0.3]: https://github.com/Rosettea/Hilbish/compare/v1.0.2...v1.0.3
+[1.0.2]: https://github.com/Rosettea/Hilbish/compare/v1.0.1...v1.0.2
+[1.0.1]: https://github.com/Rosettea/Hilbish/compare/v1.0.0...v1.0.1
+[1.0.0]: https://github.com/Rosettea/Hilbish/compare/v0.7.1...v1.0.0
+[0.7.1]: https://github.com/Rosettea/Hilbish/compare/v0.7.0...v0.7.1
 [0.7.0]: https://github.com/Rosettea/Hilbish/compare/v0.6.1...v0.7.0
 [0.6.1]: https://github.com/Rosettea/Hilbish/compare/v0.6.0...v0.6.1
 [0.6.0]: https://github.com/Rosettea/Hilbish/compare/v0.5.1...v0.6.0
@@ -296,5 +777,5 @@ First "stable" release of Hilbish.
 [0.2.0]: https://github.com/Rosettea/Hilbish/compare/v0.1.2...v0.2.0
 [0.1.2]: https://github.com/Rosettea/Hilbish/compare/v0.1.1...v0.1.2
 [0.1.1]: https://github.com/Rosettea/Hilbish/compare/v0.1.0...v0.1.1
-[0.1.0]: https://github.com/Rosettea/Hilbish/compare/v0.0.12...v0.1.0 
+[0.1.0]: https://github.com/Rosettea/Hilbish/compare/v0.0.12...v0.1.0
 [0.0.12]: https://github.com/Rosettea/Hilbish/releases/tag/v0.0.12

CONTRIBUTING.md

@@ -11,37 +11,39 @@ Use GitHub Issues to report any bugs or to request any features
 that may be useful to *anyone* else.
 
 Check [currently open issues](https://github.com/Rosettea/Hilbish/issues)
-and [closed ones](https://github.com/Rosettea/Hilbish/issues?q=is%3Aissue+is%3Aclosed) to make sure someone else hasn't already made the issue.
+and [closed ones](https://github.com/Rosettea/Hilbish/issues?q=is%3Aissue+is%3Aclosed)
+to make sure someone else hasn't already made the issue.
 
 For bug reports, be sure to include:
 - Hilbish Version (`hilbish -v`)
 - Ways to reproduce
 
 ## Code
-For any code contributions (Lua and/or Go), you should follow these
-rules:  
+For any code contributions (Lua and/or Go), you should follow these rules:  
 - Tab size 4 indentation
-- In Lua prefer no braces `()` if the function takes 1 argument
-- Use camelCase for function names
+- 80 line column limit, unless it breaks code or anything like that
+- In Lua prefer no braces `()` if the function takes 1 string argument
+- Use camelCase
 
 ### Making the Pull Request
 1. Ensure that any new install or build dependencies are documented in
-the README.md and PR request.
+the README.md and pull request.
 
-2. Say in the pull request details the changes to the shell,
-this includes useful file locations and breaking changes.
+2. Mention any and all changes, feature additons, removals, etc. This includes
+useful file locations and breaking changes. Document them in the [changelog](CHANGELOG.md)
+in the pull request.
 
-3. The versioning scheme we use is [SemVer](http://semver.org/) and the
-commit scheme we use is
-[Conventional Commits](https://www.conventionalcommits.org/en/v1.0.0/).
-Please document any backwards incompatible changes and be sure to name
-your commits correctly.
+3. We use [Semver](http://semver.org/) for versioning and
+[Conventional Commits](https://www.conventionalcommits.org/en/v1.0.0/)
+for commit messages. Please document any breaking changes and be sure to
+write proper commits, or your pull request will not be considered.
 
-4. Finally, make the pull request to the **dev** branch.
+4. Finally, make the pull request.
 
 ## Finding Issues to Contribute to
 You can check out the [help wanted](https://github.com/Rosettea/Hilbish/issues?q=is%3Aissue+is%3Aopen+label%3A%22help+wanted%22+)
 labels to figure out what we need your help working on.  
 
-The [up for grabs](https://github.com/Rosettea/Hilbish/issues?q=is%3Aissue+is%3Aopen+label%3A%22up+for+grabs%22+) labeled issues are low hanging fruit that should be
-easy for anyone. You can use this to get started on contributing!
+The [up for grabs](https://github.com/Rosettea/Hilbish/issues?q=is%3Aissue+is%3Aopen+label%3A%22up+for+grabs%22+)
+labeled issues are low hanging fruit that should be easy for anyone. You can
+use this to get started on contributing!

LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2021 Hilbis Development
+Copyright (c) 2021-2023 Rosettea
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

Makefile

@@ -1,34 +0,0 @@
-PREFIX ?= /usr
-DESTDIR ?=
-BINDIR ?= $(PREFIX)/bin
-LIBDIR ?= $(PREFIX)/share/hilbish
-
-build:
-	@go build -ldflags "-s -w"
-
-dev:
-	@go build -ldflags "-s -w -X main.version=$(shell git describe --tags)"
-
-hilbiline:
-	@go build -ldflags "-s -w -X main.version=$(shell git describe --tags)+hilbiline" -tags hilbiline
-
-install:
-	@install -v -d "$(DESTDIR)$(BINDIR)/" && install -m 0755 -v hilbish "$(DESTDIR)$(BINDIR)/hilbish"
-	@mkdir -p "$(DESTDIR)$(LIBDIR)"
-	@cp libs docs preload.lua .hilbishrc.lua "$(DESTDIR)$(LIBDIR)" -r
-	@grep "$(DESTDIR)$(BINDIR)/hilbish" -qxF /etc/shells || echo "$(DESTDIR)$(BINDIR)/hilbish" >> /etc/shells
-	@echo "Hilbish Installed"
-
-uninstall:
-	@rm -vrf \
-			"$(DESTDIR)$(BINDIR)/hilbish" \
-			"$(DESTDIR)$(LIBDIR)"
-	@sed -i '/hilbish/d' /etc/shells
-	@echo "Hilbish Uninstalled"
-
-clean:
-	@go clean
-
-all: build install
-
-.PHONY: install uninstall build dev hilbiline clean

README.md

@@ -1,84 +1,47 @@
-<div align="center">
-	<img src="./assets/hilbish-flower.png" width=128><br>
-	<img src="./assets/hilbish-text.png" width=256><br><br>
-	<blockquote>
-	🌺 The flower shell. A comfy and nice little shell for Lua users and fans!
-	</blockquote><br>
-	<p align="center">
-		<img alt="GitHub commit activity" src="https://img.shields.io/github/commit-activity/m/Rosettea/Hilbish?style=flat-square">
-		<img alt="GitHub commits since latest release (by date)" src="https://img.shields.io/github/commits-since/Rosettea/Hilbish/latest?style=flat-square">
-		<img alt="GitHub contributors" src="https://img.shields.io/github/contributors/Rosettea/Hilbish?style=flat-square"><br>
-		<a href="https://github.com/Rosettea/Hilbish/issues?q=is%3Aissue+is%3Aopen+label%3A%22help+wanted%22"><img src="https://img.shields.io/github/issues/Hilbis/Hilbish/help%20wanted?style=flat-square&color=green" alt="help wanted"></a>
-		<a href="https://github.com/Rosettea/Hilbish/blob/master/LICENSE"><img alt="GitHub license" src="https://img.shields.io/github/license/Rosettea/Hilbish?style=flat-square"></a>
-		<a href="https://discord.gg/3PDdcQz"><img alt="Discord" src="https://img.shields.io/discord/732357621503229962?color=blue&style=flat-square"></a>
-	</p>
-</div>
+<img src="./assets/hilbish-logo-and-text.png" width=512><br>
+<blockquote>
+🌓 The Moon-powered shell! A comfy and extensible shell for Lua fans! 🌺 ✨
+</blockquote>
 
-Hilbish is a new, Unix-like shell which uses Lua as its configuration language.
-It's decently fast for interactive use and includes a bunch of utility functions and features
-to make your life in a terminal easier.
+<img alt="GitHub commit activity" src="https://img.shields.io/github/commit-activity/m/Rosettea/Hilbish?style=flat-square"><img alt="GitHub commits since latest release (by date)" src="https://img.shields.io/github/commits-since/Rosettea/Hilbish/latest?style=flat-square"><img alt="GitHub contributors" src="https://img.shields.io/github/contributors/Rosettea/Hilbish?style=flat-square"><br>
+<a href="https://github.com/Rosettea/Hilbish/issues?q=is%3Aissue+is%3Aopen+label%3A%22help+wanted%22"><img src="https://img.shields.io/github/issues/Hilbis/Hilbish/help%20wanted?style=flat-square&color=green" alt="help wanted"></a>
+<a href="https://github.com/Rosettea/Hilbish/blob/master/LICENSE"><img alt="GitHub license" src="https://img.shields.io/github/license/Rosettea/Hilbish?style=flat-square"></a>
+<a href="https://discord.gg/3PDdcQz"><img alt="Discord" src="https://img.shields.io/discord/732357621503229962?color=blue&style=flat-square"></a>
+<br>
+
+Hilbish is an extensible shell designed to be highly customizable.
+It is configured in Lua and provides a good range of features.
+It aims to be easy to use for anyone but powerful enough for
+those who need it.
+
+The motivation for choosing Lua was that its simpler and better to use
+than old shell script. It's fine for basic interactive shell uses,
+but that's the only place Hilbish has shell script; everything else is Lua
+and aims to be infinitely configurable. If something isn't, open an issue!
 
 # Screenshots
 <div align="center">
-<img src="gallery/default.png"><br><br>
-<img src="gallery/terminal.png"><br><br>
+<img src="gallery/tab.png">
 <img src="gallery/pillprompt.png">
 </div>
 
-# Installation
-**NOTE:** Hilbish is currently only officially supported and tested on Linux
+# Getting Hilbish
+**NOTE:** Hilbish is not guaranteed to work properly on Windows, starting
+from the 2.0 version. It will still be able to compile, but functionality
+may be lacking. If you want to contribute to make the situation better,
+comment on the Windows discussion.
 
-### Prebuilt binaries
-Binaries are provided for the latest commit.  
+You can check the [install page](https://rosettea.github.io/Hilbish/install/)
+on the website for distributed binaries from GitHub or other package repositories.
+Otherwise, continue reading for steps on compiling.
 
-**Note that these use Hilbiline, not readline, and may be missing functionality
-(moving the cursor, proper unicode support and backspace working properly)**  
+## Prerequisites
+- [Go 1.17+](https://go.dev)
+- [Task](https://taskfile.dev/installation/) (**Go on the hyperlink here to see Task's install method for your OS.**)
 
-Click on the checkmark (or x) near the commit hash, then details for your platform  
-<br><img src="https://modeus.is-inside.me/dyr8UGGq.png"><br>
-
-Then click on the artifacts drop down, and download artifact for your platform,
-like what is highlighted in the screenshot.  
-<br><img src="https://modeus.is-inside.me/KJ0Puceb.png"><br>
-
-### AUR
-![AUR maintainer](https://img.shields.io/aur/maintainer/hilbish?logo=arch-linux&style=flat-square)  
-Arch Linux users can install Hilbish from the AUR with the following command:  
-```sh
-yay -S hilbish
-```
-Or from the latest `master` commit with:  
-```sh
-yay -S hilbish-git
-```
-
-### Nixpkgs
-Nix/NixOS users can install Hilbish from the central repository, nixpkgs, through the usual ways.
-
-If you're new to nix you should probably read up on how to do that [here](https://nixos.wiki/wiki/Cheatsheet).
-
-### Manual Build
-#### Prerequisites
-- [Go 1.16+](https://go.dev)
-- GNU Readline
-
-On Fedora or other RPM based distros, readline can be installed with:  
-```
-sudo dnf install readline-devel
-```  
-
-On Debian/Ubuntu and distros based on them, it can be installed with:  
-```
-sudo apt install libreadline-dev
-```
-
-On Arch Linux, it can be installed with:
-```
-sudo pacman -S readline
-```
-
-#### Build
-First, clone Hilbish:
+## Build
+First, clone Hilbish. The recursive is required, as some Lua libraries
+are submodules.  
 ```sh
 git clone --recursive https://github.com/Rosettea/Hilbish
 cd Hilbish
@@ -87,31 +50,28 @@ go get -d ./...
 
 To build, run:
 ```
-make dev
+task
 ```  
 
 Or, if you want a stable branch, run these commands:
 ```
 git checkout $(git describe --tags `git rev-list --tags --max-count=1`)
-make build
+task build
 ```  
 
-After you did all that, run `sudo make install` to install Hilbish globally.
+After you did all that, run `sudo task install` to install Hilbish globally.
 
 # Contributing
-Any kind of contributions to Hilbish are welcome!
-Read [CONTRIBUTING.md](CONTRIBUTING.md) before getting started.
+Any kind of contributions are welcome! Hilbish is very easy to contribute to.
+Read [CONTRIBUTING.md](CONTRIBUTING.md) as a guideline to doing so.
 
-##### Thanks to everyone below who's contributed!
-<a href="https://github.com/Hilbis/Hilbish/graphs/contributors">
-  <img src="https://contrib.rocks/image?repo=Hilbis/Hilbish" />
+**Thanks to everyone below who's contributed!**  
+<a href="https://github.com/Rosettea/Hilbish/graphs/contributors">
+  <img src="https://contrib.rocks/image?repo=Rosettea/Hilbish" />
 </a>
 
 *Made with [contributors-img](https://contrib.rocks).*
 
 # License
-Hilbish is licensed under the MIT license!
-Read the [license here](LICENSE) for more info. 
-
-Images in the [assets](assets/) folder are under CC-BY-SA 4.0
-
+Hilbish is licensed under the [MIT license](LICENSE).  
+[Images and assets](assets/) are licensed under CC-BY-SA 4.0

Taskfile.yaml

@@ -0,0 +1,47 @@
+# https://taskfile.dev
+
+version: '3'
+
+vars:
+  PREFIX: '{{default "/usr/local" .PREFIX}}'
+  bindir__: '{{.PREFIX}}/bin'
+  BINDIR: '{{default .bindir__ .BINDIR}}'
+  libdir__: '{{.PREFIX}}/share/hilbish'
+  LIBDIR: '{{default .libdir__ .LIBDIR}}'
+  goflags__: '-ldflags "-s -w -X main.dataDir={{.LIBDIR}}"'
+  GOFLAGS: '{{default .goflags__ .GOFLAGS}}'
+
+tasks:
+  default:
+    cmds:
+      - go build {{.GOFLAGS}}
+    vars:
+      GOFLAGS: '-ldflags "-s -w -X main.dataDir={{.LIBDIR}} -X main.gitCommit=$(git rev-parse --short HEAD) -X main.gitBranch=$(git rev-parse --abbrev-ref HEAD)"'
+
+  default-nocgo:
+    cmds:
+      - CGO_ENABLED=0 go build {{.GOFLAGS}}
+    vars:
+      GOFLAGS: '-ldflags "-s -w -X main.dataDir={{.LIBDIR}} -X main.gitCommit=$(git rev-parse --short HEAD) -X main.gitBranch=$(git rev-parse --abbrev-ref HEAD)"'
+
+  build:
+    cmds:
+      - go build {{.GOFLAGS}}
+
+  build-nocgo:
+    cmds:
+      - CGO_ENABLED=0 go build {{.GOFLAGS}}
+
+  install:
+    cmds:
+      - install -v -d "{{.DESTDIR}}{{.BINDIR}}/" && install -m 0755 -v hilbish "{{.DESTDIR}}{{.BINDIR}}/hilbish"
+      - mkdir -p "{{.DESTDIR}}{{.LIBDIR}}"
+      - cp -r libs docs emmyLuaDocs nature .hilbishrc.lua {{.DESTDIR}}{{.LIBDIR}}
+      - grep -qxF "{{.DESTDIR}}{{.BINDIR}}/hilbish" /etc/shells || echo "{{.DESTDIR}}{{.BINDIR}}/hilbish" >> /etc/shells
+
+  uninstall:
+    cmds:
+      - rm -vrf
+        "{{.DESTDIR}}{{.BINDIR}}/hilbish"
+        "{{.DESTDIR}}{{.LIBDIR}}"
+      - grep -v 'hilbish' /etc/shells > /tmp/shells.hilbish_uninstall && mv /tmp/shells.hilbish_uninstall /etc/shells

aliases.go

@@ -0,0 +1,173 @@
+package main
+
+import (
+	"regexp"
+	"strconv"
+	"strings"
+	"sync"
+
+	"hilbish/util"
+
+	rt "github.com/arnodel/golua/runtime"
+)
+
+var aliases *aliasModule
+
+type aliasModule struct {
+	aliases map[string]string
+	mu *sync.RWMutex
+}
+
+// initialize aliases map
+func newAliases() *aliasModule {
+	return &aliasModule{
+		aliases: make(map[string]string),
+		mu: &sync.RWMutex{},
+	}
+}
+
+func (a *aliasModule) Add(alias, cmd string) {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+
+	a.aliases[alias] = cmd
+}
+
+func (a *aliasModule) All() map[string]string {
+	return a.aliases
+}
+
+func (a *aliasModule) Delete(alias string) {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+
+	delete(a.aliases, alias)
+}
+
+func (a *aliasModule) Resolve(cmdstr string) string {
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+
+	arg, _ := regexp.Compile(`[\\]?%\d+`)
+
+	args, _ := splitInput(cmdstr)
+	if len(args) == 0 {
+		// this shouldnt reach but...????
+		return cmdstr
+	}
+
+	for a.aliases[args[0]] != "" {
+		alias := a.aliases[args[0]]
+		alias = arg.ReplaceAllStringFunc(alias, func(a string) string {
+			idx, _ := strconv.Atoi(a[1:])
+			if strings.HasPrefix(a, "\\") || idx == 0 {
+				return strings.TrimPrefix(a, "\\")
+			}
+
+			if idx + 1 > len(args) {
+				return a
+			}
+			val := args[idx]
+			args = cut(args, idx)
+			cmdstr = strings.Join(args, " ")
+
+			return val
+		})
+		
+		cmdstr = alias + strings.TrimPrefix(cmdstr, args[0])
+		cmdArgs, _ := splitInput(cmdstr)
+		args = cmdArgs
+
+		if a.aliases[args[0]] == alias {
+			break
+		}
+		if a.aliases[args[0]] != "" {
+			continue
+		}
+	}
+
+	return cmdstr
+}
+
+// lua section
+
+// #interface aliases
+// command aliasing
+// The alias interface deals with all command aliases in Hilbish.
+func (a *aliasModule) Loader(rtm *rt.Runtime) *rt.Table {
+	// create a lua module with our functions
+	hshaliasesLua := map[string]util.LuaExport{
+		"add": util.LuaExport{hlalias, 2, false},
+		"list": util.LuaExport{a.luaList, 0, false},
+		"del": util.LuaExport{a.luaDelete, 1, false},
+		"resolve": util.LuaExport{a.luaResolve, 1, false},
+	}
+
+	mod := rt.NewTable()
+	util.SetExports(rtm, mod, hshaliasesLua)
+
+	return mod
+}
+
+// #interface aliases
+// add(alias, cmd)
+// This is an alias (ha) for the [hilbish.alias](../#alias) function.
+// --- @param alias string
+// --- @param cmd string
+func _hlalias() {}
+
+// #interface aliases
+// list() -> table[string, string]
+// Get a table of all aliases, with string keys as the alias and the value as the command.
+// #returns table[string, string]
+/*
+#example
+hilbish.aliases.add('hi', 'echo hi')
+
+local aliases = hilbish.aliases.list()
+-- -> {hi = 'echo hi'}
+#example
+*/
+func (a *aliasModule) luaList(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
+	aliasesList := rt.NewTable()
+	for k, v := range a.All() {
+		aliasesList.Set(rt.StringValue(k), rt.StringValue(v))
+	}
+
+	return c.PushingNext1(t.Runtime, rt.TableValue(aliasesList)), nil
+}
+
+// #interface aliases
+// delete(name)
+// Removes an alias.
+// #param name string
+func (a *aliasModule) luaDelete(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
+	if err := c.Check1Arg(); err != nil {
+		return nil, err
+	}
+	alias, err := c.StringArg(0)
+	if err != nil {
+		return nil, err
+	}
+	a.Delete(alias)
+
+	return c.Next(), nil
+}
+
+// #interface aliases
+// resolve(alias) -> string?
+// Resolves an alias to its original command. Will thrown an error if the alias doesn't exist.
+// #param alias string
+// #returns string
+func (a *aliasModule) luaResolve(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
+	if err := c.Check1Arg(); err != nil {
+		return nil, err
+	}
+	alias, err := c.StringArg(0)
+	if err != nil {
+		return nil, err
+	}
+	resolved := a.Resolve(alias)
+
+	return c.PushingNext1(t.Runtime, rt.StringValue(resolved)), nil
+}

api.go

@@ -0,0 +1,817 @@
+// the core Hilbish API
+// The Hilbish module includes the core API, containing
+// interfaces and functions which directly relate to shell functionality.
+// #field ver The version of Hilbish
+// #field goVersion The version of Go that Hilbish was compiled with
+// #field user Username of the user
+// #field host Hostname of the machine
+// #field dataDir Directory for Hilbish data files, including the docs and default modules
+// #field interactive Is Hilbish in an interactive shell?
+// #field login Is Hilbish the login shell?
+// #field vimMode Current Vim input mode of Hilbish (will be nil if not in Vim input mode)
+// #field exitCode Exit code of the last executed command
+package main
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"io"
+	"os"
+	"os/exec"
+	"runtime"
+	"strings"
+	"syscall"
+	"time"
+
+	"hilbish/util"
+
+	rt "github.com/arnodel/golua/runtime"
+	"github.com/arnodel/golua/lib/packagelib"
+	"github.com/arnodel/golua/lib/iolib"
+	"github.com/maxlandon/readline"
+	"mvdan.cc/sh/v3/interp"
+)
+
+var exports = map[string]util.LuaExport{
+	"alias": {hlalias, 2, false},
+	"appendPath": {hlappendPath, 1, false},
+	"complete": {hlcomplete, 2, false},
+	"cwd": {hlcwd, 0, false},
+	"exec": {hlexec, 1, false},
+	"runnerMode": {hlrunnerMode, 1, false},
+	"goro": {hlgoro, 1, true},
+	"highlighter": {hlhighlighter, 1, false},
+	"hinter": {hlhinter, 1, false},
+	"multiprompt": {hlmultiprompt, 1, false},
+	"prependPath": {hlprependPath, 1, false},
+	"prompt": {hlprompt, 1, true},
+	"inputMode": {hlinputMode, 1, false},
+	"interval": {hlinterval, 2, false},
+	"read": {hlread, 1, false},
+	"run": {hlrun, 1, true},
+	"timeout": {hltimeout, 2, false},
+	"which": {hlwhich, 1, false},
+}
+
+var hshMod *rt.Table
+var hilbishLoader = packagelib.Loader{
+	Load: hilbishLoad,
+	Name: "hilbish",
+}
+
+func hilbishLoad(rtm *rt.Runtime) (rt.Value, func()) {
+	mod := rt.NewTable()
+
+	util.SetExports(rtm, mod, exports)
+	hshMod = mod
+
+	host, _ := os.Hostname()
+	username := curuser.Username
+
+	if runtime.GOOS == "windows" {
+		username = strings.Split(username, "\\")[1] // for some reason Username includes the hostname on windows
+	}
+
+	util.SetField(rtm, mod, "ver", rt.StringValue(getVersion()))
+	util.SetField(rtm, mod, "goVersion", rt.StringValue(runtime.Version()))
+	util.SetField(rtm, mod, "user", rt.StringValue(username))
+	util.SetField(rtm, mod, "host", rt.StringValue(host))
+	util.SetField(rtm, mod, "home", rt.StringValue(curuser.HomeDir))
+	util.SetField(rtm, mod, "dataDir", rt.StringValue(dataDir))
+	util.SetField(rtm, mod, "interactive", rt.BoolValue(interactive))
+	util.SetField(rtm, mod, "login", rt.BoolValue(login))
+	util.SetField(rtm, mod, "vimMode", rt.NilValue)
+	util.SetField(rtm, mod, "exitCode", rt.IntValue(0))
+
+	// hilbish.userDir table
+	hshuser := userDirLoader(rtm)
+	mod.Set(rt.StringValue("userDir"), rt.TableValue(hshuser))
+
+	// hilbish.os table
+	hshos := hshosLoader(rtm)
+	mod.Set(rt.StringValue("os"), rt.TableValue(hshos))
+
+	// hilbish.aliases table
+	aliases = newAliases()
+	aliasesModule := aliases.Loader(rtm)
+	mod.Set(rt.StringValue("aliases"), rt.TableValue(aliasesModule))
+
+	// hilbish.history table
+	historyModule := lr.Loader(rtm)
+	mod.Set(rt.StringValue("history"), rt.TableValue(historyModule))
+
+	// hilbish.completion table
+	hshcomp := completionLoader(rtm)
+	// TODO: REMOVE "completion" AND ONLY USE "completions" WITH AN S
+	mod.Set(rt.StringValue("completion"), rt.TableValue(hshcomp))
+	mod.Set(rt.StringValue("completions"), rt.TableValue(hshcomp))
+
+	// hilbish.runner table
+	runnerModule := runnerModeLoader(rtm)
+	mod.Set(rt.StringValue("runner"), rt.TableValue(runnerModule))
+
+	// hilbish.jobs table
+	jobs = newJobHandler()
+	jobModule := jobs.loader(rtm)
+	mod.Set(rt.StringValue("jobs"), rt.TableValue(jobModule))
+
+	// hilbish.timers table
+	timers = newTimersModule()
+	timersModule := timers.loader(rtm)
+	mod.Set(rt.StringValue("timers"), rt.TableValue(timersModule))
+
+	editorModule := editorLoader(rtm)
+	mod.Set(rt.StringValue("editor"), rt.TableValue(editorModule))
+
+	versionModule := rt.NewTable()
+	util.SetField(rtm, versionModule, "branch", rt.StringValue(gitBranch))
+	util.SetField(rtm, versionModule, "full", rt.StringValue(getVersion()))
+	util.SetField(rtm, versionModule, "commit", rt.StringValue(gitCommit))
+	util.SetField(rtm, versionModule, "release", rt.StringValue(releaseName))
+	mod.Set(rt.StringValue("version"), rt.TableValue(versionModule))
+
+	pluginModule := moduleLoader(rtm)
+	mod.Set(rt.StringValue("module"), rt.TableValue(pluginModule))
+
+	return rt.TableValue(mod), nil
+}
+
+func getenv(key, fallback string) string {
+    value := os.Getenv(key)
+    if len(value) == 0 {
+        return fallback
+    }
+    return value
+}
+
+func setVimMode(mode string) {
+	util.SetField(l, hshMod, "vimMode", rt.StringValue(mode))
+	hooks.Emit("hilbish.vimMode", mode)
+}
+
+func unsetVimMode() {
+	util.SetField(l, hshMod, "vimMode", rt.NilValue)
+}
+
+func handleStream(v rt.Value, strms *streams, errStream bool) error {
+	ud, ok := v.TryUserData()
+	if !ok {
+		return errors.New("expected metatable argument")
+	}
+
+	val := ud.Value()
+	var varstrm io.Writer
+	if f, ok := val.(*iolib.File); ok {
+		varstrm = f.Handle()
+	}
+
+	if f, ok := val.(*sink); ok {
+		varstrm = f.writer
+	}
+
+	if varstrm == nil {
+		return errors.New("expected either a sink or file")
+	}
+
+	if errStream {
+		strms.stderr = varstrm
+	} else {
+		strms.stdout = varstrm
+	}
+
+	return nil
+}
+
+// run(cmd, streams) -> exitCode (number), stdout (string), stderr (string)
+// Runs `cmd` in Hilbish's shell script interpreter.
+// The `streams` parameter specifies the output and input streams the command should use.
+// For example, to write command output to a sink.
+// As a table, the caller can directly specify the standard output, error, and input
+// streams of the command with the table keys `out`, `err`, and `input` respectively.
+// As a boolean, it specifies whether the command should use standard output or return its output streams.
+// #param cmd string
+// #param streams table|boolean
+// #returns number, string, string
+// #example
+/*
+// This code is the same as `ls -l | wc -l`
+local fs = require 'fs'
+local pr, pw = fs.pipe()
+hilbish.run('ls -l', {
+	stdout = pw,
+	stderr = pw,
+})
+
+pw:close()
+
+hilbish.run('wc -l', {
+	stdin = pr
+})
+*/
+// #example
+func hlrun(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
+	// TODO: ON BREAKING RELEASE, DO NOT ACCEPT `streams` AS A BOOLEAN.
+	if err := c.Check1Arg(); err != nil {
+		return nil, err
+	}
+	cmd, err := c.StringArg(0)
+	if err != nil {
+		return nil, err
+	}
+
+	strms := &streams{}
+	var terminalOut bool
+	if len(c.Etc()) != 0 {
+		tout := c.Etc()[0]
+
+		var ok bool
+		terminalOut, ok = tout.TryBool()
+		if !ok {
+			luastreams, ok := tout.TryTable()
+			if !ok {
+				return nil, errors.New("bad argument to run (expected boolean or table, got " + tout.TypeName() + ")")
+			}
+
+			handleStream(luastreams.Get(rt.StringValue("out")), strms, false)
+			handleStream(luastreams.Get(rt.StringValue("err")), strms, true)
+
+			stdinstrm := luastreams.Get(rt.StringValue("input"))
+			if !stdinstrm.IsNil() {
+				ud, ok := stdinstrm.TryUserData()
+				if !ok {
+					return nil, errors.New("bad type as run stdin stream (expected userdata as either sink or file, got " + stdinstrm.TypeName() + ")")
+				}
+
+				val := ud.Value()
+				var varstrm io.Reader
+				if f, ok := val.(*iolib.File); ok {
+					varstrm = f.Handle()
+				}
+
+				if f, ok := val.(*sink); ok {
+					varstrm = f.reader
+				}
+
+				if varstrm == nil {
+					return nil, errors.New("bad type as run stdin stream (expected userdata as either sink or file)")
+				}
+
+				strms.stdin = varstrm
+			}
+		} else {
+			if !terminalOut {
+				strms = &streams{
+					stdout: new(bytes.Buffer),
+					stderr: new(bytes.Buffer),
+				}
+			}
+		}
+	}
+
+	var exitcode uint8
+	stdout, stderr, err := execCommand(cmd, strms)
+
+	if code, ok := interp.IsExitStatus(err); ok {
+		exitcode = code
+	} else if err != nil {
+		exitcode = 1
+	}
+
+	var stdoutStr, stderrStr string
+	if stdoutBuf, ok := stdout.(*bytes.Buffer); ok {
+		stdoutStr = stdoutBuf.String()
+	}
+	if stderrBuf, ok := stderr.(*bytes.Buffer); ok {
+		stderrStr = stderrBuf.String()
+	}
+
+	return c.PushingNext(t.Runtime, rt.IntValue(int64(exitcode)), rt.StringValue(stdoutStr), rt.StringValue(stderrStr)), nil
+}
+
+// cwd() -> string
+// Returns the current directory of the shell.
+// #returns string
+func hlcwd(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
+	cwd, _ := os.Getwd()
+
+	return c.PushingNext1(t.Runtime, rt.StringValue(cwd)), nil
+}
+
+
+// read(prompt) -> input (string)
+// Read input from the user, using Hilbish's line editor/input reader.
+// This is a separate instance from the one Hilbish actually uses.
+// Returns `input`, will be nil if Ctrl-D is pressed, or an error occurs.
+// #param prompt? string Text to print before input, can be empty.
+// #returns string|nil
+func hlread(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
+	luaprompt := c.Arg(0)
+	if typ := luaprompt.Type(); typ != rt.StringType && typ != rt.NilType {
+		return nil, errors.New("expected #1 to be a string")
+	}
+	prompt, ok := luaprompt.TryString()
+	if !ok {
+		// if we are here and `luaprompt` is not a string, it's nil
+		// substitute with an empty string
+		prompt = ""
+	}
+	
+	lualr := &lineReader{
+		rl: readline.NewInstance(),
+	}
+	lualr.SetPrompt(prompt)
+
+	input, err := lualr.Read()
+	if err != nil {
+		return c.Next(), nil
+	}
+
+	return c.PushingNext1(t.Runtime, rt.StringValue(input)), nil
+}
+
+/*
+prompt(str, typ)
+Changes the shell prompt to the provided string.
+There are a few verbs that can be used in the prompt text.
+These will be formatted and replaced with the appropriate values.
+`%d` - Current working directory
+`%u` - Name of current user
+`%h` - Hostname of device
+#param str string
+#param typ? string Type of prompt, being left or right. Left by default.
+#example
+-- the default hilbish prompt without color
+hilbish.prompt '%u %d ∆'
+-- or something of old:
+hilbish.prompt '%u@%h :%d $'
+-- prompt: user@hostname: ~/directory $
+#example
+*/
+func hlprompt(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
+	err := c.Check1Arg()
+	if err != nil {
+		return nil, err
+	}
+	p, err := c.StringArg(0)
+	if err != nil {
+		return nil, err
+	}
+	typ := "left"
+	// optional 2nd arg
+	if len(c.Etc()) != 0 {
+		ltyp := c.Etc()[0]
+		var ok bool
+		typ, ok = ltyp.TryString()
+		if !ok {
+			return nil, errors.New("bad argument to run (expected string, got " + ltyp.TypeName() + ")")
+		}
+	}
+
+	switch typ {
+		case "left":
+			prompt = p
+			lr.SetPrompt(fmtPrompt(prompt))
+		case "right": lr.SetRightPrompt(fmtPrompt(p))
+		default: return nil, errors.New("expected prompt type to be right or left, got " + typ)
+	}
+
+	return c.Next(), nil
+}
+
+// multiprompt(str)
+// Changes the text prompt when Hilbish asks for more input.
+// This will show up when text is incomplete, like a missing quote
+// #param str string
+/*
+#example
+--[[
+imagine this is your text input:
+user ~ ∆ echo "hey
+
+but there's a missing quote! hilbish will now prompt you so the terminal
+will look like:
+user ~ ∆ echo "hey
+--> ...!"
+
+so then you get 
+user ~ ∆ echo "hey
+--> ...!"
+hey ...!
+]]--
+hilbish.multiprompt '-->'
+#example
+*/
+func hlmultiprompt(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
+	if err := c.Check1Arg(); err != nil {
+		return nil, err
+	}
+	prompt, err := c.StringArg(0)
+	if err != nil {
+		return nil, err
+	}
+	multilinePrompt = prompt
+
+	return c.Next(), nil
+}
+
+// alias(cmd, orig)
+// Sets an alias, with a name of `cmd` to another command.
+// #param cmd string Name of the alias
+// #param orig string Command that will be aliased
+/*
+#example
+-- With this, "ga file" will turn into "git add file"
+hilbish.alias('ga', 'git add')
+
+-- Numbered substitutions are supported here!
+hilbish.alias('dircount', 'ls %1 | wc -l')
+-- "dircount ~" would count how many files are in ~ (home directory).
+#example
+*/
+func hlalias(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
+	if err := c.CheckNArgs(2); err != nil {
+		return nil, err
+	}
+	cmd, err := c.StringArg(0)
+	if err != nil {
+		return nil, err
+	}
+	orig, err := c.StringArg(1)
+	if err != nil {
+		return nil, err
+	}
+
+	aliases.Add(cmd, orig)
+
+	return c.Next(), nil
+}
+
+// appendPath(dir)
+// Appends the provided dir to the command path (`$PATH`)
+// #param dir string|table Directory (or directories) to append to path
+/*
+#example
+hilbish.appendPath '~/go/bin'
+-- Will add ~/go/bin to the command path.
+
+-- Or do multiple:
+hilbish.appendPath {
+	'~/go/bin',
+	'~/.local/bin'
+}
+#example
+*/
+func hlappendPath(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
+	if err := c.Check1Arg(); err != nil {
+		return nil, err
+	}
+	arg := c.Arg(0)
+
+	// check if dir is a table or a string
+	if arg.Type() == rt.TableType {
+		util.ForEach(arg.AsTable(), func(k rt.Value, v rt.Value) {
+			if v.Type() == rt.StringType {
+				appendPath(v.AsString())
+			}
+		})
+	} else if arg.Type() == rt.StringType {
+		appendPath(arg.AsString())
+	} else {
+		return nil, errors.New("bad argument to appendPath (expected string or table, got " + arg.TypeName() + ")")
+	}
+
+	return c.Next(), nil
+}
+
+func appendPath(dir string) {
+	dir = strings.Replace(dir, "~", curuser.HomeDir, 1)
+	pathenv := os.Getenv("PATH")
+
+	// if dir isnt already in $PATH, add it
+	if !strings.Contains(pathenv, dir) {
+		os.Setenv("PATH", pathenv + string(os.PathListSeparator) + dir)
+	}
+}
+
+// exec(cmd)
+// Replaces the currently running Hilbish instance with the supplied command.
+// This can be used to do an in-place restart.
+// #param cmd string
+func hlexec(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
+	if err := c.Check1Arg(); err != nil {
+		return nil, err
+	}
+	cmd, err := c.StringArg(0)
+	if err != nil {
+		return nil, err
+	}
+	cmdArgs, _ := splitInput(cmd)
+	if runtime.GOOS != "windows" {
+		cmdPath, err := exec.LookPath(cmdArgs[0])
+		if err != nil {
+			fmt.Println(err)
+			// if we get here, cmdPath will be nothing
+			// therefore nothing will run
+		}
+
+		// syscall.Exec requires an absolute path to a binary
+		// path, args, string slice of environments
+		syscall.Exec(cmdPath, cmdArgs, os.Environ())
+	} else {
+		cmd := exec.Command(cmdArgs[0], cmdArgs[1:]...)
+		cmd.Stdout = os.Stdout
+		cmd.Stderr = os.Stderr
+		cmd.Stdin = os.Stdin
+		cmd.Run()
+		os.Exit(0)
+	}
+
+	return c.Next(), nil
+}
+
+// goro(fn)
+// Puts `fn` in a Goroutine.
+// This can be used to run any function in another thread at the same time as other Lua code.
+// **NOTE: THIS FUNCTION MAY CRASH HILBISH IF OUTSIDE VARIABLES ARE ACCESSED.**
+// **This is a limitation of the Lua runtime.**
+// #param fn function
+func hlgoro(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
+	if err := c.Check1Arg(); err != nil {
+		return nil, err
+	}
+	fn, err := c.ClosureArg(0)
+	if err != nil {
+		return nil, err
+	}
+
+	// call fn
+	go func() {
+		defer func() {
+			if r := recover(); r != nil {
+				// do something here?
+			}
+		}()
+
+		_, err := rt.Call1(l.MainThread(), rt.FunctionValue(fn), c.Etc()...)
+		if err != nil {
+			fmt.Fprintln(os.Stderr, "Error in goro function:\n\n", err)
+		}
+	}()
+
+	return c.Next(), nil
+}
+
+// timeout(cb, time) -> @Timer
+// Executed the `cb` function after a period of `time`.
+// This creates a Timer that starts ticking immediately.
+// #param cb function
+// #param time number Time to run in milliseconds.
+// #returns Timer
+func hltimeout(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
+	if err := c.CheckNArgs(2); err != nil {
+		return nil, err
+	}
+	cb, err := c.ClosureArg(0)
+	if err != nil {
+		return nil, err
+	}
+	ms, err := c.IntArg(1)
+	if err != nil {
+		return nil, err
+	}
+
+	interval := time.Duration(ms) * time.Millisecond
+	timer := timers.create(timerTimeout, interval, cb)
+	timer.start()
+	
+	return c.PushingNext1(t.Runtime, rt.UserDataValue(timer.ud)), nil
+}
+
+// interval(cb, time) -> @Timer
+// Runs the `cb` function every specified amount of `time`.
+// This creates a timer that ticking immediately.
+// #param cb function
+// #param time number Time in milliseconds.
+// #return Timer
+func hlinterval(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
+	if err := c.CheckNArgs(2); err != nil {
+		return nil, err
+	}
+	cb, err := c.ClosureArg(0)
+	if err != nil {
+		return nil, err
+	}
+	ms, err := c.IntArg(1)
+	if err != nil {
+		return nil, err
+	}
+
+	interval := time.Duration(ms) * time.Millisecond
+	timer := timers.create(timerInterval, interval, cb)
+	timer.start()
+
+	return c.PushingNext1(t.Runtime, rt.UserDataValue(timer.ud)), nil
+}
+
+// complete(scope, cb)
+// Registers a completion handler for the specified scope.
+// A `scope` is expected to be `command.<cmd>`,
+// replacing <cmd> with the name of the command (for example `command.git`).
+// The documentation for completions, under Features/Completions or `doc completions`
+// provides more details.
+// #param scope string
+// #param cb function
+/*
+#example
+-- This is a very simple example. Read the full doc for completions for details.
+hilbish.complete('command.sudo', function(query, ctx, fields)
+	if #fields == 0 then
+		-- complete for commands
+		local comps, pfx = hilbish.completion.bins(query, ctx, fields)
+		local compGroup = {
+			items = comps, -- our list of items to complete
+			type = 'grid' -- what our completions will look like.
+		}
+
+		return {compGroup}, pfx
+	end
+
+	-- otherwise just be boring and return files
+
+	local comps, pfx = hilbish.completion.files(query, ctx, fields)
+	local compGroup = {
+		items = comps,
+		type = 'grid'
+	}
+
+	return {compGroup}, pfx
+end)
+#example
+*/
+func hlcomplete(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
+	scope, cb, err := util.HandleStrCallback(t, c)
+	if err != nil {
+		return nil, err
+	}
+	luaCompletions[scope] = cb
+
+	return c.Next(), nil
+}
+
+// prependPath(dir)
+// Prepends `dir` to $PATH.
+// #param dir string
+func hlprependPath(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
+	if err := c.Check1Arg(); err != nil {
+		return nil, err
+	}
+	dir, err := c.StringArg(0)
+	if err != nil {
+		return nil, err
+	}
+	dir = strings.Replace(dir, "~", curuser.HomeDir, 1)
+	pathenv := os.Getenv("PATH")
+
+	// if dir isnt already in $PATH, add in
+	if !strings.Contains(pathenv, dir) {
+		os.Setenv("PATH", dir + string(os.PathListSeparator) + pathenv)
+	}
+
+	return c.Next(), nil
+}
+
+// which(name) -> string
+// Checks if `name` is a valid command.
+// Will return the path of the binary, or a basename if it's a commander.
+// #param name string
+// #returns string
+func hlwhich(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
+	if err := c.Check1Arg(); err != nil {
+		return nil, err
+	}
+	name, err := c.StringArg(0)
+	if err != nil {
+		return nil, err
+	}
+
+	// itll return either the original command or what was passed
+	// if name isnt empty its not an issue
+	alias := aliases.Resolve(name)
+	cmd := strings.Split(alias, " ")[0]
+
+	// check for commander
+	if cmds.Commands[cmd] != nil {
+		// they dont resolve to a path, so just send the cmd
+		return c.PushingNext1(t.Runtime, rt.StringValue(cmd)), nil
+	}
+
+	path, err := exec.LookPath(cmd)
+	if err != nil {
+		return c.Next(), nil
+	}
+
+	return c.PushingNext1(t.Runtime, rt.StringValue(path)), nil
+}
+
+// inputMode(mode)
+// Sets the input mode for Hilbish's line reader.
+// `emacs` is the default. Setting it to `vim` changes behavior of input to be
+// Vim-like with modes and Vim keybinds.
+// #param mode string Can be set to either `emacs` or `vim`
+func hlinputMode(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
+	if err := c.Check1Arg(); err != nil {
+		return nil, err
+	}
+	mode, err := c.StringArg(0)
+	if err != nil {
+		return nil, err
+	}
+
+	switch mode {
+		case "emacs":
+			unsetVimMode()
+			lr.rl.InputMode = readline.Emacs
+		case "vim":
+			setVimMode("insert")
+			lr.rl.InputMode = readline.Vim
+		default:
+			return nil, errors.New("inputMode: expected vim or emacs, received " + mode)
+	}
+
+	return c.Next(), nil
+}
+
+// runnerMode(mode)
+// Sets the execution/runner mode for interactive Hilbish.
+// This determines whether Hilbish wll try to run input as Lua
+// and/or sh or only do one of either.
+// Accepted values for mode are hybrid (the default), hybridRev (sh first then Lua),
+// sh, and lua. It also accepts a function, to which if it is passed one
+// will call it to execute user input instead.
+// Read [about runner mode](../features/runner-mode) for more information.
+// #param mode string|function
+func hlrunnerMode(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
+	if err := c.Check1Arg(); err != nil {
+		return nil, err
+	}
+	mode := c.Arg(0)
+
+	switch mode.Type() {
+		case rt.StringType:
+			switch mode.AsString() {
+				case "hybrid", "hybridRev", "lua", "sh": runnerMode = mode
+				default: return nil, errors.New("execMode: expected either a function or hybrid, hybridRev, lua, sh. Received " + mode.AsString())
+			}
+		case rt.FunctionType: runnerMode = mode
+		default: return nil, errors.New("execMode: expected either a function or hybrid, hybridRev, lua, sh. Received " + mode.TypeName())
+	}
+
+	return c.Next(), nil
+}
+
+// hinter(line, pos)
+// The command line hint handler. It gets called on every key insert to
+// determine what text to use as an inline hint. It is passed the current
+// line and cursor position. It is expected to return a string which is used
+// as the text for the hint. This is by default a shim. To set hints,
+// override this function with your custom handler.
+// #param line string
+// #param pos number Position of cursor in line. Usually equals string.len(line)
+/*
+#example
+-- this will display "hi" after the cursor in a dimmed color.
+function hilbish.hinter(line, pos)
+	return 'hi'
+end
+#example
+*/
+func hlhinter(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
+	return c.Next(), nil
+}
+
+// highlighter(line)
+// Line highlighter handler.
+// This is mainly for syntax highlighting, but in reality could set the input
+// of the prompt to *display* anything. The callback is passed the current line
+// and is expected to return a line that will be used as the input display.
+// Note that to set a highlighter, one has to override this function.
+// #example
+// --This code will highlight all double quoted strings in green.
+// function hilbish.highlighter(line)
+//    return line:gsub('"%w+"', function(c) return lunacolors.green(c) end)
+// end
+// #example
+// #param line string
+func hlhighlighter(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
+	if err := c.Check1Arg(); err != nil {
+		return nil, err
+	}
+
+	line, err := c.StringArg(0)
+	if err != nil {
+		return nil, err
+	}
+
+	return c.PushingNext1(t.Runtime, rt.StringValue(line)), nil
+}

cmd/docgen/docgen.go

@@ -7,14 +7,300 @@ import (
 	"go/doc"
 	"go/parser"
 	"go/token"
+	"regexp"
 	"strings"
 	"os"
+	"sync"
+
+	md "github.com/atsushinee/go-markdown-generator/doc"
 )
 
-// feel free to clean this up
-// it works, dont really care about the code
+var header = `---
+title: %s %s
+description: %s
+layout: doc
+menu:
+  docs:
+    parent: "API"
+---
+
+`
+
+type emmyPiece struct {
+	DocPiece *docPiece
+	Annotations []string
+	Params []string // we only need to know param name to put in function
+	FuncName string
+}
+
+type module struct {
+	Types []docPiece
+	Docs []docPiece
+	Fields []docPiece
+	Properties []docPiece
+	ShortDescription string
+	Description string
+	ParentModule string
+	HasInterfaces bool
+	HasTypes bool
+}
+
+type param struct{
+	Name string
+	Type string
+	Doc []string
+}
+
+type docPiece struct {
+	Doc []string
+	FuncSig string
+	FuncName string
+	Interfacing string
+	ParentModule string
+	GoFuncName string
+	IsInterface bool
+	IsMember bool
+	IsType bool
+	Fields []docPiece
+	Properties []docPiece
+	Params []param
+	Tags map[string][]tag
+}
+
+type tag struct {
+	id string
+	fields []string
+	startIdx int
+}
+
+var docs = make(map[string]module)
+var interfaceDocs = make(map[string]module)
+var emmyDocs = make(map[string][]emmyPiece)
+var typeTable = make(map[string][]string) // [0] = parentMod, [1] = interfaces
+var prefix = map[string]string{
+	"main": "hl",
+	"hilbish": "hl",
+	"fs": "f",
+	"commander": "c",
+	"bait": "b",
+	"terminal": "term",
+}
+
+func getTagsAndDocs(docs string) (map[string][]tag, []string) {
+	pts := strings.Split(docs, "\n")
+	parts := []string{}
+	tags := make(map[string][]tag)
+
+	for idx, part := range pts {
+		if strings.HasPrefix(part, "#") {
+			tagParts := strings.Split(strings.TrimPrefix(part, "#"), " ")
+			if tags[tagParts[0]] == nil {
+				var id string
+				if len(tagParts) > 1 {
+					id = tagParts[1]
+				}
+				tags[tagParts[0]] = []tag{
+					{id: id, startIdx: idx},
+				}
+				if len(tagParts) >= 2 {
+					tags[tagParts[0]][0].fields = tagParts[2:]
+				}
+			} else {
+				if tagParts[0] == "example" {
+					exampleIdx := tags["example"][0].startIdx
+					exampleCode := pts[exampleIdx+1:idx]
+
+					tags["example"][0].fields = exampleCode
+					parts = strings.Split(strings.Replace(strings.Join(parts, "\n"), strings.TrimPrefix(strings.Join(exampleCode, "\n"), "#example\n"), "", -1), "\n")
+					continue
+				}
+
+				fleds := []string{}
+				if len(tagParts) >= 2 {
+					fleds = tagParts[2:]
+				}
+				tags[tagParts[0]] = append(tags[tagParts[0]], tag{
+					id: tagParts[1],
+					fields: fleds,
+				})
+			}
+		} else {
+			parts = append(parts, part)
+		}
+	}
+
+	return tags, parts
+}
+
+func docPieceTag(tagName string, tags map[string][]tag) []docPiece {
+	dps := []docPiece{}
+	for _, tag := range tags[tagName] {
+		dps = append(dps, docPiece{
+			FuncName: tag.id,
+			Doc: tag.fields,
+		})
+	}
+
+	return dps
+}
+
+func setupDocType(mod string, typ *doc.Type) *docPiece {
+	docs := strings.TrimSpace(typ.Doc)
+	tags, doc := getTagsAndDocs(docs)
+
+	if tags["type"] == nil {
+		return nil
+	}
+	inInterface := tags["interface"] != nil
+
+	var interfaces string
+	typeName := strings.ToUpper(string(typ.Name[0])) + typ.Name[1:]
+	typeDoc := []string{}
+
+	if inInterface {
+		interfaces = tags["interface"][0].id
+	}
+
+	fields := docPieceTag("field", tags)
+	properties := docPieceTag("property", tags)
+
+	for _, d := range doc {
+		if strings.HasPrefix(d, "---") {
+			// TODO: document types in lua
+			/*
+			emmyLine := strings.TrimSpace(strings.TrimPrefix(d, "---"))
+			emmyLinePieces := strings.Split(emmyLine, " ")
+			emmyType := emmyLinePieces[0]
+			if emmyType == "@param" {
+				em.Params = append(em.Params, emmyLinePieces[1])
+			}
+			if emmyType == "@vararg" {
+				em.Params = append(em.Params, "...") // add vararg
+			}
+			em.Annotations = append(em.Annotations, d)
+			*/
+		} else {
+			typeDoc = append(typeDoc, d)
+		}
+	}
+
+	var isMember bool
+	if tags["member"] != nil {
+		isMember = true
+	}
+	parentMod := mod
+	dps := &docPiece{
+		Doc: typeDoc,
+		FuncName: typeName,
+		Interfacing: interfaces,
+		IsInterface: inInterface,
+		IsMember: isMember,
+		IsType: true,
+		ParentModule: parentMod,
+		Fields: fields,
+		Properties: properties,
+		Tags: tags,
+	}
+
+	typeTable[strings.ToLower(typeName)] = []string{parentMod, interfaces}
+
+	return dps
+}
+
+func setupDoc(mod string, fun *doc.Func) *docPiece {
+	docs := strings.TrimSpace(fun.Doc)
+	tags, parts := getTagsAndDocs(docs)
+
+	// i couldnt fit this into the condition below for some reason so here's a goto!
+	if tags["member"] != nil {
+		goto start
+	}
+
+	if (!strings.HasPrefix(fun.Name, prefix[mod]) && tags["interface"] == nil) || (strings.ToLower(fun.Name) == "loader" && tags["interface"] == nil) {
+		return nil
+	}
+
+start:
+	inInterface := tags["interface"] != nil
+	var interfaces string
+	funcsig := parts[0]
+	doc := parts[1:]
+	funcName := strings.TrimPrefix(fun.Name, prefix[mod])
+	funcdoc := []string{}
+
+	if inInterface {
+		interfaces = tags["interface"][0].id
+		funcName = interfaces + "." + strings.Split(funcsig, "(")[0]
+	}
+	em := emmyPiece{FuncName: funcName}
+
+	fields := docPieceTag("field", tags)
+	properties := docPieceTag("property", tags)
+	var params []param
+	if paramsRaw := tags["param"]; paramsRaw != nil {
+		params = make([]param, len(paramsRaw))
+		for i, p := range paramsRaw {
+			params[i] = param{
+				Name: p.id,
+				Type: p.fields[0],
+				Doc: p.fields[1:],
+			}
+		}
+	}
+
+	for _, d := range doc {
+		if strings.HasPrefix(d, "---") {
+			emmyLine := strings.TrimSpace(strings.TrimPrefix(d, "---"))
+			emmyLinePieces := strings.Split(emmyLine, " ")
+			emmyType := emmyLinePieces[0]
+			if emmyType == "@param" {
+				em.Params = append(em.Params, emmyLinePieces[1])
+			}
+			if emmyType == "@vararg" {
+				em.Params = append(em.Params, "...") // add vararg
+			}
+			em.Annotations = append(em.Annotations, d)
+		} else {
+			funcdoc = append(funcdoc, d)
+		}
+	}
+
+	var isMember bool
+	if tags["member"] != nil {
+		isMember = true
+	}
+	var parentMod string
+	if inInterface {
+		parentMod = mod
+	}
+	dps := &docPiece{
+		Doc: funcdoc,
+		FuncSig: funcsig,
+		FuncName: funcName,
+		Interfacing: interfaces,
+		GoFuncName: strings.ToLower(fun.Name),
+		IsInterface: inInterface,
+		IsMember: isMember,
+		ParentModule: parentMod,
+		Fields: fields,
+		Properties: properties,
+		Params: params,
+		Tags: tags,
+	}
+	if strings.HasSuffix(dps.GoFuncName, strings.ToLower("loader")) {
+		dps.Doc = parts
+	}
+	em.DocPiece = dps
+			
+	emmyDocs[mod] = append(emmyDocs[mod], em)
+	return dps
+}
+
 func main() {
 	fset := token.NewFileSet()
+	os.Mkdir("docs", 0777)
+	os.Mkdir("docs/api", 0777)
+	os.Mkdir("emmyLuaDocs", 0777)
 
 	dirs := []string{"./"}
 	filepath.Walk("golibs/", func (path string, info os.FileInfo, err error) error {
@@ -37,44 +323,356 @@ func main() {
 		}
 	}
 
-	prefix := map[string]string{
-		"main": "hsh",
-		"hilbish": "hl",
-		"fs": "f",
-		"commander": "c",
-		"bait": "b",
-		"terminal": "term",
-	}
-	docs := make(map[string][]string)
-
+	interfaceModules := make(map[string]*module)
 	for l, f := range pkgs {
 		p := doc.New(f, "./", doc.AllDecls)
-		for _, t := range p.Funcs {
-			mod := l
-			if strings.HasPrefix(t.Name, "hl") { mod = "hilbish" }
-			if !strings.HasPrefix(t.Name, prefix[mod]) || t.Name == "Loader" { continue }
-			parts := strings.Split(t.Doc, "\n")
-			funcsig := parts[0]
-			doc := parts[1:]
-
-			docs[mod] = append(docs[mod], funcsig + " > " + strings.Join(doc, "\n"))
+		pieces := []docPiece{}
+		typePieces := []docPiece{}
+		mod := l
+		if mod == "main" {
+			mod = "hilbish"
 		}
-		for _, t := range p.Types {
-			for _, m := range t.Methods {
-				if !strings.HasPrefix(m.Name, prefix[l]) || m.Name == "Loader" { continue }
-				parts := strings.Split(m.Doc, "\n")
-				funcsig := parts[0]
-				doc := parts[1:]
+		var hasInterfaces bool
+		for _, t := range p.Funcs {
+			piece := setupDoc(mod, t)
+			if piece == nil {
+				continue
+			}
 
-				docs[l] = append(docs[l], funcsig + " > " + strings.Join(doc, "\n"))
+			pieces = append(pieces, *piece)
+			if piece.IsInterface {
+				hasInterfaces = true
 			}
 		}
+		for _, t := range p.Types {
+			typePiece := setupDocType(mod, t)
+			if typePiece != nil {
+				typePieces = append(typePieces, *typePiece)
+				if typePiece.IsInterface {
+					hasInterfaces = true
+				}
+			}
+
+			for _, m := range t.Methods {
+				piece := setupDoc(mod, m)
+				if piece == nil {
+					continue
+				}
+
+				pieces = append(pieces, *piece)
+				if piece.IsInterface {
+					hasInterfaces = true
+				}
+			}
+		}
+
+		tags, descParts := getTagsAndDocs(strings.TrimSpace(p.Doc))
+		shortDesc := descParts[0]
+		desc := descParts[1:]
+		filteredPieces := []docPiece{}
+		filteredTypePieces := []docPiece{}
+		for _, piece := range pieces {
+			if !piece.IsInterface {
+				filteredPieces = append(filteredPieces, piece)
+				continue
+			}
+
+			modname := piece.ParentModule + "." + piece.Interfacing
+			if interfaceModules[modname] == nil {
+				interfaceModules[modname] = &module{
+					ParentModule: piece.ParentModule,
+				}
+			}
+
+			if strings.HasSuffix(piece.GoFuncName, strings.ToLower("loader")) {
+				shortDesc := piece.Doc[0]
+				desc := piece.Doc[1:]
+				interfaceModules[modname].ShortDescription = shortDesc
+				interfaceModules[modname].Description = strings.Join(desc, "\n")
+				interfaceModules[modname].Fields = piece.Fields
+				interfaceModules[modname].Properties = piece.Properties
+				continue
+			}
+
+			interfaceModules[modname].Docs = append(interfaceModules[modname].Docs, piece)
+		}
+
+		for _, piece := range typePieces {
+			if !piece.IsInterface {
+				filteredTypePieces = append(filteredTypePieces, piece)
+				continue
+			}
+
+			modname := piece.ParentModule + "." + piece.Interfacing
+			if interfaceModules[modname] == nil {
+				interfaceModules[modname] = &module{
+					ParentModule: piece.ParentModule,
+				}
+			}
+
+			interfaceModules[modname].Types = append(interfaceModules[modname].Types, piece)
+		}
+
+		docs[mod] = module{
+			Types: filteredTypePieces,
+			Docs: filteredPieces,
+			ShortDescription: shortDesc,
+			Description: strings.Join(desc, "\n"),
+			HasInterfaces: hasInterfaces,
+			Properties: docPieceTag("property", tags),
+			Fields: docPieceTag("field", tags),
+		}
 	}
 
-	for mod, v := range docs {
-		if mod == "main" { mod = "global" }
-		os.Mkdir("docs", 0777)
-		f, _ := os.Create("docs/" + mod + ".txt")
-		f.WriteString(strings.Join(v, "\n") + "\n")
+	for key, mod := range interfaceModules {
+		docs[key] = *mod
 	}
+
+	var wg sync.WaitGroup
+	wg.Add(len(docs) * 2)
+
+	for mod, v := range docs {
+		docPath := "docs/api/" + mod + ".md"
+		if v.HasInterfaces {
+			os.Mkdir("docs/api/" + mod, 0777)
+			os.Remove(docPath) // remove old doc path if it exists
+			docPath = "docs/api/" + mod + "/_index.md"
+		}
+		if v.ParentModule != "" {
+			docPath = "docs/api/" + v.ParentModule + "/" + mod + ".md"
+		}
+
+		go func(modname, docPath string, modu module) {
+			defer wg.Done()
+			modOrIface := "Module"
+			if modu.ParentModule != "" {
+				modOrIface = "Module"
+			}
+			lastHeader := ""
+
+			f, _ := os.Create(docPath)
+			f.WriteString(fmt.Sprintf(header, modOrIface, modname, modu.ShortDescription))
+			typeTag, _ := regexp.Compile(`\B@\w+`)
+			modDescription := typeTag.ReplaceAllStringFunc(strings.Replace(strings.Replace(modu.Description, "<", `\<`, -1), "{{\\<", "{{<", -1), func(typ string) string {
+				typName := typ[1:]
+				typLookup := typeTable[strings.ToLower(typName)]
+				ifaces := typLookup[0] + "." + typLookup[1] + "/"
+				if typLookup[1] == "" {
+					ifaces = ""
+				}
+				linkedTyp := fmt.Sprintf("/Hilbish/docs/api/%s/%s#%s", typLookup[0], ifaces, strings.ToLower(typName))
+				return fmt.Sprintf(`<a href="%s" style="text-decoration: none;">%s</a>`, linkedTyp, typName)
+			})
+			f.WriteString(fmt.Sprintf("## Introduction\n%s\n\n", modDescription))
+			if len(modu.Docs) != 0 {
+				funcCount := 0
+				for _, dps := range modu.Docs {
+					if dps.IsMember {
+						continue
+					}
+					funcCount++
+				}
+
+				f.WriteString("## Functions\n")
+				lastHeader = "functions"
+
+				mdTable := md.NewTable(funcCount, 2)
+				mdTable.SetTitle(0, "")
+				mdTable.SetTitle(1, "")
+
+				diff := 0
+				for i, dps := range modu.Docs {
+					if dps.IsMember {
+						diff++
+						continue
+					}
+
+					mdTable.SetContent(i - diff, 0, fmt.Sprintf(`<a href="#%s">%s</a>`, dps.FuncName, dps.FuncSig))
+					if len(dps.Doc) == 0 {
+						fmt.Printf("WARNING! Function %s on module %s has no documentation!\n", dps.FuncName, modname)
+					} else {
+						mdTable.SetContent(i - diff, 1, dps.Doc[0])
+					}
+				}
+				f.WriteString(mdTable.String())
+				f.WriteString("\n")
+			}
+
+			if len(modu.Fields) != 0 {
+				f.WriteString("## Static module fields\n")
+
+				mdTable := md.NewTable(len(modu.Fields), 2)
+				mdTable.SetTitle(0, "")
+				mdTable.SetTitle(1, "")
+
+
+				for i, dps := range modu.Fields {
+					mdTable.SetContent(i, 0, dps.FuncName)
+					mdTable.SetContent(i, 1, strings.Join(dps.Doc, " "))
+				}
+				f.WriteString(mdTable.String())
+				f.WriteString("\n")
+			}
+			if len(modu.Properties) != 0 {
+				f.WriteString("## Object properties\n")
+
+				mdTable := md.NewTable(len(modu.Fields), 2)
+				mdTable.SetTitle(0, "")
+				mdTable.SetTitle(1, "")
+
+
+				for i, dps := range modu.Properties {
+					mdTable.SetContent(i, 0, dps.FuncName)
+					mdTable.SetContent(i, 1, strings.Join(dps.Doc, " "))
+				}
+				f.WriteString(mdTable.String())
+				f.WriteString("\n")
+			}
+
+			if len(modu.Docs) != 0 {
+				if lastHeader != "functions" {
+					f.WriteString("## Functions\n")
+				}
+				for _, dps := range modu.Docs {
+					if dps.IsMember {
+						continue
+					}
+					f.WriteString(fmt.Sprintf("<hr>\n<div id='%s'>", dps.FuncName))
+					htmlSig := typeTag.ReplaceAllStringFunc(strings.Replace(modname + "." + dps.FuncSig, "<", `\<`, -1), func(typ string) string {
+						typName := typ[1:]
+						typLookup := typeTable[strings.ToLower(typName)]
+						ifaces := typLookup[0] + "." + typLookup[1] + "/"
+						if typLookup[1] == "" {
+							ifaces = ""
+						}
+						linkedTyp := fmt.Sprintf("/Hilbish/docs/api/%s/%s#%s", typLookup[0], ifaces, strings.ToLower(typName))
+						return fmt.Sprintf(`<a href="%s" style="text-decoration: none;" id="lol">%s</a>`, linkedTyp, typName)
+					})
+					f.WriteString(fmt.Sprintf(`
+<h4 class='heading'>
+%s
+<a href="#%s" class='heading-link'>
+	<i class="fas fa-paperclip"></i>
+</a>
+</h4>
+
+`, htmlSig, dps.FuncName))
+					for _, doc := range dps.Doc {
+						if !strings.HasPrefix(doc, "---") && doc != "" {
+							f.WriteString(doc + "  \n")
+						}
+					}
+					f.WriteString("\n#### Parameters\n")
+					if len(dps.Params) == 0 {
+						f.WriteString("This function has no parameters.  \n")
+					}
+					for _, p := range dps.Params {
+						isVariadic := false
+						typ := p.Type
+						if strings.HasPrefix(p.Type, "...") {
+							isVariadic = true
+							typ = p.Type[3:]
+						}
+
+						f.WriteString(fmt.Sprintf("`%s` **`%s`**", typ, p.Name))
+						if isVariadic {
+							f.WriteString(" (This type is variadic. You can pass an infinite amount of parameters with this type.)")
+						}
+						f.WriteString("  \n")
+						f.WriteString(strings.Join(p.Doc, " "))
+						f.WriteString("\n\n")
+					}
+					if codeExample := dps.Tags["example"]; codeExample != nil {
+						f.WriteString("#### Example\n")
+						f.WriteString(fmt.Sprintf("```lua\n%s\n```\n", strings.Join(codeExample[0].fields, "\n")))
+					}
+					f.WriteString("</div>")
+					f.WriteString("\n\n")
+				}
+			}
+
+			if len(modu.Types) != 0 {
+				f.WriteString("## Types\n")
+				for _, dps := range modu.Types {
+					f.WriteString("<hr>\n\n")
+					f.WriteString(fmt.Sprintf("## %s\n", dps.FuncName))
+					for _, doc := range dps.Doc {
+						if !strings.HasPrefix(doc, "---") {
+							f.WriteString(doc + "\n")
+						}
+					}
+					if len(dps.Properties) != 0 {
+						f.WriteString("## Object properties\n")
+
+						mdTable := md.NewTable(len(dps.Properties), 2)
+						mdTable.SetTitle(0, "")
+						mdTable.SetTitle(1, "")
+
+						for i, d := range dps.Properties {
+							mdTable.SetContent(i, 0, d.FuncName)
+							mdTable.SetContent(i, 1, strings.Join(d.Doc, " "))
+						}
+						f.WriteString(mdTable.String())
+						f.WriteString("\n")
+					}
+					f.WriteString("\n")
+					f.WriteString("### Methods\n")
+					for _, dps := range modu.Docs {
+						if !dps.IsMember {
+							continue
+						}
+						htmlSig := typeTag.ReplaceAllStringFunc(strings.Replace(dps.FuncSig, "<", `\<`, -1), func(typ string) string {
+							typName := regexp.MustCompile(`\w+`).FindString(typ[1:])
+							typLookup := typeTable[strings.ToLower(typName)]
+							fmt.Printf("%+q, \n", typLookup)
+							linkedTyp := fmt.Sprintf("/Hilbish/docs/api/%s/%s/#%s", typLookup[0], typLookup[0] + "." + typLookup[1], strings.ToLower(typName))
+							return fmt.Sprintf(`<a href="#%s" style="text-decoration: none;">%s</a>`, linkedTyp, typName)
+						})
+						f.WriteString(fmt.Sprintf("#### %s\n", htmlSig))
+						for _, doc := range dps.Doc {
+							if !strings.HasPrefix(doc, "---") {
+								f.WriteString(doc + "\n")
+							}
+						}
+						f.WriteString("\n")
+					}
+				}
+			}
+		}(mod, docPath, v)
+
+		go func(md, modname string, modu module) {
+			defer wg.Done()
+
+			if modu.ParentModule != "" {
+				return
+			}
+
+			ff, _ := os.Create("emmyLuaDocs/" + modname + ".lua")
+			ff.WriteString("--- @meta\n\nlocal " + modname + " = {}\n\n")
+			for _, em := range emmyDocs[modname] {
+				if strings.HasSuffix(em.DocPiece.GoFuncName, strings.ToLower("loader")) {
+					continue
+				}
+
+				dps := em.DocPiece
+				funcdocs := dps.Doc
+				ff.WriteString("--- " + strings.Join(funcdocs, "\n--- ") + "\n")
+				if len(em.Annotations) != 0 {
+					ff.WriteString(strings.Join(em.Annotations, "\n") + "\n")
+				}
+				accessor := "."
+				if dps.IsMember {
+					accessor = ":"
+				}
+				signature := strings.Split(dps.FuncSig, " ->")[0]
+				var intrface string
+				if dps.IsInterface {
+					intrface = "." + dps.Interfacing
+				}
+				ff.WriteString("function " + modname + intrface + accessor + signature + " end\n\n")
+			}
+			ff.WriteString("return " + modname + "\n")
+		}(mod, mod, v)
+	}
+	wg.Wait()
 }

cmd/docgen/docgen.lua

@@ -0,0 +1,146 @@
+local fs = require 'fs'
+local emmyPattern = '^%-%-%- (.+)'
+local modpattern = '^%-+ @module (%w+)'
+local pieces = {}
+
+local files = fs.readdir 'nature'
+for _, fname in ipairs(files) do
+	local isScript = fname:match'%.lua$'
+	if not isScript then goto continue end
+
+	local f = io.open(string.format('nature/%s', fname))
+	local header = f:read '*l'
+	local mod = header:match(modpattern)
+	if not mod then goto continue end
+
+	print(fname, mod)
+	pieces[mod] = {}
+
+	local docPiece = {}
+	local lines = {}
+	local lineno = 0
+	for line in f:lines() do
+		lineno = lineno + 1
+		lines[lineno] = line
+
+		if line == header then goto continue2 end
+		if not line:match(emmyPattern) then
+			if line:match '^function' then
+				local pattern = (string.format('^function %s%%.', mod) .. '(%w+)')
+				local funcName = line:match(pattern)
+				if not funcName then goto continue2 end
+
+				local dps = {
+					description = {},
+					params = {}
+				}
+
+				local offset = 1
+				while true do
+					local prev = lines[lineno - offset]
+
+					local docline = prev:match '^%-+ (.+)'
+					if docline then
+						local emmy = docline:match '@(%w+)'
+						local cut = 0
+
+						if emmy then cut = emmy:len() + 3 end
+						local emmythings = string.split(docline:sub(cut), ' ')
+
+						if emmy then
+							if emmy == 'param' then
+								table.insert(dps.params, 1, {
+									name = emmythings[1],
+									type = emmythings[2]
+								})
+							end
+						else
+							table.insert(dps.description, 1, docline)
+						end
+						offset = offset + 1
+					else
+						break
+					end
+				end
+
+				pieces[mod][funcName] = dps
+			end
+			docPiece = {}
+			goto continue2
+		end
+
+		table.insert(docPiece, line)
+		::continue2::
+	end
+	::continue::
+end
+
+local header = [[---
+title: %s %s
+description: %s
+layout: doc
+menu:
+  docs:
+    parent: "Nature"
+---
+
+]]
+
+for iface, dps in pairs(pieces) do
+	local mod = iface:match '(%w+)%.' or 'nature'
+	local path = string.format('docs/%s/%s.md', mod, iface)
+	fs.mkdir(fs.dir(path), true)
+	local f <close> = io.open(path, 'w')
+	f:write(string.format(header, 'Module', iface, 'No description.'))
+	print(f)
+
+	print(mod, path)
+
+	for func, docs in pairs(dps) do
+		f:write(string.format('<hr>\n<div id=\'%s\'>', func))
+		local sig = string.format('%s.%s(', iface, func)
+		for idx, param in ipairs(docs.params) do
+			sig = sig .. ((param.name:gsub('%?$', '')))
+			if idx ~= #docs.params then sig = sig .. ', ' end
+		end
+		sig = sig .. ')'
+		f:write(string.format([[			
+<h4 class='heading'>
+%s
+<a href="#%s" class='heading-link'>
+	<i class="fas fa-paperclip"></i>
+</a>
+</h4>
+
+]], sig, func))
+
+		f:write(table.concat(docs.description, '\n') .. '\n')
+		f:write '#### Parameters\n'
+		if #docs.params == 0 then
+			f:write 'This function has no parameters.  \n'
+		end
+		for _, param in ipairs(docs.params) do
+			f:write(string.format('`%s` **`%s`**\n', param.name:gsub('%?$', ''), param.type))
+		end
+		--[[
+		local params = table.filter(docs, function(t)
+			return t:match '^%-%-%- @param'
+		end)
+		for i, str in ipairs(params) do
+			if i ~= 1 then
+				f:write ', '
+			end
+			f:write(str:match '^%-%-%- @param ([%w]+) ')
+		end
+		f:write(')\n')
+
+		for _, str in ipairs(docs) do
+			if not str:match '^%-%-%- @' then
+				f:write(str:match '^%-%-%- (.+)' .. '\n')
+			end	
+		end
+		]]--
+		f:write('</div>')
+		f:write('\n\n')
+	end
+end

complete.go

@@ -0,0 +1,373 @@
+package main
+
+import (
+	"errors"
+	"path/filepath"
+	"strings"
+	"os"
+
+	"hilbish/util"
+
+	rt "github.com/arnodel/golua/runtime"
+)
+
+var charEscapeMap = []string{
+	"\"", "\\\"",
+	"'", "\\'",
+	"`", "\\`",
+	" ", "\\ ",
+	"(", "\\(",
+	")", "\\)",
+	"[", "\\[",
+	"]", "\\]",
+	"$", "\\$",
+	"&", "\\&",
+	"*", "\\*",
+	">", "\\>",
+	"<", "\\<",
+	"|", "\\|",
+}
+var charEscapeMapInvert = invert(charEscapeMap)
+var escapeReplaer = strings.NewReplacer(charEscapeMap...)
+var escapeInvertReplaer = strings.NewReplacer(charEscapeMapInvert...)
+
+func invert(m []string) []string {
+	newM := make([]string, len(charEscapeMap))
+	for i := range m {
+		if (i + 1) % 2 == 0 {
+			newM[i] = m[i - 1]
+			newM[i - 1] = m[i]
+		}
+	}
+
+	return newM
+}
+
+func splitForFile(str string) []string {
+	split := []string{}
+	sb := &strings.Builder{}
+	quoted := false
+
+	for i, r := range str {
+		if r == '"' {
+			quoted = !quoted
+			sb.WriteRune(r)
+		} else if r == ' ' && str[i - 1] == '\\' {
+			sb.WriteRune(r)
+		} else if !quoted && r == ' ' {
+			split = append(split, sb.String())
+			sb.Reset()
+		} else {
+			sb.WriteRune(r)
+		}
+	}
+	if strings.HasSuffix(str, " ") {
+		split = append(split, "")
+	}
+
+	if sb.Len() > 0 {
+		split = append(split, sb.String())
+	}
+
+	return split
+}
+
+func fileComplete(query, ctx string, fields []string) ([]string, string) {
+	q := splitForFile(ctx)
+	path := ""
+	if len(q) != 0 {
+		path = q[len(q) - 1]
+	}
+
+	return matchPath(path)
+}
+
+func binaryComplete(query, ctx string, fields []string) ([]string, string) {
+	q := splitForFile(ctx)
+	query = ""
+	if len(q) != 0 {
+		query = q[len(q) - 1]
+	}
+
+	var completions []string
+
+	prefixes := []string{"./", "../", "/", "~/"}
+	for _, prefix := range prefixes {
+		if strings.HasPrefix(query, prefix) {
+			fileCompletions, filePref := matchPath(query)
+			if len(fileCompletions) != 0 {
+				for _, f := range fileCompletions {
+					fullPath, _ := filepath.Abs(util.ExpandHome(query + strings.TrimPrefix(f, filePref)))
+					if err := findExecutable(escapeInvertReplaer.Replace(fullPath), false, true); err != nil {
+						continue
+					}
+					completions = append(completions, f)
+				}
+			}
+			return completions, filePref
+		}
+	}
+
+	// filter out executables, but in path
+	for _, dir := range filepath.SplitList(os.Getenv("PATH")) {
+		// search for an executable which matches our query string
+		if matches, err := filepath.Glob(filepath.Join(dir, query + "*")); err == nil {
+			// get basename from matches
+			for _, match := range matches {
+				// check if we have execute permissions for our match
+				err := findExecutable(match, true, false)
+				if err != nil {
+					continue
+				}
+				// get basename from match
+				name := filepath.Base(match)
+				// add basename to completions
+				completions = append(completions, name)
+			}
+		}
+	}
+
+	// add lua registered commands to completions
+	for cmdName := range cmds.Commands {
+		if strings.HasPrefix(cmdName, query) {
+			completions = append(completions, cmdName)
+		}
+	}
+
+	completions = removeDupes(completions)
+
+	return completions, query
+}
+
+func matchPath(query string) ([]string, string) {
+	oldQuery := query
+	query = strings.TrimPrefix(query, "\"")
+	var entries []string
+	var baseName string
+
+	query = escapeInvertReplaer.Replace(query)
+	path, _ := filepath.Abs(util.ExpandHome(filepath.Dir(query)))
+	if string(query) == "" {
+		// filepath base below would give us "."
+		// which would cause a match of only dotfiles
+		path, _ = filepath.Abs(".")
+	} else if !strings.HasSuffix(query, string(os.PathSeparator)) {
+		baseName = filepath.Base(query)
+	}
+
+	files, _ := os.ReadDir(path)
+	for _, entry := range files {
+		// should we handle errors here?
+		file, err := entry.Info()
+		if err == nil && file.Mode() & os.ModeSymlink != 0 {
+			path, err := filepath.EvalSymlinks(filepath.Join(path, file.Name()))
+			if err == nil {
+				file, err = os.Lstat(path)
+			}
+		}
+
+		if strings.HasPrefix(file.Name(), baseName) {
+			entry := file.Name()
+			if file.IsDir() {
+				entry = entry + string(os.PathSeparator)
+			}
+			if !strings.HasPrefix(oldQuery, "\"") {
+				entry = escapeFilename(entry)
+			}
+			entries = append(entries, entry)
+		}
+	}
+	if !strings.HasPrefix(oldQuery, "\"") {
+		baseName = escapeFilename(baseName)
+	}
+
+	return entries, baseName
+}
+
+func escapeFilename(fname string) string {
+	return escapeReplaer.Replace(fname)
+}
+
+// #interface completion
+// tab completions
+// The completions interface deals with tab completions.
+func completionLoader(rtm *rt.Runtime) *rt.Table {
+	exports := map[string]util.LuaExport{
+		"bins": {hcmpBins, 3, false},
+		"call": {hcmpCall, 4, false},
+		"files": {hcmpFiles, 3, false},
+		"handler": {hcmpHandler, 2, false},
+	}
+
+	mod := rt.NewTable()
+	util.SetExports(rtm, mod, exports)
+	
+	return mod
+}
+
+// #interface completion
+// bins(query, ctx, fields) -> entries (table), prefix (string)
+// Return binaries/executables based on the provided parameters.
+// This function is meant to be used as a helper in a command completion handler.
+// #param query string
+// #param ctx string
+// #param fields table
+/*
+#example
+-- an extremely simple completer for sudo.
+hilbish.complete('command.sudo', function(query, ctx, fields)
+	table.remove(fields, 1)
+	if #fields[1] then
+		-- return commands because sudo runs a command as root..!
+
+		local entries, pfx = hilbish.completion.bins(query, ctx, fields)
+		return {
+			type = 'grid',
+			items = entries
+		}, pfx
+	end
+
+	-- ... else suggest files or anything else ..
+end)
+#example
+*/
+func hcmpBins(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
+	query, ctx, fds, err := getCompleteParams(t, c)
+	if err != nil {
+		return nil, err
+	}
+
+	completions, pfx := binaryComplete(query, ctx, fds)
+	luaComps := rt.NewTable()
+
+	for i, comp := range completions {
+		luaComps.Set(rt.IntValue(int64(i + 1)), rt.StringValue(comp))
+	}
+
+	return c.PushingNext(t.Runtime, rt.TableValue(luaComps), rt.StringValue(pfx)), nil
+}
+
+// #interface completion
+// call(name, query, ctx, fields) -> completionGroups (table), prefix (string)
+// Calls a completer function. This is mainly used to call a command completer, which will have a `name`
+// in the form of `command.name`, example: `command.git`.
+// You can check the Completions doc or `doc completions` for info on the `completionGroups` return value.
+// #param name string
+// #param query string
+// #param ctx string
+// #param fields table
+func hcmpCall(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
+	if err := c.CheckNArgs(4); err != nil {
+		return nil, err
+	}
+	completer, err := c.StringArg(0)
+	if err != nil {
+		return nil, err
+	}
+	query, err := c.StringArg(1)
+	if err != nil {
+		return nil, err
+	}
+	ctx, err := c.StringArg(2)
+	if err != nil {
+		return nil, err
+	}
+	fields, err := c.TableArg(3)
+	if err != nil {
+		return nil, err
+	}
+
+	var completecb *rt.Closure
+	var ok bool
+	if completecb, ok = luaCompletions[completer]; !ok {
+		return nil, errors.New("completer " + completer + " does not exist")
+	}
+
+	// we must keep the holy 80 cols
+	cont := c.Next()
+	err = rt.Call(l.MainThread(), rt.FunctionValue(completecb),
+	[]rt.Value{rt.StringValue(query), rt.StringValue(ctx), rt.TableValue(fields)},
+	cont)
+
+	if err != nil {
+		return nil, err
+	}
+
+	return cont, nil
+}
+
+// #interface completion
+// files(query, ctx, fields) -> entries (table), prefix (string)
+// Returns file matches based on the provided parameters.
+// This function is meant to be used as a helper in a command completion handler.
+// #param query string
+// #param ctx string
+// #param fields table
+func hcmpFiles(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
+	query, ctx, fds, err := getCompleteParams(t, c)
+	if err != nil {
+		return nil, err
+	}
+
+	completions, pfx := fileComplete(query, ctx, fds)
+	luaComps := rt.NewTable()
+
+	for i, comp := range completions {
+		luaComps.Set(rt.IntValue(int64(i + 1)), rt.StringValue(comp))
+	}
+
+	return c.PushingNext(t.Runtime, rt.TableValue(luaComps), rt.StringValue(pfx)), nil
+}
+
+// #interface completion
+// handler(line, pos)
+// This function contains the general completion handler for Hilbish. This function handles
+// completion of everything, which includes calling other command handlers, binaries, and files.
+// This function can be overriden to supply a custom handler. Note that alias resolution is required to be done in this function.
+// #param line string The current Hilbish command line
+// #param pos number Numerical position of the cursor
+/*
+#example
+-- stripped down version of the default implementation
+function hilbish.completion.handler(line, pos)
+	local query = fields[#fields]
+
+	if #fields == 1 then
+		-- call bins handler here
+	else
+		-- call command completer or files completer here
+	end
+end
+#example
+*/
+func hcmpHandler(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
+	return c.Next(), nil
+}
+
+
+func getCompleteParams(t *rt.Thread, c *rt.GoCont) (string, string, []string, error) {
+	if err := c.CheckNArgs(3); err != nil {
+		return "", "", []string{}, err
+	}
+	query, err := c.StringArg(0)
+	if err != nil {
+		return "", "", []string{}, err
+	}
+	ctx, err := c.StringArg(1)
+	if err != nil {
+		return "", "", []string{}, err
+	}
+	fields, err := c.TableArg(2)
+	if err != nil {
+		return "", "", []string{}, err
+	}
+
+	var fds []string
+	util.ForEach(fields, func(k rt.Value, v rt.Value) {
+		if v.Type() == rt.StringType {
+			fds = append(fds, v.AsString())
+		}
+	})
+
+	return query, ctx, fds, err
+}

docs/_index.md

@@ -0,0 +1,13 @@
+---
+title: Introduction
+layout: doc
+weight: -1
+menu: docs
+---
+
+Hilbish is a hyper-extensible shell mainly intended for interactive use.
+To enhance the interactive experience, Hilbish comes with a wide range
+of features and sane defaults, including a nice looking prompt,
+advanced completion menus and history search.
+
+Here documents some of the features of Hilbish and the Lua API.

docs/api/_index.md

@@ -0,0 +1,9 @@
+---
+title: API
+layout: doc
+weight: -100
+menu: docs
+---
+
+Welcome to the API documentation for Hilbish. This documents Lua functions
+provided by Hilbish.

docs/api/bait.md

@@ -0,0 +1,167 @@
+---
+title: Module bait
+description: the event emitter
+layout: doc
+menu:
+  docs:
+    parent: "API"
+---
+
+## Introduction
+
+Bait is the event emitter for Hilbish. Much like Node.js and
+its `events` system, many actions in Hilbish emit events.
+Unlike Node.js, Hilbish events are global. So make sure to
+pick a unique name!
+
+Usage of the Bait module consists of userstanding
+event-driven architecture, but it's pretty simple:
+If you want to act on a certain event, you can `catch` it.
+You can act on events via callback functions.
+
+Examples of this are in the Hilbish default config!
+Consider this part of it:
+```lua
+bait.catch('command.exit', function(code)
+	running = false
+	doPrompt(code ~= 0)
+	doNotifyPrompt()
+end)
+```
+
+What this does is, whenever the `command.exit` event is thrown,
+this function will set the user prompt.
+
+## Functions
+|||
+|----|----|
+|<a href="#catch">catch(name, cb)</a>|Catches an event. This function can be used to act on events.|
+|<a href="#catchOnce">catchOnce(name, cb)</a>|Catches an event, but only once. This will remove the hook immediately after it runs for the first time.|
+|<a href="#hooks">hooks(name) -> table</a>|Returns a table of functions that are hooked on an event with the corresponding `name`.|
+|<a href="#release">release(name, catcher)</a>|Removes the `catcher` for the event with `name`.|
+|<a href="#throw">throw(name, ...args)</a>|Throws a hook with `name` with the provided `args`.|
+
+<hr>
+<div id='catch'>
+<h4 class='heading'>
+bait.catch(name, cb)
+<a href="#catch" class='heading-link'>
+	<i class="fas fa-paperclip"></i>
+</a>
+</h4>
+
+Catches an event. This function can be used to act on events.  
+
+#### Parameters
+`string` **`name`**  
+The name of the hook.
+
+`function` **`cb`**  
+The function that will be called when the hook is thrown.
+
+#### Example
+```lua
+bait.catch('hilbish.exit', function()
+	print 'Goodbye Hilbish!'
+end)
+```
+</div>
+
+<hr>
+<div id='catchOnce'>
+<h4 class='heading'>
+bait.catchOnce(name, cb)
+<a href="#catchOnce" class='heading-link'>
+	<i class="fas fa-paperclip"></i>
+</a>
+</h4>
+
+Catches an event, but only once. This will remove the hook immediately after it runs for the first time.  
+
+#### Parameters
+`string` **`name`**  
+The name of the event
+
+`function` **`cb`**  
+The function that will be called when the event is thrown.
+
+</div>
+
+<hr>
+<div id='hooks'>
+<h4 class='heading'>
+bait.hooks(name) -> table
+<a href="#hooks" class='heading-link'>
+	<i class="fas fa-paperclip"></i>
+</a>
+</h4>
+
+Returns a table of functions that are hooked on an event with the corresponding `name`.  
+
+#### Parameters
+`string` **`name`**  
+The name of the hook
+
+</div>
+
+<hr>
+<div id='release'>
+<h4 class='heading'>
+bait.release(name, catcher)
+<a href="#release" class='heading-link'>
+	<i class="fas fa-paperclip"></i>
+</a>
+</h4>
+
+Removes the `catcher` for the event with `name`.  
+For this to work, `catcher` has to be the same function used to catch  
+an event, like one saved to a variable.  
+
+#### Parameters
+`string` **`name`**  
+Name of the event the hook is on
+
+`function` **`catcher`**  
+Hook function to remove
+
+#### Example
+```lua
+local hookCallback = function() print 'hi' end
+
+bait.catch('event', hookCallback)
+
+-- a little while later....
+bait.release('event', hookCallback)
+-- and now hookCallback will no longer be ran for the event.
+```
+</div>
+
+<hr>
+<div id='throw'>
+<h4 class='heading'>
+bait.throw(name, ...args)
+<a href="#throw" class='heading-link'>
+	<i class="fas fa-paperclip"></i>
+</a>
+</h4>
+
+Throws a hook with `name` with the provided `args`.  
+
+#### Parameters
+`string` **`name`**  
+The name of the hook.
+
+`any` **`args`** (This type is variadic. You can pass an infinite amount of parameters with this type.)  
+The arguments to pass to the hook.
+
+#### Example
+```lua
+bait.throw('greeting', 'world')
+
+-- This can then be listened to via
+bait.catch('gretting', function(greetTo)
+	print('Hello ' .. greetTo)
+end)
+```
+</div>
+

docs/api/commander.md

@@ -0,0 +1,113 @@
+---
+title: Module commander
+description: library for custom commands
+layout: doc
+menu:
+  docs:
+    parent: "API"
+---
+
+## Introduction
+
+Commander is the library which handles Hilbish commands. This makes
+the user able to add Lua-written commands to their shell without making
+a separate script in a bin folder. Instead, you may simply use the Commander
+library in your Hilbish config.
+
+```lua
+local commander = require 'commander'
+
+commander.register('hello', function(args, sinks)
+	sinks.out:writeln 'Hello world!'
+end)
+```
+
+In this example, a command with the name of `hello` is created
+that will print `Hello world!` to output. One question you may
+have is: What is the `sinks` parameter?
+
+The `sinks` parameter is a table with 3 keys: `input`, `out`, and `err`.
+There is an `in` alias to `input`, but it requires using the string accessor syntax (`sinks['in']`)
+as `in` is also a Lua keyword, so `input` is preferred for use.
+All of them are a <a href="/Hilbish/docs/api/hilbish/#sink" style="text-decoration: none;">Sink</a>.
+In the future, `sinks.in` will be removed.
+
+- `in` is the standard input.
+You may use the read functions on this sink to get input from the user.
+- `out` is standard output.
+This is usually where command output should go.
+- `err` is standard error.
+This sink is for writing errors, as the name would suggest.
+
+## Functions
+|||
+|----|----|
+|<a href="#deregister">deregister(name)</a>|Removes the named command. Note that this will only remove Commander-registered commands.|
+|<a href="#register">register(name, cb)</a>|Adds a new command with the given `name`. When Hilbish has to run a command with a name,|
+|<a href="#registry">registry() -> table</a>|Returns all registered commanders. Returns a list of tables with the following keys:|
+
+<hr>
+<div id='deregister'>
+<h4 class='heading'>
+commander.deregister(name)
+<a href="#deregister" class='heading-link'>
+	<i class="fas fa-paperclip"></i>
+</a>
+</h4>
+
+Removes the named command. Note that this will only remove Commander-registered commands.  
+
+#### Parameters
+`string` **`name`**  
+Name of the command to remove.
+
+</div>
+
+<hr>
+<div id='register'>
+<h4 class='heading'>
+commander.register(name, cb)
+<a href="#register" class='heading-link'>
+	<i class="fas fa-paperclip"></i>
+</a>
+</h4>
+
+Adds a new command with the given `name`. When Hilbish has to run a command with a name,  
+it will run the function providing the arguments and sinks.  
+
+#### Parameters
+`string` **`name`**  
+Name of the command
+
+`function` **`cb`**  
+Callback to handle command invocation
+
+#### Example
+```lua
+-- When you run the command `hello` in the shell, it will print `Hello world`.
+-- If you run it with, for example, `hello Hilbish`, it will print 'Hello Hilbish'
+commander.register('hello', function(args, sinks)
+	local name = 'world'
+	if #args > 0 then name = args[1] end
+
+	sinks.out:writeln('Hello ' .. name)
+end)
+```
+</div>
+
+<hr>
+<div id='registry'>
+<h4 class='heading'>
+commander.registry() -> table
+<a href="#registry" class='heading-link'>
+	<i class="fas fa-paperclip"></i>
+</a>
+</h4>
+
+Returns all registered commanders. Returns a list of tables with the following keys:  
+- `exec`: The function used to run the commander. Commanders require args and sinks to be passed.  
+
+#### Parameters
+This function has no parameters.  
+</div>
+

docs/api/fs.md

@@ -0,0 +1,257 @@
+---
+title: Module fs
+description: filesystem interaction and functionality library
+layout: doc
+menu:
+  docs:
+    parent: "API"
+---
+
+## Introduction
+
+The fs module provides filesystem functions to Hilbish. While Lua's standard
+library has some I/O functions, they're missing a lot of the basics. The `fs`
+library offers more functions and will work on any operating system Hilbish does.
+
+## Functions
+|||
+|----|----|
+|<a href="#abs">abs(path) -> string</a>|Returns an absolute version of the `path`.|
+|<a href="#basename">basename(path) -> string</a>|Returns the "basename," or the last part of the provided `path`. If path is empty,|
+|<a href="#cd">cd(dir)</a>|Changes Hilbish's directory to `dir`.|
+|<a href="#dir">dir(path) -> string</a>|Returns the directory part of `path`. If a file path like|
+|<a href="#glob">glob(pattern) -> matches (table)</a>|Match all files based on the provided `pattern`.|
+|<a href="#join">join(...path) -> string</a>|Takes any list of paths and joins them based on the operating system's path separator.|
+|<a href="#mkdir">mkdir(name, recursive)</a>|Creates a new directory with the provided `name`.|
+|<a href="#pipe">fpipe() -> File, File</a>|Returns a pair of connected files, also known as a pipe.|
+|<a href="#readdir">readdir(path) -> table[string]</a>|Returns a list of all files and directories in the provided path.|
+|<a href="#stat">stat(path) -> {}</a>|Returns the information about a given `path`.|
+
+## Static module fields
+|||
+|----|----|
+|pathSep|The operating system's path separator.|
+
+<hr>
+<div id='abs'>
+<h4 class='heading'>
+fs.abs(path) -> string
+<a href="#abs" class='heading-link'>
+	<i class="fas fa-paperclip"></i>
+</a>
+</h4>
+
+Returns an absolute version of the `path`.  
+This can be used to resolve short paths like `..` to `/home/user`.  
+
+#### Parameters
+`string` **`path`**  
+
+
+</div>
+
+<hr>
+<div id='basename'>
+<h4 class='heading'>
+fs.basename(path) -> string
+<a href="#basename" class='heading-link'>
+	<i class="fas fa-paperclip"></i>
+</a>
+</h4>
+
+Returns the "basename," or the last part of the provided `path`. If path is empty,  
+`.` will be returned.  
+
+#### Parameters
+`string` **`path`**  
+Path to get the base name of.
+
+</div>
+
+<hr>
+<div id='cd'>
+<h4 class='heading'>
+fs.cd(dir)
+<a href="#cd" class='heading-link'>
+	<i class="fas fa-paperclip"></i>
+</a>
+</h4>
+
+Changes Hilbish's directory to `dir`.  
+
+#### Parameters
+`string` **`dir`**  
+Path to change directory to.
+
+</div>
+
+<hr>
+<div id='dir'>
+<h4 class='heading'>
+fs.dir(path) -> string
+<a href="#dir" class='heading-link'>
+	<i class="fas fa-paperclip"></i>
+</a>
+</h4>
+
+Returns the directory part of `path`. If a file path like  
+`~/Documents/doc.txt` then this function will return `~/Documents`.  
+
+#### Parameters
+`string` **`path`**  
+Path to get the directory for.
+
+</div>
+
+<hr>
+<div id='glob'>
+<h4 class='heading'>
+fs.glob(pattern) -> matches (table)
+<a href="#glob" class='heading-link'>
+	<i class="fas fa-paperclip"></i>
+</a>
+</h4>
+
+Match all files based on the provided `pattern`.  
+For the syntax' refer to Go's filepath.Match function: https://pkg.go.dev/path/filepath#Match  
+
+#### Parameters
+`string` **`pattern`**  
+Pattern to compare files with.
+
+#### Example
+```lua
+--[[
+	Within a folder that contains the following files:
+	a.txt
+	init.lua
+	code.lua
+	doc.pdf
+]]--
+local matches = fs.glob './*.lua'
+print(matches)
+-- -> {'init.lua', 'code.lua'}
+```
+</div>
+
+<hr>
+<div id='join'>
+<h4 class='heading'>
+fs.join(...path) -> string
+<a href="#join" class='heading-link'>
+	<i class="fas fa-paperclip"></i>
+</a>
+</h4>
+
+Takes any list of paths and joins them based on the operating system's path separator.  
+
+#### Parameters
+`string` **`path`** (This type is variadic. You can pass an infinite amount of parameters with this type.)  
+Paths to join together
+
+#### Example
+```lua
+-- This prints the directory for Hilbish's config!
+print(fs.join(hilbish.userDir.config, 'hilbish'))
+-- -> '/home/user/.config/hilbish' on Linux
+```
+</div>
+
+<hr>
+<div id='mkdir'>
+<h4 class='heading'>
+fs.mkdir(name, recursive)
+<a href="#mkdir" class='heading-link'>
+	<i class="fas fa-paperclip"></i>
+</a>
+</h4>
+
+Creates a new directory with the provided `name`.  
+With `recursive`, mkdir will create parent directories.  
+
+#### Parameters
+`string` **`name`**  
+Name of the directory
+
+`boolean` **`recursive`**  
+Whether to create parent directories for the provided name
+
+#### Example
+```lua
+-- This will create the directory foo, then create the directory bar in the
+-- foo directory. If recursive is false in this case, it will fail.
+fs.mkdir('./foo/bar', true)
+```
+</div>
+
+<hr>
+<div id='pipe'>
+<h4 class='heading'>
+fs.fpipe() -> File, File
+<a href="#pipe" class='heading-link'>
+	<i class="fas fa-paperclip"></i>
+</a>
+</h4>
+
+Returns a pair of connected files, also known as a pipe.  
+The type returned is a Lua file, same as returned from `io` functions.  
+
+#### Parameters
+This function has no parameters.  
+</div>
+
+<hr>
+<div id='readdir'>
+<h4 class='heading'>
+fs.readdir(path) -> table[string]
+<a href="#readdir" class='heading-link'>
+	<i class="fas fa-paperclip"></i>
+</a>
+</h4>
+
+Returns a list of all files and directories in the provided path.  
+
+#### Parameters
+`string` **`dir`**  
+
+
+</div>
+
+<hr>
+<div id='stat'>
+<h4 class='heading'>
+fs.stat(path) -> {}
+<a href="#stat" class='heading-link'>
+	<i class="fas fa-paperclip"></i>
+</a>
+</h4>
+
+Returns the information about a given `path`.  
+The returned table contains the following values:  
+name (string) - Name of the path  
+size (number) - Size of the path in bytes  
+mode (string) - Unix permission mode in an octal format string (with leading 0)  
+isDir (boolean) - If the path is a directory  
+
+#### Parameters
+`string` **`path`**  
+
+
+#### Example
+```lua
+local inspect = require 'inspect'
+
+local stat = fs.stat '~'
+print(inspect(stat))
+--[[
+Would print the following:
+{
+  isDir = true,
+  mode = "0755",
+  name = "username",
+  size = 12288
+}
+]]--
+```
+</div>
+

docs/api/hilbish/_index.md

@@ -0,0 +1,544 @@
+---
+title: Module hilbish
+description: the core Hilbish API
+layout: doc
+menu:
+  docs:
+    parent: "API"
+---
+
+## Introduction
+The Hilbish module includes the core API, containing
+interfaces and functions which directly relate to shell functionality.
+
+## Functions
+|||
+|----|----|
+|<a href="#alias">alias(cmd, orig)</a>|Sets an alias, with a name of `cmd` to another command.|
+|<a href="#appendPath">appendPath(dir)</a>|Appends the provided dir to the command path (`$PATH`)|
+|<a href="#complete">complete(scope, cb)</a>|Registers a completion handler for the specified scope.|
+|<a href="#cwd">cwd() -> string</a>|Returns the current directory of the shell.|
+|<a href="#exec">exec(cmd)</a>|Replaces the currently running Hilbish instance with the supplied command.|
+|<a href="#goro">goro(fn)</a>|Puts `fn` in a Goroutine.|
+|<a href="#highlighter">highlighter(line)</a>|Line highlighter handler.|
+|<a href="#hinter">hinter(line, pos)</a>|The command line hint handler. It gets called on every key insert to|
+|<a href="#inputMode">inputMode(mode)</a>|Sets the input mode for Hilbish's line reader.|
+|<a href="#interval">interval(cb, time) -> @Timer</a>|Runs the `cb` function every specified amount of `time`.|
+|<a href="#multiprompt">multiprompt(str)</a>|Changes the text prompt when Hilbish asks for more input.|
+|<a href="#prependPath">prependPath(dir)</a>|Prepends `dir` to $PATH.|
+|<a href="#prompt">prompt(str, typ)</a>|Changes the shell prompt to the provided string.|
+|<a href="#read">read(prompt) -> input (string)</a>|Read input from the user, using Hilbish's line editor/input reader.|
+|<a href="#run">run(cmd, streams) -> exitCode (number), stdout (string), stderr (string)</a>|Runs `cmd` in Hilbish's shell script interpreter.|
+|<a href="#runnerMode">runnerMode(mode)</a>|Sets the execution/runner mode for interactive Hilbish.|
+|<a href="#timeout">timeout(cb, time) -> @Timer</a>|Executed the `cb` function after a period of `time`.|
+|<a href="#which">which(name) -> string</a>|Checks if `name` is a valid command.|
+
+## Static module fields
+|||
+|----|----|
+|ver|The version of Hilbish|
+|goVersion|The version of Go that Hilbish was compiled with|
+|user|Username of the user|
+|host|Hostname of the machine|
+|dataDir|Directory for Hilbish data files, including the docs and default modules|
+|interactive|Is Hilbish in an interactive shell?|
+|login|Is Hilbish the login shell?|
+|vimMode|Current Vim input mode of Hilbish (will be nil if not in Vim input mode)|
+|exitCode|Exit code of the last executed command|
+
+<hr>
+<div id='alias'>
+<h4 class='heading'>
+hilbish.alias(cmd, orig)
+<a href="#alias" class='heading-link'>
+	<i class="fas fa-paperclip"></i>
+</a>
+</h4>
+
+Sets an alias, with a name of `cmd` to another command.  
+
+#### Parameters
+`string` **`cmd`**  
+Name of the alias
+
+`string` **`orig`**  
+Command that will be aliased
+
+#### Example
+```lua
+-- With this, "ga file" will turn into "git add file"
+hilbish.alias('ga', 'git add')
+
+-- Numbered substitutions are supported here!
+hilbish.alias('dircount', 'ls %1 | wc -l')
+-- "dircount ~" would count how many files are in ~ (home directory).
+```
+</div>
+
+<hr>
+<div id='appendPath'>
+<h4 class='heading'>
+hilbish.appendPath(dir)
+<a href="#appendPath" class='heading-link'>
+	<i class="fas fa-paperclip"></i>
+</a>
+</h4>
+
+Appends the provided dir to the command path (`$PATH`)  
+
+#### Parameters
+`string|table` **`dir`**  
+Directory (or directories) to append to path
+
+#### Example
+```lua
+hilbish.appendPath '~/go/bin'
+-- Will add ~/go/bin to the command path.
+
+-- Or do multiple:
+hilbish.appendPath {
+	'~/go/bin',
+	'~/.local/bin'
+}
+```
+</div>
+
+<hr>
+<div id='complete'>
+<h4 class='heading'>
+hilbish.complete(scope, cb)
+<a href="#complete" class='heading-link'>
+	<i class="fas fa-paperclip"></i>
+</a>
+</h4>
+
+Registers a completion handler for the specified scope.  
+A `scope` is expected to be `command.<cmd>`,  
+replacing <cmd> with the name of the command (for example `command.git`).  
+The documentation for completions, under Features/Completions or `doc completions`  
+provides more details.  
+
+#### Parameters
+`string` **`scope`**  
+
+
+`function` **`cb`**  
+
+
+#### Example
+```lua
+-- This is a very simple example. Read the full doc for completions for details.
+hilbish.complete('command.sudo', function(query, ctx, fields)
+	if #fields == 0 then
+		-- complete for commands
+		local comps, pfx = hilbish.completion.bins(query, ctx, fields)
+		local compGroup = {
+			items = comps, -- our list of items to complete
+			type = 'grid' -- what our completions will look like.
+		}
+
+		return {compGroup}, pfx
+	end
+
+	-- otherwise just be boring and return files
+
+	local comps, pfx = hilbish.completion.files(query, ctx, fields)
+	local compGroup = {
+		items = comps,
+		type = 'grid'
+	}
+
+	return {compGroup}, pfx
+end)
+```
+</div>
+
+<hr>
+<div id='cwd'>
+<h4 class='heading'>
+hilbish.cwd() -> string
+<a href="#cwd" class='heading-link'>
+	<i class="fas fa-paperclip"></i>
+</a>
+</h4>
+
+Returns the current directory of the shell.  
+
+#### Parameters
+This function has no parameters.  
+</div>
+
+<hr>
+<div id='exec'>
+<h4 class='heading'>
+hilbish.exec(cmd)
+<a href="#exec" class='heading-link'>
+	<i class="fas fa-paperclip"></i>
+</a>
+</h4>
+
+Replaces the currently running Hilbish instance with the supplied command.  
+This can be used to do an in-place restart.  
+
+#### Parameters
+`string` **`cmd`**  
+
+
+</div>
+
+<hr>
+<div id='goro'>
+<h4 class='heading'>
+hilbish.goro(fn)
+<a href="#goro" class='heading-link'>
+	<i class="fas fa-paperclip"></i>
+</a>
+</h4>
+
+Puts `fn` in a Goroutine.  
+This can be used to run any function in another thread at the same time as other Lua code.  
+**NOTE: THIS FUNCTION MAY CRASH HILBISH IF OUTSIDE VARIABLES ARE ACCESSED.**  
+**This is a limitation of the Lua runtime.**  
+
+#### Parameters
+`function` **`fn`**  
+
+
+</div>
+
+<hr>
+<div id='highlighter'>
+<h4 class='heading'>
+hilbish.highlighter(line)
+<a href="#highlighter" class='heading-link'>
+	<i class="fas fa-paperclip"></i>
+</a>
+</h4>
+
+Line highlighter handler.  
+This is mainly for syntax highlighting, but in reality could set the input  
+of the prompt to *display* anything. The callback is passed the current line  
+and is expected to return a line that will be used as the input display.  
+Note that to set a highlighter, one has to override this function.  
+
+#### Parameters
+`string` **`line`**  
+
+
+#### Example
+```lua
+--This code will highlight all double quoted strings in green.
+function hilbish.highlighter(line)
+   return line:gsub('"%w+"', function(c) return lunacolors.green(c) end)
+end
+```
+</div>
+
+<hr>
+<div id='hinter'>
+<h4 class='heading'>
+hilbish.hinter(line, pos)
+<a href="#hinter" class='heading-link'>
+	<i class="fas fa-paperclip"></i>
+</a>
+</h4>
+
+The command line hint handler. It gets called on every key insert to  
+determine what text to use as an inline hint. It is passed the current  
+line and cursor position. It is expected to return a string which is used  
+as the text for the hint. This is by default a shim. To set hints,  
+override this function with your custom handler.  
+
+#### Parameters
+`string` **`line`**  
+
+
+`number` **`pos`**  
+Position of cursor in line. Usually equals string.len(line)
+
+#### Example
+```lua
+-- this will display "hi" after the cursor in a dimmed color.
+function hilbish.hinter(line, pos)
+	return 'hi'
+end
+```
+</div>
+
+<hr>
+<div id='inputMode'>
+<h4 class='heading'>
+hilbish.inputMode(mode)
+<a href="#inputMode" class='heading-link'>
+	<i class="fas fa-paperclip"></i>
+</a>
+</h4>
+
+Sets the input mode for Hilbish's line reader.  
+`emacs` is the default. Setting it to `vim` changes behavior of input to be  
+Vim-like with modes and Vim keybinds.  
+
+#### Parameters
+`string` **`mode`**  
+Can be set to either `emacs` or `vim`
+
+</div>
+
+<hr>
+<div id='interval'>
+<h4 class='heading'>
+hilbish.interval(cb, time) -> <a href="/Hilbish/docs/api/hilbish/hilbish.timers/#timer" style="text-decoration: none;" id="lol">Timer</a>
+<a href="#interval" class='heading-link'>
+	<i class="fas fa-paperclip"></i>
+</a>
+</h4>
+
+Runs the `cb` function every specified amount of `time`.  
+This creates a timer that ticking immediately.  
+
+#### Parameters
+`function` **`cb`**  
+
+
+`number` **`time`**  
+Time in milliseconds.
+
+</div>
+
+<hr>
+<div id='multiprompt'>
+<h4 class='heading'>
+hilbish.multiprompt(str)
+<a href="#multiprompt" class='heading-link'>
+	<i class="fas fa-paperclip"></i>
+</a>
+</h4>
+
+Changes the text prompt when Hilbish asks for more input.  
+This will show up when text is incomplete, like a missing quote  
+
+#### Parameters
+`string` **`str`**  
+
+
+#### Example
+```lua
+--[[
+imagine this is your text input:
+user ~ ∆ echo "hey
+
+but there's a missing quote! hilbish will now prompt you so the terminal
+will look like:
+user ~ ∆ echo "hey
+--> ...!"
+
+so then you get
+user ~ ∆ echo "hey
+--> ...!"
+hey ...!
+]]--
+hilbish.multiprompt '-->'
+```
+</div>
+
+<hr>
+<div id='prependPath'>
+<h4 class='heading'>
+hilbish.prependPath(dir)
+<a href="#prependPath" class='heading-link'>
+	<i class="fas fa-paperclip"></i>
+</a>
+</h4>
+
+Prepends `dir` to $PATH.  
+
+#### Parameters
+`string` **`dir`**  
+
+
+</div>
+
+<hr>
+<div id='prompt'>
+<h4 class='heading'>
+hilbish.prompt(str, typ)
+<a href="#prompt" class='heading-link'>
+	<i class="fas fa-paperclip"></i>
+</a>
+</h4>
+
+Changes the shell prompt to the provided string.  
+There are a few verbs that can be used in the prompt text.  
+These will be formatted and replaced with the appropriate values.  
+`%d` - Current working directory  
+`%u` - Name of current user  
+`%h` - Hostname of device  
+
+#### Parameters
+`string` **`str`**  
+
+
+`string` **`typ?`**  
+Type of prompt, being left or right. Left by default.
+
+#### Example
+```lua
+-- the default hilbish prompt without color
+hilbish.prompt '%u %d ∆'
+-- or something of old:
+hilbish.prompt '%u@%h :%d $'
+-- prompt: user@hostname: ~/directory $
+```
+</div>
+
+<hr>
+<div id='read'>
+<h4 class='heading'>
+hilbish.read(prompt) -> input (string)
+<a href="#read" class='heading-link'>
+	<i class="fas fa-paperclip"></i>
+</a>
+</h4>
+
+Read input from the user, using Hilbish's line editor/input reader.  
+This is a separate instance from the one Hilbish actually uses.  
+Returns `input`, will be nil if Ctrl-D is pressed, or an error occurs.  
+
+#### Parameters
+`string` **`prompt?`**  
+Text to print before input, can be empty.
+
+</div>
+
+<hr>
+<div id='run'>
+<h4 class='heading'>
+hilbish.run(cmd, streams) -> exitCode (number), stdout (string), stderr (string)
+<a href="#run" class='heading-link'>
+	<i class="fas fa-paperclip"></i>
+</a>
+</h4>
+
+Runs `cmd` in Hilbish's shell script interpreter.  
+The `streams` parameter specifies the output and input streams the command should use.  
+For example, to write command output to a sink.  
+As a table, the caller can directly specify the standard output, error, and input  
+streams of the command with the table keys `out`, `err`, and `input` respectively.  
+As a boolean, it specifies whether the command should use standard output or return its output streams.  
+
+#### Parameters
+`string` **`cmd`**  
+
+
+`table|boolean` **`streams`**  
+
+
+#### Example
+```lua
+
+// This code is the same as `ls -l | wc -l`
+local fs = require 'fs'
+local pr, pw = fs.pipe()
+hilbish.run('ls -l', {
+	stdout = pw,
+	stderr = pw,
+})
+
+pw:close()
+
+hilbish.run('wc -l', {
+	stdin = pr
+})
+
+```
+</div>
+
+<hr>
+<div id='runnerMode'>
+<h4 class='heading'>
+hilbish.runnerMode(mode)
+<a href="#runnerMode" class='heading-link'>
+	<i class="fas fa-paperclip"></i>
+</a>
+</h4>
+
+Sets the execution/runner mode for interactive Hilbish.  
+This determines whether Hilbish wll try to run input as Lua  
+and/or sh or only do one of either.  
+Accepted values for mode are hybrid (the default), hybridRev (sh first then Lua),  
+sh, and lua. It also accepts a function, to which if it is passed one  
+will call it to execute user input instead.  
+Read [about runner mode](../features/runner-mode) for more information.  
+
+#### Parameters
+`string|function` **`mode`**  
+
+
+</div>
+
+<hr>
+<div id='timeout'>
+<h4 class='heading'>
+hilbish.timeout(cb, time) -> <a href="/Hilbish/docs/api/hilbish/hilbish.timers/#timer" style="text-decoration: none;" id="lol">Timer</a>
+<a href="#timeout" class='heading-link'>
+	<i class="fas fa-paperclip"></i>
+</a>
+</h4>
+
+Executed the `cb` function after a period of `time`.  
+This creates a Timer that starts ticking immediately.  
+
+#### Parameters
+`function` **`cb`**  
+
+
+`number` **`time`**  
+Time to run in milliseconds.
+
+</div>
+
+<hr>
+<div id='which'>
+<h4 class='heading'>
+hilbish.which(name) -> string
+<a href="#which" class='heading-link'>
+	<i class="fas fa-paperclip"></i>
+</a>
+</h4>
+
+Checks if `name` is a valid command.  
+Will return the path of the binary, or a basename if it's a commander.  
+
+#### Parameters
+`string` **`name`**  
+
+
+</div>
+
+## Types
+<hr>
+
+## Sink
+A sink is a structure that has input and/or output to/from
+a desination.
+
+### Methods
+#### autoFlush(auto)
+Sets/toggles the option of automatically flushing output.
+A call with no argument will toggle the value.
+
+#### flush()
+Flush writes all buffered input to the sink.
+
+#### read() -> string
+Reads a liine of input from the sink.
+
+#### readAll() -> string
+Reads all input from the sink.
+
+#### write(str)
+Writes data to a sink.
+
+#### writeln(str)
+Writes data to a sink with a newline at the end.
+

docs/api/hilbish/hilbish.aliases.md

@@ -0,0 +1,91 @@
+---
+title: Module hilbish.aliases
+description: command aliasing
+layout: doc
+menu:
+  docs:
+    parent: "API"
+---
+
+## Introduction
+The alias interface deals with all command aliases in Hilbish.
+
+## Functions
+|||
+|----|----|
+|<a href="#aliases.add">add(alias, cmd)</a>|This is an alias (ha) for the [hilbish.alias](../#alias) function.|
+|<a href="#aliases.delete">delete(name)</a>|Removes an alias.|
+|<a href="#aliases.list">list() -> table[string, string]</a>|Get a table of all aliases, with string keys as the alias and the value as the command.|
+|<a href="#aliases.resolve">resolve(alias) -> string?</a>|Resolves an alias to its original command. Will thrown an error if the alias doesn't exist.|
+
+<hr>
+<div id='aliases.add'>
+<h4 class='heading'>
+hilbish.aliases.add(alias, cmd)
+<a href="#aliases.add" class='heading-link'>
+	<i class="fas fa-paperclip"></i>
+</a>
+</h4>
+
+This is an alias (ha) for the [hilbish.alias](../#alias) function.  
+
+#### Parameters
+This function has no parameters.  
+</div>
+
+<hr>
+<div id='aliases.delete'>
+<h4 class='heading'>
+hilbish.aliases.delete(name)
+<a href="#aliases.delete" class='heading-link'>
+	<i class="fas fa-paperclip"></i>
+</a>
+</h4>
+
+Removes an alias.  
+
+#### Parameters
+`string` **`name`**  
+
+
+</div>
+
+<hr>
+<div id='aliases.list'>
+<h4 class='heading'>
+hilbish.aliases.list() -> table[string, string]
+<a href="#aliases.list" class='heading-link'>
+	<i class="fas fa-paperclip"></i>
+</a>
+</h4>
+
+Get a table of all aliases, with string keys as the alias and the value as the command.  
+
+#### Parameters
+This function has no parameters.  
+#### Example
+```lua
+hilbish.aliases.add('hi', 'echo hi')
+
+local aliases = hilbish.aliases.list()
+-- -> {hi = 'echo hi'}
+```
+</div>
+
+<hr>
+<div id='aliases.resolve'>
+<h4 class='heading'>
+hilbish.aliases.resolve(alias) -> string?
+<a href="#aliases.resolve" class='heading-link'>
+	<i class="fas fa-paperclip"></i>
+</a>
+</h4>
+
+Resolves an alias to its original command. Will thrown an error if the alias doesn't exist.  
+
+#### Parameters
+`string` **`alias`**  
+
+
+</div>
+

docs/api/hilbish/hilbish.completion.md

@@ -0,0 +1,149 @@
+---
+title: Module hilbish.completion
+description: tab completions
+layout: doc
+menu:
+  docs:
+    parent: "API"
+---
+
+## Introduction
+The completions interface deals with tab completions.
+
+## Functions
+|||
+|----|----|
+|<a href="#completion.bins">bins(query, ctx, fields) -> entries (table), prefix (string)</a>|Return binaries/executables based on the provided parameters.|
+|<a href="#completion.call">call(name, query, ctx, fields) -> completionGroups (table), prefix (string)</a>|Calls a completer function. This is mainly used to call a command completer, which will have a `name`|
+|<a href="#completion.files">files(query, ctx, fields) -> entries (table), prefix (string)</a>|Returns file matches based on the provided parameters.|
+|<a href="#completion.handler">handler(line, pos)</a>|This function contains the general completion handler for Hilbish. This function handles|
+
+<hr>
+<div id='completion.bins'>
+<h4 class='heading'>
+hilbish.completion.bins(query, ctx, fields) -> entries (table), prefix (string)
+<a href="#completion.bins" class='heading-link'>
+	<i class="fas fa-paperclip"></i>
+</a>
+</h4>
+
+Return binaries/executables based on the provided parameters.  
+This function is meant to be used as a helper in a command completion handler.  
+
+#### Parameters
+`string` **`query`**  
+
+
+`string` **`ctx`**  
+
+
+`table` **`fields`**  
+
+
+#### Example
+```lua
+-- an extremely simple completer for sudo.
+hilbish.complete('command.sudo', function(query, ctx, fields)
+	table.remove(fields, 1)
+	if #fields[1] then
+		-- return commands because sudo runs a command as root..!
+
+		local entries, pfx = hilbish.completion.bins(query, ctx, fields)
+		return {
+			type = 'grid',
+			items = entries
+		}, pfx
+	end
+
+	-- ... else suggest files or anything else ..
+end)
+```
+</div>
+
+<hr>
+<div id='completion.call'>
+<h4 class='heading'>
+hilbish.completion.call(name, query, ctx, fields) -> completionGroups (table), prefix (string)
+<a href="#completion.call" class='heading-link'>
+	<i class="fas fa-paperclip"></i>
+</a>
+</h4>
+
+Calls a completer function. This is mainly used to call a command completer, which will have a `name`  
+in the form of `command.name`, example: `command.git`.  
+You can check the Completions doc or `doc completions` for info on the `completionGroups` return value.  
+
+#### Parameters
+`string` **`name`**  
+
+
+`string` **`query`**  
+
+
+`string` **`ctx`**  
+
+
+`table` **`fields`**  
+
+
+</div>
+
+<hr>
+<div id='completion.files'>
+<h4 class='heading'>
+hilbish.completion.files(query, ctx, fields) -> entries (table), prefix (string)
+<a href="#completion.files" class='heading-link'>
+	<i class="fas fa-paperclip"></i>
+</a>
+</h4>
+
+Returns file matches based on the provided parameters.  
+This function is meant to be used as a helper in a command completion handler.  
+
+#### Parameters
+`string` **`query`**  
+
+
+`string` **`ctx`**  
+
+
+`table` **`fields`**  
+
+
+</div>
+
+<hr>
+<div id='completion.handler'>
+<h4 class='heading'>
+hilbish.completion.handler(line, pos)
+<a href="#completion.handler" class='heading-link'>
+	<i class="fas fa-paperclip"></i>
+</a>
+</h4>
+
+This function contains the general completion handler for Hilbish. This function handles  
+completion of everything, which includes calling other command handlers, binaries, and files.  
+This function can be overriden to supply a custom handler. Note that alias resolution is required to be done in this function.  
+
+#### Parameters
+`string` **`line`**  
+The current Hilbish command line
+
+`number` **`pos`**  
+Numerical position of the cursor
+
+#### Example
+```lua
+-- stripped down version of the default implementation
+function hilbish.completion.handler(line, pos)
+	local query = fields[#fields]
+
+	if #fields == 1 then
+		-- call bins handler here
+	else
+		-- call command completer or files completer here
+	end
+end
+```
+</div>
+

docs/api/hilbish/hilbish.editor.md

@@ -0,0 +1,103 @@
+---
+title: Module hilbish.editor
+description: interactions for Hilbish's line reader
+layout: doc
+menu:
+  docs:
+    parent: "API"
+---
+
+## Introduction
+The hilbish.editor interface provides functions to
+directly interact with the line editor in use.
+
+## Functions
+|||
+|----|----|
+|<a href="#editor.getLine">getLine() -> string</a>|Returns the current input line.|
+|<a href="#editor.getVimRegister">getVimRegister(register) -> string</a>|Returns the text that is at the register.|
+|<a href="#editor.insert">insert(text)</a>|Inserts text into the Hilbish command line.|
+|<a href="#editor.getChar">getChar() -> string</a>|Reads a keystroke from the user. This is in a format of something like Ctrl-L.|
+|<a href="#editor.setVimRegister">setVimRegister(register, text)</a>|Sets the vim register at `register` to hold the passed text.|
+
+<hr>
+<div id='editor.getLine'>
+<h4 class='heading'>
+hilbish.editor.getLine() -> string
+<a href="#editor.getLine" class='heading-link'>
+	<i class="fas fa-paperclip"></i>
+</a>
+</h4>
+
+Returns the current input line.  
+
+#### Parameters
+This function has no parameters.  
+</div>
+
+<hr>
+<div id='editor.getVimRegister'>
+<h4 class='heading'>
+hilbish.editor.getVimRegister(register) -> string
+<a href="#editor.getVimRegister" class='heading-link'>
+	<i class="fas fa-paperclip"></i>
+</a>
+</h4>
+
+Returns the text that is at the register.  
+
+#### Parameters
+`string` **`register`**  
+
+
+</div>
+
+<hr>
+<div id='editor.insert'>
+<h4 class='heading'>
+hilbish.editor.insert(text)
+<a href="#editor.insert" class='heading-link'>
+	<i class="fas fa-paperclip"></i>
+</a>
+</h4>
+
+Inserts text into the Hilbish command line.  
+
+#### Parameters
+`string` **`text`**  
+
+
+</div>
+
+<hr>
+<div id='editor.getChar'>
+<h4 class='heading'>
+hilbish.editor.getChar() -> string
+<a href="#editor.getChar" class='heading-link'>
+	<i class="fas fa-paperclip"></i>
+</a>
+</h4>
+
+Reads a keystroke from the user. This is in a format of something like Ctrl-L.  
+
+#### Parameters
+This function has no parameters.  
+</div>
+
+<hr>
+<div id='editor.setVimRegister'>
+<h4 class='heading'>
+hilbish.editor.setVimRegister(register, text)
+<a href="#editor.setVimRegister" class='heading-link'>
+	<i class="fas fa-paperclip"></i>
+</a>
+</h4>
+
+Sets the vim register at `register` to hold the passed text.  
+
+#### Parameters
+`string` **`text`**  
+
+
+</div>
+

docs/api/hilbish/hilbish.history.md

@@ -0,0 +1,102 @@
+---
+title: Module hilbish.history
+description: command history
+layout: doc
+menu:
+  docs:
+    parent: "API"
+---
+
+## Introduction
+The history interface deals with command history.
+This includes the ability to override functions to change the main
+method of saving history.
+
+## Functions
+|||
+|----|----|
+|<a href="#history.add">add(cmd)</a>|Adds a command to the history.|
+|<a href="#history.all">all() -> table</a>|Retrieves all history as a table.|
+|<a href="#history.clear">clear()</a>|Deletes all commands from the history.|
+|<a href="#history.get">get(index)</a>|Retrieves a command from the history based on the `index`.|
+|<a href="#history.size">size() -> number</a>|Returns the amount of commands in the history.|
+
+<hr>
+<div id='history.add'>
+<h4 class='heading'>
+hilbish.history.add(cmd)
+<a href="#history.add" class='heading-link'>
+	<i class="fas fa-paperclip"></i>
+</a>
+</h4>
+
+Adds a command to the history.  
+
+#### Parameters
+`string` **`cmd`**  
+
+
+</div>
+
+<hr>
+<div id='history.all'>
+<h4 class='heading'>
+hilbish.history.all() -> table
+<a href="#history.all" class='heading-link'>
+	<i class="fas fa-paperclip"></i>
+</a>
+</h4>
+
+Retrieves all history as a table.  
+
+#### Parameters
+This function has no parameters.  
+</div>
+
+<hr>
+<div id='history.clear'>
+<h4 class='heading'>
+hilbish.history.clear()
+<a href="#history.clear" class='heading-link'>
+	<i class="fas fa-paperclip"></i>
+</a>
+</h4>
+
+Deletes all commands from the history.  
+
+#### Parameters
+This function has no parameters.  
+</div>
+
+<hr>
+<div id='history.get'>
+<h4 class='heading'>
+hilbish.history.get(index)
+<a href="#history.get" class='heading-link'>
+	<i class="fas fa-paperclip"></i>
+</a>
+</h4>
+
+Retrieves a command from the history based on the `index`.  
+
+#### Parameters
+`number` **`index`**  
+
+
+</div>
+
+<hr>
+<div id='history.size'>
+<h4 class='heading'>
+hilbish.history.size() -> number
+<a href="#history.size" class='heading-link'>
+	<i class="fas fa-paperclip"></i>
+</a>
+</h4>
+
+Returns the amount of commands in the history.  
+
+#### Parameters
+This function has no parameters.  
+</div>
+

docs/api/hilbish/hilbish.jobs.md

@@ -0,0 +1,146 @@
+---
+title: Module hilbish.jobs
+description: background job management
+layout: doc
+menu:
+  docs:
+    parent: "API"
+---
+
+## Introduction
+
+Manage interactive jobs in Hilbish via Lua.
+
+Jobs are the name of background tasks/commands. A job can be started via
+interactive usage or with the functions defined below for use in external runners.
+
+## Functions
+|||
+|----|----|
+|<a href="#jobs.add">add(cmdstr, args, execPath)</a>|Creates a new job. This function does not run the job. This function is intended to be|
+|<a href="#jobs.all">all() -> table[@Job]</a>|Returns a table of all job objects.|
+|<a href="#jobs.disown">disown(id)</a>|Disowns a job. This simply deletes it from the list of jobs without stopping it.|
+|<a href="#jobs.get">get(id) -> @Job</a>|Get a job object via its ID.|
+|<a href="#jobs.last">last() -> @Job</a>|Returns the last added job to the table.|
+
+<hr>
+<div id='jobs.add'>
+<h4 class='heading'>
+hilbish.jobs.add(cmdstr, args, execPath)
+<a href="#jobs.add" class='heading-link'>
+	<i class="fas fa-paperclip"></i>
+</a>
+</h4>
+
+Creates a new job. This function does not run the job. This function is intended to be  
+used by runners, but can also be used to create jobs via Lua. Commanders cannot be ran as jobs.  
+
+#### Parameters
+`string` **`cmdstr`**  
+String that a user would write for the job
+
+`table` **`args`**  
+Arguments for the commands. Has to include the name of the command.
+
+`string` **`execPath`**  
+Binary to use to run the command. Needs to be an absolute path.
+
+#### Example
+```lua
+hilbish.jobs.add('go build', {'go', 'build'}, '/usr/bin/go')
+```
+</div>
+
+<hr>
+<div id='jobs.all'>
+<h4 class='heading'>
+hilbish.jobs.all() -> table[<a href="/Hilbish/docs/api/hilbish/hilbish.jobs/#job" style="text-decoration: none;" id="lol">Job</a>]
+<a href="#jobs.all" class='heading-link'>
+	<i class="fas fa-paperclip"></i>
+</a>
+</h4>
+
+Returns a table of all job objects.  
+
+#### Parameters
+This function has no parameters.  
+</div>
+
+<hr>
+<div id='jobs.disown'>
+<h4 class='heading'>
+hilbish.jobs.disown(id)
+<a href="#jobs.disown" class='heading-link'>
+	<i class="fas fa-paperclip"></i>
+</a>
+</h4>
+
+Disowns a job. This simply deletes it from the list of jobs without stopping it.  
+
+#### Parameters
+`number` **`id`**  
+
+
+</div>
+
+<hr>
+<div id='jobs.get'>
+<h4 class='heading'>
+hilbish.jobs.get(id) -> <a href="/Hilbish/docs/api/hilbish/hilbish.jobs/#job" style="text-decoration: none;" id="lol">Job</a>
+<a href="#jobs.get" class='heading-link'>
+	<i class="fas fa-paperclip"></i>
+</a>
+</h4>
+
+Get a job object via its ID.  
+
+#### Parameters
+This function has no parameters.  
+</div>
+
+<hr>
+<div id='jobs.last'>
+<h4 class='heading'>
+hilbish.jobs.last() -> <a href="/Hilbish/docs/api/hilbish/hilbish.jobs/#job" style="text-decoration: none;" id="lol">Job</a>
+<a href="#jobs.last" class='heading-link'>
+	<i class="fas fa-paperclip"></i>
+</a>
+</h4>
+
+Returns the last added job to the table.  
+
+#### Parameters
+This function has no parameters.  
+</div>
+
+## Types
+<hr>
+
+## Job
+The Job type describes a Hilbish job.
+## Object properties
+|||
+|----|----|
+|cmd|The user entered command string for the job.|
+|running|Whether the job is running or not.|
+|id|The ID of the job in the job table|
+|pid|The Process ID|
+|exitCode|The last exit code of the job.|
+|stdout|The standard output of the job. This just means the normal logs of the process.|
+|stderr|The standard error stream of the process. This (usually) includes error messages of the job.|
+
+
+### Methods
+#### background()
+Puts a job in the background. This acts the same as initially running a job.
+
+#### foreground()
+Puts a job in the foreground. This will cause it to run like it was
+executed normally and wait for it to complete.
+
+#### start()
+Starts running the job.
+
+#### stop()
+Stops the job from running.
+

docs/api/hilbish/hilbish.module.md

@@ -0,0 +1,73 @@
+---
+title: Module hilbish.module
+description: native module loading
+layout: doc
+menu:
+  docs:
+    parent: "API"
+---
+
+## Introduction
+
+The hilbish.module interface provides a function to load
+Hilbish plugins/modules. Hilbish modules are Go-written
+plugins (see https://pkg.go.dev/plugin) that are used to add functionality
+to Hilbish that cannot be written in Lua for any reason.
+
+Note that you don't ever need to use the load function that is here as
+modules can be loaded with a `require` call like Lua C modules, and the
+search paths can be changed with the `paths` property here.
+
+To make a valid native module, the Go plugin has to export a Loader function
+with a signature like so: `func(*rt.Runtime) rt.Value`.
+
+`rt` in this case refers to the Runtime type at
+https://pkg.go.dev/github.com/arnodel/golua@master/runtime#Runtime
+
+Hilbish uses this package as its Lua runtime. You will need to read
+it to use it for a native plugin.
+
+Here is some code for an example plugin:
+```go
+package main
+
+import (
+	rt "github.com/arnodel/golua/runtime"
+)
+
+func Loader(rtm *rt.Runtime) rt.Value {
+	return rt.StringValue("hello world!")
+}
+```
+
+This can be compiled with `go build -buildmode=plugin plugin.go`.
+If you attempt to require and print the result (`print(require 'plugin')`), it will show "hello world!"
+
+## Functions
+|||
+|----|----|
+|<a href="#module.load">load(path)</a>|Loads a module at the designated `path`.|
+
+## Static module fields
+|||
+|----|----|
+|paths|A list of paths to search when loading native modules. This is in the style of Lua search paths and will be used when requiring native modules. Example: `?.so;?/?.so`|
+
+<hr>
+<div id='module.load'>
+<h4 class='heading'>
+hilbish.module.load(path)
+<a href="#module.load" class='heading-link'>
+	<i class="fas fa-paperclip"></i>
+</a>
+</h4>
+
+Loads a module at the designated `path`.  
+It will throw if any error occurs.  
+
+#### Parameters
+`string` **`path`**  
+
+
+</div>
+

docs/api/hilbish/hilbish.os.md

@@ -0,0 +1,20 @@
+---
+title: Module hilbish.os
+description: operating system info
+layout: doc
+menu:
+  docs:
+    parent: "API"
+---
+
+## Introduction
+Provides simple text information properties about the current operating system.
+This mainly includes the name and version.
+
+## Static module fields
+|||
+|----|----|
+|family|Family name of the current OS|
+|name|Pretty name of the current OS|
+|version|Version of the current OS|
+

docs/api/hilbish/hilbish.runner.md

@@ -0,0 +1,114 @@
+---
+title: Module hilbish.runner
+description: interactive command runner customization
+layout: doc
+menu:
+  docs:
+    parent: "API"
+---
+
+## Introduction
+ The runner interface contains functions that allow the user to change
+how Hilbish interprets interactive input.
+Users can add and change the default runner for interactive input to any
+language or script of their choosing. A good example is using it to
+write command in Fennel.
+
+Runners are functions that evaluate user input. The default runners in
+Hilbish can run shell script and Lua code.
+
+A runner is passed the input and has to return a table with these values.
+All are not required, only the useful ones the runner needs to return.
+(So if there isn't an error, just omit `err`.)
+
+- `exitCode` (number): A numerical code to indicate the exit result.
+- `input` (string): The user input. This will be used to add
+to the history.
+- `err` (string): A string to indicate an interal error for the runner.
+It can be set to a few special values for Hilbish to throw the right hooks and have a better looking message:
+
+`[command]: not-found` will throw a command.not-found hook based on what `[command]` is.
+
+`[command]: not-executable` will throw a command.not-executable hook.
+- `continue` (boolean): Whether to prompt the user for more input.
+
+Here is a simple example of a fennel runner. It falls back to
+shell script if fennel eval has an error.
+```lua
+local fennel = require 'fennel'
+
+hilbish.runnerMode(function(input)
+	local ok = pcall(fennel.eval, input)
+	if ok then
+		return {
+			input = input
+		}
+	end
+
+	return hilbish.runner.sh(input)
+end)
+```
+
+## Functions
+|||
+|----|----|
+|<a href="#runner.setMode">setMode(cb)</a>|This is the same as the `hilbish.runnerMode` function.|
+|<a href="#runner.lua">lua(cmd)</a>|Evaluates `cmd` as Lua input. This is the same as using `dofile`|
+|<a href="#runner.sh">sh(cmd)</a>|Runs a command in Hilbish's shell script interpreter.|
+
+<hr>
+<div id='runner.setMode'>
+<h4 class='heading'>
+hilbish.runner.setMode(cb)
+<a href="#runner.setMode" class='heading-link'>
+	<i class="fas fa-paperclip"></i>
+</a>
+</h4>
+
+This is the same as the `hilbish.runnerMode` function.  
+It takes a callback, which will be used to execute all interactive input.  
+In normal cases, neither callbacks should be overrided by the user,  
+as the higher level functions listed below this will handle it.  
+
+#### Parameters
+`function` **`cb`**  
+
+
+</div>
+
+<hr>
+<div id='runner.lua'>
+<h4 class='heading'>
+hilbish.runner.lua(cmd)
+<a href="#runner.lua" class='heading-link'>
+	<i class="fas fa-paperclip"></i>
+</a>
+</h4>
+
+Evaluates `cmd` as Lua input. This is the same as using `dofile`  
+or `load`, but is appropriated for the runner interface.  
+
+#### Parameters
+`string` **`cmd`**  
+
+
+</div>
+
+<hr>
+<div id='runner.sh'>
+<h4 class='heading'>
+hilbish.runner.sh(cmd)
+<a href="#runner.sh" class='heading-link'>
+	<i class="fas fa-paperclip"></i>
+</a>
+</h4>
+
+Runs a command in Hilbish's shell script interpreter.  
+This is the equivalent of using `source`.  
+
+#### Parameters
+`string` **`cmd`**  
+
+
+</div>
+

docs/api/hilbish/hilbish.timers.md

@@ -0,0 +1,100 @@
+---
+title: Module hilbish.timers
+description: timeout and interval API
+layout: doc
+menu:
+  docs:
+    parent: "API"
+---
+
+## Introduction
+
+If you ever want to run a piece of code on a timed interval, or want to wait
+a few seconds, you don't have to rely on timing tricks, as Hilbish has a
+timer API to set intervals and timeouts.
+
+These are the simple functions `hilbish.interval` and `hilbish.timeout` (doc
+accessible with `doc hilbish`, or `Module hilbish` on the Website).
+
+An example of usage:
+```lua
+local t = hilbish.timers.create(hilbish.timers.TIMEOUT, 5000, function()
+	print 'hello!'
+end)
+
+t:start()
+print(t.running) // true
+```
+
+## Functions
+|||
+|----|----|
+|<a href="#timers.create">create(type, time, callback) -> @Timer</a>|Creates a timer that runs based on the specified `time`.|
+|<a href="#timers.get">get(id) -> @Timer</a>|Retrieves a timer via its ID.|
+
+## Static module fields
+|||
+|----|----|
+|INTERVAL|Constant for an interval timer type|
+|TIMEOUT|Constant for a timeout timer type|
+
+<hr>
+<div id='timers.create'>
+<h4 class='heading'>
+hilbish.timers.create(type, time, callback) -> <a href="/Hilbish/docs/api/hilbish/hilbish.timers/#timer" style="text-decoration: none;" id="lol">Timer</a>
+<a href="#timers.create" class='heading-link'>
+	<i class="fas fa-paperclip"></i>
+</a>
+</h4>
+
+Creates a timer that runs based on the specified `time`.  
+
+#### Parameters
+`number` **`type`**  
+What kind of timer to create, can either be `hilbish.timers.INTERVAL` or `hilbish.timers.TIMEOUT`
+
+`number` **`time`**  
+The amount of time the function should run in milliseconds.
+
+`function` **`callback`**  
+The function to run for the timer.
+
+</div>
+
+<hr>
+<div id='timers.get'>
+<h4 class='heading'>
+hilbish.timers.get(id) -> <a href="/Hilbish/docs/api/hilbish/hilbish.timers/#timer" style="text-decoration: none;" id="lol">Timer</a>
+<a href="#timers.get" class='heading-link'>
+	<i class="fas fa-paperclip"></i>
+</a>
+</h4>
+
+Retrieves a timer via its ID.  
+
+#### Parameters
+`number` **`id`**  
+
+
+</div>
+
+## Types
+<hr>
+
+## Timer
+The Job type describes a Hilbish timer.
+## Object properties
+|||
+|----|----|
+|type|What type of timer it is|
+|running|If the timer is running|
+|duration|The duration in milliseconds that the timer will run|
+
+
+### Methods
+#### start()
+Starts a timer.
+
+#### stop()
+Stops a timer.
+

docs/api/hilbish/hilbish.userDir.md

@@ -0,0 +1,20 @@
+---
+title: Module hilbish.userDir
+description: user-related directories
+layout: doc
+menu:
+  docs:
+    parent: "API"
+---
+
+## Introduction
+This interface just contains properties to know about certain user directories.
+It is equivalent to XDG on Linux and gets the user's preferred directories
+for configs and data.
+
+## Static module fields
+|||
+|----|----|
+|config|The user's config directory|
+|data|The user's directory for program data|
+

docs/api/terminal.md

@@ -0,0 +1,81 @@
+---
+title: Module terminal
+description: low level terminal library
+layout: doc
+menu:
+  docs:
+    parent: "API"
+---
+
+## Introduction
+The terminal library is a simple and lower level library for certain terminal interactions.
+
+## Functions
+|||
+|----|----|
+|<a href="#restoreState">restoreState()</a>|Restores the last saved state of the terminal|
+|<a href="#saveState">saveState()</a>|Saves the current state of the terminal.|
+|<a href="#setRaw">setRaw()</a>|Puts the terminal into raw mode.|
+|<a href="#size">size()</a>|Gets the dimensions of the terminal. Returns a table with `width` and `height`|
+
+<hr>
+<div id='restoreState'>
+<h4 class='heading'>
+terminal.restoreState()
+<a href="#restoreState" class='heading-link'>
+	<i class="fas fa-paperclip"></i>
+</a>
+</h4>
+
+Restores the last saved state of the terminal  
+
+#### Parameters
+This function has no parameters.  
+</div>
+
+<hr>
+<div id='saveState'>
+<h4 class='heading'>
+terminal.saveState()
+<a href="#saveState" class='heading-link'>
+	<i class="fas fa-paperclip"></i>
+</a>
+</h4>
+
+Saves the current state of the terminal.  
+
+#### Parameters
+This function has no parameters.  
+</div>
+
+<hr>
+<div id='setRaw'>
+<h4 class='heading'>
+terminal.setRaw()
+<a href="#setRaw" class='heading-link'>
+	<i class="fas fa-paperclip"></i>
+</a>
+</h4>
+
+Puts the terminal into raw mode.  
+
+#### Parameters
+This function has no parameters.  
+</div>
+
+<hr>
+<div id='size'>
+<h4 class='heading'>
+terminal.size()
+<a href="#size" class='heading-link'>
+	<i class="fas fa-paperclip"></i>
+</a>
+</h4>
+
+Gets the dimensions of the terminal. Returns a table with `width` and `height`  
+NOTE: The size refers to the amount of columns and rows of text that can fit in the terminal.  
+
+#### Parameters
+This function has no parameters.  
+</div>
+

docs/bait.txt

@@ -1,4 +0,0 @@
-catch(name, cb) > Catches a hook with `name`. Runs the `cb` when it is thrown
-
-throw(name, ...args) > Throws a hook with `name` with the provided `args`
-

docs/commander.txt

@@ -1,4 +0,0 @@
-deregister(name) > Deregisters any command registered with `name`
-
-register(name, cb) > Register a command with `name` that runs `cb` when ran
-

docs/completions.md

@@ -0,0 +1,78 @@
+---
+title: Completions
+description: Tab completion for commands.
+layout: doc
+menu: 
+  docs:
+    parent: "Features"
+---
+
+Completions for commands can be created with the [`hilbish.complete`](../api/hilbish#complete)
+function. See the link for how to use it.
+
+To create completions for a command is simple.
+The callback will be passed 3 parameters:
+- `query` (string): The text that the user is currently trying to complete.
+This should be used to match entries.
+- `ctx` (string): Contains the entire line. Use this if
+more text is needed to be parsed for context.
+- `fields` (string): The `ctx` split up by spaces.
+
+In most cases, the completer just uses `fields` to check the amount
+and `query` on what to match entries on.
+
+In order to return your results, it has to go within a "completion group."
+Then you return a table of completion groups and a prefix. The prefix will
+usually just be the `query`.
+
+Hilbish allows one to mix completion menus of different types, so
+a grid menu and a list menu can be used and complete and display at the same time.
+A completion group is a table with these keys:
+- `type` (string): type of completion menu, either `grid` or `list`.
+- `items` (table): a list of items. 
+
+The requirements of the `items` table is different based on the
+`type`. If it is a `grid`, it can simply be a table of strings.
+
+Otherwise if it is a `list` then each entry can
+either be a string or a table.
+Example:
+```lua
+local cg = {
+	items = {
+		'list item 1',
+		['--command-flag-here'] = {'this does a thing', '--the-flag-alias'}
+	},
+	type = 'list'
+}
+local cg2 = {
+	items = {'just', 'a bunch', 'of items', 'here', 'hehe'},
+	type = 'grid'
+}
+
+return {cg, cg2}, prefix
+```
+
+Which looks like this:  
+{{< video src="https://safe.saya.moe/t4CiLK6dgPbD.mp4" >}}
+
+# Completion Handler
+Like most parts of Hilbish, it's made to be extensible and
+customizable. The default handler for completions in general can
+be overwritten to provide more advanced completions if needed.
+This usually doesn't need to be done though, unless you know
+what you're doing.
+
+The default completion handler provides 3 things:
+binaries (with a plain name requested to complete, those in
+$PATH), files, or command completions. It will try to run a handler
+for the  command or fallback to file completions.
+
+To overwrite it, just assign a function to `hilbish.completion.handler` like so:
+```lua
+-- line is the entire line as a string
+-- pos is the position of the cursor.
+function hilbish.completion.handler(line, pos)
+	-- do things
+end
+```

docs/faq.md

@@ -0,0 +1,26 @@
+---
+title: Frequently Asked Questions
+layout: doc
+weight: -20
+menu: docs
+---
+
+# Is Hilbish POSIX compliant?
+No, it is not. POSIX compliance is a non-goal. Perhaps in the future,
+someone would be able to write a native plugin to support shell scripting
+(which would be against it's main goal, but ....)
+
+# Windows Support?
+It compiles for Windows (CI ensures it does), but otherwise it is not
+directly supported. If you'd like to improve this situation,
+checkout [the discussion](https://github.com/Rosettea/Hilbish/discussions/165).
+
+# Why?
+Hilbish emerged from the desire of a Lua configured shell.
+It was the initial reason that it was created, but now it's more:
+to be hyper extensible, simpler and more user friendly.
+
+# Does it have "autocompletion" or "tab completion"
+Of course! This is a modern shell. Hilbish provides a way for users
+to write tab completion for any command and/or the whole shell.
+Inline hinting and syntax highlighting are also available.

docs/features/_index.md

@@ -0,0 +1,11 @@
+---
+title: Features
+layout: doc
+weight: -40
+menu: docs
+---
+
+Hilbish has a wide range of features to enhance the user's experience 
+new ones are always being added. If there is something missing here or
+something you would like to see, please [start a discussion](https://github.com/Rosettea/Hilbish/discussions)
+or comment on any existing ones which match your request.

docs/features/notifications.md

@@ -0,0 +1,39 @@
+---
+title: Notification
+description: Get notified of shell actions.
+layout: doc
+menu: 
+  docs:
+    parent: "Features"
+---
+
+Hilbish features a simple notification system which can be
+used by other plugins and parts of the shell to notify the user
+of various actions. This is used via the `hilbish.message` interface.
+
+A `message` is defined as a table with the following properties:
+- `icon`: A unicode/emoji icon for the notification.
+- `title`: The title of the message
+- `text`: Message text/body
+- `channel`: The source of the message. This should be a
+unique and easily readable text identifier.
+- `summary`: A short summary of the notification and message.
+If this is not present and you are using this to display messages,
+you should take part of the `text` instead.
+
+The `hilbish.message` interface provides the following functions:
+- `send(message)`: Sends a message and emits the `hilbish.notification`
+signal. DO NOT emit the `hilbish.notification` signal directly, or
+the message will not be stored by the message handler.
+- `read(idx)`: Marks message at `idx` as read.
+- `delete(idx)`: Removes message at `idx`.
+- `readAll()`: Marks all messages as read.
+- `clear()`: Deletes all messages.
+
+There are a few simple use cases of this notification/messaging system.
+It could also be used as some "inter-shell" messaging system (???) but
+is intended to display to users.
+
+An example is notifying users of completed jobs/commands ran in the background.
+Any Hilbish-native command (think the upcoming Greenhouse pager) can display
+it.

docs/features/opts.md

@@ -0,0 +1,78 @@
+---
+title: Options
+description: Simple customizable options.
+layout: doc
+menu: 
+  docs:
+    parent: "Features"
+---
+
+Opts are simple toggle or value options a user can set in Hilbish.
+As toggles, there are things like `autocd` or history saving. As values,
+there is the `motd` which the user can either change to a custom string or disable.
+
+Opts are accessed from the `hilbish.opts` table. Here they can either
+be read or modified
+
+### `autocd`
+#### Value: `boolean`
+#### Default: `false`
+
+The autocd opt makes it so that lone directories attempted to be executed are
+instead set as the shell's directory.
+
+Example:
+```
+~/Directory                                     
+∆ ~
+~                                                                             
+∆ Downloads
+~/Downloads                                                                   
+∆ ../Documents
+~/Documents                                                                   
+∆ 
+```
+
+<hr>
+
+### `history`
+#### Value: `boolean`
+#### Default: `true`
+Sets whether command history will be saved or not.
+
+<hr>
+	
+### `greeting`
+#### Value: `boolean` or `string`
+The greeting is the message that Hilbish shows on startup
+(the one which says Welcome to Hilbish).
+
+This can be set to either true/false to enable/disable or a custom greeting string.
+
+<hr>
+
+### `motd`
+#### Value: `boolean`
+#### Default: `true`
+The message of the day shows the current major.minor version and
+includes a small range of things added in the current release.
+
+This can be set to `false` to disable the message.
+
+<hr>
+
+### `fuzzy`
+#### Value: `boolean`
+#### Default: `false`
+Toggles the functionality of fuzzy history searching, usable
+via the menu in Ctrl-R. Fuzzy searching is an approximate searching
+method, which means results that match *closest* will be shown instead
+of an exact match.
+
+<hr>
+
+### `notifyJobFinish`
+#### Value: `boolean`
+#### Default: `true`
+If this is enabled, when a background job is finished,
+a [notification](../notifications) will be sent.

docs/features/runner-mode.md

@@ -0,0 +1,66 @@
+---
+title: Runner Mode
+description: Customize the interactive script/command runner.
+layout: doc
+menu: 
+  docs:
+    parent: "Features"
+---
+
+Hilbish allows you to change how interactive text can be interpreted.
+This is mainly due to the fact that the default method Hilbish uses
+is that it runs Lua first and then falls back to shell script.
+
+In some cases, someone might want to switch to just shell script to avoid
+it while interactive but still have a Lua config, or go full Lua to use
+Hilbish as a REPL. This also allows users to add alternative languages like
+Fennel as the interactive script runner.
+
+Runner mode can also be used to handle specific kinds of input before
+evaluating like normal, which is how [Link.hsh](https://github.com/TorchedSammy/Link.hsh)
+handles links.
+
+The "runner mode" of Hilbish is customizable via `hilbish.runnerMode`,
+which determines how Hilbish will run user input. By default, this is
+set to `hybrid` which is the previously mentioned behaviour of running Lua
+first then going to shell script. If you want the reverse order, you can
+set it to `hybridRev` and for isolated modes there is `sh` and `lua`
+respectively.
+
+You can also set it to a function, which will be called everytime Hilbish
+needs to run interactive input. For more detail, see the [API documentation](../../api/hilbish/hilbish.runner)
+
+The `hilbish.runner` interface is an alternative to using `hilbish.runnerMode`
+and also provides the shell script and Lua runner functions that Hilbish itself uses.
+
+A runner function is expected to return a table with the following values:
+- `exitCode` (number): Exit code of the command
+- `input` (string): The text input of the user. This is used by Hilbish to append extra input, in case
+more is requested.
+- `err` (string): A string that represents an error from the runner.
+This should only be set when, for example, there is a syntax error.
+It can be set to a few special values for Hilbish to throw the right
+hooks and have a better looking message.
+	- `<command>: not-found` will throw a `command.not-found` hook
+	based on what `<command>` is.
+	- `<command>: not-executable` will throw a `command.not-executable` hook.
+- `continue` (boolean): Whether Hilbish should prompt the user for no input
+
+## Functions
+These are the "low level" functions for the `hilbish.runner` interface.
+
++ setMode(mode) > The same as `hilbish.runnerMode`
++ sh(input) -> table > Runs `input` in Hilbish's sh interpreter
++ lua(input) -> table > Evals `input` as Lua code
+
+These functions should be preferred over the previous ones.
++ setCurrent(mode) > The same as `setMode`, but works with runners managed
+via the functions below.
++ add(name, runner) > Adds a runner to a table of available runners. The `runner`
+argument is either a function or a table with a run callback.
++ set(name, runner) > The same as `add` but requires passing a table and
+overwrites if the `name`d runner already exists.
++ get(name) > runner > Gets a runner by name. It is a table with at least a
+run function, to run input.
++ exec(cmd, runnerName) > Runs `cmd` with a runner. If `runnerName` isn't passed,
+the current runner mode is used.

docs/fs.txt

@@ -1,8 +0,0 @@
-cd(dir) > Changes directory to `dir`
-
-mkdir(name, recursive) > Makes a directory called `name`. If `recursive` is true, it will create its parent directories.
-
-readdir(dir) > Returns a table of files in `dir`
-
-stat(path) > Returns info about `path`
-

docs/getting-started.md

@@ -0,0 +1,60 @@
+---
+title: Getting Started
+layout: doc
+weight: -10
+menu: docs
+---
+
+To start Hilbish, open a terminal. If Hilbish has been installed and is not the
+default shell, you can simply run `hilbish` to start it. This will launch
+a normal interactive session.
+To exit, you can either run the `exit` command or hit Ctrl+D.
+
+# Setting as Default
+## Login shell
+There are a few ways to make Hilbish your default shell. A simple way is 
+to make it your user/login shell.
+
+{{< warning `It is not recommended to set Hilbish as your login shell. That
+is expected to be a POSIX compliant shell, which Hilbish is not. Though if
+you still decide to do it, there will just be a few variables missing in
+your environment` >}}
+
+To do that, simply run `chsh -s /usr/bin/hilbish`.
+Some distros (namely Fedora) might have `lchsh` instead, which is used like `lchsh <user>`.
+When prompted, you can put the path for Hilbish.
+
+## Default with terminal
+The simpler way is to set the default shell for your terminal. The way of 
+doing this depends on how your terminal settings are configured.
+
+## Run after login shell
+Some shells (like zsh) have an rc file, like `.zlogin`, which is ran when the shell session
+is a login shell. In that file, you can run Hilbish. Example:
+
+```
+exec hilbish -S -l
+```
+
+This will replace the shell with Hilbish, set $SHELL to Hilbish and launch it as a login shell.
+
+# Configuration
+Once installation and setup has been done, you can then configure Hilbish.
+It is configured and scripted via Lua, so the config file is a Lua file.
+You can use any pure Lua library to do whatever you want.
+
+Hilbish's sample configuration is usually located in `hilbish.dataDir .. '/.hilbishrc.lua'`.
+You can print that path via Lua to see what it is: `print(hilbish.dataDir .. '/.hilbishrc.lua')`.
+As an example, it will usually will result in `/usr/share/hilbish/.hilbishrc.lua` on Linux.
+
+To edit your user configuration, you can copy that file to `hilbish.userDir.config .. '/hilbish/init.lua'`,
+which follows XDG on Linux and MacOS, and is located in %APPDATA% on Windows.
+
+As the directory is usually `~/.config` on Linux, you can run this command to copy it:  
+`cp /usr/share/hilbish/.hilbishrc.lua ~/.config/hilbish/init.lua`
+
+Now you can get to editing it. Since it's just a Lua file, having basic
+knowledge of Lua would help. All of Lua's standard libraries and functions
+from Lua 5.4 are available. Hilbish has some custom and modules that are
+available. To see them, you can run the `doc` command. This also works as
+general documentation for other things.

docs/global.txt

@@ -1,29 +0,0 @@
-alias(cmd, orig) > Sets an alias of `orig` to `cmd`
-
-appendPath(dir) > Appends `dir` to $PATH
-
-complete(scope, cb) > Registers a completion handler for `scope`.
-A `scope` is currently only expected to be `command.<cmd>`,
-replacing <cmd> with the name of the command (for example `command.git`).
-`cb` must be a function that returns a table of the entries to complete.
-Nested tables will be used as sub-completions.
-
-exec(cmd) > Replaces running hilbish with `cmd`
-
-goro(fn) > Puts `fn` in a goroutine
-
-interval(cb, time) > Runs the `cb` function every `time` milliseconds
-
-multiprompt(str) > Changes the continued line prompt to `str`
-
-prependPath(dir) > Prepends `dir` to $PATH
-
- prompt(str) > Changes the shell prompt to `str`
-There are a few verbs that can be used in the prompt text.
-These will be formatted and replaced with the appropriate values.
-`%d` - Current working directory
-`%u` - Name of current user
-`%h` - Hostname of device
-
-timeout(cb, time) > Runs the `cb` function after `time` in milliseconds
-

docs/hilbish.txt

@@ -1,10 +0,0 @@
-cwd() > Returns the current directory of the shell
-
-flag(f) > Checks if the `f` flag has been passed to Hilbish.
-
-read(prompt) -> input? > Read input from the user, using Hilbish's line editor/input reader.
-This is a separate instance from the one Hilbish actually uses.
-Returns `input`, will be nil if ctrl + d is pressed, or an error occurs (which shouldn't happen)
-
-run(cmd) > Runs `cmd` in Hilbish's sh interpreter
-

docs/hooks/_index.md

@@ -0,0 +1,11 @@
+---
+title: Signals
+description:
+layout: doc
+weight: -50
+menu:
+  docs
+---
+
+Signals are global events emitted with the [Bait](../api/bait) module.
+For more detail on how to use these signals, you may check the Bait page.

docs/hooks/command.md

@@ -0,0 +1,67 @@
+---
+title: Command
+description:
+layout: doc
+menu:
+  docs:
+    parent: "Signals"
+---
+
+## command.preexec
+Thrown right before a command is executed.
+
+#### Variables
+`string` **`input`**  
+The raw string that the user typed. This will include the text
+without changes applied to it (argument substitution, alias expansion,
+etc.)
+
+`string` **`cmdStr`**  
+The command that will be directly executed by the current runner.
+
+<hr>
+
+## command.exit
+Thrown after the user's ran command is finished.
+
+#### Variables
+`number` **`code`**  
+The exit code of what was executed.
+
+`string` **`cmdStr`**  
+The command or code that was executed
+
+<hr>
+	
+## command.not-found
+Thrown if the command attempted to execute was not found.
+This can be used to customize the text printed when a command is not found.
+Example:
+```lua
+local bait = require 'bait'
+-- Remove any present handlers on `command.not-found`
+
+local notFoundHooks = bait.hooks 'command.not-found'
+for _, hook in ipairs(notFoundHooks) do
+	bait.release('command.not-found', hook)
+end
+
+-- then assign custom
+bait.catch('command.not-found', function(cmd)
+	print(string.format('The command "%s" was not found.', cmd))
+end)
+```
+
+#### Variables
+`string` **`cmdStr`**  
+The name of the command.
+
+<hr>
+	
+## command.not-executable
+Thrown when the user attempts to run a file that is not executable
+(like a text file, or Unix binary without +x permission).
+
+#### Variables
+`string` **`cmdStr`**  
+The name of the command.

docs/hooks/command.txt

@@ -1,7 +0,0 @@
-+ `command.exit` -> code, cmdStr > Thrown when a command exits.
-`code` is the exit code of the command, and `cmdStr` is the command that was run.
-
-+ `command.not-found` -> cmdStr > Thrown when a command is not found.
-
-+ `command.no-perm` -> cmdStr > Thrown when Hilbish attempts to execute a file but
-has no permission.

docs/hooks/hilbish.md

@@ -0,0 +1,47 @@
+---
+title: Hilbish
+description:
+layout: doc
+menu:
+  docs:
+    parent: "Signals"
+---
+
+## hilbish.exit
+Sent when Hilbish is going to exit.
+
+#### Variables
+This signal returns no variables.
+
+<hr>
+
+## hilbish.vimMode
+Sent when the Vim mode of Hilbish is changed (like from insert to normal mode).
+This can be used to change the prompt and notify based on Vim mode.
+
+#### Variables
+`string` **`modeName`**  
+The mode that has been set.
+Can be these values: `insert`, `normal`, `delete` or `replace`
+
+<hr>
+
+## hilbish.cancel
+Sent when the user cancels their command input with Ctrl-C
+
+#### Variables
+This signal returns no variables.
+
+<hr>
+
+## hilbish.notification
+Thrown when a [notification](../../features/notifications) is sent.
+
+#### Variables
+`table` **`notification`**  
+The notification. The properties are defined in the link above.
+
+<hr>
+
++ `hilbish.vimAction` -> actionName, args > Sent when the user does a "vim action," being something
+like yanking or pasting text. See `doc vim-mode actions` for more info.

docs/hooks/index.txt

@@ -1,8 +0,0 @@
-Here is listed all scopes for bait hooks. If a hook is related to a command,
-it will have the `command` scope, as example.
-
-Here is the format for a doc for a hook:
-+ <hook name> -> <args> > <description>
-
-`<args>` just means the arguments of the hook. If a hook doc has the format
-of `arg...`, it means the hook can take/recieve any number of `arg`.

docs/hooks/job.md

@@ -0,0 +1,7 @@
+Note: `job` refers to a job object. You can check `doc jobs` for more
+detail.
+
++ `job.start` -> job > Thrown when a new background job starts.
+
++ `job.done` -> job > Thrown when a background jobs exits.
+

docs/hooks/signal.md

@@ -0,0 +1,40 @@
+---
+title: Signal
+description:
+layout: doc
+menu:
+  docs:
+    parent: "Signals"
+---
+
+## signal.sigint
+Thrown when Hilbish receive the SIGINT signal,
+aka when Ctrl-C is pressed.
+
+#### Variables
+This signal returns no variables.
+
+<hr>
+	
+## signal.resize
+Thrown when the terminal is resized.
+
+#### Variables
+This signal returns no variables.
+
+<hr>
+
+## signal.sigusr1
+Thrown when SIGUSR1 is sent to Hilbish.
+
+#### Variables
+This signal returns no variables.
+
+<hr>
+
+## signal.sigusr2
+Thrown when SIGUSR2 is sent to Hilbish.
+
+#### Variables
+This signal returns no variables.
+

docs/hooks/signal.txt

@@ -1,3 +0,0 @@
-+ `signal.sigint` > Sent when Hilbish receives SIGINT (used to Ctrl-C).
-
-+ `signal.resize` > Sent when the terminal is resized.

docs/jobs.md

@@ -0,0 +1,48 @@
+(This has mainly been replaced by [hilbish.jobs](../api/hilbish.jobs)).
+
+Hilbish has pretty standard job control. It's missing one or two things,
+but works well. One thing which is different from other shells
+(besides Hilbish) itself is the API for jobs, and of course it's in Lua.
+You can add jobs, stop and delete (disown) them and even get output.
+
+# Job Interface
+The job interface refers to `hilbish.jobs`.
+## Functions
+(Note that in the list here, they're called from `hilbish.jobs`, so
+a listing of `foo` would mean `hilbish.jobs.foo`)
+
+- `all()` -> {jobs}: Returns a table of all jobs.
+- `last()` -> job: Returns the last added job.
+- `get(id)` -> job: Get a job by its ID.
+- `add(cmdstr, args, execPath)` -> job: Adds a new job to the job table.
+Note that this does not run the command; You have to start it manually.
+`cmdstr` is the user's input for the job, `args` is a table of arguments
+for the command. It includes arg0 (don't set it as entry 0 in the table)
+and `execPath` is an absolute path for the command executable.
+- `disown(id)`: Removes a job by ID from the job table.
+
+# Job Object
+A job object is a piece of `userdata`. All the functions of a job require
+you to call them with a colon, since they are *methods* for the job object.
+Example: hilbish.jobs.last():foreground()
+Which will foreground the last job.
+
+You can still have a job object for a disowned job,
+it just won't be *working* anywhere. :^)
+
+## Properties
+- `cmd`: command string
+- `running`: boolean whether the job is running
+- `id`: unique id for the job
+- `pid`: process id for the job
+- `exitCode`: exit code of the job
+In ordinary cases you'd prefer to use the `id` instead of `pid`.
+The `id` is unique to Hilbish and is how you get jobs with the
+`hilbish.jobs` interface. It may also not describe the job entirely.
+
+## Functions
+- `stop()`: Stops the job.
+- `start()`: Starts the job.
+- `foreground()`: Set the job as the current running foreground process, or
+run it in the foreground after it has been suspended.
+- `background()`: Run the job in the background after it has been suspended.

docs/lunacolors.md

@@ -0,0 +1,41 @@
+---
+title: Lunacolors
+layout: doc
+weight: -60
+menu: docs
+---
+
+Lunacolors is an ANSI color/styling library for Lua. It is included
+by default in standard Hilbish distributions to provide easy styling
+for things like prompts and text.
+
+For simple usage, a single color or style is enough. For example,
+you can just use `lunacolors.blue 'Hello world'` and that'll return
+blue text which you can print. This includes styles like bold,
+underline, etc.
+
+In other usage, you may want to use a format string instead of having
+multiple nested functions for different styles. This is where the format
+function comes in. You can used named keywords to style a section of text.
+
+The list of arguments are:
+Colors:
+- black
+- red
+- green
+- yellow
+- blue
+- magenta
+- cyan
+- white
+Styles:
+- bold
+- dim
+- italic
+- underline
+- invert
+
+For the colors, there are background and bright variants. The background
+color variants have a suffix of `Bg` and bright has a prefix of `bright`.
+Note that appropriate camel casing has to be applied to them. So bright
+blue would be `brightBlue` and background cyan would be `cyanBg`.

docs/nature/_index.md

@@ -0,0 +1,19 @@
+---
+title: Nature
+layout: doc
+weight: -90
+menu: docs
+---
+
+A bit after creation, we have the outside nature. Little plants, seeds,
+growing to their final phase: a full plant. A lot of Hilbish itself is
+written in Go, but there are parts made in Lua, being most builtins
+(`doc`, `cd`, cdr), completions, and other things.
+
+Hilbish's Lua core module is called `nature`.
+It runs after Hilbish's Go core does.
+
+# Nature Modules
+Currently, `nature` provides 1 intended public module: `nature.dirs`.
+It is a simple API for managing recent directories and old
+current working directory.

docs/nature/dirs.md

@@ -0,0 +1,79 @@
+---
+title: Module dirs
+description: No description.
+layout: doc
+menu:
+  docs:
+    parent: "Nature"
+---
+
+<hr>
+<div id='setOld'>			
+<h4 class='heading'>
+dirs.setOld(d)
+<a href="#setOld" class='heading-link'>
+	<i class="fas fa-paperclip"></i>
+</a>
+</h4>
+
+Sets the old directory string.
+#### Parameters
+`d` **`string`**
+</div>
+
+<hr>
+<div id='push'>			
+<h4 class='heading'>
+dirs.push()
+<a href="#push" class='heading-link'>
+	<i class="fas fa-paperclip"></i>
+</a>
+</h4>
+
+Add `d` to the recent directories list.
+#### Parameters
+This function has no parameters.  
+</div>
+
+<hr>
+<div id='peak'>			
+<h4 class='heading'>
+dirs.peak(num)
+<a href="#peak" class='heading-link'>
+	<i class="fas fa-paperclip"></i>
+</a>
+</h4>
+
+Look at `num` amount of recent directories, starting from the latest.
+#### Parameters
+`num` **`number`**
+</div>
+
+<hr>
+<div id='pop'>			
+<h4 class='heading'>
+dirs.pop(num)
+<a href="#pop" class='heading-link'>
+	<i class="fas fa-paperclip"></i>
+</a>
+</h4>
+
+Remove the specified amount of dirs from the recent directories list.
+#### Parameters
+`num` **`number`**
+</div>
+
+<hr>
+<div id='recent'>			
+<h4 class='heading'>
+dirs.recent(idx)
+<a href="#recent" class='heading-link'>
+	<i class="fas fa-paperclip"></i>
+</a>
+</h4>
+
+Get entry from recent directories list based on index.
+#### Parameters
+`idx` **`number`**
+</div>
+

docs/terminal.txt

@@ -1,9 +0,0 @@
-setRaw() > Puts the terminal in raw mode
-
-restoreState() > Restores the last saved state of the terminal
-
-saveState() > Saves the current state of the terminal
-
-size() > Gets the dimensions of the terminal. Returns a table with `width` and `height`
-Note: this is not the size in relation to the dimensions of the display
-

docs/timers.md

@@ -0,0 +1 @@
+This has been moved to the `hilbish.timers` API doc (accessible by `doc api hilbish.timers`)

docs/vim-mode/_index.md

@@ -0,0 +1,11 @@
+---
+title: Vim Mode
+layout: doc
+weight: -90
+menu: docs
+---
+
+Hilbish has a Vim binding input mode accessible for use.
+It can be enabled with the `hilbish.inputMode` function (check `doc hilbish`).
+
+This is documentation for everything relating to it.

docs/vim-mode/actions.md

@@ -0,0 +1,25 @@
+---
+title: Actions
+layout: doc
+weight: -80
+menu: 
+  docs:
+    parent: "Vim Mode"
+---
+
+Vim actions are essentially just when a user uses a Vim keybind.
+Things like yanking and pasting are Vim actions.
+This is not an "offical Vim thing," just a Hilbish thing.
+
+The `hilbish.vimAction` hook is thrown whenever a Vim action occurs.
+It passes 2 arguments: the action name, and an array (table) of args
+relating to it.
+
+Here is documentation for what the table of args will hold for an
+appropriate Vim action.
+
+- `yank`: register, yankedText
+The first argument for the yank action is the register yankedText goes to.
+
+- `paste`: register, pastedText
+The first argument for the paste action is the register pastedText is taken from.

editor.go

@@ -0,0 +1,108 @@
+package main
+
+import (
+	"hilbish/util"
+
+	rt "github.com/arnodel/golua/runtime"
+)
+
+// #interface editor
+// interactions for Hilbish's line reader
+// The hilbish.editor interface provides functions to
+// directly interact with the line editor in use.
+func editorLoader(rtm *rt.Runtime) *rt.Table {
+	exports := map[string]util.LuaExport{
+		"insert": {editorInsert, 1, false},
+		"setVimRegister": {editorSetRegister, 1, false},
+		"getVimRegister": {editorGetRegister, 2, false},
+		"getLine": {editorGetLine, 0, false},
+		"readChar": {editorReadChar, 0, false},
+	}
+
+	mod := rt.NewTable()
+	util.SetExports(rtm, mod, exports)
+
+	return mod
+}
+
+// #interface editor
+// insert(text)
+// Inserts text into the Hilbish command line.
+// #param text string
+func editorInsert(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
+	if err := c.Check1Arg(); err != nil {
+		return nil, err
+	}
+
+	text, err := c.StringArg(0)
+	if err != nil {
+		return nil, err
+	}
+
+	lr.rl.Insert(text)
+
+	return c.Next(), nil
+}
+
+// #interface editor
+// setVimRegister(register, text)
+// Sets the vim register at `register` to hold the passed text.
+// #aram register string
+// #param text string
+func editorSetRegister(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
+	if err := c.Check1Arg(); err != nil {
+		return nil, err
+	}
+
+	register, err := c.StringArg(0)
+	if err != nil {
+		return nil, err
+	}
+
+	text, err := c.StringArg(1)
+	if err != nil {
+		return nil, err
+	}
+
+	lr.rl.SetRegisterBuf(register, []rune(text))
+
+	return c.Next(), nil
+}
+
+// #interface editor
+// getVimRegister(register) -> string
+// Returns the text that is at the register.
+// #param register string
+func editorGetRegister(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
+	if err := c.Check1Arg(); err != nil {
+		return nil, err
+	}
+
+	register, err := c.StringArg(0)
+	if err != nil {
+		return nil, err
+	}
+
+	buf := lr.rl.GetFromRegister(register)
+
+	return c.PushingNext1(t.Runtime, rt.StringValue(string(buf))), nil
+}
+
+// #interface editor
+// getLine() -> string
+// Returns the current input line.
+// #returns string
+func editorGetLine(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
+	buf := lr.rl.GetLine()
+
+	return c.PushingNext1(t.Runtime, rt.StringValue(string(buf))), nil
+}
+
+// #interface editor
+// getChar() -> string
+// Reads a keystroke from the user. This is in a format of something like Ctrl-L.
+func editorReadChar(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
+	buf := lr.rl.ReadChar()
+
+	return c.PushingNext1(t.Runtime, rt.StringValue(string(buf))), nil
+}

emmyLuaDocs/bait.lua

@@ -0,0 +1,28 @@
+--- @meta
+
+local bait = {}
+
+--- Catches an event. This function can be used to act on events.
+--- 
+--- 
+function bait.catch(name, cb) end
+
+--- Catches an event, but only once. This will remove the hook immediately after it runs for the first time.
+function bait.catchOnce(name, cb) end
+
+--- Returns a table of functions that are hooked on an event with the corresponding `name`.
+function bait.hooks(name) end
+
+--- Removes the `catcher` for the event with `name`.
+--- For this to work, `catcher` has to be the same function used to catch
+--- an event, like one saved to a variable.
+--- 
+--- 
+function bait.release(name, catcher) end
+
+--- Throws a hook with `name` with the provided `args`.
+--- 
+--- 
+function bait.throw(name, ...args) end
+
+return bait

emmyLuaDocs/commander.lua

@@ -0,0 +1,18 @@
+--- @meta
+
+local commander = {}
+
+--- Removes the named command. Note that this will only remove Commander-registered commands.
+function commander.deregister(name) end
+
+--- Adds a new command with the given `name`. When Hilbish has to run a command with a name,
+--- it will run the function providing the arguments and sinks.
+--- 
+--- 
+function commander.register(name, cb) end
+
+--- Returns all registered commanders. Returns a list of tables with the following keys:
+--- - `exec`: The function used to run the commander. Commanders require args and sinks to be passed.
+function commander.registry() end
+
+return commander

emmyLuaDocs/fs.lua

@@ -0,0 +1,54 @@
+--- @meta
+
+local fs = {}
+
+--- Returns an absolute version of the `path`.
+--- This can be used to resolve short paths like `..` to `/home/user`.
+function fs.abs(path) end
+
+--- Returns the "basename," or the last part of the provided `path`. If path is empty,
+--- `.` will be returned.
+function fs.basename(path) end
+
+--- Changes Hilbish's directory to `dir`.
+function fs.cd(dir) end
+
+--- Returns the directory part of `path`. If a file path like
+--- `~/Documents/doc.txt` then this function will return `~/Documents`.
+function fs.dir(path) end
+
+--- Match all files based on the provided `pattern`.
+--- For the syntax' refer to Go's filepath.Match function: https://pkg.go.dev/path/filepath#Match
+--- 
+--- 
+function fs.glob(pattern) end
+
+--- Takes any list of paths and joins them based on the operating system's path separator.
+--- 
+--- 
+function fs.join(...path) end
+
+--- Creates a new directory with the provided `name`.
+--- With `recursive`, mkdir will create parent directories.
+--- 
+--- 
+function fs.mkdir(name, recursive) end
+
+--- Returns a pair of connected files, also known as a pipe.
+--- The type returned is a Lua file, same as returned from `io` functions.
+function fs.fpipe() end
+
+--- Returns a list of all files and directories in the provided path.
+function fs.readdir(path) end
+
+--- Returns the information about a given `path`.
+--- The returned table contains the following values:
+--- name (string) - Name of the path
+--- size (number) - Size of the path in bytes
+--- mode (string) - Unix permission mode in an octal format string (with leading 0)
+--- isDir (boolean) - If the path is a directory
+--- 
+--- 
+function fs.stat(path) end
+
+return fs

emmyLuaDocs/hilbish.lua

@@ -0,0 +1,265 @@
+--- @meta
+
+local hilbish = {}
+
+--- This is an alias (ha) for the [hilbish.alias](../#alias) function.
+--- @param alias string
+--- @param cmd string
+function hilbish.aliases.add(alias, cmd) end
+
+--- This is the same as the `hilbish.runnerMode` function.
+--- It takes a callback, which will be used to execute all interactive input.
+--- In normal cases, neither callbacks should be overrided by the user,
+--- as the higher level functions listed below this will handle it.
+function hilbish.runner.setMode(cb) end
+
+--- Returns the current input line.
+function hilbish.editor.getLine() end
+
+--- Returns the text that is at the register.
+function hilbish.editor.getVimRegister(register) end
+
+--- Inserts text into the Hilbish command line.
+function hilbish.editor.insert(text) end
+
+--- Reads a keystroke from the user. This is in a format of something like Ctrl-L.
+function hilbish.editor.getChar() end
+
+--- Sets the vim register at `register` to hold the passed text.
+function hilbish.editor.setVimRegister(register, text) end
+
+--- Return binaries/executables based on the provided parameters.
+--- This function is meant to be used as a helper in a command completion handler.
+--- 
+--- 
+function hilbish.completion.bins(query, ctx, fields) end
+
+--- Calls a completer function. This is mainly used to call a command completer, which will have a `name`
+--- in the form of `command.name`, example: `command.git`.
+--- You can check the Completions doc or `doc completions` for info on the `completionGroups` return value.
+function hilbish.completion.call(name, query, ctx, fields) end
+
+--- Returns file matches based on the provided parameters.
+--- This function is meant to be used as a helper in a command completion handler.
+function hilbish.completion.files(query, ctx, fields) end
+
+--- This function contains the general completion handler for Hilbish. This function handles
+--- completion of everything, which includes calling other command handlers, binaries, and files.
+--- This function can be overriden to supply a custom handler. Note that alias resolution is required to be done in this function.
+--- 
+--- 
+function hilbish.completion.handler(line, pos) end
+
+--- Sets an alias, with a name of `cmd` to another command.
+--- 
+--- 
+function hilbish.alias(cmd, orig) end
+
+--- Appends the provided dir to the command path (`$PATH`)
+--- 
+--- 
+function hilbish.appendPath(dir) end
+
+--- Registers a completion handler for the specified scope.
+--- A `scope` is expected to be `command.<cmd>`,
+--- replacing <cmd> with the name of the command (for example `command.git`).
+--- The documentation for completions, under Features/Completions or `doc completions`
+--- provides more details.
+--- 
+--- 
+function hilbish.complete(scope, cb) end
+
+--- Returns the current directory of the shell.
+function hilbish.cwd() end
+
+--- Replaces the currently running Hilbish instance with the supplied command.
+--- This can be used to do an in-place restart.
+function hilbish.exec(cmd) end
+
+--- Puts `fn` in a Goroutine.
+--- This can be used to run any function in another thread at the same time as other Lua code.
+--- **NOTE: THIS FUNCTION MAY CRASH HILBISH IF OUTSIDE VARIABLES ARE ACCESSED.**
+--- **This is a limitation of the Lua runtime.**
+function hilbish.goro(fn) end
+
+--- Line highlighter handler.
+--- This is mainly for syntax highlighting, but in reality could set the input
+--- of the prompt to *display* anything. The callback is passed the current line
+--- and is expected to return a line that will be used as the input display.
+--- Note that to set a highlighter, one has to override this function.
+--- 
+function hilbish.highlighter(line) end
+
+--- The command line hint handler. It gets called on every key insert to
+--- determine what text to use as an inline hint. It is passed the current
+--- line and cursor position. It is expected to return a string which is used
+--- as the text for the hint. This is by default a shim. To set hints,
+--- override this function with your custom handler.
+--- 
+--- 
+function hilbish.hinter(line, pos) end
+
+--- Sets the input mode for Hilbish's line reader.
+--- `emacs` is the default. Setting it to `vim` changes behavior of input to be
+--- Vim-like with modes and Vim keybinds.
+function hilbish.inputMode(mode) end
+
+--- Runs the `cb` function every specified amount of `time`.
+--- This creates a timer that ticking immediately.
+function hilbish.interval(cb, time) end
+
+--- Changes the text prompt when Hilbish asks for more input.
+--- This will show up when text is incomplete, like a missing quote
+--- 
+--- 
+function hilbish.multiprompt(str) end
+
+--- Prepends `dir` to $PATH.
+function hilbish.prependPath(dir) end
+
+--- Changes the shell prompt to the provided string.
+--- There are a few verbs that can be used in the prompt text.
+--- These will be formatted and replaced with the appropriate values.
+--- `%d` - Current working directory
+--- `%u` - Name of current user
+--- `%h` - Hostname of device
+--- 
+function hilbish.prompt(str, typ) end
+
+--- Read input from the user, using Hilbish's line editor/input reader.
+--- This is a separate instance from the one Hilbish actually uses.
+--- Returns `input`, will be nil if Ctrl-D is pressed, or an error occurs.
+function hilbish.read(prompt) end
+
+--- Runs `cmd` in Hilbish's shell script interpreter.
+--- The `streams` parameter specifies the output and input streams the command should use.
+--- For example, to write command output to a sink.
+--- As a table, the caller can directly specify the standard output, error, and input
+--- streams of the command with the table keys `out`, `err`, and `input` respectively.
+--- As a boolean, it specifies whether the command should use standard output or return its output streams.
+--- 
+function hilbish.run(cmd, streams) end
+
+--- Sets the execution/runner mode for interactive Hilbish.
+--- This determines whether Hilbish wll try to run input as Lua
+--- and/or sh or only do one of either.
+--- Accepted values for mode are hybrid (the default), hybridRev (sh first then Lua),
+--- sh, and lua. It also accepts a function, to which if it is passed one
+--- will call it to execute user input instead.
+--- Read [about runner mode](../features/runner-mode) for more information.
+function hilbish.runnerMode(mode) end
+
+--- Executed the `cb` function after a period of `time`.
+--- This creates a Timer that starts ticking immediately.
+function hilbish.timeout(cb, time) end
+
+--- Checks if `name` is a valid command.
+--- Will return the path of the binary, or a basename if it's a commander.
+function hilbish.which(name) end
+
+--- Puts a job in the background. This acts the same as initially running a job.
+function hilbish.jobs:background() end
+
+--- Puts a job in the foreground. This will cause it to run like it was
+--- executed normally and wait for it to complete.
+function hilbish.jobs:foreground() end
+
+--- Evaluates `cmd` as Lua input. This is the same as using `dofile`
+--- or `load`, but is appropriated for the runner interface.
+function hilbish.runner.lua(cmd) end
+
+--- Sets/toggles the option of automatically flushing output.
+--- A call with no argument will toggle the value.
+--- @param auto boolean|nil
+function hilbish:autoFlush(auto) end
+
+--- Flush writes all buffered input to the sink.
+function hilbish:flush() end
+
+--- Reads a liine of input from the sink.
+--- @returns string
+function hilbish:read() end
+
+--- Reads all input from the sink.
+--- @returns string
+function hilbish:readAll() end
+
+--- Writes data to a sink.
+function hilbish:write(str) end
+
+--- Writes data to a sink with a newline at the end.
+function hilbish:writeln(str) end
+
+--- Starts running the job.
+function hilbish.jobs:start() end
+
+--- Stops the job from running.
+function hilbish.jobs:stop() end
+
+--- Loads a module at the designated `path`.
+--- It will throw if any error occurs.
+function hilbish.module.load(path) end
+
+--- Runs a command in Hilbish's shell script interpreter.
+--- This is the equivalent of using `source`.
+function hilbish.runner.sh(cmd) end
+
+--- Starts a timer.
+function hilbish.timers:start() end
+
+--- Stops a timer.
+function hilbish.timers:stop() end
+
+--- Removes an alias.
+function hilbish.aliases.delete(name) end
+
+--- Get a table of all aliases, with string keys as the alias and the value as the command.
+--- 
+--- 
+function hilbish.aliases.list() end
+
+--- Resolves an alias to its original command. Will thrown an error if the alias doesn't exist.
+function hilbish.aliases.resolve(alias) end
+
+--- Creates a new job. This function does not run the job. This function is intended to be
+--- used by runners, but can also be used to create jobs via Lua. Commanders cannot be ran as jobs.
+--- 
+--- 
+function hilbish.jobs.add(cmdstr, args, execPath) end
+
+--- Returns a table of all job objects.
+function hilbish.jobs.all() end
+
+--- Disowns a job. This simply deletes it from the list of jobs without stopping it.
+function hilbish.jobs.disown(id) end
+
+--- Get a job object via its ID.
+--- @param id number
+--- @returns Job
+function hilbish.jobs.get(id) end
+
+--- Returns the last added job to the table.
+function hilbish.jobs.last() end
+
+--- Adds a command to the history.
+function hilbish.history.add(cmd) end
+
+--- Retrieves all history as a table.
+function hilbish.history.all() end
+
+--- Deletes all commands from the history.
+function hilbish.history.clear() end
+
+--- Retrieves a command from the history based on the `index`.
+function hilbish.history.get(index) end
+
+--- Returns the amount of commands in the history.
+function hilbish.history.size() end
+
+--- Creates a timer that runs based on the specified `time`.
+function hilbish.timers.create(type, time, callback) end
+
+--- Retrieves a timer via its ID.
+function hilbish.timers.get(id) end
+
+return hilbish

emmyLuaDocs/terminal.lua

@@ -0,0 +1,18 @@
+--- @meta
+
+local terminal = {}
+
+--- Restores the last saved state of the terminal
+function terminal.restoreState() end
+
+--- Saves the current state of the terminal.
+function terminal.saveState() end
+
+--- Puts the terminal into raw mode.
+function terminal.setRaw() end
+
+--- Gets the dimensions of the terminal. Returns a table with `width` and `height`
+--- NOTE: The size refers to the amount of columns and rows of text that can fit in the terminal.
+function terminal.size() end
+
+return terminal

exec.go

@@ -0,0 +1,588 @@
+package main
+
+import (
+	"bytes"
+	"context"
+	"errors"
+	"os/exec"
+	"fmt"
+	"io"
+	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"syscall"
+	"time"
+
+	"hilbish/util"
+
+	rt "github.com/arnodel/golua/runtime"
+	"mvdan.cc/sh/v3/shell"
+	//"github.com/yuin/gopher-lua/parse"
+	"mvdan.cc/sh/v3/interp"
+	"mvdan.cc/sh/v3/syntax"
+	"mvdan.cc/sh/v3/expand"
+)
+
+var errNotExec = errors.New("not executable")
+var errNotFound = errors.New("not found")
+var runnerMode rt.Value = rt.StringValue("hybrid")
+
+type streams struct {
+	stdout io.Writer
+	stderr io.Writer
+	stdin io.Reader
+}
+
+type execError struct{
+	typ string
+	cmd string
+	code int
+	colon bool
+	err error
+}
+
+func (e execError) Error() string {
+	return fmt.Sprintf("%s: %s", e.cmd, e.typ)
+}
+
+func (e execError) sprint() error {
+	sep := " "
+	if e.colon {
+		sep = ": "
+	}
+
+	return fmt.Errorf("hilbish: %s%s%s", e.cmd, sep, e.err.Error())
+}
+
+func isExecError(err error) (execError, bool) {
+	if exErr, ok := err.(execError); ok {
+		return exErr, true
+	}
+
+	fields := strings.Split(err.Error(), ": ")
+	knownTypes := []string{
+		"not-found",
+		"not-executable",
+	}
+
+	if len(fields) > 1 && contains(knownTypes, fields[1]) {
+		var colon bool
+		var e error
+		switch fields[1] {
+			case "not-found":
+				e = errNotFound
+			case "not-executable":
+				colon = true
+				e = errNotExec
+		}
+
+		return execError{
+			cmd: fields[0],
+			typ: fields[1],
+			colon: colon,
+			err: e,
+		}, true
+	}
+
+	return execError{}, false
+}
+
+func runInput(input string, priv bool) {
+	running = true
+	cmdString := aliases.Resolve(input)
+	hooks.Emit("command.preexec", input, cmdString)
+
+	rerun:
+	var exitCode uint8
+	var err error
+	var cont bool
+	// save incase it changes while prompting (For some reason)
+	currentRunner := runnerMode
+	if currentRunner.Type() == rt.StringType {
+		switch currentRunner.AsString() {
+			case "hybrid":
+				_, _, err = handleLua(input)
+				if err == nil {
+					cmdFinish(0, input, priv)
+					return
+				}
+				input, exitCode, cont, err = handleSh(input)
+			case "hybridRev":
+				_, _, _, err = handleSh(input)
+				if err == nil {
+					cmdFinish(0, input, priv)
+					return
+				}
+				input, exitCode, err = handleLua(input)
+			case "lua":
+				input, exitCode, err = handleLua(input)
+			case "sh":
+				input, exitCode, cont, err = handleSh(input)
+		}
+	} else {
+		// can only be a string or function so
+		var runnerErr error
+		input, exitCode, cont, runnerErr, err = runLuaRunner(currentRunner, input)
+		if err != nil {
+			fmt.Fprintln(os.Stderr, err)
+			cmdFinish(124, input, priv)
+			return
+		}
+		// yep, we only use `err` to check for lua eval error
+		// our actual error should only be a runner provided error at this point
+		// command not found type, etc
+		err = runnerErr
+	}
+
+	if cont {
+		input, err = reprompt(input)
+		if err == nil {
+			goto rerun
+		} else if err == io.EOF {
+			return
+		}
+	}
+
+	if err != nil {
+		if exErr, ok := isExecError(err); ok {
+			hooks.Emit("command." + exErr.typ, exErr.cmd)
+		} else {
+			fmt.Fprintln(os.Stderr, err)
+		}
+	}
+	cmdFinish(exitCode, input, priv)
+}
+
+func reprompt(input string) (string, error) {
+	for {
+		in, err := continuePrompt(strings.TrimSuffix(input, "\\"))
+		if err != nil {
+			lr.SetPrompt(fmtPrompt(prompt))
+			return input, err
+		}
+
+		if strings.HasSuffix(in, "\\") {
+			continue
+		}
+		return in, nil
+	}
+}
+
+func runLuaRunner(runr rt.Value, userInput string) (input string, exitCode uint8, continued bool, runnerErr, err error) {
+	term := rt.NewTerminationWith(l.MainThread().CurrentCont(), 3, false)
+	err = rt.Call(l.MainThread(), runr, []rt.Value{rt.StringValue(userInput)}, term)
+	if err != nil {
+		return "", 124, false, nil, err
+	}
+
+	var runner *rt.Table
+	var ok bool
+	runnerRet := term.Get(0)
+	if runner, ok = runnerRet.TryTable(); !ok {
+		fmt.Fprintln(os.Stderr, "runner did not return a table")
+		exitCode = 125
+		input = userInput
+		return
+	}
+
+	if code, ok := runner.Get(rt.StringValue("exitCode")).TryInt(); ok {
+		exitCode = uint8(code)
+	}
+
+	if inp, ok := runner.Get(rt.StringValue("input")).TryString(); ok {
+		input = inp
+	}
+
+	if errStr, ok := runner.Get(rt.StringValue("err")).TryString(); ok {
+		runnerErr = fmt.Errorf("%s", errStr)
+	}
+
+	if c, ok := runner.Get(rt.StringValue("continue")).TryBool(); ok {
+		continued = c
+	}
+	return
+}
+
+func handleLua(input string) (string, uint8, error) {
+	cmdString := aliases.Resolve(input)
+	// First try to load input, essentially compiling to bytecode
+	chunk, err := l.CompileAndLoadLuaChunk("", []byte(cmdString), rt.TableValue(l.GlobalEnv()))
+	if err != nil && noexecute {
+		fmt.Println(err)
+	/*	if lerr, ok := err.(*lua.ApiError); ok {
+			if perr, ok := lerr.Cause.(*parse.Error); ok {
+				print(perr.Pos.Line == parse.EOF)
+			}
+		}
+	*/
+		return cmdString, 125, err
+	}
+	// And if there's no syntax errors and -n isnt provided, run
+	if !noexecute {
+		if chunk != nil {
+			_, err = rt.Call1(l.MainThread(), rt.FunctionValue(chunk))
+		}
+	}
+	if err == nil {
+		return cmdString, 0, nil
+	}
+
+	return cmdString, 125, err
+}
+
+func handleSh(cmdString string) (input string, exitCode uint8, cont bool, runErr error) {
+	shRunner := hshMod.Get(rt.StringValue("runner")).AsTable().Get(rt.StringValue("sh"))
+	var err error
+	input, exitCode, cont, runErr, err = runLuaRunner(shRunner, cmdString)
+	if err != nil {
+		runErr = err
+	}
+	return
+}
+
+func execSh(cmdString string) (string, uint8, bool, error) {
+	_, _, err := execCommand(cmdString, nil)
+	if err != nil {
+		// If input is incomplete, start multiline prompting
+		if syntax.IsIncomplete(err) {
+			if !interactive {
+				return cmdString, 126, false, err
+			}
+			return cmdString, 126, true, err
+		} else {
+			if code, ok := interp.IsExitStatus(err); ok {
+				return cmdString, code, false, nil
+			} else {
+				return cmdString, 126, false, err
+			}
+		}
+	}
+
+	return cmdString, 0, false, nil
+}
+
+// Run command in sh interpreter
+func execCommand(cmd string, strms *streams) (io.Writer, io.Writer, error) {
+	file, err := syntax.NewParser().Parse(strings.NewReader(cmd), "")
+	if err != nil {
+		return nil, nil, err
+	}
+
+	runner, _ := interp.New()
+
+	if strms == nil {
+		strms = &streams{}
+	}
+
+	if strms.stdout == nil {
+		strms.stdout = os.Stdout
+	}
+
+	if strms.stderr == nil {
+		strms.stderr = os.Stderr
+	}
+
+	if strms.stdin == nil {
+		strms.stdin = os.Stdin
+	}
+
+	interp.StdIO(strms.stdin, strms.stdout, strms.stderr)(runner)
+
+	buf := new(bytes.Buffer)
+	printer := syntax.NewPrinter()
+
+	var bg bool
+	for _, stmt := range file.Stmts {
+		bg = false
+		if stmt.Background {
+			bg = true
+			printer.Print(buf, stmt.Cmd)
+
+			stmtStr := buf.String()
+			buf.Reset()
+			jobs.add(stmtStr, []string{}, "")
+		}
+
+		interp.ExecHandler(execHandle(bg))(runner)
+		err = runner.Run(context.TODO(), stmt)
+		if err != nil {
+			return strms.stdout, strms.stderr, err
+		}
+	}
+
+	return strms.stdout, strms.stderr, nil
+}
+
+func execHandle(bg bool) interp.ExecHandlerFunc {
+	return func(ctx context.Context, args []string) error {
+		_, argstring := splitInput(strings.Join(args, " "))
+		// i dont really like this but it works
+		if aliases.All()[args[0]] != "" {
+			for i, arg := range args {
+				if strings.Contains(arg, " ") {
+					args[i] = fmt.Sprintf("\"%s\"", arg)
+				}
+			}
+			_, argstring = splitInput(strings.Join(args, " "))
+
+			// If alias was found, use command alias
+			argstring = aliases.Resolve(argstring)
+			var err error
+			args, err = shell.Fields(argstring, nil)
+			if err != nil {
+				return err
+			}
+		}
+
+		// If command is defined in Lua then run it
+		luacmdArgs := rt.NewTable()
+		for i, str := range args[1:] {
+			luacmdArgs.Set(rt.IntValue(int64(i + 1)), rt.StringValue(str))
+		}
+
+		hc := interp.HandlerCtx(ctx)
+		if cmd := cmds.Commands[args[0]]; cmd != nil {
+			stdin := newSinkInput(hc.Stdin)
+			stdout := newSinkOutput(hc.Stdout)
+			stderr := newSinkOutput(hc.Stderr)
+
+			sinks := rt.NewTable()
+			sinks.Set(rt.StringValue("in"), rt.UserDataValue(stdin.ud))
+			sinks.Set(rt.StringValue("input"), rt.UserDataValue(stdin.ud))
+			sinks.Set(rt.StringValue("out"), rt.UserDataValue(stdout.ud))
+			sinks.Set(rt.StringValue("err"), rt.UserDataValue(stderr.ud))
+
+			luaexitcode, err := rt.Call1(l.MainThread(), rt.FunctionValue(cmd), rt.TableValue(luacmdArgs), rt.TableValue(sinks))
+			if err != nil {
+				fmt.Fprintln(os.Stderr, "Error in command:\n" + err.Error())
+				return interp.NewExitStatus(1)
+			}
+
+			var exitcode uint8
+
+			if code, ok := luaexitcode.TryInt(); ok {
+				exitcode = uint8(code)
+			} else if luaexitcode != rt.NilValue {
+				// deregister commander
+				delete(cmds.Commands, args[0])
+				fmt.Fprintf(os.Stderr, "Commander did not return number for exit code. %s, you're fired.\n", args[0])
+			}
+
+			return interp.NewExitStatus(exitcode)
+		}
+
+		err := lookpath(args[0])
+		if err == errNotExec {
+			return execError{
+				typ: "not-executable",
+				cmd: args[0],
+				code: 126,
+				colon: true,
+				err: errNotExec,
+			}
+		} else if err != nil {
+			return execError{
+				typ: "not-found",
+				cmd: args[0],
+				code: 127,
+				err: errNotFound,
+			}
+		}
+
+		killTimeout := 2 * time.Second
+		// from here is basically copy-paste of the default exec handler from
+		// sh/interp but with our job handling
+		path, err := interp.LookPathDir(hc.Dir, hc.Env, args[0])
+		if err != nil {
+			fmt.Fprintln(hc.Stderr, err)
+			return interp.NewExitStatus(127)
+		}
+
+		env := hc.Env
+		envList := make([]string, 0, 64)
+		env.Each(func(name string, vr expand.Variable) bool {
+			if !vr.IsSet() {
+				// If a variable is set globally but unset in the
+				// runner, we need to ensure it's not part of the final
+				// list. Seems like zeroing the element is enough.
+				// This is a linear search, but this scenario should be
+				// rare, and the number of variables shouldn't be large.
+				for i, kv := range envList {
+					if strings.HasPrefix(kv, name+"=") {
+						envList[i] = ""
+					}
+				}
+			}
+			if vr.Exported && vr.Kind == expand.String {
+				envList = append(envList, name+"="+vr.String())
+			}
+			return true
+		})
+		cmd := exec.Cmd{
+			Path: path,
+			Args: args,
+			Env: envList,
+			Dir: hc.Dir,
+			Stdin: hc.Stdin,
+			Stdout: hc.Stdout,
+			Stderr: hc.Stderr,
+		}
+
+		var j *job
+		if bg {
+			j = jobs.getLatest()
+			j.setHandle(&cmd)
+			err = j.start()
+		} else {
+			err = cmd.Start()
+		}
+
+		if err == nil {
+			if done := ctx.Done(); done != nil {
+				go func() {
+					<-done
+
+					if killTimeout <= 0 || runtime.GOOS == "windows" {
+						cmd.Process.Signal(os.Kill)
+						return
+					}
+
+					// TODO: don't temporarily leak this goroutine
+					// if the program stops itself with the
+					// interrupt.
+					go func() {
+						time.Sleep(killTimeout)
+						cmd.Process.Signal(os.Kill)
+					}()
+					cmd.Process.Signal(os.Interrupt)
+				}()
+			}
+
+			err = cmd.Wait()
+		}
+
+		exit := handleExecErr(err)
+
+		if bg {
+			j.exitCode = int(exit)
+			j.finish()
+		}
+		return interp.NewExitStatus(exit)
+	}
+}
+
+func handleExecErr(err error) (exit uint8) {
+	ctx := context.TODO()
+
+	switch x := err.(type) {
+	case *exec.ExitError:
+		// started, but errored - default to 1 if OS
+		// doesn't have exit statuses
+		if status, ok := x.Sys().(syscall.WaitStatus); ok {
+			if status.Signaled() {
+				if ctx.Err() != nil {
+					return
+				}
+				exit = uint8(128 + status.Signal())
+				return
+			}
+			exit = uint8(status.ExitStatus())
+			return
+		}
+		exit = 1
+		return
+	case *exec.Error:
+		// did not start
+		//fmt.Fprintf(hc.Stderr, "%v\n", err)
+		exit = 127
+	default: return
+	}
+
+	return
+}
+func lookpath(file string) error { // custom lookpath function so we know if a command is found *and* is executable
+	var skip []string
+	if runtime.GOOS == "windows" {
+		skip = []string{"./", "../", "~/", "C:"}
+	} else {
+		skip = []string{"./", "/", "../", "~/"}
+	}
+	for _, s := range skip {
+		if strings.HasPrefix(file, s) {
+			return findExecutable(file, false, false)
+		}
+	}
+	for _, dir := range filepath.SplitList(os.Getenv("PATH")) {
+		path := filepath.Join(dir, file)
+		err := findExecutable(path, true, false)
+		if err == errNotExec {
+			return err
+		} else if err == nil {
+			return nil
+		}
+	}
+
+	return os.ErrNotExist
+}
+
+func splitInput(input string) ([]string, string) {
+	// end my suffering
+	// TODO: refactor this garbage
+	quoted := false
+	startlastcmd := false
+	lastcmddone := false
+	cmdArgs := []string{}
+	sb := &strings.Builder{}
+	cmdstr := &strings.Builder{}
+	lastcmd := "" //readline.GetHistory(readline.HistorySize() - 1)
+
+	for _, r := range input {
+		if r == '"' {
+			// start quoted input
+			// this determines if other runes are replaced
+			quoted = !quoted
+			// dont add back quotes
+			//sb.WriteRune(r)
+		} else if !quoted && r == '~' {
+			// if not in quotes and ~ is found then make it $HOME
+			sb.WriteString(os.Getenv("HOME"))
+		} else if !quoted && r == ' ' {
+			// if not quoted and there's a space then add to cmdargs
+			cmdArgs = append(cmdArgs, sb.String())
+			sb.Reset()
+		} else if !quoted && r == '^' && startlastcmd && !lastcmddone {
+			// if ^ is found, isnt in quotes and is
+			// the second occurence of the character and is
+			// the first time "^^" has been used
+			cmdstr.WriteString(lastcmd)
+			sb.WriteString(lastcmd)
+
+			startlastcmd = !startlastcmd
+			lastcmddone = !lastcmddone
+
+			continue
+		} else if !quoted && r == '^' && !lastcmddone {
+			// if ^ is found, isnt in quotes and is the
+			// first time of starting "^^"
+			startlastcmd = !startlastcmd
+			continue
+		} else {
+			sb.WriteRune(r)
+		}
+		cmdstr.WriteRune(r)
+	}
+	if sb.Len() > 0 {
+		cmdArgs = append(cmdArgs, sb.String())
+	}
+
+	return cmdArgs, cmdstr.String()
+}
+
+func cmdFinish(code uint8, cmdstr string, private bool) {
+	util.SetField(l, hshMod, "exitCode", rt.IntValue(int64(code)))
+	// using AsValue (to convert to lua type) on an interface which is an int
+	// results in it being unknown in lua .... ????
+	// so we allow the hook handler to take lua runtime Values
+	hooks.Emit("command.exit", rt.IntValue(int64(code)), cmdstr, private)
+}

execfile_unix.go

@@ -0,0 +1,29 @@
+// +build linux darwin
+
+package main
+
+import (
+	"os"
+	"syscall"
+)
+
+var bgProcAttr *syscall.SysProcAttr = &syscall.SysProcAttr{
+	Setpgid: true,
+}
+
+func findExecutable(path string, inPath, dirs bool) error {
+	f, err := os.Stat(path)
+	if err != nil {
+		return err
+	}
+	if dirs {
+		if m := f.Mode(); m & 0111 != 0 {
+			return nil
+		}
+	} else {
+		if m := f.Mode(); !m.IsDir() && m & 0111 != 0 {
+			return nil
+		}
+	}
+	return errNotExec
+}

execfile_windows.go

@@ -0,0 +1,42 @@
+// +build windows
+
+package main
+
+import (
+	"path/filepath"
+	"os"
+	"syscall"
+)
+
+var bgProcAttr *syscall.SysProcAttr = &syscall.SysProcAttr{
+	CreationFlags: syscall.CREATE_NEW_PROCESS_GROUP,
+}
+
+func findExecutable(path string, inPath, dirs bool) error {
+	nameExt := filepath.Ext(path)
+	pathExts := filepath.SplitList(os.Getenv("PATHEXT"))
+	if inPath {
+		if nameExt == "" {
+			for _, ext := range pathExts {
+				_, err := os.Stat(path + ext)
+				if err == nil {
+					return nil
+				}
+			}
+		} else {
+			_, err := os.Stat(path)
+			if err == nil {
+				if contains(pathExts, nameExt) { return nil }
+				return errNotExec
+			}
+		}
+	} else {
+		_, err := os.Stat(path)
+		if err == nil {
+			if contains(pathExts, nameExt) { return nil }
+			return errNotExec
+		}
+	}
+
+	return os.ErrNotExist
+}

go.mod

@@ -1,18 +1,34 @@
 module hilbish
 
-go 1.16
+go 1.18
 
 require (
-	github.com/Rosettea/Hilbiline v0.0.0-20210603231612-80054dac3650
-	github.com/Rosettea/readline v0.0.0-20211122152601-6d95ce44b7ed
-	github.com/bobappleyard/readline v0.0.0-20150707195538-7e300e02d38e
-	github.com/chuckpreslar/emission v0.0.0-20170206194824-a7ddd980baf9
-	github.com/mattn/go-runewidth v0.0.13 // indirect
+	github.com/arnodel/golua v0.0.0-20230215163904-e0b5347eaaa1
+	github.com/atsushinee/go-markdown-generator v0.0.0-20191121114853-83f9e1f68504
+	github.com/blackfireio/osinfo v1.0.5
+	github.com/maxlandon/readline v1.0.14
 	github.com/pborman/getopt v1.1.0
-	github.com/yuin/gopher-lua v0.0.0-20210529063254-f4c35e4016d9
-	golang.org/x/term v0.0.0-20210916214954-140adaaadfaf
-	layeh.com/gopher-luar v1.0.8
-	mvdan.cc/sh/v3 v3.3.0
+	github.com/sahilm/fuzzy v0.1.1
+	golang.org/x/sys v0.19.0
+	golang.org/x/term v0.19.0
+	mvdan.cc/sh/v3 v3.8.0
 )
 
-replace mvdan.cc/sh/v3 => github.com/Rosettea/sh/v3 v3.4.0-0.dev.0.20211022004519-f67a49cb50f5
+require (
+	github.com/acarl005/stripansi v0.0.0-20180116102854-5a71ef0e047d // indirect
+	github.com/arnodel/strftime v0.1.6 // indirect
+	github.com/evilsocket/islazy v1.11.0 // indirect
+	github.com/kylelemons/godebug v1.1.0 // indirect
+	github.com/olekukonko/ts v0.0.0-20171002115256-78ecb04241c0 // indirect
+	github.com/rivo/uniseg v0.4.7 // indirect
+	golang.org/x/sync v0.7.0 // indirect
+	golang.org/x/text v0.14.0 // indirect
+)
+
+replace mvdan.cc/sh/v3 => github.com/Rosettea/sh/v3 v3.4.0-0.dev.0.20220524215627-dfd9a4fa219b
+
+replace github.com/maxlandon/readline => ./readline
+
+replace layeh.com/gopher-luar => github.com/layeh/gopher-luar v1.0.10
+
+replace github.com/arnodel/golua => github.com/Rosettea/golua v0.0.0-20240427174124-d239074c1749

go.sum

@@ -1,67 +1,54 @@
-github.com/Rosettea/Hilbiline v0.0.0-20210603231612-80054dac3650 h1:nzFJUdJU8UJ1DA8mSQp4eoBtQyOJyecekVWusjfQsqE=
-github.com/Rosettea/Hilbiline v0.0.0-20210603231612-80054dac3650/go.mod h1:/FFZ4cgR6TXXYaskRUxyLIYdfG0PS4BPtWjWRQms754=
-github.com/Rosettea/readline v0.0.0-20211122152601-6d95ce44b7ed h1:sGsGPG+b5h9OR1GjM0PiM4iemB9hmi0o8cg2YRSRKko=
-github.com/Rosettea/readline v0.0.0-20211122152601-6d95ce44b7ed/go.mod h1:OH+WJSCks0t2ISvaCFUT4ZxNGr4Etq4ju9JE/UxH/5o=
-github.com/Rosettea/sh/v3 v3.3.0 h1:0/xmOfzpy46gB1I2oPj8QwdYvyJzpdF5STcgNPRQHcI=
-github.com/Rosettea/sh/v3 v3.3.0/go.mod h1:dh3avhLDhJJ/MJKzbak6FYn+DJKUWk7Fb6Dh5mGdv6Y=
-github.com/Rosettea/sh/v3 v3.4.0-0.dev.0.20211022004519-f67a49cb50f5 h1:ygwVRX8gf5MHA0VzSgOdscCEoAJLjM8joEotfQPgAd0=
-github.com/Rosettea/sh/v3 v3.4.0-0.dev.0.20211022004519-f67a49cb50f5/go.mod h1:R09vh/04ILvP2Gj8/Z9Jd0Dh0ZIvaucowMEs6abQpWs=
-github.com/bobappleyard/readline v0.0.0-20150707195538-7e300e02d38e h1:4G8AYOOwZdDWOiJR6D6JXaFmj5BDS7c5D5PyqsG/+Hg=
-github.com/bobappleyard/readline v0.0.0-20150707195538-7e300e02d38e/go.mod h1:fmqtV+Wqx0uFYLN1F4VhjZdtT56Dr8c3yA7nALFsw/Q=
-github.com/chuckpreslar/emission v0.0.0-20170206194824-a7ddd980baf9 h1:xz6Nv3zcwO2Lila35hcb0QloCQsc38Al13RNEzWRpX4=
-github.com/chuckpreslar/emission v0.0.0-20170206194824-a7ddd980baf9/go.mod h1:2wSM9zJkl1UQEFZgSd68NfCgRz1VL1jzy/RjCg+ULrs=
-github.com/chzyer/logex v1.1.10/go.mod h1:+Ywpsq7O8HXn0nuIou7OrIPyXbp3wmkHB+jjWRnGsAI=
-github.com/chzyer/readline v0.0.0-20180603132655-2972be24d48e/go.mod h1:nSuG5e5PlCu98SY8svDHJxuZscDgtXS6KTTbou5AhLI=
-github.com/chzyer/test v0.0.0-20180213035817-a1ea475d72b1/go.mod h1:Q3SI9o4m/ZMnBNeIyt5eFwwo7qiLfzFZmjNmxjkiQlU=
+github.com/Rosettea/golua v0.0.0-20240427174124-d239074c1749 h1:jIFnWBTsYw8s7RX7H2AOXjDVhWP3ol7OzUVaPN2KnGI=
+github.com/Rosettea/golua v0.0.0-20240427174124-d239074c1749/go.mod h1:9jzpYPiU2is0HVGCiuIOBSXdergHUW44IEjmuN1UrIE=
+github.com/Rosettea/sh/v3 v3.4.0-0.dev.0.20220524215627-dfd9a4fa219b h1:s5eDMhBk6H1BgipgLub/gv9qeyBaTuiHM0k3h2/9TSE=
+github.com/Rosettea/sh/v3 v3.4.0-0.dev.0.20220524215627-dfd9a4fa219b/go.mod h1:R09vh/04ILvP2Gj8/Z9Jd0Dh0ZIvaucowMEs6abQpWs=
+github.com/acarl005/stripansi v0.0.0-20180116102854-5a71ef0e047d h1:licZJFw2RwpHMqeKTCYkitsPqHNxTmd4SNR5r94FGM8=
+github.com/acarl005/stripansi v0.0.0-20180116102854-5a71ef0e047d/go.mod h1:asat636LX7Bqt5lYEZ27JNDcqxfjdBQuJ/MM4CN/Lzo=
+github.com/arnodel/strftime v0.1.6 h1:0hc0pUvk8KhEMXE+htyaOUV42zNcf/csIbjzEFCJqsw=
+github.com/arnodel/strftime v0.1.6/go.mod h1:5NbK5XqYK8QpRZpqKNt4OlxLtIB8cotkLk4KTKzJfWs=
+github.com/atsushinee/go-markdown-generator v0.0.0-20191121114853-83f9e1f68504 h1:R1/AOzdMbopSliUTTEHvHbyNmnZ3YxY5GvdhTkpPsSY=
+github.com/atsushinee/go-markdown-generator v0.0.0-20191121114853-83f9e1f68504/go.mod h1:kHBCvAXJIatTX1pw6tLiOspjGc3MhUDRlog9yrCUS+k=
+github.com/blackfireio/osinfo v1.0.5 h1:6hlaWzfcpb87gRmznVf7wSdhysGqLRz9V/xuSdCEXrA=
+github.com/blackfireio/osinfo v1.0.5/go.mod h1:Pd987poVNmd5Wsx6PRPw4+w7kLlf9iJxoRKPtPAjOrA=
 github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=
-github.com/creack/pty v1.1.11 h1:07n33Z8lZxZ2qwegKbObQohDhXDQxiMMz1NOUGYlesw=
-github.com/creack/pty v1.1.11/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=
+github.com/creack/pty v1.1.15 h1:cKRCLMj3Ddm54bKSpemfQ8AtYFBhAI2MPmdys22fBdc=
 github.com/creack/pty v1.1.15/go.mod h1:MOBLtS5ELjhRRrroQr9kyvTxUAFNvYEK993ew/Vr4O4=
-github.com/google/renameio v1.0.1-0.20210406141108-81588dbe0453/go.mod h1:t/HQoYBZSsWSNK35C6CO/TpPLDVWvxOHboWUAweKUpk=
+github.com/evilsocket/islazy v1.11.0 h1:B5w6uuS6ki6iDG+aH/RFeoMb8ijQh/pGabewqp2UeJ0=
+github.com/evilsocket/islazy v1.11.0/go.mod h1:muYH4x5MB5YRdkxnrOtrXLIBX6LySj1uFIqys94LKdo=
 github.com/google/renameio v1.0.1/go.mod h1:t/HQoYBZSsWSNK35C6CO/TpPLDVWvxOHboWUAweKUpk=
 github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
-github.com/kr/pretty v0.2.1 h1:Fmg33tUaq4/8ym9TJN1x7sLJnHVwhP33CNkpYV/7rwI=
-github.com/kr/pretty v0.2.1/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI=
+github.com/kr/pretty v0.3.0 h1:WgNl7dwNpEZ6jJ9k1snq4pZsg7DOEN8hP9Xw0Tsjwk0=
 github.com/kr/pretty v0.3.0/go.mod h1:640gp4NfQd8pI5XOwp5fnNeVWj67G7CFk/SaSQn7NBk=
 github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
 github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
 github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
 github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
-github.com/mattn/go-runewidth v0.0.12/go.mod h1:RAqKPSqVFrSLVXbA8x7dzmKdmGzieGRCM46jaSJTDAk=
-github.com/mattn/go-runewidth v0.0.13 h1:lTGmDsbAYt5DmK6OnoV7EuIF1wEIFAcxld6ypU4OSgU=
-github.com/mattn/go-runewidth v0.0.13/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
+github.com/kylelemons/godebug v1.1.0 h1:RPNrshWIDI6G2gRW9EHilWtl7Z6Sb1BR0xunSBf0SNc=
+github.com/kylelemons/godebug v1.1.0/go.mod h1:9/0rRGxNHcop5bhtWyNeEfOS8JIWk580+fNqagV/RAw=
+github.com/olekukonko/ts v0.0.0-20171002115256-78ecb04241c0 h1:LiZB1h0GIcudcDci2bxbqI6DXV8bF8POAnArqvRrIyw=
+github.com/olekukonko/ts v0.0.0-20171002115256-78ecb04241c0/go.mod h1:F/7q8/HZz+TXjlsoZQQKVYvXTZaFH4QRa3y+j1p7MS0=
 github.com/pborman/getopt v1.1.0 h1:eJ3aFZroQqq0bWmraivjQNt6Dmm5M0h2JcDW38/Azb0=
 github.com/pborman/getopt v1.1.0/go.mod h1:FxXoW1Re00sQG/+KIkuSqRL/LwQgSkv7uyac+STFsbk=
 github.com/pkg/diff v0.0.0-20210226163009-20ebb0f2a09e/go.mod h1:pJLUxLENpZxwdsKMEsNbx1VGcRFpLqf3715MtcvvzbA=
-github.com/rivo/uniseg v0.1.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
-github.com/rivo/uniseg v0.2.0 h1:S1pD9weZBuJdFmowNwbpi7BJ8TNftyUImj/0WQi72jY=
-github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
+github.com/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ=
+github.com/rivo/uniseg v0.4.7/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
 github.com/rogpeppe/go-internal v1.6.1/go.mod h1:xXDCJY+GAPziupqXw64V24skbSoqbTEfhy4qGm1nDQc=
-github.com/rogpeppe/go-internal v1.7.0/go.mod h1:xXDCJY+GAPziupqXw64V24skbSoqbTEfhy4qGm1nDQc=
+github.com/rogpeppe/go-internal v1.8.1-0.20210923151022-86f73c517451 h1:d1PiN4RxzIFXCJTvRkvSkKqwtRAl5ZV4lATKtQI0B7I=
 github.com/rogpeppe/go-internal v1.8.1-0.20210923151022-86f73c517451/go.mod h1:JeRgkft04UBgHMgCIwADu4Pn6Mtm5d4nPKWu0nJ5d+o=
-github.com/yuin/gopher-lua v0.0.0-20190206043414-8bfc7677f583/go.mod h1:gqRgreBUhTSL0GeU64rtZ3Uq3wtjOa/TB2YfrtkCbVQ=
-github.com/yuin/gopher-lua v0.0.0-20210529063254-f4c35e4016d9 h1:k/gmLsJDWwWqbLCur2yWnJzwQEKRcAHXo6seXGuSwWw=
-github.com/yuin/gopher-lua v0.0.0-20210529063254-f4c35e4016d9/go.mod h1:E1AXubJBdNmFERAOucpDIxNzeGfLzg0mYh+UfMWdChA=
-golang.org/x/sync v0.0.0-20210220032951-036812b2e83c h1:5KslGYwFpkhGh+Q16bwMP3cOontH8FOep7tGV86Y7SQ=
+github.com/sahilm/fuzzy v0.1.1 h1:ceu5RHF8DGgoi+/dR5PsECjCDH1BE3Fnmpo7aVXOdRA=
+github.com/sahilm/fuzzy v0.1.1/go.mod h1:VFvziUEIMCrT6A6tw2RFIXPXXmzXbOsSHF0DOI8ZK9Y=
 golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sys v0.0.0-20190204203706-41f3e6584952/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20210414055047-fe65e336abe0/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20210503080704-8803ae5d1324/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20210603125802-9665404d3644 h1:CA1DEQ4NdKphKeL70tvsWNdT5oFh1lOjihRcEDROi0I=
-golang.org/x/sys v0.0.0-20210603125802-9665404d3644/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sync v0.7.0 h1:YsImfSBoP9QPYL0xyKJPq0gcaJdG3rInoqxTWbfQu9M=
+golang.org/x/sync v0.7.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
 golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20210925032602-92d5a993a665 h1:QOQNt6vCjMpXE7JSK5VvAzJC1byuN3FgTNSBwf+CJgI=
 golang.org/x/sys v0.0.0-20210925032602-92d5a993a665/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/term v0.0.0-20210406210042-72f3dc4e9b72/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
-golang.org/x/term v0.0.0-20210503060354-a79de5458b56 h1:b8jxX3zqjpqb2LklXPzKSGJhzyxCOZSz8ncv8Nv+y7w=
-golang.org/x/term v0.0.0-20210503060354-a79de5458b56/go.mod h1:tfny5GFUkzUvx4ps4ajbZsCe5lw1metzhBm9T3x7oIY=
-golang.org/x/term v0.0.0-20210916214954-140adaaadfaf h1:Ihq/mm/suC88gF8WFcVwk+OV6Tq+wyA1O0E5UEvDglI=
+golang.org/x/sys v0.19.0 h1:q5f1RH2jigJ1MoAWp2KTp3gm5zAGFUTarQZ5U386+4o=
+golang.org/x/sys v0.19.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
 golang.org/x/term v0.0.0-20210916214954-140adaaadfaf/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
+golang.org/x/term v0.19.0 h1:+ThwsDv+tYfnJFhF4L8jITxu1tdTWRTZpdsWgEgjL6Q=
+golang.org/x/term v0.19.0/go.mod h1:2CuTdWZ7KHSQwUzKva0cbMg6q2DMI3Mmxp+gKJbskEk=
+golang.org/x/text v0.14.0 h1:ScX5w1eTa3QqT8oi6+ziP7dTV1S2+ALU0bI+0zXKWiQ=
+golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
 gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/errgo.v2 v2.1.0/go.mod h1:hNsd1EY+bozCKY1Ytp96fpM3vjJbqLJn88ws8XvfDNI=
-layeh.com/gopher-luar v1.0.8 h1:Uqws1Z6T0vK6pZ7ehNNurLLSFcz7+E0EOHVM4FNiMQs=
-layeh.com/gopher-luar v1.0.8/go.mod h1:TPnIVCZ2RJBndm7ohXyaqfhzjlZ+OA2SZR/YwL8tECk=
 mvdan.cc/editorconfig v0.2.0/go.mod h1:lvnnD3BNdBYkhq+B4uBuFFKatfp02eB6HixDvEz91C0=
-mvdan.cc/sh/v3 v3.3.0 h1:ujzElMnry63f4I5sjPFxzo6xia+gwsHZM0yyauuyZ6k=
-mvdan.cc/sh/v3 v3.3.0/go.mod h1:dh3avhLDhJJ/MJKzbak6FYn+DJKUWk7Fb6Dh5mGdv6Y=

golibs/bait/bait.go

@@ -1,51 +1,376 @@
+// the event emitter
+/*
+Bait is the event emitter for Hilbish. Much like Node.js and
+its `events` system, many actions in Hilbish emit events.
+Unlike Node.js, Hilbish events are global. So make sure to
+pick a unique name!
+
+Usage of the Bait module consists of userstanding
+event-driven architecture, but it's pretty simple:
+If you want to act on a certain event, you can `catch` it.
+You can act on events via callback functions.
+
+Examples of this are in the Hilbish default config!
+Consider this part of it:
+```lua
+bait.catch('command.exit', function(code)
+	running = false
+	doPrompt(code ~= 0)
+	doNotifyPrompt()
+end)
+```
+
+What this does is, whenever the `command.exit` event is thrown,
+this function will set the user prompt.
+*/
 package bait
 
 import (
+	"errors"
+
 	"hilbish/util"
 
-	"github.com/chuckpreslar/emission"
-	"github.com/yuin/gopher-lua"
-	"layeh.com/gopher-luar"
+	rt "github.com/arnodel/golua/runtime"
+	"github.com/arnodel/golua/lib/packagelib"
 )
 
-type Bait struct{
-	Em *emission.Emitter
+type listenerType int
+const (
+	goListener listenerType = iota
+	luaListener
+)
+
+// Recoverer is a function which is called when a panic occurs in an event.
+type Recoverer func(event string, handler *Listener, err interface{})
+
+// Listener is a struct that holds the handler for an event.
+type Listener struct{
+	typ listenerType
+	once bool
+	caller func(...interface{})
+	luaCaller *rt.Closure
 }
 
-func New() Bait {
-	return Bait{
-		Em: emission.NewEmitter(),
+type Bait struct{
+	Loader packagelib.Loader
+	recoverer Recoverer
+	handlers map[string][]*Listener
+	rtm *rt.Runtime
+}
+
+// New creates a new Bait instance.
+func New(rtm *rt.Runtime) *Bait {
+	b := &Bait{
+		handlers: make(map[string][]*Listener),
+		rtm: rtm,
+	}
+	b.Loader = packagelib.Loader{
+		Load: b.loaderFunc,
+		Name: "bait",
+	}
+
+	return b
+}
+
+// Emit throws an event.
+func (b *Bait) Emit(event string, args ...interface{}) {
+	handles := b.handlers[event]
+	if handles == nil {
+		return
+	}
+
+	for idx, handle := range handles {
+		defer func() {
+			if err := recover(); err != nil {
+				b.callRecoverer(event, handle, err)
+			}
+		}()
+
+		if handle.typ == luaListener {
+			funcVal := rt.FunctionValue(handle.luaCaller)
+			var luaArgs []rt.Value
+			for _, arg := range args {
+				var luarg rt.Value
+				switch arg.(type) {
+					case rt.Value: luarg = arg.(rt.Value)
+					default: luarg = rt.AsValue(arg)
+				}
+				luaArgs = append(luaArgs, luarg)
+			}
+			_, err := rt.Call1(b.rtm.MainThread(), funcVal, luaArgs...)
+			if err != nil {
+				if event != "error" {
+					b.Emit("error", event, handle.luaCaller, err.Error())
+					return
+				}
+				// if there is an error in an error event handler, panic instead
+				// (calls the go recoverer function)
+				panic(err)
+			}
+		} else {
+			handle.caller(args...)
+		}
+
+		if handle.once {
+			b.removeListener(event, idx)
+		}
 	}
 }
 
-func (b *Bait) Loader(L *lua.LState) int {
-	mod := L.SetFuncs(L.NewTable(), map[string]lua.LGFunction{})
+// On adds a Go function handler for an event.
+func (b *Bait) On(event string, handler func(...interface{})) *Listener {
+	listener := &Listener{
+		typ: goListener,
+		caller: handler,
+	}
 
-	util.Document(L, mod,
-`Bait is the event emitter for Hilbish. Why name it bait?
-Because it throws hooks that you can catch (emits events
-that you can listen to) and because why not, fun naming
-is fun. This is what you will use if you want to listen
-in on hooks to know when certain things have happened,
-like when you've changed directory, a command has
-failed, etc. To find all available hooks, see doc hooks.`)
-
-	L.SetField(mod, "throw", luar.New(L, b.bthrow))
-	L.SetField(mod, "catch", luar.New(L, b.bcatch))
-
-	L.Push(mod)
-
-	return 1
+	b.addListener(event, listener)
+	return listener
 }
 
-// throw(name, ...args)
-// Throws a hook with `name` with the provided `args`
-func (b *Bait) bthrow(name string, args ...interface{}) {
-	b.Em.Emit(name, args...)
+// OnLua adds a Lua function handler for an event.
+func (b *Bait) OnLua(event string, handler *rt.Closure) *Listener {
+	listener :=&Listener{
+		typ: luaListener,
+		luaCaller: handler,
+	}
+	b.addListener(event, listener)
+
+	return listener
+}
+
+// Off removes a Go function handler for an event.
+func (b *Bait) Off(event string, listener *Listener) {
+	handles := b.handlers[event]
+
+	for i, handle := range handles {
+		if handle == listener {
+			b.removeListener(event, i)
+		}
+	}
+}
+
+// OffLua removes a Lua function handler for an event.
+func (b *Bait) OffLua(event string, handler *rt.Closure) {
+	handles := b.handlers[event]
+
+	for i, handle := range handles {
+		if handle.luaCaller == handler {
+			b.removeListener(event, i)
+		}
+	}
+}
+
+// Once adds a Go function listener for an event that only runs once.
+func (b *Bait) Once(event string, handler func(...interface{})) *Listener {
+	listener := &Listener{
+		typ: goListener,
+		once: true,
+		caller: handler,
+	}
+	b.addListener(event, listener)
+
+	return listener
+}
+
+// OnceLua adds a Lua function listener for an event that only runs once.
+func (b *Bait) OnceLua(event string, handler *rt.Closure) *Listener {
+	listener := &Listener{
+		typ: luaListener,
+		once: true,
+		luaCaller: handler,
+	}
+	b.addListener(event, listener)
+
+	return listener
+}
+
+// SetRecoverer sets the function to be executed when a panic occurs in an event.
+func (b *Bait) SetRecoverer(recoverer Recoverer) {
+	b.recoverer = recoverer
+}
+
+func (b *Bait) addListener(event string, listener *Listener) {
+	if b.handlers[event] == nil {
+		b.handlers[event] = []*Listener{}
+	}
+
+	b.handlers[event] = append(b.handlers[event], listener)
+}
+
+
+func (b *Bait) removeListener(event string, idx int) {
+	b.handlers[event][idx] = b.handlers[event][len(b.handlers[event]) - 1]
+
+	b.handlers[event] = b.handlers[event][:len(b.handlers[event]) - 1]
+}
+
+func (b *Bait) callRecoverer(event string, handler *Listener, err interface{}) {
+	if b.recoverer == nil {
+		panic(err)
+	}
+	b.recoverer(event, handler, err)
+}
+
+func (b *Bait) loaderFunc(rtm *rt.Runtime) (rt.Value, func()) {
+	exports := map[string]util.LuaExport{
+		"catch": util.LuaExport{b.bcatch, 2, false},
+		"catchOnce": util.LuaExport{b.bcatchOnce, 2, false},
+		"throw": util.LuaExport{b.bthrow, 1, true},
+		"release": util.LuaExport{b.brelease, 2, false},
+		"hooks": util.LuaExport{b.bhooks, 1, false},
+	}
+	mod := rt.NewTable()
+	util.SetExports(rtm, mod, exports)
+
+	return rt.TableValue(mod), nil
+}
+
+func handleHook(t *rt.Thread, c *rt.GoCont, name string, catcher *rt.Closure, args ...interface{}) {
+	funcVal := rt.FunctionValue(catcher)
+	var luaArgs []rt.Value
+	for _, arg := range args {
+		var luarg rt.Value
+		switch arg.(type) {
+			case rt.Value: luarg = arg.(rt.Value)
+			default: luarg = rt.AsValue(arg)
+		}
+		luaArgs = append(luaArgs, luarg)
+	}
+	_, err := rt.Call1(t, funcVal, luaArgs...)
+	if err != nil {
+		e := rt.NewError(rt.StringValue(err.Error()))
+		e = e.AddContext(c.Next(), 1)
+		// panicking here won't actually cause hilbish to panic and instead will
+		// print the error and remove the hook (look at emission recover from above)
+		panic(e)
+	}
 }
 
 // catch(name, cb)
-// Catches a hook with `name`. Runs the `cb` when it is thrown
-func (b *Bait) bcatch(name string, catcher func(...interface{})) {
-	b.Em.On(name, catcher)
+// Catches an event. This function can be used to act on events.
+// #param name string The name of the hook.
+// #param cb function The function that will be called when the hook is thrown.
+/*
+#example
+bait.catch('hilbish.exit', function()
+	print 'Goodbye Hilbish!'
+end)
+#example
+*/
+func (b *Bait) bcatch(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
+	name, catcher, err := util.HandleStrCallback(t, c)
+	if err != nil {
+		return nil, err
+	}
+
+	b.OnLua(name, catcher)
+
+	return c.Next(), nil
+}
+
+// catchOnce(name, cb)
+// Catches an event, but only once. This will remove the hook immediately after it runs for the first time.
+// #param name string The name of the event
+// #param cb function The function that will be called when the event is thrown.
+func (b *Bait) bcatchOnce(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
+	name, catcher, err := util.HandleStrCallback(t, c)
+	if err != nil {
+		return nil, err
+	}
+
+	b.OnceLua(name, catcher)
+
+	return c.Next(), nil
+}
+
+// hooks(name) -> table
+// Returns a table of functions that are hooked on an event with the corresponding `name`.
+// #param name string The name of the hook
+// #returns table<function>
+func (b *Bait) bhooks(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
+	if err := c.Check1Arg(); err != nil {
+		return nil, err
+	}
+	evName, err := c.StringArg(0)
+	if err != nil {
+		return nil, err
+	}
+	noHooks := errors.New("no hooks for event " + evName)
+
+	handlers := b.handlers[evName]
+	if handlers == nil {
+		return nil, noHooks
+	}
+
+	luaHandlers := rt.NewTable()
+	for _, handler := range handlers {
+		if handler.typ != luaListener { continue }
+		luaHandlers.Set(rt.IntValue(luaHandlers.Len() + 1), rt.FunctionValue(handler.luaCaller))
+	}
+
+	if luaHandlers.Len() == 0 {
+		return nil, noHooks
+	}
+
+	return c.PushingNext1(t.Runtime, rt.TableValue(luaHandlers)), nil
+}
+
+// release(name, catcher)
+// Removes the `catcher` for the event with `name`.
+// For this to work, `catcher` has to be the same function used to catch
+// an event, like one saved to a variable.
+// #param name string Name of the event the hook is on
+// #param catcher function Hook function to remove
+/*
+#example
+local hookCallback = function() print 'hi' end
+
+bait.catch('event', hookCallback)
+
+-- a little while later....
+bait.release('event', hookCallback)
+-- and now hookCallback will no longer be ran for the event.
+#example
+*/
+func (b *Bait) brelease(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
+	name, catcher, err := util.HandleStrCallback(t, c)
+	if err != nil {
+		return nil, err
+	}
+
+	b.OffLua(name, catcher)
+
+	return c.Next(), nil
+}
+
+// throw(name, ...args)
+// #param name string The name of the hook.
+// #param args ...any The arguments to pass to the hook.
+// Throws a hook with `name` with the provided `args`.
+/*
+#example
+bait.throw('greeting', 'world')
+
+-- This can then be listened to via
+bait.catch('gretting', function(greetTo)
+	print('Hello ' .. greetTo)
+end)
+#example
+*/
+func (b *Bait) bthrow(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
+	if err := c.Check1Arg(); err != nil {
+		return nil, err
+	}
+	name, err := c.StringArg(0)
+	if err != nil {
+		return nil, err
+	}
+	ifaceSlice := make([]interface{}, len(c.Etc()))
+	for i, v := range c.Etc() {
+		ifaceSlice[i] = v
+	}
+	b.Emit(name, ifaceSlice...)
+
+	return c.Next(), nil
 }

golibs/commander/commander.go

@@ -1,51 +1,133 @@
+// library for custom commands
+/*
+Commander is the library which handles Hilbish commands. This makes
+the user able to add Lua-written commands to their shell without making
+a separate script in a bin folder. Instead, you may simply use the Commander
+library in your Hilbish config.
+
+```lua
+local commander = require 'commander'
+
+commander.register('hello', function(args, sinks)
+	sinks.out:writeln 'Hello world!'
+end)
+```
+
+In this example, a command with the name of `hello` is created
+that will print `Hello world!` to output. One question you may
+have is: What is the `sinks` parameter?
+
+The `sinks` parameter is a table with 3 keys: `input`, `out`, and `err`.
+There is an `in` alias to `input`, but it requires using the string accessor syntax (`sinks['in']`)
+as `in` is also a Lua keyword, so `input` is preferred for use.
+All of them are a @Sink.
+In the future, `sinks.in` will be removed.
+
+- `in` is the standard input.
+You may use the read functions on this sink to get input from the user.
+- `out` is standard output.
+This is usually where command output should go.
+- `err` is standard error.
+This sink is for writing errors, as the name would suggest.
+*/
 package commander
 
 import (
 	"hilbish/util"
+	"hilbish/golibs/bait"
 
-	"github.com/chuckpreslar/emission"
-	"github.com/yuin/gopher-lua"
+	rt "github.com/arnodel/golua/runtime"
+	"github.com/arnodel/golua/lib/packagelib"
 )
 
 type Commander struct{
-	Events *emission.Emitter
+	Events *bait.Bait
+	Loader packagelib.Loader
+	Commands map[string]*rt.Closure
 }
 
-func New() Commander {
-	return Commander{
-		Events: emission.NewEmitter(),
+func New(rtm *rt.Runtime) *Commander {
+	c := &Commander{
+		Events: bait.New(rtm),
+		Commands: make(map[string]*rt.Closure),
 	}
+	c.Loader = packagelib.Loader{
+		Load: c.loaderFunc,
+		Name: "commander",
+	}
+
+	return c
 }
 
-func (c *Commander) Loader(L *lua.LState) int {
-	var exports = map[string]lua.LGFunction{
-		"register": c.cregister,
-		"deregister": c.cderegister,
+func (c *Commander) loaderFunc(rtm *rt.Runtime) (rt.Value, func()) {
+	exports := map[string]util.LuaExport{
+		"register": util.LuaExport{c.cregister, 2, false},
+		"deregister": util.LuaExport{c.cderegister, 1, false},
+		"registry": util.LuaExport{c.cregistry, 0, false},
 	}
-	mod := L.SetFuncs(L.NewTable(), exports)
-	util.Document(L, mod, "Commander is Hilbish's custom command library, a way to write commands with the shell in Lua.")
-	L.Push(mod)
+	mod := rt.NewTable()
+	util.SetExports(rtm, mod, exports)
 
-	return 1
+	return rt.TableValue(mod), nil
 }
 
 // register(name, cb)
-// Register a command with `name` that runs `cb` when ran
-func (c *Commander) cregister(L *lua.LState) int {
-	cmdName := L.CheckString(1)
-	cmd := L.CheckFunction(2)
+// Adds a new command with the given `name`. When Hilbish has to run a command with a name,
+// it will run the function providing the arguments and sinks.
+// #param name string Name of the command
+// #param cb function Callback to handle command invocation
+/*
+#example
+-- When you run the command `hello` in the shell, it will print `Hello world`.
+-- If you run it with, for example, `hello Hilbish`, it will print 'Hello Hilbish'
+commander.register('hello', function(args, sinks)
+	local name = 'world'
+	if #args > 0 then name = args[1] end
 
-	c.Events.Emit("commandRegister", cmdName, cmd)
+	sinks.out:writeln('Hello ' .. name)
+end)
+#example
+*/
+func (c *Commander) cregister(t *rt.Thread, ct *rt.GoCont) (rt.Cont, error) {
+	cmdName, cmd, err := util.HandleStrCallback(t, ct)
+	if err != nil {
+		return nil, err
+	}
 
-	return 0
+	c.Commands[cmdName] = cmd
+
+	return ct.Next(), err
 }
 
 // deregister(name)
-// Deregisters any command registered with `name`
-func (c *Commander) cderegister(L *lua.LState) int {
-	cmdName := L.CheckString(1)
+// Removes the named command. Note that this will only remove Commander-registered commands.
+// #param name string Name of the command to remove.
+func (c *Commander) cderegister(t *rt.Thread, ct *rt.GoCont) (rt.Cont, error) {
+	if err := ct.Check1Arg(); err != nil {
+		return nil, err
+	}
+	cmdName, err := ct.StringArg(0)
+	if err != nil {
+		return nil, err
+	}
 
-	c.Events.Emit("commandDeregister", cmdName)
+	delete(c.Commands, cmdName)
 
-	return 0
+	return ct.Next(), err
+}
+
+// registry() -> table
+// Returns all registered commanders. Returns a list of tables with the following keys:
+// - `exec`: The function used to run the commander. Commanders require args and sinks to be passed.
+// #returns table
+func (c *Commander) cregistry(t *rt.Thread, ct *rt.GoCont) (rt.Cont, error) {
+	registryLua := rt.NewTable()
+	for cmdName, cmd := range c.Commands {
+		cmdTbl := rt.NewTable()
+		cmdTbl.Set(rt.StringValue("exec"), rt.FunctionValue(cmd))
+
+		registryLua.Set(rt.StringValue(cmdName), rt.TableValue(cmdTbl))
+	}
+
+	return ct.PushingNext1(t.Runtime, rt.TableValue(registryLua)), nil
 }

golibs/fs/fs.go

@@ -1,55 +1,220 @@
-// The fs module provides easy and simple access to filesystem functions and other
-// things, and acts an addition to the Lua standard library's I/O and fs functions.
+// filesystem interaction and functionality library
+/*
+The fs module provides filesystem functions to Hilbish. While Lua's standard
+library has some I/O functions, they're missing a lot of the basics. The `fs`
+library offers more functions and will work on any operating system Hilbish does.
+#field pathSep The operating system's path separator.
+*/
 package fs
 
 import (
+	"fmt"
+	"path/filepath"
 	"strconv"
 	"os"
 	"strings"
 
 	"hilbish/util"
-	"github.com/yuin/gopher-lua"
+
+	rt "github.com/arnodel/golua/runtime"
+	"github.com/arnodel/golua/lib/packagelib"
+	"github.com/arnodel/golua/lib/iolib"
 )
 
-func Loader(L *lua.LState) int {
-	mod := L.SetFuncs(L.NewTable(), exports)
-
-	util.Document(L, mod, `The fs module provides easy and simple access to
-filesystem functions and other things, and acts an
-addition to the Lua standard library's I/O and fs functions.`)
-
-	L.Push(mod)
-	return 1
+var Loader = packagelib.Loader{
+	Load: loaderFunc,
+	Name: "fs",
 }
 
-var exports = map[string]lua.LGFunction{
-	"cd": fcd,
-	"mkdir": fmkdir,
-	"stat": fstat,
-	"readdir": freaddir,
+func loaderFunc(rtm *rt.Runtime) (rt.Value, func()) {
+	exports := map[string]util.LuaExport{
+		"cd": util.LuaExport{fcd, 1, false},
+		"mkdir": util.LuaExport{fmkdir, 2, false},
+		"stat": util.LuaExport{fstat, 1, false},
+		"readdir": util.LuaExport{freaddir, 1, false},
+		"abs": util.LuaExport{fabs, 1, false},
+		"basename": util.LuaExport{fbasename, 1, false},
+		"dir": util.LuaExport{fdir, 1, false},
+		"glob": util.LuaExport{fglob, 1, false},
+		"join": util.LuaExport{fjoin, 0, true},
+		"pipe": util.LuaExport{fpipe, 0, false},
+	}
+	mod := rt.NewTable()
+	util.SetExports(rtm, mod, exports)
+	mod.Set(rt.StringValue("pathSep"), rt.StringValue(string(os.PathSeparator)))
+	mod.Set(rt.StringValue("pathListSep"), rt.StringValue(string(os.PathListSeparator)))
+
+	return rt.TableValue(mod), nil
+}
+
+// abs(path) -> string
+// Returns an absolute version of the `path`.
+// This can be used to resolve short paths like `..` to `/home/user`.
+// #param path string
+// #returns string
+func fabs(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
+	path, err := c.StringArg(0)
+	if err != nil {
+		return nil, err
+	}
+	path = util.ExpandHome(path)
+
+	abspath, err := filepath.Abs(path)
+	if err != nil {
+		return nil, err
+	}
+
+	return c.PushingNext1(t.Runtime, rt.StringValue(abspath)), nil
+}
+
+// basename(path) -> string
+// Returns the "basename," or the last part of the provided `path`. If path is empty,
+// `.` will be returned.
+// #param path string Path to get the base name of.
+// #returns string
+func fbasename(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
+	if err := c.Check1Arg(); err != nil {
+		return nil, err
+	}
+	path, err := c.StringArg(0)
+	if err != nil {
+		return nil, err
+	}
+
+	return c.PushingNext(t.Runtime, rt.StringValue(filepath.Base(path))), nil
 }
 
 // cd(dir)
-// Changes directory to `dir`
-func fcd(L *lua.LState) int {
-	path := L.CheckString(1)
-
-	err := os.Chdir(strings.TrimSpace(path))
+// Changes Hilbish's directory to `dir`.
+// #param dir string Path to change directory to.
+func fcd(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
+	if err := c.Check1Arg(); err != nil {
+		return nil, err
+	}
+	path, err := c.StringArg(0)
 	if err != nil {
-		e := err.(*os.PathError).Err.Error()
-		L.RaiseError(e + ": " + path)
+		return nil, err
+	}
+	path = util.ExpandHome(strings.TrimSpace(path))
+
+	err = os.Chdir(path)
+	if err != nil {
+		return nil, err
 	}
 
-	return 0
+	return c.Next(), err
+}
+
+// dir(path) -> string
+// Returns the directory part of `path`. If a file path like
+// `~/Documents/doc.txt` then this function will return `~/Documents`.
+// #param path string Path to get the directory for.
+// #returns string
+func fdir(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
+	if err := c.Check1Arg(); err != nil {
+		return nil, err
+	}
+	path, err := c.StringArg(0)
+	if err != nil {
+		return nil, err
+	}
+
+	return c.PushingNext(t.Runtime, rt.StringValue(filepath.Dir(path))), nil
+}
+
+// glob(pattern) -> matches (table)
+// Match all files based on the provided `pattern`.
+// For the syntax' refer to Go's filepath.Match function: https://pkg.go.dev/path/filepath#Match
+// #param pattern string Pattern to compare files with.
+// #returns table A list of file names/paths that match.
+/*
+#example
+--[[
+	Within a folder that contains the following files:
+	a.txt
+	init.lua
+	code.lua
+	doc.pdf
+]]--
+local matches = fs.glob './*.lua'
+print(matches)
+-- -> {'init.lua', 'code.lua'}
+#example
+*/
+func fglob(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
+	if err := c.Check1Arg(); err != nil {
+		return nil, err
+	}
+	pattern, err := c.StringArg(0)
+	if err != nil {
+		return nil, err
+	}
+
+	matches, err := filepath.Glob(pattern)
+	if err != nil {
+		return nil, err
+	}
+
+	luaMatches := rt.NewTable()
+
+	for i, match := range matches {
+		luaMatches.Set(rt.IntValue(int64(i + 1)), rt.StringValue(match))
+	}
+	
+	return c.PushingNext(t.Runtime, rt.TableValue(luaMatches)), nil
+}
+
+// join(...path) -> string
+// Takes any list of paths and joins them based on the operating system's path separator.
+// #param path ...string Paths to join together
+// #returns string The joined path.
+/*
+#example
+-- This prints the directory for Hilbish's config!
+print(fs.join(hilbish.userDir.config, 'hilbish'))
+-- -> '/home/user/.config/hilbish' on Linux
+#example
+*/
+func fjoin(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
+	strs := make([]string, len(c.Etc()))
+	for i, v := range c.Etc() {
+		if v.Type() != rt.StringType {
+			// +2; go indexes of 0 and first arg from above
+			return nil, fmt.Errorf("bad argument #%d to run (expected string, got %s)", i + 1, v.TypeName())
+		}
+		strs[i] = v.AsString()
+	}
+
+	res := filepath.Join(strs...)
+
+	return c.PushingNext(t.Runtime, rt.StringValue(res)), nil
 }
 
 // mkdir(name, recursive)
-// Makes a directory called `name`. If `recursive` is true, it will create its parent directories.
-func fmkdir(L *lua.LState) int {
-	dirname := L.CheckString(1)
-	recursive := L.ToBool(2)
-	path := strings.TrimSpace(dirname)
-	var err error
+// Creates a new directory with the provided `name`.
+// With `recursive`, mkdir will create parent directories.
+// #param name string Name of the directory
+// #param recursive boolean Whether to create parent directories for the provided name
+/*
+#example
+-- This will create the directory foo, then create the directory bar in the
+-- foo directory. If recursive is false in this case, it will fail.
+fs.mkdir('./foo/bar', true)
+#example
+*/
+func fmkdir(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
+	if err := c.CheckNArgs(2); err != nil {
+		return nil, err
+	}
+	path, err := c.StringArg(0)
+	if err != nil {
+		return nil, err
+	}
+	recursive, err := c.BoolArg(1)
+	if err != nil {
+		return nil, err
+	}
+	path = util.ExpandHome(strings.TrimSpace(path))
 
 	if recursive {
 		err = os.MkdirAll(path, 0744)
@@ -57,48 +222,100 @@ func fmkdir(L *lua.LState) int {
 		err = os.Mkdir(path, 0744)
 	}
 	if err != nil {
-		L.RaiseError(err.Error() + ": " + path)
+		return nil, err
 	}
 
-	return 0
+	return c.Next(), err
 }
 
-// stat(path)
-// Returns info about `path`
-func fstat(L *lua.LState) int {
-	path := L.CheckString(1)
-
-	pathinfo, err := os.Stat(path)
+// fpipe() -> File, File
+// Returns a pair of connected files, also known as a pipe.
+// The type returned is a Lua file, same as returned from `io` functions.
+// #returns File
+// #returns File
+func fpipe(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
+	rf, wf, err := os.Pipe()
 	if err != nil {
-		L.RaiseError(err.Error() + ": " + path)
-		return 0
+		return nil, err
 	}
-	statTbl := L.NewTable()
-	L.SetField(statTbl, "name", lua.LString(pathinfo.Name()))
-	L.SetField(statTbl, "size", lua.LNumber(pathinfo.Size()))
-	L.SetField(statTbl, "mode", lua.LString("0" + strconv.FormatInt(int64(pathinfo.Mode().Perm()), 8)))
-	L.SetField(statTbl, "isDir", lua.LBool(pathinfo.IsDir()))
-	L.Push(statTbl)
 
-	return 1
+	rfLua := iolib.NewFile(rf, 0)
+	wfLua := iolib.NewFile(wf, 0)
+
+	return c.PushingNext(t.Runtime, rfLua.Value(t.Runtime), wfLua.Value(t.Runtime)), nil
 }
-
-// readdir(dir)
-// Returns a table of files in `dir`
-func freaddir(L *lua.LState) int {
-	dir := L.CheckString(1)
-	names := L.NewTable()
+// readdir(path) -> table[string]
+// Returns a list of all files and directories in the provided path.
+// #param dir string
+// #returns table
+func freaddir(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
+	if err := c.Check1Arg(); err != nil {
+		return nil, err
+	}
+	dir, err := c.StringArg(0)
+	if err != nil {
+		return nil, err
+	}
+	dir = util.ExpandHome(dir)
+	names := rt.NewTable()
 
 	dirEntries, err := os.ReadDir(dir)
 	if err != nil {
-		L.RaiseError(err.Error() + ": " + dir)
-		return 0
+		return nil, err
 	}
-	for _, entry := range dirEntries {
-		names.Append(lua.LString(entry.Name()))
+	for i, entry := range dirEntries {
+		names.Set(rt.IntValue(int64(i + 1)), rt.StringValue(entry.Name()))
 	}
 
-	L.Push(names)
-
-	return 1
+	return c.PushingNext1(t.Runtime, rt.TableValue(names)), nil
 }
+
+// stat(path) -> {}
+// Returns the information about a given `path`.
+// The returned table contains the following values:
+// name (string) - Name of the path
+// size (number) - Size of the path in bytes
+// mode (string) - Unix permission mode in an octal format string (with leading 0)
+// isDir (boolean) - If the path is a directory
+// #param path string
+// #returns table
+/*
+#example
+local inspect = require 'inspect'
+
+local stat = fs.stat '~'
+print(inspect(stat))
+--[[
+Would print the following:
+{
+  isDir = true,
+  mode = "0755",
+  name = "username",
+  size = 12288
+}
+]]--
+#example
+*/
+func fstat(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
+	if err := c.Check1Arg(); err != nil {
+		return nil, err
+	}
+	path, err := c.StringArg(0)
+	if err != nil {
+		return nil, err
+	}
+	path = util.ExpandHome(path)
+
+	pathinfo, err := os.Stat(path)
+	if err != nil {
+		return nil, err
+	}
+	statTbl := rt.NewTable()
+	statTbl.Set(rt.StringValue("name"), rt.StringValue(pathinfo.Name()))
+	statTbl.Set(rt.StringValue("size"), rt.IntValue(pathinfo.Size()))
+	statTbl.Set(rt.StringValue("mode"), rt.StringValue("0" + strconv.FormatInt(int64(pathinfo.Mode().Perm()), 8)))
+	statTbl.Set(rt.StringValue("isDir"), rt.BoolValue(pathinfo.IsDir()))
+	
+	return c.PushingNext1(t.Runtime, rt.TableValue(statTbl)), nil
+}
+

golibs/terminal/terminal.go

@@ -1,3 +1,5 @@
+// low level terminal library
+// The terminal library is a simple and lower level library for certain terminal interactions.
 package terminal
 
 import (
@@ -5,76 +7,77 @@ import (
 
 	"hilbish/util"
 
+	rt "github.com/arnodel/golua/runtime"
+	"github.com/arnodel/golua/lib/packagelib"
 	"golang.org/x/term"
-	"github.com/yuin/gopher-lua"
 )
 
 var termState *term.State
-
-func Loader(L *lua.LState) int {
-	mod := L.SetFuncs(L.NewTable(), exports)
-	util.Document(L, mod, "The terminal library is a simple and lower level library for certain terminal interactions.")
-
-	L.Push(mod)
-
-	return 1
+var Loader = packagelib.Loader{
+	Load: loaderFunc,
+	Name: "terminal",
 }
 
-var exports = map[string]lua.LGFunction{
-	"setRaw": termraw,
-	"restoreState": termrestoreState,
-	"size": termsize,
-	"saveState": termsaveState,
+func loaderFunc(rtm *rt.Runtime) (rt.Value, func()) {
+	exports := map[string]util.LuaExport{
+		"setRaw": util.LuaExport{termsetRaw, 0, false},
+		"restoreState": util.LuaExport{termrestoreState, 0, false},
+		"size": util.LuaExport{termsize, 0, false},
+		"saveState": util.LuaExport{termsaveState, 0, false},
+	}
+
+	mod := rt.NewTable()
+	util.SetExports(rtm, mod, exports)
+
+	return rt.TableValue(mod), nil
 }
 
 // size()
 // Gets the dimensions of the terminal. Returns a table with `width` and `height`
-// Note: this is not the size in relation to the dimensions of the display
-func termsize(L *lua.LState) int {
+// NOTE: The size refers to the amount of columns and rows of text that can fit in the terminal.
+func termsize(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
 	w, h, err := term.GetSize(int(os.Stdin.Fd()))
 	if err != nil {
-		L.RaiseError(err.Error())
-		return 0
+		return nil, err
 	}
-	dimensions := L.NewTable()
-	L.SetField(dimensions, "width", lua.LNumber(w))
-	L.SetField(dimensions, "height", lua.LNumber(h))
 
-	L.Push(dimensions)
-	return 1
+	dimensions := rt.NewTable()
+	dimensions.Set(rt.StringValue("width"), rt.IntValue(int64(w)))
+	dimensions.Set(rt.StringValue("height"), rt.IntValue(int64(h)))
+
+	return c.PushingNext1(t.Runtime, rt.TableValue(dimensions)), nil
 }
 
 // saveState()
-// Saves the current state of the terminal
-func termsaveState(L *lua.LState) int {
+// Saves the current state of the terminal.
+func termsaveState(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
 	state, err := term.GetState(int(os.Stdin.Fd()))
 	if err != nil {
-		L.RaiseError(err.Error())
-		return 0
+		return nil, err
 	}
 
 	termState = state
-	return 0
+	return c.Next(), nil
 }
 
 // restoreState()
 // Restores the last saved state of the terminal
-func termrestoreState(L *lua.LState) int {
+func termrestoreState(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
 	err := term.Restore(int(os.Stdin.Fd()), termState)
 	if err != nil {
-		L.RaiseError(err.Error())
+		return nil, err
 	}
 
-	return 0
+	return c.Next(), nil
 }
 
 // setRaw()
-// Puts the terminal in raw mode
-func termraw(L *lua.LState) int {
+// Puts the terminal into raw mode.
+func termsetRaw(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
 	_, err := term.MakeRaw(int(os.Stdin.Fd()))
 	if err != nil {
-		L.RaiseError(err.Error())
+		return nil, err
 	}
 
-	return 0
+	return c.Next(), nil
 }

hilbish-git.spec

@@ -0,0 +1,59 @@
+%global _missing_build_ids_terminate_build 0
+%global debug_package %{nil}
+
+Name: hilbish-git
+Version: {{{ git_tag_version }}}.{{{ git_short_hash }}}
+Release: 1%{?dist}
+Summary: The flower shell. A comfy and nice little shell for Lua fans!
+License: MIT
+
+Source: {{{ git_dir_pack }}}
+BuildRequires: git golang go-task
+Requires: inspect succulent lunacolors
+
+Url: https://github.com/Rosettea/Hilbish
+VCS: {{{ git_dir_vcs }}}
+
+%description
+Hilbish is a extensible shell (framework). It was made to be very customizable
+via the Lua programming language. It aims to be easy to use for the casual
+people but powerful for those who want to tinker more with their shell,
+the thing used to interface with most of the system.
+
+The motivation for choosing Lua was that its simpler and better to use
+than old shell script. It's fine for basic interactive shell uses,
+but that's the only place Hilbish has shell script; everything else is Lua
+and aims to be infinitely configurable. If something isn't, open an issue!
+
+%prep
+{{{ git_dir_setup_macro }}}
+sed -i '\|/etc/shells|d' Taskfile.yaml
+
+%build
+go-task
+
+%install
+go-task install PREFIX=%{buildroot}/usr BINDIR=%{buildroot}/%{_bindir}
+
+%post
+if [ "$1" = 1 ]; then
+	if [ ! -f %{_sysconfdir}/shells ] ; then
+		echo "%{_bindir}/hilbish" > %{_sysconfdir}/shells
+		echo "/bin/hilbish" >> %{_sysconfdir}/shells
+	else
+		grep -q "^%{_bindir}/hilbish$" %{_sysconfdir}/shells || echo "%{_bindir}/hilbish" >> %{_sysconfdir}/shells
+		grep -q "^/bin/hilbish$" %{_sysconfdir}/shells || echo "/bin/hilbish" >> %{_sysconfdir}/shells
+	fi
+fi
+ 
+%postun
+if [ "$1" = 0 ] && [ -f %{_sysconfdir}/shells ] ; then
+	sed -i '\!^%{_bindir}/hilbish$!d' %{_sysconfdir}/shells
+	sed -i '\!^/bin/hilbish$!d' %{_sysconfdir}/shells
+fi
+
+%files
+%doc README.md
+%license LICENSE
+%{_bindir}/hilbish
+%{_datadir}/hilbish

hilbish.go

@@ -1,116 +0,0 @@
-// Here is the core api for the hilbi shell itself
-// Basically, stuff about the shell itself and other functions
-// go here.
-package main
-
-import (
-	"os"
-	"runtime"
-	"strings"
-
-	"hilbish/util"
-
-	"github.com/pborman/getopt"
-	"github.com/yuin/gopher-lua"
-	"mvdan.cc/sh/v3/interp"
-)
-
-var exports = map[string]lua.LGFunction {
-	"run": hlrun,
-	"flag": hlflag,
-	"cwd": hlcwd,
-	"read": hlread,
-}
-
-func HilbishLoader(L *lua.LState) int {
-	mod := L.SetFuncs(L.NewTable(), exports)
-
-	host, _ := os.Hostname()
-	username := curuser.Username
-	// this will be baked into binary since GOOS is a constant
-	if runtime.GOOS == "windows" {
-		username = strings.Split(username, "\\")[1] // for some reason Username includes the hostname on windows
-	}
-
-	util.SetField(L, mod, "ver", lua.LString(version), "Hilbish version")
-	util.SetField(L, mod, "user", lua.LString(username), "Username of user")
-	util.SetField(L, mod, "host", lua.LString(host), "Host name of the machine")
-	util.SetField(L, mod, "home", lua.LString(homedir), "Home directory of the user")
-	util.SetField(L, mod, "dataDir", lua.LString(dataDir), "Directory for Hilbish's data files")
-	util.SetField(L, mod, "interactive", lua.LBool(interactive), "If this is an interactive shell")
-	util.SetField(L, mod, "login", lua.LBool(interactive), "Whether this is a login shell")
-
-	xdg := L.NewTable()
-	L.SetField(xdg, "config", lua.LString(confDir))
-	L.SetField(xdg, "data", lua.LString(getenv("XDG_DATA_HOME", homedir + "/.local/share")))
-	L.SetField(mod, "xdg", xdg)
-
-	util.Document(L, mod, "A miscellaneous sort of \"core\" API for things that relate to the shell itself and others.")
-	L.Push(mod)
-
-	return 1
-}
-
-// run(cmd)
-// Runs `cmd` in Hilbish's sh interpreter
-func hlrun(L *lua.LState) int {
-	var exitcode uint8 = 0
-	cmd := L.CheckString(1)
-	err := execCommand(cmd)
-
-	if code, ok := interp.IsExitStatus(err); ok {
-		exitcode = code
-	} else if err != nil {
-		exitcode = 1
-	}
-
-	L.Push(lua.LNumber(exitcode))
-	return 1
-}
-
-// flag(f)
-// Checks if the `f` flag has been passed to Hilbish.
-func hlflag(L *lua.LState) int {
-	flagchar := L.CheckString(1)
-
-	L.Push(lua.LBool(getopt.Lookup([]rune(flagchar)[0]).Seen()))
-
-	return 1
-}
-
-// cwd()
-// Returns the current directory of the shell
-func hlcwd(L *lua.LState) int {
-	cwd, _ := os.Getwd()
-
-	L.Push(lua.LString(cwd))
-
-	return 1
-}
-
-func getenv(key, fallback string) string {
-    value := os.Getenv(key)
-    if len(value) == 0 {
-        return fallback
-    }
-    return value
-}
-
-// read(prompt) -> input?
-// Read input from the user, using Hilbish's line editor/input reader.
-// This is a separate instance from the one Hilbish actually uses.
-// Returns `input`, will be nil if ctrl + d is pressed, or an error occurs (which shouldn't happen)
-func hlread(L *lua.LState) int {
-	luaprompt := L.CheckString(1)
-	lualr := NewLineReader(luaprompt)
-
-	input, err := lualr.Read()
-	if err != nil {
-		L.Push(lua.LNil)
-		return 1
-	}
-
-	L.Push(lua.LString(input))
-	return 1
-}
-

history.go

@@ -0,0 +1,134 @@
+package main
+
+import (
+	"errors"
+	"io/fs"
+	"os"
+	"path/filepath"
+	"strings"
+
+	rt "github.com/arnodel/golua/runtime"
+)
+
+type luaHistory struct {}
+
+func (h *luaHistory) Write(line string) (int, error) {
+	histWrite := hshMod.Get(rt.StringValue("history")).AsTable().Get(rt.StringValue("add"))
+	ln, err := rt.Call1(l.MainThread(), histWrite, rt.StringValue(line))
+
+	var num int64
+	if ln.Type() == rt.IntType {
+		num = ln.AsInt()
+	}
+
+	return int(num), err
+}
+
+func (h *luaHistory) GetLine(idx int) (string, error) {
+	histGet := hshMod.Get(rt.StringValue("history")).AsTable().Get(rt.StringValue("get"))
+	lcmd, err := rt.Call1(l.MainThread(), histGet, rt.IntValue(int64(idx)))
+
+	var cmd string
+	if lcmd.Type() == rt.StringType {
+		cmd = lcmd.AsString()
+	}
+
+	return cmd, err
+}
+
+func (h *luaHistory) Len() int {
+	histSize := hshMod.Get(rt.StringValue("history")).AsTable().Get(rt.StringValue("size"))
+	ln, _ := rt.Call1(l.MainThread(), histSize)
+
+	var num int64
+	if ln.Type() == rt.IntType {
+		num = ln.AsInt()
+	}
+
+	return int(num)
+}
+
+func (h *luaHistory) Dump() interface{} {
+	// hilbish.history interface already has all function, this isnt used in readline
+	return nil
+}
+
+type fileHistory struct {
+	items []string
+	f *os.File
+}
+
+func newFileHistory(path string) *fileHistory {
+	dir := filepath.Dir(path)
+
+	err := os.MkdirAll(dir, 0755)
+	if err != nil {
+		panic(err)
+	}
+
+	data, err := os.ReadFile(path)
+	if err != nil {
+		if !errors.Is(err, fs.ErrNotExist) {
+			panic(err)
+		}
+	}
+
+	lines := strings.Split(string(data), "\n")
+	itms := make([]string, len(lines) - 1)
+	for i, l := range lines {
+		if i == len(lines) - 1 {
+			continue
+		}
+		itms[i] = l
+	}
+	f, err := os.OpenFile(path, os.O_APPEND | os.O_WRONLY | os.O_CREATE, 0755)
+	if err != nil {
+		panic(err)
+	}
+
+	fh := &fileHistory{
+		items: itms,
+		f: f,
+	}
+
+	return fh
+}
+
+func (h *fileHistory) Write(line string) (int, error) {
+	if line == "" {
+		return len(h.items), nil
+	}
+
+	_, err := h.f.WriteString(line + "\n")
+	if err != nil {
+		return 0, err
+	}
+	h.f.Sync()
+
+	h.items = append(h.items, line)
+	return len(h.items), nil
+}
+
+func (h *fileHistory) GetLine(idx int) (string, error) {
+	if len(h.items) == 0 {
+		return "", nil
+	}
+	if idx == -1 { // this should be fixed readline side
+		return "", nil
+	}
+	return h.items[idx], nil
+}
+
+func (h *fileHistory) Len() int {
+	return len(h.items)
+}
+
+func (h *fileHistory) Dump() interface{} {
+	return h.items
+}
+
+func (h *fileHistory) clear() {
+	h.items = []string{}
+	h.f.Truncate(0)
+	h.f.Sync()
+}

init_windows.go

@@ -0,0 +1,17 @@
+// +build windows
+
+package main
+
+import "golang.org/x/sys/windows"
+
+func init() {
+	// vt output (escape codes)
+	var outMode uint32
+	windows.GetConsoleMode(windows.Stdout, &outMode)
+	windows.SetConsoleMode(windows.Stdout, outMode | windows.ENABLE_VIRTUAL_TERMINAL_PROCESSING)
+
+	// vt input
+	var inMode uint32
+	windows.GetConsoleMode(windows.Stdin, &inMode)
+	windows.SetConsoleMode(windows.Stdin, inMode | windows.ENABLE_VIRTUAL_TERMINAL_INPUT)
+}

job.go

@@ -0,0 +1,507 @@
+package main
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"io"
+	"os"
+	"os/exec"
+	"sync"
+	"syscall"
+
+	"hilbish/util"
+
+	rt "github.com/arnodel/golua/runtime"
+)
+
+var jobs *jobHandler
+var jobMetaKey = rt.StringValue("hshjob")
+
+// #type
+// #interface jobs
+// #property cmd The user entered command string for the job.
+// #property running Whether the job is running or not.
+// #property id The ID of the job in the job table
+// #property pid The Process ID
+// #property exitCode The last exit code of the job.
+// #property stdout The standard output of the job. This just means the normal logs of the process.
+// #property stderr The standard error stream of the process. This (usually) includes error messages of the job.
+// The Job type describes a Hilbish job.
+type job struct {
+	cmd string
+	running bool
+	id int
+	pid int
+	exitCode int
+	once bool
+	args []string
+	// save path for a few reasons, one being security (lmao) while the other
+	// would just be so itll be the same binary command always (path changes)
+	path string
+	handle *exec.Cmd
+	cmdout io.Writer
+	cmderr io.Writer
+	stdout *bytes.Buffer
+	stderr *bytes.Buffer
+	ud *rt.UserData
+}
+
+func (j *job) start() error {
+	if j.handle == nil || j.once {
+		// cmd cant be reused so make a new one
+		cmd := exec.Cmd{
+			Path: j.path,
+			Args: j.args,
+		}
+		j.setHandle(&cmd)
+	}
+	// bgProcAttr is defined in execfile_<os>.go, it holds a procattr struct
+	// in a simple explanation, it makes signals from hilbish (sigint)
+	// not go to it (child process)
+	j.handle.SysProcAttr = bgProcAttr
+	// reset output buffers
+	j.stdout.Reset()
+	j.stderr.Reset()
+	// make cmd write to both standard output and output buffers for lua access
+	j.handle.Stdout = io.MultiWriter(j.cmdout, j.stdout)
+	j.handle.Stderr = io.MultiWriter(j.cmderr, j.stderr)
+
+	if !j.once {
+		j.once = true
+	}
+
+	err := j.handle.Start()
+	proc := j.getProc()
+
+	j.pid = proc.Pid
+	j.running = true
+
+	hooks.Emit("job.start", rt.UserDataValue(j.ud))
+
+	return err
+}
+
+func (j *job) stop() {
+	// finish will be called in exec handle
+	proc := j.getProc()
+	if proc != nil {
+		proc.Kill()
+	}
+}
+
+func (j *job) finish() {
+	j.running = false
+	hooks.Emit("job.done", rt.UserDataValue(j.ud))
+}
+
+func (j *job) wait() {
+	j.handle.Wait()
+}
+
+func (j *job) setHandle(handle *exec.Cmd) {
+	j.handle = handle
+	j.args = handle.Args
+	j.path = handle.Path
+	if handle.Stdout != nil {
+		j.cmdout = handle.Stdout
+	}
+	if handle.Stderr != nil {
+		j.cmderr = handle.Stderr
+	}
+}
+
+func (j *job) getProc() *os.Process {
+	handle := j.handle
+	if handle != nil {
+		return handle.Process
+	}
+
+	return nil
+}
+
+// #interface jobs
+// #member
+// start()
+// Starts running the job.
+func luaStartJob(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
+	if err := c.Check1Arg(); err != nil {
+		return nil, err
+	}
+
+	j, err := jobArg(c, 0)
+	if err != nil {
+		return nil, err
+	}
+
+	if !j.running {
+		err := j.start()
+		exit := handleExecErr(err)
+		j.exitCode = int(exit)
+		j.finish()
+	}
+
+	return c.Next(), nil
+}
+
+// #interface jobs
+// #member
+// stop()
+// Stops the job from running.
+func luaStopJob(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
+	if err := c.Check1Arg(); err != nil {
+		return nil, err
+	}
+
+	j, err := jobArg(c, 0)
+	if err != nil {
+		return nil, err
+	}
+
+	if j.running {
+		j.stop()
+		j.finish()
+	}
+
+	return c.Next(), nil
+}
+
+// #interface jobs
+// #member
+// foreground()
+// Puts a job in the foreground. This will cause it to run like it was
+// executed normally and wait for it to complete.
+func luaForegroundJob(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
+	if err := c.Check1Arg(); err != nil {
+		return nil, err
+	}
+
+	j, err := jobArg(c, 0)
+	if err != nil {
+		return nil, err
+	}
+
+	if !j.running {
+		return nil, errors.New("job not running")
+	}
+
+	// lua code can run in other threads and goroutines, so this exists
+	jobs.foreground = true
+	// this is kinda funny
+	// background continues the process incase it got suspended
+	err = j.background()
+	if err != nil {
+		return nil, err
+	}
+
+	err = j.foreground()
+	if err != nil {
+		return nil, err
+	}
+	jobs.foreground = false
+
+	return c.Next(), nil
+}
+
+// #interface jobs
+// #member
+// background()
+// Puts a job in the background. This acts the same as initially running a job.
+func luaBackgroundJob(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
+	if err := c.Check1Arg(); err != nil {
+		return nil, err
+	}
+
+	j, err := jobArg(c, 0)
+	if err != nil {
+		return nil, err
+	}
+
+	if !j.running {
+		return nil, errors.New("job not running")
+	}
+
+	err = j.background()
+	if err != nil {
+		return nil, err
+	}
+
+	return c.Next(), nil
+}
+
+type jobHandler struct {
+	jobs map[int]*job
+	latestID int
+	foreground bool // if job currently in the foreground
+	mu *sync.RWMutex
+}
+
+func newJobHandler() *jobHandler {
+	return &jobHandler{
+		jobs: make(map[int]*job),
+		latestID: 0,
+		mu: &sync.RWMutex{},
+	}
+}
+
+func (j *jobHandler) add(cmd string, args []string, path string) *job {
+	j.mu.Lock()
+	defer j.mu.Unlock()
+
+	j.latestID++
+	jb := &job{
+		cmd: cmd,
+		running: false,
+		id: j.latestID,
+		args: args,
+		path: path,
+		cmdout: os.Stdout,
+		cmderr: os.Stderr,
+		stdout: &bytes.Buffer{},
+		stderr: &bytes.Buffer{},
+	}
+	jb.ud = jobUserData(jb)
+
+	j.jobs[j.latestID] = jb
+	hooks.Emit("job.add", rt.UserDataValue(jb.ud))
+
+	return jb
+}
+
+func (j *jobHandler) getLatest() *job {
+	j.mu.RLock()
+	defer j.mu.RUnlock()
+
+	return j.jobs[j.latestID]
+}
+
+func (j *jobHandler) disown(id int) error {
+	j.mu.RLock()
+	if j.jobs[id] == nil {
+		return errors.New("job doesnt exist")
+	}
+	j.mu.RUnlock()
+
+	j.mu.Lock()
+	delete(j.jobs, id)
+	j.mu.Unlock()
+
+	return nil
+}
+
+func (j *jobHandler) stopAll() {
+	j.mu.RLock()
+	defer j.mu.RUnlock()
+
+	for _, jb := range j.jobs {
+		// on exit, unix shell should send sighup to all jobs
+		if jb.running {
+			proc := jb.getProc()
+			proc.Signal(syscall.SIGHUP)
+			jb.wait() // waits for program to exit due to sighup
+		}
+	}
+}
+
+// #interface jobs
+// background job management
+/*
+Manage interactive jobs in Hilbish via Lua.
+
+Jobs are the name of background tasks/commands. A job can be started via
+interactive usage or with the functions defined below for use in external runners. */
+func (j *jobHandler) loader(rtm *rt.Runtime) *rt.Table {
+	jobMethods := rt.NewTable()
+	jFuncs := map[string]util.LuaExport{
+		"stop": {luaStopJob, 1, false},
+		"start": {luaStartJob, 1, false},
+		"foreground": {luaForegroundJob, 1, false},
+		"background": {luaBackgroundJob, 1, false},
+	}
+	util.SetExports(l, jobMethods, jFuncs)
+
+	jobMeta := rt.NewTable()
+	jobIndex := func(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
+		j, _ := jobArg(c, 0)
+
+		arg := c.Arg(1)
+		val := jobMethods.Get(arg)
+
+		if val != rt.NilValue {
+			return c.PushingNext1(t.Runtime, val), nil
+		}
+
+		keyStr, _ := arg.TryString()
+
+		switch keyStr {
+			case "cmd": val = rt.StringValue(j.cmd)
+			case "running": val = rt.BoolValue(j.running)
+			case "id": val = rt.IntValue(int64(j.id))
+			case "pid": val = rt.IntValue(int64(j.pid))
+			case "exitCode": val = rt.IntValue(int64(j.exitCode))
+			case "stdout": val = rt.StringValue(string(j.stdout.Bytes()))
+			case "stderr": val = rt.StringValue(string(j.stderr.Bytes()))
+		}
+
+		return c.PushingNext1(t.Runtime, val), nil
+	}
+
+	jobMeta.Set(rt.StringValue("__index"), rt.FunctionValue(rt.NewGoFunction(jobIndex, "__index", 2, false)))
+	l.SetRegistry(jobMetaKey, rt.TableValue(jobMeta))
+
+	jobFuncs := map[string]util.LuaExport{
+		"all": {j.luaAllJobs, 0, false},
+		"last": {j.luaLastJob, 0, false},
+		"get": {j.luaGetJob, 1, false},
+		"add": {j.luaAddJob, 3, false},
+		"disown": {j.luaDisownJob, 1, false},
+	}
+
+	luaJob := rt.NewTable()
+	util.SetExports(rtm, luaJob, jobFuncs)
+
+	return luaJob
+}
+
+func jobArg(c *rt.GoCont, arg int) (*job, error) {
+	j, ok := valueToJob(c.Arg(arg))
+	if !ok {
+		return nil, fmt.Errorf("#%d must be a job", arg + 1)
+	}
+
+	return j, nil
+}
+
+func valueToJob(val rt.Value) (*job, bool) {
+	u, ok := val.TryUserData()
+	if !ok {
+		return nil, false
+	}
+
+	j, ok := u.Value().(*job)
+	return j, ok
+}
+
+func jobUserData(j *job) *rt.UserData {
+	jobMeta := l.Registry(jobMetaKey)
+	return rt.NewUserData(j, jobMeta.AsTable())
+}
+
+// #interface jobs
+// get(id) -> @Job
+// Get a job object via its ID.
+// --- @param id number
+// --- @returns Job
+func (j *jobHandler) luaGetJob(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
+	j.mu.RLock()
+	defer j.mu.RUnlock()
+
+	if err := c.Check1Arg(); err != nil {
+		return nil, err
+	}
+	jobID, err := c.IntArg(0)
+	if err != nil {
+		return nil, err
+	}
+
+	job := j.jobs[int(jobID)]
+	if job == nil {
+		return c.Next(), nil
+	}
+
+	return c.PushingNext(t.Runtime, rt.UserDataValue(job.ud)), nil
+}
+
+// #interface jobs
+// add(cmdstr, args, execPath)
+// Creates a new job. This function does not run the job. This function is intended to be
+// used by runners, but can also be used to create jobs via Lua. Commanders cannot be ran as jobs.
+// #param cmdstr string String that a user would write for the job
+// #param args table Arguments for the commands. Has to include the name of the command.
+// #param execPath string Binary to use to run the command. Needs to be an absolute path.
+/*
+#example
+hilbish.jobs.add('go build', {'go', 'build'}, '/usr/bin/go')
+#example
+*/
+func (j *jobHandler) luaAddJob(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
+	if err := c.CheckNArgs(3); err != nil {
+		return nil, err
+	}
+	cmd, err := c.StringArg(0)
+	if err != nil {
+		return nil, err
+	}
+	largs, err := c.TableArg(1)
+	if err != nil {
+		return nil, err
+	}
+	execPath, err := c.StringArg(2)
+	if err != nil {
+		return nil, err
+	}
+
+	var args []string
+	util.ForEach(largs, func(k rt.Value, v rt.Value) {
+		if v.Type() == rt.StringType {
+			args = append(args, v.AsString())
+		}
+	})
+
+	jb := j.add(cmd, args, execPath)
+
+	return c.PushingNext1(t.Runtime, rt.UserDataValue(jb.ud)), nil
+}
+
+// #interface jobs
+// all() -> table[@Job]
+// Returns a table of all job objects.
+// #returns table[Job]
+func (j *jobHandler) luaAllJobs(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
+	j.mu.RLock()
+	defer j.mu.RUnlock()
+
+	jobTbl := rt.NewTable()
+	for id, job := range j.jobs {
+		jobTbl.Set(rt.IntValue(int64(id)), rt.UserDataValue(job.ud))
+	}
+
+	return c.PushingNext1(t.Runtime, rt.TableValue(jobTbl)), nil
+}
+
+// #interface jobs
+// disown(id)
+// Disowns a job. This simply deletes it from the list of jobs without stopping it.
+// #param id number
+func (j *jobHandler) luaDisownJob(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
+	if err := c.Check1Arg(); err != nil {
+		return nil, err
+	}
+	jobID, err := c.IntArg(0)
+	if err != nil {
+		return nil, err
+	}
+
+	err = j.disown(int(jobID))
+	if err != nil {
+		return nil, err
+	}
+
+	return c.Next(), nil
+}
+
+// #interface jobs
+// last() -> @Job
+// Returns the last added job to the table.
+// #returns Job
+func (j *jobHandler) luaLastJob(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
+	j.mu.RLock()
+	defer j.mu.RUnlock()
+
+	job := j.jobs[j.latestID]
+	if job == nil { // incase we dont have any jobs yet
+		return c.Next(), nil
+	}
+
+	return c.PushingNext1(t.Runtime, rt.UserDataValue(job.ud)), nil
+}

job_unix.go

@@ -0,0 +1,38 @@
+// +build darwin linux
+
+package main
+
+import (
+	"errors"
+	"os"
+	"syscall"
+	
+	"golang.org/x/sys/unix"
+)
+
+func (j *job) foreground() error {
+	if jobs.foreground {
+		return errors.New("(another) job already foregrounded")
+	}
+
+	pgid, _ := syscall.Getpgid(j.pid)
+	// tcsetpgrp
+	unix.IoctlSetPointerInt(0, unix.TIOCSPGRP, pgid)
+	proc, _ := os.FindProcess(j.pid)
+	proc.Wait()
+	
+	hshPgid, _ := syscall.Getpgid(os.Getpid())
+	unix.IoctlSetPointerInt(0, unix.TIOCSPGRP, hshPgid)
+
+	return nil
+}
+
+func (j *job) background() error {
+	proc := j.handle.Process
+	if proc == nil {
+		return nil
+	}
+
+	proc.Signal(syscall.SIGCONT)
+	return nil
+}

job_windows.go

@@ -0,0 +1,15 @@
+// +build windows
+
+package main
+
+import (
+	"errors"
+)
+
+func (j *job) foreground() error {
+	return errors.New("not supported on windows")
+}
+
+func (j *job) background() error {
+	return errors.New("not supported on windows")
+}

libs/ansikit/init.lua

@@ -1,15 +1,19 @@
--- We're basically porting Ansikit to lua
--- https://github.com/Luvella/AnsiKit/blob/master/lib/index.js
--- which is made by yours truly sammy :^)
 local lunacolors = require 'lunacolors'
-local ansikit = {}
+local ansikit = {
+	blockCursor = 1,
+	blockCursorSteady = 2,
+	underlineCursor = 3,
+	underlineCursorSteady = 4,
+	lineCursor = 5,
+	lineCursorSteady = 6,
+}
 
 ansikit.clear = function(scrollback)
-	typ = (scrollback and 3 or 2)
+	local typ = (scrollback and 3 or 2)
 	return ansikit.printCSI(typ, 'J')
 end
 
-ansikit.clearFromPos = function(scrollback)
+ansikit.clearFromPos = function()
 	return ansikit.printCSI(0, 'J')
 end
 
@@ -47,7 +51,7 @@ end
 ansikit.cursorStyle = function(style)
 	style = (style and style or ansikit.underlineCursor)
 	if style > 6 or style < 1 then style = ansikit.underlineCursor end
-	
+
 	return ansikit.printCSI(style, ' q')
 end
 
@@ -79,27 +83,31 @@ end
 
 ansikit.link = function(url, text)
 	if not url then error 'ansikit: missing url for hyperlink' end
-	local text = (text and text or 'link')
+	text = (text and text or 'link')
 	return lunacolors.blue('\27]8;;' .. url .. '\27\\' .. text .. '\27]8;;\27\\\n')
 end
 
 ansikit.print = function(text)
 	io.write(ansikit.format(text))
+	io.flush()
 	return ansikit
 end
 
 ansikit.printCode = function(code, terminate)
 	io.write(ansikit.getCode(code, terminate))
+	io.flush()
 	return ansikit
 end
 
 ansikit.printCSI = function(code, endc)
 	io.write(ansikit.getCSI(code, endc))
+	io.flush()
 	return ansikit
 end
 
 ansikit.println = function(text)
-	print(ansikit.print(text))
+	io.write(ansikit.format(text) .. "\n")
+	io.flush()
 	return ansikit
 end
 
@@ -131,6 +139,15 @@ ansikit.saveState = function()
 	return ansikit.printCode(7)
 end
 
+ansikit.screenMain = function()
+	return ansikit.printCSI('?1049', 'l')
+end
+
+ansikit.screenAlt = function()
+	ansikit.cursorTo(0, 0)
+	return ansikit.printCSI('?1049', 'h')
+end
+
 ansikit.setTitle = function(text)
 	return ansikit.printCode(']2;' .. text, true)
 end

libs/lunacolors

@@ -1 +1 @@
-Subproject commit d200fca13df1c47e133b269420223d7e257dbc41
+Subproject commit 34a57c964590f89aa065188a588c7b38aff99c28

lua.go

@@ -3,249 +3,82 @@ package main
 import (
 	"fmt"
 	"os"
-	"os/exec"
-	"strings"
-	"syscall"
-	"time"
 
+	"hilbish/util"
 	"hilbish/golibs/bait"
 	"hilbish/golibs/commander"
 	"hilbish/golibs/fs"
 	"hilbish/golibs/terminal"
 
-	"github.com/yuin/gopher-lua"
-	"layeh.com/gopher-luar"
+	rt "github.com/arnodel/golua/runtime"
+	"github.com/arnodel/golua/lib"
+	"github.com/arnodel/golua/lib/debuglib"
 )
 
-var minimalconf = `
-lunacolors = require 'lunacolors'
-prompt(lunacolors.format(
-		'{blue}%u {cyan}%d {green}∆{reset} '
-))
-`
+var minimalconf = `hilbish.prompt '& '`
 
-func LuaInit() {
-	l = lua.NewState()
-	l.OpenLibs()
-
-	l.SetGlobal("prompt", l.NewFunction(hshprompt))
-	l.SetGlobal("multiprompt", l.NewFunction(hshmlprompt))
-	l.SetGlobal("alias", l.NewFunction(hshalias))
-	l.SetGlobal("appendPath", l.NewFunction(hshappendPath))
-	l.SetGlobal("prependPath", l.NewFunction(hshprependPath))
-	l.SetGlobal("exec", l.NewFunction(hshexec))
-	l.SetGlobal("goro", luar.New(l, hshgoroutine))
-	l.SetGlobal("timeout", luar.New(l, hshtimeout))
-	l.SetGlobal("interval", l.NewFunction(hshinterval))
+func luaInit() {
+	l = rt.New(os.Stdout)
+	l.PushContext(rt.RuntimeContextDef{
+		MessageHandler: debuglib.Traceback,
+	})
+	lib.LoadAll(l)
+	setupSinkType(l)
 
+	lib.LoadLibs(l, hilbishLoader)
 	// yes this is stupid, i know
-	l.PreloadModule("hilbish", HilbishLoader)
-	l.DoString("hilbish = require 'hilbish'")
+	util.DoString(l, "hilbish = require 'hilbish'")
 
 	// Add fs and terminal module module to Lua
-	l.PreloadModule("fs", fs.Loader)
-	l.PreloadModule("terminal", terminal.Loader)
+	lib.LoadLibs(l, fs.Loader)
+	lib.LoadLibs(l, terminal.Loader)
 
-	cmds := commander.New()
-	// When a command from Lua is added, register it for use
-	cmds.Events.On("commandRegister", func(cmdName string, cmd *lua.LFunction) {
-		commands[cmdName] = cmd
-	})
-	cmds.Events.On("commandDeregister", func(cmdName string) {
-		delete(commands, cmdName)
-	})
-	l.PreloadModule("commander", cmds.Loader)
+	cmds = commander.New(l)
+	lib.LoadLibs(l, cmds.Loader)
 
-	hooks = bait.New()
-	l.PreloadModule("bait", hooks.Loader)
+	hooks = bait.New(l)
+	hooks.SetRecoverer(func(event string, handler *bait.Listener, err interface{}) {
+		fmt.Println("Error in `error` hook handler:", err)
+		hooks.Off(event, handler)
+	})
+
+	lib.LoadLibs(l, hooks.Loader)
 
 	// Add Ctrl-C handler
-	hooks.Em.On("signal.sigint", func() {
+	hooks.On("signal.sigint", func(...interface{}) {
 		if !interactive {
 			os.Exit(0)
 		}
 	})
 
-	l.SetGlobal("complete", l.NewFunction(hshcomplete))
+	lr.rl.RawInputCallback = func(r []rune) {
+		hooks.Emit("hilbish.rawInput", string(r))
+	}
 
 	// Add more paths that Lua can require from
-	l.DoString("package.path = package.path .. " + requirePaths)
-
-	err := l.DoFile("preload.lua")
+	_, err := util.DoString(l, "package.path = package.path .. " + requirePaths)
 	if err != nil {
-		err = l.DoFile(preloadPath)
-		if err != nil {
-			fmt.Fprintln(os.Stderr,
-				"Missing preload file, builtins may be missing.")
+		fmt.Fprintln(os.Stderr, "Could not add Hilbish require paths! Libraries will be missing. This shouldn't happen.")
+	}
+
+	err1 := util.DoFile(l, "nature/init.lua")
+	if err1 != nil {
+		err2 := util.DoFile(l, preloadPath)
+		if err2 != nil {
+			fmt.Fprintln(os.Stderr, "Missing nature module, some functionality and builtins will be missing.")
+			fmt.Fprintln(os.Stderr, "local error:", err1)
+			fmt.Fprintln(os.Stderr, "global install error:", err2)
 		}
 	}
 }
-func RunConfig(confpath string) {
+
+func runConfig(confpath string) {
 	if !interactive {
 		return
 	}
-	err := l.DoFile(confpath)
+	err := util.DoFile(l, confpath)
 	if err != nil {
-		fmt.Fprintln(os.Stderr, err,
-			"\nAn error has occured while loading your config! Falling back to minimal default config.")
-
-		l.DoString(minimalconf)
+		fmt.Fprintln(os.Stderr, err, "\nAn error has occured while loading your config! Falling back to minimal default config.")
+		util.DoString(l, minimalconf)
 	}
 }
-
-func RunLogin() {
-	if _, err := os.Stat(homedir + "/.hprofile.lua"); os.IsNotExist(err) {
-		return
-	}
-	if !login {
-		return
-	}
-	err := l.DoFile(homedir + "/.hprofile.lua")
-	if err != nil {
-		fmt.Fprintln(os.Stderr, err,
-			"\nAn error has occured while loading your login config!n")
-	}
-}
-
-/* prompt(str)
-Changes the shell prompt to `str`
-There are a few verbs that can be used in the prompt text.
-These will be formatted and replaced with the appropriate values.
-`%d` - Current working directory
-`%u` - Name of current user
-`%h` - Hostname of device */
-func hshprompt(L *lua.LState) int {
-	prompt = L.CheckString(1)
-
-	return 0
-}
-
-// multiprompt(str)
-// Changes the continued line prompt to `str`
-func hshmlprompt(L *lua.LState) int {
-	multilinePrompt = L.CheckString(1)
-
-	return 0
-}
-
-// alias(cmd, orig)
-// Sets an alias of `orig` to `cmd`
-func hshalias(L *lua.LState) int {
-	alias := L.CheckString(1)
-	source := L.CheckString(2)
-
-	aliases[alias] = source
-
-	return 1
-}
-
-// appendPath(dir)
-// Appends `dir` to $PATH
-func hshappendPath(L *lua.LState) int {
-	dir := L.CheckString(1)
-	dir = strings.Replace(dir, "~", curuser.HomeDir, 1)
-	pathenv := os.Getenv("PATH")
-
-	// if dir isnt already in $PATH, add it
-	if !strings.Contains(pathenv, dir) {
-		os.Setenv("PATH", pathenv + string(os.PathListSeparator) + dir)
-	}
-
-	return 0
-}
-
-// exec(cmd)
-// Replaces running hilbish with `cmd`
-func hshexec(L *lua.LState) int {
-	cmd := L.CheckString(1)
-	cmdArgs, _ := splitInput(cmd)
-	cmdPath, err := exec.LookPath(cmdArgs[0])
-	if err != nil {
-		fmt.Println(err)
-		// if we get here, cmdPath will be nothing
-		// therefore nothing will run
-	}
-
-	// syscall.Exec requires an absolute path to a binary
-	// path, args, string slice of environments
-	// TODO: alternative for windows
-	syscall.Exec(cmdPath, cmdArgs, os.Environ())
-	return 0 // random thought: does this ever return?
-}
-
-// goro(fn)
-// Puts `fn` in a goroutine
-func hshgoroutine(gofunc func()) {
-	go gofunc()
-}
-
-// timeout(cb, time)
-// Runs the `cb` function after `time` in milliseconds
-func hshtimeout(timeoutfunc func(), ms int) {
-	timeout := time.Duration(ms) * time.Millisecond
-	time.Sleep(timeout)
-	timeoutfunc()
-}
-
-// interval(cb, time)
-// Runs the `cb` function every `time` milliseconds
-func hshinterval(L *lua.LState) int {
-	intervalfunc := L.CheckFunction(1)
-	ms := L.CheckInt(2)
-	interval := time.Duration(ms) * time.Millisecond
-
-	ticker := time.NewTicker(interval)
-	stop := make(chan lua.LValue)
-
-	go func() {
-		for {
-			select {
-			case <-ticker.C:
-				if err := L.CallByParam(lua.P{
-					Fn: intervalfunc,
-					NRet: 0,
-					Protect: true,
-				}); err != nil {
-					fmt.Fprintln(os.Stderr,
-						"Error in interval function:\n\n", err)
-				}
-			case <-stop:
-				ticker.Stop()
-				return
-			}
-		}
-	}()
-
-	L.Push(lua.LChannel(stop))
-	return 1
-}
-
-// complete(scope, cb)
-// Registers a completion handler for `scope`.
-// A `scope` is currently only expected to be `command.<cmd>`,
-// replacing <cmd> with the name of the command (for example `command.git`).
-// `cb` must be a function that returns a table of the entries to complete.
-// Nested tables will be used as sub-completions.
-func hshcomplete(L *lua.LState) int {
-	scope := L.CheckString(1)
-	cb := L.CheckFunction(2)
-
-	luaCompletions[scope] = cb
-
-	return 0
-}
-
-// prependPath(dir)
-// Prepends `dir` to $PATH
-func hshprependPath(L *lua.LState) int {
-	dir := L.CheckString(1)
-	dir = strings.Replace(dir, "~", curuser.HomeDir, 1)
-	pathenv := os.Getenv("PATH")
-
-	// if dir isnt already in $PATH, add in
-	if !strings.Contains(pathenv, dir) {
-		os.Setenv("PATH", dir + string(os.PathListSeparator) + pathenv)
-	}
-
-	return 0
-}

main.go

@@ -2,70 +2,72 @@ package main
 
 import (
 	"bufio"
+	"errors"
 	"fmt"
 	"io"
 	"os"
-	"os/signal"
 	"os/user"
 	"path/filepath"
 	"runtime"
 	"strings"
 	"syscall"
 
+	"hilbish/util"
 	"hilbish/golibs/bait"
+	"hilbish/golibs/commander"
 
+	rt "github.com/arnodel/golua/runtime"
 	"github.com/pborman/getopt"
-	"github.com/yuin/gopher-lua"
+	"github.com/maxlandon/readline"
 	"golang.org/x/term"
-	"layeh.com/gopher-luar"
 )
 
 var (
-	l *lua.LState
-	lr *LineReader
+	l *rt.Runtime
+	lr *lineReader
 
-	commands = map[string]*lua.LFunction{}
-	aliases = map[string]string{}
-	luaCompletions = map[string]*lua.LFunction{}
+	luaCompletions = map[string]*rt.Closure{}
 
-	homedir string
 	confDir string
+	userDataDir string
 	curuser *user.User
 
-	hooks bait.Bait
+	hooks *bait.Bait
+	cmds *commander.Commander
 	defaultConfPath string
 	defaultHistPath string
 )
 
 func main() {
-	homedir, _ = os.UserHomeDir()
-	confDir = getenv("XDG_CONFIG_HOME", homedir + "/.config")
 	curuser, _ = user.Current()
+	homedir := curuser.HomeDir
+	confDir, _ = os.UserConfigDir()
 	preloadPath = strings.Replace(preloadPath, "~", homedir, 1)
 	sampleConfPath = strings.Replace(sampleConfPath, "~", homedir, 1)
 
+	// i honestly dont know what directories to use for this
+	switch runtime.GOOS {
+	case "linux", "darwin":
+		userDataDir = getenv("XDG_DATA_HOME", curuser.HomeDir + "/.local/share")
+	default:
+		// this is fine on windows, dont know about others
+		userDataDir = confDir
+	}
+
 	if defaultConfDir == "" {
 		// we'll add *our* default if its empty (wont be if its changed comptime)
-		if _, err := os.Stat(filepath.Join(confDir, "hilbish")); os.IsNotExist(err) {
-			defaultConfPath = filepath.Join(homedir, "/.hilbishrc.lua")
-		} else {
-			defaultConfPath = filepath.Join(confDir, "hilbish", "hilbishrc.lua")
-		}
+		defaultConfDir = filepath.Join(confDir, "hilbish")
 	} else {
 		// else do ~ substitution
-		defaultConfPath = filepath.Join(strings.Replace(defaultConfDir, "~", homedir, 1), ".hilbishrc.lua")
+		defaultConfDir = filepath.Join(util.ExpandHome(defaultConfDir), "hilbish")
 	}
+	defaultConfPath = filepath.Join(defaultConfDir, "init.lua")
 	if defaultHistDir == "" {
-		// we'll add *our* default if its empty (wont be if its changed comptime)
-		if _, err := os.Stat(filepath.Join(confDir, "hilbish")); os.IsNotExist(err) {
-			defaultHistPath = filepath.Join(homedir, "/.hilbish-history")
-		} else {
-			defaultHistPath = filepath.Join(confDir, "hilbish", ".hilbish-history")
-		}
+		defaultHistDir = filepath.Join(userDataDir, "hilbish")
 	} else {
-		// else do ~ substitution
-		defaultHistPath = filepath.Join(strings.Replace(defaultHistDir, "~", homedir, 1), ".hilbishrc.lua")
+		defaultHistDir = filepath.Join(util.ExpandHome(defaultHistDir), "hilbish")
 	}
+	defaultHistPath = filepath.Join(defaultHistDir, ".hilbish-history")
 	helpflag := getopt.BoolLong("help", 'h', "Prints Hilbish flags")
 	verflag := getopt.BoolLong("version", 'v', "Prints Hilbish version")
 	setshflag := getopt.BoolLong("setshellenv", 'S', "Sets $SHELL to Hilbish's executed path")
@@ -89,7 +91,7 @@ func main() {
 		interactive = true
 	}
 
-	if fileInfo, _ := os.Stdin.Stat(); (fileInfo.Mode() & os.ModeCharDevice) == 0 {
+	if fileInfo, _ := os.Stdin.Stat(); (fileInfo.Mode() & os.ModeCharDevice) == 0 || !term.IsTerminal(int(os.Stdin.Fd())) {
 		interactive = false
 	}
 
@@ -107,7 +109,7 @@ func main() {
 	}
 
 	if *verflag {
-		fmt.Printf("Hilbish %s\n", version)
+		fmt.Printf("Hilbish %s\nCompiled with %s\n", getVersion(), runtime.Version())
 		os.Exit(0)
 	}
 
@@ -116,84 +118,106 @@ func main() {
 		os.Setenv("SHELL", os.Args[0])
 	}
 
+	lr = newLineReader("", false)
+	luaInit()
+
+	go handleSignals()
+
 	// If user's config doesn't exixt,
-	if _, err := os.Stat(defaultConfPath); os.IsNotExist(err) {
+	if _, err := os.Stat(defaultConfPath); os.IsNotExist(err) && *configflag == defaultConfPath {
 		// Read default from current directory
 		// (this is assuming the current dir is Hilbish's git)
-		input, err := os.ReadFile(".hilbishrc.lua")
+		_, err := os.ReadFile(".hilbishrc.lua")
+		confpath := ".hilbishrc.lua"
 		if err != nil {
 			// If it wasnt found, go to the real sample conf
-			input, err = os.ReadFile(sampleConfPath)
+			_, err = os.ReadFile(sampleConfPath)
+			confpath = sampleConfPath
 			if err != nil {
 				fmt.Println("could not find .hilbishrc.lua or", sampleConfPath)
 				return
 			}
 		}
 
-		// Create it using either default config we found
-		err = os.WriteFile(defaultConfPath, input, 0644)
-		if err != nil {
-			// If that fails, bail
-			fmt.Println("Error creating config file")
-			fmt.Println(err)
-			return
-		}
+		runConfig(confpath)
+	} else {
+		runConfig(*configflag)
 	}
-
-	go HandleSignals()
-	LuaInit()
-	RunLogin()
-	RunConfig(*configflag)
-
-	lr = NewLineReader("")
+	hooks.Emit("hilbish.init")
 
 	if fileInfo, _ := os.Stdin.Stat(); (fileInfo.Mode() & os.ModeCharDevice) == 0 {
 		scanner := bufio.NewScanner(bufio.NewReader(os.Stdin))
 		for scanner.Scan() {
-			RunInput(scanner.Text())
+			text := scanner.Text()
+			runInput(text, true)
 		}
+		exit(0)
 	}
 
 	if *cmdflag != "" {
-		RunInput(*cmdflag)
+		runInput(*cmdflag, true)
 	}
 
 	if getopt.NArgs() > 0 {
-		l.SetGlobal("args", luar.New(l, getopt.Args()))
-		err := l.DoFile(getopt.Arg(0))
+		luaArgs := rt.NewTable()
+		for i, arg := range getopt.Args() {
+			luaArgs.Set(rt.IntValue(int64(i)), rt.StringValue(arg))
+		}
+
+		l.GlobalEnv().Set(rt.StringValue("args"), rt.TableValue(luaArgs))
+		err := util.DoFile(l, getopt.Arg(0))
 		if err != nil {
 			fmt.Fprintln(os.Stderr, err)
-			os.Exit(1)
+			exit(1)
 		}
-		os.Exit(0)
+		exit(0)
 	}
 
+	initialized = true
 input:
 	for interactive {
 		running = false
 
-		lr.SetPrompt(fmtPrompt())
 		input, err := lr.Read()
 
 		if err == io.EOF {
 			// Exit if user presses ^D (ctrl + d)
+			hooks.Emit("hilbish.exit")
 			break
 		}
 		if err != nil {
-			// If we get a completely random error, print
-			fmt.Fprintln(os.Stderr, err)
+			if err == readline.CtrlC {
+				fmt.Println("^C")
+				hooks.Emit("hilbish.cancel")
+			} else {
+				// If we get a completely random error, print
+				fmt.Fprintln(os.Stderr, err)
+				if errors.Is(err, syscall.ENOTTY) {
+					// what are we even doing here?
+					panic("not a tty")
+				}
+				<-make(chan struct{})
+			}
+			continue
+		}
+		var priv bool
+		if strings.HasPrefix(input, " ") {
+			priv = true
 		}
 
 		input = strings.TrimSpace(input)
 		if len(input) == 0 {
-			hooks.Em.Emit("command.exit", 0)
+			running = true
+			hooks.Emit("command.exit", 0)
 			continue
 		}
 
 		if strings.HasSuffix(input, "\\") {
 			for {
-				input, err = ContinuePrompt(strings.TrimSuffix(input, "\\"))
+				input, err = continuePrompt(input)
 				if err != nil {
+					running = true
+					lr.SetPrompt(fmtPrompt(prompt))
 					goto input // continue inside nested loop
 				}
 				if !strings.HasSuffix(input, "\\") {
@@ -201,9 +225,8 @@ input:
 				}
 			}
 		}
-		running = true
-		HandleHistory(input)
-		RunInput(input)
+
+		runInput(input, priv)
 
 		termwidth, _, err := term.GetSize(0)
 		if err != nil {
@@ -211,14 +234,15 @@ input:
 		}
 		fmt.Printf("\u001b[7m∆\u001b[0m" + strings.Repeat(" ", termwidth - 1) + "\r")
 	}
+
+	exit(0)
 }
 
-func ContinuePrompt(prev string) (string, error) {
-	hooks.Em.Emit("multiline", nil)
+func continuePrompt(prev string) (string, error) {
+	hooks.Emit("multiline", nil)
 	lr.SetPrompt(multilinePrompt)
 	cont, err := lr.Read()
 	if err != nil {
-		fmt.Println("")
 		return "", err
 	}
 	cont = strings.TrimSpace(cont)
@@ -227,11 +251,11 @@ func ContinuePrompt(prev string) (string, error) {
 }
 
 // This semi cursed function formats our prompt (obviously)
-func fmtPrompt() string {
+func fmtPrompt(prompt string) string {
 	host, _ := os.Hostname()
 	cwd, _ := os.Getwd()
 
-	cwd = strings.Replace(cwd, curuser.HomeDir, "~", 1)
+	cwd = util.AbbrevHome(cwd)
 	username := curuser.Username
 	// this will be baked into binary since GOOS is a constant
 	if runtime.GOOS == "windows" {
@@ -257,29 +281,57 @@ func fmtPrompt() string {
 	return nprompt
 }
 
-// do i even have to say
-func HandleSignals() {
-	c := make(chan os.Signal)
-	signal.Notify(c, os.Interrupt, syscall.SIGWINCH)
-
-	for s := range c {
-		switch s {
-		case os.Interrupt:
-			hooks.Em.Emit("signals.sigint")
-			if !running {
-				lr.ClearInput()
-			}
-		case syscall.SIGWINCH:
-			hooks.Em.Emit("signals.resize")
-			if !running {
-				lr.Resize()
-			}
+func removeDupes(slice []string) []string {
+	all := make(map[string]bool)
+	newSlice := []string{}
+	for _, item := range slice {
+		if _, val := all[item]; !val {
+			all[item] = true
+			newSlice = append(newSlice, item)
 		}
 	}
+
+	return newSlice
 }
 
-func HandleHistory(cmd string) {
-	lr.AddHistory(cmd)
-	// TODO: load history again (history shared between sessions like this ye)
+func contains(s []string, e string) bool {
+	for _, a := range s {
+		if strings.ToLower(a) == strings.ToLower(e) {
+			return true
+		}
+	}
+	return false
 }
 
+func exit(code int) {
+	jobs.stopAll()
+
+	// wait for all timers to finish before exiting.
+	// only do that when not interactive
+	if !interactive {
+		timers.wait()
+	}
+
+	os.Exit(code)
+}
+
+func getVersion() string {
+	v := strings.Builder{}
+
+	v.WriteString(ver)
+	if gitBranch != "" && gitBranch != "HEAD" {
+		v.WriteString("-" + gitBranch)
+	}
+
+	if gitCommit != "" {
+		v.WriteString("." + gitCommit)
+	}
+
+	v.WriteString(" (" + releaseName + ")")
+
+	return v.String()
+}
+
+func cut(slice []string, idx int) []string {
+	return append(slice[:idx], slice[idx + 1:]...)
+}

module.go

@@ -0,0 +1,93 @@
+package main
+
+import (
+	"plugin"
+
+	"hilbish/util"
+
+	rt "github.com/arnodel/golua/runtime"
+)
+
+// #interface module
+// native module loading
+// #field paths A list of paths to search when loading native modules. This is in the style of Lua search paths and will be used when requiring native modules. Example: `?.so;?/?.so`
+/*
+The hilbish.module interface provides a function to load
+Hilbish plugins/modules. Hilbish modules are Go-written
+plugins (see https://pkg.go.dev/plugin) that are used to add functionality
+to Hilbish that cannot be written in Lua for any reason.
+
+Note that you don't ever need to use the load function that is here as
+modules can be loaded with a `require` call like Lua C modules, and the
+search paths can be changed with the `paths` property here.
+
+To make a valid native module, the Go plugin has to export a Loader function
+with a signature like so: `func(*rt.Runtime) rt.Value`.
+
+`rt` in this case refers to the Runtime type at
+https://pkg.go.dev/github.com/arnodel/golua@master/runtime#Runtime
+
+Hilbish uses this package as its Lua runtime. You will need to read
+it to use it for a native plugin.
+
+Here is some code for an example plugin:
+```go
+package main
+
+import (
+	rt "github.com/arnodel/golua/runtime"
+)
+
+func Loader(rtm *rt.Runtime) rt.Value {
+	return rt.StringValue("hello world!")
+}
+```
+
+This can be compiled with `go build -buildmode=plugin plugin.go`.
+If you attempt to require and print the result (`print(require 'plugin')`), it will show "hello world!"
+*/
+func moduleLoader(rtm *rt.Runtime) *rt.Table {
+	exports := map[string]util.LuaExport{
+		"load": {moduleLoad, 2, false},
+	}
+
+	mod := rt.NewTable()
+	util.SetExports(rtm, mod, exports)
+
+	return mod
+}
+
+// #interface module
+// load(path)
+// Loads a module at the designated `path`.
+// It will throw if any error occurs.
+// #param path string 
+func moduleLoad(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
+	if err := c.CheckNArgs(1); err != nil {
+		return nil, err
+	}
+	
+	path, err := c.StringArg(0)
+	if err != nil {
+		return nil, err
+	}
+
+	p, err := plugin.Open(path)
+	if err != nil {
+		return nil, err
+	}
+
+	value, err := p.Lookup("Loader")
+	if err != nil {
+		return nil, err
+	}
+
+	loader, ok := value.(func(*rt.Runtime) rt.Value)
+	if !ok {
+		return nil, nil
+	}
+
+	val := loader(t.Runtime)
+
+	return c.PushingNext1(t.Runtime, val), nil
+}

nature/commands/bg.lua

@@ -0,0 +1,15 @@
+local commander = require 'commander'
+
+commander.register('bg', function(_, sinks)
+	local job = hilbish.jobs.last()
+	if not job then
+		sinks.out:writeln 'bg: no last job'
+		return 1
+	end
+
+	local err = job:background()
+	if err then
+		sinks.out:writeln('bg: ' .. err)
+		return 2
+	end
+end)

nature/commands/cat.lua

@@ -0,0 +1,31 @@
+local commander = require 'commander'
+local fs = require 'fs'
+
+commander.register('cat', function(args, sinks)
+	local exit = 0
+
+	if #args == 0 then
+		sinks.out:writeln [[
+usage: cat [file]...]]
+	end
+
+	local chunkSize = 2^13 -- 8K buffer size
+
+	for _, fName in ipairs(args) do
+		local f = io.open(fName)
+		if f == nil then
+			exit = 1
+			sinks.out:writeln(string.format('cat: %s: no such file or directory', fName))
+			goto continue
+		end
+
+		while true do
+			local block = f:read(chunkSize)
+			if not block then break end
+			sinks.out:write(block)
+		end
+		::continue::
+	end
+	io.flush()
+	return exit
+end)