DEV Community: Cason Adams

The "Claude Mythos" Illusion: Innovation or Data Harvesting?

Cason Adams — Sat, 11 Apr 2026 18:26:02 +0000

The tech industry is currently captivated by the aura surrounding "Claude Mythos," the latest offering from Anthropic. Positioned as an elite-tier, highly restricted model, its access is tightly gated, purportedly reserved only for the world’s most distinguished subject matter experts, scientists, lead architects, and high-level cybersecurity researchers.

Anthropic’s marketing is a masterclass in exclusivity. They describe Mythos not just as a tool, but as a "secure research partner," claiming it features advanced, hardware-level security checks designed to protect the intellectual property of the users who interact with it. But beyond the polished press releases and the invitation-only access, a darker, more pragmatic narrative is beginning to emerge.

The Security Pretext

The core of the Mythos marketing campaign is its "zero-trust" security architecture. Anthropic insists that the model is designed to operate in a walled-off environment, specifically engineered so that experts can feed it proprietary data, raw codebases, and classified research without fear of leakage.

By framing the model as a fortress, they have effectively lowered the defenses of the very people who should be the most cautious. Experts, often wary of cloud-based AI, are finding themselves enticed by the promise of a "secure" sandbox. However, the mechanism they trust to keep their work safe may be the exact pipeline used to ingest it.

The Data Ingestion Engine

If we look past the "security" labels, a different architecture reveals itself. Every interaction with Mythos requires the user to submit their most sensitive, cutting-edge work, the very thing the model claims to be "protecting."

In this model, the "security checks" act as a sophisticated data-cleaning and indexing layer. As an expert uploads a breakthrough algorithm or a novel architectural design, the system isn't just "securing" it; it is tokenizing, categorizing, and mapping the logic into Anthropic's training sets.

Why This Is Different

In previous iterations of AI development, training data was largely scraped from the open web, a "wild west" of publicly available information. Mythos represents a pivot to "High-Value Proprietary Ingestion."

The Expertise Gap: By gating the model to elite users, Anthropic isn't just limiting quantity; they are optimizing for quality. They are essentially crowdsourcing the R&D of the world's most capable minds.
The Validation Loop: By labeling the ingestion process as "security verification," they gain explicit, user-signed permission to analyze the data. It effectively bypasses the ethical grey areas of scraping, as the users are effectively "handing over the keys" to their own intellectual property.
The Mythos Cycle: The experts get a high-performing tool, and in exchange, the model learns from the very solutions those experts are developing. The model becomes smarter, more "expert," and more attractive to the next cohort of users, creating a feedback loop where Anthropic extracts the intellectual capital of an entire industry.

The Takeaway

The "Claude Mythos" is less of a technological breakthrough and more of a strategic masterstroke in data acquisition. It turns the concept of "security" into a Trojan Horse. As developers and researchers, we must ask ourselves: is the convenience of an "expert-only" model worth the price of the very expertise that makes us valuable?

When we step into the walled garden of Mythos, we aren't just using an AI; we are training our own replacements.

Manjaro Linux MacBook Pro 14,1

Cason Adams — Tue, 09 Jul 2024 06:56:00 +0000

Leaving steps to re provision a MacBook Pro 14,1 in the future for me :P

Download Manjaro Linux

https://manjaro.org/download/
I am using Gnome version x86

Burn iso image to usb drive

There are various tools to help with this. I won't go into details that is a blog in it self.

Boot Mac via drive

Insert drive
Reboot machine
Hold option key to get boot menu
Select drive
Manjaro boot screen will load, chose the default option to boot with open source drivers

Getting WiFi working

Open a terminal and execute this command, wlp2s0 and 31 might differ per machine. Likely a smaller number will have a greater success.

iw dev wlp2s0 set txpower fixed 31

Then connect to WiFi

Install

Choose to install, and follow steps for installation. Once complete reboot.

Post Install

auto fix WiFi

I created a simple systemd unit file and saved it to /etc/systemd/system/wifi-txpower.service

[Unit]
Description=Set WiFi txpower on boot

[Service]
Type=oneshot
ExecStart=/usr/bin/iw dev wlp2s0 set txpower fixed 31
Restart=on-failure
RestartSec=5s

[Install]
WantedBy=multi-user.target

Test the service
sudo chmod 644 /etc/systemd/system/wifi-txpower.service

systemctl daemon-reload
systemctl start wifi-txpower
journalctl -exfu wifi-txpower

If everything is good go ahead enable the service and reboot and verify that WiFi works on reboot

systemd enable wifi-txtpower
reboot

Most of the time it works just fine, if not toggle wifi on and off and you should be good.

fix sound

I followed this repo here https://github.com/davidjo/snd_hda_macbookpro because my sound card was the same.

cat /proc/asound/card0/codec* | grep Codec
Codec: Cirrus Logic CS8409/CS42L83
Codec: Intel Kabylake HDMI

pacman -S gcc linux-headers make patch wget
yay -Syu snd-hda-macbookpro-dkms-git

Then reboot

Set keyboard backlighting

Install brighnessctl

sudo pacman -Syu brightnessctl

List devices

brightnessctl --list
Device 'spi::kbd_backlight' of class 'leds':
    Current brightness: 255 (100%)
    Max brightness: 255

Set desired brightness

brightnessctl --device='spi::kbd_backlight' s 100%

I didn't dive into getting the touchbar working, it seems that I need to do much more work than this. I am fine without it as I map CAPS to ESC anyway.

Happy Hacking!

Simple vim / terminal color changing

Cason Adams — Sat, 05 Mar 2022 19:14:41 +0000

Why?

So I have been looking for solutions that sync my vim colors with my terminal colors. And there are many awesome solutions out there. But none of them gave me the flexibility /freedom I wanted that was simple. So I decided to try to build my own system.

Terminal setup

So there are two options here:

I prefer alacritty-shell because it is the simplest, fastest, and most flexible. However, it requires the use of the alacritty terminal.

Vim setup

Install walh a clean vim colorscheme.

walh will use the first 16 colors from the terminal, and orange(color208) and grey(color247).

Result

Vim colorscheme that matches the terminal colors. Now one can open vim and decided to change the terminal colors from a light theme to a dark theme all from running alacritty_{theme} or walh_{theme}. This gets better if one lives in a multiplex terminal like tmux. This opens doors for setting up scheduled tasks to switch themes based on the time of day.

Ditch iTerm for Alacritty and tmux

Cason Adams — Sun, 26 Dec 2021 22:34:35 +0000

setting up terminal theme

First thing that needs to be done is how to manage terminal theming. But for the full experience (inactive window dimming) this is an important first step.

What's important here is setting index color 18.

alacritty-shell option 1

Follow the instructions for installing alacritty-shell

alacritty theme manual update option 2

Copy a 256 color theme from alacritty-themes into alacritty.yml file.

setting up tmux

Add the following snippet to tmux.conf file.
NOTE if using alacritty-shell use colour247 instead of colour18

Note fg=colour2 is terminal green
Note bg=colour18 is using the index color set from the theming above. It is important that colour18 is a lighter/darker shade of the background color. Usually by about 5-10 lightness values.

set -g pane-active-border-style fg=colour2,bg=colour18
set -g pane-border-style bg=colour18
set-window-option -g window-active-style bg=terminal
set-window-option -g window-style bg=colour18

see it in action

also using walh vim theme for dimming with vim screens.

Neovim LSP to replace VSCode

Cason Adams — Sun, 26 Dec 2021 20:26:48 +0000

If you are looking for a much simpler solution to replacing VSCode with a terminal editor I suggest reading my minimal vim post.

TLDR;

All the code for this is availible nvim-code

Setup

This post is going to assume that neovim 0.6+ is installed and ready to go. From that point lets lay down the directory structure we are going to be dealing with.

Neovim defaults to using ${HOME}/.config/nvim as the configuration directory. I am going to build off that as the base for config files.

nvim
├── after
│   └── ftplugin
│       └── python.lua
├── init.lua
├── lua
│   ├── _lsp.lua
│   ├── _options.lua
│   ├── _plugins.lua
│   ├── _statusline.lua
│   ├── _telescope.lua
│   ├── _treesitter.lua
│   └── _whichkey.lua

init.lua

require("_options")
require("_plugins")
require("_lsp")
require("_treesitter")
require("_telescope")
require("_whichkey")
require("_statusline")

vim.cmd("colorscheme walh-gruvbox")

_options.lua

I'm not going to cover all the options available, but here are some common ones that can be used or omitted. Heavily inspired by lunarvim.

vim.g.mapleader = " "

vim.g.border_style = "rounded"
vim.g.markdown_fenced_languages = {
    "bash=sh",
}

vim.opt.backup = false -- creates a backup file
vim.opt.clipboard = "" -- don't use clipboard
vim.opt.cmdheight = 1 -- more space in the neovim command line for displaying messages
vim.opt.colorcolumn = "99999" -- fixes indentline for now
vim.opt.completeopt = { "menuone", "noselect" }
vim.opt.conceallevel = 0 -- so that `` is visible in markdown files
vim.opt.cursorline = true -- highlight the current line
vim.opt.expandtab = true -- convert tabs to spaces
vim.opt.fileencoding = "utf-8" -- the encoding written to a file
vim.opt.foldexpr = "" -- set to "nvim_treesitter#foldexpr()" for treesitter based folding
vim.opt.foldmethod = "manual" -- folding set to "expr" for treesitter based folding
vim.opt.hidden = true -- required to keep multiple buffers and open multiple buffers
vim.opt.hlsearch = true -- highlight all matches on previous search pattern
vim.opt.ignorecase = true -- ignore case in search patterns
vim.opt.list = true
vim.opt.listchars = "tab:│ ,trail:·,nbsp:+"
vim.opt.number = true -- set numbered lines
vim.opt.numberwidth = 1 -- set number column width to 2 {default 4}
vim.opt.pumheight = 10 -- pop up menu height
vim.opt.relativenumber = false -- set relative numbered lines
vim.opt.scrolloff = 4 -- is one of my fav
vim.opt.shiftwidth = 2 -- the number of spaces inserted for each indentation
vim.opt.showmode = false -- we don't need to see things like -- INSERT -- anymore
vim.opt.sidescrolloff = 4
vim.opt.signcolumn = "yes" -- always show the sign column otherwise it would shift the text each time
vim.opt.smartcase = true -- smart case
vim.opt.smartindent = true -- make indenting smarter again
vim.opt.spell = false -- disable spell checking
vim.opt.spelllang = "en" -- language for spell checking
vim.opt.splitbelow = true -- force all horizontal splits to go below current window
vim.opt.splitright = true -- force all vertical splits to go to the right of current window
vim.opt.swapfile = false -- creates a swapfile
vim.opt.tabstop = 2 -- insert 2 spaces for a tab
vim.opt.termguicolors = false -- set term gui colors (most terminals support this)
vim.opt.timeoutlen = 500 -- timeout length
vim.opt.title = true -- set the title of window to the value of the titlestring
vim.opt.titlestring = "%<%F - nvim" -- what the title of the window will be set to
vim.opt.undodir = vim.fn.stdpath("cache") .. "/undo"
vim.opt.undofile = true -- enable persistent undo
vim.opt.updatetime = 300 -- faster completion
vim.opt.wrap = true -- display lines as one long line
vim.opt.writebackup = false -- if a file is being edited by another program (or was written to file while editing with another program) it is not allowed to be edited

vim.opt.showtabline = 2 -- always show tabs
vim.opt.laststatus = 2 -- hide statusline

_plugins.lua

I have to admit using neovims builtin lsp is nice but it comes with the requirement to install many plugins to get a similar experience with VSCode.

local fn = vim.fn
local install_path = fn.stdpath("data") .. "/site/pack/packer/start/packer.nvim"
if fn.empty(fn.glob(install_path)) > 0 then
    packer_bootstrap = fn.system({
        "git",
        "clone",
        "--depth",
        "1",
        "https://github.com/wbthomason/packer.nvim",
        install_path,
    })
end

return require("packer").startup(function()
    use({
        "L3MON4D3/LuaSnip",
        "casonadams/walh",
        "folke/trouble.nvim",
        "hrsh7th/cmp-buffer",
        "hrsh7th/cmp-cmdline",
        "hrsh7th/cmp-nvim-lsp",
        "hrsh7th/cmp-path",
        "hrsh7th/nvim-cmp",
        "jose-elias-alvarez/null-ls.nvim",
        "neovim/nvim-lspconfig",
        "nvim-lua/lsp-status.nvim",
        "nvim-treesitter/nvim-treesitter",
        "saadparwaiz1/cmp_luasnip",
        "tamago324/nlsp-settings.nvim",
        "wbthomason/packer.nvim",
        "williamboman/nvim-lsp-installer",
    })
    use({
        "rafamadriz/friendly-snippets",
    })
    use({
        "nvim-telescope/telescope.nvim",
        requires = { "nvim-lua/plenary.nvim" },
    })
    use({
        "nvim-lualine/lualine.nvim",
        requires = { "kyazdani42/nvim-web-devicons", opt = true },
    })
    use({
        "folke/which-key.nvim",
        config = function()
            require("which-key").setup({})
        end,
    })
    use({
        "terrortylor/nvim-comment",
        config = function()
            require("nvim_comment").setup({})
        end,
    })
    use({
        "lewis6991/gitsigns.nvim",
        config = function()
            require("gitsigns").setup({ yadm = { enable = true } })
        end,
    })
    use({
        "ethanholz/nvim-lastplace",
        event = "BufRead",
        config = function()
            require("nvim-lastplace").setup({
                lastplace_ignore_buftype = { "quickfix", "nofile", "help" },
                lastplace_ignore_filetype = { "gitcommit", "gitrebase", "svn", "hgcommit" },
                lastplace_open_folds = true,
            })
        end,
    })
    -- Automatically set up your configuration after cloning packer.nvim
    -- Put this at the end after all plugins
    if packer_bootstrap then
        require("packer").sync()
    end
end)

_lsp.lua

local cmp = require("cmp")
local lsp_status = require("lsp-status")

local win = require("lspconfig.ui.windows")
local _default_opts = win.default_opts

win.default_opts = function(options)
    local opts = _default_opts(options)
    opts.border = "rounded"
    return opts
end

-- statusline progress setup
lsp_status.config({
    current_function = false,
    show_filename = false,
    diagnostics = false,
    status_symbol = "",
    select_symbol = nil,
    update_interval = 200,
})

-- completion setup
cmp.setup({
    snippet = {
        expand = function(args)
            -- vim.fn["vsnip#anonymous"](args.body)
            require("luasnip").lsp_expand(args.body) -- For `luasnip` users.
            -- vim.fn["UltiSnips#Anon"](args.body)
        end,
    },
    mapping = {
        ["<C-d>"] = cmp.mapping.scroll_docs(-4),
        ["<C-f>"] = cmp.mapping.scroll_docs(4),
        ["<C-Space>"] = cmp.mapping.complete(),
        ["<C-e>"] = cmp.mapping.close(),
        ["<CR>"] = cmp.mapping.confirm({ select = false }),
        ["<Tab>"] = cmp.mapping(cmp.mapping.select_next_item(), { "i", "s" }),
        ["<S-Tab>"] = cmp.mapping(cmp.mapping.select_prev_item(), { "i", "s" }),
    },
    sources = {
        { name = "nvim_lsp" },
        { name = "luasnip" },
        -- { name = "ultisnips" },
        -- { name = "vsnip" },
        { name = "buffer" },
        { name = "path" },
    },
})

-- helper function for mappings
local m = function(mode, key, result)
    vim.api.nvim_buf_set_keymap(0, mode, key, "<cmd> " .. result .. "<cr>", {
        noremap = true,
        silent = true,
    })
end

-- function to attach completion when setting up lsp
local on_attach = function(client)
    lsp_status.register_progress()
    lsp_status.on_attach(client)

    -- Mappings.
    m("n", "ga", "lua vim.lsp.buf.code_action()")
    m("n", "gD", "lua vim.lsp.buf.declaration()")
    m("n", "gd", "lua vim.lsp.buf.definition()")
    m("n", "ge", "lua vim.lsp.diagnostic.goto_next()")
    m("n", "gE", "lua vim.lsp.diagnostic.goto_prev()")
    m("n", "gi", "lua vim.lsp.buf.implementation()")
    m("n", "gr", "lua vim.lsp.buf.references()")
    m("n", "K", "lua vim.lsp.buf.hover()")
    -- m("n", "<space>rn", "lua vim.lsp.buf.rename()")
    m("n", "gl", "lua vim.lsp.diagnostic.show_line_diagnostics()")
    -- m("n", "<space>f", "lua vim.lsp.buf.formatting()")
end

-- setup lsp installer
local lsp_installer = require("nvim-lsp-installer")
-- Provide settings first!
lsp_installer.settings({
    ui = {
        icons = {
            server_installed = "✓",
            server_pending = "➜",
            server_uninstalled = "✗",
        },
    },
})
lsp_installer.on_server_ready(function(server)
    local opts = {
        on_attach = on_attach,
        capabilities = require("cmp_nvim_lsp").update_capabilities(vim.lsp.protocol.make_client_capabilities()),
        flags = {
            debounce_text_changes = 150,
        },
    }
    server:setup(opts)
end)

-- lsp settings
require("nlspsettings").setup()

-- diagnostics
vim.diagnostic.config({
    virtual_text = false,
    underline = true,
    float = {
        source = "always",
    },
    severity_sort = true,
    --[[ virtual_text = {
      prefix = "»",
      spacing = 4,
    }, ]]
    signs = true,
    update_in_insert = false,
})

_treesitter.lua

require'nvim-treesitter.configs'.setup {
  ensure_installed = "maintained",
  sync_install = false,
  highlight = {
    enable = true,
    additional_vim_regex_highlighting = false,
  },
}

_telescope.lua

require("telescope").setup({
    defaults = {
        border = true,
        layout_strategy = "bottom_pane",
        layout_config = {
            height = 0.30,
            width = 1.00,
        },
        -- path_display = { "shorten" },
        sorting_strategy = "ascending",
    },
})

require("trouble").setup({
  icons=false
})

_whichkey.lua

local which_key = {
    setup = {
        plugins = {
            marks = true,
            registers = true,
            presets = {
                operators = false,
                motions = false,
                text_objects = false,
                windows = true,
                nav = true,
                z = true,
                g = true,
            },
            spelling = { enabled = true, suggestions = 20 },
        },
        icons = {
            breadcrumb = "»",
            separator = "➜",
            group = "+",
        },
        window = {
            border = "none", -- none, single, double, shadow
            position = "bottom", -- bottom, top
            margin = { 1, 0, 1, 0 },
            padding = { 2, 2, 2, 2 },
        },
        layout = {
            height = { min = 4, max = 25 },
            width = { min = 20, max = 50 },
            spacing = 3,
        },
        hidden = { "<silent>", "<cmd>", "<Cmd>", "<CR>", "call", "lua", "^:", "^ " },
        show_help = true,
    },

    opts = {
        mode = "n",
        prefix = "<leader>",
        buffer = nil,
        silent = true,
        noremap = true,
        nowait = true,
    },
    vopts = {
        mode = "v",
        prefix = "<leader>",
        buffer = nil,
        silent = true,
        noremap = true,
        nowait = true,
    },
    -- NOTE: Prefer using : over <cmd> as the latter avoids going back in normal-mode.
    -- see https://neovim.io/doc/user/map.html#:map-cmd
    vmappings = {},
    mappings = {
        ["c"] = { ":BufferClose!<CR>", "Close Buffer" },
        ["e"] = { ":Telescope file_browser <CR>", "File Browser" },
        ["f"] = { ":Telescope find_files <CR>", "Find File" },
        ["h"] = { ":nohlsearch<CR>", "No Highlight" },
        b = {
            name = "Buffers",
            l = { ":Telescope buffers<CR>", "List Buffers" },
            b = { ":b#<cr>", "Previous" },
            d = { ":bd<cr>", "Delete" },
            f = { ":Telescope buffers <cr>", "Find" },
            n = { ":bn<cr>", "Next" },
            p = { ":bp<cr>", "Previous" },
        },
        p = {
            name = "Packer",
            c = { ":PackerCompile<cr>", "Compile" },
            i = { ":PackerInstall<cr>", "Install" },
            r = { ":lua require('lvim.utils').reload_lv_config()<cr>", "Reload" },
            s = { ":PackerSync<cr>", "Sync" },
            S = { ":PackerStatus<cr>", "Status" },
            u = { ":PackerUpdate<cr>", "Update" },
        },
        l = {
            name = "LSP",
            a = { ":Telescope lsp_code_actions<cr>", "Code Action" },
            d = {
                ":Telescope lsp_document_diagnostics<cr>",
                "Document Diagnostics",
            },
            w = {
                ":Telescope diagnostics<cr>",
                "Workspace Diagnostics",
            },
            f = { ":lua vim.lsp.buf.formatting()<cr>", "Format" },
            i = { ":LspInfo<cr>", "Info" },
            I = { ":LspInstallInfo<cr>", "Installer Info" },
            r = { ":lua vim.lsp.buf.rename()<cr>", "Rename" },
        },
        s = {
            name = "Search",
            b = { ":Telescope git_branches <cr>", "Checkout branch" },
            c = { ":Telescope colorscheme <cr>", "Colorscheme" },
            C = { ":Telescope commands <cr>", "Commands" },
            f = { ":Telescope find_files <cr>", "Find File" },
            h = { ":Telescope help_tags <cr>", "Find Help" },
            j = { ":Telescope jumplist <cr>", "Jumplist" },
            k = { ":Telescope keymaps <cr>", "Keymaps" },
            M = { ":Telescope man_pages <cr>", "Man Pages" },
            r = { ":Telescope oldfiles <cr>", "Open Recent File" },
            R = { ":Telescope registers <cr>", "Registers" },
            t = { ":Telescope live_grep <cr>", "Text" },
            n = { ":Telescope live_grep search_dirs={os.getenv('NOTES')} <cr>", "Notes" },
            p = {
                ":lua require('telescope.builtin.internal').colorscheme({enable_preview = true})<cr>",
                "Colorscheme with Preview",
            },
        },
        T = {
            name = "Treesitter",
            i = { ":TSConfigInfo<cr>", "Info" },
        },
        t = {
            name = "Diagnostics",
            t = { "<cmd>TroubleToggle<cr>", "trouble" },
            w = { "<cmd>TroubleToggle workspace_diagnostics<cr>", "workspace" },
            d = { "<cmd>TroubleToggle document_diagnostics<cr>", "document" },
            q = { "<cmd>TroubleToggle quickfix<cr>", "quickfix" },
            l = { "<cmd>TroubleToggle loclist<cr>", "loclist" },
            r = { "<cmd>TroubleToggle lsp_references<cr>", "references" },
        },
    },
}

function map(mode, lhs, rhs, opts)
        local options = { noremap = true, silent = true }
    if opts then
        options = vim.tbl_extend("force", options, opts)
    end
    vim.api.nvim_set_keymap(mode, lhs, rhs, options)
end

map("n", "H", ":bp<CR>")
map("n", "L", ":bn<CR>")

map("n", "<tab>", ":tabnext<CR>")
map("n", "<S-tab>", ":tabprevious<CR>")

map("n", "<C-h>", ":wincmd h<CR>")
map("n", "<C-j>", ":wincmd j<CR>")
map("n", "<C-k>", ":wincmd k<CR>")
map("n", "<C-l>", ":wincmd l<CR>")

local wk = require("which-key")
wk.setup(which_key.setup)

local opts = which_key.opts
local vopts = which_key.vopts

local mappings = which_key.mappings
local vmappings = which_key.vmappings

wk.register(mappings, opts)
wk.register(vmappings, vopts)

if which_key.on_config_done then
    which_key.on_config_done(wk)
end

_statusline.lua

local lsp_status = require("lsp-status")

local function lsp_progress()
    return lsp_status.status()
end

local function extract_highlight_colors(color_group, scope)
    if vim.fn.hlexists(color_group) == 0 then
        return nil
    end
    local color = vim.api.nvim_get_hl_by_name(color_group, true)
    if color.background ~= nil then
        color.bg = string.format("#%06x", color.background)
        color.background = nil
    end
    if color.foreground ~= nil then
        color.fg = string.format("#%06x", color.foreground)
        color.foreground = nil
    end
    if scope then
        return color[scope]
    end
    return color
end

local colors = {
    gray = 8,
    red = 9,
    green = 10,
    yellow = 11,
    blue = 12,
    magenta = 13,
    cyan = 14,
    white = 15,
    background = extract_highlight_colors("StatusLine", "bg"),
    foreground = 7,
}

local custom_theme = {
    normal = {
        a = { bg = colors.foreground, fg = colors.background },
        b = { bg = colors.background, fg = colors.foreground },
        c = { bg = colors.background, fg = colors.foreground },
    },
    insert = {
        a = { bg = colors.cyan, fg = colors.background },
        b = { bg = colors.background, fg = colors.cyan },
        c = { bg = colors.background, fg = colors.foreground },
    },
    visual = {
        a = { bg = colors.yellow, fg = colors.background },
        b = { bg = colors.background, fg = colors.yellow },
        c = { bg = colors.background, fg = colors.foreground },
    },
    replace = {
        a = { bg = colors.red, fg = colors.background },
        b = { bg = colors.background, fg = colors.red },
        c = { bg = colors.background, fg = colors.foreground },
    },
    command = {
        a = { bg = colors.magenta, fg = colors.background },
        b = { bg = colors.background, fg = colors.magenta },
        c = { bg = colors.background, fg = colors.foreground },
    },
    inactive = {
        a = { bg = colors.background, fg = colors.gray },
        b = { bg = colors.background, fg = colors.gray },
        c = { bg = colors.background, fg = colors.gray },
    },
}

local components = {
    mode = {
        function()
            return " "
        end,
        padding = { left = 0, right = 0 },
    },
    filename = {
        "filename",
    },
    diagnostics = {
        "diagnostics",
        sources = { "nvim_diagnostic" },
        symbols = { error = " ", warn = " ", info = " ", hint = " " },
    },
    treesitter = {
        function()
            local b = vim.api.nvim_get_current_buf()
            if next(vim.treesitter.highlighter.active[b]) then
                return ""
            end
            return ""
        end,
    },
    location = { "location" },
    progress = { "progress" },
    encoding = {
        "o:encoding",
        fmt = string.upper,
    },
    filetype = { "filetype" },
}

require("lualine").setup({
    options = {
        theme = custom_theme,
        icons_enabled = false,
        component_separators = { left = "", right = "" },
        section_separators = { left = "", right = "" },
        disabled_filetypes = { "dashboard", "NvimTree", "Outline" },
    },
    sections = {
        lualine_a = {},
        lualine_b = {
            components.filename,
        },
        lualine_c = {
            components.diff,
        },
        lualine_x = {
            lsp_progress,
            components.diagnostics,
        },
        lualine_y = {
            components.treesitter,
        },
        lualine_z = {},
    },
    inactive_sections = {
        lualine_a = {},
        lualine_b = {
            "filename",
        },
        lualine_c = {},
        lualine_x = {},
        lualine_y = {},
        lualine_z = {},
    },
    tabline = {
        lualine_a = {},
        lualine_b = { { "buffers" } },
        lualine_c = {},
        lualine_x = {},
        lualine_y = { { "tabs", mode = 0 } },
        lualine_z = {},
    },
    extensions = { "nvim-tree" },
})

Conclusion

Sooo much config I know! I am sorry about all of that. But it think having all of this config makes everything customizable for anyone. Take the settings I made as a grain of salt, I have an opinion about how vim should be for me. Hopefully this is just a foundation that someone can use to get up and running then modify things to the prefered settings. I also, left some commented out settings for further tinkering.

So if you have made it this far the next step is to try it out. Let see how it works.

main.py test

Create a file nvim main.py. On first load nvim is going to complain because none of the plugins are setup. Go ahead and just type q until the complaints end. We need restart nvim now that packer has been installed. qa then nvim main.py. Now we have packer we can :PackerSync this will install and update all the plugins defined in _plugins.lua. Close nvim one more time :qa. Now we got that over with then get on to testing out our setup. nvim main.py (notice that tree-sitter is installing a few things) let that happen in the background. Wait for tree-sitter to finish before exiting. Put this snippet in the file.

#!/usr/bin/env python

def echo(msg):
    print msg

if __name__ == "__main__":
    echo("Hello World!")

Save :w

install pyright server

Now we need to install the lsp server to work with python files. This can be done a few different ways fastest is to :LspInstall pyright, or one can access a "dashboard" with :LspInstallInfo and then use the help ? to see options. u will upgrade the server under the cursor, and i will install the server under the cursor.

Now that pyright is installed lets make sure it is working.

Notice line 4 msg is underlined and an E is indicated in the gitgutter. Move the cursor to line 4 and trigger the line diagnostics gl. If you see the popup you are configured correctly!

black formatter

I didn't go into very much detail about custom settings for the language servers that get installed or formatting and linting. Here is an
w to use black as the python formatter. We are using null-ls for the formatting here.

after/ftplugin/python.lua

 local null_ls = require("null-ls")

local sources = {
    null_ls.builtins.formatting.black,
}

null_ls.setup({ sources = sources })

Note null_ls can setup all settings in a regular way like the other lua files we created. Using the after dir / lazy loading is just one way of doing this.

Make sure black in installed pip install black. Lets try it out with our main.py file. Update it to the following, then save :w.

#!/usr/bin/env python
def echo(msg):
    print(msg)
if __name__ == "__main__":
    echo("Hello World!")

Note leader is space

Now to tell nvim to format with the defined formatter send leader lf.

And the result should be a nicely formatted python file.

And that about wraps it up.

Minimal (neo)vim with VSCode like setup

Cason Adams — Sun, 26 Dec 2021 07:39:09 +0000

I wanted to share a quick little setup to get up and running quickly with vim as an IDE. I don't really like vim and IDE in the same sentence, but I do have to admit that having an IDE that runs in the terminal and loads fast is pretty sweet.
header image

~/.vimrc

~/.vim
├── _lsp.vim
├── _options.vim
├── _plugins.vim
├── _theme.vim

Requirements

nodejs

create ~/.vim directory

First we need a place to store a few files. I am going to put them in ${HOME}/.vim/ so I will make that directory.

_theme.vim (optional)

Lets create a file to store theme settings. I am going to put it in ${HOME}/.vim/_theme.vim.

syntax enable
" set t_Co=16 " uncomment to force ANSI 16 colors

if has('gui_running')
    set background=light
else
    set background=dark
endif

colorscheme gruvbox8

_options.vim (optional)

Lets create a file to store vim options. I am going to put it in ${HOME}/.vim/_options.vim. I tried to document the options below. These are optional, I borrowed some of this information from LunarVims default settings. Most options can be prefixed with no to disable the behavior.

let mapleader="\ " " set leader key to space

set clipboard="" " don't use clipboard
set cmdheight=1 " more space in the neovim command line for
set colorcolumn="99999" " fixes indentline for now
set completeopt=menuone,noselect
set conceallevel=0 " so that `` is visible in markdown files
set cursorline " highlight the current line
set expandtab " convert tabs to spaces
set fileencoding="utf-8" " the encoding written to a file
set foldexpr="" " set to "nvim_treesitter#foldexpr()" for treesitter based folding
set hidden " required to keep multiple buffers and open multiple buffers
set hlsearch " highlight all matches on previous search pattern
set ignorecase " ignore case in search patterns
set laststatus=2 " hide statusline
set list " show hidden chars
set listchars=tab:│\ ,trail:·,nbsp:+
set nobackup " creates a backup file
set norelativenumber " set relative numbered lines
set nospell " disable spell checking
set noswapfile " creates a swapfile
set nowritebackup " if a file is being edited by another program (or was written to file while editing with another program) it is not allowed to be edited
set number " set numbered lines
set numberwidth=1 " set number column width to 2 {default 4}
set pumheight=10 " pop up menu height
set scrolloff=4 " is one of my fav
set shiftwidth=2 " the number of spaces inserted for each indentation
set showmode " shows " INSERT " in cmdline
set showtabline=2 " always show tabs
set sidescrolloff=4
set signcolumn="yes" " always show the sign column otherwise it would shift the text each time
set smartcase " smart case
set smartindent " make indenting smarter again
set spelllang="en" " language for spell checking
set splitbelow " force all horizontal splits to go below current window
set splitright " force all vertical splits to go to the right of current window
set tabstop=2 " insert 2 spaces for a tab
set timeoutlen=500 " timeout length
set title " set the title of window to the value of the titlestring
set titlestring="%<%F - vim" " what the title of the window will be set to
set undodir="/undo" .. "/undo"
set undofile " enable persistent undo
set updatetime=300 " faster completion
set wrap " display lines as one long line

_plugins.vim

Lets create a file to manage vim plugins. I am going to put it in ${HOME}/.vim/_plugins.vim. For this tutorial we are using vim-plug.

Note fancy things are happening in the first 2 blocks of code that will auto install vim-plug and auto install missing plugins. (curl is required for this magic to happen)
Note 3 plugins are being installed here:
1. coc.nvim (LSP IDE magic)
2. vim-gruvbox8 (colorscheme)
3. vim-commentary (nice shortcuts for code commenting)

" https://github.com/junegunn/vim-plug/wiki/tips#automatic-installation

" Install vim-plug if not found
if empty(glob('~/.vim/autoload/plug.vim'))
   silent !curl -fLo ~/.vim/autoload/plug.vim --create-dirs
     \ https://raw.githubusercontent.com/junegunn/vim-plug/master/plug.vim
   endif

" Run PlugInstall if there are missing plugins
autocmd VimEnter * if len(filter(values(g:plugs), '!isdirectory(v:val.dir)'))
 \| PlugInstall --sync | source $MYVIMRC
 \| endif

" Plugins
call plug#begin()
  Plug 'neoclide/coc.nvim', {'branch': 'release'}
  Plug 'lifepillar/vim-gruvbox8'
  Plug 'tpope/vim-commentary'
call plug#end()

Most used shortcut key for vim-commentary

Shortcut	Description
`gcc`	comment / uncomment

_lsp.vim

Lets create a file to manage vim lsp servers. I am going to put it in ${HOME}/.vim/_lsp.vim. This is where we will configure coc.nvim.

From the example. The following has been slightly modified moving some options to _options.vim, and configuring the statusline to be as close to vanilla vim with some lsp information.

" Use tab for trigger completion with characters ahead and navigate.
" NOTE: Use command ':verbose imap <tab>' to make sure tab is not mapped by
" other plugin before putting this into your config.
inoremap <silent><expr> <TAB>
      \ pumvisible() ? "\<C-n>" :
      \ <SID>check_back_space() ? "\<TAB>" :
      \ coc#refresh()
inoremap <expr><S-TAB> pumvisible() ? "\<C-p>" : "\<C-h>"

function! s:check_back_space() abort
  let col = col('.') - 1
  return !col || getline('.')[col - 1]  =~# '\s'
endfunction

" Use <c-space> to trigger completion.
if has('nvim')
  inoremap <silent><expr> <c-space> coc#refresh()
else
  inoremap <silent><expr> <c-@> coc#refresh()
endif

" Make <CR> auto-select the first completion item and notify coc.nvim to
" format on enter, <cr> could be remapped by other vim plugin
inoremap <silent><expr> <cr> pumvisible() ? coc#_select_confirm()
                              \: "\<C-g>u\<CR>\<c-r>=coc#on_enter()\<CR>"


" Use `[g` and `]g` to navigate diagnostics
" Use `:CocDiagnostics` to get all diagnostics of current buffer in location list.
nmap <silent> [g <Plug>(coc-diagnostic-prev)
nmap <silent> ]g <Plug>(coc-diagnostic-next)

" GoTo code navigation.
nmap <silent> gd <Plug>(coc-definition)
nmap <silent> gy <Plug>(coc-type-definition)
nmap <silent> gi <Plug>(coc-implementation)
nmap <silent> gr <Plug>(coc-references)

" Use K to show documentation in preview window.
nnoremap <silent> K :call <SID>show_documentation()<CR>

function! s:show_documentation()
  if (index(['vim','help'], &filetype) >= 0)
    execute 'h '.expand('<cword>')
  elseif (coc#rpc#ready())
    call CocActionAsync('doHover')
  else
    execute '!' . &keywordprg . " " . expand('<cword>')
  endif
endfunction

" Highlight the symbol and its references when holding the cursor.
" autocmd CursorHold * silent call CocActionAsync('highlight')

" Symbol renaming.
nmap <leader>rn <Plug>(coc-rename)

" Formatting selected code.
xmap <leader>f  <Plug>(coc-format-selected)
nmap <leader>f  <Plug>(coc-format-selected)

augroup mygroup
  autocmd!
  " Setup formatexpr specified filetype(s).
  autocmd FileType typescript,json setl formatexpr=CocAction('formatSelected')
  " Update signature help on jump placeholder.
  autocmd User CocJumpPlaceholder call CocActionAsync('showSignatureHelp')
augroup end

" Applying codeAction to the selected region.
" Example: `<leader>aap` for current paragraph
xmap <leader>a  <Plug>(coc-codeaction-selected)
nmap <leader>a  <Plug>(coc-codeaction-selected)

" Remap keys for applying codeAction to the current buffer.
nmap <leader>ac  <Plug>(coc-codeaction)
" Apply AutoFix to problem on the current line.
nmap <leader>qf  <Plug>(coc-fix-current)

" Run the Code Lens action on the current line.
nmap <leader>cl  <Plug>(coc-codelens-action)

" Map function and class text objects
" NOTE: Requires 'textDocument.documentSymbol' support from the language server.
xmap if <Plug>(coc-funcobj-i)
omap if <Plug>(coc-funcobj-i)
xmap af <Plug>(coc-funcobj-a)
omap af <Plug>(coc-funcobj-a)
xmap ic <Plug>(coc-classobj-i)
omap ic <Plug>(coc-classobj-i)
xmap ac <Plug>(coc-classobj-a)
omap ac <Plug>(coc-classobj-a)

" Remap <C-f> and <C-b> for scroll float windows/popups.
if has('nvim-0.4.0') || has('patch-8.2.0750')
  nnoremap <silent><nowait><expr> <C-f> coc#float#has_scroll() ? coc#float#scroll(1) : "\<C-f>"
  nnoremap <silent><nowait><expr> <C-b> coc#float#has_scroll() ? coc#float#scroll(0) : "\<C-b>"
  inoremap <silent><nowait><expr> <C-f> coc#float#has_scroll() ? "\<c-r>=coc#float#scroll(1)\<cr>" : "\<Right>"
  inoremap <silent><nowait><expr> <C-b> coc#float#has_scroll() ? "\<c-r>=coc#float#scroll(0)\<cr>" : "\<Left>"
  vnoremap <silent><nowait><expr> <C-f> coc#float#has_scroll() ? coc#float#scroll(1) : "\<C-f>"
  vnoremap <silent><nowait><expr> <C-b> coc#float#has_scroll() ? coc#float#scroll(0) : "\<C-b>"
endif

" Use CTRL-S for selections ranges.
" Requires 'textDocument/selectionRange' support of language server.
nmap <silent> <C-s> <Plug>(coc-range-select)
xmap <silent> <C-s> <Plug>(coc-range-select)

" Add `:Format` command to format current buffer.
command! -nargs=0 Format :call CocAction('format')

" Add `:Fold` command to fold current buffer.
command! -nargs=? Fold :call     CocAction('fold', <f-args>)

" Add `:OR` command for organize imports of the current buffer.
command! -nargs=0 OR   :call     CocActionAsync('runCommand', 'editor.action.organizeImport')

" Add (Neo)Vim's native statusline support.
" NOTE: Please see `:h coc-status` for integrations with external plugins that
" provide custom statusline: lightline.vim, vim-airline.
set statusline=\ %<%f\ %h%m%r
set statusline+=%=%-10.50{ShowCocStatus()}\ %-.(%l,%c%V%)\ %P

function! ShowCocStatus() 
  return get(g:, 'coc_status', '')
endfunc

" Mappings for CoCList
" Show all diagnostics.
nnoremap <silent><nowait> <space>a  :<C-u>CocList diagnostics<cr>
" Manage extensions.
nnoremap <silent><nowait> <space>e  :<C-u>CocList extensions<cr>
" Show commands.
nnoremap <silent><nowait> <space>c  :<C-u>CocList commands<cr>
" Find symbol of current document.
nnoremap <silent><nowait> <space>o  :<C-u>CocList outline<cr>
" Search workspace symbols.
nnoremap <silent><nowait> <space>s  :<C-u>CocList -I symbols<cr>
" Do default action for next item.
nnoremap <silent><nowait> <space>j  :<C-u>CocNext<CR>
" Do default action for previous item.
nnoremap <silent><nowait> <space>k  :<C-u>CocPrev<CR>
" Resume latest coc list.
nnoremap <silent><nowait> <space>p  :<C-u>CocListResume<CR>

There is a lot going on in there. This makes it so we get (tab) completion on typing, and setups tons of shortcuts for quickly doing things. Look for nmap for all the settings. Here are a few of the very basics.

Shortcut	Description
`gd`	go to def
`K`	show hover
`leader rn`	rename
`leader f`	call format

Note some languages require formatters to be installed first. As an example in python the default formatter using coc-pyright server is autopep8. In order to use this formatter pip install autopep8 etc...

vimrc

Now lets bring it all together. Open ${HOME}/.vimrc (I am not sure where this lives in windows sorry) and add the following.

source ~/.vim/_options.vim
source ~/.vim/_plugins.vim
source ~/.vim/_lsp.vim
source ~/.vim/_theme.vim

Installing servers

Lets try installing a coc.nvim extension. Quick link to some extenstions. For the purpose of this post lets install coc-pyright and try it out with a python file.

Install extenstion

Lets create a simple python file. vim main.py

Note line 4 has an error, and once we are setup with coc.nvim we should see it.

#!/usr/bin/env python

def echo(msg):
    print msg

if __name__ == "__main__":
    echo("Hello World!")

Install coc-pyright :CocInstall coc-pyright
Save the file :wq

Next time the file is open it is expected to see an error indicated in line 4. Move the cursor to msg and the following should pop up.

Conclusion

If everything is working as planned you have successfully setup coc.nvim and are now off to the races to further configure things. Happy hacking.

Neovim LSP only show line error on CursorHold

Cason Adams — Fri, 08 Oct 2021 08:05:04 +0000

I've been using lunarvim for just a bit now, and It is pretty well setup. I recommend trying it out.

Here is a fun little trick to show only the line error for the given line the cursor is on.

There are somethings it doesn't do and that is change the line color base on the error type (Error, Warn, etc..). It is setup to just use highlight for Comment

Open ~/.config/lvim/config.lua and add the following:

lvim.lsp.diagnostics.virtual_text = false


function PrintDiagnostics(opts, bufnr, line_nr, client_id)
  opts = opts or {}

  bufnr = bufnr or 0
  line_nr = line_nr or (vim.api.nvim_win_get_cursor(0)[1] - 1)

  local line_diagnostics = vim.lsp.diagnostic.get_line_diagnostics(bufnr, line_nr, opts, client_id)
  if vim.tbl_isempty(line_diagnostics) then return end

  local diagnostic_message = ""
  for i, diagnostic in ipairs(line_diagnostics) do
    diagnostic_message = diagnostic_message .. string.format("%s ", diagnostic.message or "")
  end
  -- print(diagnostic_message) -- on comment to print to MsgArea
  vim.api.nvim_buf_set_virtual_text(bufnr, 1, line_nr , {{diagnostic_message, "Comment"}}, {})
end

function Clear(_, bufnr, _, _)
-- print("    ") -- on comment to print to MsgArea
  vim.api.nvim_buf_clear_namespace(bufnr, 1, 0, -1)
end

vim.cmd [[ autocmd CursorHold * lua PrintDiagnostics() ]]
vim.cmd [[ autocmd CursorMoved * lua Clear() ]]

Trying to reach terminal constancy using ANSI only colors

Cason Adams — Fri, 17 Sep 2021 00:23:20 +0000

I really like spending as much of my day as a software engineer in the terminal. I really wanted to get all the things to match colors, themes, etc. Now keep in mind this doesn't always solve all the things but it is a good step forward.

Goal

Use terminal colors across vi, tmux, bat, fzf, and most other terminal applications.

Terminal setup

I really like the alacritty terminal and I needed to find a color style that works for me. I ended up with something like this:

schemes:
  dark: &dark
    primary:
      background: "#2B2B2B"
      foreground: "#BBBBBB"

    normal:
      black: "#252525"
      red: "#DB5451"
      green: "#548C26"
      yellow: "#A89022"
      blue: "#3A91CF"
      magenta: "#A575BA"
      cyan: "#009191"
      white: "#CCCCCC"
    bright:
      black: "#666666"
      white: "#FFFFFF"

  light: &light
    primary:
      background: "#E2E2E2"
      foreground: "#666666"

    normal:
      black: "#FFFFFF"
      red: "#DB5451"
      green: "#548C26"
      yellow: "#A89022"
      blue: "#3A91CF"
      magenta: "#A575BA"
      cyan: "#009191"
      white: "#AAAAAA"
    bright:
      black: "#666666"
      white: "#000000"

colors: *dark

I can switch between dark and light mode by changing the colors: value. And because alacritty can do live reload of the config file. A simple script to modify that value allows for light and dark mode switching via the command line. And because I am using all ANSI colors for things everything changes in real time.

Vim setup

I created a color theme for vim based off vim-dim

Using vim-plug I load the plugin like this:

call plug#begin('~/.config/nvim/plugged'
  Plug 'casonadams/vim-dim'
call plug#end()

colorscheme dim

Be sure that set termguicolors is not in the vimrc or init.vim file.

shell setup

I use fzf and bat for fuzzy searching to set it to use ANSI colors do the following in a bashrc or zshrc file.

snippet

export BAT_THEME="ansi"

export FZF_DEFAULT_OPTS="
--inline-info \
--layout=reverse \
--ansi \
--color=16 \

full working example

export BAT_THEME="ansi"
export FZF_DEFAULT_COMMAND="fd -uu"
export FZF_CTRL_T_COMMAND="${FZF_DEFAULT_COMMAND} --type file"
export FZF_ALT_C_COMMAND="${FZF_DEFAULT_COMMAND} --type directory"
export FZF_DEFAULT_OPTS="
--inline-info \
--layout=reverse \
--ansi \
--color=16 \
--preview-window=:hidden \
--preview '([[ -f {} ]] \
    && (bat --style=numbers --color=always {} \
    || cat {})) \
    || ([[ -d {} ]] && (tree -C {} | less)) \
    || echo {} 2> /dev/null | head -200' \
--bind '?:toggle-preview'
"

tmux fun (iterm dimming)

Modifying tmux doesn't need to happen, but this is a fun trick to add using this color idea.

Currently this only looks good in dark mode

set -g pane-border-style fg=colour8,bg=colour237
set -g pane-active-border-style fg=blue,bg=colour237

set-window-option -g window-active-style bg=terminal
set-window-option -g window-style bg=colour237

full tmux color settings from images

######### THEME  ##########
set -g status-style bg=colour8,fg=colour7
setw -g clock-mode-colour green

set -g mode-style bg=blue,fg=colour7
set -g message-style bg=colour8,fg=colour7
set -g message-command-style bg=colour8,fg=colour7

set-option -g status-right-length 100
set-option -g status-left-length 100
set -g status-left " #{?pane_synchronized, ¤ ,}#{?window_zoomed_flag, ↕ ,}[#S-#{window_active_clients}] "

set -g status-right "#(cd #{pane_current_path}; git branch --show-current) #H "

set -g pane-border-style fg=colour8,bg=colour237
set -g pane-active-border-style fg=blue,bg=colour237

set-window-option -g window-active-style bg=terminal
set-window-option -g window-style bg=colour237

Neovim and its built in language server protocol

Cason Adams — Tue, 16 Feb 2021 14:29:54 +0000

I have been using coc for a few years now as my link to the various language servers out there. It is awesome! However, recently I have been tinkering with the built in LSP in neovim 0.5.0+. At the time of writing this, it is almost stable. I just wanted to share how I got things setup and working for me.

Requirements:

This brings in the tools that I use. I have included an upgrade.sh file that auto installs the needed language servers (macOS or fedora). There are a few more deps needed if one wants to run this. Most packages managers will have these.

golang
fd

Once everything is setup a few shortcut keys defined below will be as follows:

keys	description
gd	goto definition
gD	goto declaration
gr	show references
gi	goto implementation
K	show doc
SPACE rn	rename
SPACE e	show line diagnostics
[d	diagnostic previous
]d	diagnostic next

init.vim

~/.config/nvim/init.vim

"------------------------------------------------
" Plugins START
call plug#begin()
  Plug 'neovim/nvim-lspconfig'
  Plug 'nvim-lua/completion-nvim'
  Plug 'nvim-lua/lsp-status.nvim'
  Plug 'nvim-lua/diagnostic-nvim'
  Plug 'airblade/vim-gitgutter'
  Plug 'sbdchd/neoformat'
call plug#end()
" Plugins END
"------------------------------------------------

" Loads lua config
lua require('init')

" Use <Tab> and <S-Tab> to navigate through popup menu
inoremap <expr> <Tab>   pumvisible() ? "\<C-n>" : "\<Tab>"
inoremap <expr> <S-Tab> pumvisible() ? "\<C-p>" : "\<S-Tab>"

"------------------------------------------------
" Settings START
filetype plugin on
set updatetime=300
set completeopt=menuone
set completeopt+=noinsert
set completeopt-=preview
set shortmess+=c
" Settings END
"------------------------------------------------

"------------------------------------------------
" Status Line START
set statusline=%<%f\ %h%m%r
set statusline+=%=%-10.60{LspStatus()}\ %-.(%l,%c%V%)\ %P

function! LspStatus() abort
  if luaeval('#vim.lsp.buf_get_clients() > 0')
    return luaeval("require('lsp-status').status()")
  endif

  return ''
endfunction
" Status Line END
"------------------------------------------------

init.lua

~/.config/nvim/lua/init.lua

local nvim_lsp = require "lspconfig"
local lsp_status = require("lsp-status")

-- function to attach completion when setting up lsp
local on_attach = function(client)
    lsp_status.register_progress()
    lsp_status.config(
        {
            status_symbol = "LSP ",
            indicator_errors = "E",
            indicator_warnings = "W",
            indicator_info = "I",
            indicator_hint = "H",
            indicator_ok = "ok"
        }
    )

    require "completion".on_attach(client)
    local function buf_set_keymap(...)
        vim.api.nvim_buf_set_keymap(bufnr, ...)
    end
    local function buf_set_option(...)
        vim.api.nvim_buf_set_option(bufnr, ...)
    end

    buf_set_option("omnifunc", "v:lua.vim.lsp.omnifunc")

    -- Mappings.
    local opts = {noremap = true, silent = true}
    buf_set_keymap("n", "gD", "<Cmd>lua vim.lsp.buf.declaration()<CR>", opts)
    buf_set_keymap("n", "gd", "<Cmd>lua vim.lsp.buf.definition()<CR>", opts)
    buf_set_keymap("n", "gr", "<cmd>lua vim.lsp.buf.references()<CR>", opts)
    buf_set_keymap("n", "gi", "<cmd>lua vim.lsp.buf.implementation()<CR>", opts)
    buf_set_keymap("n", "K", "<Cmd>lua vim.lsp.buf.hover()<CR>", opts)
    buf_set_keymap("n", "<space>rn", "<cmd>lua vim.lsp.buf.rename()<CR>", opts)
    buf_set_keymap("n", "<space>e", "<cmd>lua vim.lsp.diagnostic.show_line_diagnostics()<CR>", opts)
    buf_set_keymap("n", "[d", "<cmd>lua vim.lsp.diagnostic.goto_prev()<CR>", opts)
    buf_set_keymap("n", "]d", "<cmd>lua vim.lsp.diagnostic.goto_next()<CR>", opts)

    -- Set some keybinds conditional on server capabilities
    if client.resolved_capabilities.document_formatting then
        buf_set_keymap("n", "<space>f", "<cmd>lua vim.lsp.buf.formatting()<CR>", opts)
    elseif client.resolved_capabilities.document_range_formatting then
        buf_set_keymap("n", "<space>f", "<cmd>lua vim.lsp.buf.range_formatting()<CR>", opts)
    end

    -- Set autocommands conditional on server_capabilities
    if client.resolved_capabilities.document_highlight then
        vim.api.nvim_exec([[
            augroup lsp_document_highlight
            autocmd! * <buffer>
            autocmd CursorHold <buffer> lua vim.lsp.buf.document_highlight()
            autocmd CursorMoved <buffer> lua vim.lsp.buf.clear_references()
            " autocmd CursorHold *.* :lua vim.lsp.diagnostic.show_line_diagnostics()
            autocmd BufWritePre * lua vim.lsp.buf.formatting_sync(nil, 300)
           augroup END
        ]],
            false
        )
    else
        vim.api.nvim_exec([[
            autocmd!
            autocmd BufWritePre * Neoformat
            augroup END
        ]], false)
    end
end

-- Use a loop to conveniently both setup defined servers
-- and map buffer local keybindings when the language server attaches
local servers = {
    "gopls",
    "dockerls",
    "tsserver",
    "bashls",
    "cmake",
    "pyright",
    "rust_analyzer",
    "clangd"
}
for _, lsp in ipairs(servers) do
    nvim_lsp[lsp].setup {
        on_attach = on_attach,
        capabilities = lsp_status.capabilities
    }
end

-- Setup diagnostics formaters and linters for non LSP provided files
nvim_lsp.diagnosticls.setup {
    on_attach = on_attach,
    capabilities = lsp_status.capabilities,
    cmd = {"diagnostic-languageserver", "--stdio"},
    filetypes = {
        "lua",
        "sh",
        "markdown",
        "json",
        "yaml",
        "toml"
    },
    init_options = {
        linters = {
            shellcheck = {
                command = "shellcheck",
                debounce = 100,
                args = {"--format", "json", "-"},
                sourceName = "shellcheck",
                parseJson = {
                    line = "line",
                    column = "column",
                    endLine = "endLine",
                    endColumn = "endColumn",
                    message = "${message} [${code}]",
                    security = "level"
                },
                securities = {
                    error = "error",
                    warning = "warning",
                    info = "info",
                    style = "hint"
                }
            },
            markdownlint = {
                command = "markdownlint",
                isStderr = true,
                debounce = 100,
                args = {"--stdin"},
                offsetLine = 0,
                offsetColumn = 0,
                sourceName = "markdownlint",
                formatLines = 1,
                formatPattern = {
                    "^.*?:\\s?(\\d+)(:(\\d+)?)?\\s(MD\\d{3}\\/[A-Za-z0-9-/]+)\\s(.*)$",
                    {
                        line = 1,
                        column = 3,
                        message = {4}
                    }
                }
            }
        },
        filetypes = {
            sh = "shellcheck",
            markdown = "markdownlint"
        },
        formatters = {
            shfmt = {
                command = "shfmt",
                args = {"-i", "2", "-bn", "-ci", "-sr"}
            },
            prettier = {
                command = "prettier",
                args = {"--stdin-filepath", "%filepath"},
            }
        },
        formatFiletypes = {
            sh = "shfmt",
            json = "prettier",
            yaml = "prettier",
            toml = "prettier",
            markdown = "prettier",
            lua = "prettier"
        }
    }
}

-- Enable diagnostics
vim.lsp.handlers["textDocument/publishDiagnostics"] =
    vim.lsp.with(
    vim.lsp.diagnostic.on_publish_diagnostics,
    {
        underline = true,
        virtual_text = false,
        signs = true,
        update_in_insert = true
    }
)

upgrade.sh

~/.config/nvim/upgrade.sh

#!/usr/bin/env bash
set -e

system_type=$(uname -s)
if [ "$system_type" = "Darwin" ]; then
  brew install shellcheck
  brew install shfmt
  brew install llvm
  fd 'clangd$' /usr/local/ --exec ln -s '{}' "$HOME"/.local/bin | :

  curl -L https://github.com/rust-analyzer/rust-analyzer/releases/download/nightly/rust-analyzer-mac.gz | gunzip -f > "$HOME"/.local/bin/rust-analyzer && chmod +x "$HOME"/.local/bin/rust-analyzer

else
  sudo dnf install -y \
    ShellCheck \
    clang-tools-extra \
    ;

  curl -L https://github.com/rust-analyzer/rust-analyzer/releases/download/nightly/rust-analyzer-linux.gz | gunzip -f > "$HOME"/.local/bin/rust-analyzer && chmod +x "$HOME"/.local/bin/rust-analyzer
fi

sudo npm install -g -f \
  pyright \
  lua-fmt \
  prettier \
  prettier-plugin-toml \
  markdownlint \
  diagnostic-languageserver \
  typescript typescript-language-server \
  dockerfile-language-server-nodejs \
  ;

pip install --upgrade \
  cmake-language-server \
  ;

GO111MODULE=on go get golang.org/x/tools/gopls@latest

Edge Router X | OpenWRT | Tailscale

Cason Adams — Sun, 29 Nov 2020 08:22:48 +0000

Tailscale is an awesome opensource project. It leverages WireGuard to create a light weight VPN like connection.

I am using an EdgeRouter X with OpenWRT on it. This router is using a mipsle chipset.

Getting started

Build from source below or download the static bin file from builds

Clone the tailscale repo

git clone https://github.com/tailscale/tailscale.git

Build the `mipsle` binaries

Other options

GOOS=linux GOARCH=mipsle GOMIPS=softfloat go build -o tailscale tailscale.com/cmd/tailscale

GOOS=linux GOARCH=mipsle GOMIPS=softfloat go build -o tailscaled tailscale.com/cmd/tailscaled

Copy binaries to /usr/sbin/

scp <bins> root@<router-ip>:/usr/sbin/

Install deps

opkg update
opkg install ca-bundle kmod-tun

Create /etc/init.d/tailscaled

NOTE line /usr/sbin/tailscale up is commented out remove comment after logging in manually

#!/bin/sh /etc/rc.common
### BEGIN INIT INFO
# Provides:       tailscaled
# Description:    tailscaled daemon service
### END INIT INFO

USE_PROCD=1

# starts after network starts
START=21
# stops before networking stops
STOP=89

PROG=/usr/sbin/tailscaled

start_service() {
        echo "starting tailscaled"
        procd_open_instance
        procd_set_param env SERVICE_RUN_MODE=1
        procd_set_param command $PROG -state /etc/tailscale/tailscaled.state
        procd_set_param pidfile /var/run/tailscaled.pid
        procd_set_param stdout 1
        procd_set_param stderr 1
        procd_set_param respawn
        procd_close_instance
        # /usr/sbin/tailscale up
}

service_triggers() {
        procd_add_reload_trigger "tailscaled"
}

Make the file executable

chmod +x /etc/init.d/tailscaled

Test service

/etc/init.d/tailscaled start
/usr/sbin/tailscale up

This should prompt with a url. Use this to authorize the device. If everything is good. Remove the comment in the /etc/init.d/tailscaled (tailscale up)

Enable service

/etc/init.d/tailscaled enable

Reboot

reboot
Verify things are working

Simple vim note setup

Cason Adams — Fri, 20 Nov 2020 07:54:34 +0000

I have tried a few techniques in taking, organizing, and searching notes. I found the more notes I took the more difficult it was to find what I wanted, or keep them all organized. I decided to just let it slip and see what happens. I finally hit a point where I needed a fuzzy finder to find what I was looking for. This led me to this simple setup with vim.

Notes and where to keep them

First I needed a place to store my notes. I've tried file syncing software, which is fine but I really didn't want some process always on taking up resources. So I decided to use gitlab wiki. Here is how I got setup:

Create a private repo in gitlab. Then clone that repo's wiki to your local machine. Here is an example of cloning a wiki. I cloned this to $HOME and will set it as an ENV var in the steps to follow.

git clone git@gitlab.com:myawesomeproject/notes.wiki

side note

I don't like using auto command on exit/save to auto-commit the notes but that is an option. For now I do this manually as needed.

Notes and how to find what you are looking for

Setup an ENV var in ~/.bash_profile or ~/.bashrc or where ever your operating system loads in ENV vars. I use this export NOTES="$HOME/notes.wiki" this just needs to be the path that the notes wiki was cloned to.

Add fzf as a vim plugin Installing instructions

Create a helper method in the vimrc file. Then map :Notes to <Leader>n.

"------------------------------------------------
" Note search START
command! -bang -nargs=* Notes
  \ call fzf#vim#grep(
  \   'rg --column --line-number --no-heading --color=always --passthru "" $NOTES'.shellescape(<q-args>), 1,
  \   fzf#vim#with_preview(), <bang>0)

nmap <Leader>n :Notes<CR>
" Note search END
"------------------------------------------------

Reload vim and give it a try :Notes or <Leader>n will bring up all the notes from the defined $NOTES dir, and allow for fuzzy searching.

If you don't want to fuzzy search you can always run :FZF $NOTES inside of vim and search via file name.

Optional FZF settings

Adding these setting will allow to toggle the preview window while invoking fzf in both your shell, or in vim by using ? key.

This will also setup your shell to use fzf commands ctrl + r, and ctrl + t

For optimal performance I have installed (most package mangers have these tools available)

I have these settings in my ~/.bashrc file:

export NOTES="$HOME/notes.wiki"

if [ ! -f "${HOME}/.key-bindings.bash" ]; then
  curl -sSL \
    https://raw.githubusercontent.com/junegunn/fzf/master/shell/key-bindings.bash \
    -o "${HOME}/.key-bindings.bash" \
    ;
fi

source "${HOME}/.key-bindings.bash"

export FZF_DEFAULT_COMMAND="fd"
export FZF_CTRL_T_COMMAND="$FZF_DEFAULT_COMMAND --type file"
export FZF_ALT_C_COMMAND="$FZF_DEFAULT_COMMAND --type d"
export FZF_DEFAULT_OPTS="
--layout=reverse
--info=inline
--height=50%
--preview-window=:hidden
--preview '([[ -f {} ]] \
│·&& (bat --style=numbers --color=always {} \
│·|| cat {})) \
│·|| ([[ -d {} ]] && (tree -C {} | less)) \
│·|| echo {} 2> /dev/null | head -200'
--bind '?:toggle-preview'
"

Neovim auto select suggestions using coc-vim

Cason Adams — Tue, 22 Sep 2020 06:49:08 +0000

I do a lot of pair programming using vi and tmux so I try to accommodate those I pair with by adding features into vi that are similar to those in other IDEs.

I have been pairing with a colleague over the past few days and I noticed that every time a suggestion dialog would appear we ended up on the next line down and partially typed word above. Come to find out that Intellij has this nice option to autocomplete suggestions by auto selecting them as you type and auto filling if return is pressed.

Here is what I did to get this to work.

Requirements

neovim 4.4 or greater
coc-vim

I am going to just copy a segment from the coc-vim README and plug it into the ~/.config/nvim/init.vim file.

" --------------------------------------------------------
" SETTINGS START

set completeopt=longest,menuone

" SETTINGS END
" --------------------------------------------------------

" --------------------------------------------------------
" COC-VIM TAB SETTINGS START

" Use tab for trigger completion with characters ahead and navigate.
" NOTE: Use command ':verbose imap <tab>' to make sure tab is not mapped by
" other plugin before putting this into your config.
inoremap <silent><expr> <TAB>
      \ pumvisible() ? "\<C-n>" :
      \ <SID>check_back_space() ? "\<TAB>" :
      \ coc#refresh()
inoremap <expr><S-TAB> pumvisible() ? "\<C-p>" : "\<C-h>"

function! s:check_back_space() abort
  let col = col('.') - 1
  return !col || getline('.')[col - 1]  =~# '\s'
endfunction

" Use <c-space> to trigger completion.
if has('nvim')
  inoremap <silent><expr> <c-space> coc#refresh()
else
  inoremap <silent><expr> <c-@> coc#refresh()
endif

" Use <cr> to confirm completion, `<C-g>u` means break undo chain at current
" position. Coc only does snippet and additional edit on confirm.
" <cr> could be remapped by other vim plugin, try `:verbose imap <CR>`.
if exists('*complete_info')
  inoremap <expr> <cr> complete_info()["selected"] != "-1" ? "\<C-y>" : "\<C-g>u\<CR>"
else
  inoremap <expr> <cr> pumvisible() ? "\<C-y>" : "\<C-g>u\<CR>"
endif

" COC-VIM TAB SETTINGS END
" --------------------------------------------------------

Then add the following setting to ~/.config/nvim/coc-settings.json file. In vi execute :CocConfig

"suggest.noselect": false

DEV Community: Cason Adams

The "Claude Mythos" Illusion: Innovation or Data Harvesting?

The Security Pretext

The Data Ingestion Engine

Why This Is Different

The Takeaway

Manjaro Linux MacBook Pro 14,1

Download Manjaro Linux

Burn iso image to usb drive

Boot Mac via drive

Getting WiFi working

Install

Post Install

auto fix WiFi

fix sound

Set keyboard backlighting

Simple vim / terminal color changing

Why?

Terminal setup

Vim setup

Result

Ditch iTerm for Alacritty and tmux

setting up terminal theme

alacritty-shell option 1

alacritty theme manual update option 2

setting up tmux

see it in action

Neovim LSP to replace VSCode

TLDR;

Setup

init.lua

_options.lua

_plugins.lua

_lsp.lua

_treesitter.lua

_telescope.lua

_whichkey.lua

_statusline.lua

Conclusion

main.py test

install pyright server

black formatter

Minimal (neo)vim with VSCode like setup

Requirements

create ~/.vim directory

_theme.vim (optional)

_options.vim (optional)

_plugins.vim

_lsp.vim

vimrc

Installing servers

Install extenstion

Conclusion

Neovim LSP only show line error on CursorHold

Trying to reach terminal constancy using ANSI only colors

Goal

Terminal setup

Vim setup

shell setup

tmux fun (iterm dimming)

full tmux color settings from images

Neovim and its built in language server protocol

init.vim

init.lua

upgrade.sh

Edge Router X | OpenWRT | Tailscale

Getting started

Clone the tailscale repo

Build the mipsle binaries

Copy binaries to /usr/sbin/

Install deps

Create /etc/init.d/tailscaled

Test service

Enable service

Reboot

Simple vim note setup

Notes and where to keep them

side note

Notes and how to find what you are looking for

Optional FZF settings

Build the `mipsle` binaries