@opencode-cockpit/status 0.3.0

package/dist/core/builtins/place.js

@@ -0,0 +1,66 @@
+/** Where you are: the folder, the branch, and what has changed in it. */
+
+import { compact, shortPath, truncateStart } from "../format.js";
+import { formatted, num } from "./settings.js";
+export const SEGMENTS = [{
+  name: "cwd",
+  icon: "▸",
+  priority: 80,
+  render(ctx, config) {
+    // A directory outside both the worktree and home has no short form, and an absolute path can
+    // be longer than the terminal. Keep the tail: the end of a path is the part that identifies it.
+    const text = truncateStart(shortPath(ctx.directory, ctx.worktree, ctx.home), num(config, "maxWidth", 28));
+    return text ? {
+      text,
+      tone: "accent"
+    } : undefined;
+  }
+}, {
+  name: "git.branch",
+  icon: "⑂",
+  priority: 70,
+  render(ctx) {
+    if (!ctx.branch) return undefined;
+    // The default branch is the boring answer; a feature branch is the one worth noticing.
+    const onDefault = ctx.defaultBranch !== undefined && ctx.branch === ctx.defaultBranch;
+    return {
+      text: ctx.branch,
+      tone: onDefault ? "muted" : "info"
+    };
+  }
+}, {
+  /**
+   * What *this session* changed, which is what OpenCode's own Files list shows -- not what `git
+   * status` would. A file you edited by hand was never part of the session and does not appear
+   * here, which is why the old name, `git.diff`, was a trap. That name still works.
+   *
+   * For the working tree, use a command segment: `git diff --shortstat`.
+   */
+  name: "session.diff",
+  icon: "±",
+  priority: 50,
+  render(ctx, config) {
+    const diff = ctx.session?.diff;
+    if (!diff || diff.additions === 0 && diff.deletions === 0) return undefined;
+    const shaped = formatted(config, {
+      files: diff.files,
+      added: diff.additions,
+      removed: diff.deletions
+    });
+    if (shaped) return shaped;
+    // Two colours: what was added and what was taken away are read separately.
+    return {
+      runs: [{
+        text: `+${compact(diff.additions)}`,
+        tone: "success"
+      }, {
+        text: " / ",
+        tone: "muted",
+        dim: true
+      }, {
+        text: `-${compact(diff.deletions)}`,
+        tone: "error"
+      }]
+    };
+  }
+}];

package/dist/core/builtins/session.js

@@ -0,0 +1,72 @@
+/** How the session is going: work outstanding, work in progress, time spent. */
+
+import { todoRemaining } from "../context.js";
+import { duration, preciseDuration } from "../format.js";
+import { formatted } from "./settings.js";
+export const SEGMENTS = [{
+  name: "todo",
+  icon: "▤",
+  priority: 55,
+  render(ctx, config) {
+    const todo = ctx.session?.todo;
+    if (!todo || todo.total === 0) return undefined;
+    const left = todoRemaining(ctx.session);
+    /**
+     * A finished list has nothing left to act on, and todos live for the whole session -- so
+     * "5/5 todo" would sit there for the rest of it, saying only that you already finished.
+     * `showComplete` keeps it for anyone who wants the confirmation.
+     */
+    if (left === 0 && config.showComplete !== true) return undefined;
+    const shaped = formatted(config, {
+      done: todo.completed,
+      total: todo.total,
+      left
+    });
+    if (shaped) return shaped;
+    return {
+      text: `${todo.completed}/${todo.total} todo`,
+      tone: left === 0 ? "success" : "muted"
+    };
+  }
+}, {
+  name: "session.status",
+  icon: "●",
+  priority: 95,
+  render(ctx) {
+    const session = ctx.session;
+    if (!session) return undefined;
+    if (session.status === "retry") {
+      // Retries are invisible in OpenCode today; a stuck session looks identical to a slow one.
+      const retry = session.retry;
+      const wait = retry ? duration(Math.max(0, retry.next - ctx.now)) : "";
+      return {
+        text: `retry ${retry?.attempt ?? 1}${wait ? ` in ${wait}` : ""}`,
+        tone: "warning"
+      };
+    }
+    if (session.status === "busy") {
+      const started = session.startedAt;
+      return {
+        text: started ? `working ${preciseDuration(ctx.now - started)}` : "working",
+        tone: "info"
+      };
+    }
+    return undefined; // idle is the normal state; saying so every frame is noise
+  }
+}, {
+  name: "session.time",
+  icon: "◷",
+  priority: 20,
+  render(ctx, config) {
+    const started = ctx.session?.startedAt;
+    // `=== undefined`, not falsy: a startedAt of 0 is a real instant, not a missing one.
+    if (started === undefined) return undefined;
+    const elapsed = ctx.now - started;
+    // "3m42s" while you are watching it; "2h 5m" once the seconds stop mattering.
+    const text = config.coarse === true ? duration(elapsed) : preciseDuration(elapsed);
+    return {
+      text,
+      tone: "muted"
+    };
+  }
+}];

package/dist/core/builtins/settings.js

@@ -0,0 +1,28 @@
+/** Reading a segment's own settings out of its config entry, safely. */
+
+import { template } from "../format.js";
+export function num(config, key, fallback) {
+  const value = config[key];
+  return typeof value === "number" && Number.isFinite(value) ? value : fallback;
+}
+export function str(config, key) {
+  const value = config[key];
+  return typeof value === "string" ? value : undefined;
+}
+
+/**
+ * A segment's own shape, when the config asked for one.
+ *
+ * Returns `undefined` when no `format` was written, so the segment draws its default — which is
+ * usually several runs in several colours. A format is one run in one tone: full control of the
+ * words, at the cost of the colouring, which is the honest trade and worth saying out loud.
+ */
+export function formatted(config, values, tone = "muted") {
+  const shape = str(config, "format");
+  if (shape === undefined) return undefined;
+  const text = template(shape, values);
+  return text.length > 0 ? {
+    text,
+    tone
+  } : undefined;
+}

package/dist/core/builtins/system.js

@@ -0,0 +1,58 @@
+/** Everything outside the conversation: service health, versions, and your own commands. */
+
+import { parseAnsi } from "../ansi.js";
+import { outputRows } from "../command.js";
+import { unhealthy } from "../context.js";
+import { num, str } from "./settings.js";
+export const SEGMENTS = [{
+  name: "diagnostics",
+  priority: 90,
+  render(ctx) {
+    // Silent while everything is healthy: a statusline that always shows "LSP ✓" has spent a
+    // column to tell you nothing.
+    const broken = [...unhealthy(ctx.lsp), ...unhealthy(ctx.mcp)];
+    if (broken.length === 0) return undefined;
+    const names = broken.slice(0, 2).map(item => item.name).join(", ");
+    const more = broken.length > 2 ? ` +${broken.length - 2}` : "";
+    return {
+      text: `⚠ ${names}${more}`,
+      tone: "error"
+    };
+  }
+}, {
+  name: "version",
+  icon: "⌁",
+  priority: 10,
+  render(ctx) {
+    return ctx.version ? {
+      text: `v${ctx.version}`,
+      tone: "muted"
+    } : undefined;
+  }
+}, {
+  name: "text",
+  priority: 40,
+  render(_ctx, config) {
+    const value = str(config, "value");
+    return value ? {
+      text: value,
+      tone: "muted"
+    } : undefined;
+  }
+}, {
+  name: "command",
+  priority: 45,
+  render(ctx, config) {
+    const name = str(config, "name") ?? "default";
+    const value = ctx.commands[name];
+    if (!value) return undefined;
+    // A Claude Code statusline may print several rows; `row` picks one, and each row keeps the
+    // colours the script asked for rather than being flattened to grey.
+    const row = outputRows(value)[num(config, "row", 0)];
+    if (row === undefined) return undefined;
+    const runs = parseAnsi(row);
+    return runs.length > 0 ? {
+      runs
+    } : undefined;
+  }
+}];

package/dist/core/claude-code.js

@@ -0,0 +1,79 @@
+import { contextUsed } from "./context.js";
+import { shortModel } from "./format.js";
+
+/**
+ * The escape hatch: a shell command whose stdout becomes a segment.
+ *
+ * It is fed the same JSON on stdin that Claude Code's statusLine hook sends, so a statusline
+ * script someone already wrote works here unchanged. That matters more than elegance — nobody
+ * rewrites a working statusline to try a new editor.
+ *
+ * Unlike Claude Code's, this is not on the draw path: the command runs on its own interval and the
+ * line renders whatever it last returned, so a slow script makes the value stale rather than making
+ * the interface stutter.
+ */
+
+/**
+ * Claude Code's statusLine stdin payload, as close as our data allows.
+ *
+ * The fields real statuslines actually read are the context-window ones — a script that draws a
+ * capacity bar wants `context_window.used_percentage`, not a token total it has to divide itself.
+ * `rate_limits` is deliberately absent: it describes an Anthropic plan's quota, which has no
+ * meaning behind a proxy or another provider, and inventing a number there would be worse than
+ * the field being missing.
+ */
+
+export function claudeCodeInput(ctx) {
+  const session = ctx.session;
+  const model = session?.model;
+  const tokens = session?.tokens;
+  const used = contextUsed(tokens);
+  const limit = model?.contextLimit;
+  const payload = {
+    hook_event_name: "Status",
+    session_id: session?.id ?? "",
+    cwd: ctx.directory,
+    model: {
+      id: model?.modelID ?? "",
+      display_name: model ? shortModel(model.modelID) : ""
+    },
+    workspace: {
+      current_dir: ctx.directory,
+      project_dir: ctx.worktree
+    },
+    version: ctx.version,
+    output_style: {
+      name: "default"
+    },
+    cost: {
+      total_cost_usd: session?.cost ?? 0,
+      total_duration_ms: session?.startedAt ? Math.max(0, ctx.now - session.startedAt) : 0,
+      total_lines_added: session?.diff.additions ?? 0,
+      total_lines_removed: session?.diff.deletions ?? 0
+    },
+    exceeds_200k_tokens: used > 200_000
+  };
+  if (session?.title) payload.session_name = session.title;
+  if (ctx.worktree) payload.workspace.git_worktree = ctx.worktree;
+  if (tokens) {
+    payload.current_usage = {
+      input_tokens: tokens.input,
+      output_tokens: tokens.output,
+      cache_creation_tokens: tokens.cache.write,
+      cache_read_tokens: tokens.cache.read
+    };
+  }
+  // Only when a window was actually declared: a script dividing by a made-up size draws a
+  // confident wrong bar, which is the one thing worse than an empty segment.
+  if (tokens && limit && limit > 0) {
+    const share = Math.min(100, used / limit * 100);
+    payload.context_window = {
+      used_percentage: Number(share.toFixed(2)),
+      remaining_percentage: Number((100 - share).toFixed(2)),
+      context_window_size: limit,
+      total_input_tokens: tokens.input + tokens.cache.read + tokens.cache.write,
+      total_output_tokens: tokens.output + tokens.reasoning
+    };
+  }
+  return payload;
+}

package/dist/core/command.js

@@ -0,0 +1,77 @@
+/**
+ * Running a shell command for a segment.
+ *
+ * Unlike Claude Code's statusline, this is not on the draw path: the command runs on its own
+ * interval and the line renders whatever it last returned, so a slow script makes the value stale
+ * rather than making the interface stutter.
+ */
+
+import { claudeCodeInput } from "./claude-code.js";
+/**
+ * What a command's output is worth keeping: every row, escapes and all.
+ *
+ * The colour escapes are deliberately *not* stripped — they are parsed into styled runs when the
+ * segment draws, so a script someone already tuned for Claude Code looks the same here. Claude
+ * Code statuslines may also print several rows, so the rows are kept rather than the first one.
+ */
+export function cleanOutput(stdout) {
+  return stdout.replace(/\r/g, "").replace(/\s+$/, "");
+}
+
+/** The rows of a command's last output. */
+export function outputRows(value) {
+  return value.length === 0 ? [] : value.split("\n");
+}
+export function createRunner(config, host) {
+  const interval = Math.max(250, config.intervalMs ?? 2000);
+  const timeout = Math.max(100, config.timeoutMs ?? 1000);
+  const compat = config.claudeCodeCompat !== false;
+  let value = "";
+  let lastRun = Number.NEGATIVE_INFINITY;
+  let running = false;
+  let disposed = false;
+  return {
+    value: () => value,
+    maybeRun(ctx) {
+      if (disposed || running || host.now() - lastRun < interval) return;
+      running = true;
+      lastRun = host.now();
+      const stdin = compat ? JSON.stringify(claudeCodeInput(ctx)) : "";
+      host.exec(config.run, stdin, timeout).then(stdout => {
+        if (disposed) return;
+        const next = cleanOutput(stdout);
+        if (next !== value) {
+          value = next;
+          host.onValue();
+        }
+      })
+      // A failing command leaves the previous value in place: a statusline that empties itself
+      // because a script had a bad second is worse than one that is briefly stale.
+      .catch(() => {}).finally(() => {
+        running = false;
+      });
+    },
+    dispose() {
+      disposed = true;
+    }
+  };
+}
+
+/** The real shell, used outside tests. */
+export async function execShell(command, stdin, timeoutMs) {
+  const proc = Bun.spawn(["/bin/sh", "-c", command], {
+    stdin: new TextEncoder().encode(stdin),
+    stdout: "pipe",
+    stderr: "ignore",
+    env: process.env
+  });
+  const timer = setTimeout(() => proc.kill(), timeoutMs);
+  try {
+    const out = await new Response(proc.stdout).text();
+    const code = await proc.exited;
+    if (code !== 0) throw new Error(`exit ${code}`);
+    return out;
+  } finally {
+    clearTimeout(timer);
+  }
+}

package/dist/core/config.js

@@ -0,0 +1,187 @@
+import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+/**
+ * Statusline settings, read from the same two files every cockpit bay uses:
+ *
+ *   ~/.config/opencode-cockpit/config.json  →  <project>/.cockpit.json  →  plugin-entry options
+ *
+ * Only the `statusline` section is read here. An unreadable or invalid file is ignored rather than
+ * fatal — a typo in a config should never cost you the interface.
+ */
+
+export const CONFIG_FILE = "config.json";
+export const PROJECT_FILE = ".cockpit.json";
+
+/**
+ * Where a line is drawn.
+ *
+ * Two surfaces, deliberately. A third sat inside the prompt box, which is both the narrowest place
+ * in the window and the one OpenCode already fills with the agent, the model and the elapsed time:
+ * a line there had almost no room and almost nothing left to say.
+ */
+
+/**
+ * A segment is either a built-in named by string ("cwd"), or that name with settings. `when` and
+ * `priority` are what make a line survive a narrow terminal instead of wrapping into noise.
+ */
+
+/**
+ * How a line lays its segments out. A wide line under the prompt reads across; a sidebar four
+ * columns wide reads down.
+ */
+
+export function globalConfigPath(env = process.env) {
+  const base = env.XDG_CONFIG_HOME ?? join(env.HOME ?? homedir(), ".config");
+  return join(base, "opencode-cockpit", CONFIG_FILE);
+}
+
+/** Reads and merges every source. `options` is the plugin entry's own options object. */
+export function loadStatusConfig(directory, options, env = process.env) {
+  return mergeStatus(mergeStatus(readStatusFile(globalConfigPath(env)), readStatusFile(join(directory, PROJECT_FILE))), asStatusConfig(options));
+}
+export function readStatusFile(path) {
+  if (!existsSync(path)) return {};
+  try {
+    return asStatusConfig(JSON.parse(readFileSync(path, "utf8")));
+  } catch {
+    return {};
+  }
+}
+
+/**
+ * Section-wise merge. `segments` is replaced rather than concatenated: a project that lists its
+ * own segments means "this line", not "these as well as the global ones".
+ */
+export function mergeStatus(base, over) {
+  const merged = {
+    ...base,
+    ...over
+  };
+  if (base.commands || over.commands) merged.commands = {
+    ...base.commands,
+    ...over.commands
+  };
+  // Modules add up: a project can bring its own segments without losing the ones you use everywhere.
+  if (base.modules || over.modules) merged.modules = [...(base.modules ?? []), ...(over.modules ?? [])];
+  return merged;
+}
+
+/**
+ * Accepts either a whole cockpit config (`{ statusline: {...} }`) or the statusline section on its
+ * own, because plugin-entry options are written straight onto the `tui.json` entry.
+ */
+export function asStatusConfig(input) {
+  if (!input || typeof input !== "object") return {};
+  const raw = input;
+  const section = raw.statusline ?? raw.status;
+  if (section && typeof section === "object") return section;
+  const own = {};
+  for (const key of ["enabled", "surface", "segments", "separator", "stack", "icons", "lines", "commands", "modules"]) {
+    if (raw[key] !== undefined) Object.assign(own, {
+      [key]: raw[key]
+    });
+  }
+  return own;
+}
+
+/**
+ * The default line: what someone who writes nothing at all should see.
+ *
+ * It took a long walk to arrive here, and the shape is the point. A capacity bar that means
+ * something at a glance, the total beside the three quantities that make it up, what changed, how
+ * long it has been. Colour carries which is which; the separators carry the grouping.
+ *
+ * It does repeat one thing OpenCode already shows -- the token count and the percentage, which its
+ * footer carries in a corner. That is deliberate. The rule is not to avoid every fact the host
+ * mentions, it is to avoid saying it no better than the host does: a bar you can read without
+ * looking, with the breakdown beside it, is a different instrument from "78.5K (39%)" in the
+ * corner. What stays out are the facts a second copy adds nothing to -- the path, the branch, the
+ * model, the spend.
+ */
+export const DEFAULT_SEGMENTS = [{
+  type: "context",
+  style: "bar",
+  width: 14,
+  icon: ""
+}, {
+  type: "tokens",
+  format: "tk {total}",
+  icon: ""
+}, {
+  type: "tokens",
+  format: "cache {cacheRead}",
+  color: "success",
+  icon: ""
+}, {
+  type: "tokens",
+  format: "in {input}",
+  color: "info",
+  icon: ""
+}, {
+  type: "tokens",
+  format: "out {output}",
+  color: "accent",
+  icon: ""
+}, {
+  type: "session.diff",
+  icon: ""
+}, {
+  type: "session.time",
+  icon: ""
+}, "todo", "session.status", "diagnostics"];
+export const DEFAULT_SEPARATOR = " │ ";
+/** What each surface needs to sit level with the host's own content. */
+const PADDING = {
+  // OpenCode's footer indents three columns, and a line hard against the bottom of the window
+  // reads as clipped, so this one keeps a row clear underneath it.
+  bottom: {
+    left: 3,
+    right: 2,
+    top: 0,
+    bottom: 1
+  },
+  // Flush with the sidebar's own content, which the shell bay draws with no padding at all.
+  sidebar: {
+    left: 0,
+    right: 0,
+    top: 0,
+    bottom: 0
+  }
+};
+
+/** Normalises whatever the config said into the lines the renderer draws. */
+export function resolveLines(config) {
+  const lines = config.lines?.length ? config.lines : [{
+    surface: config.surface,
+    segments: config.segments,
+    separator: config.separator,
+    stack: config.stack,
+    icons: config.icons
+  }];
+  return lines.map(line => {
+    const surface = line.surface ?? "bottom";
+    // The sidebar is a narrow column: across, it would be three truncated words.
+    const stack = line.stack ?? config.stack ?? (surface === "sidebar" ? "vertical" : "horizontal");
+    return {
+      surface,
+      segments: line.segments ?? config.segments ?? DEFAULT_SEGMENTS,
+      separator: line.separator ?? config.separator ?? (stack === "vertical" ? "" : DEFAULT_SEPARATOR),
+      stack,
+      maxRows: line.maxRows ?? 8,
+      icons: line.icons ?? config.icons ?? true,
+      paddingLeft: line.paddingLeft ?? PADDING[surface].left,
+      paddingRight: line.paddingRight ?? PADDING[surface].right,
+      paddingTop: line.paddingTop ?? PADDING[surface].top,
+      paddingBottom: line.paddingBottom ?? PADDING[surface].bottom
+    };
+  });
+}
+
+/** A segment written as a bare string is that built-in with no settings. */
+export function asSegmentConfig(entry) {
+  return typeof entry === "string" ? {
+    type: entry
+  } : entry;
+}

package/dist/core/context.js

@@ -0,0 +1,24 @@
+/**
+ * The snapshot a segment sees. Deliberately a plain object rather than the live plugin api: every
+ * built-in is then a pure function of it, which is what makes the line testable without an
+ * OpenCode to draw it in.
+ */
+
+/** Tokens that occupy the context window right now: everything the model reads back. */
+export function contextUsed(tokens) {
+  if (!tokens) return 0;
+  return tokens.input + tokens.output + tokens.reasoning + tokens.cache.read + tokens.cache.write;
+}
+export function contextRatio(session) {
+  const limit = session?.model?.contextLimit;
+  if (!limit || limit <= 0 || !session?.tokens) return undefined;
+  return Math.min(1, contextUsed(session.tokens) / limit);
+}
+export function todoRemaining(session) {
+  if (!session) return 0;
+  return Math.max(0, session.todo.total - session.todo.completed);
+}
+const HEALTHY = new Set(["connected", "ready", "ok", "running", "active"]);
+export function unhealthy(list) {
+  return list.filter(item => !HEALTHY.has(item.status.toLowerCase()));
+}