muonroi-cli 1.7.2 → 1.8.1

package/dist/src/product-loop/__tests__/discovery-interview.test.js

@@ -2,7 +2,7 @@
 import { promises as fs } from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
-import { beforeEach, describe, expect, it, vi } from "vitest";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import { iterateInterview } from "../discovery-interview.js";
 import { initDiscoveryState, readDiscoveryState } from "../discovery-persistence.js";
 async function mktmp() {
@@ -66,13 +66,25 @@ function makeRecommender(answers) {
 describe("discovery-interview", () => {
     let flowDir;
     const runId = "iv-run";
+    let prevAutofill;
     beforeEach(async () => {
+        // These tests exercise the per-question CARD flow (skip budget, FE-policy
+        // retry, leader/council dispatch). Disable G2-b auto-fill so the cards
+        // actually surface; the auto-fill path has its own test below.
+        prevAutofill = process.env.MUONROI_DISCOVERY_AUTOFILL;
+        process.env.MUONROI_DISCOVERY_AUTOFILL = "0";
         flowDir = await mktmp();
         await initDiscoveryState(flowDir, runId, {
             classification: "greenfield",
             prefillSource: { fromDetection: [], fromPrompt: [] },
         });
     });
+    afterEach(() => {
+        if (prevAutofill === undefined)
+            delete process.env.MUONROI_DISCOVERY_AUTOFILL;
+        else
+            process.env.MUONROI_DISCOVERY_AUTOFILL = prevAutofill;
+    });
     it("iterates all 10 questions with leader/council dispatch", async () => {
         const answers = {
             productType: "saas",
@@ -288,5 +300,95 @@ describe("discovery-interview", () => {
         const state = await readDiscoveryState(flowDir, runId);
         expect((state?.answers.frontendApproach).library).toBe("shadcn");
     });
+    // G2-b: a minimal/well-specified prompt auto-accepts the recommender primary
+    // for required questions — NO per-question cards — and surfaces ONE summary
+    // gate listing the assumptions (verified live: /ideal previously showed
+    // productType/targetPlatform/audience as 3 separate cards).
+    it("auto-fills required questions and surfaces ONE summary gate (minimal prompt)", async () => {
+        delete process.env.MUONROI_DISCOVERY_AUTOFILL; // auto-fill ON (default)
+        const answers = {
+            productType: "saas",
+            targetPlatform: ["cli"],
+            audience: { persona: "devs", scale: "1k-100k", geography: "SEA" },
+            backendArchitecture: "monolith",
+            backendStack: { language: "TS", framework: "Nest" },
+            dbStrategy: { mode: "greenfield", engine: "PG" },
+        };
+        const rec = makeRecommender(answers);
+        const promptedIds = [];
+        let gateAssumptions;
+        const userPrompt = async (args) => {
+            promptedIds.push(args.questionId);
+            if (args.questionId === "__user_gate__") {
+                gateAssumptions = args.assumptions;
+                return { action: "proceed" };
+            }
+            return { action: "accept" };
+        };
+        await iterateInterview({
+            flowDir,
+            runId,
+            idea: "build a small cli todo app",
+            capUsd: 50,
+            detection: FAKE_DETECTION,
+            userPrompt,
+            recommender: rec,
+        });
+        // No per-question card was shown — only the single summary gate.
+        expect(promptedIds.filter((id) => id !== "__user_gate__")).toEqual([]);
+        expect(promptedIds).toContain("__user_gate__");
+        // The gate carried the assumed required answers for one-shot review.
+        expect(gateAssumptions?.map((a) => a.id)).toEqual(expect.arrayContaining(["productType", "targetPlatform", "audience", "backendStack", "dbStrategy"]));
+        const state = await readDiscoveryState(flowDir, runId);
+        expect(state?.answers.productType).toBe("saas");
+        expect(state?.userGatePassed).toBe(true);
+    });
+    // G1 follow-up: from the summary gate the user can revise ONE auto-filled
+    // assumption in place (instead of abort+reprompt or AUTOFILL=0). The interview
+    // re-asks just that field, persists the new value, and re-shows the gate.
+    it("edit-field at the gate re-asks one assumption, saves the new value, then re-shows the gate", async () => {
+        delete process.env.MUONROI_DISCOVERY_AUTOFILL; // auto-fill ON
+        const answers = {
+            productType: "saas",
+            targetPlatform: ["cli"],
+            audience: { persona: "devs", scale: "1k-100k", geography: "SEA" },
+            backendArchitecture: "monolith",
+            backendStack: { language: "TS", framework: "Nest" },
+            dbStrategy: { mode: "greenfield", engine: "PG" },
+        };
+        const rec = makeRecommender(answers);
+        const gatesSeen = [];
+        let productTypeEditAsks = 0;
+        const userPrompt = async (args) => {
+            if (args.questionId === "__user_gate__") {
+                gatesSeen.push(args.assumptions);
+                // First gate → edit productType; after the edit, second gate → proceed.
+                return gatesSeen.length === 1 ? { action: "edit-field", fieldId: "productType" } : { action: "proceed" };
+            }
+            if (args.questionId === "productType" && !args.message) {
+                productTypeEditAsks += 1;
+                return { action: "override", value: "internal-tool", reason: "revised at gate" };
+            }
+            return { action: "accept" };
+        };
+        await iterateInterview({
+            flowDir,
+            runId,
+            idea: "build a small cli todo app",
+            capUsd: 50,
+            detection: FAKE_DETECTION,
+            userPrompt,
+            recommender: rec,
+        });
+        // Gate shown twice (edit, then proceed); productType re-asked exactly once.
+        expect(gatesSeen.length).toBe(2);
+        expect(productTypeEditAsks).toBe(1);
+        // The edited value is persisted (NOT the auto-filled "saas").
+        const state = await readDiscoveryState(flowDir, runId);
+        expect(state?.answers.productType).toBe("internal-tool");
+        expect(state?.userGatePassed).toBe(true);
+        // The re-shown gate reflects the edit in its assumption summary.
+        expect(gatesSeen[1]?.find((a) => a.id === "productType")?.value).toBe("internal-tool");
+    });
 });
 //# sourceMappingURL=discovery-interview.test.js.map

package/dist/src/product-loop/__tests__/gather-selectable-alts.test.js

@@ -106,4 +106,38 @@ describe("buildGatherUserPrompt — selectable alternatives", () => {
         expect(await prompt2({ questionId: "x", recommendation: makeRec() })).toEqual({ action: "skip" });
     });
 });
+describe("buildGatherUserPrompt — user-gate per-field edit (G1 follow-up)", () => {
+    const assumptions = [
+        { id: "productType", value: "internal-tool" },
+        { id: "targetPlatform", value: ["cli"] },
+    ];
+    it("offers proceed + one edit:<id> per assumption + ask-more + abort", async () => {
+        let captured;
+        const tuiAsk = vi.fn(async (_label, options) => {
+            captured = options;
+            return "proceed";
+        });
+        await buildGatherUserPrompt(tuiAsk)({ questionId: "__user_gate__", assumptions });
+        expect(captured).toEqual(["proceed", "edit: productType", "edit: targetPlatform", "ask-more", "abort"]);
+    });
+    it('selecting "edit: targetPlatform" returns {action:"edit-field", fieldId}', async () => {
+        const tuiAsk = vi.fn(async () => "edit: targetPlatform");
+        const result = await buildGatherUserPrompt(tuiAsk)({ questionId: "__user_gate__", assumptions });
+        expect(result).toEqual({ action: "edit-field", fieldId: "targetPlatform" });
+    });
+    it("no assumptions → no edit options (proceed/ask-more/abort only)", async () => {
+        let captured;
+        const tuiAsk = vi.fn(async (_label, options) => {
+            captured = options;
+            return "ask-more";
+        });
+        await buildGatherUserPrompt(tuiAsk)({ questionId: "__user_gate__" });
+        expect(captured).toEqual(["proceed", "ask-more", "abort"]);
+    });
+    it("proceed / abort / ask-more still map correctly with assumptions present", async () => {
+        expect(await buildGatherUserPrompt(vi.fn(async () => "proceed"))({ questionId: "__user_gate__", assumptions })).toEqual({ action: "proceed" });
+        expect(await buildGatherUserPrompt(vi.fn(async () => "abort"))({ questionId: "__user_gate__", assumptions })).toEqual({ action: "abort" });
+        expect(await buildGatherUserPrompt(vi.fn(async () => "ask-more"))({ questionId: "__user_gate__", assumptions })).toEqual({ action: "ask-more" });
+    });
+});
 //# sourceMappingURL=gather-selectable-alts.test.js.map

package/dist/src/product-loop/__tests__/sprint-self-verify.test.js

@@ -8,22 +8,22 @@
 import { describe, expect, it } from "vitest";
 import { runSprintSelfVerify } from "../sprint-self-verify.js";
 describe("runSprintSelfVerify", () => {
-    const ORIG_CI = process.env["CI"];
-    const ORIG_NODE_ENV = process.env["NODE_ENV"];
+    const ORIG_CI = process.env.CI;
+    const ORIG_NODE_ENV = process.env.NODE_ENV;
     function clearEnv() {
-        delete process.env["MUONROI_SPRINT_SELF_VERIFY"];
-        delete process.env["CI"];
-        delete process.env["NODE_ENV"];
+        delete process.env.MUONROI_SPRINT_SELF_VERIFY;
+        delete process.env.CI;
+        delete process.env.NODE_ENV;
     }
     function restoreEnv() {
         if (ORIG_CI === undefined)
-            delete process.env["CI"];
+            delete process.env.CI;
         else
-            process.env["CI"] = ORIG_CI;
+            process.env.CI = ORIG_CI;
         if (ORIG_NODE_ENV === undefined)
-            delete process.env["NODE_ENV"];
+            delete process.env.NODE_ENV;
         else
-            process.env["NODE_ENV"] = ORIG_NODE_ENV;
+            process.env.NODE_ENV = ORIG_NODE_ENV;
     }
     it("default ON when no env flag set — fires past the gate", async () => {
         clearEnv();
@@ -34,7 +34,7 @@ describe("runSprintSelfVerify", () => {
     });
     it("returns skipReason='disabled' when MUONROI_SPRINT_SELF_VERIFY=0", async () => {
         clearEnv();
-        process.env["MUONROI_SPRINT_SELF_VERIFY"] = "0";
+        process.env.MUONROI_SPRINT_SELF_VERIFY = "0";
         const r = await runSprintSelfVerify({ repoRoot: process.cwd() });
         expect(r.ran).toBe(false);
         expect(r.skipReason).toBe("disabled");
@@ -42,7 +42,7 @@ describe("runSprintSelfVerify", () => {
     });
     it("returns skipReason='disabled' when CI=true", async () => {
         clearEnv();
-        process.env["CI"] = "true";
+        process.env.CI = "true";
         const r = await runSprintSelfVerify({ repoRoot: process.cwd() });
         expect(r.ran).toBe(false);
         expect(r.skipReason).toBe("disabled");
@@ -60,7 +60,7 @@ describe("runSprintSelfVerify", () => {
     });
     it("forceEnable overrides CI=true", async () => {
         clearEnv();
-        process.env["CI"] = "true";
+        process.env.CI = "true";
         const r = await runSprintSelfVerify({
             repoRoot: process.cwd(),
             baseRef: "HEAD",

package/dist/src/product-loop/discovery-interview.d.ts

@@ -14,6 +14,16 @@ export type UserPromptResult = {
     action: "proceed";
 } | {
     action: "ask-more";
+}
+/**
+ * G1 follow-up: from the `__user_gate__` summary card the user picked one
+ * auto-filled assumption to revise. The interview re-asks that single field
+ * (reusing the per-question card) and re-shows the gate — instead of forcing
+ * an abort-and-reprompt or MUONROI_DISCOVERY_AUTOFILL=0 to change one value.
+ */
+ | {
+    action: "edit-field";
+    fieldId: string;
 } | {
     action: "abort";
 };
@@ -22,6 +32,16 @@ export interface UserPromptArgs {
     recommendation?: RecommendOutput;
     prefilled?: any;
     message?: string;
+    /**
+     * G2-b: when the interview auto-filled required questions from the
+     * recommender (minimal/well-specified prompt), the `__user_gate__` card
+     * carries the assumed answers so it can render ONE summary ("I assumed X/Y/Z
+     * — proceed or adjust?") instead of N sequential per-question cards.
+     */
+    assumptions?: Array<{
+        id: string;
+        value: any;
+    }>;
 }
 export type UserPromptFn = (args: UserPromptArgs) => Promise<UserPromptResult>;
 export interface RecommenderLike {

package/dist/src/product-loop/discovery-interview.js

@@ -21,6 +21,21 @@ export async function iterateInterview(opts) {
     // not web) are deferred unless the user explicitly re-runs with more context.
     const specificity = computePromptSpecificity(opts.idea);
     const skipOptionalForMinimal = specificity === "minimal";
+    // G2-b: for a minimal OR well-specified ("detailed") prompt the recommender's
+    // primary is high-confidence — minimal picks smallest-scope defaults, detailed
+    // respects the stated context. In both cases surfacing a card for EVERY
+    // required question (productType/targetPlatform/audience/…) is over-asking the
+    // user already complained about: they accept by reflex. Instead auto-accept
+    // the recommender primary for required questions and surface ONE summary card
+    // (the user gate) listing the assumptions so the user can proceed or adjust.
+    // "moderate" prompts keep the per-question cards (genuinely ambiguous). Escape
+    // hatch: MUONROI_DISCOVERY_AUTOFILL=0 restores per-question cards everywhere.
+    const autoFillRequired = (specificity === "minimal" || specificity === "detailed") && process.env.MUONROI_DISCOVERY_AUTOFILL !== "0";
+    const assumed = [];
+    // G1 follow-up: keep the recommendation behind each auto-filled assumption so
+    // the user-gate "edit: <field>" path can re-render the SAME per-question card
+    // (Recommended + alternatives) without a second recommender LLM call.
+    const assumedRec = new Map();
     // Build the repo brief ONCE per interview run for existing projects. The
     // brief replaces the Muonroi vendor preamble inside leader prompts so
     // rationales must cite real files, deps, and scripts. Skipped for greenfield —
@@ -74,12 +89,33 @@ export async function iterateInterview(opts) {
         else {
             recommendation = await opts.recommender.leaderRecommend(recInput);
         }
+        // G2-b: auto-accept the recommender primary for required questions on a
+        // minimal/well-specified prompt — no per-question card. Validated (+ FE
+        // policy) so a malformed recommendation falls back to the normal card flow.
+        // The assumed answers are surfaced together on the single user-gate card.
+        let autoAccepted = false;
+        if (autoFillRequired && effectivelyRequired && recommendation.primary?.value != null) {
+            const v = recommendation.primary.value;
+            const validation = validateAnswer(question.id, v);
+            const feLib = question.id === "frontendApproach" ? v?.library : undefined;
+            const fePolicyOk = !feLib || isFePolicyAccepted(feLib);
+            if (validation.ok && fePolicyOk) {
+                await recordRecommendation(flowDir, runId, question.id, toEntry(recommendation), recommendation.costUsd);
+                await saveDiscoveryAnswer(flowDir, runId, question.id, v);
+                assumed.push({ id: question.id, value: v });
+                assumedRec.set(question.id, recommendation);
+                autoAccepted = true;
+                // Fall through to the post-answer user-gate check below (skip the card).
+            }
+        }
         // Per-question skip-attempt counter for required questions.
         // Resets when the user provides a real answer (accept/override).
         let skipAttempts = 0;
         const MAX_SKIP_ATTEMPTS = 3;
         const _debugInterview = process.env.MUONROI_DEBUG_LEADER === "1";
-        for (;;) {
+        // When auto-accepted above, the card loop body is skipped entirely (the
+        // for-condition is false on entry) and we go straight to the gate check.
+        for (; !autoAccepted;) {
             const _iterStart = Date.now();
             if (_debugInterview) {
                 process.stderr.write(`[interview-timing] iter-start: ${JSON.stringify({ questionId: question.id, skipAttempts })}\n`);
@@ -176,14 +212,32 @@ export async function iterateInterview(opts) {
         if (refreshed &&
             allRequiredAnswered(refreshed.questionsAnswered, refreshedPlatforms) &&
             !refreshed.userGatePassed) {
-            const gate = await opts.userPrompt({ questionId: "__user_gate__" });
-            if (gate.action === "proceed") {
-                await markUserGatePassed(flowDir, runId);
+            // Gate loop: "proceed" exits the whole interview, "abort" throws,
+            // "edit-field" re-asks one assumed answer then RE-shows the gate (so the
+            // user can revise several before proceeding), "ask-more" falls through to
+            // keep iterating optional questions.
+            let proceeded = false;
+            for (;;) {
+                const gate = await opts.userPrompt({
+                    questionId: "__user_gate__",
+                    assumptions: assumed.length > 0 ? assumed : undefined,
+                });
+                if (gate.action === "proceed") {
+                    await markUserGatePassed(flowDir, runId);
+                    proceeded = true;
+                    break;
+                }
+                if (gate.action === "abort")
+                    throw new Error("discovery aborted at user gate");
+                if (gate.action === "edit-field") {
+                    await reAskAssumedField(opts, flowDir, runId, gate.fieldId, assumed, assumedRec.get(gate.fieldId));
+                    continue; // re-render the gate with the updated assumption
+                }
+                // ask-more: stop gating, continue iterating optional questions
                 break;
             }
-            if (gate.action === "abort")
-                throw new Error("discovery aborted at user gate");
-            // ask-more: continue iterating optional questions
+            if (proceeded)
+                break;
         }
     }
     const finalState = await readDiscoveryState(flowDir, runId);
@@ -197,6 +251,66 @@ export async function iterateInterview(opts) {
     await markDone(flowDir, runId);
     return ctx;
 }
+/**
+ * G1 follow-up: re-ask ONE auto-filled assumption from the user gate. Renders
+ * the same per-question card (Recommended + alternatives) as the normal flow by
+ * reusing the stored recommendation, validates (+ FE policy), persists the new
+ * answer, and updates the in-memory `assumed` list so the re-rendered gate shows
+ * the revised value. "skip" cancels the edit (keeps the current assumption);
+ * "abort" aborts the whole interview, consistent with the per-question card.
+ */
+async function reAskAssumedField(opts, flowDir, runId, fieldId, assumed, recommendation) {
+    const question = DISCOVERY_QUESTIONS.find((q) => q.id === fieldId);
+    if (!question)
+        return; // unknown field id — ignore defensively, keep current value
+    for (;;) {
+        const ans = await opts.userPrompt({ questionId: fieldId, recommendation });
+        if (ans.action === "abort")
+            throw new Error("discovery aborted by user");
+        let chosenValue;
+        if (ans.action === "accept") {
+            if (recommendation?.primary?.value == null)
+                continue; // nothing to accept — re-prompt
+            chosenValue = recommendation.primary.value;
+        }
+        else if (ans.action === "override") {
+            chosenValue = ans.value;
+        }
+        else if (ans.action === "skip") {
+            return; // user backed out of editing this field — keep the existing assumption
+        }
+        else {
+            continue; // more-options / edit-field / proceed / ask-more are no-ops here
+        }
+        const validation = validateAnswer(fieldId, chosenValue);
+        if (!validation.ok) {
+            if (fieldId !== "frontendApproach") {
+                await opts.userPrompt({ questionId: fieldId, message: validation.reason ?? "invalid answer" });
+            }
+            continue;
+        }
+        if (fieldId === "frontendApproach") {
+            const lib = chosenValue?.library;
+            if (lib && !isFePolicyAccepted(lib)) {
+                await opts.userPrompt({
+                    questionId: fieldId,
+                    message: "FE policy: library must be shadcn, radix, headlessui, or none",
+                });
+                continue;
+            }
+        }
+        if (ans.action === "override" && recommendation) {
+            await appendUserOverride(flowDir, runId, fieldId, recommendation.primary.value, chosenValue, ans.reason);
+        }
+        await saveDiscoveryAnswer(flowDir, runId, fieldId, chosenValue);
+        const entry = assumed.find((a) => a.id === fieldId);
+        if (entry)
+            entry.value = chosenValue;
+        else
+            assumed.push({ id: fieldId, value: chosenValue });
+        return;
+    }
+}
 function allRequiredAnswered(answered, platforms) {
     const baseRequired = REQUIRED_QUESTION_IDS.every((id) => answered.includes(id));
     if (!baseRequired)

package/dist/src/product-loop/gather.js

@@ -93,15 +93,29 @@ function buildLiveTuiAsk(emit, respondToQuestion) {
 export function buildGatherUserPrompt(tuiAsk) {
     return async (args) => {
         if (args.questionId === "__user_gate__") {
-            const choice = await tuiAsk("All required questions answered. Proceed to research or ask more?", [
-                "proceed",
-                "ask-more",
-                "abort",
-            ]);
+            // G2-b: when required answers were auto-filled from the recommender
+            // (minimal/well-specified prompt), this single card IS the summary — list
+            // the assumptions so the user reviews them in one place instead of N
+            // sequential per-question cards. "ask-more" lets them revisit/expand.
+            const hasAssumptions = !!args.assumptions && args.assumptions.length > 0;
+            const label = hasAssumptions
+                ? `Assumed from your prompt:\n${args
+                    .assumptions.map((a) => `  • ${a.id} = ${JSON.stringify(a.value)}`)
+                    .join("\n")}\n\nProceed, edit one of the assumptions, or ask more to adjust/expand?`
+                : "All required questions answered. Proceed to research or ask more?";
+            // G1 follow-up: one "edit: <field>" option per auto-filled assumption so a
+            // single wrong default can be revised in place — no abort+reprompt or
+            // MUONROI_DISCOVERY_AUTOFILL=0. The prefix must match the parse below.
+            const EDIT_PREFIX = "edit: ";
+            const editOpts = hasAssumptions ? args.assumptions.map((a) => `${EDIT_PREFIX}${a.id}`) : [];
+            const choice = await tuiAsk(label, ["proceed", ...editOpts, "ask-more", "abort"]);
             if (choice === "proceed")
                 return { action: "proceed" };
             if (choice === "abort")
                 return { action: "abort" };
+            if (choice.startsWith(EDIT_PREFIX)) {
+                return { action: "edit-field", fieldId: choice.slice(EDIT_PREFIX.length) };
+            }
             return { action: "ask-more" };
         }
         if (args.message) {

package/dist/src/product-loop/loop-driver.js

@@ -39,10 +39,10 @@ function wrapLLMForUsageTracking(llm, ctx) {
         }
     };
     return {
-        generate: (modelId, system, prompt, maxTokens, onUsage) => llm.generate(modelId, system, prompt, maxTokens, (u) => {
+        generate: (modelId, system, prompt, maxTokens, onUsage, signal) => llm.generate(modelId, system, prompt, maxTokens, (u) => {
             recorder(modelId)(u);
             onUsage?.(u);
-        }),
+        }, signal),
         debate: (modelId, system, prompt, signal, persistTrace, options, onUsage) => llm.debate(modelId, system, prompt, signal, persistTrace, options, (u) => {
             recorder(modelId)(u);
             onUsage?.(u);

package/dist/src/product-loop/sprint-self-verify.js

@@ -31,10 +31,10 @@ const WATCH_DIRS = ["src/ui/", "src/self-qa/", "src/agent-harness/", "packages/a
 function isEnabled(forceEnable) {
     if (forceEnable === true)
         return true;
-    const v = process.env["MUONROI_SPRINT_SELF_VERIFY"];
+    const v = process.env.MUONROI_SPRINT_SELF_VERIFY;
     if (v === "0" || (v && v.toLowerCase() === "false"))
         return false;
-    if (process.env["CI"] === "true" || process.env["NODE_ENV"] === "ci")
+    if (process.env.CI === "true" || process.env.NODE_ENV === "ci")
         return false;
     // Default: ON. v === "1"/"true" still works; absence of env var also enables.
     return true;

package/dist/src/providers/__tests__/reasoning-roundtrip.test.js

@@ -179,6 +179,18 @@ describe("transformThinkingModeBody — backfill / disable (code 20015 fix)", ()
         expect(asst[0].reasoning_content).toBe("real thought"); // untouched
         expect(asst[1].reasoning_content).toBe(""); // backfilled
     });
+    it("A (default): backfills content: '' on a reasoning-only turn that lacks content and tool_calls", () => {
+        const body = {
+            messages: [
+                { role: "user", content: "go" },
+                { role: "assistant", content: null, reasoning_content: "only thought" },
+            ],
+        };
+        const out = transformThinkingModeBody(body);
+        const asst = out.messages.find((m) => m.role === "assistant");
+        expect(asst.reasoning_content).toBe("only thought");
+        expect(asst.content).toBe("");
+    });
     it("A (default): does not touch non-assistant messages", () => {
         const body = {
             messages: [

package/dist/src/providers/auth/__tests__/gemini-oauth.test.d.ts

@@ -1,8 +1,4 @@
 /**
- * Tests for src/providers/auth/gemini-oauth.ts
- *
- * Login flow (callback server mocked), refresh (expiry pre-emption + mutex),
- * revoke, authHeaders, loadGeminiTokensWithRefresh.
- * No live network calls — all HTTP via mockFetch, no real browser opens.
+ * Tests for Agy Google OAuth (replaces legacy gemini public client)
  */
 export {};

package/dist/src/providers/auth/__tests__/gemini-oauth.test.js

@@ -1,9 +1,5 @@
 /**
- * Tests for src/providers/auth/gemini-oauth.ts
- *
- * Login flow (callback server mocked), refresh (expiry pre-emption + mutex),
- * revoke, authHeaders, loadGeminiTokensWithRefresh.
- * No live network calls — all HTTP via mockFetch, no real browser opens.
+ * Tests for Agy Google OAuth (replaces legacy gemini public client)
  */
 import { describe, expect, it, vi } from "vitest";
 import { GeminiOAuthProvider, loadGeminiTokensWithRefresh } from "../gemini-oauth.js";

package/dist/src/providers/auth/gcloud.d.ts

@@ -0,0 +1,28 @@
+/**
+ * src/providers/auth/gcloud.ts
+ *
+ * Reads and refreshes tokens from Google Cloud SDK credentials
+ * (~/.config/gcloud/application_default_credentials.json).
+ *
+ * The gcloud ADC token uses GCP's official OAuth client with cloud-platform
+ * scopes, which IS accepted by generativelanguage.googleapis.com (unlike the
+ * Agy OAuth token whose scope is restricted to cloudcode-pa).
+ *
+ * Usage:
+ *   1. User runs `gcloud auth application-default login` once.
+ *   2. This file reads the resulting credentials file, extracts the token,
+ *      and returns it as an OAuthTokens-compatible object.
+ *   3. The token auto-refreshes when expired (using the refresh_token inside
+ *      the credentials file).
+ */
+import type { OAuthTokens } from "./types.js";
+/**
+ * Try to load a token from gcloud ADC.
+ * Returns null if gcloud is not installed or no credentials exist.
+ */
+export declare function loadGcloudToken(): Promise<OAuthTokens | null>;
+/**
+ * Obtain auth headers from a gcloud-derived OAuthTokens.
+ * Compatible with ProviderOAuth.authHeaders() signature.
+ */
+export declare function gcloudAuthHeaders(tokens: OAuthTokens): Record<string, string>;