axusage 3.1.0 → 3.3.0

package/dist/services/service-adapter-registry.js

@@ -1,14 +1,14 @@
-import { chatGPTAdapter } from "../adapters/chatgpt.js";
+import { codexAdapter } from "../adapters/codex.js";
 import { claudeAdapter } from "../adapters/claude.js";
 import { geminiAdapter } from "../adapters/gemini.js";
-import { githubCopilotAdapter } from "../adapters/github-copilot.js";
+import { copilotAdapter } from "../adapters/copilot.js";
 /**
  * Registry of available service adapters
  */
 export const SERVICE_ADAPTERS = {
     claude: claudeAdapter,
-    chatgpt: chatGPTAdapter,
-    "github-copilot": githubCopilotAdapter,
+    codex: codexAdapter,
+    copilot: copilotAdapter,
     gemini: geminiAdapter,
 };
 /**

package/dist/services/service-diagnostics.d.ts

@@ -0,0 +1,11 @@
+import type { SupportedService } from "./supported-service.js";
+type ServiceDiagnostic = {
+    readonly service: SupportedService;
+    readonly cliAvailable: boolean;
+    readonly cliPath: string;
+    readonly authenticated: boolean;
+    readonly authMethod: string | undefined;
+};
+export type { ServiceDiagnostic };
+export declare function getServiceDiagnostic(service: SupportedService): ServiceDiagnostic;
+export declare function getAllServiceDiagnostics(): ServiceDiagnostic[];

package/dist/services/service-diagnostics.js

@@ -0,0 +1,29 @@
+import { checkAuth } from "axauth";
+import { checkCliDependency, getAuthCliDependency, } from "../utils/check-cli-dependency.js";
+import { getCopilotTokenFromCustomGhPath } from "../utils/copilot-gh-token.js";
+import { SUPPORTED_SERVICES } from "./supported-service.js";
+export function getServiceDiagnostic(service) {
+    const dependency = getAuthCliDependency(service);
+    const cliResult = checkCliDependency(dependency);
+    let authResult = checkAuth(service);
+    if (service === "copilot" && !authResult.authenticated) {
+        const tokenFromOverride = getCopilotTokenFromCustomGhPath();
+        if (tokenFromOverride) {
+            authResult = {
+                ...authResult,
+                authenticated: true,
+                method: "GitHub CLI (AXUSAGE_GH_PATH)",
+            };
+        }
+    }
+    return {
+        service,
+        cliAvailable: cliResult.ok,
+        cliPath: cliResult.path,
+        authenticated: authResult.authenticated,
+        authMethod: authResult.method,
+    };
+}
+export function getAllServiceDiagnostics() {
+    return SUPPORTED_SERVICES.map((service) => getServiceDiagnostic(service));
+}

package/dist/services/supported-service.d.ts

@@ -1,6 +1,10 @@
+import type { AgentCli } from "axauth";
 /**
- * Supported service names for usage tracking
+ * Supported service names for usage tracking.
+ *
+ * Derived from the canonical AGENT_CLIS list, excluding agents
+ * that axusage doesn't yet support (opencode).
  */
-export type SupportedService = "claude" | "chatgpt" | "github-copilot" | "gemini";
+export type SupportedService = Exclude<AgentCli, "opencode">;
 export declare const SUPPORTED_SERVICES: SupportedService[];
 export declare function validateService(service: string | undefined): SupportedService;

package/dist/services/supported-service.js

@@ -1,9 +1,5 @@
-export const SUPPORTED_SERVICES = [
-    "claude",
-    "chatgpt",
-    "github-copilot",
-    "gemini",
-];
+import { AGENT_CLIS } from "axauth";
+export const SUPPORTED_SERVICES = AGENT_CLIS.filter((cli) => cli !== "opencode");
 export function validateService(service) {
     if (!service) {
         throw new Error(`Service is required. Supported services: ${SUPPORTED_SERVICES.join(", ")}. ` +

package/dist/types/{chatgpt.d.ts → codex.d.ts}

@@ -2,14 +2,14 @@ import { z } from "zod";
 /**
  * ChatGPT API response schemas
  */
-export declare const ChatGPTRateLimitWindow: z.ZodObject<{
+export declare const CodexRateLimitWindow: z.ZodObject<{
     used_percent: z.ZodNumber;
     limit_window_seconds: z.ZodNumber;
     reset_after_seconds: z.ZodNumber;
     reset_at: z.ZodNumber;
 }, z.core.$strip>;
-export type ChatGPTRateLimitWindow = z.infer<typeof ChatGPTRateLimitWindow>;
-export declare const ChatGPTUsageResponse: z.ZodObject<{
+export type CodexRateLimitWindow = z.infer<typeof CodexRateLimitWindow>;
+export declare const CodexUsageResponse: z.ZodObject<{
     plan_type: z.ZodString;
     rate_limit: z.ZodObject<{
         allowed: z.ZodBoolean;
@@ -29,4 +29,4 @@ export declare const ChatGPTUsageResponse: z.ZodObject<{
     }, z.core.$strip>;
     credits: z.ZodNullable<z.ZodUnknown>;
 }, z.core.$strip>;
-export type ChatGPTUsageResponse = z.infer<typeof ChatGPTUsageResponse>;
+export type CodexUsageResponse = z.infer<typeof CodexUsageResponse>;

package/dist/types/{chatgpt.js → codex.js}

@@ -2,20 +2,20 @@ import { z } from "zod";
 /**
  * ChatGPT API response schemas
  */
-export const ChatGPTRateLimitWindow = z.object({
+export const CodexRateLimitWindow = z.object({
     used_percent: z.number(),
     limit_window_seconds: z.number(),
     reset_after_seconds: z.number(),
     reset_at: z.number(), // Unix timestamp
 });
-const ChatGPTRateLimit = z.object({
+const CodexRateLimit = z.object({
     allowed: z.boolean(),
     limit_reached: z.boolean(),
-    primary_window: ChatGPTRateLimitWindow,
-    secondary_window: ChatGPTRateLimitWindow,
+    primary_window: CodexRateLimitWindow,
+    secondary_window: CodexRateLimitWindow,
 });
-export const ChatGPTUsageResponse = z.object({
+export const CodexUsageResponse = z.object({
     plan_type: z.string(),
-    rate_limit: ChatGPTRateLimit,
+    rate_limit: CodexRateLimit,
     credits: z.unknown().nullable(),
 });

package/dist/types/copilot.d.ts

@@ -0,0 +1,14 @@
+import { z } from "zod";
+export declare const CopilotUsageResponse: z.ZodObject<{
+    quota_reset_date_utc: z.ZodString;
+    copilot_plan: z.ZodString;
+    quota_snapshots: z.ZodObject<{
+        premium_interactions: z.ZodObject<{
+            entitlement: z.ZodNumber;
+            remaining: z.ZodNumber;
+            percent_remaining: z.ZodNumber;
+            unlimited: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type CopilotUsageResponse = z.infer<typeof CopilotUsageResponse>;

package/dist/types/copilot.js

@@ -0,0 +1,21 @@
+import { z } from "zod";
+/**
+ * GitHub Copilot internal API response schema
+ * Endpoint: GET https://api.github.com/copilot_internal/user
+ */
+const PremiumInteractionsSnapshot = z.object({
+    entitlement: z.number(),
+    remaining: z.number(),
+    percent_remaining: z.number(),
+    unlimited: z.boolean().optional(),
+});
+const QuotaSnapshots = z.object({
+    premium_interactions: PremiumInteractionsSnapshot,
+});
+export const CopilotUsageResponse = z.object({
+    quota_reset_date_utc: z
+        .string()
+        .refine((s) => !Number.isNaN(new Date(s).getTime()), "Invalid date"),
+    copilot_plan: z.string(),
+    quota_snapshots: QuotaSnapshots,
+});

package/dist/utils/check-cli-dependency.d.ts

@@ -3,8 +3,7 @@ type CliDependency = {
     readonly envVar: string;
     readonly installHint: string;
 };
-declare const AUTH_CLI_SERVICES: readonly ["claude", "chatgpt", "gemini"];
-type AuthCliService = (typeof AUTH_CLI_SERVICES)[number];
+type AuthCliService = "claude" | "codex" | "copilot" | "gemini";
 export declare function getAuthCliDependency(service: AuthCliService): CliDependency;
 export declare function checkCliDependency(dep: CliDependency): {
     ok: boolean;
@@ -21,5 +20,4 @@ export declare function ensureAuthCliDependency(service: AuthCliService): {
 export declare function resolveAuthCliDependencyOrReport(service: AuthCliService, options?: {
     readonly setExitCode?: boolean;
 }): string | undefined;
-export { AUTH_CLI_SERVICES };
-export type { AuthCliService };
+export {};

package/dist/utils/check-cli-dependency.js

@@ -11,13 +11,17 @@ const CLI_DEPENDENCIES = {
         envVar: "AXUSAGE_CODEX_PATH",
         installHint: "npm install -g @openai/codex",
     },
+    gh: {
+        command: "gh",
+        envVar: "AXUSAGE_GH_PATH",
+        installHint: "https://cli.github.com/ or brew install gh",
+    },
     gemini: {
         command: "gemini",
         envVar: "AXUSAGE_GEMINI_PATH",
         installHint: "npm install -g @google/gemini-cli",
     },
 };
-const AUTH_CLI_SERVICES = ["claude", "chatgpt", "gemini"];
 function resolveCliDependencyTimeout() {
     const raw = process.env.AXUSAGE_CLI_TIMEOUT_MS;
     if (!raw)
@@ -28,8 +32,8 @@ function resolveCliDependencyTimeout() {
     return Math.round(parsed);
 }
 export function getAuthCliDependency(service) {
-    if (service === "chatgpt")
-        return CLI_DEPENDENCIES.codex;
+    if (service === "copilot")
+        return CLI_DEPENDENCIES.gh;
     return CLI_DEPENDENCIES[service];
 }
 function resolveCliDependencyPath(dep) {
@@ -78,4 +82,3 @@ function reportMissingCliDependency(dependency, path) {
     console.error(chalk.gray(`  2. Set ${dependency.envVar}=/path/to/${dependency.command}`));
     console.error(chalk.gray("Try 'axusage --help' for requirements and overrides."));
 }
-export { AUTH_CLI_SERVICES };

package/dist/utils/copilot-gh-token.d.ts

@@ -0,0 +1 @@
+export declare function getCopilotTokenFromCustomGhPath(): string | undefined;

package/dist/utils/copilot-gh-token.js

@@ -0,0 +1,38 @@
+import { execFileSync } from "node:child_process";
+const GH_PATH_OVERRIDE_ENV = "AXUSAGE_GH_PATH";
+const DEFAULT_TIMEOUT_MS = 5000;
+function resolveCliTimeoutMs() {
+    const rawValue = process.env.AXUSAGE_CLI_TIMEOUT_MS;
+    if (!rawValue)
+        return DEFAULT_TIMEOUT_MS;
+    const parsed = Number(rawValue);
+    if (!Number.isFinite(parsed) || parsed <= 0)
+        return DEFAULT_TIMEOUT_MS;
+    return Math.round(parsed);
+}
+function resolveGhOverridePath() {
+    const value = process.env[GH_PATH_OVERRIDE_ENV]?.trim();
+    if (!value)
+        return undefined;
+    return value;
+}
+export function getCopilotTokenFromCustomGhPath() {
+    const path = resolveGhOverridePath();
+    if (!path)
+        return undefined;
+    try {
+        const token = execFileSync(path, ["auth", "token"], {
+            encoding: "utf8",
+            stdio: ["pipe", "pipe", "pipe"],
+            timeout: resolveCliTimeoutMs(),
+        }).trim();
+        // Copilot requires fine-grained tokens; reject classic PATs.
+        if (token && !token.startsWith("ghp_")) {
+            return token;
+        }
+    }
+    catch {
+        // Ignore command failures and fall back to other auth sources.
+    }
+    return undefined;
+}

package/dist/utils/format-requires-help-text.d.ts

@@ -0,0 +1,17 @@
+type RuntimeRequirement = {
+    readonly label: string;
+    readonly status: "ok";
+} | {
+    readonly label: string;
+    readonly status: "missing" | "not-authorized";
+    readonly fix: string;
+};
+export type { RuntimeRequirement };
+/**
+ * Formats a list of runtime requirements into a compact or detailed string.
+ *
+ * All-ok → single line: `Requires: claude, codex (ChatGPT), gemini, gh (Copilot)`
+ * Any non-ok → multi-line with inline remediation per requirement.
+ */
+export declare function formatRequiresSection(requirements: readonly RuntimeRequirement[]): string;
+export declare function formatRequiresHelpText(): string;

package/dist/utils/format-requires-help-text.js

@@ -0,0 +1,62 @@
+import { getAllServiceDiagnostics } from "../services/service-diagnostics.js";
+import { getAuthCliDependency } from "./check-cli-dependency.js";
+const SERVICE_LABELS = {
+    claude: "claude",
+    codex: "codex (ChatGPT)",
+    gemini: "gemini",
+    copilot: "gh (Copilot)",
+};
+const AUTH_FIX_COMMANDS = {
+    claude: "Run: claude",
+    codex: "Run: codex",
+    gemini: "Run: gemini",
+    copilot: "Run: gh auth login",
+};
+function diagnosticToRequirement(diagnostic) {
+    const label = SERVICE_LABELS[diagnostic.service];
+    if (!diagnostic.cliAvailable) {
+        const dependency = getAuthCliDependency(diagnostic.service);
+        return {
+            label,
+            status: "missing",
+            fix: `Install: ${dependency.installHint}. ` +
+                `Or set ${dependency.envVar}=/path/to/${dependency.command}`,
+        };
+    }
+    if (!diagnostic.authenticated) {
+        return {
+            label,
+            status: "not-authorized",
+            fix: AUTH_FIX_COMMANDS[diagnostic.service],
+        };
+    }
+    return { label, status: "ok" };
+}
+let cachedRequirements;
+function getRuntimeRequirementsStatus() {
+    if (cachedRequirements)
+        return cachedRequirements;
+    cachedRequirements = getAllServiceDiagnostics().map((d) => diagnosticToRequirement(d));
+    return cachedRequirements;
+}
+/**
+ * Formats a list of runtime requirements into a compact or detailed string.
+ *
+ * All-ok → single line: `Requires: claude, codex (ChatGPT), gemini, gh (Copilot)`
+ * Any non-ok → multi-line with inline remediation per requirement.
+ */
+export function formatRequiresSection(requirements) {
+    if (requirements.every((r) => r.status === "ok")) {
+        return `Requires: ${requirements.map((r) => r.label).join(", ")}`;
+    }
+    const lines = requirements.map((r) => {
+        if (r.status === "ok")
+            return `  - ${r.label}`;
+        const tag = r.status === "missing" ? "MISSING" : "NOT AUTHORIZED";
+        return `  - ${r.label} - ${tag}! ${r.fix}`;
+    });
+    return `Requires:\n${lines.join("\n")}`;
+}
+export function formatRequiresHelpText() {
+    return formatRequiresSection(getRuntimeRequirementsStatus());
+}

package/dist/utils/validate-root-options.d.ts

@@ -2,10 +2,7 @@ import type { UsageCommandOptions } from "../commands/fetch-service-usage.js";
 export type RootOptions = {
     readonly authSetup?: string;
     readonly authStatus?: string | boolean;
-    readonly authClear?: string;
-    readonly force?: boolean;
     readonly service?: UsageCommandOptions["service"];
     readonly format?: UsageCommandOptions["format"];
-    readonly interactive?: UsageCommandOptions["interactive"];
 };
 export declare function getRootOptionsError(options: RootOptions, formatSource?: string): string | undefined;

package/dist/utils/validate-root-options.js

@@ -1,13 +1,9 @@
 export function getRootOptionsError(options, formatSource) {
     // Commander sets optional args to `true` when provided without a value.
     const authSelectionCount = Number(Boolean(options.authSetup)) +
-        Number(options.authStatus !== undefined) +
-        Number(Boolean(options.authClear));
+        Number(options.authStatus !== undefined);
     if (authSelectionCount > 1) {
-        return "Use only one of --auth-setup, --auth-status, or --auth-clear.";
-    }
-    if (options.force && !options.authClear) {
-        return "--force is only supported with --auth-clear.";
+        return "Use only one of --auth-setup or --auth-status.";
     }
     const hasExplicitFormat = formatSource === "cli";
     const hasUsageOptions = Boolean(options.service) || hasExplicitFormat;

package/package.json

@@ -2,7 +2,7 @@
   "name": "axusage",
   "author": "Łukasz Jerciński",
   "license": "MIT",
-  "version": "3.1.0",
+  "version": "3.3.0",
   "description": "Monitor API usage across Claude, ChatGPT, GitHub Copilot, and Gemini from a single CLI",
   "repository": {
     "type": "git",
@@ -19,7 +19,6 @@
     "LICENSE"
   ],
   "scripts": {
-    "postinstall": "playwright install chromium",
     "prepare": "git config core.hooksPath .githooks",
     "prepublishOnly": "pnpm run rebuild",
     "build": "tsc -p tsconfig.app.json",
@@ -48,35 +47,32 @@
     "llm",
     "monitoring"
   ],
-  "packageManager": "pnpm@10.25.0",
+  "packageManager": "pnpm@10.30.1",
   "engines": {
     "node": ">=22.14.0"
   },
   "dependencies": {
     "@commander-js/extra-typings": "^14.0.0",
-    "@inquirer/prompts": "^8.2.0",
-    "axauth": "^2.1.0",
+    "axauth": "^3.1.6",
     "chalk": "^5.6.2",
-    "commander": "^14.0.2",
-    "conf": "^15.0.2",
-    "env-paths": "^3.0.0",
-    "playwright": "^1.57.0",
+    "commander": "^14.0.3",
+    "conf": "^15.1.0",
+    "env-paths": "^4.0.0",
     "prom-client": "^15.1.3",
-    "trash": "^10.0.1",
-    "zod": "^4.3.5"
+    "zod": "^4.3.6"
   },
   "devDependencies": {
     "@total-typescript/ts-reset": "^0.6.1",
-    "@types/node": "^25.0.9",
-    "@vitest/coverage-v8": "^4.0.17",
-    "eslint": "^9.39.2",
-    "eslint-config-axkit": "^1.1.0",
+    "@types/node": "^25.3.0",
+    "@vitest/coverage-v8": "^4.0.18",
+    "eslint": "^10.0.1",
+    "eslint-config-axkit": "^1.2.1",
     "fta-check": "^1.5.1",
     "fta-cli": "^3.0.0",
-    "knip": "^5.81.0",
-    "prettier": "3.8.0",
-    "semantic-release": "^25.0.2",
+    "knip": "^5.85.0",
+    "prettier": "3.8.1",
+    "semantic-release": "^25.0.3",
     "typescript": "^5.9.3",
-    "vitest": "^4.0.17"
+    "vitest": "^4.0.18"
   }
 }

package/dist/adapters/github-copilot.d.ts

@@ -1,6 +0,0 @@
-import type { ServiceAdapter } from "../types/domain.js";
-/** Functional core is extracted to ./parse-github-copilot-usage.ts */
-/**
- * GitHub Copilot service adapter
- */
-export declare const githubCopilotAdapter: ServiceAdapter;

package/dist/adapters/github-copilot.js

@@ -1,57 +0,0 @@
-import { ApiError } from "../types/domain.js";
-import { GitHubCopilotUsageResponse as GitHubCopilotUsageResponseSchema } from "../types/github-copilot.js";
-import { toServiceUsageData } from "./parse-github-copilot-usage.js";
-import { acquireAuthManager, releaseAuthManager, } from "../services/shared-browser-auth-manager.js";
-// Copilot web fetches entitlements from this endpoint (requires GitHub session cookies)
-const API_URL = "https://github.com/github-copilot/chat/entitlement";
-/** Functional core is extracted to ./parse-github-copilot-usage.ts */
-/**
- * GitHub Copilot service adapter
- */
-export const githubCopilotAdapter = {
-    name: "GitHub Copilot",
-    async fetchUsage() {
-        const manager = acquireAuthManager();
-        try {
-            if (!manager.hasAuth("github-copilot")) {
-                return {
-                    ok: false,
-                    error: new ApiError("No saved authentication for github-copilot. " +
-                        "Run 'axusage --auth-setup github-copilot --interactive' first."),
-                };
-            }
-            const body = await manager.makeAuthenticatedRequest("github-copilot", API_URL);
-            const data = JSON.parse(body);
-            const parseResult = GitHubCopilotUsageResponseSchema.safeParse(data);
-            if (!parseResult.success) {
-                return {
-                    ok: false,
-                    error: new ApiError(`Invalid response format: ${parseResult.error.message}`, undefined, data),
-                };
-            }
-            try {
-                return {
-                    ok: true,
-                    value: toServiceUsageData(parseResult.data),
-                };
-            }
-            catch (error) {
-                return {
-                    ok: false,
-                    error: new ApiError(error instanceof Error
-                        ? error.message
-                        : "Unable to parse GitHub Copilot reset date", undefined, parseResult.data.quotas.resetDate),
-                };
-            }
-        }
-        catch (error) {
-            return {
-                ok: false,
-                error: new ApiError(`Browser authentication failed: ${error instanceof Error ? error.message : String(error)}`),
-            };
-        }
-        finally {
-            await releaseAuthManager();
-        }
-    },
-};

package/dist/adapters/parse-github-copilot-usage.d.ts

@@ -1,23 +0,0 @@
-import type { ServiceUsageData } from "../types/domain.js";
-import type { GitHubCopilotUsageResponse } from "../types/github-copilot.js";
-/**
- * Parses GitHub reset date (YYYY-MM-DD) into a UTC Date
- */
-export declare function parseResetDate(resetDateString: string): Date;
-/**
- * Calculates monthly period duration ending at the reset date
- *
- * Determines the period start by going back one month from the reset
- * date and clamping the day to the last valid day of that previous
- * month. This handles edge cases like Jan 31 → Feb 28/29 where the
- * target month has fewer days than the reset date's day component.
- *
- * Example:
- *   For resetDate = 2025-03-31, calculates duration from 2025-02-28 (clamped)
- *   to 2025-03-31.
- */
-export declare function calculatePeriodDuration(resetDate: Date): number;
-/**
- * Converts GitHub Copilot response to common domain model
- */
-export declare function toServiceUsageData(response: GitHubCopilotUsageResponse): ServiceUsageData;

package/dist/adapters/parse-github-copilot-usage.js

@@ -1,78 +0,0 @@
-const MS_PER_DAY = 24 * 60 * 60 * 1000;
-/**
- * Parses GitHub reset date (YYYY-MM-DD) into a UTC Date
- */
-export function parseResetDate(resetDateString) {
-    const parts = resetDateString.split("-");
-    if (parts.length !== 3) {
-        throw new Error(`Invalid reset date format: ${resetDateString}`);
-    }
-    const [yearString, monthString, dayString] = parts;
-    if (!yearString || !monthString || !dayString) {
-        throw new Error(`Invalid reset date components: ${resetDateString}`);
-    }
-    const year = Number(yearString);
-    const month = Number(monthString);
-    const day = Number(dayString);
-    if (Number.isNaN(year) ||
-        Number.isNaN(month) ||
-        Number.isNaN(day) ||
-        month < 1 ||
-        month > 12 ||
-        day < 1 ||
-        day > 31) {
-        throw new Error(`Invalid reset date components: ${resetDateString}`);
-    }
-    return new Date(Date.UTC(year, month - 1, day, 0, 0, 0));
-}
-/**
- * Calculates monthly period duration ending at the reset date
- *
- * Determines the period start by going back one month from the reset
- * date and clamping the day to the last valid day of that previous
- * month. This handles edge cases like Jan 31 → Feb 28/29 where the
- * target month has fewer days than the reset date's day component.
- *
- * Example:
- *   For resetDate = 2025-03-31, calculates duration from 2025-02-28 (clamped)
- *   to 2025-03-31.
- */
-export function calculatePeriodDuration(resetDate) {
-    const periodEnd = resetDate.getTime();
-    // Determine previous month and clamp day to its last day
-    const year = resetDate.getUTCFullYear();
-    const month = resetDate.getUTCMonth(); // 0-based
-    const day = resetDate.getUTCDate();
-    // First day of current month in UTC
-    const firstOfCurrentMonth = Date.UTC(year, month, 1, 0, 0, 0);
-    // Last day of previous month: subtract 1 day from first of current month
-    const lastPreviousMonthDate = new Date(firstOfCurrentMonth - MS_PER_DAY);
-    const lastPreviousMonthDay = lastPreviousMonthDate.getUTCDate();
-    const previousMonth = lastPreviousMonthDate.getUTCMonth();
-    const previousYear = lastPreviousMonthDate.getUTCFullYear();
-    const targetDay = Math.min(day, lastPreviousMonthDay);
-    const periodStart = Date.UTC(previousYear, previousMonth, targetDay, 0, 0, 0);
-    return Math.max(periodEnd - periodStart, 0);
-}
-/**
- * Converts GitHub Copilot response to common domain model
- */
-export function toServiceUsageData(response) {
-    const resetDate = parseResetDate(response.quotas.resetDate);
-    const periodDurationMs = calculatePeriodDuration(resetDate);
-    const used = response.quotas.limits.premiumInteractions -
-        response.quotas.remaining.premiumInteractions;
-    const utilization = (used / response.quotas.limits.premiumInteractions) * 100;
-    return {
-        service: "GitHub Copilot",
-        planType: response.plan,
-        windows: [
-            {
-                name: "Monthly Premium Interactions",
-                utilization: Math.round(utilization * 100) / 100,
-                resetsAt: resetDate,
-                periodDurationMs,
-            },
-        ],
-    };
-}

package/dist/commands/auth-clear-command.d.ts

@@ -1,7 +0,0 @@
-type AuthClearOptions = {
-    readonly service?: string;
-    readonly interactive?: boolean;
-    readonly force?: boolean;
-};
-export declare function authClearCommand(options: AuthClearOptions): Promise<void>;
-export {};