omniagent 0.1.7 → 0.1.8

package/README.md

@@ -71,11 +71,33 @@ npx omniagent@latest sync --list-local
 # Apply a sync profile (see docs/profiles.md)
 npx omniagent@latest sync --profile code-reviewer
 
+# Show usage limits for installed usage-capable agents
+omniagent usage
+omniagent usage codex
+omniagent usage --only claude,codex
+omniagent usage --window=weekly
+omniagent usage --sort=reset
+omniagent usage --sort=left
+omniagent usage codex --window=5h
+omniagent usage --timeout=45
+omniagent usage --agentsDir ./my-custom-agents
+omniagent usage codex --json
+omniagent usage codex --debug
+
 # Shim mode (no subcommand)
 omniagent --agent codex
 omniagent -p "Summarize this repo" --agent codex --output json
 ```
 
+`usage` supports Codex, Claude, and Gemini in v1. Copilot is not supported for usage
+extraction yet. Usage extraction may launch agent TUIs and may incur cost if an agent
+reads repo context or instructions on startup; omniagent uses cheap/minimal launch settings
+where possible. Usage extraction times out after 30 seconds unless the target config defines
+a target-specific timeout; built-in TUI probes may use longer defaults. Some CLIs require
+session-scoped setup flags to inspect usage, such as Gemini's `--skip-trust`; omniagent does
+not complete auth or onboarding prompts for you. Pass `--timeout=<seconds>` to override the
+per-agent timeout for the current run.
+
 ## Local Overrides (`.local`)
 
 Use `.local` files for personal variants that should not become team defaults.

package/dist/claude-Dmv_YFKX.js

@@ -0,0 +1,146 @@
+import { c as cleanControlOutput, a as compactLines, p as parsePercentUsed, m as makeUsageLimit } from "./cli.js";
+import { r as runPtyScenario, e as enterKey, a as escapeKey } from "./pty-CZBSAJzE.js";
+async function extractClaudeUsage(context) {
+  const command = context.command ?? context.launch?.command ?? "claude";
+  const model = context.launch?.cheapModel ?? "haiku";
+  validateClaudeModel(model);
+  const ptyResult = await runPtyScenario({
+    command,
+    args: context.launch?.args ?? ["--model", model],
+    cwd: context.repoRoot,
+    cols: 100,
+    rows: 40,
+    timeoutMs: context.launch?.timeoutMs ?? 6e4,
+    signal: context.signal,
+    debug: context.debug,
+    steps: [
+      { waitFor: /Claude|>|❯/u, waitForSource: "screen", waitForTimeoutMs: 4e3 },
+      { write: enterKey() },
+      { waitFor: /Claude|>|❯/u, waitForSource: "screen", waitForTimeoutMs: 8e3 },
+      { write: `/usage${enterKey()}` },
+      {
+        waitFor: hasClaudeUsageRows,
+        waitForTimeoutMs: 15e3,
+        capture: "usage",
+        captureWaitMs: 500
+      },
+      { write: escapeKey() },
+      { waitMs: 500 },
+      { write: `/exit${enterKey()}` }
+    ]
+  });
+  const usageSnapshot = ptyResult.snapshots.usage ?? ptyResult;
+  const cleanedOutput = cleanControlOutput(usageSnapshot.raw);
+  const parsed = parseClaudeUsage(usageSnapshot.screen, cleanedOutput);
+  const limits = buildClaudeUsageLimits(parsed, context);
+  if (limits.length === 0) {
+    throw new Error("Claude usage output did not include session or weekly usage rows.");
+  }
+  return {
+    targetId: context.targetId,
+    displayName: context.displayName,
+    command,
+    limits,
+    debug: ptyResult.debug.length > 0 ? ptyResult.debug : void 0
+  };
+}
+function hasClaudeUsageRows(snapshot) {
+  const parsed = parseClaudeUsage(snapshot.screen, cleanControlOutput(snapshot.raw));
+  return Boolean(parsed.currentSessionUsed || parsed.currentWeekUsed);
+}
+function buildClaudeUsageLimits(parsed, context) {
+  const sessionUsed = parsePercentUsed(parsed.currentSessionUsed);
+  const weekUsed = parsePercentUsed(parsed.currentWeekUsed);
+  const limits = [];
+  if (parsed.currentSessionUsed.trim()) {
+    limits.push(
+      makeUsageLimit({
+        targetId: context.targetId,
+        scope: "current_session",
+        window: "session",
+        percentUsed: sessionUsed,
+        percentRemaining: sessionUsed == null ? null : 100 - sessionUsed,
+        resetText: parsed.currentSessionResets,
+        raw: formatRaw(parsed.currentSessionUsed, parsed.currentSessionResets),
+        now: context.now
+      })
+    );
+  }
+  if (parsed.currentWeekUsed.trim()) {
+    limits.push(
+      makeUsageLimit({
+        targetId: context.targetId,
+        scope: "current_week",
+        window: "weekly",
+        percentUsed: weekUsed,
+        percentRemaining: weekUsed == null ? null : 100 - weekUsed,
+        resetText: parsed.currentWeekResets,
+        raw: formatRaw(parsed.currentWeekUsed, parsed.currentWeekResets),
+        now: context.now
+      })
+    );
+  }
+  return limits;
+}
+function parseClaudeUsage(screen, cleanedOutput = "") {
+  const fromScreen = parseClaudeLines(compactLines(screen));
+  if (fromScreen.currentSessionUsed || fromScreen.currentWeekUsed) {
+    return fromScreen;
+  }
+  return parseClaudeLines(compactLines(cleanedOutput));
+}
+function parseClaudeLines(lines) {
+  const values = {
+    currentSessionUsed: "",
+    currentSessionResets: "",
+    currentWeekUsed: "",
+    currentWeekResets: ""
+  };
+  let section = "";
+  for (const line of lines) {
+    if (line === "Current session") {
+      section = "currentSession";
+      continue;
+    }
+    if (line.startsWith("Current week")) {
+      section = "currentWeek";
+      continue;
+    }
+    if (!section) {
+      continue;
+    }
+    const usedMatch = /(\d+(?:\.\d+)?% used)/i.exec(line);
+    if (usedMatch != null) {
+      if (section === "currentSession") {
+        values.currentSessionUsed = usedMatch[1];
+      } else {
+        values.currentWeekUsed = usedMatch[1];
+      }
+      continue;
+    }
+    if (line.startsWith("Resets ")) {
+      if (section === "currentSession") {
+        values.currentSessionResets = line.slice("Resets ".length).trim();
+      } else {
+        values.currentWeekResets = line.slice("Resets ".length).trim();
+      }
+    }
+  }
+  return values;
+}
+function formatRaw(used, resets) {
+  if (!used) {
+    return "";
+  }
+  return resets ? `${used} (resets ${resets})` : used;
+}
+function validateClaudeModel(model) {
+  if (!/^[A-Za-z0-9._:-]+$/.test(model)) {
+    throw new Error(`Unsupported Claude usage model value: ${model}`);
+  }
+}
+export {
+  buildClaudeUsageLimits,
+  extractClaudeUsage,
+  parseClaudeUsage
+};