crispy-recall 0.2.0 → 0.3.0

package/dist/statusline.js

@@ -0,0 +1,180 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/hooks/statusline.ts
+var statusline_exports = {};
+__export(statusline_exports, {
+  parseGitStatus: () => parseGitStatus
+});
+module.exports = __toCommonJS(statusline_exports);
+var import_node_process = __toESM(require("node:process"));
+var import_node_child_process = require("node:child_process");
+
+// src/recall/statusline-segment.ts
+var import_node_path = require("node:path");
+var RESET = "\x1B[0m";
+var DIM = "\x1B[2;37m";
+var SOFT = "\x1B[37m";
+var GREEN = "\x1B[32m";
+var RED = "\x1B[31m";
+function dim(s) {
+  return `${DIM}${s}${RESET}`;
+}
+function renderModel(input) {
+  const raw = input?.model?.display_name;
+  if (typeof raw !== "string" || raw.length === 0)
+    return "";
+  const cleaned = raw.replace("Claude ", "").replace(/\s*\([^)]*\)\s*/g, " ").trim();
+  if (cleaned.length === 0)
+    return "";
+  const family = /Opus/i.test(cleaned) ? "Opus" : /Sonnet/i.test(cleaned) ? "Sonnet" : /Haiku/i.test(cleaned) ? "Haiku" : void 0;
+  const icon = family === "Opus" ? "\u{1F9E0}" : family === "Haiku" ? "\u{1F4B2}" : "\u26A1";
+  const version = /(\d+\.?\d*)/.exec(cleaned)?.[1];
+  if (family && version)
+    return `${SOFT}${family}${RESET} ${icon} ${dim(version)}`;
+  return `${SOFT}${family ?? cleaned}${RESET} ${icon}`;
+}
+function renderContext(input) {
+  const ctx = input?.context_window;
+  const usage = ctx?.current_usage;
+  if (!ctx || usage === void 0 || usage === null || typeof usage !== "object")
+    return "";
+  const window = Number(ctx.context_window_size);
+  if (!Number.isFinite(window) || window <= 0)
+    return "";
+  const fields = [usage.input_tokens, usage.cache_creation_input_tokens, usage.cache_read_input_tokens];
+  const present = fields.filter((v) => typeof v === "number" && Number.isFinite(v));
+  if (present.length === 0)
+    return "";
+  const tokens = present.reduce((a, b) => a + b, 0);
+  const pct = Math.floor(tokens * 100 / window);
+  const color = pct >= 81 ? "\x1B[1;31m" : pct >= 61 ? "\x1B[31m" : pct >= 41 ? "\x1B[33m" : pct >= 21 ? "\x1B[32m" : pct >= 11 ? "\x1B[37m" : "\x1B[2;37m";
+  return `\u{1F4BF} ${color}${pct}%${RESET}`;
+}
+function renderDir(input, git) {
+  const cwd = input?.workspace?.current_dir ?? input?.cwd;
+  let dir = "";
+  if (typeof cwd === "string" && cwd.length > 0) {
+    const base = (0, import_node_path.basename)(cwd);
+    if (base)
+      dir = dim(base);
+  }
+  if (git && git.branch) {
+    const star = git.dirty ? `${RED}*${RESET}` : "";
+    const suffix = `(${GREEN}${git.branch}${RESET}${star})`;
+    return dir ? `${dir} ${suffix}` : suffix;
+  }
+  return dir;
+}
+function renderChip(input) {
+  const sid = input?.session_id;
+  if (typeof sid !== "string" || sid.length === 0)
+    return "";
+  return `\u{1F517} ${dim(sid)}`;
+}
+function renderStandaloneStatusline(input, opts) {
+  const parts = [];
+  const dir = renderDir(input, opts?.git);
+  if (dir)
+    parts.push(dir);
+  const model = renderModel(input);
+  if (model)
+    parts.push(model);
+  const ctx = renderContext(input);
+  if (ctx)
+    parts.push(ctx);
+  const chip = renderChip(input);
+  if (chip)
+    parts.push(chip);
+  return parts.join(` ${DIM}\xB7${RESET} `);
+}
+
+// src/hooks/statusline.ts
+function parseGitStatus(stdout) {
+  if (typeof stdout !== "string" || stdout.length === 0)
+    return void 0;
+  const lines = stdout.split("\n");
+  const header = lines.find((l) => l.startsWith("## "));
+  if (!header)
+    return void 0;
+  const rest = header.slice(3);
+  let branch;
+  if (rest.startsWith("No commits yet on ")) {
+    branch = rest.slice("No commits yet on ".length).trim();
+  } else if (rest.startsWith("Initial commit on ")) {
+    branch = rest.slice("Initial commit on ".length).trim();
+  } else if (rest.startsWith("HEAD (no branch)")) {
+    branch = void 0;
+  } else {
+    branch = rest.split(/\.\.\.| /, 1)[0].trim();
+  }
+  if (!branch)
+    return void 0;
+  const dirty = lines.some((l) => l.length > 0 && !l.startsWith("## "));
+  return { branch, dirty };
+}
+function readGit(cwd) {
+  try {
+    const res = (0, import_node_child_process.spawnSync)("git", ["status", "--porcelain=v1", "--branch"], {
+      cwd,
+      timeout: 400,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"],
+      windowsHide: true
+    });
+    if (res.error || res.status !== 0 || typeof res.stdout !== "string")
+      return void 0;
+    return parseGitStatus(res.stdout);
+  } catch {
+    return void 0;
+  }
+}
+async function runStatusline() {
+  let data = "";
+  for await (const chunk of import_node_process.default.stdin)
+    data += chunk;
+  let json;
+  try {
+    json = JSON.parse(data);
+  } catch {
+    json = {};
+  }
+  const cwd = json?.workspace?.current_dir ?? json?.cwd;
+  const git = typeof cwd === "string" && cwd.length > 0 ? readGit(cwd) : void 0;
+  import_node_process.default.stdout.write(renderStandaloneStatusline(json ?? {}, { git }));
+  import_node_process.default.exit(0);
+}
+if (typeof require !== "undefined" && typeof module !== "undefined" && require.main === module) {
+  void runStatusline();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  parseGitStatus
+});