255 lines
9.6 KiB
Zig
255 lines
9.6 KiB
Zig
const std = @import("std");
|
|
const zfin = @import("../root.zig");
|
|
const cli = @import("common.zig");
|
|
const framework = @import("framework.zig");
|
|
const fmt = cli.fmt;
|
|
const Money = @import("../Money.zig");
|
|
|
|
pub const ParsedArgs = struct {
|
|
symbol: []const u8,
|
|
/// `--ntm <N>`: show ±N strikes near the money on the auto-expanded
|
|
/// expiration. Default 8.
|
|
ntm: usize = 8,
|
|
};
|
|
|
|
pub const meta: framework.Meta = .{
|
|
.name = "options",
|
|
.group = .symbol_lookup,
|
|
.synopsis = "Show options chain (all expirations) for a symbol",
|
|
.uppercase_first_arg = true,
|
|
.help =
|
|
\\Usage: zfin options <SYMBOL> [--ntm <N>]
|
|
\\
|
|
\\Show the options chain (all expirations) for a symbol from
|
|
\\CBOE. Cached for 1 hour. The nearest monthly expiration is
|
|
\\auto-expanded with ±N strikes near the money; other
|
|
\\expirations are listed collapsed.
|
|
\\
|
|
\\Options:
|
|
\\ --ntm <N> Show ±N strikes near the money (default: 8)
|
|
\\
|
|
\\Examples:
|
|
\\ zfin options SPY
|
|
\\ zfin options AAPL --ntm 12
|
|
\\
|
|
,
|
|
.user_errors = error{ MissingSymbol, UnexpectedArg, MissingFlagValue, InvalidFlagValue },
|
|
};
|
|
|
|
pub fn parseArgs(ctx: *framework.RunCtx, cmd_args: []const []const u8) !ParsedArgs {
|
|
if (cmd_args.len < 1) {
|
|
cli.stderrPrint(ctx.io, "Error: 'options' requires a symbol argument\n");
|
|
return error.MissingSymbol;
|
|
}
|
|
var parsed: ParsedArgs = .{ .symbol = cmd_args[0] };
|
|
var i: usize = 1;
|
|
while (i < cmd_args.len) : (i += 1) {
|
|
const a = cmd_args[i];
|
|
if (std.mem.eql(u8, a, "--ntm")) {
|
|
if (i + 1 >= cmd_args.len) {
|
|
cli.stderrPrint(ctx.io, "Error: --ntm requires a value\n");
|
|
return error.MissingFlagValue;
|
|
}
|
|
parsed.ntm = std.fmt.parseInt(usize, cmd_args[i + 1], 10) catch {
|
|
cli.stderrPrint(ctx.io, "Error: --ntm value must be a non-negative integer\n");
|
|
return error.InvalidFlagValue;
|
|
};
|
|
i += 1;
|
|
} else {
|
|
cli.stderrPrint(ctx.io, "Error: unexpected argument to 'options': ");
|
|
cli.stderrPrint(ctx.io, a);
|
|
cli.stderrPrint(ctx.io, "\n");
|
|
return error.UnexpectedArg;
|
|
}
|
|
}
|
|
return parsed;
|
|
}
|
|
|
|
pub fn run(ctx: *framework.RunCtx, parsed: ParsedArgs) !void {
|
|
const svc = ctx.svc orelse return error.MissingDataService;
|
|
const opts = cli.fetchOptionsFromPolicy(ctx.globals.refresh_policy);
|
|
const result = svc.getOptions(parsed.symbol, opts) catch |err| switch (err) {
|
|
zfin.DataError.FetchFailed => {
|
|
cli.stderrPrint(ctx.io, "Error fetching options data from CBOE.\n");
|
|
return;
|
|
},
|
|
else => {
|
|
cli.stderrPrint(ctx.io, "Error loading options data.\n");
|
|
return;
|
|
},
|
|
};
|
|
const ch = result.data;
|
|
defer result.deinit();
|
|
|
|
if (result.source == .cached) cli.stderrPrint(ctx.io, "(using cached options data)\n");
|
|
|
|
if (ch.len == 0) {
|
|
cli.stderrPrint(ctx.io, "No options data found.\n");
|
|
return;
|
|
}
|
|
|
|
try display(ctx.out, ch, parsed.symbol, parsed.ntm, ctx.color);
|
|
}
|
|
|
|
pub fn display(out: *std.Io.Writer, chains: []const zfin.OptionsChain, symbol: []const u8, ntm: usize, color: bool) !void {
|
|
if (chains.len == 0) return;
|
|
|
|
try cli.printBold(out, color, "\nOptions Chain for {s}\n", .{symbol});
|
|
try out.print("========================================\n", .{});
|
|
if (chains[0].underlying_price) |price| {
|
|
try out.print("Underlying: {f} {d} expiration(s) +/- {d} strikes NTM\n", .{ Money.from(price), chains.len, ntm });
|
|
} else {
|
|
try out.print("{d} expiration(s) available\n", .{chains.len});
|
|
}
|
|
|
|
// Find nearest monthly expiration to auto-expand
|
|
var auto_expand_idx: ?usize = null;
|
|
for (chains, 0..) |chain, ci| {
|
|
if (fmt.isMonthlyExpiration(chain.expiration)) {
|
|
auto_expand_idx = ci;
|
|
break;
|
|
}
|
|
}
|
|
// If no monthly found, expand the first one
|
|
if (auto_expand_idx == null and chains.len > 0) auto_expand_idx = 0;
|
|
|
|
const atm_price = if (chains[0].underlying_price) |p| p else @as(f64, 0);
|
|
|
|
// List all expirations, expanding the nearest monthly
|
|
for (chains, 0..) |chain, ci| {
|
|
const is_monthly = fmt.isMonthlyExpiration(chain.expiration);
|
|
const is_expanded = auto_expand_idx != null and ci == auto_expand_idx.?;
|
|
|
|
try out.print("\n", .{});
|
|
if (is_expanded) {
|
|
try cli.setBold(out, color);
|
|
try out.print("{f} ({d} calls, {d} puts)", .{
|
|
chain.expiration, chain.calls.len, chain.puts.len,
|
|
});
|
|
if (is_monthly) try out.print(" [monthly]", .{});
|
|
try cli.reset(out, color);
|
|
try out.print("\n", .{});
|
|
|
|
// Print calls
|
|
try printSection(out, "CALLS", chain.calls, atm_price, ntm, true, color);
|
|
try out.print("\n", .{});
|
|
// Print puts
|
|
try printSection(out, "PUTS", chain.puts, atm_price, ntm, false, color);
|
|
} else {
|
|
try cli.setFg(out, color, if (is_monthly) cli.CLR_HEADER else cli.CLR_MUTED);
|
|
try out.print("{f} ({d} calls, {d} puts)", .{
|
|
chain.expiration, chain.calls.len, chain.puts.len,
|
|
});
|
|
if (is_monthly) try out.print(" [monthly]", .{});
|
|
try cli.reset(out, color);
|
|
try out.print("\n", .{});
|
|
}
|
|
}
|
|
|
|
try out.print("\n", .{});
|
|
}
|
|
|
|
pub fn printSection(
|
|
out: *std.Io.Writer,
|
|
label: []const u8,
|
|
contracts: []const zfin.OptionContract,
|
|
atm_price: f64,
|
|
ntm: usize,
|
|
is_calls: bool,
|
|
color: bool,
|
|
) !void {
|
|
try cli.printBold(out, color, " {s}\n", .{label});
|
|
try cli.setFg(out, color, cli.CLR_MUTED);
|
|
try out.print(" {s:>10} {s:>10} {s:>10} {s:>10} {s:>10} {s:>8} {s:>8}\n", .{
|
|
"Strike", "Last", "Bid", "Ask", "Volume", "OI", "IV",
|
|
});
|
|
try out.print(" {s:->10} {s:->10} {s:->10} {s:->10} {s:->10} {s:->8} {s:->8}\n", .{
|
|
"", "", "", "", "", "", "",
|
|
});
|
|
try cli.reset(out, color);
|
|
|
|
const filtered = fmt.filterNearMoney(contracts, atm_price, ntm);
|
|
for (filtered) |c| {
|
|
const itm = if (is_calls) c.strike <= atm_price else c.strike >= atm_price;
|
|
const prefix: []const u8 = if (itm) " |" else " ";
|
|
var contract_buf: [128]u8 = undefined;
|
|
const line = fmt.fmtContractLine(&contract_buf, prefix, c);
|
|
try out.print("{s}\n", .{line});
|
|
}
|
|
}
|
|
|
|
// ── Tests ────────────────────────────────────────────────────
|
|
|
|
test "parseArgs: accepts a symbol with default ntm" {
|
|
var ctx: framework.RunCtx = undefined;
|
|
ctx.io = std.testing.io;
|
|
const args = [_][]const u8{"SPY"};
|
|
const parsed = try parseArgs(&ctx, &args);
|
|
try std.testing.expectEqualStrings("SPY", parsed.symbol);
|
|
try std.testing.expectEqual(@as(usize, 8), parsed.ntm);
|
|
}
|
|
|
|
test "parseArgs: --ntm overrides default" {
|
|
var ctx: framework.RunCtx = undefined;
|
|
ctx.io = std.testing.io;
|
|
const args = [_][]const u8{ "SPY", "--ntm", "12" };
|
|
const parsed = try parseArgs(&ctx, &args);
|
|
try std.testing.expectEqual(@as(usize, 12), parsed.ntm);
|
|
}
|
|
|
|
test "parseArgs: missing symbol errors" {
|
|
var ctx: framework.RunCtx = undefined;
|
|
ctx.io = std.testing.io;
|
|
const args = [_][]const u8{};
|
|
try std.testing.expectError(error.MissingSymbol, parseArgs(&ctx, &args));
|
|
}
|
|
|
|
test "parseArgs: --ntm without value errors" {
|
|
var ctx: framework.RunCtx = undefined;
|
|
ctx.io = std.testing.io;
|
|
const args = [_][]const u8{ "SPY", "--ntm" };
|
|
try std.testing.expectError(error.MissingFlagValue, parseArgs(&ctx, &args));
|
|
}
|
|
|
|
test "parseArgs: --ntm with non-numeric value errors" {
|
|
var ctx: framework.RunCtx = undefined;
|
|
ctx.io = std.testing.io;
|
|
const args = [_][]const u8{ "SPY", "--ntm", "abc" };
|
|
try std.testing.expectError(error.InvalidFlagValue, parseArgs(&ctx, &args));
|
|
}
|
|
|
|
test "parseArgs: unknown flag errors" {
|
|
var ctx: framework.RunCtx = undefined;
|
|
ctx.io = std.testing.io;
|
|
const args = [_][]const u8{ "SPY", "--bogus" };
|
|
try std.testing.expectError(error.UnexpectedArg, parseArgs(&ctx, &args));
|
|
}
|
|
|
|
test "printSection shows header and contracts" {
|
|
var buf: [8192]u8 = undefined;
|
|
var w: std.Io.Writer = .fixed(&buf);
|
|
const calls = [_]zfin.OptionContract{
|
|
.{ .contract_type = .call, .strike = 150.0, .expiration = .{ .days = 20100 }, .bid = 5.0, .ask = 5.50, .last_price = 5.25 },
|
|
.{ .contract_type = .call, .strike = 155.0, .expiration = .{ .days = 20100 }, .bid = 2.0, .ask = 2.50, .last_price = 2.25 },
|
|
};
|
|
try printSection(&w, "CALLS", &calls, 152.0, 8, true, false);
|
|
const out = w.buffered();
|
|
try std.testing.expect(std.mem.indexOf(u8, out, "CALLS") != null);
|
|
try std.testing.expect(std.mem.indexOf(u8, out, "Strike") != null);
|
|
try std.testing.expect(std.mem.indexOf(u8, out, "\x1b[") == null);
|
|
}
|
|
|
|
test "display shows chain header no color" {
|
|
var buf: [8192]u8 = undefined;
|
|
var w: std.Io.Writer = .fixed(&buf);
|
|
const calls = [_]zfin.OptionContract{};
|
|
const puts = [_]zfin.OptionContract{};
|
|
const chains = [_]zfin.OptionsChain{
|
|
.{ .underlying_symbol = "SPY", .underlying_price = 500.0, .expiration = .{ .days = 20100 }, .calls = &calls, .puts = &puts },
|
|
};
|
|
try display(&w, &chains, "SPY", 8, false);
|
|
const out = w.buffered();
|
|
try std.testing.expect(std.mem.indexOf(u8, out, "Options Chain for SPY") != null);
|
|
try std.testing.expect(std.mem.indexOf(u8, out, "1 expiration(s)") != null);
|
|
try std.testing.expect(std.mem.indexOf(u8, out, "\x1b[") == null);
|
|
}
|