DEV Community: Varun D

[Claude Code] Super Simple Statusline

Varun D — Wed, 04 Mar 2026 08:15:41 +0000

Tested on Mac

This Super Simple Statusline shows Model Name, input token count, output token count, context progress bar + % and git status if available.

1. Install jq command line tool

JQ makes json parsing easier

JQ installation

2. Enable statusline in Claude Code settings

Modify your settings.json file found in top level .claude folder ~/.claude/settings.json.
If the file doesn't exist, create it.

Enable statusline

 {
    "statusLine": {
      "type": "command",
      "command": "~/.claude/statusline.sh",
      "padding": 2
    }
  }

3. Create statusline file and make it executable

Create statusline.sh file in the same folder

You can name it anything but make sure file path is the same in "command" in the settings.

touch ~/.claude/statusline.sh

Make it executable

chmod +x ~/.claude/statusline.sh

Write the statusline script to statusline.sh

This Super Simple Statusline file shows Model Name, input token count, output token count and context % progress bar.

#!/bin/bash
# Read JSON data that Claude Code sends to stdin
# Remember to install jq to extract data from json string, makes it easier
# You can piple json in text format to test the script
input=$(cat)

# Set color variables. Escape sequences can vary by system, bash, zsh, etc.
GREEN=$'\033[32m'
YELLOW=$'\033[33m'
RED=$'\033[91m'
RESET=$'\033[0m'

# Extract fields using jq. Remember to install jq
# Get Model Name
MODEL=$(echo "$input" | jq -r '.model.display_name')
# Get Used Percentage, Total Outout Tokens and Total Input Tokens, save to variables
# The "// 0" provides a fallback if the field is null
PCT=$(echo "$input" | jq -r '.context_window.used_percentage // 0' | cut -d. -f1)
OTOK=$(echo "$input" | jq -r '.context_window.total_output_tokens // 0' | cut -d. -f1)
ITOK=$(echo "$input" | jq -r '.context_window.total_input_tokens // 0' | cut -d. -f1)

# Context progress bar, yey
BAR_WIDTH=10
FILLED=$((PCT * BAR_WIDTH / 100))
EMPTY=$((BAR_WIDTH - FILLED))
BAR=""
[ "$FILLED" -gt 0 ] && BAR=$(printf "%${FILLED}s" | tr ' ' '▓')
[ "$EMPTY" -gt 0 ] && BAR="${BAR}$(printf "%${EMPTY}s" | tr ' ' '░')"

# Pick bar color based on usage. < 50 green, < 80 yello, otherwise red
if [ "$PCT" -lt 50 ]; then
    BAR_COLOR="$GREEN"
elif [ "$PCT" -lt 80 ]; then
    BAR_COLOR="$YELLOW"
else
    BAR_COLOR="$RED"  # bright red
fi

# Git status for folder, if available
if git rev-parse --git-dir > /dev/null 2>&1; then
    BRANCH=$(git branch --show-current 2>/dev/null)
    STAGED=$(git diff --cached --numstat 2>/dev/null | wc -l | tr -d ' ')
    MODIFIED=$(git diff --numstat 2>/dev/null | wc -l | tr -d ' ')

    GIT_STATUS=""
    [ "$STAGED" -gt 0 ] && GIT_STATUS="${GREEN}+${STAGED}${RESET}"
    [ "$MODIFIED" -gt 0 ] && GIT_STATUS="${GIT_STATUS}${YELLOW}~${MODIFIED}${RESET}"

    # Show statusline with git status if available
    echo -e "$MODEL | i$ITOK, o$OTOK | cntxt ${BAR_COLOR}$BAR${RESET} ${PCT}% |⎇  $BRANCH $GIT_STATUS"
else
    # Else show statusline without git status
    echo -e "$MODEL | i$ITOK, o$OTOK | cntxt ${BAR_COLOR}$BAR${RESET} ${PCT}%"
fi

3. Troubleshooting

a. If statusline isn't loading, check folder structure
b. Make sure statusline.sh file is executable, chmod +x ~/.claude/statusline.sh
c. Bash scripting is flaky, check quotes and escape characters

NotebookLM to learn about Canadian Parliament

Varun D — Thu, 23 Jan 2025 16:31:33 +0000

Using NotebookLM to learn about the Canadian Parliament

Listen to the Podcast here!

I would like to learn about the Canadian Parliament and the best way to do this would be to write down the content in NotebookLM, create a podcast and ask questions.

The following content is used to create the podcast. I've made it public. Next I would create a short YouTube video with visuals to gain deeper understanding and share this knowledge with others.

All content taken from this source.

Canada’s Parliament

Canada is a federation of 10 provinces and 3 territories that share a common federal government. In Parliament, Senators and Members of Parliament work together to represent Canadians from across the country.

Parliament passes laws that affect all Canadians, in areas like foreign policy and national defence. Each province makes its own laws in other domains, such as education and health care.

Canada is also a constitutional monarchy. This means that the Monarch is the Head of State and the Prime Minister is the Head of Government. Bills are created and passed by Parliament and signed into law by the Governor General (the Monarch’s representative in Canada).

There are three parts of Parliament, which all work together to create new laws.

The Work of the Senate

The Senate is Parliament’s Upper Chamber.

Senators are appointed by the Governor General, on the advice of the Prime Minister, to represent Canada’s regions, provinces and territories. The Senate’s 105 seats are distributed by region to ensure equal representation across the country. Senators are Canadians of accomplishment and experience from various professional backgrounds. Senators refine legislation, suggest amendments, introduce bills and debate on current issues. Much of the Senate’s work is done in committee, where Senators use their expertise and hear from witnesses to study bills.

The Speaker

The Speaker of the Senate is in charge of debates in the Senate Chamber and oversees the Senate’s operations. The Speaker ensures that the rules, procedures and traditions of the Senate are followed. The thrones behind the Speaker’s Chair are used by the Monarch or Governor General and their spouse.

The Senators

Senators are appointed by the Governor General on the advice of the Prime Minister to represent Canada’s provinces and territories. The Senate’s 105 seats are distributed by region to ensure equal representation across the country. Senators are accomplished Canadians from various professional backgrounds. They introduce bills, work to improve legislation passed by the House of Commons, suggest amendments, and debate issues.

The Government Representative

The Government Representative in the Senate (who used to be called the Government Leader) is a senator who is appointed by the Prime Minister to represent the Government’s bills and ideas in the Senate. This individual can attend Cabinet meetings and is responsible for answering questions about the Government’s bills.

The Government Liaison

The Government Liaison (who used to be called the Whip) ensures that the other senators have the information they need to vote on a bill. This senator also helps organize the timing of votes in the Senate Chamber.

The Leader of the Opposition

The Leader of the Opposition in the Senate is a senator who belongs to the same party as the Official Opposition in the House of Commons. This individual is chosen by the Leader of the Opposition in the House of Commons to help organize opposition to bills being discussed in the Senate Chamber and committees.

The Clerk of the Senate and Clerk of the Parliaments

The Clerk of the Senate and the Clerk of the Parliaments are two positions typically held by one person, who is the chief administrative officer of the Senate. The Clerk of the Senate advises the Speaker on procedural matters, supports the legislative process and has many duties related to the overall management of the Senate. The Clerk of the Parliaments is the keeper of all original acts (bills that have received Royal Assent) and is responsible for certifying true copies of these acts.

The Usher of the Black Rod

The Usher of the Black Rod has many ceremonial and administrative duties, including leading the Speaker’s Parade to start the day and overseeing the security of the Chamber. The Usher of the Black Rod organizes the Speech from the Throne as well as the Royal Assent ceremonies when the Governor General signs bills into law. The Black Rod itself is an ebony cane used to knock on the House of Commons doors to request access to the Chamber.

The table officers

The table officers are clerks who advise the Speaker and other senators on procedural matters. They also record proceedings and decisions in the official record of the Senate. They sit at the Clerk’s Table in the Chamber.

The stenographers

The stenographers produce the official record of the debates, discussions and decisions in the Senate. This record, commonly known as Hansard, is published in English and French after each sitting day.

Pages

Pages are university students from across Canada who are hired to support and assist the senators in the Chamber and in committee meetings.

The Mace

The Mace is the symbol of the Senate’s authority and the Senate cannot hold proceedings without it. When the Senate is sitting, it is carried by the Mace Bearer during the Speaker’s Parade and placed on the Clerk’s Table pointing toward the Thrones. Once the Mace is laid on the Table, the Senate is officially in session.

The Work of the House of Commons

The House of Commons is Parliament’s elected Lower Chamber.

Each of the 338 Members of Parliament (MPs) represents a specific geographic area in Canada, known as a constituency. MPs bring the concerns of the people who elected them to the House of Commons. They spend much of their time debating, voting and participating in committees.

Most MPs belong to a political party. Normally, the leader of the party with the most seats becomes the Prime Minister, and the second-largest party becomes the Official Opposition.

The Speaker of the House

The Speaker of the House maintains order in the Chamber and must be impartial. All questions, speeches and debates are directed to the Speaker, who ensures that the rules, procedures and traditions of the House are followed and applied to all MPs equally. The Speaker – who is an elected MP – also oversees the administration and finances of the House. The Speaker sits in the Speaker’s Chair in the centre of the Chamber.

Government MPs, including the Prime Minister

Government MPs, including the Prime Minister and Cabinet ministers, form the governing party. Government MPs decide for the most part what legislation is discussed in the Chamber. They propose new laws and policies for the country, which are then debated by all the MPs.

Opposition MPs challenge

Opposition MPs challenge government policies and hold the Government accountable for its actions. When the House is sitting, opposition MPs play an important role in questioning the Government about its actions and decisions during Question Period.

The Prime Minister

The Prime Minister is the Head of Government. They have many roles including political party leader, Cabinet leader and Member of Parliament (MP). The Prime Minister guides government policy, determines its agenda and selects a Cabinet, primarily from the governing party’s elected MPs. The Prime Minister sits to the right of the Speaker in the 11th seat.

Leader of the Official Opposition

The Official Opposition is the party with the second-highest number of elected MPs. The Official Opposition holds the government to account and challenges its policies. The Leader of the Official Opposition takes a lead role in debating and suggesting changes to government legislation. The Official Opposition party sits directly opposite from the Prime Minister and government members.

The Clerk of the House

The Clerk of the House and table officers sit at the table in front of the Speaker’s Chair and provide procedural advice to the Speaker and MPs. This table is called the Clerk’s Table. The Clerk is the chief administrative officer of the House and advises the Speaker on parliamentary procedure. Together, the Clerk and the table officers provide advice on the rules in the Chamber, count the votes and keep the official record of decisions made in the Chamber.

The Sergeant-at-Arms

The Sergeant-at-Arms is responsible for the security of the House and maintains order in the Chamber based on instruction from the Speaker. Each sitting day begins with the Speaker’s Parade – a ceremonial procession in which the Sergeant-at-Arms carries the Mace while escorting the Speaker to the Chamber.

Proceedings and verification officers

Proceedings and verification officers create an official record of the discussions and decisions made in the Chamber. This record, commonly known as Hansard, is published in English and French after each sitting day.

Pages

Pages are first-year university students from across Canada who work for the House of Commons. They carry messages and deliver documents to MPs in the Chamber.

The Mace

The Mace is the symbol of the Speaker’s authority and the right of the House of Commons to meet and pass new laws. The Mace is carried into the Chamber by the Sergeant-at-Arms and placed on the Clerk’s Table. It is a rule that the House cannot meet without the Mace in the Chamber.

How does bill become a law?

Step 1: A bill (proposed law) is introduced in either the Senate or the House of Commons.
Step 2: Parliamentarians debate the bill and vote to decide whether it should be studied further.
Step 3: If the bill passes, it is sent to a committee, which studies it in depth and may suggest changes.
Step 4: The bill goes back for a final debate and vote, based on the committee’s report.
Step 5: If the bill passes the vote, it is sent to the other Chamber, where it goes through the same process.
Step 6: Once the bill has been passed by both Chambers in identical form, it goes to the Governor General for Royal Assent and becomes Canadian law.

New DigitalOcean Droplet Setup

Varun D — Wed, 22 Jan 2025 23:48:26 +0000

New droplet created specifically for API hosting.
2GB Ram 50GB storage
Supabase as DB

About CAD 16/mo

Add SSH key on creation of Droplet

1. Initial Connection to Your Droplet

   ssh root@your_server_ip

2. Update the System

Update the package lists and upgrade installed packages:

   apt update && apt upgrade -y

Optionally, remove unnecessary packages:

   apt autoremove -y

3. Create a New User

Add a new user (replace your_username with the desired username):

   adduser your_username

Grant the new user sudo privileges:

   usermod -aG sudo your_username

4. Set Up SSH for the New User

Switch to the new user:

   su - your_username

Create the .ssh directory and set proper permissions:

   mkdir -p ~/.ssh && chmod 700 ~/.ssh

Copy your public SSH key to the new user’s authorized_keys file:

   nano ~/.ssh/authorized_keys

Paste your public key and save the file.

Set proper permissions:

   chmod 600 ~/.ssh/authorized_keys

Exit back to the root user:

   exit

Test logging in as the new user:

   ssh your_username@your_server_ip

5. Disable Root Login

Edit the SSH configuration file:

   sudo nano /etc/ssh/sshd_config

Find and set the following:

   PermitRootLogin no

Optionally, disable password authentication for additional security:

   PasswordAuthentication no

Restart the SSH service:

   sudo systemctl restart ssh

6. Install Docker

If you use ufw or firewalld to manage firewall settings, be aware that when you expose container ports using Docker, these ports bypass your firewall rules. For more information, refer to Docker and ufw.

Docker is only compatible with iptables-nft and iptables-legacy. Firewall rules created with nft are not supported on a system with Docker installed. Make sure that any firewall rulesets you use are created with iptables or ip6tables, and that you add them to the DOCKER-USER chain, see Packet filtering and firewalls.

Remove old stuff if needed:

for pkg in docker.io docker-doc docker-compose podman-docker containerd runc; do sudo apt-get remove $pkg; done

Install prerequisites:

   sudo apt-get install ca-certificates curl

Add Docker's official GPG key:


sudo install -m 0755 -d /etc/apt/keyrings
sudo curl -fsSL https://download.docker.com/linux/debian/gpg -o /etc/apt/keyrings/docker.asc
sudo chmod a+r /etc/apt/keyrings/docker.asc

Set up the Docker repository:

# Add the repository to Apt sources:
echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.asc] https://download.docker.com/linux/debian \
  $(. /etc/os-release && echo "$VERSION_CODENAME") stable" | \
  sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
sudo apt-get update

Install Docker:

sudo apt-get install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

Add your user to the Docker group to avoid running through sudo:

   sudo usermod -aG docker your_username
newgrp docker

Test run. This will not run due to permission issue.

docker run hello-world

Enable and start Docker (if above didn't work):

   sudo systemctl enable docker
   sudo systemctl start docker

For more info, check official docks on linux post install.

7. Install Caddy

Download the official Caddy installation script:



sudo apt install -y debian-keyring debian-archive-keyring apt-transport-https curl
curl -1sLf 'https://dl.cloudsmith.io/public/caddy/stable/gpg.key' | sudo gpg --dearmor -o /usr/share/keyrings/caddy-stable-archive-keyring.gpg
curl -1sLf 'https://dl.cloudsmith.io/public/caddy/stable/debian.deb.txt' | sudo tee /etc/apt/sources.list.d/caddy-stable.list

Install Caddy:

   sudo apt update
   sudo apt install -y caddy

Enable and start Caddy:

   sudo systemctl enable caddy
   sudo systemctl start caddy

8. Secure Your Firewall

Allow SSH, HTTP, and HTTPS through the firewall:

   sudo apt install -y ufw
sudo ufw default deny incoming
sudo ufw default allow outgoing

   sudo ufw allow OpenSSH
   sudo ufw allow 80
   sudo ufw allow 443

# Use if keeping behind a DNS (e.g., cloudflare)
udo ufw allow from 203.0.X.X

Enable the firewall:

   sudo ufw enable

9. Verify Installations

Check Docker:

  docker --version

Check Caddy:

  caddy version

10. Optional: Set Up a Basic Caddyfile

Edit the Caddy configuration:

   sudo nano /etc/caddy/Caddyfile

Example configuration for a website:

   yourdomain.com {
       root * /var/www/html
       file_server
   }

Test the Caddyfile:

   sudo caddy validate

Reload Caddy to apply changes:

   sudo systemctl reload caddy

[Quickstart] Python FastAPI with uv

Varun D — Mon, 13 Jan 2025 03:14:05 +0000

Install uv for Python package and venv manager

UV Official Docs

brew install uv

Initialize UV and install FastAPI

Create project folder and move into it

mkcd myproject

Initialize uv inside it

uv init

Add my packages, e.g., FastAPI

uv add fastapi --extra standard

Setup project structure

Create folder /app

mkcd app

Add file __init__.py inside /app
Add file main.py inside /app

touch __init__.py
touch main.py

Run fastapi

uv run fastapi dev

https://fastapi.tiangolo.com/tutorial/first-steps/

Sample API, GET and POST (add this to app/main.py)

from typing import Union
from pydantic import BaseModel
from fastapi import FastAPI
from fastapi.middleware.cors import CORSMiddleware
from datetime import datetime


app = FastAPI()

# Not safe! Add your own allowed domains
origins = [
    "*",
] 

app.add_middleware(
    CORSMiddleware,
    allow_origins=origins,
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
)

# Define what you will receiving in request
class TypePayload(BaseModel):
    content: str

# Example GET route for app
@app.get("/")
def read_root():
    return {"Message": "Hello World! FastAPI is working."}

# Example POST route for app
@app.post("/getdata")
async def create_secret(payload: TypePayload):
    with open('output_file.txt', 'a') as f:
        now = datetime.now()
        formatted_date = now.strftime("%B %d, %Y at %I:%M %p")
        f.write(formatted_date + ": " + payload.content)
        f.write('\n')
    return payload.content

[Optional] Setting up logging

import logging

# Get the univorn logger for the same CLI look
logger = logging.getLogger("uvicorn")

logger.info("GET request received at root endpoint")
logger.error("This is a test error.")

Notes on React Typescript

Varun D — Fri, 13 Oct 2023 14:31:16 +0000

Creating a simple component in a new file, Component.tsx being called from App.tsx with props passed to it:

App.tsx

//standard imports
import {Component} from "./Component"

// Some state example. Array of objects - most common.
const ArrayofObj = [
  {
    id: 1
    name: "Lovelace",
    age: 32,
    cool: true
}]

export function default App(){
return (
  <>
    <Component mystuff={ArrayofObj}/>
  </>
)}

Component.tsx

// Define type of props I get here.
// Any name that makes sense. Notice the [] at the end.
type propTypes = {
  ArrayofObj: { id: number; name: string; age: number; cool: bool }[];
// Specify it's an array using [] at the end!
};

// Accept prop with propTypes we defined above
export default function Component({ mystuff }: propTypes) {
// Create the lil pieces to put together later
  const mystuff_li = mystuff.map((item) => (
    <li key={item.id}/>{item.name} is {item.age} years old.</li>
  ));

// Return the stuffs
  return <ul>{friends_li}</ul>;
}

Some other common ones...
Callbacks with mouse events can be found by hovering over your own function.

For example, a button with onClick={handleCancel} received from parent, the prop type in this case will be:
handleCancel: React.MouseEventHandler<HTMLButtonElement>;

Good resource for TypeScript cheatsheets.

My Buns are hot. Bun + NextJS

Varun D — Tue, 03 Oct 2023 19:32:35 +0000

Started to learn NextJS and thought why not start using Bun.

Installed bun on my Mac:
curl -fsSL https://bun.sh/install | bash

Made sure it worked:
bun

Created my usual NextJS app with Typescript, Tailwind...
bunx create-next-app@latest myappname

Interesting how npx is bunx. Nice.

Installed shadcn for my UI needs. I like how it provides me with a boilerplate globals.css and a Tailwind config without complicating anything else. Shadcn is built over Radix UI primitives.
bunx shadcn-ui@latest init

and get button styles
bunx shadcn-ui@latest add button

Done! I start my dev server through
bun run dev