@redstone-md/mapr 0.0.4-alpha → 0.0.6-alpha

package/README.md

@@ -10,6 +10,7 @@ This repository is public for source visibility and collaboration. The license r
 
 - Bun-only CLI/TUI with interactive setup through `@clack/prompts`
 - OpenAI and OpenAI-compatible provider support
+- OpenAI Codex family support with fast/reasoning selection
 - Built-in provider presets for BlackBox AI, Nvidia NIM, and OnlySQ
 - Model discovery with searchable selection
 - Automatic context-window detection from provider model metadata when available
@@ -77,6 +78,14 @@ npx @redstone-md/mapr --help
 - `onlysq` -> `https://api.onlysq.ru/ai/openai`
 - `custom` -> any other OpenAI-compatible endpoint
 
+## OpenAI Auth Modes
+
+- `API key` uses the standard OpenAI API at `https://api.openai.com/v1`
+- `Use existing Codex CLI auth` reuses the local `codex login` browser session from `~/.codex/auth.json`
+- Codex CLI auth automatically switches OpenAI requests to `https://chatgpt.com/backend-api/codex`
+- When the local Codex access token expires, Mapr refreshes it through the official OpenAI refresh-token flow before retrying the request
+- If Codex CLI auth is missing, run `codex login` first and then re-run Mapr
+
 ## Usage
 
 Interactive:
@@ -105,6 +114,17 @@ List models with detected context sizes when available:
 npx @redstone-md/mapr --list-models --headless --provider-preset nvidia-nim --api-key secret
 ```
 
+List models through an existing Codex CLI login:
+
+```bash
+npx @redstone-md/mapr \
+  --headless \
+  --list-models \
+  --provider-type openai \
+  --auth-method codex-cli \
+  --codex-home ~/.codex
+```
+
 Useful flags:
 
 - `--max-pages <n>` limits same-origin HTML pages

package/index.ts

@@ -1,6 +1,6 @@
 #!/usr/bin/env bun
 
-import { cancel, confirm, intro, isCancel, log, outro, spinner, text } from "@clack/prompts";
+import { cancel, confirm, intro, isCancel, log, outro, select, spinner, text } from "@clack/prompts";
 import pc from "picocolors";
 import packageJson from "./package.json";
 
@@ -9,11 +9,15 @@ import { AiBundleAnalyzer, chunkTextByBytes, deriveChunkSizeBytes } from "./lib/
 import { getConfigOverrides, parseCliArgs, renderHelpText } from "./lib/cli-args";
 import { ConfigManager } from "./lib/config";
 import { BundleFormatter } from "./lib/formatter";
-import { renderProgressBar } from "./lib/progress";
+import { renderAdaptiveAnalysisProgressLine, renderProgressBar } from "./lib/progress";
+import { findKnownModelInfo, isCodexModel } from "./lib/provider";
 import { ReportWriter } from "./lib/reporter";
 import { BundleScraper } from "./lib/scraper";
 import { SWARM_AGENT_ORDER } from "./lib/swarm-prompts";
 
+process.env.AI_SDK_LOG_WARNINGS = "false";
+(globalThis as typeof globalThis & { AI_SDK_LOG_WARNINGS?: boolean }).AI_SDK_LOG_WARNINGS = false;
+
 function exitIfCancelled<T>(value: T): T {
   if (isCancel(value)) {
     cancel("Operation cancelled.");
@@ -62,6 +66,30 @@ async function resolveTargetUrl(headless: boolean, prefilledUrl?: string): Promi
   );
 }
 
+async function resolveAnalysisConcurrency(headless: boolean, prefilledValue: number | undefined, totalChunks: number): Promise<number> {
+  if (prefilledValue !== undefined) {
+    return prefilledValue;
+  }
+
+  if (headless || totalChunks <= 1) {
+    return 1;
+  }
+
+  return Number(
+    exitIfCancelled(
+      await select({
+        message: "Analysis concurrency",
+        initialValue: 2,
+        options: [
+          { value: 1, label: "1 lane", hint: "Most stable" },
+          { value: 2, label: "2 lanes", hint: "Recommended" },
+          { value: 4, label: "4 lanes", hint: "Aggressive" },
+        ],
+      }),
+    ),
+  );
+}
+
 async function run(): Promise<void> {
   const args = parseCliArgs(process.argv.slice(2));
 
@@ -147,21 +175,41 @@ async function run(): Promise<void> {
       sum + chunkTextByBytes(artifact.formattedContent || artifact.content, deriveChunkSizeBytes(config.modelContextSize)).length,
     0,
   );
+  const analysisConcurrency = await resolveAnalysisConcurrency(headless, args.analysisConcurrency, totalChunks);
   const totalAgentTasks = Math.max(1, totalChunks * SWARM_AGENT_ORDER.length);
   let completedAgentTasks = 0;
+  const analysisStartedAt = Date.now();
 
   const analysisStep = spinner({ indicator: "timer" });
-  analysisStep.start(formatAnalysisProgress(0, totalAgentTasks, "Starting swarm analysis"));
+  analysisStep.start(formatAnalysisProgress(0, totalAgentTasks, `Starting swarm analysis (${analysisConcurrency} lane${analysisConcurrency === 1 ? "" : "s"})`));
 
   const analyzer = new AiBundleAnalyzer({
     providerConfig: config,
     localRag: args.localRag,
+    analysisConcurrency,
     onProgress(event) {
       if (event.stage === "agent" && event.state === "completed") {
         completedAgentTasks += 1;
       }
 
-      const progressLine = formatAnalysisProgress(completedAgentTasks, totalAgentTasks, event.message);
+      const progressLine =
+        event.stage === "agent" && event.agent
+          ? renderAdaptiveAnalysisProgressLine({
+              completed: completedAgentTasks,
+              total: totalAgentTasks,
+              elapsedMs: Date.now() - analysisStartedAt,
+              agent: event.agent,
+              state: event.state,
+              artifactUrl: event.artifactUrl,
+              ...(event.chunkIndex !== undefined ? { chunkIndex: event.chunkIndex } : {}),
+              ...(event.chunkCount !== undefined ? { chunkCount: event.chunkCount } : {}),
+              ...(event.estimatedOutputTokens !== undefined
+                ? { estimatedOutputTokens: event.estimatedOutputTokens }
+                : {}),
+              ...(event.outputTokens !== undefined ? { outputTokens: event.outputTokens } : {}),
+              ...(event.tokensPerSecond !== undefined ? { tokensPerSecond: event.tokensPerSecond } : {}),
+            })
+          : formatAnalysisProgress(completedAgentTasks, totalAgentTasks, event.message);
       analysisStep.message(progressLine);
 
       if (args.verboseAgents && event.stage === "agent" && event.state === "completed") {
@@ -218,12 +266,17 @@ async function run(): Promise<void> {
   });
   reportStep.stop(reportStatus === "partial" ? "Partial report written to disk" : "Report written to disk");
 
+  const selectedModelInfo = findKnownModelInfo(config.model);
   const summaryLines = [
     reportStatus === "partial" ? `${pc.yellow("Analysis incomplete.")}` : `${pc.green("Analysis complete.")}`,
     `${pc.bold("Status:")} ${reportStatus === "partial" ? "partial report saved after error" : "complete"}`,
     `${pc.bold("Target:")} ${scrapeResult.pageUrl}`,
     `${pc.bold("Provider:")} ${config.providerName} (${config.model})`,
+    ...(config.authMethod !== undefined ? [`${pc.bold("Auth:")} ${config.authMethod}`] : []),
     `${pc.bold("Context size:")} ${config.modelContextSize.toLocaleString()} tokens`,
+    ...(config.openAiMode !== undefined ? [`${pc.bold("OpenAI mode:")} ${config.openAiMode}`] : []),
+    ...(isCodexModel(config.model) && selectedModelInfo?.usageLimitsNote ? [`${pc.bold("Codex limits:")} ${selectedModelInfo.usageLimitsNote}`] : []),
+    `${pc.bold("Concurrency:")} ${analysisConcurrency}`,
     `${pc.bold("Local RAG:")} ${args.localRag ? "enabled" : "disabled"}`,
     `${pc.bold("Pages:")} ${scrapeResult.htmlPages.length}`,
     `${pc.bold("Artifacts:")} ${formattedArtifacts.length}`,