Update scripts and docs to no longer use aliases

Author: ZakaHaceCosas

.vscode/settings.json

@@ -7,22 +7,7 @@
         "codeberg",
         "crossplatform",
         "crossruntime",
-        "fkadd",
-        "fkaudit",
-        "fkbuild",
-        "fkclean",
-        "fkcommit",
-        "fklaunch",
-        "fklist",
-        "fkmigrate",
         "fknode",
-        "fkrelease",
-        "fkrem",
-        "fksetup",
-        "fkstart",
-        "fkstats",
-        "fksurrender",
-        "fkuncommit",
         "fontawesome",
         "framagit",
         "fuckingnode",

docs/about/why.md

@@ -22,42 +22,40 @@ FuckingNode exists because it fixes all of the issues mentioned above.
 
 ### Bored of manually updating dependencies, linting code, or prettifying code? Of committing all of that? Of removing built output / artifacts?
 
-- [X] `fuckingnode clean -- -- --lint --pretty --commit --destroy --update`
-    - Shorthand: `fkclean -- -- -l -p -c -d -u`.
-    - Assuming [flagless features](../manual/fknode-yaml.md#flagless) are enabled, it can be shortened to just `fkclean`.
+- [X] `fkn clean -- -- --lint --pretty --commit --destroy --update`
+    - Shorthand: `fkn clean -- -- -l -p -c -d -u`.
+    - Assuming [flagless features](../manual/fknode-yaml.md#flagless) are enabled, it can be shortened to just `fkn clean`.
 
 ### Bored of finding and pasting or writing your own `tsconfig.json`?
 
-- [X] `fuckingnode setup ts-strictest`
-    - `ts-strictest` is an example, there are more setups available. Run `fuckingnode setup` to see them all.
+- [X] `fkn setup ts-strictest`
+    - `ts-strictest` is an example, there are more setups available. Run `fkn setup` to see them all.
 
 ### Bored of manually cloning, installing, and launching?
 
-- [X] `fuckingnode kickstart <git-url> [path] [manager]`
-    - Shorthand: `fkstart <git-url> [path] [manager]`
+- [X] `fkn kickstart <git-url> [path] [manager]`
     - `<git-url>` can be not just a Git URL, but also a shorthand (e.g., `gh:Owner/Repo` for GitHub, or `gl:*` for GitLab).
     - `[path]` is optional and specifies a custom path to clone to.
     - `[manager]` is optional and overrides the package manager to use for this project.
 
 ### Bored of manually writing a deprecation notice?
 
-- [X] `fuckingnode surrender <path> [message] [alternatives] [learn-more]`
+- [X] `fkn surrender <path> [message] [alternatives] [learn-more]`
     - `<path>` is the path to the project, or `.` to use the CWD.
     - `[message]` is optional and adds a custom message.
     - `[alternatives]` is optional and lets you write about alternatives to what is going to be deprecated.
     - `[learn-more]` is optional and lets you write a text or link about where the user can learn more about this deprecation.
 
 ### Scared of the pain of making a commit forgetting your tests?
 
-- [X] `fuckingnode commit <message> <...files> [--branch=x] [--push]`
-    - Shorthand: `fkcommit <message> <...files> [--branch=x] [--push]`
+- [X] `fkn commit <message> <...files> [--branch=x] [--push]`
     - `<message>` is your commit message.
     - `--branch=*` is optional and specifies the branch to commit to. If unspecified, current active branch is used.
     - `--push` is optional and if passed the commit (and any previous local commit) will be pushed.
 
 ### Tired of the annoyance of npm or jsr package releases?
 
-- [X] `fuckingnode release <version> [--push] [--dry]`
+- [X] `fkn release <version> [--push] [--dry]`
     - `<version>` is the version to be released, we'll auto bump your package file's version field and create a Git tag with this version code. Must be SemVer parsable.
     - `--push` is optional and if passed, changes will be pushed to Git.
     - `--dry` is optional and if passed, changes will be done (and pushed if specified), but not published to npm / jsr.

docs/index.html

@@ -725,7 +725,7 @@ <h3>FAQ</h3>
           </summary>
           <p>
             You just need to add all your projects to the FuckingNode list,
-            using <code>fuckingnode add</code>. If you have a single folder with
+            using <code>fkn add</code>. If you have a single folder with
             all of your projects (like most people do), you'll enjoy the fact
             that glob patterns like /* do work.<br /><br />Once added,
             <code>clean</code> will take care of all added projects one by one.
@@ -737,7 +737,7 @@ <h3>FAQ</h3>
             that?
           </summary>
           <p>
-            <code>fuckingnode commit</code>, besides preventing the "oh i forgot
+            <code>fkn commit</code>, besides preventing the "oh i forgot
             the test suite" headache, also prevents commits that include .env or
             node_modules/ even if not in the .gitignore. You're welcome.
           </p>
@@ -747,7 +747,7 @@ <h3>FAQ</h3>
             Needing to hotfix a commit is also a headache. What about that?
           </summary>
           <p>
-            <code>fuckingnode uncommit</code> undoes the last commit and lets
+            <code>fkn uncommit</code> undoes the last commit and lets
             you modify its files, then automatically commits them
             back.<br /><br />If a commitCmd exists (like your test suite), it'll
             run it again, to stop you if the code doesn't pass tests (note: if
@@ -769,8 +769,8 @@ <h3>FAQ</h3>
         <details>
           <summary>How to "add a project"? Is it needed?</summary>
           <p>
-            Just run <code>fkadd</code> from its root (or
-            <code>fkadd [filepath]</code>) and it'll be auto-added. If it's a
+            Just run <code>fkn add</code> from its root (or
+            <code>fkn add [filepath]</code>) and it'll be auto-added. If it's a
             monorepo it'll ask what to do with its workspaces.<br /><br />It's
             not <i>needed</i>, since most features are either runtime agnostic
             or can detect the current-working-directory as a project, but it is
@@ -785,7 +785,7 @@ <h3>FAQ</h3>
           </summary>
           <p>
             Actually, yes.<br /><br />FuckingNode provides an automation (<code
-            >fuckingnode surrender</code>) to deprecate projects. It'll generate
+            >fkn surrender</code>) to deprecate projects. It'll generate
             a deprecation notice in the README for you, push that to Git, then
             remove the code (and consequently node_modules) from your local
             system so you don't waste storage to an abandoned project.
@@ -797,7 +797,7 @@ <h3>FAQ</h3>
             that...?
           </summary>
           <p>
-            Actually...<br /><br /><code>fuckingnode terminate</code> entirely
+            Actually...<br /><br /><code>fkn terminate</code> entirely
             uninstalls a language and removes package manager caches from it, as
             well as typical installation leftovers. For NodeJS, it removes all
             three package managers if installed. It works for any runtime/stack

docs/install.ps1

@@ -1,11 +1,7 @@
 $ErrorActionPreference = "Stop"
 
-$APP_NAME = @{
-    CASED = "FuckingNode"
-    CLI   = "fuckingnode"
-}
-$INSTALL_DIR = "C:\$($APP_NAME.CASED)"
-$EXE_PATH = Join-Path -Path $INSTALL_DIR -ChildPath "$($APP_NAME.CLI).exe"
+$INSTALL_DIR = "C:\FuckingNode"
+$EXE_PATH = Join-Path -Path $INSTALL_DIR -ChildPath "fkn.exe"
 
 # DETACH PROCESS
 $IsIex = -not $PSCommandPath
@@ -32,7 +28,7 @@ Function Remove-IfNeeded {
         $procId = $args[0] -as [int]
     }
     else {
-        $proc = Get-Process -Name $APP_NAME.CLI -ErrorAction SilentlyContinue | Select-Object -First 1
+        $proc = Get-Process -Name "fkn" -ErrorAction SilentlyContinue | Select-Object -First 1
         if ($proc) { $procId = $proc.Id }
     }
 
@@ -75,55 +71,6 @@ Function Get-LatestReleaseUrl {
     }
 }
 
-# creates a .bat shortcut to allow for fknode to exist alongside fuckingnode in the CLI
-Function New-Shortcuts {
-    try {
-        Write-Output "Creating shortcuts for CLI..."
-
-        # all aliases should be
-        # (appName).exe <a command> [ANY ARGS PASSED]
-        # so e.g. fkclean "b" = (appName).exe <command> "b"
-
-        $appName = $APP_NAME.CLI
-
-        if (-not (Test-Path $INSTALL_DIR -PathType Container)) {
-            Throw "Error: Install directory '$INSTALL_DIR' does not exist."
-        }
-
-        $commands = @{
-            "fknode"      = ""
-            "fkn"         = ""
-            "fkclean"     = "clean"
-            "fkstart"     = "kickstart"
-            "fklaunch"    = "launch"
-            "fkcommit"    = "commit"
-            "fkuncommit"  = "uncommit"
-            "fkbuild"     = "build"
-            "fkrelease"   = "release"
-            "fksurrender" = "surrender"
-            "fkadd"       = "add"
-            "fkrem"       = "remove"
-            "fklist"      = "list"
-            "fkaudit"     = "audit"
-            "fkstats"     = "stats"
-            "fksetup"     = "setup"
-            "fkmigrate"   = "migrate"
-        }
-
-        foreach ($name in $commands.Keys) {
-            $cmd = $commands[$name]
-            $batContent = "@echo off`n%~dp0$($appName).exe $cmd %*"
-            $batPath = Join-Path -Path $INSTALL_DIR -ChildPath "$name.bat"
-            Set-Content -Path $batPath -Value $batContent -Encoding ASCII
-            Write-Output "Shortcut created successfully at $batPath"
-        }
-    }
-    catch {
-        Write-Error "Failed to create .bat shortcuts for the CLI: $_"
-        Throw $_
-    }
-}
-
 # download the app
 Function Install-App {
     param (
@@ -140,7 +87,7 @@ Function Install-App {
         Write-Output "Downloaded successfully to $EXE_PATH"
     }
     catch {
-        Throw "Failed to download fuckingnode.exe: $_"
+        Throw "Failed to download fkn.exe: $_"
     }
 }
 
@@ -232,14 +179,10 @@ Function Add-AppToPath {
 
 Function Installer {
     try {
-        Write-Output "Hi! We'll install $($APP_NAME.CASED) for you. Just a sec!"
+        Write-Output "Hi! We'll install FuckingNode for you. Just a sec!"
         Remove-IfNeeded
         Install-App -url (Get-LatestReleaseUrl)
         Add-AppToPath
-        Write-Output "You may have seen our documentation mention shortcuts like 'fknode', 'fkn', 'fkclean'..."
-        Write-Output "These are made by creating a bunch of scripts (fknode.bat, fkn.bat...) next to the main installation."
-        Write-Output "We will create a bunch of shell scripts next to the main installation for these to work."
-        New-Shortcuts
         Write-Output "Installed successfully! Restart your terminal for it to work."
     }
     catch {

docs/install.sh

@@ -105,50 +105,6 @@ install_app() {
     echo "Downloaded successfully to $EXE_PATH"
 }
 
-# make shortcuts
-create_shortcuts() {
-
-    echo "Creating shortcuts for CLI..."
-
-    # all aliases should be
-    # (appName).exe <a command> [ANY ARGS PASSED]
-    # so e.g. fkclean "b" = (appName) <command> "b"
-
-    declare -A commands=(
-        ["fknode"]=""
-        ["fkn"]=""
-        ["fkclean"]="clean"
-        ["fkstart"]="kickstart"
-        ["fklaunch"]="launch"
-        ["fkcommit"]="commit"
-        ["fkuncommit"]="uncommit"
-        ["fkbuild"]="build"
-        ["fkrelease"]="release"
-        ["fksurrender"]="surrender"
-        ["fkadd"]="add"
-        ["fkrem"]="remove"
-        ["fklist"]="list"
-        ["fkaudit"]="audit"
-        ["fkstats"]="stats"
-        ["fksetup"]="setup"
-        ["fkmigrate"]="migrate"
-    )
-
-    for name in "${!commands[@]}"; do
-        cmd=${commands[$name]}
-        script_path="$BIN_DIR/$name"
-
-        sudo tee "$script_path" >/dev/null <<EOF
-#!/usr/bin/env bash
-$EXE_NAME $cmd "\$@"
-EOF
-
-        sudo chmod +x "$script_path"
-
-        echo "Shortcut created successfully at $script_path"
-    done
-}
-
 # installer itself
 installer() {
     echo "Hi! We'll install FuckingNode ($ARCH edition) for you. Just a sec!"
@@ -163,10 +119,6 @@ installer() {
     migrate_old_install
     remove_if_needed
     install_app
-    echo "You may have seen our documentation mention shortcuts like 'fknode', 'fkn', 'fkclean'..."
-    echo "We will create a bunch of shell scripts next to the main installation for these to work."
-    echo ""
-    create_shortcuts
     echo ""
     echo "Installed successfully!"
 }

docs/learn/audit.md

@@ -12,7 +12,7 @@ However, as a mobile app that never interacted with cookies and very rarely used
 
 ### TL;DR
 
-`fuckingnode audit` analyzes vulnerabilities and helps you tell if they really affect your project or if they can be left alone without too much risk.
+`fkn audit` analyzes vulnerabilities and helps you tell if they really affect your project or if they can be left alone without too much risk.
 
 ## How it works
 
@@ -29,7 +29,7 @@ Due to where nowadays society is heading, it _is_ worth noting questions are not
 
 ```mermaid
 graph TD
-    A[fkaudit] -->|Command execution| B[Runs platform-specific audit command]
+    A[fkn audit] -->|Command execution| B[Runs platform-specific audit command]
     B -->|Parse JSON output| C[Stores text in a SV_KEYWORDS object]
     B -->|Parse JSON output| G[Stores severities separately]
     C -->|Analyzed| D[Questions asked to the user]

docs/learn/clean.md

@@ -42,11 +42,11 @@ This workflow can be simplified into the following:
 
 ```mermaid
 graph TD
-    A["fkadd ../project1"]
-    B["fkadd ../project2"]
-    C["fkadd /home/Zaka/Code/some-app"]
+    A["fkn add ../project1"]
+    B["fkn add ../project2"]
+    C["fkn add /home/Zaka/Code/some-app"]
 
-    D["fkclean -- -- -u -l -d -p -"]
+    D["fkn clean -- -- -u -l -d -p -"]
 
     A --> D
     B --> D
@@ -59,13 +59,13 @@ We reduce your workflow to a one-time bunch of commands for initial setup, and t
 
 ### TL;DR
 
-`fuckingnode clean` gets into each project's root directory and executes all the maintenance commands you need, automatically.
+`fkn clean` gets into each project's root directory and executes all the maintenance commands you need, automatically.
 
 ## How it works
 
 ### Finding your projects
 
-You need to manually add a project, via the `fuckingnode add` command. When you add a project, it's stored in either:
+You need to manually add a project, via the `fkn add` command. When you add a project, it's stored in either:
 
 - `C:\Users\YOUR_USER\AppData\Roaming\FuckingNode\` on :fontawesome-brands-windows: Windows
 - `/home/.config/FuckingNode/` on :simple-apple: macOS and :simple-linux: Linux
@@ -80,15 +80,15 @@ C:\Users\Zaka\projects\Vuelto
 C:\Users\Zaka\projects\FuckingNode
 ```
 
-Whenever you run the `fuckingnode clean` command, first thing we do is reading this file.
+Whenever you run the `fkn clean` command, first thing we do is reading this file.
 
 ### Cleaning a project
 
 Cleaning a project involves the following steps:
 
 ```mermaid
 graph TD
-    CLI["fuckingnode clean [...flags]"]
+    CLI["fkn clean [...flags]"]
 
     CLI -->|chdir into| A["C:\Users\Zaka\projects\Sokora"]
 
@@ -107,11 +107,11 @@ graph TD
     I -->|Validates| B
 ```
 
-Inside the terminal you're running `fuckingnode` from, we'll change directories to each added project's path. From the inside, we proceed as follows:
+Inside the terminal you're running `fkn` from, we'll change directories to each added project's path. From the inside, we proceed as follows:
 
 First, we basically do some basic validations before touching each project (is the lockfile present? are node modules installed? etc...), so we know what to do and we're sure all commands will work out of the box. Some validations, like the absence of `node_modules`, will result in that project being skipped into the next one. Other validations, like a `deno.lock` lockfile, will change our behavior (in this example, we'd skip some features as Deno doesn't support all cleaning features, [as noted here](./cross-runtime-support.md)).
 
-Then, we seek a `fknode.yaml` config file - if present, we parse it and validate it. If not present, or invalid, **we run each CLI command from the open terminal**. When using `fuckingnode clean` you'll notice we don't add a loader whatsoever, but instead show you the raw output of each command as if you executed it yourself. That's because we did the same, each command is ran from the terminal you're on.
+Then, we seek a `fknode.yaml` config file - if present, we parse it and validate it. If not present, or invalid, **we run each CLI command from the open terminal**. When using `fkn clean` you'll notice we don't add a loader whatsoever, but instead show you the raw output of each command as if you executed it yourself. That's because we did the same, each command is ran from the terminal you're on.
 
 If settings _are_ present, we take them into account before doing anything, so if you added a `divineProtection` value we skip certain actions.
 

docs/learn/cross-runtime-support.md

@@ -1,6 +1,6 @@
 # Cross-runtime compatibility
 
-> `fuckingnode compat [item]`
+> `fkn compat [item]`
 
 !!! note "What we mean by _Cross-runtime_" While we always use the term
 "cross-runtime", we also include _cross-platform_ (Golang and Rust) support

docs/learn/errors.md

@@ -158,9 +158,9 @@ All errors in this category are `Task__[TASK TYPE]`, which can be `Release`, `Co
 
 ## Parameter [Param]
 
-All errors in this category are `Param__[PARAM TYPE]Invalid`, which can be `Target`, `CIntensity`, `Setup`, `Ver`, `GitTarget`, `GitTargetAlias`, or `Whatever` for anything else. When running a command that requires parameters (`fkstart <GIT TARGET>`, `fksetup <SETUP>`, and so on...), any missing or invalid parameter will trigger a Task category error.
+All errors in this category are `Param__[PARAM TYPE]Invalid`, which can be `Target`, `CIntensity`, `Setup`, `Ver`, `GitTarget`, `GitTargetAlias`, or `Whatever` for anything else. When running a command that requires parameters (`fkn kickstart <GIT TARGET>`, `fkn setup <SETUP>`, and so on...), any missing or invalid parameter will trigger a Task category error.
 
-If unclear, `Ver` refers to "version" (for the `fkrelease` command), `CIntensity` refers to "cleaner intensity", and both `GitTarget` and `GitTargetAlias` refer to the kickstart parameter, respectively referring to Git URLs and Git aliases.
+If unclear, `Ver` refers to "version" (for the `fkn release` command), `CIntensity` refers to "cleaner intensity", and both `GitTarget` and `GitTargetAlias` refer to the kickstart parameter, respectively referring to Git URLs and Git aliases.
 
 ## Interop [Interop]