@kairyou/agent-tools 0.2.0 → 0.4.0

package/dist/statusline/claude-statusline.mjs

@@ -0,0 +1,355 @@
+#!/usr/bin/env node
+
+// integrations/statusline/claude-statusline.mjs
+import { execFileSync, spawn } from "node:child_process";
+import fs from "node:fs";
+import { basename, dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+var SCRIPT_DIR = dirname(fileURLToPath(import.meta.url));
+var AGENT_TOOLS_HOME = process.env.AGENT_TOOLS_HOME || join(SCRIPT_DIR, "..", "..");
+var DEFAULT_CONFIG_FILE = join(AGENT_TOOLS_HOME, "config.jsonc");
+var SNAPSHOT_FILE = join(AGENT_TOOLS_HOME, "cache", "usage-snapshot.json");
+var REFRESH_STATE_FILE = join(AGENT_TOOLS_HOME, "cache", "usage-refresh-state.json");
+var USAGE_RUNTIME = join(AGENT_TOOLS_HOME, "dist", "usage", "core.mjs");
+var DEFAULT_SNAPSHOT_TTL_MS = 6e4;
+var DEFAULT_REFRESH_COOLDOWN_MS = 3e4;
+var DEFAULT_FAILURE_BACKOFF_MS = 12e4;
+var DEFAULT_CONFIG = {
+  fields: ["branch", "model", "fiveHour", "week"],
+  separator: " | ",
+  symbols: {
+    branch: "\u2387",
+    reset: "\u27F3",
+    empty: "\u2013",
+    fiveHour: "5h",
+    week: "w",
+    context: "ctx"
+  }
+};
+var FIELD_ALIASES = {
+  cwd: "directory",
+  dir: "directory",
+  five: "fiveHour",
+  five_hour: "fiveHour",
+  "5h": "fiveHour",
+  sevenDay: "week",
+  seven_day: "week",
+  "7d": "week",
+  weekly: "week",
+  ctx: "context"
+};
+async function readStdin() {
+  const chunks = [];
+  for await (const chunk of process.stdin) chunks.push(chunk);
+  return Buffer.concat(chunks).toString("utf8");
+}
+function readJsonFile(file) {
+  try {
+    if (!fs.existsSync(file)) return {};
+    const raw = stripTrailingCommas(stripJsonComments(fs.readFileSync(file, "utf8").replace(/^\uFEFF/, "")));
+    return raw.trim() ? JSON.parse(raw) : {};
+  } catch {
+    return {};
+  }
+}
+function stripJsonComments(input) {
+  let out = "";
+  let inString = false;
+  let escaped = false;
+  for (let i = 0; i < input.length; i++) {
+    const ch = input[i];
+    const next = input[i + 1];
+    if (inString) {
+      out += ch;
+      escaped = ch === "\\" ? !escaped : false;
+      if (ch === '"' && !escaped) inString = false;
+      continue;
+    }
+    if (ch === '"') {
+      inString = true;
+      out += ch;
+      continue;
+    }
+    if (ch === "/" && next === "/") {
+      while (i < input.length && input[i] !== "\n") i++;
+      out += "\n";
+      continue;
+    }
+    if (ch === "/" && next === "*") {
+      i += 2;
+      while (i < input.length && !(input[i] === "*" && input[i + 1] === "/")) i++;
+      i++;
+      continue;
+    }
+    out += ch;
+  }
+  return out;
+}
+function stripTrailingCommas(input) {
+  let out = "";
+  let inString = false;
+  let escaped = false;
+  for (let i = 0; i < input.length; i++) {
+    const ch = input[i];
+    if (inString) {
+      out += ch;
+      escaped = ch === "\\" ? !escaped : false;
+      if (ch === '"' && !escaped) inString = false;
+      continue;
+    }
+    if (ch === '"') {
+      inString = true;
+      out += ch;
+      continue;
+    }
+    if (ch === ",") {
+      let j = i + 1;
+      while (j < input.length && /\s/.test(input[j])) j++;
+      if (input[j] === "}" || input[j] === "]") continue;
+    }
+    out += ch;
+  }
+  return out;
+}
+function parseArgs(argv) {
+  const opts = {};
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === "--fields" && argv[i + 1]) {
+      opts.fields = argv[++i];
+    } else if (arg.startsWith("--fields=")) {
+      opts.fields = arg.slice("--fields=".length);
+    } else if (arg === "--separator" && argv[i + 1]) {
+      opts.separator = argv[++i];
+    } else if (arg.startsWith("--separator=")) {
+      opts.separator = arg.slice("--separator=".length);
+    }
+  }
+  return opts;
+}
+function splitFields(value) {
+  if (Array.isArray(value)) return value;
+  if (typeof value !== "string") return null;
+  return value.split(/[,\s]+/).map((part) => part.trim()).filter(Boolean);
+}
+function normalizeField(field) {
+  return FIELD_ALIASES[field] || field;
+}
+function mergeConfig(cli) {
+  const rootConfig = readJsonFile(DEFAULT_CONFIG_FILE);
+  const fileConfig = rootConfig.statusline || {};
+  const envFields = process.env.AGENT_TOOLS_STATUSLINE_FIELDS;
+  const envSeparator = process.env.AGENT_TOOLS_STATUSLINE_SEPARATOR;
+  const config = {
+    ...DEFAULT_CONFIG,
+    ...fileConfig,
+    symbols: { ...DEFAULT_CONFIG.symbols, ...fileConfig.symbols || {} }
+  };
+  const fields = splitFields(cli.fields) || splitFields(envFields) || splitFields(fileConfig.fields) || DEFAULT_CONFIG.fields;
+  config.fields = fields.map(normalizeField);
+  if (typeof envSeparator === "string") config.separator = envSeparator;
+  if (typeof cli.separator === "string") config.separator = cli.separator;
+  return config;
+}
+function gitBranch(cwd) {
+  try {
+    const out = execFileSync("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
+      cwd,
+      stdio: ["ignore", "pipe", "ignore"],
+      encoding: "utf8"
+    }).trim();
+    return out && out !== "HEAD" ? out : "";
+  } catch {
+    return "";
+  }
+}
+function secondsUntil(unixSeconds) {
+  if (!unixSeconds) return null;
+  const seconds = Number(unixSeconds) - Math.floor(Date.now() / 1e3);
+  return Number.isFinite(seconds) ? Math.max(0, seconds) : null;
+}
+function compactDuration(totalSeconds) {
+  if (totalSeconds == null) return "";
+  if (totalSeconds <= 0) return "0m";
+  let seconds = totalSeconds;
+  const days = Math.floor(seconds / 86400);
+  seconds %= 86400;
+  const hours = Math.floor(seconds / 3600);
+  seconds %= 3600;
+  const minutes = Math.floor(seconds / 60);
+  if (days) return `${days}d${hours}h`;
+  if (hours) return `${hours}h${minutes}m`;
+  return `${minutes}m`;
+}
+function usageWindow(window, config) {
+  if (!window || typeof window.used_percentage !== "number") {
+    return "";
+  }
+  const pct = `${Math.round(window.used_percentage)}%`;
+  const left = compactDuration(secondsUntil(window.resets_at));
+  return left ? `${pct} ${config.symbols.reset}${left}` : pct;
+}
+function showMissingUsageWindow() {
+  const baseUrl = activeRelayBaseUrl();
+  return !baseUrl || isOfficialBaseUrl(baseUrl);
+}
+function shortModelName(name) {
+  if (!name) return "";
+  return String(name).replace(/^Claude\s+/i, "").replace(/\s*\[1m\]\s*$/i, "").trim();
+}
+function renderField(field, data, config) {
+  const dir = data?.workspace?.current_dir || data?.cwd || process.cwd() || "";
+  const projectDir = data?.workspace?.project_dir || dir;
+  switch (field) {
+    case "branch": {
+      const branch = gitBranch(projectDir);
+      return branch ? `${config.symbols.branch} ${branch}` : "";
+    }
+    case "model":
+      return shortModelName(data?.model?.display_name || data?.model?.id || "");
+    case "fiveHour": {
+      const value = usageWindow(data?.rate_limits?.five_hour, config);
+      return value || showMissingUsageWindow() ? `${config.symbols.fiveHour} ${value || config.symbols.empty}` : "";
+    }
+    case "week": {
+      const value = usageWindow(data?.rate_limits?.seven_day, config);
+      return value || showMissingUsageWindow() ? `${config.symbols.week} ${value || config.symbols.empty}` : "";
+    }
+    case "context": {
+      const pct = data?.context_window?.used_percentage;
+      return typeof pct === "number" ? `${config.symbols.context} ${Math.round(pct)}%` : "";
+    }
+    case "directory":
+      return dir ? basename(dir) : "";
+    default:
+      return "";
+  }
+}
+function numberFromEnv(name, fallback) {
+  const value = Number(process.env[name]);
+  return Number.isFinite(value) && value >= 0 ? value : fallback;
+}
+function cleanBaseUrl(baseUrl) {
+  return String(baseUrl || "").replace(/\/+$/, "");
+}
+function isOfficialBaseUrl(baseUrl) {
+  if (!baseUrl) return true;
+  const clean = cleanBaseUrl(baseUrl);
+  return [
+    "https://api.anthropic.com",
+    "https://api.anthropic.com/v1",
+    "https://api.openai.com",
+    "https://api.openai.com/v1"
+  ].includes(clean);
+}
+function usageRouteCacheKey(baseUrl) {
+  try {
+    const url = new URL(cleanBaseUrl(baseUrl));
+    url.hash = "";
+    url.search = "";
+    url.pathname = url.pathname.replace(/\/+$/, "").replace(/\/api\/v1$/i, "").replace(/\/v1$/i, "");
+    return url.toString().replace(/\/$/, "");
+  } catch {
+    return cleanBaseUrl(baseUrl).endsWith("/v1") ? cleanBaseUrl(baseUrl).slice(0, -3) : cleanBaseUrl(baseUrl);
+  }
+}
+function readJsonFileRaw(file) {
+  try {
+    if (!fs.existsSync(file)) return {};
+    const raw = fs.readFileSync(file, "utf8").replace(/^\uFEFF/, "");
+    return raw.trim() ? JSON.parse(raw) : {};
+  } catch {
+    return {};
+  }
+}
+function activeRelayBaseUrl() {
+  return process.env.PROVIDER_USAGE_BASE_URL || process.env.ANTHROPIC_BASE_URL || "";
+}
+function hasClaudeUsageToken() {
+  return Boolean(
+    process.env.PROVIDER_USAGE_API_KEY || process.env.ANTHROPIC_AUTH_TOKEN || process.env.ANTHROPIC_API_KEY
+  );
+}
+function snapshotForBaseUrl(baseUrl) {
+  const snapshot = readJsonFileRaw(SNAPSHOT_FILE);
+  const key = usageRouteCacheKey(baseUrl);
+  const item = snapshot?.items?.[key];
+  return item?.text ? item : null;
+}
+function refreshStateForBaseUrl(baseUrl) {
+  const state = readJsonFileRaw(REFRESH_STATE_FILE);
+  return state?.items?.[usageRouteCacheKey(baseUrl)] || {};
+}
+function ageMs(isoDate) {
+  const time = Date.parse(isoDate || "");
+  return Number.isFinite(time) ? Date.now() - time : Number.POSITIVE_INFINITY;
+}
+function writeRefreshAttempt(baseUrl) {
+  try {
+    const state = readJsonFileRaw(REFRESH_STATE_FILE);
+    const key = usageRouteCacheKey(baseUrl);
+    state.version = 1;
+    state.items = state.items && typeof state.items === "object" ? state.items : {};
+    state.items[key] = {
+      ...state.items[key] || {},
+      baseUrl,
+      lastAttemptAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    fs.mkdirSync(dirname(REFRESH_STATE_FILE), { recursive: true });
+    fs.writeFileSync(REFRESH_STATE_FILE, `${JSON.stringify(state, null, 2)}
+`);
+  } catch {
+  }
+}
+function shouldRefreshUsage(baseUrl, snapshot) {
+  if (process.env.AGENT_TOOLS_USAGE_REFRESH === "0") return false;
+  if (!baseUrl || isOfficialBaseUrl(baseUrl)) return false;
+  if (!hasClaudeUsageToken()) return false;
+  if (!fs.existsSync(USAGE_RUNTIME)) return false;
+  const ttlMs = numberFromEnv("AGENT_TOOLS_USAGE_SNAPSHOT_TTL_MS", DEFAULT_SNAPSHOT_TTL_MS);
+  const cooldownMs = numberFromEnv("AGENT_TOOLS_USAGE_REFRESH_COOLDOWN_MS", DEFAULT_REFRESH_COOLDOWN_MS);
+  const failureBackoffMs = numberFromEnv("AGENT_TOOLS_USAGE_FAILURE_BACKOFF_MS", DEFAULT_FAILURE_BACKOFF_MS);
+  const state = refreshStateForBaseUrl(baseUrl);
+  if (ageMs(state.lastAttemptAt) < cooldownMs) return false;
+  if (state.lastError && ageMs(state.lastFailureAt) < failureBackoffMs) return false;
+  return !snapshot || ageMs(snapshot.updatedAt) >= ttlMs;
+}
+function refreshUsageInBackground(baseUrl) {
+  if (!shouldRefreshUsage(baseUrl, snapshotForBaseUrl(baseUrl))) return;
+  writeRefreshAttempt(baseUrl);
+  try {
+    const child = spawn(process.execPath, [USAGE_RUNTIME, "refresh", "--agent", "claude"], {
+      detached: true,
+      stdio: "ignore",
+      env: process.env,
+      windowsHide: true
+    });
+    child.unref();
+  } catch {
+  }
+}
+function providerUsageStatus() {
+  const baseUrl = activeRelayBaseUrl();
+  if (!baseUrl || isOfficialBaseUrl(baseUrl)) return "";
+  const snapshot = snapshotForBaseUrl(baseUrl);
+  if (shouldRefreshUsage(baseUrl, snapshot)) refreshUsageInBackground(baseUrl);
+  return snapshot?.text || "";
+}
+function render(data, config) {
+  const fields = config.fields.map((field) => renderField(field, data, config)).filter(Boolean);
+  const providerUsage = providerUsageStatus();
+  if (providerUsage) fields.push(providerUsage);
+  return fields.join(config.separator);
+}
+async function main() {
+  const config = mergeConfig(parseArgs(process.argv.slice(2)));
+  let data = {};
+  try {
+    const raw = await readStdin();
+    data = raw.trim() ? JSON.parse(raw) : {};
+  } catch {
+    data = {};
+  }
+  process.stdout.write(render(data, config));
+}
+main();

package/dist/usage/cli.mjs

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+
+// integrations/usage/cli.mjs
+import { queryAgentProviderUsage } from "./core.mjs";
+function parseAgent(argv) {
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (arg === "--agent" && argv[index + 1]) return argv[index + 1];
+    if (arg.startsWith("--agent=")) return arg.slice("--agent=".length);
+  }
+  return null;
+}
+var agent = parseAgent(process.argv.slice(2));
+if (agent !== "claude" && agent !== "codex") {
+  process.stderr.write(agent ? `Unsupported agent: ${agent}
+` : "Missing --agent <claude|codex>\n");
+  process.exitCode = 2;
+} else {
+  try {
+    const result = await queryAgentProviderUsage(agent);
+    if (result?.text) process.stdout.write(`${result.text}
+`);
+  } catch {
+  }
+}

package/dist/usage/codex-hook.mjs

@@ -0,0 +1,144 @@
+#!/usr/bin/env node
+
+// integrations/usage/codex-hook.mjs
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { spawn } from "node:child_process";
+import { fileURLToPath } from "node:url";
+var SCRIPT_DIR = path.dirname(fileURLToPath(import.meta.url));
+var AGENT_TOOLS_HOME = process.env.AGENT_TOOLS_HOME || path.resolve(SCRIPT_DIR, "..", "..");
+var USAGE_SCRIPT = path.join(SCRIPT_DIR, "core.mjs");
+var LOG_PATH = path.join(AGENT_TOOLS_HOME, "logs", "usage-hook.log");
+var TIMEOUT_MS = Number(process.env.AGENT_TOOLS_USAGE_HOOK_TIMEOUT_MS || 4500);
+var MAX_LOG_BYTES = Number(process.env.AGENT_TOOLS_USAGE_HOOK_LOG_BYTES || 256 * 1024);
+var KEEP_LOG_BYTES = 128 * 1024;
+function hookOut(message) {
+  const payload = { continue: true };
+  if (message) payload.systemMessage = message;
+  process.stdout.write(`${JSON.stringify(payload)}
+`);
+}
+function preview(text) {
+  return String(text || "").replace(/\s+/g, " ").trim().slice(0, 500);
+}
+function logFailure(event) {
+  try {
+    fs.mkdirSync(path.dirname(LOG_PATH), { recursive: true });
+    rotateLogIfNeeded();
+    fs.appendFileSync(
+      LOG_PATH,
+      `${JSON.stringify({ at: (/* @__PURE__ */ new Date()).toISOString(), ...event })}
+`
+    );
+  } catch {
+  }
+}
+function rotateLogIfNeeded() {
+  const maxBytes = Number.isFinite(MAX_LOG_BYTES) && MAX_LOG_BYTES > 0 ? MAX_LOG_BYTES : 256 * 1024;
+  if (!fs.existsSync(LOG_PATH)) return;
+  const stat = fs.statSync(LOG_PATH);
+  if (stat.size <= maxBytes) return;
+  const keepBytes = Math.min(KEEP_LOG_BYTES, Math.floor(maxBytes / 2));
+  const fd = fs.openSync(LOG_PATH, "r");
+  try {
+    const buffer = Buffer.alloc(keepBytes);
+    fs.readSync(fd, buffer, 0, keepBytes, Math.max(0, stat.size - keepBytes));
+    fs.writeFileSync(
+      LOG_PATH,
+      `${JSON.stringify({ at: (/* @__PURE__ */ new Date()).toISOString(), reason: "log rotated", previousBytes: stat.size })}
+` + buffer.toString("utf8").replace(/^[^\n]*\n?/, "")
+    );
+  } finally {
+    fs.closeSync(fd);
+  }
+}
+function failureMessage() {
+  return `API usage hook failed; see ${LOG_PATH.replace(/\\/g, "/")}`;
+}
+function parseHookJson(stdout) {
+  const text = stdout.trim();
+  if (!text) return { continue: true };
+  return JSON.parse(text);
+}
+async function runUsageScript() {
+  if (!fs.existsSync(USAGE_SCRIPT)) {
+    logFailure({ reason: "missing usage script", usageScript: USAGE_SCRIPT });
+    hookOut(failureMessage());
+    return;
+  }
+  const result = await new Promise((resolve) => {
+    const child = spawn(process.execPath, [USAGE_SCRIPT, "hook", "--agent", "codex"], {
+      cwd: process.cwd(),
+      env: process.env,
+      stdio: ["ignore", "pipe", "pipe"],
+      windowsHide: true
+    });
+    let stdout = "";
+    let stderr = "";
+    let settled = false;
+    const timeout = setTimeout(() => {
+      if (settled) return;
+      settled = true;
+      child.kill();
+      resolve({ status: null, signal: "timeout", stdout, stderr });
+    }, Number.isFinite(TIMEOUT_MS) && TIMEOUT_MS > 0 ? TIMEOUT_MS : 4500);
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk;
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk;
+    });
+    child.on("error", (error) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timeout);
+      resolve({ status: null, error, stdout, stderr });
+    });
+    child.on("exit", (status, signal) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timeout);
+      resolve({ status, signal, stdout, stderr });
+    });
+  });
+  if (result.status !== 0) {
+    logFailure({
+      reason: "usage script exited non-zero",
+      status: result.status,
+      signal: result.signal || "",
+      error: result.error?.message || "",
+      stdout: preview(result.stdout),
+      stderr: preview(result.stderr),
+      usageScript: USAGE_SCRIPT,
+      node: process.version,
+      platform: `${process.platform} ${os.release()}`
+    });
+    hookOut(failureMessage());
+    return;
+  }
+  try {
+    const payload = parseHookJson(result.stdout);
+    process.stdout.write(`${JSON.stringify(payload)}
+`);
+  } catch (error) {
+    logFailure({
+      reason: "usage script returned invalid hook JSON",
+      error: error.message,
+      stdout: preview(result.stdout),
+      stderr: preview(result.stderr),
+      usageScript: USAGE_SCRIPT
+    });
+    hookOut(failureMessage());
+  }
+}
+try {
+  await runUsageScript();
+} catch (error) {
+  logFailure({
+    reason: "wrapper exception",
+    error: error?.stack || error?.message || String(error),
+    usageScript: USAGE_SCRIPT
+  });
+  hookOut(failureMessage());
+}