nvim

users/daniel/configs/system/default.nix

@@ -3,6 +3,6 @@
     ./alacritty
     ./helix
     ./kitty
-    ./neovim
+    ./nvim
   ];
 }

users/daniel/configs/system/nvim/default.nix

@@ -0,0 +1,11 @@
+{...}:
+
+{
+  programs.neovim.enable = true;
+
+  home.file = {
+    ".config/nvim" = {
+      source = ./nvim;
+    };
+  };
+}

users/daniel/configs/system/nvim/nvim/.gitignore

@@ -0,0 +1,9 @@
+!colors/astronvim.lua
+colors/*
+docs
+ginit.vim
+lua/user
+plugin
+ftplugin
+spell
+.luarc.json

users/daniel/configs/system/nvim/nvim/.luacheckrc

@@ -0,0 +1,21 @@
+-- Global objects
+globals = {
+  "PACKER_BOOTSTRAP",
+  "astronvim",
+  "astronvim_installation",
+  "vim",
+  "bit",
+  "C",
+  "packer_plugins",
+}
+
+-- Rerun tests only if their modification time changed
+cache = true
+
+-- Don't report unused self arguments of methods
+self = false
+
+ignore = {
+  "631", -- max_line_length
+  "212/_.*", -- unused argument, for vars with "_" prefix
+}

users/daniel/configs/system/nvim/nvim/.stylua.toml

@@ -0,0 +1,7 @@
+column_width = 120
+line_endings = "Unix"
+indent_type = "Spaces"
+indent_width = 2
+quote_style = "AutoPreferDouble"
+call_parentheses = "None"
+collapse_simple_statement = "Always"

users/daniel/configs/system/nvim/nvim/.styluaignore

@@ -0,0 +1 @@
+lua/lazy_snapshot.lua

users/daniel/configs/system/nvim/nvim/LICENSE

@@ -0,0 +1,674 @@
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.  We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors.  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights.  Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received.  You must make sure that they, too, receive
+or can get the source code.  And you must show them these terms so they
+know their rights.
+
+  Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+
+  For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software.  For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+
+  Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so.  This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software.  The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable.  Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products.  If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.
+
+  Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary.  To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Use with the GNU Affero General Public License.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If the program does terminal interaction, make it output a short
+notice like this when it starts in an interactive mode:
+
+    <program>  Copyright (C) <year>  <name of author>
+    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, your program's commands
+might be different; for a GUI interface, you would use an "about box".
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU GPL, see
+<https://www.gnu.org/licenses/>.
+
+  The GNU General Public License does not permit incorporating your program
+into proprietary programs.  If your program is a subroutine library, you
+may consider it more useful to permit linking proprietary applications with
+the library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.  But first, please read
+<https://www.gnu.org/licenses/why-not-lgpl.html>.

users/daniel/configs/system/nvim/nvim/config.ld

@@ -0,0 +1,7 @@
+project='AstroNvim'
+title='AstroNvim API'
+description='Documentation of AstroNvim\'s core API'
+format = 'markdown'
+file='lua'
+dir='docs'
+no_space_before_args=true

users/daniel/configs/system/nvim/nvim/init.lua

@@ -0,0 +1,18 @@
+for _, source in ipairs {
+  "astronvim.bootstrap",
+  "astronvim.options",
+  "astronvim.lazy",
+  "astronvim.autocmds",
+  "astronvim.mappings",
+} do
+  local status_ok, fault = pcall(require, source)
+  if not status_ok then vim.api.nvim_err_writeln("Failed to load " .. source .. "\n\n" .. fault) end
+end
+
+if astronvim.default_colorscheme then
+  if not pcall(vim.cmd.colorscheme, astronvim.default_colorscheme) then
+    require("astronvim.utils").notify("Error setting up colorscheme: " .. astronvim.default_colorscheme, "error")
+  end
+end
+
+require("astronvim.utils").conditional_func(astronvim.user_opts("polish", nil, false), true)

users/daniel/configs/system/nvim/nvim/lua/astronvim/autocmds.lua

@@ -0,0 +1,235 @@
+local augroup = vim.api.nvim_create_augroup
+local autocmd = vim.api.nvim_create_autocmd
+local cmd = vim.api.nvim_create_user_command
+local namespace = vim.api.nvim_create_namespace
+
+local utils = require "astronvim.utils"
+local is_available = utils.is_available
+local astroevent = utils.event
+
+vim.on_key(function(char)
+  if vim.fn.mode() == "n" then
+    local new_hlsearch = vim.tbl_contains({ "<CR>", "n", "N", "*", "#", "?", "/" }, vim.fn.keytrans(char))
+    if vim.opt.hlsearch:get() ~= new_hlsearch then vim.opt.hlsearch = new_hlsearch end
+  end
+end, namespace "auto_hlsearch")
+
+local bufferline_group = augroup("bufferline", { clear = true })
+autocmd({ "BufAdd", "BufEnter" }, {
+  desc = "Update buffers when adding new buffers",
+  group = bufferline_group,
+  callback = function(args)
+    if not vim.t.bufs then vim.t.bufs = {} end
+    local bufs = vim.t.bufs
+    if not vim.tbl_contains(bufs, args.buf) then
+      table.insert(bufs, args.buf)
+      vim.t.bufs = bufs
+    end
+    vim.t.bufs = vim.tbl_filter(require("astronvim.utils.buffer").is_valid, vim.t.bufs)
+    astroevent "BufsUpdated"
+  end,
+})
+autocmd("BufDelete", {
+  desc = "Update buffers when deleting buffers",
+  group = bufferline_group,
+  callback = function(args)
+    for _, tab in ipairs(vim.api.nvim_list_tabpages()) do
+      local bufs = vim.t[tab].bufs
+      if bufs then
+        for i, bufnr in ipairs(bufs) do
+          if bufnr == args.buf then
+            table.remove(bufs, i)
+            vim.t[tab].bufs = bufs
+            break
+          end
+        end
+      end
+    end
+    vim.t.bufs = vim.tbl_filter(require("astronvim.utils.buffer").is_valid, vim.t.bufs)
+    astroevent "BufsUpdated"
+    vim.cmd.redrawtabline()
+  end,
+})
+
+autocmd({ "VimEnter", "FileType", "BufEnter", "WinEnter" }, {
+  desc = "URL Highlighting",
+  group = augroup("highlighturl", { clear = true }),
+  pattern = "*",
+  callback = function() utils.set_url_match() end,
+})
+
+local view_group = augroup("auto_view", { clear = true })
+autocmd("BufWinLeave", {
+  desc = "Save view with mkview for real files",
+  group = view_group,
+  callback = function(event)
+    if vim.b[event.buf].view_activated then vim.cmd.mkview { mods = { emsg_silent = true } } end
+  end,
+})
+autocmd("BufWinEnter", {
+  desc = "Try to load file view if available and enable view saving for real files",
+  group = view_group,
+  callback = function(event)
+    if not vim.b[event.buf].view_activated then
+      local filetype = vim.api.nvim_get_option_value("filetype", { buf = event.buf })
+      local buftype = vim.api.nvim_get_option_value("buftype", { buf = event.buf })
+      local ignore_filetypes = { "gitcommit", "gitrebase", "svg", "hgcommit" }
+      if buftype == "" and filetype and filetype ~= "" and not vim.tbl_contains(ignore_filetypes, filetype) then
+        vim.b[event.buf].view_activated = true
+        vim.cmd.loadview { mods = { emsg_silent = true } }
+      end
+    end
+  end,
+})
+
+autocmd("FileType", {
+  desc = "Make q close help, man, quickfix, dap floats",
+  group = augroup("q_close_windows", { clear = true }),
+  pattern = { "qf", "help", "man", "dap-float" },
+  callback = function(event)
+    vim.keymap.set("n", "q", "<cmd>close<cr>", { buffer = event.buf, silent = true, nowait = true })
+  end,
+})
+
+autocmd("TextYankPost", {
+  desc = "Highlight yanked text",
+  group = augroup("highlightyank", { clear = true }),
+  pattern = "*",
+  callback = function() vim.highlight.on_yank() end,
+})
+
+autocmd("FileType", {
+  desc = "Unlist quickfist buffers",
+  group = augroup("unlist_quickfist", { clear = true }),
+  pattern = "qf",
+  callback = function() vim.opt_local.buflisted = false end,
+})
+
+autocmd("BufEnter", {
+  desc = "Quit AstroNvim if more than one window is open and only sidebar windows are list",
+  group = augroup("auto_quit", { clear = true }),
+  callback = function()
+    local wins = vim.api.nvim_tabpage_list_wins(0)
+    -- Both neo-tree and aerial will auto-quit if there is only a single window left
+    if #wins <= 1 then return end
+    local sidebar_fts = { aerial = true, ["neo-tree"] = true }
+    for _, winid in ipairs(wins) do
+      if vim.api.nvim_win_is_valid(winid) then
+        local bufnr = vim.api.nvim_win_get_buf(winid)
+        local filetype = vim.api.nvim_get_option_value("filetype", { buf = bufnr })
+        -- If any visible windows are not sidebars, early return
+        if not sidebar_fts[filetype] then
+          return
+        -- If the visible window is a sidebar
+        else
+          -- only count filetypes once, so remove a found sidebar from the detection
+          sidebar_fts[filetype] = nil
+        end
+      end
+    end
+    if #vim.api.nvim_list_tabpages() > 1 then
+      vim.cmd.tabclose()
+    else
+      vim.cmd.qall()
+    end
+  end,
+})
+
+if is_available "alpha-nvim" then
+  local group_name = augroup("alpha_settings", { clear = true })
+  autocmd("User", {
+    desc = "Disable status and tablines for alpha",
+    group = group_name,
+    pattern = "AlphaReady",
+    callback = function()
+      local prev_showtabline = vim.opt.showtabline
+      local prev_status = vim.opt.laststatus
+      vim.opt.laststatus = 0
+      vim.opt.showtabline = 0
+      vim.opt_local.winbar = nil
+      autocmd("BufUnload", {
+        pattern = "<buffer>",
+        callback = function()
+          vim.opt.laststatus = prev_status
+          vim.opt.showtabline = prev_showtabline
+        end,
+      })
+    end,
+  })
+  autocmd("VimEnter", {
+    desc = "Start Alpha when vim is opened with no arguments",
+    group = group_name,
+    callback = function()
+      local should_skip = false
+      if vim.fn.argc() > 0 or vim.fn.line2byte "$" ~= -1 or not vim.o.modifiable then
+        should_skip = true
+      else
+        for _, arg in pairs(vim.v.argv) do
+          if arg == "-b" or arg == "-c" or vim.startswith(arg, "+") or arg == "-S" then
+            should_skip = true
+            break
+          end
+        end
+      end
+      if not should_skip then require("alpha").start(true, require("alpha").default_config) end
+    end,
+  })
+end
+
+if is_available "neo-tree.nvim" then
+  autocmd("BufEnter", {
+    desc = "Open Neo-Tree on startup with directory",
+    group = augroup("neotree_start", { clear = true }),
+    callback = function()
+      if package.loaded["neo-tree"] then
+        vim.api.nvim_del_augroup_by_name "neotree_start"
+      else
+        local stats = vim.loop.fs_stat(vim.api.nvim_buf_get_name(0))
+        if stats and stats.type == "directory" then
+          require "neo-tree"
+          vim.api.nvim_del_augroup_by_name "neotree_start"
+          vim.api.nvim_exec_autocmds("BufEnter", {})
+        end
+      end
+    end,
+  })
+end
+
+autocmd({ "VimEnter", "ColorScheme" }, {
+  desc = "Load custom highlights from user configuration",
+  group = augroup("astronvim_highlights", { clear = true }),
+  callback = function()
+    if vim.g.colors_name then
+      for _, module in ipairs { "init", vim.g.colors_name } do
+        for group, spec in pairs(astronvim.user_opts("highlights." .. module)) do
+          vim.api.nvim_set_hl(0, group, spec)
+        end
+      end
+    end
+    astroevent "ColorScheme"
+  end,
+})
+
+autocmd({ "BufReadPost", "BufNewFile" }, {
+  group = augroup("file_user_events", { clear = true }),
+  callback = function(args)
+    if not (vim.fn.expand "%" == "" or vim.api.nvim_get_option_value("buftype", { buf = args.buf }) == "nofile") then
+      utils.event "File"
+      if utils.cmd('git -C "' .. vim.fn.expand "%:p:h" .. '" rev-parse', false) then utils.event "GitFile" end
+    end
+  end,
+})
+
+cmd(
+  "AstroChangelog",
+  function() require("astronvim.utils.updater").changelog() end,
+  { desc = "Check AstroNvim Changelog" }
+)
+cmd(
+  "AstroUpdatePackages",
+  function() require("astronvim.utils.updater").update_packages() end,
+  { desc = "Update Plugins and Mason" }
+)
+cmd("AstroRollback", function() require("astronvim.utils.updater").rollback() end, { desc = "Rollback AstroNvim" })
+cmd("AstroUpdate", function() require("astronvim.utils.updater").update() end, { desc = "Update AstroNvim" })
+cmd("AstroVersion", function() require("astronvim.utils.updater").version() end, { desc = "Check AstroNvim Version" })

users/daniel/configs/system/nvim/nvim/lua/astronvim/bootstrap.lua

@@ -0,0 +1,131 @@
+--- ### AstroNvim Core Bootstrap
+--
+-- This module simply sets up the global `astronvim` module.
+-- This is automatically loaded and should not be resourced, everything is accessible through the global `astronvim` variable.
+--
+-- @module astronvim.bootstrap
+-- @copyright 2022
+-- @license GNU General Public License v3.0
+
+_G.astronvim = {}
+
+--- installation details from external installers
+astronvim.install = _G["astronvim_installation"] or { home = vim.fn.stdpath "config" }
+astronvim.supported_configs = { astronvim.install.home }
+--- external astronvim configuration folder
+astronvim.install.config = vim.fn.stdpath("config"):gsub("nvim$", "astronvim")
+-- check if they are the same, protects against NVIM_APPNAME use for isolated install
+if astronvim.install.home ~= astronvim.install.config then
+  vim.opt.rtp:append(astronvim.install.config)
+  --- supported astronvim user conifg folders
+  table.insert(astronvim.supported_configs, astronvim.install.config)
+end
+
+--- Looks to see if a module path references a lua file in a configuration folder and tries to load it. If there is an error loading the file, write an error and continue
+-- @param module the module path to try and load
+-- @return the loaded module if successful or nil
+local function load_module_file(module)
+  -- placeholder for final return value
+  local found_module = nil
+  -- search through each of the supported configuration locations
+  for _, config_path in ipairs(astronvim.supported_configs) do
+    -- convert the module path to a file path (example user.init -> user/init.lua)
+    local module_path = config_path .. "/lua/" .. module:gsub("%.", "/") .. ".lua"
+    -- check if there is a readable file, if so, set it as found
+    if vim.fn.filereadable(module_path) == 1 then found_module = module_path end
+  end
+  -- if we found a readable lua file, try to load it
+  if found_module then
+    -- try to load the file
+    local status_ok, loaded_module = pcall(require, module)
+    -- if successful at loading, set the return variable
+    if status_ok then
+      found_module = loaded_module
+    -- if unsuccessful, throw an error
+    else
+      vim.api.nvim_err_writeln("Error loading file: " .. found_module .. "\n\n" .. loaded_module)
+    end
+  end
+  -- return the loaded module or nil if no file found
+  return found_module
+end
+
+--- Main configuration engine logic for extending a default configuration table with either a function override or a table to merge into the default option
+-- @param overrides the override definition, either a table or a function that takes a single parameter of the original table
+-- @param default the default configuration table
+-- @param extend boolean value to either extend the default or simply overwrite it if an override is provided
+-- @return the new configuration table
+local function func_or_extend(overrides, default, extend)
+  -- if we want to extend the default with the provided override
+  if extend then
+    -- if the override is a table, use vim.tbl_deep_extend
+    if type(overrides) == "table" then
+      local opts = overrides or {}
+      default = default and vim.tbl_deep_extend("force", default, opts) or opts
+    -- if the override is  a function, call it with the default and overwrite default with the return value
+    elseif type(overrides) == "function" then
+      default = overrides(default)
+    end
+  -- if extend is set to false and we have a provided override, simply override the default
+  elseif overrides ~= nil then
+    default = overrides
+  end
+  -- return the modified default table
+  return default
+end
+
+--- user settings from the base `user/init.lua` file
+local user_settings = load_module_file "user.init"
+
+--- Search the user settings (user/init.lua table) for a table with a module like path string
+-- @param module the module path like string to look up in the user settings table
+-- @return the value of the table entry if exists or nil
+local function user_setting_table(module)
+  -- get the user settings table
+  local settings = user_settings or {}
+  -- iterate over the path string split by '.' to look up the table value
+  for tbl in string.gmatch(module, "([^%.]+)") do
+    settings = settings[tbl]
+    -- if key doesn't exist, keep the nil value and stop searching
+    if settings == nil then break end
+  end
+  -- return the found settings
+  return settings
+end
+
+--- User configuration entry point to override the default options of a configuration table with a user configuration file or table in the user/init.lua user settings
+-- @param module the module path of the override setting
+-- @param default the default settings that will be overridden
+-- @param extend boolean value to either extend the default settings or overwrite them with the user settings entirely (default: true)
+-- @return the new configuration settings with the user overrides applied
+function astronvim.user_opts(module, default, extend)
+  -- default to extend = true
+  if extend == nil then extend = true end
+  -- if no default table is provided set it to an empty table
+  if default == nil then default = {} end
+  -- try to load a module file if it exists
+  local user_module_settings = load_module_file("user." .. module)
+  -- if no user module file is found, try to load an override from the user settings table from user/init.lua
+  if user_module_settings == nil then user_module_settings = user_setting_table(module) end
+  -- if a user override was found call the configuration engine
+  if user_module_settings ~= nil then default = func_or_extend(user_module_settings, default, extend) end
+  -- return the final configuration table with any overrides applied
+  return default
+end
+
+--- Updater settings overridden with any user provided configuration
+astronvim.updater = {
+  options = astronvim.user_opts("updater", { remote = "origin", channel = "stable" }),
+  snapshot = { module = "lazy_snapshot", path = vim.fn.stdpath "config" .. "/lua/lazy_snapshot.lua" },
+  rollback_file = vim.fn.stdpath "cache" .. "/astronvim_rollback.lua",
+}
+local options = astronvim.updater.options
+if astronvim.install.is_stable ~= nil then options.channel = astronvim.install.is_stable and "stable" or "nightly" end
+if options.pin_plugins == nil then options.pin_plugins = options.channel == "stable" end
+
+--- table of user created terminals
+astronvim.user_terminals = {}
+--- table of language servers to ignore the setup of, configured through lsp.skip_setup in the user configuration
+astronvim.lsp = { skip_setup = astronvim.user_opts("lsp.skip_setup", {}) }
+--- the default colorscheme to apply on startup
+astronvim.default_colorscheme = astronvim.user_opts("colorscheme", "astrotheme", false)

users/daniel/configs/system/nvim/nvim/lua/astronvim/health.lua

@@ -0,0 +1,51 @@
+local M = {}
+
+function M.check()
+  vim.health.report_start "AstroNvim"
+
+  vim.health.report_info("AstroNvim Version: " .. require("astronvim.utils.updater").version(true))
+  vim.health.report_info("Neovim Version: v" .. vim.fn.matchstr(vim.fn.execute "version", "NVIM v\\zs[^\n]*"))
+
+  if vim.version().prerelease then
+    vim.health.report_warn "Neovim nightly is not officially supported and may have breaking changes"
+  elseif vim.fn.has "nvim-0.8" == 1 then
+    vim.health.report_ok "Using stable Neovim >= 0.8.0"
+  else
+    vim.health.report_error "Neovim >= 0.8.0 is required"
+  end
+
+  local programs = {
+    { cmd = "git", type = "error", msg = "Used for core functionality such as updater and plugin management" },
+    {
+      cmd = { "xdg-open", "open", "explorer" },
+      type = "warn",
+      msg = "Used for `gx` mapping for opening files with system opener (Optional)",
+    },
+    { cmd = "lazygit", type = "warn", msg = "Used for mappings to pull up git TUI (Optional)" },
+    { cmd = "node", type = "warn", msg = "Used for mappings to pull up node REPL (Optional)" },
+    { cmd = "gdu", type = "warn", msg = "Used for mappings to pull up disk usage analyzer (Optional)" },
+    { cmd = "btm", type = "warn", msg = "Used for mappings to pull up system monitor (Optional)" },
+    { cmd = { "python", "python3" }, type = "warn", msg = "Used for mappings to pull up python REPL (Optional)" },
+  }
+
+  for _, program in ipairs(programs) do
+    if type(program.cmd) == "string" then program.cmd = { program.cmd } end
+    local name = table.concat(program.cmd, "/")
+    local found = false
+    for _, cmd in ipairs(program.cmd) do
+      if vim.fn.executable(cmd) == 1 then
+        name = cmd
+        found = true
+        break
+      end
+    end
+
+    if found then
+      vim.health.report_ok(("`%s` is installed: %s"):format(name, program.msg))
+    else
+      vim.health["report_" .. program.type](("`%s` is not installed: %s"):format(name, program.msg))
+    end
+  end
+end
+
+return M

users/daniel/configs/system/nvim/nvim/lua/astronvim/icons/nerd_font.lua

@@ -0,0 +1,48 @@
+return {
+  ActiveLSP = "",
+  ActiveTS = "",
+  ArrowLeft = "",
+  ArrowRight = "",
+  BufferClose = "",
+  DapBreakpoint = "",
+  DapBreakpointCondition = "",
+  DapBreakpointRejected = "",
+  DapLogPoint = ".>",
+  DapStopped = "",
+  DefaultFile = "",
+  Diagnostic = "裂",
+  DiagnosticError = "",
+  DiagnosticHint = "",
+  DiagnosticInfo = "",
+  DiagnosticWarn = "",
+  Ellipsis = "…",
+  FileModified = "",
+  FileReadOnly = "",
+  FoldClosed = "",
+  FoldOpened = "",
+  FoldSeparator = " ",
+  FolderClosed = "",
+  FolderEmpty = "",
+  FolderOpen = "",
+  Git = "",
+  GitAdd = "",
+  GitBranch = "",
+  GitChange = "",
+  GitConflict = "",
+  GitDelete = "",
+  GitIgnored = "◌",
+  GitRenamed = "➜",
+  GitStaged = "✓",
+  GitUnstaged = "✗",
+  GitUntracked = "★",
+  LSPLoaded = "",
+  LSPLoading1 = "",
+  LSPLoading2 = "",
+  LSPLoading3 = "",
+  MacroRecording = "",
+  Paste = "",
+  Search = "",
+  Selected = "❯",
+  Spellcheck = "暈",
+  TabClose = "",
+}

users/daniel/configs/system/nvim/nvim/lua/astronvim/icons/text.lua

@@ -0,0 +1,40 @@
+return {
+  ActiveLSP = "LSP:",
+  ArrowLeft = "<",
+  ArrowRight = ">",
+  BufferClose = "x",
+  DapBreakpoint = "B",
+  DapBreakpointCondition = "C",
+  DapBreakpointRejected = "R",
+  DapLogPoint = "L",
+  DapStopped = ">",
+  DefaultFile = "[F]",
+  DiagnosticError = "X",
+  DiagnosticHint = "?",
+  DiagnosticInfo = "i",
+  DiagnosticWarn = "!",
+  Ellipsis = "...",
+  FileModified = "*",
+  FileReadOnly = "[lock]",
+  FoldClosed = "+",
+  FoldOpened = "-",
+  FoldSeparator = " ",
+  FolderClosed = "[D]",
+  FolderEmpty = "[E]",
+  FolderOpen = "[O]",
+  GitAdd = "[+]",
+  GitChange = "[/]",
+  GitConflict = "[!]",
+  GitDelete = "[-]",
+  GitIgnored = "[I]",
+  GitRenamed = "[R]",
+  GitStaged = "[S]",
+  GitUnstaged = "[U]",
+  GitUntracked = "[?]",
+  MacroRecording = "Recording:",
+  Paste = "[PASTE]",
+  Search = "?",
+  Selected = "*",
+  Spellcheck = "[SPELL]",
+  TabClose = "X",
+}

users/daniel/configs/system/nvim/nvim/lua/astronvim/lazy.lua

@@ -0,0 +1,41 @@
+local lazypath = vim.fn.stdpath "data" .. "/lazy/lazy.nvim"
+if not vim.loop.fs_stat(lazypath) then
+  vim.fn.system { "git", "clone", "https://github.com/folke/lazy.nvim.git", "--branch=stable", lazypath }
+  local oldcmdheight = vim.opt.cmdheight:get()
+  vim.opt.cmdheight = 1
+  vim.notify "Please wait while plugins are installed..."
+  vim.api.nvim_create_autocmd("User", {
+    once = true,
+    pattern = "LazyInstall",
+    callback = function()
+      vim.cmd.bw()
+      vim.opt.cmdheight = oldcmdheight
+      vim.tbl_map(function(module) pcall(require, module) end, { "nvim-treesitter", "mason" })
+      require("astronvim.utils").notify "Mason is installing packages if configured, check status with :Mason"
+    end,
+  })
+end
+vim.opt.rtp:prepend(lazypath)
+
+local user_plugins = astronvim.user_opts "plugins"
+for _, config_dir in ipairs(astronvim.supported_configs) do
+  if vim.fn.isdirectory(config_dir .. "/lua/user/plugins") == 1 then user_plugins = { import = "user.plugins" } end
+end
+
+local spec = astronvim.updater.options.pin_plugins and { { import = astronvim.updater.snapshot.module } } or {}
+vim.list_extend(spec, { { import = "plugins" }, user_plugins })
+
+local colorscheme = astronvim.default_colorscheme and { astronvim.default_colorscheme } or nil
+
+require("lazy").setup(astronvim.user_opts("lazy", {
+  spec = spec,
+  defaults = { lazy = true },
+  install = { colorscheme = colorscheme },
+  performance = {
+    rtp = {
+      paths = astronvim.supported_configs,
+      disabled_plugins = { "tohtml", "gzip", "matchit", "zipPlugin", "netrwPlugin", "tarPlugin" },
+    },
+  },
+  lockfile = vim.fn.stdpath "data" .. "/lazy-lock.json",
+}))

users/daniel/configs/system/nvim/nvim/lua/astronvim/mappings.lua

@@ -0,0 +1,379 @@
+local utils = require "astronvim.utils"
+local is_available = utils.is_available
+local ui = require "astronvim.utils.ui"
+
+local maps = { i = {}, n = {}, v = {}, t = {} }
+
+local sections = {
+  f = { name = "󰍉 Find" },
+  p = { name = "󰏖 Packages" },
+  l = { name = " LSP" },
+  u = { name = " UI" },
+  b = { name = "󰓩 Buffers" },
+  d = { name = " Debugger" },
+  g = { name = " Git" },
+  S = { name = "󱂬 Session" },
+  t = { name = " Terminal" },
+}
+if not vim.g.icons_enabled then vim.tbl_map(function(opts) opts.name = opts.name:gsub("^.* ", "") end, sections) end
+
+-- Normal --
+-- Standard Operations
+maps.n["j"] = { "v:count ? 'j' : 'gj'", expr = true, desc = "Move cursor down" }
+maps.n["k"] = { "v:count ? 'k' : 'gk'", expr = true, desc = "Move cursor up" }
+maps.v["j"] = maps.n.j
+maps.v["k"] = maps.n.k
+maps.n["<leader>w"] = { "<cmd>w<cr>", desc = "Save" }
+maps.n["<leader>q"] = { "<cmd>confirm q<cr>", desc = "Quit" }
+maps.n["<leader>n"] = { "<cmd>enew<cr>", desc = "New File" }
+maps.n["gx"] = { utils.system_open, desc = "Open the file under cursor with system app" }
+maps.n["<C-s>"] = { "<cmd>w!<cr>", desc = "Force write" }
+maps.n["<C-q>"] = { "<cmd>q!<cr>", desc = "Force quit" }
+maps.n["|"] = { "<cmd>vsplit<cr>", desc = "Vertical Split" }
+maps.n["\\"] = { "<cmd>split<cr>", desc = "Horizontal Split" }
+
+-- Plugin Manager
+maps.n["<leader>p"] = sections.p
+maps.n["<leader>pi"] = { function() require("lazy").install() end, desc = "Plugins Install" }
+maps.n["<leader>ps"] = { function() require("lazy").home() end, desc = "Plugins Status" }
+maps.n["<leader>pS"] = { function() require("lazy").sync() end, desc = "Plugins Sync" }
+maps.n["<leader>pu"] = { function() require("lazy").check() end, desc = "Plugins Check Updates" }
+maps.n["<leader>pU"] = { function() require("lazy").update() end, desc = "Plugins Update" }
+
+-- AstroNvim
+maps.n["<leader>pa"] = { "<cmd>AstroUpdatePackages<cr>", desc = "Update Plugins and Mason" }
+maps.n["<leader>pA"] = { "<cmd>AstroUpdate<cr>", desc = "AstroNvim Update" }
+maps.n["<leader>pv"] = { "<cmd>AstroVersion<cr>", desc = "AstroNvim Version" }
+maps.n["<leader>pl"] = { "<cmd>AstroChangelog<cr>", desc = "AstroNvim Changelog" }
+
+-- Manage Buffers
+maps.n["<leader>c"] = { function() require("astronvim.utils.buffer").close() end, desc = "Close buffer" }
+maps.n["<leader>C"] = { function() require("astronvim.utils.buffer").close(0, true) end, desc = "Force close buffer" }
+maps.n["]b"] =
+  { function() require("astronvim.utils.buffer").nav(vim.v.count > 0 and vim.v.count or 1) end, desc = "Next buffer" }
+maps.n["[b"] = {
+  function() require("astronvim.utils.buffer").nav(-(vim.v.count > 0 and vim.v.count or 1)) end,
+  desc = "Previous buffer",
+}
+maps.n[">b"] = {
+  function() require("astronvim.utils.buffer").move(vim.v.count > 0 and vim.v.count or 1) end,
+  desc = "Move buffer tab right",
+}
+maps.n["<b"] = {
+  function() require("astronvim.utils.buffer").move(-(vim.v.count > 0 and vim.v.count or 1)) end,
+  desc = "Move buffer tab left",
+}
+
+maps.n["<leader>b"] = sections.b
+maps.n["<leader>bc"] =
+  { function() require("astronvim.utils.buffer").close_all(true) end, desc = "Close all buffers except current" }
+maps.n["<leader>bC"] = { function() require("astronvim.utils.buffer").close_all() end, desc = "Close all buffers" }
+maps.n["<leader>bb"] = {
+  function()
+    require("astronvim.utils.status").heirline.buffer_picker(function(bufnr) vim.api.nvim_win_set_buf(0, bufnr) end)
+  end,
+  desc = "Select buffer from tabline",
+}
+maps.n["<leader>bd"] = {
+  function()
+    require("astronvim.utils.status").heirline.buffer_picker(
+      function(bufnr) require("astronvim.utils.buffer").close(bufnr) end
+    )
+  end,
+  desc = "Delete buffer from tabline",
+}
+maps.n["<leader>b\\"] = {
+  function()
+    require("astronvim.utils.status").heirline.buffer_picker(function(bufnr)
+      vim.cmd.split()
+      vim.api.nvim_win_set_buf(0, bufnr)
+    end)
+  end,
+  desc = "Horizontal split buffer from tabline",
+}
+maps.n["<leader>b|"] = {
+  function()
+    require("astronvim.utils.status").heirline.buffer_picker(function(bufnr)
+      vim.cmd.vsplit()
+      vim.api.nvim_win_set_buf(0, bufnr)
+    end)
+  end,
+  desc = "Vertical split buffer from tabline",
+}
+
+-- Navigate tabs
+maps.n["]t"] = { function() vim.cmd.tabnext() end, desc = "Next tab" }
+maps.n["[t"] = { function() vim.cmd.tabprevious() end, desc = "Previous tab" }
+
+-- Alpha
+if is_available "alpha-nvim" then
+  maps.n["<leader>h"] = {
+    function()
+      local wins = vim.api.nvim_tabpage_list_wins(0)
+      if #wins > 1 and vim.api.nvim_get_option_value("filetype", { win = wins[1] }) == "neo-tree" then
+        vim.fn.win_gotoid(wins[2]) -- go to non-neo-tree window to toggle alpha
+      end
+      require("alpha").start(false, require("alpha").default_config)
+    end,
+    desc = "Home Screen",
+  }
+end
+
+-- Comment
+if is_available "Comment.nvim" then
+  maps.n["<leader>/"] = {
+    function() require("Comment.api").toggle.linewise.count(vim.v.count > 0 and vim.v.count or 1) end,
+    desc = "Comment line",
+  }
+  maps.v["<leader>/"] =
+    { "<esc><cmd>lua require('Comment.api').toggle.linewise(vim.fn.visualmode())<cr>", desc = "Toggle comment line" }
+end
+
+-- GitSigns
+if is_available "gitsigns.nvim" then
+  maps.n["<leader>g"] = sections.g
+  maps.n["]g"] = { function() require("gitsigns").next_hunk() end, desc = "Next Git hunk" }
+  maps.n["[g"] = { function() require("gitsigns").prev_hunk() end, desc = "Previous Git hunk" }
+  maps.n["<leader>gl"] = { function() require("gitsigns").blame_line() end, desc = "View Git blame" }
+  maps.n["<leader>gp"] = { function() require("gitsigns").preview_hunk() end, desc = "Preview Git hunk" }
+  maps.n["<leader>gh"] = { function() require("gitsigns").reset_hunk() end, desc = "Reset Git hunk" }
+  maps.n["<leader>gr"] = { function() require("gitsigns").reset_buffer() end, desc = "Reset Git buffer" }
+  maps.n["<leader>gs"] = { function() require("gitsigns").stage_hunk() end, desc = "Stage Git hunk" }
+  maps.n["<leader>gS"] = { function() require("gitsigns").stage_buffer() end, desc = "Stage Git buffer" }
+  maps.n["<leader>gu"] = { function() require("gitsigns").undo_stage_hunk() end, desc = "Unstage Git hunk" }
+  maps.n["<leader>gd"] = { function() require("gitsigns").diffthis() end, desc = "View Git diff" }
+end
+
+-- NeoTree
+if is_available "neo-tree.nvim" then
+  maps.n["<leader>e"] = { "<cmd>Neotree toggle<cr>", desc = "Toggle Explorer" }
+  maps.n["<leader>o"] = {
+    function()
+      if vim.bo.filetype == "neo-tree" then
+        vim.cmd.wincmd "p"
+      else
+        vim.cmd.Neotree "focus"
+      end
+    end,
+    desc = "Toggle Explorer Focus",
+  }
+end
+
+-- Session Manager
+if is_available "neovim-session-manager" then
+  maps.n["<leader>S"] = sections.S
+  maps.n["<leader>Sl"] = { "<cmd>SessionManager! load_last_session<cr>", desc = "Load last session" }
+  maps.n["<leader>Ss"] = { "<cmd>SessionManager! save_current_session<cr>", desc = "Save this session" }
+  maps.n["<leader>Sd"] = { "<cmd>SessionManager! delete_session<cr>", desc = "Delete session" }
+  maps.n["<leader>Sf"] = { "<cmd>SessionManager! load_session<cr>", desc = "Search sessions" }
+  maps.n["<leader>S."] =
+    { "<cmd>SessionManager! load_current_dir_session<cr>", desc = "Load current directory session" }
+end
+
+-- Package Manager
+if is_available "mason.nvim" then
+  maps.n["<leader>pm"] = { "<cmd>Mason<cr>", desc = "Mason Installer" }
+  maps.n["<leader>pM"] = { "<cmd>MasonUpdateAll<cr>", desc = "Mason Update" }
+end
+
+-- Smart Splits
+if is_available "smart-splits.nvim" then
+  maps.n["<C-h>"] = { function() require("smart-splits").move_cursor_left() end, desc = "Move to left split" }
+  maps.n["<C-j>"] = { function() require("smart-splits").move_cursor_down() end, desc = "Move to below split" }
+  maps.n["<C-k>"] = { function() require("smart-splits").move_cursor_up() end, desc = "Move to above split" }
+  maps.n["<C-l>"] = { function() require("smart-splits").move_cursor_right() end, desc = "Move to right split" }
+  maps.n["<C-Up>"] = { function() require("smart-splits").resize_up() end, desc = "Resize split up" }
+  maps.n["<C-Down>"] = { function() require("smart-splits").resize_down() end, desc = "Resize split down" }
+  maps.n["<C-Left>"] = { function() require("smart-splits").resize_left() end, desc = "Resize split left" }
+  maps.n["<C-Right>"] = { function() require("smart-splits").resize_right() end, desc = "Resize split right" }
+else
+  maps.n["<C-h>"] = { "<C-w>h", desc = "Move to left split" }
+  maps.n["<C-j>"] = { "<C-w>j", desc = "Move to below split" }
+  maps.n["<C-k>"] = { "<C-w>k", desc = "Move to above split" }
+  maps.n["<C-l>"] = { "<C-w>l", desc = "Move to right split" }
+  maps.n["<C-Up>"] = { "<cmd>resize -2<CR>", desc = "Resize split up" }
+  maps.n["<C-Down>"] = { "<cmd>resize +2<CR>", desc = "Resize split down" }
+  maps.n["<C-Left>"] = { "<cmd>vertical resize -2<CR>", desc = "Resize split left" }
+  maps.n["<C-Right>"] = { "<cmd>vertical resize +2<CR>", desc = "Resize split right" }
+end
+
+-- SymbolsOutline
+if is_available "aerial.nvim" then
+  maps.n["<leader>l"] = sections.l
+  maps.n["<leader>lS"] = { function() require("aerial").toggle() end, desc = "Symbols outline" }
+end
+
+-- Telescope
+if is_available "telescope.nvim" then
+  maps.n["<leader>f"] = sections.f
+  maps.n["<leader>g"] = sections.g
+  maps.n["<leader>gb"] = { function() require("telescope.builtin").git_branches() end, desc = "Git branches" }
+  maps.n["<leader>gc"] = { function() require("telescope.builtin").git_commits() end, desc = "Git commits" }
+  maps.n["<leader>gt"] = { function() require("telescope.builtin").git_status() end, desc = "Git status" }
+  maps.n["<leader>f<CR>"] = { function() require("telescope.builtin").resume() end, desc = "Resume previous search" }
+  maps.n["<leader>f'"] = { function() require("telescope.builtin").marks() end, desc = "Find marks" }
+  maps.n["<leader>fa"] = {
+    function()
+      local cwd = vim.fn.stdpath "config" .. "/.."
+      local search_dirs = {}
+      for _, dir in ipairs(astronvim.supported_configs) do -- search all supported config locations
+        if dir == astronvim.install.home then dir = dir .. "/lua/user" end -- don't search the astronvim core files
+        if vim.fn.isdirectory(dir) == 1 then table.insert(search_dirs, dir) end -- add directory to search if exists
+      end
+      if vim.tbl_isempty(search_dirs) then -- if no config folders found, show warning
+        utils.notify("No user configuration files found", "warn")
+      else
+        if #search_dirs == 1 then cwd = search_dirs[1] end -- if only one directory, focus cwd
+        require("telescope.builtin").find_files {
+          prompt_title = "Config Files",
+          search_dirs = search_dirs,
+          cwd = cwd,
+        } -- call telescope
+      end
+    end,
+    desc = "Find AstroNvim config files",
+  }
+  maps.n["<leader>fb"] = { function() require("telescope.builtin").buffers() end, desc = "Find buffers" }
+  maps.n["<leader>fc"] =
+    { function() require("telescope.builtin").grep_string() end, desc = "Find for word under cursor" }
+  maps.n["<leader>fC"] = { function() require("telescope.builtin").commands() end, desc = "Find commands" }
+  maps.n["<leader>ff"] = { function() require("telescope.builtin").find_files() end, desc = "Find files" }
+  maps.n["<leader>fF"] = {
+    function() require("telescope.builtin").find_files { hidden = true, no_ignore = true } end,
+    desc = "Find all files",
+  }
+  maps.n["<leader>fh"] = { function() require("telescope.builtin").help_tags() end, desc = "Find help" }
+  maps.n["<leader>fk"] = { function() require("telescope.builtin").keymaps() end, desc = "Find keymaps" }
+  maps.n["<leader>fm"] = { function() require("telescope.builtin").man_pages() end, desc = "Find man" }
+  if is_available "nvim-notify" then
+    maps.n["<leader>fn"] =
+      { function() require("telescope").extensions.notify.notify() end, desc = "Find notifications" }
+  end
+  maps.n["<leader>fo"] = { function() require("telescope.builtin").oldfiles() end, desc = "Find history" }
+  maps.n["<leader>fr"] = { function() require("telescope.builtin").registers() end, desc = "Find registers" }
+  maps.n["<leader>ft"] =
+    { function() require("telescope.builtin").colorscheme { enable_preview = true } end, desc = "Find themes" }
+  maps.n["<leader>fw"] = { function() require("telescope.builtin").live_grep() end, desc = "Find words" }
+  maps.n["<leader>fW"] = {
+    function()
+      require("telescope.builtin").live_grep {
+        additional_args = function(args) return vim.list_extend(args, { "--hidden", "--no-ignore" }) end,
+      }
+    end,
+    desc = "Find words in all files",
+  }
+  maps.n["<leader>l"] = sections.l
+  maps.n["<leader>lD"] = { function() require("telescope.builtin").diagnostics() end, desc = "Search diagnostics" }
+  maps.n["<leader>ls"] = {
+    function()
+      local aerial_avail, _ = pcall(require, "aerial")
+      if aerial_avail then
+        require("telescope").extensions.aerial.aerial()
+      else
+        require("telescope.builtin").lsp_document_symbols()
+      end
+    end,
+    desc = "Search symbols",
+  }
+end
+
+-- Terminal
+if is_available "toggleterm.nvim" then
+  maps.n["<leader>t"] = sections.t
+  if vim.fn.executable "lazygit" == 1 then
+    maps.n["<leader>g"] = sections.g
+    maps.n["<leader>gg"] = { function() utils.toggle_term_cmd "lazygit" end, desc = "ToggleTerm lazygit" }
+    maps.n["<leader>tl"] = { function() utils.toggle_term_cmd "lazygit" end, desc = "ToggleTerm lazygit" }
+  end
+  if vim.fn.executable "node" == 1 then
+    maps.n["<leader>tn"] = { function() utils.toggle_term_cmd "node" end, desc = "ToggleTerm node" }
+  end
+  if vim.fn.executable "gdu" == 1 then
+    maps.n["<leader>tu"] = { function() utils.toggle_term_cmd "gdu" end, desc = "ToggleTerm gdu" }
+  end
+  if vim.fn.executable "btm" == 1 then
+    maps.n["<leader>tt"] = { function() utils.toggle_term_cmd "btm" end, desc = "ToggleTerm btm" }
+  end
+  local python = vim.fn.executable "python" == 1 and "python" or vim.fn.executable "python3" == 1 and "python3"
+  if python then maps.n["<leader>tp"] = { function() utils.toggle_term_cmd(python) end, desc = "ToggleTerm python" } end
+  maps.n["<leader>tf"] = { "<cmd>ToggleTerm direction=float<cr>", desc = "ToggleTerm float" }
+  maps.n["<leader>th"] = { "<cmd>ToggleTerm size=10 direction=horizontal<cr>", desc = "ToggleTerm horizontal split" }
+  maps.n["<leader>tv"] = { "<cmd>ToggleTerm size=80 direction=vertical<cr>", desc = "ToggleTerm vertical split" }
+  maps.n["<F7>"] = { "<cmd>ToggleTerm<cr>", desc = "Toggle terminal" }
+  maps.t["<F7>"] = maps.n["<F7>"]
+  maps.n["<C-'>"] = maps.n["<F7>"]
+  maps.t["<C-'>"] = maps.n["<F7>"]
+end
+
+if is_available "nvim-dap" then
+  maps.n["<leader>d"] = sections.d
+  -- modified function keys found with `showkey -a` in the terminal to get key code
+  -- run `nvim -V3log +quit` and search through the "Terminal info" in the `log` file for the correct keyname
+  maps.n["<F5>"] = { function() require("dap").continue() end, desc = "Debugger: Start" }
+  maps.n["<F17>"] = { function() require("dap").terminate() end, desc = "Debugger: Stop" } -- Shift+F5
+  maps.n["<F29>"] = { function() require("dap").restart_frame() end, desc = "Debugger: Restart" } -- Control+F5
+  maps.n["<F6>"] = { function() require("dap").pause() end, desc = "Debugger: Pause" }
+  maps.n["<F9>"] = { function() require("dap").toggle_breakpoint() end, desc = "Debugger: Toggle Breakpoint" }
+  maps.n["<F10>"] = { function() require("dap").step_over() end, desc = "Debugger: Step Over" }
+  maps.n["<F11>"] = { function() require("dap").step_into() end, desc = "Debugger: Step Into" }
+  maps.n["<F23>"] = { function() require("dap").step_out() end, desc = "Debugger: Step Out" } -- Shift+F11
+  maps.n["<leader>db"] = { function() require("dap").toggle_breakpoint() end, desc = "Toggle Breakpoint (F9)" }
+  maps.n["<leader>dB"] = { function() require("dap").clear_breakpoints() end, desc = "Clear Breakpoints" }
+  maps.n["<leader>dc"] = { function() require("dap").continue() end, desc = "Start/Continue (F5)" }
+  maps.n["<leader>di"] = { function() require("dap").step_into() end, desc = "Step Into (F11)" }
+  maps.n["<leader>do"] = { function() require("dap").step_over() end, desc = "Step Over (F10)" }
+  maps.n["<leader>dO"] = { function() require("dap").step_out() end, desc = "Step Out (S-F11)" }
+  maps.n["<leader>dq"] = { function() require("dap").close() end, desc = "Close Session" }
+  maps.n["<leader>dQ"] = { function() require("dap").terminate() end, desc = "Terminate Session (S-F5)" }
+  maps.n["<leader>dp"] = { function() require("dap").pause() end, desc = "Pause (F6)" }
+  maps.n["<leader>dr"] = { function() require("dap").restart_frame() end, desc = "Restart (C-F5)" }
+  maps.n["<leader>dR"] = { function() require("dap").repl.toggle() end, desc = "Toggle REPL" }
+  if is_available "nvim-dap-ui" then
+    maps.n["<leader>du"] = { function() require("dapui").toggle() end, desc = "Toggle Debugger UI" }
+    maps.n["<leader>dh"] = { function() require("dap.ui.widgets").hover() end, desc = "Debugger Hover" }
+  end
+end
+
+-- Improved Code Folding
+if is_available "nvim-ufo" then
+  maps.n["zR"] = { function() require("ufo").openAllFolds() end, desc = "Open all folds" }
+  maps.n["zM"] = { function() require("ufo").closeAllFolds() end, desc = "Close all folds" }
+  maps.n["zr"] = { function() require("ufo").openFoldsExceptKinds() end, desc = "Fold less" }
+  maps.n["zm"] = { function() require("ufo").closeFoldsWith() end, desc = "Fold more" }
+  maps.n["zp"] = { function() require("ufo").peekFoldedLinesUnderCursor() end, desc = "Peek fold" }
+end
+
+-- Stay in indent mode
+maps.v["<S-Tab>"] = { "<gv", desc = "unindent line" }
+maps.v["<Tab>"] = { ">gv", desc = "indent line" }
+
+-- Improved Terminal Navigation
+maps.t["<C-h>"] = { "<cmd>wincmd h<cr>", desc = "Terminal left window navigation" }
+maps.t["<C-j>"] = { "<cmd>wincmd j<cr>", desc = "Terminal down window navigation" }
+maps.t["<C-k>"] = { "<cmd>wincmd k<cr>", desc = "Terminal up window navigation" }
+maps.t["<C-l>"] = { "<cmd>wincmd l<cr>", desc = "Terminal right window navigation" }
+
+maps.n["<leader>u"] = sections.u
+-- Custom menu for modification of the user experience
+if is_available "nvim-autopairs" then maps.n["<leader>ua"] = { ui.toggle_autopairs, desc = "Toggle autopairs" } end
+maps.n["<leader>ub"] = { ui.toggle_background, desc = "Toggle background" }
+if is_available "nvim-cmp" then maps.n["<leader>uc"] = { ui.toggle_cmp, desc = "Toggle autocompletion" } end
+if is_available "nvim-colorizer.lua" then
+  maps.n["<leader>uC"] = { "<cmd>ColorizerToggle<cr>", desc = "Toggle color highlight" }
+end
+maps.n["<leader>ud"] = { ui.toggle_diagnostics, desc = "Toggle diagnostics" }
+maps.n["<leader>ug"] = { ui.toggle_signcolumn, desc = "Toggle signcolumn" }
+maps.n["<leader>ui"] = { ui.set_indent, desc = "Change indent setting" }
+maps.n["<leader>ul"] = { ui.toggle_statusline, desc = "Toggle statusline" }
+maps.n["<leader>uL"] = { ui.toggle_codelens, desc = "Toggle CodeLens refresh" }
+maps.n["<leader>un"] = { ui.change_number, desc = "Change line numbering" }
+maps.n["<leader>uN"] = { ui.toggle_ui_notifications, desc = "Toggle UI notifications" }
+maps.n["<leader>up"] = { ui.toggle_paste, desc = "Toggle paste mode" }
+maps.n["<leader>us"] = { ui.toggle_spell, desc = "Toggle spellcheck" }
+maps.n["<leader>uS"] = { ui.toggle_conceal, desc = "Toggle conceal" }
+maps.n["<leader>ut"] = { ui.toggle_tabline, desc = "Toggle tabline" }
+maps.n["<leader>uu"] = { ui.toggle_url_match, desc = "Toggle URL highlight" }
+maps.n["<leader>uw"] = { ui.toggle_wrap, desc = "Toggle wrap" }
+maps.n["<leader>uy"] = { ui.toggle_syntax, desc = "Toggle syntax highlight" }
+
+utils.set_mappings(astronvim.user_opts("mappings", maps))

users/daniel/configs/system/nvim/nvim/lua/astronvim/options.lua

@@ -0,0 +1,71 @@
+vim.opt.viewoptions:remove "curdir" -- disable saving current directory with views
+vim.opt.shortmess:append { s = true, I = true } -- disable startup message
+vim.opt.backspace:append { "nostop" } -- Don't stop backspace at insert
+if vim.fn.has "nvim-0.9" == 1 then
+  vim.opt.diffopt:append "linematch:60" -- enable linematch diff algorithm
+end
+local options = astronvim.user_opts("options", {
+  opt = {
+    breakindent = true, -- Wrap indent to match  line start
+    clipboard = "unnamedplus", -- Connection to the system clipboard
+    cmdheight = 0, -- hide command line unless needed
+    completeopt = { "menuone", "noselect" }, -- Options for insert mode completion
+    copyindent = true, -- Copy the previous indentation on autoindenting
+    cursorline = true, -- Highlight the text line of the cursor
+    expandtab = true, -- Enable the use of space in tab
+    fileencoding = "utf-8", -- File content encoding for the buffer
+    fillchars = { eob = " " }, -- Disable `~` on nonexistent lines
+    foldenable = true, -- enable fold for nvim-ufo
+    foldlevel = 99, -- set high foldlevel for nvim-ufo
+    foldlevelstart = 99, -- start with all code unfolded
+    foldcolumn = vim.fn.has "nvim-0.9" == 1 and "1" or nil, -- show foldcolumn in nvim 0.9
+    history = 100, -- Number of commands to remember in a history table
+    ignorecase = true, -- Case insensitive searching
+    infercase = true, -- Infer cases in keyword completion
+    laststatus = 3, -- globalstatus
+    linebreak = true, -- Wrap lines at 'breakat'
+    mouse = "a", -- Enable mouse support
+    number = true, -- Show numberline
+    preserveindent = true, -- Preserve indent structure as much as possible
+    pumheight = 10, -- Height of the pop up menu
+    relativenumber = true, -- Show relative numberline
+    scrolloff = 8, -- Number of lines to keep above and below the cursor
+    shiftwidth = 2, -- Number of space inserted for indentation
+    showmode = false, -- Disable showing modes in command line
+    showtabline = 2, -- always display tabline
+    sidescrolloff = 8, -- Number of columns to keep at the sides of the cursor
+    signcolumn = "yes", -- Always show the sign column
+    smartcase = true, -- Case sensitivie searching
+    smartindent = true, -- Smarter autoindentation
+    splitbelow = true, -- Splitting a new window below the current one
+    splitkeep = vim.fn.has "nvim-0.9" == 1 and "screen" or nil, -- Maintain code view when splitting
+    splitright = true, -- Splitting a new window at the right of the current one
+    tabstop = 2, -- Number of space in a tab
+    termguicolors = true, -- Enable 24-bit RGB color in the TUI
+    timeoutlen = 500, -- Shorten key timeout length a little bit for which-key
+    undofile = true, -- Enable persistent undo
+    updatetime = 300, -- Length of time to wait before triggering the plugin
+    virtualedit = "block", -- allow going past end of line in visual block mode
+    wrap = false, -- Disable wrapping of lines longer than the width of window
+    writebackup = false, -- Disable making a backup before overwriting a file
+  },
+  g = {
+    highlighturl_enabled = true, -- highlight URLs by default
+    mapleader = " ", -- set leader key
+    autoformat_enabled = true, -- enable or disable auto formatting at start (lsp.formatting.format_on_save must be enabled)
+    codelens_enabled = true, -- enable or disable automatic codelens refreshing for lsp that support it
+    lsp_handlers_enabled = true, -- enable or disable default vim.lsp.handlers (hover and signatureHelp)
+    cmp_enabled = true, -- enable completion at start
+    autopairs_enabled = true, -- enable autopairs at start
+    diagnostics_mode = 3, -- set the visibility of diagnostics in the UI (0=off, 1=only show in status line, 2=virtual text off, 3=all on)
+    icons_enabled = true, -- disable icons in the UI (disable if no nerd font is available)
+    ui_notifications_enabled = true, -- disable notifications when toggling UI elements
+  },
+  t = { bufs = vim.api.nvim_list_bufs() }, -- initialize buffers for the current tab
+})
+
+for scope, table in pairs(options) do
+  for setting, value in pairs(table) do
+    vim[scope][setting] = value
+  end
+end

users/daniel/configs/system/nvim/nvim/lua/astronvim/utils/buffer.lua

@@ -0,0 +1,103 @@
+--- ### AstroNvim Buffer Utilities
+--
+-- Buffer management related utility functions
+--
+-- This module can be loaded with `local buffer_utils = require "astronvim.utils.buffer"`
+--
+-- @module astronvim.utils.buffer
+-- @copyright 2022
+-- @license GNU General Public License v3.0
+
+local M = {}
+
+--- Check if a buffer is valid
+-- @param bufnr the buffer to check
+-- @return true if the buffer is valid or false
+function M.is_valid(bufnr)
+  if not bufnr or bufnr < 1 then return false end
+  return vim.bo[bufnr].buflisted and vim.api.nvim_buf_is_valid(bufnr)
+end
+
+--- Move the current buffer tab n places in the bufferline
+-- @param n numer of tabs to move the current buffer over by (positive = right, negative = left)
+function M.move(n)
+  if n == 0 then return end -- if n = 0 then no shifts are needed
+  local bufs = vim.t.bufs -- make temp variable
+  for i, bufnr in ipairs(bufs) do -- loop to find current buffer
+    if bufnr == vim.api.nvim_get_current_buf() then -- found index of current buffer
+      for _ = 0, (n % #bufs) - 1 do -- calculate number of right shifts
+        local new_i = i + 1 -- get next i
+        if i == #bufs then -- if at end, cycle to beginning
+          new_i = 1 -- next i is actually 1 if at the end
+          local val = bufs[i] -- save value
+          table.remove(bufs, i) -- remove from end
+          table.insert(bufs, new_i, val) -- insert at beginning
+        else -- if not at the end,then just do an in place swap
+          bufs[i], bufs[new_i] = bufs[new_i], bufs[i]
+        end
+        i = new_i -- iterate i to next value
+      end
+      break
+    end
+  end
+  vim.t.bufs = bufs -- set buffers
+  require("astronvim.utils").event "BufsUpdated"
+  vim.cmd.redrawtabline() -- redraw tabline
+end
+
+--- Navigate left and right by n places in the bufferline
+-- @param n the number of tabs to navigate to (positive = right, negative = left)
+function M.nav(n)
+  local current = vim.api.nvim_get_current_buf()
+  for i, v in ipairs(vim.t.bufs) do
+    if current == v then
+      vim.cmd.b(vim.t.bufs[(i + n - 1) % #vim.t.bufs + 1])
+      break
+    end
+  end
+end
+
+--- Navigate to a specific buffer by its position in the bufferline
+-- @param tabnr the position of the buffer to navigate to
+function M.nav_to(tabnr) vim.cmd.b(vim.t.bufs[tabnr]) end
+
+--- Close a given buffer
+-- @param bufnr? the buffer number to close or the current buffer if not provided
+-- @param force? whether or not to foce close the buffers or confirm changes (default: false)
+function M.close(bufnr, force)
+  if force == nil then force = false end
+  if require("astronvim.utils").is_available "bufdelete.nvim" then
+    require("bufdelete").bufdelete(bufnr, force)
+  else
+    vim.cmd((force and "bd!" or "confirm bd") .. bufnr)
+  end
+end
+
+--- Close all buffers
+-- @param keep_current? whether or not to keep the current buffer (default: false)
+-- @param force? whether or not to foce close the buffers or confirm changes (default: false)
+function M.close_all(keep_current, force)
+  if force == nil then force = false end
+  if keep_current == nil then keep_current = false end
+  local current = vim.api.nvim_get_current_buf()
+  for _, bufnr in ipairs(vim.t.bufs) do
+    if not keep_current or bufnr ~= current then
+      if require("astronvim.utils").is_available "bufdelete.nvim" then
+        require("bufdelete").bufdelete(bufnr, force)
+      else
+        vim.cmd((force and "bd!" or "confirm bd") .. bufnr)
+      end
+    end
+  end
+end
+
+--- Close the current tab
+function M.close_tab()
+  if #vim.api.nvim_list_tabpages() > 1 then
+    vim.t.bufs = nil
+    require("astronvim.utils").event "BufsUpdated"
+    vim.cmd.tabclose()
+  end
+end
+
+return M

users/daniel/configs/system/nvim/nvim/lua/astronvim/utils/ffi.lua

@@ -0,0 +1,20 @@
+-- ### AstroNvim C Extensions
+
+local ffi = require "ffi"
+
+-- Custom C extension to get direct fold information from Neovim
+ffi.cdef [[
+	typedef struct {} Error;
+	typedef struct {} win_T;
+	typedef struct {
+		int start;  // line number where deepest fold starts
+		int level;  // fold level, when zero other fields are N/A
+		int llevel; // lowest level that starts in v:lnum
+		int lines;  // number of lines from v:lnum to end of closed fold
+	} foldinfo_T;
+	foldinfo_T fold_info(win_T* wp, int lnum);
+	win_T *find_window_by_handle(int Window, Error *err);
+	int compute_foldcolumn(win_T *wp, int col);
+]]
+
+return ffi

users/daniel/configs/system/nvim/nvim/lua/astronvim/utils/git.lua

@@ -0,0 +1,168 @@
+--- ### Git LUA API
+--
+-- This module can be loaded with `local git = require "astronvim.utils.git"`
+--
+-- @module astronvim.utils.git
+-- @copyright 2022
+-- @license GNU General Public License v3.0
+
+local git = { url = "https://github.com/" }
+
+local function trim_or_nil(str) return type(str) == "string" and vim.trim(str) or nil end
+
+--- Run a git command from the AstroNvim installation directory
+-- @param args the git arguments
+-- @return the result of the command or nil if unsuccessful
+function git.cmd(args, ...)
+  return require("astronvim.utils").cmd("git -C " .. astronvim.install.home .. " " .. args, ...)
+end
+
+--- Check if the AstroNvim is able to reach the `git` command
+-- @return the result of running `git --help`
+function git.available() return vim.fn.executable "git" == 1 end
+
+--- Check if the AstroNvim home is a git repo
+-- @return the result of the command
+function git.is_repo() return git.cmd("rev-parse --is-inside-work-tree", false) end
+
+--- Fetch git remote
+-- @param remote the remote to fetch
+-- @return the result of the command
+function git.fetch(remote, ...) return git.cmd("fetch " .. remote, ...) end
+
+--- Pull the git repo
+-- @return the result of the command
+function git.pull(...) return git.cmd("pull --rebase", ...) end
+
+--- Checkout git target
+-- @param dest the target to checkout
+-- @return the result of the command
+function git.checkout(dest, ...) return git.cmd("checkout " .. dest, ...) end
+
+--- Hard reset to a git target
+-- @param dest the target to hard reset to
+-- @return the result of the command
+function git.hard_reset(dest, ...) return git.cmd("reset --hard " .. dest, ...) end
+
+--- Check if a branch contains a commit
+-- @param remote the git remote to check
+-- @param branch the git branch to check
+-- @param commit the git commit to check for
+-- @return the result of the command
+function git.branch_contains(remote, branch, commit, ...)
+  return git.cmd("merge-base --is-ancestor " .. commit .. " " .. remote .. "/" .. branch, ...) ~= nil
+end
+
+--- Get the remote name for a given branch
+-- @param branch the git branch to check
+-- @return the name of the remote for the given branch
+function git.branch_remote(branch, ...) return trim_or_nil(git.cmd("config branch." .. branch .. ".remote", ...)) end
+
+--- Add a git remote
+-- @param remote the remote to add
+-- @param url the url of the remote
+-- @return the result of the command
+function git.remote_add(remote, url, ...) return git.cmd("remote add " .. remote .. " " .. url, ...) end
+
+--- Update a git remote URL
+-- @param remote the remote to update
+-- @param url the new URL of the remote
+-- @return the result of the command
+function git.remote_update(remote, url, ...) return git.cmd("remote set-url " .. remote .. " " .. url, ...) end
+
+--- Get the URL of a given git remote
+-- @param remote the remote to get the URL of
+-- @return the url of the remote
+function git.remote_url(remote, ...) return trim_or_nil(git.cmd("remote get-url " .. remote, ...)) end
+
+--- Get the current version with git describe including tags
+-- @return the current git describe string
+function git.current_version(...) return trim_or_nil(git.cmd("describe --tags", ...)) end
+
+--- Get the current branch
+-- @return the branch of the AstroNvim installation
+function git.current_branch(...) return trim_or_nil(git.cmd("rev-parse --abbrev-ref HEAD", ...)) end
+
+--- Get the current head of the git repo
+-- @return the head string
+function git.local_head(...) return trim_or_nil(git.cmd("rev-parse HEAD", ...)) end
+
+--- Get the current head of a git remote
+-- @param remote the remote to check
+-- @param branch the branch to check
+-- @return the head string of the remote branch
+function git.remote_head(remote, branch, ...)
+  return trim_or_nil(git.cmd("rev-list -n 1 " .. remote .. "/" .. branch, ...))
+end
+
+--- Get the commit hash of a given tag
+-- @param tag the tag to resolve
+-- @return the commit hash of a git tag
+function git.tag_commit(tag, ...) return trim_or_nil(git.cmd("rev-list -n 1 " .. tag, ...)) end
+
+--- Get the commit log between two commit hashes
+-- @param start_hash the start commit hash
+-- @param end_hash the end commit hash
+-- @return an array like table of commit messages
+function git.get_commit_range(start_hash, end_hash, ...)
+  local range = ""
+  if start_hash and end_hash then range = start_hash .. ".." .. end_hash end
+  local log = git.cmd('log --no-merges --pretty="format:[%h] %s" ' .. range, ...)
+  return log and vim.fn.split(log, "\n") or {}
+end
+
+--- Get a list of all tags with a regex filter
+-- @param search a regex to search the tags with (defaults to "v*" for version tags)
+-- @return an array like table of tags that match the search
+function git.get_versions(search, ...)
+  local tags = git.cmd('tag -l --sort=version:refname "' .. (search == "latest" and "v*" or search) .. '"', ...)
+  return tags and vim.fn.split(tags, "\n") or {}
+end
+
+--- Get the latest version of a list of versions
+-- @param versions a list of versions to search (defaults to all versions available)
+-- @return the latest version from the array
+function git.latest_version(versions, ...)
+  if not versions then versions = git.get_versions(...) end
+  return versions[#versions]
+end
+
+--- Parse a remote url
+-- @param str the remote to parse to a full git url
+-- @return the full git url for the given remote string
+function git.parse_remote_url(str)
+  return vim.fn.match(str, astronvim.url_matcher) == -1
+      and git.url .. str .. (vim.fn.match(str, "/") == -1 and "/AstroNvim.git" or ".git")
+    or str
+end
+
+--- Check if a Conventional Commit commit message is breaking or not
+-- @param commit a commit message
+-- @return boolean true if the message is breaking, false if the commit message is not breaking
+function git.is_breaking(commit) return vim.fn.match(commit, "\\[.*\\]\\s\\+\\w\\+\\((\\w\\+)\\)\\?!:") ~= -1 end
+
+--- Get a list of breaking commits from commit messages using Conventional Commit standard
+-- @param commits an array like table of commit messages
+-- @return an array like table of commits that are breaking
+function git.breaking_changes(commits) return vim.tbl_filter(git.is_breaking, commits) end
+
+--- Generate a table of commit messages for neovim's echo API with highlighting
+-- @param commits an array like table of commit messages
+-- @return an array like table of echo messages to provide to nvim_echo or astronvim.echo
+function git.pretty_changelog(commits)
+  local changelog = {}
+  for _, commit in ipairs(commits) do
+    local hash, type, msg = commit:match "(%[.*%])(.*:)(.*)"
+    if hash and type and msg then
+      vim.list_extend(changelog, {
+        { hash, "DiffText" },
+        { type, git.is_breaking(commit) and "DiffDelete" or "DiffChange" },
+        { msg },
+        { "\n" },
+      })
+    end
+  end
+  return changelog
+end
+
+return git

users/daniel/configs/system/nvim/nvim/lua/astronvim/utils/init.lua

@@ -0,0 +1,249 @@
+--- ### AstroNvim Utilities
+--
+-- Various utility functions to use within AstroNvim and user configurations.
+--
+-- This module can be loaded with `local utils = require "astronvim.utils"`
+--
+-- @module astronvim.utils
+-- @copyright 2022
+-- @license GNU General Public License v3.0
+
+local M = {}
+
+--- Merge extended options with a default table of options
+-- @param default the default table that you want to merge into
+-- @param opts the new options that should be merged with the default table
+-- @return the merged table
+function M.extend_tbl(default, opts)
+  opts = opts or {}
+  return default and vim.tbl_deep_extend("force", default, opts) or opts
+end
+
+--- Insert one or more values into a list like table and maintain that you do not insert non-unique values (THIS MODIFIES `lst`)
+-- @param lst the list like table that you want to insert into
+-- @param vals either a list like table of values to be inserted or a single value to be inserted
+-- @return the modified list like table
+function M.list_insert_unique(lst, vals)
+  assert(vim.tbl_islist(lst), "Provided table is not a list like table")
+  if not vim.tbl_islist(vals) then vals = { vals } end
+  for _, val in ipairs(vals) do
+    if not vim.tbl_contains(lst, val) then table.insert(lst, val) end
+  end
+  return lst
+end
+
+--- Call function if a condition is met
+-- @param func the function to run
+-- @param condition a boolean value of whether to run the function or not
+function M.conditional_func(func, condition, ...)
+  -- if the condition is true or no condition is provided, evaluate the function with the rest of the parameters and return the result
+  if condition and type(func) == "function" then return func(...) end
+end
+
+--- Get an icon from `lspkind` if it is available and return it
+-- @param kind the kind of icon in `lspkind` to retrieve
+-- @return the icon
+function M.get_icon(kind)
+  local icon_pack = vim.g.icons_enabled and "icons" or "text_icons"
+  if not M[icon_pack] then
+    M.icons = astronvim.user_opts("icons", require "astronvim.icons.nerd_font")
+    M.text_icons = astronvim.user_opts("text_icons", require "astronvim.icons.text")
+  end
+  return M[icon_pack] and M[icon_pack][kind] or ""
+end
+
+--- Get highlight properties for a given highlight name
+-- @param name highlight group name
+-- @return table of highlight group properties
+function M.get_hlgroup(name, fallback)
+  if vim.fn.hlexists(name) == 1 then
+    local hl = vim.api.nvim_get_hl_by_name(name, vim.o.termguicolors)
+    if not hl["foreground"] then hl["foreground"] = "NONE" end
+    if not hl["background"] then hl["background"] = "NONE" end
+    hl.fg, hl.bg, hl.sp = hl.foreground, hl.background, hl.special
+    hl.ctermfg, hl.ctermbg = hl.foreground, hl.background
+    return hl
+  end
+  return fallback
+end
+
+--- Serve a notification with a title of AstroNvim
+-- @param msg the notification body
+-- @param type the type of the notification (:help vim.log.levels)
+-- @param opts table of nvim-notify options to use (:help notify-options)
+function M.notify(msg, type, opts)
+  vim.schedule(function() vim.notify(msg, type, M.extend_tbl({ title = "AstroNvim" }, opts)) end)
+end
+
+--- Trigger an AstroNvim user event
+-- @param event the event name to be appended to Astro
+function M.event(event)
+  vim.schedule(function() vim.api.nvim_exec_autocmds("User", { pattern = "Astro" .. event }) end)
+end
+
+--- Open a URL under the cursor with the current operating system
+-- @param path the path of the file to open with the system opener
+function M.system_open(path)
+  local cmd
+  if vim.fn.has "win32" == 1 and vim.fn.executable "explorer" == 1 then
+    cmd = "explorer"
+  elseif vim.fn.has "unix" == 1 and vim.fn.executable "xdg-open" == 1 then
+    cmd = "xdg-open"
+  elseif (vim.fn.has "mac" == 1 or vim.fn.has "unix" == 1) and vim.fn.executable "open" == 1 then
+    cmd = "open"
+  end
+  if not cmd then M.notify("Available system opening tool not found!", "error") end
+  vim.fn.jobstart({ cmd, path or vim.fn.expand "<cfile>" }, { detach = true })
+end
+
+-- term_details can be either a string for just a command or
+-- a complete table to provide full access to configuration when calling Terminal:new()
+
+--- Toggle a user terminal if it exists, if not then create a new one and save it
+-- @param term_details a terminal command string or a table of options for Terminal:new() (Check toggleterm.nvim documentation for table format)
+function M.toggle_term_cmd(opts)
+  local terms = astronvim.user_terminals
+  -- if a command string is provided, create a basic table for Terminal:new() options
+  if type(opts) == "string" then opts = { cmd = opts, hidden = true } end
+  local num = vim.v.count > 0 and vim.v.count or 1
+  -- if terminal doesn't exist yet, create it
+  if not terms[opts.cmd] then terms[opts.cmd] = {} end
+  if not terms[opts.cmd][num] then
+    if not opts.count then opts.count = vim.tbl_count(terms) * 100 + num end
+    if not opts.on_exit then opts.on_exit = function() terms[opts.cmd][num] = nil end end
+    terms[opts.cmd][num] = require("toggleterm.terminal").Terminal:new(opts)
+  end
+  -- toggle the terminal
+  terms[opts.cmd][num]:toggle()
+end
+
+--- Create a button entity to use with the alpha dashboard
+-- @param sc the keybinding string to convert to a button
+-- @param txt the explanation text of what the keybinding does
+-- @return a button entity table for an alpha configuration
+function M.alpha_button(sc, txt)
+  -- replace <leader> in shortcut text with LDR for nicer printing
+  local sc_ = sc:gsub("%s", ""):gsub("LDR", "<leader>")
+  -- if the leader is set, replace the text with the actual leader key for nicer printing
+  if vim.g.mapleader then sc = sc:gsub("LDR", vim.g.mapleader == " " and "SPC" or vim.g.mapleader) end
+  -- return the button entity to display the correct text and send the correct keybinding on press
+  return {
+    type = "button",
+    val = txt,
+    on_press = function()
+      local key = vim.api.nvim_replace_termcodes(sc_, true, false, true)
+      vim.api.nvim_feedkeys(key, "normal", false)
+    end,
+    opts = {
+      position = "center",
+      text = txt,
+      shortcut = sc,
+      cursor = 5,
+      width = 36,
+      align_shortcut = "right",
+      hl = "DashboardCenter",
+      hl_shortcut = "DashboardShortcut",
+    },
+  }
+end
+
+--- Check if a plugin is defined in lazy. Useful with lazy loading when a plugin is not necessarily loaded yet
+-- @param plugin the plugin string to search for
+-- @return boolean value if the plugin is available
+function M.is_available(plugin)
+  local lazy_config_avail, lazy_config = pcall(require, "lazy.core.config")
+  return lazy_config_avail and lazy_config.plugins[plugin] ~= nil
+end
+
+--- A helper function to wrap a module function to require a plugin before running
+-- @param plugin the plugin string to call `require("lazy").laod` with
+-- @param module the system module where the functions live (e.g. `vim.ui`)
+-- @param func_names a string or a list like table of strings for functions to wrap in the given moduel (e.g. `{ "ui", "select }`)
+function M.load_plugin_with_func(plugin, module, func_names)
+  if type(func_names) == "string" then func_names = { func_names } end
+  for _, func in ipairs(func_names) do
+    local old_func = module[func]
+    module[func] = function(...)
+      module[func] = old_func
+      require("lazy").load { plugins = { plugin } }
+      module[func](...)
+    end
+  end
+end
+
+--- Register queued which-key mappings
+function M.which_key_register()
+  if M.which_key_queue then
+    local wk_avail, wk = pcall(require, "which-key")
+    if wk_avail then
+      for mode, registration in pairs(M.which_key_queue) do
+        wk.register(registration, { mode = mode })
+      end
+      M.which_key_queue = nil
+    end
+  end
+end
+
+--- Table based API for setting keybindings
+-- @param map_table A nested table where the first key is the vim mode, the second key is the key to map, and the value is the function to set the mapping to
+-- @param base A base set of options to set on every keybinding
+function M.set_mappings(map_table, base)
+  -- iterate over the first keys for each mode
+  base = base or {}
+  for mode, maps in pairs(map_table) do
+    -- iterate over each keybinding set in the current mode
+    for keymap, options in pairs(maps) do
+      -- build the options for the command accordingly
+      if options then
+        local cmd = options
+        local keymap_opts = base
+        if type(options) == "table" then
+          cmd = options[1]
+          keymap_opts = vim.tbl_deep_extend("force", keymap_opts, options)
+          keymap_opts[1] = nil
+        end
+        if not cmd or keymap_opts.name then -- if which-key mapping, queue it
+          if not M.which_key_queue then M.which_key_queue = {} end
+          if not M.which_key_queue[mode] then M.which_key_queue[mode] = {} end
+          M.which_key_queue[mode][keymap] = keymap_opts
+        else -- if not which-key mapping, set it
+          vim.keymap.set(mode, keymap, cmd, keymap_opts)
+        end
+      end
+    end
+  end
+  if package.loaded["which-key"] then M.which_key_register() end -- if which-key is loaded already, register
+end
+
+--- regex used for matching a valid URL/URI string
+local url_matcher =
+  "\\v\\c%(%(h?ttps?|ftp|file|ssh|git)://|[a-z]+[@][a-z]+[.][a-z]+:)%([&:#*@~%_\\-=?!+;/0-9a-z]+%(%([.;/?]|[.][.]+)[&:#*@~%_\\-=?!+/0-9a-z]+|:\\d+|,%(%(%(h?ttps?|ftp|file|ssh|git)://|[a-z]+[@][a-z]+[.][a-z]+:)@![0-9a-z]+))*|\\([&:#*@~%_\\-=?!+;/.0-9a-z]*\\)|\\[[&:#*@~%_\\-=?!+;/.0-9a-z]*\\]|\\{%([&:#*@~%_\\-=?!+;/.0-9a-z]*|\\{[&:#*@~%_\\-=?!+;/.0-9a-z]*})\\})+"
+
+--- Delete the syntax matching rules for URLs/URIs if set
+function M.delete_url_match()
+  for _, match in ipairs(vim.fn.getmatches()) do
+    if match.group == "HighlightURL" then vim.fn.matchdelete(match.id) end
+  end
+end
+
+--- Add syntax matching rules for highlighting URLs/URIs
+function M.set_url_match()
+  M.delete_url_match()
+  if vim.g.highlighturl_enabled then vim.fn.matchadd("HighlightURL", url_matcher, 15) end
+end
+
+--- Run a shell command and capture the output and if the command succeeded or failed
+-- @param cmd the terminal command to execute
+-- @param show_error boolean of whether or not to show an unsuccessful command as an error to the user
+-- @return the result of a successfully executed command or nil
+function M.cmd(cmd, show_error)
+  if vim.fn.has "win32" == 1 then cmd = { "cmd.exe", "/C", cmd } end
+  local result = vim.fn.system(cmd)
+  local success = vim.api.nvim_get_vvar "shell_error" == 0
+  if not success and (show_error == nil or show_error) then
+    vim.api.nvim_err_writeln("Error running command: " .. cmd .. "\nError message:\n" .. result)
+  end
+  return success and result:gsub("[\27\155][][()#;?%d]*[A-PRZcf-ntqry=><~]", "") or nil
+end
+
+return M

users/daniel/configs/system/nvim/nvim/lua/astronvim/utils/lsp.lua

@@ -0,0 +1,377 @@
+--- ### AstroNvim LSP Utils
+--
+-- LSP related utility functions to use within AstroNvim and user configurations.
+--
+-- This module can be loaded with `local lsp_utils = require("astronvim.utils.lsp")`
+--
+-- @module astronvim.utils.lsp
+-- @see astronvim.utils
+-- @copyright 2022
+-- @license GNU General Public License v3.0
+
+local M = {}
+local tbl_contains = vim.tbl_contains
+local tbl_isempty = vim.tbl_isempty
+local user_opts = astronvim.user_opts
+
+local utils = require "astronvim.utils"
+local conditional_func = utils.conditional_func
+local is_available = utils.is_available
+
+local server_config = "lsp.config."
+local setup_handlers = user_opts("lsp.setup_handlers", {
+  function(server, opts) require("lspconfig")[server].setup(opts) end,
+})
+
+M.diagnostics = { [0] = {}, {}, {}, {} }
+
+M.setup_diagnostics = function(signs)
+  local default_diagnostics = astronvim.user_opts("diagnostics", {
+    virtual_text = true,
+    signs = { active = signs },
+    update_in_insert = true,
+    underline = true,
+    severity_sort = true,
+    float = {
+      focused = false,
+      style = "minimal",
+      border = "rounded",
+      source = "always",
+      header = "",
+      prefix = "",
+    },
+  })
+  M.diagnostics = {
+    -- diagnostics off
+    [0] = utils.extend_tbl(
+      default_diagnostics,
+      { underline = false, virtual_text = false, signs = false, update_in_insert = false }
+    ),
+    -- status only
+    utils.extend_tbl(default_diagnostics, { virtual_text = false, signs = false }),
+    -- virtual text off, signs on
+    utils.extend_tbl(default_diagnostics, { virtual_text = false }),
+    -- all diagnostics on
+    default_diagnostics,
+  }
+
+  vim.diagnostic.config(M.diagnostics[vim.g.diagnostics_mode])
+end
+
+M.formatting = user_opts("lsp.formatting", { format_on_save = { enabled = true }, disabled = {} })
+if type(M.formatting.format_on_save) == "boolean" then
+  M.formatting.format_on_save = { enabled = M.formatting.format_on_save }
+end
+
+M.format_opts = vim.deepcopy(M.formatting)
+M.format_opts.disabled = nil
+M.format_opts.format_on_save = nil
+M.format_opts.filter = function(client)
+  local filter = M.formatting.filter
+  local disabled = M.formatting.disabled or {}
+  -- check if client is fully disabled or filtered by function
+  return not (vim.tbl_contains(disabled, client.name) or (type(filter) == "function" and not filter(client)))
+end
+
+--- Helper function to set up a given server with the Neovim LSP client
+-- @param server the name of the server to be setup
+M.setup = function(server)
+  -- if server doesn't exist, set it up from user server definition
+  local config_avail, config = pcall(require, "lspconfig.server_configurations." .. server)
+  if not config_avail or not config.default_config then
+    local server_definition = user_opts(server_config .. server)
+    if server_definition.cmd then require("lspconfig.configs")[server] = { default_config = server_definition } end
+  end
+  local opts = M.config(server)
+  local setup_handler = setup_handlers[server] or setup_handlers[1]
+  if not vim.tbl_contains(astronvim.lsp.skip_setup, server) and setup_handler then setup_handler(server, opts) end
+end
+
+local function add_buffer_autocmd(augroup, bufnr, autocmds)
+  if not vim.tbl_islist(autocmds) then autocmds = { autocmds } end
+  local cmds_found, cmds = pcall(vim.api.nvim_get_autocmds, { group = augroup, buffer = bufnr })
+  if not cmds_found or vim.tbl_isempty(cmds) then
+    vim.api.nvim_create_augroup(augroup, { clear = false })
+    for _, autocmd in ipairs(autocmds) do
+      local events = autocmd.events
+      autocmd.events = nil
+      autocmd.group = augroup
+      autocmd.buffer = bufnr
+      vim.api.nvim_create_autocmd(events, autocmd)
+    end
+  end
+end
+
+--- The `on_attach` function used by AstroNvim
+-- @param client the LSP client details when attaching
+-- @param bufnr the number of the buffer that the LSP client is attaching to
+M.on_attach = function(client, bufnr)
+  local capabilities = client.server_capabilities
+  local lsp_mappings = {
+    n = {
+      ["<leader>ld"] = {
+        function() vim.diagnostic.open_float() end,
+        desc = "Hover diagnostics",
+      },
+      ["[d"] = {
+        function() vim.diagnostic.goto_prev() end,
+        desc = "Previous diagnostic",
+      },
+      ["]d"] = {
+        function() vim.diagnostic.goto_next() end,
+        desc = "Next diagnostic",
+      },
+      ["gl"] = {
+        function() vim.diagnostic.open_float() end,
+        desc = "Hover diagnostics",
+      },
+    },
+    v = {},
+  }
+
+  if is_available "mason-lspconfig.nvim" then
+    lsp_mappings.n["<leader>li"] = { "<cmd>LspInfo<cr>", desc = "LSP information" }
+  end
+
+  if is_available "null-ls.nvim" then
+    lsp_mappings.n["<leader>lI"] = { "<cmd>NullLsInfo<cr>", desc = "Null-ls information" }
+  end
+
+  if capabilities.codeActionProvider then
+    lsp_mappings.n["<leader>la"] = {
+      function() vim.lsp.buf.code_action() end,
+      desc = "LSP code action",
+    }
+    lsp_mappings.v["<leader>la"] = lsp_mappings.n["<leader>la"]
+  end
+
+  if capabilities.codeLensProvider then
+    add_buffer_autocmd("lsp_codelens_refresh", bufnr, {
+      events = { "InsertLeave", "BufEnter" },
+      desc = "Refresh codelens",
+      callback = function()
+        if vim.g.codelens_enabled then vim.lsp.codelens.refresh() end
+      end,
+    })
+    vim.lsp.codelens.refresh()
+    lsp_mappings.n["<leader>ll"] = {
+      function() vim.lsp.codelens.refresh() end,
+      desc = "LSP CodeLens refresh",
+    }
+    lsp_mappings.n["<leader>lL"] = {
+      function() vim.lsp.codelens.run() end,
+      desc = "LSP CodeLens run",
+    }
+  end
+
+  if capabilities.declarationProvider then
+    lsp_mappings.n["gD"] = {
+      function() vim.lsp.buf.declaration() end,
+      desc = "Declaration of current symbol",
+    }
+  end
+
+  if capabilities.definitionProvider then
+    lsp_mappings.n["gd"] = {
+      function() vim.lsp.buf.definition() end,
+      desc = "Show the definition of current symbol",
+    }
+  end
+
+  if capabilities.documentFormattingProvider and not tbl_contains(M.formatting.disabled, client.name) then
+    lsp_mappings.n["<leader>lf"] = {
+      function() vim.lsp.buf.format(M.format_opts) end,
+      desc = "Format buffer",
+    }
+    lsp_mappings.v["<leader>lf"] = lsp_mappings.n["<leader>lf"]
+
+    vim.api.nvim_buf_create_user_command(
+      bufnr,
+      "Format",
+      function() vim.lsp.buf.format(M.format_opts) end,
+      { desc = "Format file with LSP" }
+    )
+    local autoformat = M.formatting.format_on_save
+    local filetype = vim.api.nvim_get_option_value("filetype", { buf = bufnr })
+    if
+      autoformat.enabled
+      and (tbl_isempty(autoformat.allow_filetypes or {}) or tbl_contains(autoformat.allow_filetypes, filetype))
+      and (tbl_isempty(autoformat.ignore_filetypes or {}) or not tbl_contains(autoformat.ignore_filetypes, filetype))
+    then
+      add_buffer_autocmd("lsp_auto_format", bufnr, {
+        events = "BufWritePre",
+        desc = "autoformat on save",
+        callback = function()
+          local autoformat_enabled = vim.b.autoformat_enabled
+          if autoformat_enabled == nil then autoformat_enabled = vim.g.autoformat_enabled end
+          if autoformat_enabled and ((not autoformat.filter) or autoformat.filter(bufnr)) then
+            vim.lsp.buf.format(require("astronvim.utils").extend_tbl(M.format_opts, { bufnr = bufnr }))
+          end
+        end,
+      })
+      lsp_mappings.n["<leader>uf"] = {
+        function() require("astronvim.utils.ui").toggle_buffer_autoformat() end,
+        desc = "Toggle autoformatting (buffer)",
+      }
+      lsp_mappings.n["<leader>uF"] = {
+        function() require("astronvim.utils.ui").toggle_autoformat() end,
+        desc = "Toggle autoformatting (global)",
+      }
+    end
+  end
+
+  if capabilities.documentHighlightProvider then
+    add_buffer_autocmd("lsp_document_highlight", bufnr, {
+      {
+        events = { "CursorHold", "CursorHoldI" },
+        desc = "highlight references when cursor holds",
+        callback = function() vim.lsp.buf.document_highlight() end,
+      },
+      {
+        events = { "CursorMoved", "CursorMovedI" },
+        desc = "clear references when cursor moves",
+        callback = function() vim.lsp.buf.clear_references() end,
+      },
+    })
+  end
+
+  if capabilities.hoverProvider then
+    lsp_mappings.n["K"] = {
+      function() vim.lsp.buf.hover() end,
+      desc = "Hover symbol details",
+    }
+  end
+
+  if capabilities.implementationProvider then
+    lsp_mappings.n["gI"] = {
+      function() vim.lsp.buf.implementation() end,
+      desc = "Implementation of current symbol",
+    }
+  end
+
+  if capabilities.referencesProvider then
+    lsp_mappings.n["gr"] = {
+      function() vim.lsp.buf.references() end,
+      desc = "References of current symbol",
+    }
+    lsp_mappings.n["<leader>lR"] = {
+      function() vim.lsp.buf.references() end,
+      desc = "Search references",
+    }
+  end
+
+  if capabilities.renameProvider then
+    lsp_mappings.n["<leader>lr"] = {
+      function() vim.lsp.buf.rename() end,
+      desc = "Rename current symbol",
+    }
+  end
+
+  if capabilities.signatureHelpProvider then
+    lsp_mappings.n["<leader>lh"] = {
+      function() vim.lsp.buf.signature_help() end,
+      desc = "Signature help",
+    }
+  end
+
+  if capabilities.typeDefinitionProvider then
+    lsp_mappings.n["gT"] = {
+      function() vim.lsp.buf.type_definition() end,
+      desc = "Definition of current type",
+    }
+  end
+
+  if capabilities.workspaceSymbolProvider then
+    lsp_mappings.n["<leader>lG"] = {
+      function() vim.lsp.buf.workspace_symbol() end,
+      desc = "Search workspace symbols",
+    }
+  end
+
+  if is_available "telescope.nvim" then -- setup telescope mappings if available
+    if lsp_mappings.n.gd then lsp_mappings.n.gd[1] = function() require("telescope.builtin").lsp_definitions() end end
+    if lsp_mappings.n.gI then
+      lsp_mappings.n.gI[1] = function() require("telescope.builtin").lsp_implementations() end
+    end
+    if lsp_mappings.n.gr then lsp_mappings.n.gr[1] = function() require("telescope.builtin").lsp_references() end end
+    if lsp_mappings.n["<leader>lR"] then
+      lsp_mappings.n["<leader>lR"][1] = function() require("telescope.builtin").lsp_references() end
+    end
+    if lsp_mappings.n.gT then
+      lsp_mappings.n.gT[1] = function() require("telescope.builtin").lsp_type_definitions() end
+    end
+    if lsp_mappings.n["<leader>lG"] then
+      lsp_mappings.n["<leader>lG"][1] = function() require("telescope.builtin").lsp_workspace_symbols() end
+    end
+  end
+
+  if not vim.tbl_isempty(lsp_mappings.v) then
+    lsp_mappings.v["<leader>l"] = { name = (vim.g.icons_enabled and " " or "") .. "LSP" }
+  end
+  utils.set_mappings(user_opts("lsp.mappings", lsp_mappings), { buffer = bufnr })
+
+  local on_attach_override = user_opts("lsp.on_attach", nil, false)
+  conditional_func(on_attach_override, true, client, bufnr)
+end
+
+--- The default AstroNvim LSP capabilities
+M.capabilities = vim.lsp.protocol.make_client_capabilities()
+M.capabilities.textDocument.completion.completionItem.documentationFormat = { "markdown", "plaintext" }
+M.capabilities.textDocument.completion.completionItem.snippetSupport = true
+M.capabilities.textDocument.completion.completionItem.preselectSupport = true
+M.capabilities.textDocument.completion.completionItem.insertReplaceSupport = true
+M.capabilities.textDocument.completion.completionItem.labelDetailsSupport = true
+M.capabilities.textDocument.completion.completionItem.deprecatedSupport = true
+M.capabilities.textDocument.completion.completionItem.commitCharactersSupport = true
+M.capabilities.textDocument.completion.completionItem.tagSupport = { valueSet = { 1 } }
+M.capabilities.textDocument.completion.completionItem.resolveSupport =
+  { properties = { "documentation", "detail", "additionalTextEdits" } }
+M.capabilities.textDocument.foldingRange = { dynamicRegistration = false, lineFoldingOnly = true }
+M.capabilities = user_opts("lsp.capabilities", M.capabilities)
+M.flags = user_opts "lsp.flags"
+
+--- Get the server configuration for a given language server to be provided to the server's `setup()` call
+-- @param  server_name the name of the server
+-- @return the table of LSP options used when setting up the given language server
+function M.config(server_name)
+  local server = require("lspconfig")[server_name]
+  local lsp_opts = require("astronvim.utils").extend_tbl(
+    { capabilities = server.capabilities, flags = server.flags },
+    { capabilities = M.capabilities, flags = M.flags }
+  )
+  if server_name == "jsonls" then -- by default add json schemas
+    local schemastore_avail, schemastore = pcall(require, "schemastore")
+    if schemastore_avail then
+      lsp_opts.settings = { json = { schemas = schemastore.json.schemas(), validate = { enable = true } } }
+    end
+  end
+  if server_name == "yamlls" then -- by default add yaml schemas
+    local schemastore_avail, schemastore = pcall(require, "schemastore")
+    if schemastore_avail then lsp_opts.settings = { yaml = { schemas = schemastore.yaml.schemas() } } end
+  end
+  if server_name == "lua_ls" then -- by default initialize neodev and disable third party checking
+    pcall(require, "neodev")
+    lsp_opts.before_init = function(param, config)
+      if vim.b.neodev_enabled then
+        for _, astronvim_config in ipairs(astronvim.supported_configs) do
+          if param.rootPath:match(astronvim_config) then
+            table.insert(config.settings.Lua.workspace.library, astronvim.install.home .. "/lua")
+            break
+          end
+        end
+      end
+    end
+    lsp_opts.settings = { Lua = { workspace = { checkThirdParty = false } } }
+  end
+  local opts = user_opts(server_config .. server_name, lsp_opts)
+  local old_on_attach = server.on_attach
+  local user_on_attach = opts.on_attach
+  opts.on_attach = function(client, bufnr)
+    conditional_func(old_on_attach, true, client, bufnr)
+    M.on_attach(client, bufnr)
+    conditional_func(user_on_attach, true, client, bufnr)
+  end
+  return opts
+end
+
+return M

users/daniel/configs/system/nvim/nvim/lua/astronvim/utils/mason.lua

@@ -0,0 +1,99 @@
+--- ### Mason Utils
+--
+-- Mason related utility functions to use within AstroNvim and user configurations.
+--
+-- This module can be loaded with `local mason_utils = require("astronvim.utils.mason")`
+--
+-- @module astronvim.utils.mason
+-- @see astronvim.utils
+-- @copyright 2022
+-- @license GNU General Public License v3.0
+
+local M = {}
+
+local utils = require "astronvim.utils"
+local notify = utils.notify
+local astroevent = utils.event
+
+--- Update a mason package
+-- @param pkg_name string of the name of the package as defined in Mason (Not mason-lspconfig or mason-null-ls)
+-- @param auto_install boolean of whether or not to install a package that is not currently installed (default: True)
+function M.update(pkg_name, auto_install)
+  if auto_install == nil then auto_install = true end
+  local registry_avail, registry = pcall(require, "mason-registry")
+  if not registry_avail then
+    vim.api.nvim_err_writeln "Unable to access mason registry"
+    return
+  end
+
+  local pkg_avail, pkg = pcall(registry.get_package, pkg_name)
+  if not pkg_avail then
+    notify(("Mason: %s is not available"):format(pkg_name), "error")
+  else
+    if not pkg:is_installed() then
+      if auto_install then
+        notify(("Mason: Installing %s"):format(pkg.name))
+        pkg:install()
+      else
+        notify(("Mason: %s not installed"):format(pkg.name), "warn")
+      end
+    else
+      pkg:check_new_version(function(update_available, version)
+        if update_available then
+          notify(("Mason: Updating %s to %s"):format(pkg.name, version.latest_version))
+          pkg:install():on("closed", function() notify(("Mason: Updated %s"):format(pkg.name)) end)
+        else
+          notify(("Mason: No updates available for %s"):format(pkg.name))
+        end
+      end)
+    end
+  end
+end
+
+--- Update all packages in Mason
+function M.update_all()
+  local registry_avail, registry = pcall(require, "mason-registry")
+  if not registry_avail then
+    vim.api.nvim_err_writeln "Unable to access mason registry"
+    return
+  end
+
+  local installed_pkgs = registry.get_installed_packages()
+  local running = #installed_pkgs
+  local no_pkgs = running == 0
+  notify "Mason: Checking for package updates..."
+
+  if no_pkgs then
+    notify "Mason: No updates available"
+    astroevent "MasonUpdateCompleted"
+  else
+    local updated = false
+    for _, pkg in ipairs(installed_pkgs) do
+      pkg:check_new_version(function(update_available, version)
+        if update_available then
+          updated = true
+          notify(("Mason: Updating %s to %s"):format(pkg.name, version.latest_version))
+          pkg:install():on("closed", function()
+            running = running - 1
+            if running == 0 then
+              notify "Mason: Update Complete"
+              astroevent "MasonUpdateCompleted"
+            end
+          end)
+        else
+          running = running - 1
+          if running == 0 then
+            if updated then
+              notify "Mason: Update Complete"
+            else
+              notify "Mason: No updates available"
+            end
+            astroevent "MasonUpdateCompleted"
+          end
+        end
+      end)
+    end
+  end
+end
+
+return M

users/daniel/configs/system/nvim/nvim/lua/astronvim/utils/ui.lua

@@ -0,0 +1,199 @@
+--- ### AstroNvim UI Options
+--
+--  Utility functions for easy UI toggles.
+--
+-- This module can be loaded with `local ui = require("astronvim.utils.ui")`
+--
+-- @module astronvim.utils.ui
+-- @see astronvim.utils
+-- @copyright 2022
+-- @license GNU General Public License v3.0
+
+local M = {}
+
+local function bool2str(bool) return bool and "on" or "off" end
+
+local function ui_notify(str)
+  if vim.g.ui_notifications_enabled then require("astronvim.utils").notify(str) end
+end
+
+--- Toggle notifications for UI toggles
+function M.toggle_ui_notifications()
+  vim.g.ui_notifications_enabled = not vim.g.ui_notifications_enabled
+  ui_notify(string.format("ui notifications %s", bool2str(vim.g.ui_notifications_enabled)))
+end
+
+--- Toggle autopairs
+function M.toggle_autopairs()
+  local ok, autopairs = pcall(require, "nvim-autopairs")
+  if ok then
+    if autopairs.state.disabled then
+      autopairs.enable()
+    else
+      autopairs.disable()
+    end
+    vim.g.autopairs_enabled = autopairs.state.disabled
+    ui_notify(string.format("autopairs %s", bool2str(not autopairs.state.disabled)))
+  else
+    ui_notify "autopairs not available"
+  end
+end
+
+--- Toggle diagnostics
+function M.toggle_diagnostics()
+  vim.g.diagnostics_mode = (vim.g.diagnostics_mode - 1) % 4
+  vim.diagnostic.config(require("astronvim.utils.lsp").diagnostics[vim.g.diagnostics_mode])
+  if vim.g.diagnostics_mode == 0 then
+    ui_notify "diagnostics off"
+  elseif vim.g.diagnostics_mode == 1 then
+    ui_notify "only status diagnostics"
+  elseif vim.g.diagnostics_mode == 2 then
+    ui_notify "virtual text off"
+  else
+    ui_notify "all diagnostics on"
+  end
+end
+
+--- Toggle background="dark"|"light"
+function M.toggle_background()
+  vim.go.background = vim.go.background == "light" and "dark" or "light"
+  ui_notify(string.format("background=%s", vim.go.background))
+end
+
+--- Toggle cmp entrirely
+function M.toggle_cmp()
+  vim.g.cmp_enabled = not vim.g.cmp_enabled
+  local ok, _ = pcall(require, "cmp")
+  ui_notify(ok and string.format("completion %s", bool2str(vim.g.cmp_enabled)) or "completion not available")
+end
+
+--- Toggle auto format
+function M.toggle_autoformat()
+  vim.g.autoformat_enabled = not vim.g.autoformat_enabled
+  ui_notify(string.format("Global autoformatting %s", bool2str(vim.g.autoformat_enabled)))
+end
+
+--- Toggle buffer local auto format
+function M.toggle_buffer_autoformat()
+  local old_val = vim.b.autoformat_enabled
+  if old_val == nil then old_val = vim.g.autoformat_enabled end
+  vim.b.autoformat_enabled = not old_val
+  ui_notify(string.format("Buffer autoformatting %s", bool2str(vim.b.autoformat_enabled)))
+end
+
+--- Toggle codelens refresh
+function M.toggle_codelens()
+  vim.g.codelens_enabled = not vim.g.codelens_enabled
+  ui_notify(string.format("CodeLens refresh %s", bool2str(vim.g.codelens_enabled)))
+end
+
+--- Toggle showtabline=2|0
+function M.toggle_tabline()
+  vim.opt.showtabline = vim.opt.showtabline:get() == 0 and 2 or 0
+  ui_notify(string.format("tabline %s", bool2str(vim.opt.showtabline:get() == 2)))
+end
+
+--- Toggle conceal=2|0
+function M.toggle_conceal()
+  vim.opt.conceallevel = vim.opt.conceallevel:get() == 0 and 2 or 0
+  ui_notify(string.format("conceal %s", bool2str(vim.opt.conceallevel:get() == 2)))
+end
+
+--- Toggle laststatus=3|2|0
+function M.toggle_statusline()
+  local laststatus = vim.opt.laststatus:get()
+  local status
+  if laststatus == 0 then
+    vim.opt.laststatus = 2
+    status = "local"
+  elseif laststatus == 2 then
+    vim.opt.laststatus = 3
+    status = "global"
+  elseif laststatus == 3 then
+    vim.opt.laststatus = 0
+    status = "off"
+  end
+  ui_notify(string.format("statusline %s", status))
+end
+
+--- Toggle signcolumn="auto"|"no"
+function M.toggle_signcolumn()
+  if vim.wo.signcolumn == "no" then
+    vim.wo.signcolumn = "yes"
+  elseif vim.wo.signcolumn == "yes" then
+    vim.wo.signcolumn = "auto"
+  else
+    vim.wo.signcolumn = "no"
+  end
+  ui_notify(string.format("signcolumn=%s", vim.wo.signcolumn))
+end
+
+--- Set the indent and tab related numbers
+function M.set_indent()
+  local input_avail, input = pcall(vim.fn.input, "Set indent value (>0 expandtab, <=0 noexpandtab): ")
+  if input_avail then
+    local indent = tonumber(input)
+    if not indent or indent == 0 then return end
+    vim.bo.expandtab = (indent > 0) -- local to buffer
+    indent = math.abs(indent)
+    vim.bo.tabstop = indent -- local to buffer
+    vim.bo.softtabstop = indent -- local to buffer
+    vim.bo.shiftwidth = indent -- local to buffer
+    ui_notify(string.format("indent=%d %s", indent, vim.bo.expandtab and "expandtab" or "noexpandtab"))
+  end
+end
+
+--- Change the number display modes
+function M.change_number()
+  local number = vim.wo.number -- local to window
+  local relativenumber = vim.wo.relativenumber -- local to window
+  if not number and not relativenumber then
+    vim.wo.number = true
+  elseif number and not relativenumber then
+    vim.wo.relativenumber = true
+  elseif number and relativenumber then
+    vim.wo.number = false
+  else -- not number and relativenumber
+    vim.wo.relativenumber = false
+  end
+  ui_notify(string.format("number %s, relativenumber %s", bool2str(vim.wo.number), bool2str(vim.wo.relativenumber)))
+end
+
+--- Toggle spell
+function M.toggle_spell()
+  vim.wo.spell = not vim.wo.spell -- local to window
+  ui_notify(string.format("spell %s", bool2str(vim.wo.spell)))
+end
+
+--- Toggle paste
+function M.toggle_paste()
+  vim.opt.paste = not vim.opt.paste:get() -- local to window
+  ui_notify(string.format("paste %s", bool2str(vim.opt.paste:get())))
+end
+
+--- Toggle wrap
+function M.toggle_wrap()
+  vim.wo.wrap = not vim.wo.wrap -- local to window
+  ui_notify(string.format("wrap %s", bool2str(vim.wo.wrap)))
+end
+
+--- Toggle syntax highlighting and treesitter
+function M.toggle_syntax()
+  local ts_avail, parsers = pcall(require, "nvim-treesitter.parsers")
+  if vim.g.syntax_on then -- global var for on//off
+    if ts_avail and parsers.has_parser() then vim.cmd.TSBufDisable "highlight" end
+    vim.cmd.syntax "off" -- set vim.g.syntax_on = false
+  else
+    if ts_avail and parsers.has_parser() then vim.cmd.TSBufEnable "highlight" end
+    vim.cmd.syntax "on" -- set vim.g.syntax_on = true
+  end
+  ui_notify(string.format("syntax %s", bool2str(vim.g.syntax_on)))
+end
+
+--- Toggle URL/URI syntax highlighting rules
+function M.toggle_url_match()
+  vim.g.highlighturl_enabled = not vim.g.highlighturl_enabled
+  require("astronvim.utils").set_url_match()
+end
+
+return M

users/daniel/configs/system/nvim/nvim/lua/astronvim/utils/updater.lua

@@ -0,0 +1,312 @@
+--- ### AstroNvim Updater
+--
+-- AstroNvim Updater utilities to use within AstroNvim and user configurations.
+--
+-- This module can also loaded with `local updater = require("astronvim.utils.updater")`
+--
+-- @module astronvim.utils.updater
+-- @see astronvim.utils
+-- @copyright 2022
+-- @license GNU General Public License v3.0
+
+local git = require "astronvim.utils.git"
+
+local M = {}
+
+local utils = require "astronvim.utils"
+local notify = utils.notify
+
+local function echo(messages)
+  -- if no parameter provided, echo a new line
+  messages = messages or { { "\n" } }
+  if type(messages) == "table" then vim.api.nvim_echo(messages, false, {}) end
+end
+
+local function confirm_prompt(messages)
+  if messages then echo(messages) end
+  local confirmed = string.lower(vim.fn.input "(y/n) ") == "y"
+  echo()
+  echo()
+  return confirmed
+end
+
+--- Helper function to generate AstroNvim snapshots (For internal use only)
+-- @param write boolean whether or not to write to the snapshot file (default: false)
+-- @return the plugin specification table of the snapshot
+function M.generate_snapshot(write)
+  local file
+  local prev_snapshot = require(astronvim.updater.snapshot.module)
+  for _, plugin in ipairs(prev_snapshot) do
+    prev_snapshot[plugin[1]] = plugin
+  end
+  local plugins = assert(require("lazy").plugins())
+  local function git_commit(dir)
+    local commit = assert(utils.cmd("git -C " .. dir .. " rev-parse HEAD", false))
+    if commit then return vim.trim(commit) end
+  end
+  if write == true then
+    file = assert(io.open(astronvim.updater.snapshot.path, "w"))
+    file:write "return {\n"
+  end
+  local snapshot = vim.tbl_map(function(plugin)
+    if not plugin[1] and plugin.name == "lazy.nvim" then plugin[1] = "folke/lazy.nvim" end
+    plugin = { plugin[1], commit = git_commit(plugin.dir), version = plugin.version }
+    if prev_snapshot[plugin[1]] and prev_snapshot[plugin[1]].version then
+      plugin.version = prev_snapshot[plugin[1]].version
+    end
+    if file then
+      file:write(("  { %q, "):format(plugin[1]))
+      if plugin.version then
+        file:write(("version = %q "):format(plugin.version))
+      else
+        file:write(("commit = %q "):format(plugin.commit))
+      end
+      file:write "},\n"
+    end
+    return plugin
+  end, plugins)
+  if file then
+    file:write "}"
+    file:close()
+  end
+  return snapshot
+end
+
+--- Get the current AstroNvim version
+-- @param quiet boolean to quietly execute or send a notification
+-- @return the current AstroNvim version string
+function M.version(quiet)
+  local version = astronvim.install.version or git.current_version(false) or "unknown"
+  if astronvim.updater.options.channel ~= "stable" then version = ("nightly (%s)"):format(version) end
+  if version and not quiet then notify("Version: " .. version) end
+  return version
+end
+
+--- Get the full AstroNvim changelog
+-- @param quiet boolean to quietly execute or display the changelog
+-- @return the current AstroNvim changelog table of commit messages
+function M.changelog(quiet)
+  local summary = {}
+  vim.list_extend(summary, git.pretty_changelog(git.get_commit_range()))
+  if not quiet then echo(summary) end
+  return summary
+end
+
+--- Attempt an update of AstroNvim
+-- @param target the target if checking out a specific tag or commit or nil if just pulling
+local function attempt_update(target, opts)
+  -- if updating to a new stable version or a specific commit checkout the provided target
+  if opts.channel == "stable" or opts.commit then
+    return git.checkout(target, false)
+  -- if no target, pull the latest
+  else
+    return git.pull(false)
+  end
+end
+
+--- Cancelled update message
+local cancelled_message = { { "Update cancelled", "WarningMsg" } }
+
+--- Sync Packer and then update Mason
+function M.update_packages()
+  require("lazy").sync { wait = true }
+  require("astronvim.utils.mason").update_all()
+end
+
+--- Create a table of options for the currently installed AstroNvim version
+-- @return the table of updater options
+function M.create_rollback(write)
+  local snapshot = { branch = git.current_branch(), commit = git.local_head() }
+  if snapshot.branch == "HEAD" then snapshot.branch = "main" end
+  snapshot.remote = git.branch_remote(snapshot.branch)
+  snapshot.remotes = { [snapshot.remote] = git.remote_url(snapshot.remote) }
+
+  if write == true then
+    local file = assert(io.open(astronvim.updater.rollback_file, "w"))
+    file:write("return " .. vim.inspect(snapshot, { newline = " ", indent = "" }))
+    file:close()
+  end
+
+  return snapshot
+end
+
+--- AstroNvim's rollback to saved previous version function
+function M.rollback()
+  local rollback_avail, rollback_opts = pcall(dofile, astronvim.updater.rollback_file)
+  if not rollback_avail then
+    notify("No rollback file available", "error")
+    return
+  end
+  M.update(rollback_opts)
+end
+
+--- AstroNvim's updater function
+function M.update(opts)
+  if not opts then opts = astronvim.updater.options end
+  opts = require("astronvim.utils").extend_tbl({ remote = "origin", show_changelog = true, auto_quit = false }, opts)
+  -- if the git command is not available, then throw an error
+  if not git.available() then
+    notify(
+      "git command is not available, please verify it is accessible in a command line. This may be an issue with your PATH",
+      "error"
+    )
+    return
+  end
+
+  -- if installed with an external package manager, disable the internal updater
+  if not git.is_repo() then
+    notify("Updater not available for non-git installations", "error")
+    return
+  end
+  -- set up any remotes defined by the user if they do not exist
+  for remote, entry in pairs(opts.remotes and opts.remotes or {}) do
+    local url = git.parse_remote_url(entry)
+    local current_url = git.remote_url(remote, false)
+    local check_needed = false
+    if not current_url then
+      git.remote_add(remote, url)
+      check_needed = true
+    elseif
+      current_url ~= url
+      and confirm_prompt {
+        { "Remote " },
+        { remote, "Title" },
+        { " is currently set to " },
+        { current_url, "WarningMsg" },
+        { "\nWould you like us to set it to " },
+        { url, "String" },
+        { "?" },
+      }
+    then
+      git.remote_update(remote, url)
+      check_needed = true
+    end
+    if check_needed and git.remote_url(remote, false) ~= url then
+      vim.api.nvim_err_writeln("Error setting up remote " .. remote .. " to " .. url)
+      return
+    end
+  end
+  local is_stable = opts.channel == "stable"
+  if is_stable then
+    opts.branch = "main"
+  elseif not opts.branch then
+    opts.branch = "nightly"
+  end
+  -- fetch the latest remote
+  if not git.fetch(opts.remote) then
+    vim.api.nvim_err_writeln("Error fetching remote: " .. opts.remote)
+    return
+  end
+  -- switch to the necessary branch only if not on the stable channel
+  if not is_stable then
+    local local_branch = (opts.remote == "origin" and "" or (opts.remote .. "_")) .. opts.branch
+    if git.current_branch() ~= local_branch then
+      echo {
+        { "Switching to branch: " },
+        { opts.remote .. "/" .. opts.branch .. "\n\n", "String" },
+      }
+      if not git.checkout(local_branch, false) then
+        git.checkout("-b " .. local_branch .. " " .. opts.remote .. "/" .. opts.branch, false)
+      end
+    end
+    -- check if the branch was switched to successfully
+    if git.current_branch() ~= local_branch then
+      vim.api.nvim_err_writeln("Error checking out branch: " .. opts.remote .. "/" .. opts.branch)
+      return
+    end
+  end
+  local source = git.local_head() -- calculate current commit
+  local target -- calculate target commit
+  if is_stable then -- if stable get tag commit
+    local version_search = opts.version or "latest"
+    opts.version = git.latest_version(git.get_versions(version_search))
+    if not opts.version then -- continue only if stable version is found
+      vim.api.nvim_err_writeln("Error finding version: " .. version_search)
+      return
+    end
+    target = git.tag_commit(opts.version)
+  elseif opts.commit then -- if commit specified use it
+    target = git.branch_contains(opts.remote, opts.branch, opts.commit) and opts.commit or nil
+  else -- get most recent commit
+    target = git.remote_head(opts.remote, opts.branch)
+  end
+  if not source or not target then -- continue if current and target commits were found
+    vim.api.nvim_err_writeln "Error checking for updates"
+    return
+  elseif source == target then
+    echo { { "No updates available", "String" } }
+    return
+  elseif -- prompt user if they want to accept update
+    not opts.skip_prompts
+    and not confirm_prompt {
+      { "Update available to ", "Title" },
+      { is_stable and opts.version or target, "String" },
+      { "\nUpdating requires a restart, continue?" },
+    }
+  then
+    echo(cancelled_message)
+    return
+  else -- perform update
+    M.create_rollback(true) -- create rollback file before updating
+    -- calculate and print the changelog
+    local changelog = git.get_commit_range(source, target)
+    local breaking = git.breaking_changes(changelog)
+    local breaking_prompt = { { "Update contains the following breaking changes:\n", "WarningMsg" } }
+    vim.list_extend(breaking_prompt, git.pretty_changelog(breaking))
+    vim.list_extend(breaking_prompt, { { "\nWould you like to continue?" } })
+    if #breaking > 0 and not opts.skip_prompts and not confirm_prompt(breaking_prompt) then
+      echo(cancelled_message)
+      return
+    end
+    -- attempt an update
+    local updated = attempt_update(target, opts)
+    -- check for local file conflicts and prompt user to continue or abort
+    if
+      not updated
+      and not opts.skip_prompts
+      and not confirm_prompt {
+        { "Unable to pull due to local modifications to base files.\n", "ErrorMsg" },
+        { "Reset local files and continue?" },
+      }
+    then
+      echo(cancelled_message)
+      return
+    -- if continued and there were errors reset the base config and attempt another update
+    elseif not updated then
+      git.hard_reset(source)
+      updated = attempt_update(target, opts)
+    end
+    -- if update was unsuccessful throw an error
+    if not updated then
+      vim.api.nvim_err_writeln "Error occurred performing update"
+      return
+    end
+    -- print a summary of the update with the changelog
+    local summary = {
+      { "AstroNvim updated successfully to ", "Title" },
+      { git.current_version(), "String" },
+      { "!\n", "Title" },
+      {
+        opts.auto_quit and "AstroNvim will now update plugins and quit.\n\n"
+          or "After plugins update, please restart.\n\n",
+        "WarningMsg",
+      },
+    }
+    if opts.show_changelog and #changelog > 0 then
+      vim.list_extend(summary, { { "Changelog:\n", "Title" } })
+      vim.list_extend(summary, git.pretty_changelog(changelog))
+    end
+    echo(summary)
+
+    -- if the user wants to auto quit, create an autocommand to quit AstroNvim on the update completing
+    if opts.auto_quit then
+      vim.api.nvim_create_autocmd("User", { pattern = "AstroUpdateComplete", command = "quitall" })
+    end
+
+    require("lazy.core.plugin").load() -- force immediate reload of lazy
+    require("lazy").sync { wait = true } -- sync new plugin spec changes
+    utils.event "UpdateComplete"
+  end
+end
+
+return M

users/daniel/configs/system/nvim/nvim/lua/lazy_snapshot.lua

@@ -0,0 +1,51 @@
+return {
+  { "AstroNvim/astrotheme", version = "^1.1" },
+  { "JoosepAlviste/nvim-ts-context-commentstring", commit = "729d83ecb990dc2b30272833c213cc6d49ed5214" },
+  { "L3MON4D3/LuaSnip", version = "^1" },
+  { "MunifTanjim/nui.nvim", commit = "0dc148c6ec06577fcf06cbab3b7dac96d48ba6be" },
+  { "NMAC427/guess-indent.nvim", commit = "c37467baa1a51b74ed767cbe0540fce44e03d828" },
+  { "NvChad/nvim-colorizer.lua", commit = "dde3084106a70b9a79d48f426f6d6fec6fd203f7" },
+  { "Shatur/neovim-session-manager", commit = "e7a2cbf56b5fd3a223f2774b535499fc62eca6ef" },
+  { "akinsho/toggleterm.nvim", commit = "c8e982ad2739eeb0b13d0fecb14820c9bf5e3da0" },
+  { "b0o/SchemaStore.nvim", commit = "5173267a218675f123be958e3d2eb770f8a425de" },
+  { "famiu/bufdelete.nvim", commit = "8933abc09df6c381d47dc271b1ee5d266541448e" },
+  { "folke/lazy.nvim", version = "^9" },
+  { "folke/neodev.nvim", version = "^2" },
+  { "folke/which-key.nvim", version = "^1" },
+  { "goolord/alpha-nvim", commit = "3847d6baf74da61e57a13e071d8ca185f104dc96" },
+  { "hrsh7th/cmp-buffer", commit = "3022dbc9166796b644a841a02de8dd1cc1d311fa" },
+  { "hrsh7th/cmp-nvim-lsp", commit = "0e6b2ed705ddcff9738ec4ea838141654f12eeef" },
+  { "hrsh7th/cmp-path", commit = "91ff86cd9c29299a64f968ebb45846c485725f23" },
+  { "hrsh7th/nvim-cmp", commit = "a9c701fa7e12e9257b3162000e5288a75d280c28" },
+  { "jay-babu/mason-null-ls.nvim", version = "^1" },
+  { "jay-babu/mason-nvim-dap.nvim", version = "^1" },
+  { "jose-elias-alvarez/null-ls.nvim", commit = "2fcc10637b325e656d45a760901e1e05170e36c9" },
+  { "kevinhwang91/nvim-ufo", version = "^1" },
+  { "kevinhwang91/promise-async", commit = "7fa127fa80e7d4d447e0e2c78e99af4355f4247b" },
+  { "lewis6991/gitsigns.nvim", version = "^0.6" },
+  { "lukas-reineke/indent-blankline.nvim", version = "^2" },
+  { "max397574/better-escape.nvim", commit = "426d29708064d5b1bfbb040424651c92af1f3f64" },
+  { "mfussenegger/nvim-dap", version = "^0.5" },
+  { "mrjones2014/smart-splits.nvim", commit = "52b521618511b3a874255c8a717ace7155fd5f21" },
+  { "neovim/nvim-lspconfig", commit = "63f4c0082f007d2356df4bc335f55e6d414da89c" },
+  { "numToStr/Comment.nvim", commit = "8d3aa5c22c2d45e788c7a5fe13ad77368b783c20" },
+  { "nvim-lua/plenary.nvim", commit = "253d34830709d690f013daf2853a9d21ad7accab" },
+  { "nvim-neo-tree/neo-tree.nvim", version = "^2" },
+  { "nvim-telescope/telescope-fzf-native.nvim", commit = "580b6c48651cabb63455e97d7e131ed557b8c7e2" },
+  { "nvim-telescope/telescope.nvim", version = "v0.1" },
+  { "nvim-tree/nvim-web-devicons", commit = "f1b1cee3a561590a6c1637a9326c406f6e4af914" },
+  { "nvim-treesitter/nvim-treesitter", commit = "fa0644667ea7ee7a72efdb69c471de4953a11019" },
+  { "onsails/lspkind.nvim", commit = "c68b3a003483cf382428a43035079f78474cd11e" },
+  { "rafamadriz/friendly-snippets", commit = "2f5b8a41659a19bd602497a35da8d81f1e88f6d9" },
+  { "rcarriga/nvim-dap-ui", version = "^3" },
+  { "rcarriga/nvim-notify", version = "^3" },
+  { "rebelot/heirline.nvim", commit = "a7cc90b6ef4b599fef8f0d61a88c389bfd7fdb10" },
+  { "s1n7ax/nvim-window-picker", version = "^1" },
+  { "saadparwaiz1/cmp_luasnip", commit = "18095520391186d634a0045dacaa346291096566" },
+  { "stevearc/aerial.nvim", commit = "5b788392ec571621891e1b73887af5ac12056610" },
+  { "stevearc/dressing.nvim", commit = "5f44f829481640be0f96759c965ae22a3bcaf7ce" },
+  { "williamboman/mason-lspconfig.nvim", commit = "3924f2d264097b2caf13e713485dbc3e9d616574" },
+  { "williamboman/mason.nvim", commit = "87c9453cd91da3bba1076fa578a72439fbc4d311" },
+  { "windwp/nvim-autopairs", commit = "e755f366721bc9e189ddecd39554559045ac0a18" },
+  { "windwp/nvim-ts-autotag", commit = "fdefe46c6807441460f11f11a167a2baf8e4534b" },
+}

users/daniel/configs/system/nvim/nvim/lua/plugins/alpha.lua

@@ -0,0 +1,37 @@
+return {
+  "goolord/alpha-nvim",
+  cmd = "Alpha",
+  opts = function()
+    local dashboard = require "alpha.themes.dashboard"
+    dashboard.section.header.val = {
+      " █████  ███████ ████████ ██████   ██████",
+      "██   ██ ██         ██    ██   ██ ██    ██",
+      "███████ ███████    ██    ██████  ██    ██",
+      "██   ██      ██    ██    ██   ██ ██    ██",
+      "██   ██ ███████    ██    ██   ██  ██████",
+      " ",
+      "    ███    ██ ██    ██ ██ ███    ███",
+      "    ████   ██ ██    ██ ██ ████  ████",
+      "    ██ ██  ██ ██    ██ ██ ██ ████ ██",
+      "    ██  ██ ██  ██  ██  ██ ██  ██  ██",
+      "    ██   ████   ████   ██ ██      ██",
+    }
+    dashboard.section.header.opts.hl = "DashboardHeader"
+
+    local button = require("astronvim.utils").alpha_button
+    dashboard.section.buttons.val = {
+      button("LDR n", "  New File  "),
+      button("LDR f f", "  Find File  "),
+      button("LDR f o", "  Recents  "),
+      button("LDR f w", "  Find Word  "),
+      button("LDR f '", "  Bookmarks  "),
+      button("LDR S l", "  Last Session  "),
+    }
+
+    dashboard.config.layout[1].val = vim.fn.max { 2, vim.fn.floor(vim.fn.winheight(0) * 0.2) }
+    dashboard.config.layout[3].val = 5
+    dashboard.config.opts.noautocmd = true
+    return dashboard
+  end,
+  config = require "plugins.configs.alpha",
+}

users/daniel/configs/system/nvim/nvim/lua/plugins/cmp.lua

@@ -0,0 +1,103 @@
+return {
+  {
+    "L3MON4D3/LuaSnip",
+    dependencies = { "rafamadriz/friendly-snippets" },
+    config = require "plugins.configs.luasnip",
+  },
+  {
+    "hrsh7th/nvim-cmp",
+    commit = "a9c701fa7e12e9257b3162000e5288a75d280c28", -- https://github.com/hrsh7th/nvim-cmp/issues/1382
+    dependencies = {
+      "saadparwaiz1/cmp_luasnip",
+      "hrsh7th/cmp-buffer",
+      "hrsh7th/cmp-path",
+      "hrsh7th/cmp-nvim-lsp",
+    },
+    event = "InsertEnter",
+    opts = function()
+      local cmp = require "cmp"
+      local snip_status_ok, luasnip = pcall(require, "luasnip")
+      local lspkind_status_ok, lspkind = pcall(require, "lspkind")
+      if not snip_status_ok then return end
+      local border_opts = {
+        border = "single",
+        winhighlight = "Normal:Normal,FloatBorder:FloatBorder,CursorLine:Visual,Search:None",
+      }
+
+      local function has_words_before()
+        local line, col = unpack(vim.api.nvim_win_get_cursor(0))
+        return col ~= 0 and vim.api.nvim_buf_get_lines(0, line - 1, line, true)[1]:sub(col, col):match "%s" == nil
+      end
+
+      return {
+        enabled = function()
+          if vim.api.nvim_get_option_value("buftype", { buf = 0 }) == "prompt" then return false end
+          return vim.g.cmp_enabled
+        end,
+        preselect = cmp.PreselectMode.None,
+        formatting = {
+          fields = { "kind", "abbr", "menu" },
+          format = lspkind_status_ok and lspkind.cmp_format(astronvim.lspkind) or nil,
+        },
+        snippet = {
+          expand = function(args) luasnip.lsp_expand(args.body) end,
+        },
+        duplicates = {
+          nvim_lsp = 1,
+          luasnip = 1,
+          cmp_tabnine = 1,
+          buffer = 1,
+          path = 1,
+        },
+        confirm_opts = {
+          behavior = cmp.ConfirmBehavior.Replace,
+          select = false,
+        },
+        window = {
+          completion = cmp.config.window.bordered(border_opts),
+          documentation = cmp.config.window.bordered(border_opts),
+        },
+        mapping = {
+          ["<Up>"] = cmp.mapping.select_prev_item { behavior = cmp.SelectBehavior.Select },
+          ["<Down>"] = cmp.mapping.select_next_item { behavior = cmp.SelectBehavior.Select },
+          ["<C-p>"] = cmp.mapping.select_prev_item { behavior = cmp.SelectBehavior.Insert },
+          ["<C-n>"] = cmp.mapping.select_next_item { behavior = cmp.SelectBehavior.Insert },
+          ["<C-k>"] = cmp.mapping.select_prev_item { behavior = cmp.SelectBehavior.Insert },
+          ["<C-j>"] = cmp.mapping.select_next_item { behavior = cmp.SelectBehavior.Insert },
+          ["<C-u>"] = cmp.mapping(cmp.mapping.scroll_docs(-4), { "i", "c" }),
+          ["<C-d>"] = cmp.mapping(cmp.mapping.scroll_docs(4), { "i", "c" }),
+          ["<C-Space>"] = cmp.mapping(cmp.mapping.complete(), { "i", "c" }),
+          ["<C-y>"] = cmp.config.disable,
+          ["<C-e>"] = cmp.mapping { i = cmp.mapping.abort(), c = cmp.mapping.close() },
+          ["<CR>"] = cmp.mapping.confirm { select = false },
+          ["<Tab>"] = cmp.mapping(function(fallback)
+            if cmp.visible() then
+              cmp.select_next_item()
+            elseif luasnip.expand_or_jumpable() then
+              luasnip.expand_or_jump()
+            elseif has_words_before() then
+              cmp.complete()
+            else
+              fallback()
+            end
+          end, { "i", "s" }),
+          ["<S-Tab>"] = cmp.mapping(function(fallback)
+            if cmp.visible() then
+              cmp.select_prev_item()
+            elseif luasnip.jumpable(-1) then
+              luasnip.jump(-1)
+            else
+              fallback()
+            end
+          end, { "i", "s" }),
+        },
+        sources = cmp.config.sources {
+          { name = "nvim_lsp", priority = 1000 },
+          { name = "luasnip", priority = 750 },
+          { name = "buffer", priority = 500 },
+          { name = "path", priority = 250 },
+        },
+      }
+    end,
+  },
+}

users/daniel/configs/system/nvim/nvim/lua/plugins/configs/alpha.lua

@@ -0,0 +1,13 @@
+return function(_, opts)
+  require("alpha").setup(opts.config)
+
+  vim.api.nvim_create_autocmd("UIEnter", {
+    callback = function()
+      local stats = require("lazy").stats()
+      local ms = math.floor(stats.startuptime * 100 + 0.5) / 100
+      opts.section.footer.val =
+        { " ", " ", " ", "AstroNvim loaded " .. stats.count .. " plugins   in " .. ms .. "ms" }
+      opts.section.footer.opts.hl = "DashboardFooter"
+    end,
+  })
+end

users/daniel/configs/system/nvim/nvim/lua/plugins/configs/guess-indent.lua

@@ -0,0 +1,4 @@
+return function(_, opts)
+  require("guess-indent").setup(opts)
+  vim.cmd.lua { args = { "require('guess-indent').set_from_buffer('auto_cmd')" }, mods = { silent = true } }
+end

users/daniel/configs/system/nvim/nvim/lua/plugins/configs/heirline.lua

@@ -0,0 +1,119 @@
+return function(_, opts)
+  local heirline = require "heirline"
+  local status = require "astronvim.utils.status"
+  local C = status.env.fallback_colors
+  local get_hlgroup = require("astronvim.utils").get_hlgroup
+
+  local function setup_colors()
+    local Normal = get_hlgroup("Normal", { fg = C.fg, bg = C.bg })
+    local Comment = get_hlgroup("Comment", { fg = C.bright_grey, bg = C.bg })
+    local Error = get_hlgroup("Error", { fg = C.red, bg = C.bg })
+    local StatusLine = get_hlgroup("StatusLine", { fg = C.fg, bg = C.dark_bg })
+    local TabLine = get_hlgroup("TabLine", { fg = C.grey, bg = C.none })
+    local TabLineSel = get_hlgroup("TabLineSel", { fg = C.fg, bg = C.none })
+    local WinBar = get_hlgroup("WinBar", { fg = C.bright_grey, bg = C.bg })
+    local WinBarNC = get_hlgroup("WinBarNC", { fg = C.grey, bg = C.bg })
+    local Conditional = get_hlgroup("Conditional", { fg = C.bright_purple, bg = C.dark_bg })
+    local String = get_hlgroup("String", { fg = C.green, bg = C.dark_bg })
+    local TypeDef = get_hlgroup("TypeDef", { fg = C.yellow, bg = C.dark_bg })
+    local GitSignsAdd = get_hlgroup("GitSignsAdd", { fg = C.green, bg = C.dark_bg })
+    local GitSignsChange = get_hlgroup("GitSignsChange", { fg = C.orange, bg = C.dark_bg })
+    local GitSignsDelete = get_hlgroup("GitSignsDelete", { fg = C.bright_red, bg = C.dark_bg })
+    local DiagnosticError = get_hlgroup("DiagnosticError", { fg = C.bright_red, bg = C.dark_bg })
+    local DiagnosticWarn = get_hlgroup("DiagnosticWarn", { fg = C.orange, bg = C.dark_bg })
+    local DiagnosticInfo = get_hlgroup("DiagnosticInfo", { fg = C.white, bg = C.dark_bg })
+    local DiagnosticHint = get_hlgroup("DiagnosticHint", { fg = C.bright_yellow, bg = C.dark_bg })
+    local HeirlineInactive = get_hlgroup("HeirlineInactive", { bg = nil }).bg
+      or status.hl.lualine_mode("inactive", C.dark_grey)
+    local HeirlineNormal = get_hlgroup("HeirlineNormal", { bg = nil }).bg or status.hl.lualine_mode("normal", C.blue)
+    local HeirlineInsert = get_hlgroup("HeirlineInsert", { bg = nil }).bg or status.hl.lualine_mode("insert", C.green)
+    local HeirlineVisual = get_hlgroup("HeirlineVisual", { bg = nil }).bg or status.hl.lualine_mode("visual", C.purple)
+    local HeirlineReplace = get_hlgroup("HeirlineReplace", { bg = nil }).bg
+      or status.hl.lualine_mode("replace", C.bright_red)
+    local HeirlineCommand = get_hlgroup("HeirlineCommand", { bg = nil }).bg
+      or status.hl.lualine_mode("command", C.bright_yellow)
+    local HeirlineTerminal = get_hlgroup("HeirlineTerminal", { bg = nil }).bg
+      or status.hl.lualine_mode("insert", HeirlineInsert)
+
+    local colors = astronvim.user_opts("heirline.colors", {
+      close_fg = Error.fg,
+      fg = StatusLine.fg,
+      bg = StatusLine.bg,
+      section_fg = StatusLine.fg,
+      section_bg = StatusLine.bg,
+      git_branch_fg = Conditional.fg,
+      mode_fg = StatusLine.bg,
+      treesitter_fg = String.fg,
+      scrollbar = TypeDef.fg,
+      git_added = GitSignsAdd.fg,
+      git_changed = GitSignsChange.fg,
+      git_removed = GitSignsDelete.fg,
+      diag_ERROR = DiagnosticError.fg,
+      diag_WARN = DiagnosticWarn.fg,
+      diag_INFO = DiagnosticInfo.fg,
+      diag_HINT = DiagnosticHint.fg,
+      winbar_fg = WinBar.fg,
+      winbar_bg = WinBar.bg,
+      winbarnc_fg = WinBarNC.fg,
+      winbarnc_bg = WinBarNC.bg,
+      tabline_bg = StatusLine.bg,
+      tabline_fg = StatusLine.bg,
+      buffer_fg = Comment.fg,
+      buffer_path_fg = WinBarNC.fg,
+      buffer_close_fg = Comment.fg,
+      buffer_bg = StatusLine.bg,
+      buffer_active_fg = Normal.fg,
+      buffer_active_path_fg = WinBarNC.fg,
+      buffer_active_close_fg = Error.fg,
+      buffer_active_bg = Normal.bg,
+      buffer_visible_fg = Normal.fg,
+      buffer_visible_path_fg = WinBarNC.fg,
+      buffer_visible_close_fg = Error.fg,
+      buffer_visible_bg = Normal.bg,
+      buffer_overflow_fg = Comment.fg,
+      buffer_overflow_bg = StatusLine.bg,
+      buffer_picker_fg = Error.fg,
+      tab_close_fg = Error.fg,
+      tab_close_bg = StatusLine.bg,
+      tab_fg = TabLine.fg,
+      tab_bg = TabLine.bg,
+      tab_active_fg = TabLineSel.fg,
+      tab_active_bg = TabLineSel.bg,
+      inactive = HeirlineInactive,
+      normal = HeirlineNormal,
+      insert = HeirlineInsert,
+      visual = HeirlineVisual,
+      replace = HeirlineReplace,
+      command = HeirlineCommand,
+      terminal = HeirlineTerminal,
+    })
+
+    for _, section in ipairs {
+      "git_branch",
+      "file_info",
+      "git_diff",
+      "diagnostics",
+      "lsp",
+      "macro_recording",
+      "mode",
+      "cmd_info",
+      "treesitter",
+      "nav",
+    } do
+      if not colors[section .. "_bg"] then colors[section .. "_bg"] = colors["section_bg"] end
+      if not colors[section .. "_fg"] then colors[section .. "_fg"] = colors["section_fg"] end
+    end
+    return colors
+  end
+
+  heirline.load_colors(setup_colors())
+  heirline.setup(opts)
+
+  local augroup = vim.api.nvim_create_augroup("Heirline", { clear = true })
+  vim.api.nvim_create_autocmd("User", {
+    pattern = "AstroColorScheme",
+    group = augroup,
+    desc = "Refresh heirline colors",
+    callback = function() require("heirline.utils").on_colorscheme(setup_colors()) end,
+  })
+end

users/daniel/configs/system/nvim/nvim/lua/plugins/configs/lspconfig.lua

@@ -0,0 +1,36 @@
+return function(_, _)
+  local lsp = require "astronvim.utils.lsp"
+  local get_icon = require("astronvim.utils").get_icon
+  local signs = {
+    { name = "DiagnosticSignError", text = get_icon "DiagnosticError", texthl = "DiagnosticSignError" },
+    { name = "DiagnosticSignWarn", text = get_icon "DiagnosticWarn", texthl = "DiagnosticSignWarn" },
+    { name = "DiagnosticSignHint", text = get_icon "DiagnosticHint", texthl = "DiagnosticSignHint" },
+    { name = "DiagnosticSignInfo", text = get_icon "DiagnosticInfo", texthl = "DiagnosticSignInfo" },
+    { name = "DapStopped", text = get_icon "DapStopped", texthl = "DiagnosticWarn" },
+    { name = "DapBreakpoint", text = get_icon "DapBreakpoint", texthl = "DiagnosticInfo" },
+    { name = "DapBreakpointRejected", text = get_icon "DapBreakpointRejected", texthl = "DiagnosticError" },
+    { name = "DapBreakpointCondition", text = get_icon "DapBreakpointCondition", texthl = "DiagnosticInfo" },
+    { name = "DapLogPoint", text = get_icon "DapLogPoint", texthl = "DiagnosticInfo" },
+  }
+
+  for _, sign in ipairs(signs) do
+    vim.fn.sign_define(sign.name, sign)
+  end
+  lsp.setup_diagnostics(signs)
+
+  if vim.g.lsp_handlers_enabled then
+    vim.lsp.handlers["textDocument/hover"] = vim.lsp.with(vim.lsp.handlers.hover, { border = "rounded" })
+    vim.lsp.handlers["textDocument/signatureHelp"] =
+      vim.lsp.with(vim.lsp.handlers.signature_help, { border = "rounded" })
+  end
+  local setup_servers = function()
+    vim.tbl_map(require("astronvim.utils.lsp").setup, astronvim.user_opts "lsp.servers")
+    vim.api.nvim_exec_autocmds("FileType", {})
+    require("astronvim.utils").event "LspSetup"
+  end
+  if require("astronvim.utils").is_available "mason-lspconfig.nvim" then
+    vim.api.nvim_create_autocmd("User", { pattern = "AstroMasonLspSetup", once = true, callback = setup_servers })
+  else
+    setup_servers()
+  end
+end

users/daniel/configs/system/nvim/nvim/lua/plugins/configs/lspkind.lua

@@ -0,0 +1,4 @@
+return function(_, opts)
+  astronvim.lspkind = opts
+  require("lspkind").init(opts)
+end

users/daniel/configs/system/nvim/nvim/lua/plugins/configs/luasnip.lua

@@ -0,0 +1,4 @@
+return function(_, opts)
+  if opts then require("luasnip").config.setup(opts) end
+  vim.tbl_map(function(type) require("luasnip.loaders.from_" .. type).lazy_load() end, { "vscode", "snipmate", "lua" })
+end

users/daniel/configs/system/nvim/nvim/lua/plugins/configs/mason-lspconfig.lua

@@ -0,0 +1,8 @@
+return function(_, opts)
+  local mason_lspconfig = require "mason-lspconfig"
+  mason_lspconfig.setup(opts)
+  mason_lspconfig.setup_handlers {
+    function(server) require("astronvim.utils.lsp").setup(server) end,
+  }
+  require("astronvim.utils").event "MasonLspSetup"
+end

users/daniel/configs/system/nvim/nvim/lua/plugins/configs/mason-null-ls.lua

@@ -0,0 +1,5 @@
+return function(_, opts)
+  local mason_null_ls = require "mason-null-ls"
+  mason_null_ls.setup(opts)
+  mason_null_ls.setup_handlers {}
+end

users/daniel/configs/system/nvim/nvim/lua/plugins/configs/mason-nvim-dap.lua

@@ -0,0 +1,5 @@
+return function(_, opts)
+  local mason_nvim_dap = require "mason-nvim-dap"
+  mason_nvim_dap.setup(opts)
+  mason_nvim_dap.setup_handlers {}
+end

users/daniel/configs/system/nvim/nvim/lua/plugins/configs/mason.lua

@@ -0,0 +1,6 @@
+return function(_, opts)
+  require("mason").setup(opts)
+  for _, plugin in ipairs { "mason-lspconfig", "mason-null-ls", "mason-nvim-dap" } do
+    pcall(require, plugin)
+  end
+end

users/daniel/configs/system/nvim/nvim/lua/plugins/configs/notify.lua

@@ -0,0 +1,5 @@
+return function(_, opts)
+  local notify = require "notify"
+  notify.setup(opts)
+  vim.notify = notify
+end

users/daniel/configs/system/nvim/nvim/lua/plugins/configs/nvim-autopairs.lua

@@ -0,0 +1,10 @@
+return function(_, opts)
+  local npairs = require "nvim-autopairs"
+  npairs.setup(opts)
+
+  if not vim.g.autopairs_enabled then npairs.disable() end
+  local cmp_status_ok, cmp = pcall(require, "cmp")
+  if cmp_status_ok then
+    cmp.event:on("confirm_done", require("nvim-autopairs.completion.cmp").on_confirm_done { tex = false })
+  end
+end

users/daniel/configs/system/nvim/nvim/lua/plugins/configs/nvim-dap-ui.lua

@@ -0,0 +1,7 @@
+return function(_, opts)
+  local dap, dapui = require "dap", require "dapui"
+  dap.listeners.after.event_initialized["dapui_config"] = function() dapui.open() end
+  dap.listeners.before.event_terminated["dapui_config"] = function() dapui.close() end
+  dap.listeners.before.event_exited["dapui_config"] = function() dapui.close() end
+  dapui.setup(opts)
+end

users/daniel/configs/system/nvim/nvim/lua/plugins/configs/nvim-treesitter.lua

@@ -0,0 +1 @@
+return function(_, opts) require("nvim-treesitter.configs").setup(opts) end

users/daniel/configs/system/nvim/nvim/lua/plugins/configs/nvim-web-devicons.lua

@@ -0,0 +1,4 @@
+return function(_, opts)
+  require("nvim-web-devicons").set_default_icon(require("astronvim.utils").get_icon "DefaultFile", "#6d8086", "66")
+  require("nvim-web-devicons").set_icon(opts)
+end

users/daniel/configs/system/nvim/nvim/lua/plugins/configs/telescope.lua

@@ -0,0 +1,9 @@
+return function(_, opts)
+  local telescope = require "telescope"
+  telescope.setup(opts)
+  local utils = require "astronvim.utils"
+  local conditional_func = utils.conditional_func
+  conditional_func(telescope.load_extension, pcall(require, "notify"), "notify")
+  conditional_func(telescope.load_extension, pcall(require, "aerial"), "aerial")
+  conditional_func(telescope.load_extension, utils.is_available "telescope-fzf-native.nvim", "fzf")
+end

users/daniel/configs/system/nvim/nvim/lua/plugins/configs/which-key.lua

@@ -0,0 +1,4 @@
+return function(_, opts)
+  require("which-key").setup(opts)
+  require("astronvim.utils").which_key_register()
+end

users/daniel/configs/system/nvim/nvim/lua/plugins/core.lua

@@ -0,0 +1,96 @@
+return {
+  "nvim-lua/plenary.nvim",
+  { "AstroNvim/astrotheme", opts = { plugins = { ["dashboard-nvim"] = true } } },
+  { "famiu/bufdelete.nvim", cmd = { "Bdelete", "Bwipeout" } },
+  { "max397574/better-escape.nvim", event = "InsertCharPre", opts = { timeout = 300 } },
+  { "NMAC427/guess-indent.nvim", event = "User AstroFile", config = require "plugins.configs.guess-indent" },
+  { "Shatur/neovim-session-manager", event = "BufWritePost", cmd = "SessionManager" },
+  { "s1n7ax/nvim-window-picker", opts = { use_winbar = "smart" } },
+  {
+    "mrjones2014/smart-splits.nvim",
+    opts = { ignored_filetypes = { "nofile", "quickfix", "qf", "prompt" }, ignored_buftypes = { "nofile" } },
+  },
+  {
+    "windwp/nvim-autopairs",
+    event = "InsertEnter",
+    opts = {
+      check_ts = true,
+      ts_config = { java = false },
+      fast_wrap = {
+        map = "<M-e>",
+        chars = { "{", "[", "(", '"', "'" },
+        pattern = string.gsub([[ [%'%"%)%>%]%)%}%,] ]], "%s+", ""),
+        offset = 0,
+        end_key = "$",
+        keys = "qwertyuiopzxcvbnmasdfghjkl",
+        check_comma = true,
+        highlight = "PmenuSel",
+        highlight_grey = "LineNr",
+      },
+    },
+    config = require "plugins.configs.nvim-autopairs",
+  },
+  {
+    "folke/which-key.nvim",
+    event = "VeryLazy",
+    opts = {
+      icons = { group = vim.g.icons_enabled and "" or "+", separator = "" },
+      disable = { filetypes = { "TelescopePrompt" } },
+    },
+    config = require "plugins.configs.which-key",
+  },
+  {
+    "kevinhwang91/nvim-ufo",
+    event = { "User AstroFile", "InsertEnter" },
+    dependencies = { "kevinhwang91/promise-async" },
+    opts = {
+      preview = {
+        mappings = {
+          scrollB = "<C-b>",
+          scrollF = "<C-f>",
+          scrollU = "<C-u>",
+          scrollD = "<C-d>",
+        },
+      },
+      provider_selector = function(_, filetype, buftype)
+        local function handleFallbackException(bufnr, err, providerName)
+          if type(err) == "string" and err:match "UfoFallbackException" then
+            return require("ufo").getFolds(bufnr, providerName)
+          else
+            return require("promise").reject(err)
+          end
+        end
+
+        return (filetype == "" or buftype == "nofile") and "indent" -- only use indent until a file is opened
+          or function(bufnr)
+            return require("ufo")
+              .getFolds(bufnr, "lsp")
+              :catch(function(err) return handleFallbackException(bufnr, err, "treesitter") end)
+              :catch(function(err) return handleFallbackException(bufnr, err, "indent") end)
+          end
+      end,
+    },
+  },
+  {
+    "numToStr/Comment.nvim",
+    keys = { { "gc", mode = { "n", "v" } }, { "gb", mode = { "n", "v" } } },
+    opts = function()
+      local commentstring_avail, commentstring = pcall(require, "ts_context_commentstring.integrations.comment_nvim")
+      return commentstring_avail and commentstring and { pre_hook = commentstring.create_pre_hook() } or {}
+    end,
+  },
+  {
+    "akinsho/toggleterm.nvim",
+    cmd = { "ToggleTerm", "TermExec" },
+    opts = {
+      size = 10,
+      open_mapping = [[<F7>]],
+      shading_factor = 2,
+      direction = "float",
+      float_opts = {
+        border = "curved",
+        highlights = { border = "Normal", background = "Normal" },
+      },
+    },
+  },
+}

users/daniel/configs/system/nvim/nvim/lua/plugins/dap.lua

@@ -0,0 +1,19 @@
+return {
+  "mfussenegger/nvim-dap",
+  enabled = vim.fn.has "win32" == 0,
+  dependencies = {
+    {
+      "jay-babu/mason-nvim-dap.nvim",
+      dependencies = { "nvim-dap" },
+      cmd = { "DapInstall", "DapUninstall" },
+      opts = { automatic_setup = true },
+      config = require "plugins.configs.mason-nvim-dap",
+    },
+    {
+      "rcarriga/nvim-dap-ui",
+      opts = { floating = { border = "rounded" } },
+      config = require "plugins.configs.nvim-dap-ui",
+    },
+  },
+  event = "User AstroFile",
+}

users/daniel/configs/system/nvim/nvim/lua/plugins/git.lua

@@ -0,0 +1,16 @@
+return {
+  "lewis6991/gitsigns.nvim",
+  enabled = vim.fn.executable "git" == 1,
+  ft = "gitcommit",
+  event = "User AstroGitFile",
+  opts = {
+    signs = {
+      add = { text = "▎" },
+      change = { text = "▎" },
+      delete = { text = "▎" },
+      topdelete = { text = "契" },
+      changedelete = { text = "▎" },
+      untracked = { text = "▎" },
+    },
+  },
+}

users/daniel/configs/system/nvim/nvim/lua/plugins/heirline.lua

@@ -0,0 +1,86 @@
+return {
+  "rebelot/heirline.nvim",
+  event = "BufEnter",
+  opts = function()
+    local status = require "astronvim.utils.status"
+    return {
+      opts = {
+        disable_winbar_cb = function(args)
+          return status.condition.buffer_matches({
+            buftype = { "terminal", "prompt", "nofile", "help", "quickfix" },
+            filetype = { "NvimTree", "neo%-tree", "dashboard", "Outline", "aerial" },
+          }, args.buf)
+        end,
+      },
+      statusline = { -- statusline
+        hl = { fg = "fg", bg = "bg" },
+        status.component.mode(),
+        status.component.git_branch(),
+        status.component.file_info { filetype = {}, filename = false, file_modified = false },
+        status.component.git_diff(),
+        status.component.diagnostics(),
+        status.component.fill(),
+        status.component.cmd_info(),
+        status.component.fill(),
+        status.component.lsp(),
+        status.component.treesitter(),
+        status.component.nav(),
+        status.component.mode { surround = { separator = "right" } },
+      },
+      winbar = { -- winbar
+        init = function(self) self.bufnr = vim.api.nvim_get_current_buf() end,
+        fallthrough = false,
+        {
+          condition = function() return not status.condition.is_active() end,
+          status.component.separated_path(),
+          status.component.file_info {
+            file_icon = { hl = status.hl.file_icon "winbar", padding = { left = 0 } },
+            file_modified = false,
+            file_read_only = false,
+            hl = status.hl.get_attributes("winbarnc", true),
+            surround = false,
+            update = "BufEnter",
+          },
+        },
+        status.component.breadcrumbs { hl = status.hl.get_attributes("winbar", true) },
+      },
+      tabline = { -- bufferline
+        { -- file tree padding
+          condition = function(self)
+            self.winid = vim.api.nvim_tabpage_list_wins(0)[1]
+            return status.condition.buffer_matches(
+              { filetype = { "aerial", "dapui_.", "neo%-tree", "NvimTree" } },
+              vim.api.nvim_win_get_buf(self.winid)
+            )
+          end,
+          provider = function(self) return string.rep(" ", vim.api.nvim_win_get_width(self.winid) + 1) end,
+          hl = { bg = "tabline_bg" },
+        },
+        status.heirline.make_buflist(status.component.tabline_file_info()), -- component for each buffer tab
+        status.component.fill { hl = { bg = "tabline_bg" } }, -- fill the rest of the tabline with background color
+        { -- tab list
+          condition = function() return #vim.api.nvim_list_tabpages() >= 2 end, -- only show tabs if there are more than one
+          status.heirline.make_tablist { -- component for each tab
+            provider = status.provider.tabnr(),
+            hl = function(self) return status.hl.get_attributes(status.heirline.tab_type(self, "tab"), true) end,
+          },
+          { -- close button for current tab
+            provider = status.provider.close_button { kind = "TabClose", padding = { left = 1, right = 1 } },
+            hl = status.hl.get_attributes("tab_close", true),
+            on_click = {
+              callback = function() require("astronvim.utils.buffer").close_tab() end,
+              name = "heirline_tabline_close_tab_callback",
+            },
+          },
+        },
+      },
+      statuscolumn = vim.fn.has "nvim-0.9" == 1 and {
+        status.component.foldcolumn(),
+        status.component.fill(),
+        status.component.numbercolumn(),
+        status.component.signcolumn(),
+      } or nil,
+    }
+  end,
+  config = require "plugins.configs.heirline",
+}

users/daniel/configs/system/nvim/nvim/lua/plugins/lsp.lua

@@ -0,0 +1,69 @@
+return {
+  "b0o/SchemaStore.nvim",
+  {
+    "folke/neodev.nvim",
+    opts = {
+      override = function(root_dir, library)
+        for _, astronvim_config in ipairs(astronvim.supported_configs) do
+          if root_dir:match(astronvim_config) then
+            library.plugins = true
+            break
+          end
+        end
+        vim.b.neodev_enabled = library.enabled
+      end,
+    },
+  },
+  {
+    "neovim/nvim-lspconfig",
+    dependencies = {
+      {
+        "williamboman/mason-lspconfig.nvim",
+        cmd = { "LspInstall", "LspUninstall" },
+        config = require "plugins.configs.mason-lspconfig",
+      },
+    },
+    event = "User AstroFile",
+    config = require "plugins.configs.lspconfig",
+  },
+  {
+    "jose-elias-alvarez/null-ls.nvim",
+    dependencies = {
+      {
+        "jay-babu/mason-null-ls.nvim",
+        cmd = { "NullLsInstall", "NullLsUninstall" },
+        opts = { automatic_setup = true },
+        config = require "plugins.configs.mason-null-ls",
+      },
+    },
+    event = "User AstroFile",
+    opts = function() return { on_attach = require("astronvim.utils.lsp").on_attach } end,
+  },
+  {
+    "stevearc/aerial.nvim",
+    event = "User AstroFile",
+    opts = {
+      attach_mode = "global",
+      backends = { "lsp", "treesitter", "markdown", "man" },
+      layout = { min_width = 28 },
+      show_guides = true,
+      filter_kind = false,
+      guides = {
+        mid_item = "├ ",
+        last_item = "└ ",
+        nested_top = "│ ",
+        whitespace = "  ",
+      },
+      keymaps = {
+        ["[y"] = "actions.prev",
+        ["]y"] = "actions.next",
+        ["[Y"] = "actions.prev_up",
+        ["]Y"] = "actions.next_up",
+        ["{"] = false,
+        ["}"] = false,
+        ["[["] = false,
+        ["]]"] = false,
+      },
+    },
+  },
+}

users/daniel/configs/system/nvim/nvim/lua/plugins/mason.lua

@@ -0,0 +1,35 @@
+return {
+  {
+    "williamboman/mason.nvim",
+    cmd = {
+      "Mason",
+      "MasonInstall",
+      "MasonUninstall",
+      "MasonUninstallAll",
+      "MasonLog",
+    },
+    init = function()
+      local cmd = vim.api.nvim_create_user_command
+      cmd(
+        "MasonUpdateAll",
+        function() require("astronvim.utils.mason").update_all() end,
+        { desc = "Update Mason Packages" }
+      )
+      cmd(
+        "MasonUpdate",
+        function(options) require("astronvim.utils.mason").update(options.args) end,
+        { nargs = 1, desc = "Update Mason Package" }
+      )
+    end,
+    opts = {
+      ui = {
+        icons = {
+          package_installed = "✓",
+          package_uninstalled = "✗",
+          package_pending = "⟳",
+        },
+      },
+    },
+    config = require "plugins.configs.mason",
+  },
+}

users/daniel/configs/system/nvim/nvim/lua/plugins/neo-tree.lua

@@ -0,0 +1,133 @@
+return {
+  "nvim-neo-tree/neo-tree.nvim",
+  dependencies = { "MunifTanjim/nui.nvim" },
+  cmd = "Neotree",
+  init = function() vim.g.neo_tree_remove_legacy_commands = true end,
+  opts = function()
+    -- TODO move after neo-tree improves (https://github.com/nvim-neo-tree/neo-tree.nvim/issues/707)
+    local global_commands = {
+      system_open = function(state) require("astronvim.utils").system_open(state.tree:get_node():get_id()) end,
+      parent_or_close = function(state)
+        local node = state.tree:get_node()
+        if (node.type == "directory" or node:has_children()) and node:is_expanded() then
+          state.commands.toggle_node(state)
+        else
+          require("neo-tree.ui.renderer").focus_node(state, node:get_parent_id())
+        end
+      end,
+      child_or_open = function(state)
+        local node = state.tree:get_node()
+        if node.type == "directory" or node:has_children() then
+          if not node:is_expanded() then -- if unexpanded, expand
+            state.commands.toggle_node(state)
+          else -- if expanded and has children, seleect the next child
+            require("neo-tree.ui.renderer").focus_node(state, node:get_child_ids()[1])
+          end
+        else -- if not a directory just open it
+          state.commands.open(state)
+        end
+      end,
+      copy_selector = function(state)
+        local node = state.tree:get_node()
+        local filepath = node:get_id()
+        local filename = node.name
+        local modify = vim.fn.fnamemodify
+
+        local results = {
+          e = { val = modify(filename, ":e"), msg = "Extension only" },
+          f = { val = filename, msg = "Filename" },
+          F = { val = modify(filename, ":r"), msg = "Filename w/o extension" },
+          h = { val = modify(filepath, ":~"), msg = "Path relative to Home" },
+          p = { val = modify(filepath, ":."), msg = "Path relative to CWD" },
+          P = { val = filepath, msg = "Absolute path" },
+        }
+
+        local messages = {
+          { "\nChoose to copy to clipboard:\n", "Normal" },
+        }
+        for i, result in pairs(results) do
+          if result.val and result.val ~= "" then
+            vim.list_extend(messages, {
+              { ("%s."):format(i), "Identifier" },
+              { (" %s: "):format(result.msg) },
+              { result.val, "String" },
+              { "\n" },
+            })
+          end
+        end
+        vim.api.nvim_echo(messages, false, {})
+        local result = results[vim.fn.getcharstr()]
+        if result and result.val and result.val ~= "" then
+          vim.notify("Copied: " .. result.val)
+          vim.fn.setreg("+", result.val)
+        end
+      end,
+    }
+    local get_icon = require("astronvim.utils").get_icon
+    return {
+      auto_clean_after_session_restore = true,
+      close_if_last_window = true,
+      source_selector = {
+        winbar = true,
+        content_layout = "center",
+        tab_labels = {
+          filesystem = get_icon "FolderClosed" .. " File",
+          buffers = get_icon "DefaultFile" .. " Bufs",
+          git_status = get_icon "Git" .. " Git",
+          diagnostics = get_icon "Diagnostic" .. " Diagnostic",
+        },
+      },
+      default_component_configs = {
+        indent = { padding = 0, indent_size = 1 },
+        icon = {
+          folder_closed = get_icon "FolderClosed",
+          folder_open = get_icon "FolderOpen",
+          folder_empty = get_icon "FolderEmpty",
+          default = get_icon "DefaultFile",
+        },
+        modified = { symbol = get_icon "FileModified" },
+        git_status = {
+          symbols = {
+            added = get_icon "GitAdd",
+            deleted = get_icon "GitDelete",
+            modified = get_icon "GitChange",
+            renamed = get_icon "GitRenamed",
+            untracked = get_icon "GitUntracked",
+            ignored = get_icon "GitIgnored",
+            unstaged = get_icon "GitUnstaged",
+            staged = get_icon "GitStaged",
+            conflict = get_icon "GitConflict",
+          },
+        },
+      },
+      window = {
+        width = 30,
+        mappings = {
+          ["<space>"] = false, -- disable space until we figure out which-key disabling
+          ["[b"] = "prev_source",
+          ["]b"] = "next_source",
+          o = "open",
+          O = "system_open",
+          h = "parent_or_close",
+          l = "child_or_open",
+          Y = "copy_selector",
+        },
+      },
+      filesystem = {
+        follow_current_file = true,
+        hijack_netrw_behavior = "open_current",
+        use_libuv_file_watcher = true,
+        commands = global_commands,
+      },
+      buffers = { commands = global_commands },
+      git_status = { commands = global_commands },
+      diagnostics = { commands = global_commands },
+      event_handlers = {
+        {
+          event = "neo_tree_buffer_enter",
+          handler = function(_) vim.opt_local.signcolumn = "auto" end,
+        },
+      },
+    }
+  end,
+}

users/daniel/configs/system/nvim/nvim/lua/plugins/telescope.lua

@@ -0,0 +1,42 @@
+return {
+  "nvim-telescope/telescope.nvim",
+  dependencies = {
+    { "nvim-telescope/telescope-fzf-native.nvim", enabled = vim.fn.executable "make" == 1, build = "make" },
+  },
+  cmd = "Telescope",
+  opts = function()
+    local actions = require "telescope.actions"
+    local get_icon = require("astronvim.utils").get_icon
+    return {
+      defaults = {
+        prompt_prefix = string.format("%s ", get_icon "Search"),
+        selection_caret = string.format("%s ", get_icon "Selected"),
+        path_display = { "truncate" },
+        sorting_strategy = "ascending",
+        layout_config = {
+          horizontal = {
+            prompt_position = "top",
+            preview_width = 0.55,
+          },
+          vertical = {
+            mirror = false,
+          },
+          width = 0.87,
+          height = 0.80,
+          preview_cutoff = 120,
+        },
+
+        mappings = {
+          i = {
+            ["<C-n>"] = actions.cycle_history_next,
+            ["<C-p>"] = actions.cycle_history_prev,
+            ["<C-j>"] = actions.move_selection_next,
+            ["<C-k>"] = actions.move_selection_previous,
+          },
+          n = { ["q"] = actions.close },
+        },
+      },
+    }
+  end,
+  config = require "plugins.configs.telescope",
+}

users/daniel/configs/system/nvim/nvim/lua/plugins/treesitter.lua

@@ -0,0 +1,28 @@
+return {
+  "nvim-treesitter/nvim-treesitter",
+  dependencies = { "windwp/nvim-ts-autotag", "JoosepAlviste/nvim-ts-context-commentstring" },
+  event = "User AstroFile",
+  cmd = {
+    "TSBufDisable",
+    "TSBufEnable",
+    "TSBufToggle",
+    "TSDisable",
+    "TSEnable",
+    "TSToggle",
+    "TSInstall",
+    "TSInstallInfo",
+    "TSInstallSync",
+    "TSModuleInfo",
+    "TSUninstall",
+    "TSUpdate",
+    "TSUpdateSync",
+  },
+  build = ":TSUpdate",
+  opts = {
+    highlight = { enable = true },
+    incremental_selection = { enable = true },
+    autotag = { enable = true },
+    context_commentstring = { enable = true, enable_autocmd = false },
+  },
+  config = require "plugins.configs.nvim-treesitter",
+}

users/daniel/configs/system/nvim/nvim/lua/plugins/ui.lua

@@ -0,0 +1,122 @@
+return {
+  {
+    "nvim-tree/nvim-web-devicons",
+    enabled = vim.g.icons_enabled,
+    opts = {
+      deb = { icon = "", name = "Deb" },
+      lock = { icon = "", name = "Lock" },
+      mp3 = { icon = "", name = "Mp3" },
+      mp4 = { icon = "", name = "Mp4" },
+      out = { icon = "", name = "Out" },
+      ["robots.txt"] = { icon = "ﮧ", name = "Robots" },
+      ttf = { icon = "", name = "TrueTypeFont" },
+      rpm = { icon = "", name = "Rpm" },
+      woff = { icon = "", name = "WebOpenFontFormat" },
+      woff2 = { icon = "", name = "WebOpenFontFormat2" },
+      xz = { icon = "", name = "Xz" },
+      zip = { icon = "", name = "Zip" },
+    },
+    config = require "plugins.configs.nvim-web-devicons",
+  },
+  {
+    "onsails/lspkind.nvim",
+    opts = {
+      mode = "symbol",
+      symbol_map = {
+        Array = "",
+        Boolean = "⊨",
+        Class = "",
+        Constructor = "",
+        Key = "",
+        Namespace = "",
+        Null = "NULL",
+        Number = "#",
+        Object = "",
+        Package = "",
+        Property = "",
+        Reference = "",
+        Snippet = "",
+        String = "",
+        TypeParameter = "",
+        Unit = "",
+      },
+    },
+    enabled = vim.g.icons_enabled,
+    config = require "plugins.configs.lspkind",
+  },
+  {
+    "rcarriga/nvim-notify",
+    init = function() require("astronvim.utils").load_plugin_with_func("nvim-notify", vim, "notify") end,
+    opts = { on_open = function(win) vim.api.nvim_win_set_config(win, { zindex = 1000 }) end },
+    config = require "plugins.configs.notify",
+  },
+  {
+    "stevearc/dressing.nvim",
+    init = function() require("astronvim.utils").load_plugin_with_func("dressing.nvim", vim.ui, { "input", "select" }) end,
+    opts = {
+      input = {
+        default_prompt = "➤ ",
+        win_options = { winhighlight = "Normal:Normal,NormalNC:Normal" },
+      },
+      select = {
+        backend = { "telescope", "builtin" },
+        builtin = { win_options = { winhighlight = "Normal:Normal,NormalNC:Normal" } },
+      },
+    },
+  },
+  {
+    "NvChad/nvim-colorizer.lua",
+    event = "User AstroFile",
+    cmd = { "ColorizerToggle", "ColorizerAttachToBuffer", "ColorizerDetachFromBuffer", "ColorizerReloadAllBuffers" },
+    opts = { user_default_options = { names = false } },
+  },
+  {
+    "lukas-reineke/indent-blankline.nvim",
+    event = "User AstroFile",
+    opts = {
+      buftype_exclude = {
+        "nofile",
+        "terminal",
+      },
+      filetype_exclude = {
+        "help",
+        "startify",
+        "aerial",
+        "alpha",
+        "dashboard",
+        "lazy",
+        "neogitstatus",
+        "NvimTree",
+        "neo-tree",
+        "Trouble",
+      },
+      context_patterns = {
+        "class",
+        "return",
+        "function",
+        "method",
+        "^if",
+        "^while",
+        "jsx_element",
+        "^for",
+        "^object",
+        "^table",
+        "block",
+        "arguments",
+        "if_statement",
+        "else_clause",
+        "jsx_element",
+        "jsx_self_closing_element",
+        "try_statement",
+        "catch_clause",
+        "import_statement",
+        "operation_type",
+      },
+      show_trailing_blankline_indent = false,
+      use_treesitter = true,
+      char = "▏",
+      context_char = "▏",
+      show_current_context = true,
+    },
+  },
+}