omniagent 0.1.13 → 0.1.16

package/README.md

@@ -1,6 +1,6 @@
 # omniagent
 
-One source of truth for agent config across Claude, Codex, Gemini, and Copilot (and [any other agent](docs/custom-targets.md))
+One source of truth for agent config across Claude, Codex, Antigravity (agy), and Copilot (and [any other agent](docs/custom-targets.md))
 
 Define canonical agent files once in `agents/`, then run `sync` to compile target-specific outputs.
 
@@ -89,14 +89,17 @@ 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.
+`usage` supports Codex, Claude, and Antigravity (`agy`; `gemini` works as an alias). 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
+gate usage inspection behind auth or onboarding state. When Antigravity requests directory trust,
+interactive usage shows the exact directory and forwards approval only after you confirm;
+omniagent never accepts trust automatically or completes authentication prompts. If Antigravity
+requests directory trust, JSON, debug, and non-interactive runs return a `trust_required` error
+instead of prompting. Pass `--timeout=<seconds>` to override the per-agent timeout for the current
+run.
 
 ## Local Overrides (`.local`)
 
@@ -213,6 +216,18 @@ Example usage:
 ./code-review.sh codex
 ```
 
+The shim also unifies structured outputs: pass a JSON schema (file path or inline JSON) with
+`--output-schema`, and stdout is exactly the schema-conforming JSON regardless of agent. Agents
+with native schema support (claude, codex) enforce it server-side; all others get a prompt-based
+fallback with client-side validation and automatic retries:
+
+```bash
+omniagent -p "Top 3 benefits of TypeScript" --agent claude \
+  --output-schema ./schema.json | jq .answer
+```
+
+See [`docs/cli-shim.md`](docs/cli-shim.md) for the full shared-flag capability matrix.
+
 ## Documentation
 
 - Docs index: [`docs/README.md`](docs/README.md)

package/dist/agy-DlbWeyP_.js

@@ -0,0 +1,379 @@
+import { mkdir } from "node:fs/promises";
+import path from "node:path";
+import { c as cleanControlOutput, m as makeUsageLimit, U as UsageExtractionError, a as compactLines, p as parsePercentRemaining } from "./cli.js";
+import { r as runPtyScenario, e as enterKey, a as escapeKey } from "./pty-D8BFQQQg.js";
+const TRUST_DIALOG_PATTERN = /Do you trust the contents of this project\?/i;
+const READY_PATTERN = /\?\s+for shortcuts/i;
+const LOGIN_SELECTION_PATTERN = /Select login method:/i;
+const USAGE_GROUP_HEADING_PATTERN = /^[A-Z][A-Z0-9 &/-]+$/;
+const LIMIT_LABEL_PATTERN = /limit$/i;
+const MODELS_LINE_PATTERN = /^Models within this group:\s*(.+)$/i;
+const REFRESH_PATTERN = /Refreshes\s+in\s+(?:(\d+)h)?\s*(?:(\d+)m)?/i;
+const NOT_SIGNED_IN_PATTERN = /\bnot signed in\b/i;
+const SIGNING_IN_PATTERN = /\bsigning in\b/i;
+const DISABLED_PATTERN = /^Disabled$/i;
+const AGY_USAGE_FALLBACK_PATH = [".omniagent", "state", "usage", "antigravity-cli"];
+const STARTUP_READY_TIMEOUT_MS = 25e3;
+const USAGE_PANEL_STABLE_MS = 1e3;
+const USAGE_PANEL_MIN_OBSERVE_MS = 2e3;
+function isCurrentTrustDialog(snapshot) {
+  return TRUST_DIALOG_PATTERN.test(snapshot.screen);
+}
+function isNotCurrentTrustDialog(snapshot) {
+  return !isCurrentTrustDialog(snapshot);
+}
+function isReady(snapshot) {
+  return READY_PATTERN.test(snapshot.screen);
+}
+function isLoginSelection(snapshot) {
+  return LOGIN_SELECTION_PATTERN.test(snapshot.screen);
+}
+function isStartupTerminalState(snapshot) {
+  return isReady(snapshot) || isCurrentTrustDialog(snapshot) || isLoginSelection(snapshot);
+}
+function isPostTrustTerminalState(snapshot) {
+  return isReady(snapshot) || isLoginSelection(snapshot);
+}
+function isCurrentSignInFailure(snapshot) {
+  return NOT_SIGNED_IN_PATTERN.test(snapshot.screen) || isLoginSelection(snapshot);
+}
+function isInteractionBlocked(snapshot) {
+  return isCurrentTrustDialog(snapshot) || isCurrentSignInFailure(snapshot);
+}
+function isAuthenticationTransition(snapshot) {
+  return SIGNING_IN_PATTERN.test(snapshot.screen);
+}
+function isUsageWriteBlocked(snapshot) {
+  return isInteractionBlocked(snapshot) || isAuthenticationTransition(snapshot);
+}
+function createStableUsagePanelWait(stableMs = USAGE_PANEL_STABLE_MS, minObserveMs = USAGE_PANEL_MIN_OBSERVE_MS) {
+  let previousSignature = "";
+  let firstSeenAt = null;
+  let stableSince = 0;
+  return (snapshot) => {
+    if (isInteractionBlocked(snapshot)) {
+      return true;
+    }
+    const groups = parseAgyUsage(snapshot.screen, cleanControlOutput(snapshot.raw));
+    if (groups.length === 0) {
+      previousSignature = "";
+      firstSeenAt = null;
+      stableSince = 0;
+      return false;
+    }
+    const signature = usageGroupSignature(groups);
+    const now = Date.now();
+    if (firstSeenAt == null) {
+      firstSeenAt = now;
+    }
+    if (signature !== previousSignature) {
+      previousSignature = signature;
+      stableSince = now;
+      return false;
+    }
+    return now - firstSeenAt >= minObserveMs && now - stableSince >= stableMs;
+  };
+}
+function guardedUsageWrite(value, scenarioState, waitMs) {
+  return {
+    waitMs,
+    write: (snapshot) => {
+      if (isUsageWriteBlocked(snapshot)) {
+        scenarioState.canEnterUsage = false;
+        return void 0;
+      }
+      return scenarioState.canEnterUsage ? value : void 0;
+    }
+  };
+}
+async function extractAgyUsage(context) {
+  const command = context.command ?? context.launch?.command ?? "agy";
+  const launchCwd = await ensureAgyUsageCwd(context.homeDir, context.repoRoot);
+  const scenarioState = {
+    trustOutcome: "not-requested",
+    canEnterUsage: false,
+    reachedReadyAfterTrust: false
+  };
+  const ptyResult = await runPtyScenario({
+    command,
+    args: context.launch?.args ?? [],
+    cwd: launchCwd.path,
+    cols: 120,
+    rows: 40,
+    timeoutMs: context.launch?.timeoutMs ?? 7e4,
+    signal: context.signal,
+    debug: context.debug,
+    steps: [
+      {
+        waitFor: isStartupTerminalState,
+        waitForTimeoutMs: STARTUP_READY_TIMEOUT_MS,
+        optional: true,
+        capture: "startup",
+        captureWaitMs: 0
+      },
+      {
+        skipIf: isNotCurrentTrustDialog,
+        skipIfSource: "screen",
+        write: async () => {
+          if (context.confirm == null) {
+            scenarioState.trustOutcome = "required";
+            return void 0;
+          }
+          const approved = await context.confirm({
+            type: "trust-directory",
+            targetId: context.targetId,
+            displayName: context.displayName,
+            path: launchCwd.path,
+            managed: launchCwd.managed
+          });
+          scenarioState.trustOutcome = approved ? "approved" : "denied";
+          return void 0;
+        }
+      },
+      {
+        write: (snapshot2) => {
+          if (!isCurrentTrustDialog(snapshot2)) {
+            return void 0;
+          }
+          if (scenarioState.trustOutcome === "approved") {
+            return enterKey();
+          }
+          if (scenarioState.trustOutcome === "denied") {
+            return escapeKey();
+          }
+          return void 0;
+        }
+      },
+      {
+        skipIf: () => scenarioState.trustOutcome !== "approved",
+        waitFor: isPostTrustTerminalState,
+        waitForTimeoutMs: STARTUP_READY_TIMEOUT_MS,
+        optional: true
+      },
+      {
+        write: (snapshot2) => {
+          const readyForUsage = isReady(snapshot2) && !isInteractionBlocked(snapshot2);
+          if (scenarioState.trustOutcome === "approved" && readyForUsage) {
+            scenarioState.reachedReadyAfterTrust = true;
+          }
+          scenarioState.canEnterUsage = scenarioState.trustOutcome !== "denied" && scenarioState.trustOutcome !== "required" && readyForUsage;
+          return void 0;
+        }
+      },
+      ...[..."/usage"].map((character) => guardedUsageWrite(character, scenarioState, 25)),
+      guardedUsageWrite(enterKey(), scenarioState, 250),
+      {
+        skipIf: () => !scenarioState.canEnterUsage,
+        waitFor: createStableUsagePanelWait(),
+        waitForTimeoutMs: 15e3,
+        optional: true,
+        capture: "usage",
+        captureWaitMs: 0
+      },
+      guardedUsageWrite(escapeKey(), scenarioState, 250)
+    ]
+  });
+  const buildError = (message, code) => {
+    const error = code == null ? new Error(message) : new UsageExtractionError(code, message);
+    if (ptyResult.debug.length > 0) {
+      Object.assign(error, { debug: ptyResult.debug });
+    }
+    return error;
+  };
+  const trustSubject = launchCwd.managed ? "managed usage directory" : "project directory";
+  if (scenarioState.trustOutcome === "required") {
+    throw buildError(
+      `Antigravity needs permission to trust the ${trustSubject} at ${launchCwd.path}. Re-run usage in an interactive terminal to review this request.`,
+      "trust_required"
+    );
+  }
+  if (scenarioState.trustOutcome === "denied") {
+    throw buildError(
+      `Antigravity trust was declined for the ${trustSubject} at ${launchCwd.path}.`,
+      "trust_denied"
+    );
+  }
+  if (isCurrentSignInFailure(ptyResult)) {
+    throw buildError(`Antigravity is not signed in. Run \`${command}\` and complete the login.`);
+  }
+  if (scenarioState.trustOutcome === "approved" && !scenarioState.reachedReadyAfterTrust) {
+    throw buildError(
+      `Antigravity did not accept trust for the ${trustSubject} at ${launchCwd.path}. Run \`${command}\` there once, accept the trust prompt, then re-run usage.`,
+      "trust_acceptance_failed"
+    );
+  }
+  if (isCurrentTrustDialog(ptyResult)) {
+    throw buildError(
+      `Antigravity still requires trust for the ${trustSubject} at ${launchCwd.path}.`,
+      "trust_required"
+    );
+  }
+  const snapshot = ptyResult.snapshots.usage ?? ptyResult;
+  const cleanedOutput = cleanControlOutput(snapshot.raw);
+  if (isCurrentSignInFailure(snapshot)) {
+    throw buildError(`Antigravity is not signed in. Run \`${command}\` and complete the login.`);
+  }
+  const groups = parseAgyUsage(snapshot.screen, cleanedOutput);
+  if (groups.length === 0) {
+    throw buildError("Antigravity /usage output did not include Models & Quota limit groups.");
+  }
+  return {
+    targetId: context.targetId,
+    displayName: context.displayName,
+    command,
+    limits: groups.map((group) => {
+      const percentRemaining = group.disabled || group.percentRemaining == null ? null : clampPercent(group.percentRemaining);
+      const limit = makeUsageLimit({
+        targetId: context.targetId,
+        scope: usageScope(group.heading),
+        window: "weekly",
+        label: titleCase(group.heading),
+        percentUsed: percentRemaining == null ? null : 100 - percentRemaining,
+        percentRemaining,
+        remainingText: group.disabled ? "Disabled" : null,
+        resetText: group.resetText,
+        raw: group.raw,
+        now: context.now
+      });
+      return {
+        ...limit,
+        resetAt: parseAgyRefreshResetAt(group.resetText, context.now) ?? limit.resetAt
+      };
+    }),
+    debug: ptyResult.debug.length > 0 ? ptyResult.debug : void 0
+  };
+}
+async function ensureAgyUsageCwd(homeDir, repoRoot) {
+  const fallbackDir = path.join(homeDir, ...AGY_USAGE_FALLBACK_PATH);
+  try {
+    await mkdir(fallbackDir, { recursive: true });
+    return { path: fallbackDir, managed: true };
+  } catch {
+    return { path: repoRoot, managed: false };
+  }
+}
+function parseAgyUsage(screen, cleanedOutput = "") {
+  const fromRaw = parseAgyUsageLines(compactLines(cleanedOutput));
+  const fromScreen = parseAgyUsageLines(compactLines(screen));
+  const merged = /* @__PURE__ */ new Map();
+  for (const group of [...fromRaw, ...fromScreen]) {
+    merged.set(usageGroupKey(group), group);
+  }
+  return [...merged.values()];
+}
+function usageGroupKey(group) {
+  return `${group.heading.trim().toLowerCase()}\0${group.limitLabel.trim().toLowerCase()}`;
+}
+function usageGroupSignature(groups) {
+  return JSON.stringify(
+    groups.map((group) => ({
+      heading: group.heading,
+      models: group.models,
+      limitLabel: group.limitLabel,
+      percentRemaining: group.percentRemaining,
+      resetText: group.resetText,
+      disabled: group.disabled
+    }))
+  );
+}
+function parseAgyUsageLines(lines) {
+  const groups = [];
+  let index = 0;
+  while (index < lines.length) {
+    const heading = lines[index] ?? "";
+    if (!isUsageGroupHeading(heading)) {
+      index += 1;
+      continue;
+    }
+    const rawLines = [heading];
+    let models = null;
+    let limitLabel = "";
+    let percentRemaining = null;
+    let resetText = null;
+    let disabled = false;
+    index += 1;
+    while (index < lines.length && !isUsageGroupHeading(lines[index] ?? "")) {
+      const line = lines[index] ?? "";
+      rawLines.push(line);
+      const modelsMatch = MODELS_LINE_PATTERN.exec(line);
+      if (modelsMatch?.[1]) {
+        models = modelsMatch[1].trim();
+      }
+      if (LIMIT_LABEL_PATTERN.test(line)) {
+        limitLabel = line.trim();
+      }
+      const linePercentRemaining = parseAgyRemainingPercent(line);
+      if (linePercentRemaining != null && percentRemaining == null) {
+        percentRemaining = linePercentRemaining;
+      }
+      const lineResetText = parseAgyRefreshText(line);
+      if (lineResetText != null) {
+        resetText = lineResetText;
+      }
+      if (DISABLED_PATTERN.test(line)) {
+        disabled = true;
+      }
+      index += 1;
+    }
+    if (limitLabel && (percentRemaining != null || resetText != null || disabled)) {
+      groups.push({
+        heading,
+        models,
+        limitLabel,
+        percentRemaining,
+        resetText,
+        disabled,
+        raw: rawLines.join("\n")
+      });
+    }
+  }
+  return groups;
+}
+function isUsageGroupHeading(line) {
+  if (!USAGE_GROUP_HEADING_PATTERN.test(line)) {
+    return false;
+  }
+  return !/^(MODELS|WEEKLY|MONTHLY|DAILY|ACCOUNT)$/i.test(line);
+}
+function parseAgyRemainingPercent(line) {
+  return parsePercentRemaining(line) ?? parseStandalonePercent(line);
+}
+function parseStandalonePercent(line) {
+  const match = /(?:^|\])\s*(\d+(?:\.\d+)?)\s*%\s*$/i.exec(line);
+  if (!match?.[1]) {
+    return null;
+  }
+  return Number(match[1]);
+}
+function parseAgyRefreshText(line) {
+  const match = /(Refreshes\s+in\s+(?:(?:\d+)h)?\s*(?:(?:\d+)m)?)/i.exec(line);
+  return match?.[1]?.trim() ?? null;
+}
+function parseAgyRefreshResetAt(resetText, now) {
+  if (resetText == null) {
+    return null;
+  }
+  const match = REFRESH_PATTERN.exec(resetText);
+  if (match == null) {
+    return null;
+  }
+  const hours = Number(match[1] ?? 0);
+  const minutes = Number(match[2] ?? 0);
+  if (!Number.isFinite(hours) || !Number.isFinite(minutes) || hours + minutes <= 0) {
+    return null;
+  }
+  return new Date(now.getTime() + hours * 36e5 + minutes * 6e4).toISOString();
+}
+function clampPercent(value) {
+  return Math.max(0, Math.min(100, value));
+}
+function usageScope(heading) {
+  return heading.trim().toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "");
+}
+function titleCase(value) {
+  return value.trim().toLowerCase().split(/\s+/).map((word) => word === "gpt" ? "GPT" : `${word.charAt(0).toUpperCase()}${word.slice(1)}`).join(" ");
+}
+export {
+  extractAgyUsage,
+  parseAgyUsage
+};

package/dist/{claude-DWeyS4fP.js → claude-CcxRb8OW.js}

@@ -3,8 +3,8 @@ import { readFile } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import { promisify } from "node:util";
-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";
+import { c as cleanControlOutput, a as compactLines, b as parsePercentUsed, m as makeUsageLimit } from "./cli.js";
+import { r as runPtyScenario, e as enterKey, a as escapeKey } from "./pty-D8BFQQQg.js";
 const execFileAsync = promisify(execFile);
 const CLAUDE_CODE_KEYCHAIN_SERVICE = "Claude Code-credentials";
 const CLAUDE_CODE_CREDENTIALS_PATH = [".claude", ".credentials.json"];