init

dbushell · dbushell · commit 4bf09040bd7c · 2025-03-03T13:04:44.000Z
diff --git a/.gitignore b/.gitignore
@@ -0,0 +1,8 @@
+.zig-cache
+zig-out
+**/*.*
+!**/*.zig
+!init.sh
+!.gitignore
+!LICENSE
+!README.md
diff --git a/LICENSE b/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 David Bushell
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/README.md b/README.md
@@ -0,0 +1,11 @@
+# ⚡ Zigbar
+
+Zigbar is my personal ZSH prompt written in [Zig](https://ziglang.org).
+
+Inspired by [Starship](https://github.com/starship/starship) and [Pure](https://github.com/sindresorhus/pure).
+
+🚧 Under construction!
+
+* * *
+
+[MIT License](/LICENSE) | Copyright © 2025 [David Bushell](https://dbushell.com)
diff --git a/build.zig b/build.zig
@@ -0,0 +1,91 @@
+const std = @import("std");
+
+// Although this function looks imperative, note that its job is to
+// declaratively construct a build graph that will be executed by an external
+// runner.
+pub fn build(b: *std.Build) void {
+    // Standard target options allows the person running `zig build` to choose
+    // what target to build for. Here we do not override the defaults, which
+    // means any target is allowed, and the default is native. Other options
+    // for restricting supported target set are available.
+    const target = b.standardTargetOptions(.{});
+
+    // Standard optimization options allow the person running `zig build` to select
+    // between Debug, ReleaseSafe, ReleaseFast, and ReleaseSmall. Here we do not
+    // set a preferred release mode, allowing the user to decide how to optimize.
+    const optimize = b.standardOptimizeOption(.{});
+
+    // const lib = b.addStaticLibrary(.{
+    //     .name = "Zigbar",
+    //     // In this case the main source file is merely a path, however, in more
+    //     // complicated build scripts, this could be a generated file.
+    //     .root_source_file = b.path("src/root.zig"),
+    //     .target = target,
+    //     .optimize = optimize,
+    // });
+
+    // // This declares intent for the library to be installed into the standard
+    // // location when the user invokes the "install" step (the default step when
+    // // running `zig build`).
+    // b.installArtifact(lib);
+
+    const exe = b.addExecutable(.{
+        .name = "Zigbar",
+        .root_source_file = b.path("src/main.zig"),
+        .target = target,
+        .optimize = optimize,
+    });
+
+    // This declares intent for the executable to be installed into the
+    // standard location when the user invokes the "install" step (the default
+    // step when running `zig build`).
+    b.installArtifact(exe);
+
+    // This *creates* a Run step in the build graph, to be executed when another
+    // step is evaluated that depends on it. The next line below will establish
+    // such a dependency.
+    const run_cmd = b.addRunArtifact(exe);
+
+    // By making the run step depend on the install step, it will be run from the
+    // installation directory rather than directly from within the cache directory.
+    // This is not necessary, however, if the application depends on other installed
+    // files, this ensures they will be present and in the expected location.
+    run_cmd.step.dependOn(b.getInstallStep());
+
+    // This allows the user to pass arguments to the application in the build
+    // command itself, like this: `zig build run -- arg1 arg2 etc`
+    if (b.args) |args| {
+        run_cmd.addArgs(args);
+    }
+
+    // This creates a build step. It will be visible in the `zig build --help` menu,
+    // and can be selected like this: `zig build run`
+    // This will evaluate the `run` step rather than the default, which is "install".
+    const run_step = b.step("run", "Run the app");
+    run_step.dependOn(&run_cmd.step);
+
+    // Creates a step for unit testing. This only builds the test executable
+    // but does not run it.
+    // const lib_unit_tests = b.addTest(.{
+    //     .root_source_file = b.path("src/root.zig"),
+    //     .target = target,
+    //     .optimize = optimize,
+    // });
+
+    // const run_lib_unit_tests = b.addRunArtifact(lib_unit_tests);
+
+    const exe_unit_tests = b.addTest(.{
+        .root_source_file = b.path("src/main.zig"),
+        .target = target,
+        .optimize = optimize,
+    });
+
+    const run_exe_unit_tests = b.addRunArtifact(exe_unit_tests);
+
+    // Similar to creating the run step earlier, this exposes a `test` step to
+    // the `zig build --help` menu, providing a way for the user to request
+    // running the unit tests.
+    const test_step = b.step("test", "Run unit tests");
+    // test_step.dependOn(&run_lib_unit_tests.step);
+    test_step.dependOn(&run_exe_unit_tests.step);
+}
diff --git a/init.sh b/init.sh
@@ -0,0 +1,3 @@
+setopt promptsubst
+
+PROMPT='$('${0:a:h}'/zig-out/bin/Zigbar prompt)'
diff --git a/src/Context.zig b/src/Context.zig
@@ -0,0 +1,191 @@
+const std = @import("std");
+const TTY = @import("./TTY.zig");
+const Allocator = std.mem.Allocator;
+const AutoHashMap = std.AutoHashMap;
+const Dir = std.fs.Dir;
+const eql = std.mem.eql;
+const extension = std.fs.path.extension;
+const isDigit = std.ascii.isDigit;
+
+/// Limit number of parent directories to scan (inclusive of current directory)
+const max_scan_depth = 10;
+
+pub const Prop = enum {
+    bun,
+    deno,
+    docker,
+    node,
+    rust,
+    zig,
+
+    /// Nerd font unicode characters
+    pub fn symbol(prop: Prop) []const u8 {
+        return switch (prop) {
+            .bun => "",
+            .deno => "",
+            .docker => "󰡨",
+            .node => "󰎙",
+            .rust => "󱘗",
+            .zig => "",
+        };
+    }
+
+    /// Spawn child process to get the version string.
+    /// If successful, caller owns result.
+    pub fn version(prop: Prop, allocator: Allocator) !?[]const u8 {
+        if (prop.versionArgv()) |argv| {
+            const result = std.process.Child.run(.{
+                .allocator = allocator,
+                .argv = argv,
+            }) catch return null;
+            if (result.term == .Exited) {
+                allocator.free(result.stderr);
+                return result.stdout;
+            }
+            allocator.free(result.stderr);
+            allocator.free(result.stdout);
+        }
+        return null;
+    }
+
+    /// Get the version command arguments
+    pub fn versionArgv(prop: Prop) ?[]const []const u8 {
+        return switch (prop) {
+            .bun => &.{ "bun", "-v" },
+            .deno => &.{ "deno", "-v" },
+            .docker => &.{ "docker", "-v" },
+            .node => &.{ "node", "-v" },
+            .rust => &.{ "rustc", "--version" },
+            .zig => &.{ "zig", "version" },
+        };
+    }
+
+    /// Returns a version slice, e.g. "1.0.0", trimming additional text
+    pub fn versionFormat(prop: Prop, string: []const u8) []const u8 {
+        _ = prop;
+        var start: usize = 0;
+        var end: usize = 0;
+        for (0..string.len) |i| if (isDigit(string[i])) {
+            start = i;
+            break;
+        };
+        for (start..string.len) |i| if (string[i] != '.' and !isDigit(string[i])) {
+            end = i;
+            break;
+        };
+        return if (start < end) string[start..end] else "";
+    }
+};
+
+const Context = @This();
+
+allocator: Allocator,
+cwd: Dir,
+props: AutoHashMap(Prop, void),
+
+pub fn init(allocator: Allocator, cwd: std.fs.Dir) Context {
+    return Context{
+        .allocator = allocator,
+        .cwd = cwd,
+        .props = AutoHashMap(Prop, void).init(allocator),
+    };
+}
+
+pub fn deinit(self: *Context) void {
+    self.props.deinit();
+}
+
+pub fn is(self: Context, prop: Prop) bool {
+    return self.props.contains(prop);
+}
+
+pub fn print(self: Context, tty: TTY) !void {
+    inline for (std.meta.fields(Prop)) |field| {
+        const prop: Prop = @enumFromInt(field.value);
+        if (self.props.contains(prop)) {
+            try tty.setColor(.white);
+            try tty.write(" via ");
+            try tty.setColor(.yellow);
+            try tty.write(prop.symbol());
+            const version = try prop.version(self.allocator);
+            if (version) |string| {
+                defer self.allocator.free(string);
+                try tty.write(" ");
+                try tty.write(prop.versionFormat(string));
+            }
+        }
+    }
+    try tty.setColor(.reset);
+}
+
+pub fn scanAll(self: *Context) !void {
+    var dir = try self.cwd.openDir("./", .{});
+    defer dir.close();
+    var depth: usize = 0;
+    while (true) : (depth += 1) {
+        if (depth == max_scan_depth) break;
+        self.scanDirectory(&dir);
+        const parent = try dir.openDir("../", .{});
+        dir.close();
+        dir = parent;
+        // Exit once root is reached
+        const path = try dir.realpathAlloc(self.allocator, ".");
+        defer self.allocator.free(path);
+        if (eql(u8, path, "/")) break;
+    }
+}
+
+/// Check all entries inside the open directory
+pub fn scanDirectory(self: *Context, open_dir: *Dir) void {
+    var iter = open_dir.iterate();
+    while (iter.next()) |next| {
+        if (next) |entry| self.scanEntry(entry) else break;
+    } else |_| return;
+}
+
+/// Check an individual directory entry
+pub fn scanEntry(self: *Context, entry: Dir.Entry) void {
+    const result: ?Prop = switch (entry.kind) {
+        .directory => result: {
+            if (eql(u8, entry.name, "node_modules")) {
+                break :result .node;
+            } else if (eql(u8, entry.name, "zig-out")) {
+                break :result .zig;
+            }
+            break :result null;
+        },
+        .file, .sym_link => result: {
+            const ext = extension(entry.name);
+            if (eql(u8, entry.name, "bun.lock")) {
+                break :result .bun;
+            } else if (eql(u8, entry.name, "bun.lockb")) {
+                break :result .bun;
+            } else if (eql(u8, entry.name, "bunfig.toml")) {
+                break :result .bun;
+            } else if (eql(u8, entry.name, "Cargo.lock")) {
+                break :result .rust;
+            } else if (eql(u8, entry.name, "Cargo.toml")) {
+                break :result .rust;
+            } else if (eql(u8, entry.name, "deno.json")) {
+                break :result .deno;
+            } else if (eql(u8, entry.name, "deno.jsonc")) {
+                break :result .deno;
+            } else if (eql(u8, entry.name, "deno.lock")) {
+                break :result .deno;
+            } else if (eql(u8, entry.name, "docker-compose.yml")) {
+                break :result .docker;
+            } else if (eql(u8, entry.name, "package.json")) {
+                break :result .node;
+            } else if (eql(u8, ext, ".rs")) {
+                break :result .rust;
+            } else if (eql(u8, ext, ".zig")) {
+                break :result .zig;
+            }
+            break :result null;
+        },
+        else => null,
+    };
+    if (result) |prop| {
+        self.props.put(prop, {}) catch unreachable;
+    }
+}
diff --git a/src/Host.zig b/src/Host.zig
@@ -0,0 +1,35 @@
+const std = @import("std");
+const builtin = @import("builtin");
+const mem = std.mem;
+const posix = std.posix;
+
+const Host = @This();
+
+hostname_buffer: [std.posix.HOST_NAME_MAX]u8 = [_]u8{0} ** std.posix.HOST_NAME_MAX,
+
+/// Returns the logged in username
+pub fn user(_: Host) []const u8 {
+    const maybe = posix.getenv("USER");
+    return if (maybe) |string| string else "user";
+}
+
+/// Returns the system hostname
+pub fn name(self: *Host) ![]const u8 {
+    const hostname = try posix.gethostname(&self.hostname_buffer);
+    if (mem.indexOfScalar(u8, hostname, '.')) |i| {
+        return hostname[0..i];
+    }
+    return hostname;
+}
+
+/// Returns an OS emoji
+pub fn emoji(_: Host) []const u8 {
+    return switch (builtin.os.tag) {
+        .macos => "",
+        .linux => emoji: {
+            // @TODO Check uname for Raspberry Pi or Proxmox etc
+            break :emoji "";
+        },
+        else => "",
+    };
+}
diff --git a/src/TTY.zig b/src/TTY.zig
@@ -0,0 +1,27 @@
+const std = @import("std");
+
+const TTY = @This();
+
+writer: std.fs.File.Writer,
+config: std.io.tty.Config,
+
+pub fn init() TTY {
+    return .{
+        .writer = std.io.getStdOut().writer(),
+        .config = std.io.tty.detectConfig(std.io.getStdErr()),
+    };
+}
+
+pub fn write(self: TTY, bytes: []const u8) !void {
+    _ = try self.writer.write(bytes);
+}
+
+pub fn print(self: TTY, comptime format: []const u8, args: anytype) !void {
+    try self.writer.print(format, args);
+}
+
+pub fn setColor(self: TTY, color: std.io.tty.Color) !void {
+    _ = try self.writer.write("%{");
+    try self.config.setColor(self.writer, color);
+    _ = try self.writer.write("%}");
+}
diff --git a/src/main.zig b/src/main.zig

Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,3 @@`
	`1`	`+setopt promptsubst`
	`2`	`+`
	`3`	`+PROMPT='$('${0:a:h}'/zig-out/bin/Zigbar prompt)'`