Full Code of MadAppGang/claudish for AI

gitextract_7tdmfy1z/

├── .github/
│   ├── ISSUE_TRIAGE.md
│   ├── prompts/
│   │   ├── issue-comment-system.md
│   │   └── issue-triage-system.md
│   ├── release.yml
│   └── workflows/
│       ├── claude-code.yml
│       ├── issue-triage.yml
│       ├── release.yml
│       └── smoke-test.yml
├── .gitignore
├── AI_AGENT_GUIDE.md
├── CHANGELOG.md
├── CLAUDE.md
├── README.md
├── apps/
│   ├── .gitignore
│   └── ClaudishProxy/
│       ├── Package.swift
│       └── Sources/
│           ├── ApiKeyManager.swift
│           ├── BridgeManager.swift
│           ├── CertificateManager.swift
│           ├── ClaudishProxyApp.swift
│           ├── ModelProvider.swift
│           ├── Models.swift
│           ├── ProcessManager.swift
│           ├── ProfileManager.swift
│           ├── ProfilePicker.swift
│           ├── ProfilesSettingsView.swift
│           ├── SettingsView.swift
│           ├── StatsDatabase.swift
│           ├── StatsPanel.swift
│           ├── Theme.swift
│           └── UnifiedModelPicker.swift
├── biome.json
├── cliff.toml
├── design-references/
│   └── stats-panel-style.md
├── docs/
│   ├── advanced/
│   │   ├── automation.md
│   │   ├── cost-tracking.md
│   │   ├── environment.md
│   │   └── mtm-to-magmux-migration.md
│   ├── ai-integration/
│   │   └── for-agents.md
│   ├── api-key-architecture.md
│   ├── api-reference.md
│   ├── getting-started/
│   │   └── quick-start.md
│   ├── index.md
│   ├── models/
│   │   ├── choosing-models.md
│   │   └── model-mapping.md
│   ├── settings-reference.md
│   ├── three-layer-architecture.md
│   ├── troubleshooting.md
│   └── usage/
│       ├── interactive-mode.md
│       ├── magmux.md
│       ├── mcp-server.md
│       ├── monitor-mode.md
│       └── single-shot-mode.md
├── experiments/
│   └── tool-replacement-proxy-2026-04/
│       ├── README.md
│       ├── claudish-patch/
│       │   ├── native-handler-advisor.test.ts
│       │   ├── native-handler-advisor.ts
│       │   └── native-handler.patch
│       ├── evidence/
│       │   ├── evidence-index.ndjson
│       │   ├── evidence-req-advisor-enabled.json
│       │   ├── evidence-resp-advisor-enabled.ndjson
│       │   ├── evidence-stage1-swap.ndjson
│       │   ├── evidence-stage2-rewrite.ndjson
│       │   └── evidence-stage2-ui-transcript.txt
│       ├── journal/
│       │   └── 2026-04-10-to-15-investigation.md
│       ├── poc/
│       │   ├── 01-recording-proxy.ts
│       │   ├── 02-mock-advisor-proxy.ts
│       │   ├── 03-sdk-validation.ts
│       │   ├── 04-multi-turn-validation.ts
│       │   ├── 05-tool-loop-proxy.ts
│       │   ├── 06-sdk-e2e-validation.ts
│       │   └── README.md
│       └── research/
│           ├── 01-advisor-pattern-research.md
│           ├── 01-research-plan.md
│           ├── 02-proxy-replacement-architecture.md
│           ├── 03-how-to-enable-advisor.md
│           ├── 04-real-test-results.md
│           ├── 05-stage1-tool-swap.md
│           └── 06-stage2-tool-result-rewrite.md
├── install.sh
├── landingpage/
│   ├── .firebaserc
│   ├── .gitignore
│   ├── App.tsx
│   ├── README.md
│   ├── components/
│   │   ├── BlockLogo.tsx
│   │   ├── BridgeDiagram.tsx
│   │   ├── Changelog.tsx
│   │   ├── FeatureSection.tsx
│   │   ├── HeroSection.tsx
│   │   ├── MultiModelAnimation.tsx
│   │   ├── SmartRouting.tsx
│   │   ├── SubscriptionSection.tsx
│   │   ├── SupportSection.tsx
│   │   ├── TerminalWindow.tsx
│   │   ├── TypingAnimation.tsx
│   │   └── VisionSection.tsx
│   ├── constants.ts
│   ├── firebase.json
│   ├── firebase.ts
│   ├── index.html
│   ├── index.tsx
│   ├── metadata.json
│   ├── package.json
│   ├── pnpm-workspace.yaml
│   ├── public/
│   │   └── site.webmanifest
│   ├── tsconfig.json
│   ├── types.ts
│   └── vite.config.ts
├── package.json
├── packages/
│   ├── .gitignore
│   ├── cli/
│   │   ├── .gitignore
│   │   ├── AI_AGENT_GUIDE.md
│   │   ├── bin/
│   │   │   └── claudish.cjs
│   │   ├── package.json
│   │   ├── recommended-models.json
│   │   ├── scripts/
│   │   │   ├── generate-version.ts
│   │   │   ├── smoke/
│   │   │   │   ├── probes.ts
│   │   │   │   ├── providers.ts
│   │   │   │   ├── reporter.ts
│   │   │   │   └── types.ts
│   │   │   ├── smoke-test.ts
│   │   │   └── smoke.test.ts
│   │   ├── skills/
│   │   │   └── claudish-usage/
│   │   │       └── SKILL.md
│   │   ├── src/
│   │   │   ├── adapters/
│   │   │   │   ├── anthropic-api-format.ts
│   │   │   │   ├── api-format.ts
│   │   │   │   ├── base-api-format.ts
│   │   │   │   ├── codex-api-format.ts
│   │   │   │   ├── deepseek-model-dialect.ts
│   │   │   │   ├── dialect-manager.ts
│   │   │   │   ├── gemini-api-format.ts
│   │   │   │   ├── glm-model-dialect.ts
│   │   │   │   ├── grok-model-dialect.ts
│   │   │   │   ├── index.ts
│   │   │   │   ├── litellm-api-format.ts
│   │   │   │   ├── local-adapter.ts
│   │   │   │   ├── minimax-model-dialect.ts
│   │   │   │   ├── model-catalog.test.ts
│   │   │   │   ├── model-catalog.ts
│   │   │   │   ├── model-dialect.ts
│   │   │   │   ├── ollama-api-format.ts
│   │   │   │   ├── openai-api-format.ts
│   │   │   │   ├── openrouter-api-format.ts
│   │   │   │   ├── qwen-model-dialect.ts
│   │   │   │   ├── tool-name-utils.ts
│   │   │   │   └── xiaomi-model-dialect.ts
│   │   │   ├── auth/
│   │   │   │   ├── auth-commands.ts
│   │   │   │   ├── codex-oauth.ts
│   │   │   │   ├── gemini-oauth.ts
│   │   │   │   ├── kimi-oauth.ts
│   │   │   │   ├── oauth-manager.ts
│   │   │   │   ├── oauth-registry.ts
│   │   │   │   ├── quota-command.ts
│   │   │   │   └── vertex-auth.ts
│   │   │   ├── channel/
│   │   │   │   ├── e2e-channel.test.ts
│   │   │   │   ├── index.ts
│   │   │   │   ├── scrollback-buffer.test.ts
│   │   │   │   ├── scrollback-buffer.ts
│   │   │   │   ├── session-manager.test.ts
│   │   │   │   ├── session-manager.ts
│   │   │   │   ├── signal-watcher.test.ts
│   │   │   │   ├── signal-watcher.ts
│   │   │   │   ├── test-helpers/
│   │   │   │   │   └── fake-claudish.ts
│   │   │   │   └── types.ts
│   │   │   ├── claude-runner.ts
│   │   │   ├── cli-passthrough.test.ts
│   │   │   ├── cli.test.ts
│   │   │   ├── cli.ts
│   │   │   ├── config-command.ts
│   │   │   ├── config-schema.test.ts
│   │   │   ├── config-schema.ts
│   │   │   ├── config.ts
│   │   │   ├── default-provider.test.ts
│   │   │   ├── default-provider.ts
│   │   │   ├── diag-output.ts
│   │   │   ├── format-translation.test.ts
│   │   │   ├── glm-adapter.test.ts
│   │   │   ├── handlers/
│   │   │   │   ├── composed-handler.test.ts
│   │   │   │   ├── composed-handler.ts
│   │   │   │   ├── default-provider-e2e.test.ts
│   │   │   │   ├── fallback-handler.test.ts
│   │   │   │   ├── fallback-handler.ts
│   │   │   │   ├── native-handler-advisor.test.ts
│   │   │   │   ├── native-handler-advisor.ts
│   │   │   │   ├── native-handler.ts
│   │   │   │   ├── shared/
│   │   │   │   │   ├── anthropic-error.test.ts
│   │   │   │   │   ├── anthropic-error.ts
│   │   │   │   │   ├── format/
│   │   │   │   │   │   ├── identity-filter.ts
│   │   │   │   │   │   ├── openai-messages.ts
│   │   │   │   │   │   └── openai-tools.ts
│   │   │   │   │   ├── gemini-queue.ts
│   │   │   │   │   ├── gemini-schema.ts
│   │   │   │   │   ├── local-queue.ts
│   │   │   │   │   ├── openai-compat.ts
│   │   │   │   │   ├── openrouter-queue.ts
│   │   │   │   │   ├── remote-provider-types.ts
│   │   │   │   │   ├── stream-parsers/
│   │   │   │   │   │   ├── anthropic-sse.ts
│   │   │   │   │   │   ├── gemini-sse.ts
│   │   │   │   │   │   ├── index.ts
│   │   │   │   │   │   ├── ollama-jsonl.ts
│   │   │   │   │   │   ├── openai-responses-sse.ts
│   │   │   │   │   │   └── openai-sse.ts
│   │   │   │   │   ├── token-tracker.ts
│   │   │   │   │   ├── tool-call-recovery.ts
│   │   │   │   │   └── web-search-detector.ts
│   │   │   │   └── types.ts
│   │   │   ├── index.ts
│   │   │   ├── logger.ts
│   │   │   ├── mcp-server.ts
│   │   │   ├── middleware/
│   │   │   │   ├── gemini-thought-signature.ts
│   │   │   │   ├── index.ts
│   │   │   │   ├── manager.ts
│   │   │   │   └── types.ts
│   │   │   ├── model-catalog.test.ts
│   │   │   ├── model-loader.ts
│   │   │   ├── model-selector.ts
│   │   │   ├── native-anthropic-mapping.test.ts
│   │   │   ├── port-manager.ts
│   │   │   ├── probe/
│   │   │   │   ├── probe-results-printer.ts
│   │   │   │   ├── probe-tui-app.tsx
│   │   │   │   └── probe-tui-runtime.tsx
│   │   │   ├── profile-commands.ts
│   │   │   ├── profile-config.ts
│   │   │   ├── providers/
│   │   │   │   ├── all-models-cache.test.ts
│   │   │   │   ├── all-models-cache.ts
│   │   │   │   ├── api-key-map.ts
│   │   │   │   ├── api-key-provenance.ts
│   │   │   │   ├── auto-route-default-provider.test.ts
│   │   │   │   ├── auto-route.ts
│   │   │   │   ├── catalog-resolvers/
│   │   │   │   │   ├── litellm.ts
│   │   │   │   │   ├── openrouter.test.ts
│   │   │   │   │   ├── openrouter.ts
│   │   │   │   │   └── static-fallback.ts
│   │   │   │   ├── custom-endpoints-loader.test.ts
│   │   │   │   ├── custom-endpoints-loader.ts
│   │   │   │   ├── index.ts
│   │   │   │   ├── model-catalog-resolver.ts
│   │   │   │   ├── model-parser.ts
│   │   │   │   ├── probe-live.ts
│   │   │   │   ├── provider-definitions.test.ts
│   │   │   │   ├── provider-definitions.ts
│   │   │   │   ├── provider-profiles.ts
│   │   │   │   ├── provider-registry.ts
│   │   │   │   ├── provider-resolver.ts
│   │   │   │   ├── provider-routing.test.ts
│   │   │   │   ├── remote-provider-registry.ts
│   │   │   │   ├── routing-rules.test.ts
│   │   │   │   ├── routing-rules.ts
│   │   │   │   ├── runtime-providers.test.ts
│   │   │   │   ├── runtime-providers.ts
│   │   │   │   └── transport/
│   │   │   │       ├── anthropic-compat.test.ts
│   │   │   │       ├── anthropic-compat.ts
│   │   │   │       ├── gemini-apikey.ts
│   │   │   │       ├── gemini-codeassist.ts
│   │   │   │       ├── litellm.ts
│   │   │   │       ├── local.ts
│   │   │   │       ├── ollamacloud.ts
│   │   │   │       ├── openai-codex.ts
│   │   │   │       ├── openai.test.ts
│   │   │   │       ├── openai.ts
│   │   │   │       ├── openrouter.ts
│   │   │   │       ├── poe.ts
│   │   │   │       ├── types.ts
│   │   │   │       └── vertex-oauth.ts
│   │   │   ├── proxy-server.ts
│   │   │   ├── services/
│   │   │   │   ├── pricing-cache.ts
│   │   │   │   └── vision-proxy.ts
│   │   │   ├── stats-buffer.test.ts
│   │   │   ├── stats-buffer.ts
│   │   │   ├── stats-otlp.test.ts
│   │   │   ├── stats-otlp.ts
│   │   │   ├── stats.test.ts
│   │   │   ├── stats.ts
│   │   │   ├── team-cli.ts
│   │   │   ├── team-grid.e2e-helpers.ts
│   │   │   ├── team-grid.e2e.test.ts
│   │   │   ├── team-grid.ts
│   │   │   ├── team-orchestrator.test.ts
│   │   │   ├── team-orchestrator.ts
│   │   │   ├── team-timeout-repro.test.ts
│   │   │   ├── telemetry.test.ts
│   │   │   ├── telemetry.ts
│   │   │   ├── test-fixtures/
│   │   │   │   ├── extract-sse-from-log.ts
│   │   │   │   └── sse-responses/
│   │   │   │       ├── SEED-anthropic-text-only.sse
│   │   │   │       ├── SEED-anthropic-thinking.sse
│   │   │   │       ├── SEED-openai-text-only.sse
│   │   │   │       ├── SEED-openai-tool-call.sse
│   │   │   │       ├── minimax-m25-turn1-thinking-text-tool.sse
│   │   │   │       ├── minimax-m25-turn2-thinking-tool-only.sse
│   │   │   │       ├── minimax-m25-turn3-thinking-multichunk.sse
│   │   │   │       ├── regression-zai-glm5-instream-error.sse
│   │   │   │       └── regression-zai-glm5-usage.sse
│   │   │   ├── transform.ts
│   │   │   ├── tui/
│   │   │   │   ├── App.tsx
│   │   │   │   ├── index.tsx
│   │   │   │   ├── panels/
│   │   │   │   │   ├── ApiKeysPanel.tsx
│   │   │   │   │   ├── ConfigViewPanel.tsx
│   │   │   │   │   ├── ProfilesPanel.tsx
│   │   │   │   │   ├── ProvidersPanel.tsx
│   │   │   │   │   ├── RoutingPanel.tsx
│   │   │   │   │   ├── StatsPanel.tsx
│   │   │   │   │   └── TelemetryPanel.tsx
│   │   │   │   ├── providers.ts
│   │   │   │   ├── test-provider.ts
│   │   │   │   └── theme.ts
│   │   │   ├── types.ts
│   │   │   ├── update-checker.ts
│   │   │   ├── update-command.ts
│   │   │   ├── utils.ts
│   │   │   ├── version.ts
│   │   │   └── zai-glm.e2e.test.ts
│   │   ├── tsconfig.json
│   │   └── tsconfig.tui.json
│   ├── macos-bridge/
│   │   ├── docs/
│   │   │   └── PROXY_TRAFFIC_FLOW.md
│   │   ├── package.json
│   │   ├── scripts/
│   │   │   ├── full-test.js
│   │   │   ├── simple-test.js
│   │   │   ├── test-claude-desktop.sh
│   │   │   ├── test-cycletls.ts
│   │   │   ├── test-full-interception.sh
│   │   │   └── test-proxy.sh
│   │   ├── src/
│   │   │   ├── auth.ts
│   │   │   ├── bridge.test.ts
│   │   │   ├── certificate-manager.ts
│   │   │   ├── config-manager.ts
│   │   │   ├── connect-handler.ts
│   │   │   ├── cycletls-manager.ts
│   │   │   ├── detection.ts
│   │   │   ├── http-parser.ts
│   │   │   ├── https-proxy-server.ts
│   │   │   ├── index.ts
│   │   │   ├── process-manager.ts
│   │   │   ├── routing-middleware.ts
│   │   │   ├── server.ts
│   │   │   └── types.ts
│   │   └── tsconfig.json
│   ├── magmux-darwin-arm64/
│   │   ├── .gitignore
│   │   ├── bin/
│   │   │   └── .gitkeep
│   │   └── package.json
│   ├── magmux-darwin-x64/
│   │   ├── .gitignore
│   │   ├── bin/
│   │   │   └── .gitkeep
│   │   └── package.json
│   ├── magmux-linux-arm64/
│   │   ├── .gitignore
│   │   ├── bin/
│   │   │   └── .gitkeep
│   │   └── package.json
│   └── magmux-linux-x64/
│       ├── .gitignore
│       ├── bin/
│       │   └── .gitkeep
│       └── package.json
├── recommended-models.json
├── scripts/
│   ├── generate-manifest.ts
│   ├── postinstall.cjs
│   └── update-models.ts
├── skills/
│   └── claudish-usage/
│       └── SKILL.md
├── test-mcp-e2e.ts
└── tsconfig.json

SYMBOL INDEX (1864 symbols across 192 files)

FILE: experiments/tool-replacement-proxy-2026-04/claudish-patch/native-handler-advisor.ts
  constant ADVISOR_SERVER_TOOL_TYPE (line 27) | const ADVISOR_SERVER_TOOL_TYPE = "advisor_20260301";
  constant ADVISOR_BETA_FLAG (line 28) | const ADVISOR_BETA_FLAG = "advisor-tool-2026-03-01";
  type AdvisorSwapConfig (line 30) | interface AdvisorSwapConfig {
  function loadAdvisorSwapConfig (line 37) | function loadAdvisorSwapConfig(): AdvisorSwapConfig {
  type AdvisorInfo (line 45) | interface AdvisorInfo {
  function swapAdvisorToolInBody (line 63) | function swapAdvisorToolInBody(
  function stripAdvisorBeta (line 115) | function stripAdvisorBeta(
  function logAdvisorEvent (line 137) | function logAdvisorEvent(
  function recordAdvisorEventsFromChunk (line 159) | function recordAdvisorEventsFromChunk(
  constant MAX_TRACKED (line 204) | const MAX_TRACKED = 256;
  function extractAdvisorToolUseIds (line 214) | function extractAdvisorToolUseIds(chunkText: string): void {
  function rememberAdvisorToolUseId (line 233) | function rememberAdvisorToolUseId(id: string): void {
  function _debug_getTrackedAdvisorIds (line 244) | function _debug_getTrackedAdvisorIds(): string[] {
  function _debug_resetTrackedAdvisorIds (line 249) | function _debug_resetTrackedAdvisorIds(): void {
  function rewriteAdvisorToolResults (line 262) | function rewriteAdvisorToolResults(
  function stubAdvisorAdvice (line 309) | function stubAdvisorAdvice(toolUseId: string): string {

FILE: experiments/tool-replacement-proxy-2026-04/poc/01-recording-proxy.ts
  constant LOG_DIR (line 25) | const LOG_DIR = join(import.meta.dir, "logs");
  constant UPSTREAM (line 28) | const UPSTREAM = "https://api.anthropic.com";
  constant PORT (line 29) | const PORT = 8787;
  function logIndex (line 36) | function logIndex(entry: Record<string, unknown>) {
  method fetch (line 46) | async fetch(req: Request): Promise<Response> {
  function safeParseJSON (line 214) | function safeParseJSON(s: string): unknown {
  type SSEEvent (line 222) | interface SSEEvent {
  function parseSSE (line 227) | function parseSSE(block: string): SSEEvent | null {

FILE: experiments/tool-replacement-proxy-2026-04/poc/02-mock-advisor-proxy.ts
  constant LOG_DIR (line 25) | const LOG_DIR = join(import.meta.dir, "logs");
  constant PORT (line 27) | const PORT = 8788;
  constant MESSAGE_ID (line 32) | const MESSAGE_ID = "msg_poc_advisor_01";
  constant ADVISOR_ID (line 33) | const ADVISOR_ID = "srvtoolu_poc_advisor_01";
  constant MODEL (line 34) | const MODEL = "claude-sonnet-4-6";
  method fetch (line 53) | async fetch(req: Request): Promise<Response> {
  function buildNonStreamingResponse (line 100) | function buildNonStreamingResponse() {
  function buildStreamingResponse (line 160) | function buildStreamingResponse(): ReadableStream<Uint8Array> {
  function runSelfTest (line 282) | async function runSelfTest() {

FILE: experiments/tool-replacement-proxy-2026-04/poc/03-sdk-validation.ts
  constant BASE_URL (line 20) | const BASE_URL = "http://127.0.0.1:8788";
  function formatBlock (line 105) | function formatBlock(b: any): string {

FILE: experiments/tool-replacement-proxy-2026-04/poc/04-multi-turn-validation.ts
  constant BASE_URL (line 27) | const BASE_URL = "http://127.0.0.1:8788";

FILE: experiments/tool-replacement-proxy-2026-04/poc/05-tool-loop-proxy.ts
  constant EXECUTOR_PORT (line 47) | const EXECUTOR_PORT = 9001;
  constant ADVISOR_PORT (line 48) | const ADVISOR_PORT = 9002;
  constant PROXY_PORT (line 49) | const PROXY_PORT = 8789;
  constant MOCK_THIRD_PARTY_ADVICE (line 51) | const MOCK_THIRD_PARTY_ADVICE =
  function startMockExecutor (line 58) | function startMockExecutor() {
  function startMockAdvisor (line 133) | function startMockAdvisor() {
  constant EXECUTOR_URL (line 163) | const EXECUTOR_URL = `http://127.0.0.1:${EXECUTOR_PORT}`;
  constant ADVISOR_URL (line 164) | const ADVISOR_URL = `http://127.0.0.1:${ADVISOR_PORT}`;
  function extractAdvisorTool (line 170) | function extractAdvisorTool(tools: any[] | undefined): {
  function callThirdPartyAdvisor (line 200) | async function callThirdPartyAdvisor(
  function callExecutor (line 226) | async function callExecutor(requestBody: any): Promise<any> {
  function runToolLoop (line 241) | async function runToolLoop(
  function transformToAdvisorBlocks (line 311) | function transformToAdvisorBlocks(blocks: any[]): any[] {
  function processClientRequest (line 329) | async function processClientRequest(originalBody: any): Promise<any> {
  function startProxy (line 430) | function startProxy() {

FILE: experiments/tool-replacement-proxy-2026-04/poc/06-sdk-e2e-validation.ts
  constant EXECUTOR_PORT (line 55) | const EXECUTOR_PORT = 9101;
  constant ADVISOR_PORT (line 56) | const ADVISOR_PORT = 9102;
  constant PROXY_PORT (line 57) | const PROXY_PORT = 8889;
  constant MOCK_THIRD_PARTY_ADVICE (line 58) | const MOCK_THIRD_PARTY_ADVICE =
  method fetch (line 67) | async fetch(req) {
  method fetch (line 123) | async fetch(req) {
  method fetch (line 146) | async fetch(req) {

FILE: landingpage/components/BlockLogo.tsx
  constant LETTERS (line 4) | const LETTERS: Record<string, number[][]> = {
  constant WORD (line 50) | const WORD = "CLAUD";

FILE: landingpage/components/Changelog.tsx
  type GitHubRelease (line 3) | interface GitHubRelease {
  constant CACHE_KEY (line 13) | const CACHE_KEY = "claudish-releases";
  constant CACHE_TTL (line 14) | const CACHE_TTL = 5 * 60 * 1000;
  function formatRelativeDate (line 16) | function formatRelativeDate(dateStr: string): string {
  constant SECTION_COLORS (line 30) | const SECTION_COLORS: Record<string, string> = {
  function renderInline (line 40) | function renderInline(text: string): React.ReactNode[] {
  function ReleaseBody (line 88) | function ReleaseBody({ body }: { body: string }) {
  function ReleaseSkeleton (line 177) | function ReleaseSkeleton() {

FILE: landingpage/components/FeatureSection.tsx
  constant COMPARISON_ROWS (line 10) | const COMPARISON_ROWS = [

FILE: landingpage/components/SubscriptionSection.tsx
  constant SUBSCRIPTIONS (line 21) | const SUBSCRIPTIONS = [

FILE: landingpage/components/TerminalWindow.tsx
  type TerminalWindowProps (line 3) | interface TerminalWindowProps {

FILE: landingpage/components/TypingAnimation.tsx
  type TypingAnimationProps (line 3) | interface TypingAnimationProps {

FILE: landingpage/constants.ts
  constant HERO_SEQUENCE (line 3) | const HERO_SEQUENCE: TerminalLine[] = [
  constant HIGHLIGHT_FEATURES (line 104) | const HIGHLIGHT_FEATURES: Feature[] = [
  constant STANDARD_FEATURES (line 131) | const STANDARD_FEATURES: Feature[] = [
  constant MARKETING_FEATURES (line 171) | const MARKETING_FEATURES = [...HIGHLIGHT_FEATURES, ...STANDARD_FEATURES];
  constant MODEL_CARDS (line 173) | const MODEL_CARDS: ModelCard[] = [

FILE: landingpage/types.ts
  type TerminalLine (line 1) | interface TerminalLine {
  type Feature (line 21) | interface Feature {
  type ModelCard (line 31) | interface ModelCard {

FILE: packages/cli/bin/claudish.cjs
  function findBun (line 10) | function findBun() {

FILE: packages/cli/scripts/smoke-test.ts
  type CLIFlags (line 36) | interface CLIFlags {
  function parseCLIFlags (line 44) | function parseCLIFlags(): CLIFlags {
  function printDryRun (line 80) | function printDryRun(configs: SmokeProviderConfig[]): void {
  function buildFailedProviderResult (line 103) | function buildFailedProviderResult(config: SmokeProviderConfig, reason: ...
  function runProviderProbes (line 124) | async function runProviderProbes(
  function buildRunId (line 162) | function buildRunId(): string {
  function buildRunResult (line 171) | function buildRunResult(
  function main (line 190) | async function main(): Promise<void> {

FILE: packages/cli/scripts/smoke.test.ts
  function makeProbe (line 16) | function makeProbe(
  function makeProviderResult (line 23) | function makeProviderResult(probeStatuses: ProbeResult["status"][]): Pro...
  function makeConfig (line 110) | function makeConfig(authScheme: SmokeProviderConfig["authScheme"]): Smok...
  function makeVisionConfig (line 355) | function makeVisionConfig(): SmokeProviderConfig {

FILE: packages/cli/scripts/smoke/probes.ts
  constant TEST_IMAGE_BASE64 (line 19) | const TEST_IMAGE_BASE64 =
  constant TEST_IMAGE_MEDIA_TYPE (line 21) | const TEST_IMAGE_MEDIA_TYPE = "image/png";
  constant VISION_ERROR_PHRASES (line 24) | const VISION_ERROR_PHRASES = [
  function isReasoningModel (line 37) | function isReasoningModel(modelId: string): boolean {
  function buildHeaders (line 44) | function buildHeaders(config: SmokeProviderConfig): Record<string, strin...
  function callProvider (line 71) | async function callProvider(
  function runProbe (line 97) | async function runProbe(

FILE: packages/cli/scripts/smoke/providers.ts
  constant SKIP_PROVIDERS (line 14) | const SKIP_PROVIDERS = new Set([
  constant REPRESENTATIVE_MODELS (line 19) | const REPRESENTATIVE_MODELS: Record<string, string> = {
  constant SMOKE_MODEL_CAPABILITIES (line 39) | const SMOKE_MODEL_CAPABILITIES: Record<
  constant ANTHROPIC_COMPAT_PROVIDERS (line 56) | const ANTHROPIC_COMPAT_PROVIDERS = new Set([
  function getWireFormat (line 64) | function getWireFormat(providerName: string): WireFormat {
  function getAuthScheme (line 69) | function getAuthScheme(provider: RemoteProvider): SmokeProviderConfig["a...
  function getVertexToken (line 85) | function getVertexToken(): string | undefined {
  function getApiKey (line 108) | function getApiKey(provider: RemoteProvider): string | undefined {
  function getApiPath (line 126) | function getApiPath(provider: RemoteProvider): string {
  function getBaseUrl (line 142) | function getBaseUrl(provider: RemoteProvider): string {
  function discoverProviders (line 156) | function discoverProviders(filterName?: string): SmokeProviderConfig[] {

FILE: packages/cli/scripts/smoke/reporter.ts
  constant GREEN (line 10) | const GREEN = "\x1b[32m";
  constant RED (line 11) | const RED = "\x1b[31m";
  constant YELLOW (line 12) | const YELLOW = "\x1b[33m";
  constant RESET (line 13) | const RESET = "\x1b[0m";
  constant BOLD (line 14) | const BOLD = "\x1b[1m";
  constant DIM (line 15) | const DIM = "\x1b[2m";
  function color (line 19) | function color(text: string, code: string): string {
  function renderStatus (line 24) | function renderStatus(result: ProbeResult | undefined): string {
  function padEnd (line 38) | function padEnd(str: string, len: number): string {
  function printTable (line 52) | function printTable(results: ProviderResult[], quiet: boolean): void {
  function printSummary (line 103) | function printSummary(run: SmokeRunResult): void {
  function writeJsonResults (line 119) | function writeJsonResults(run: SmokeRunResult, resultsDir?: string): void {
  function buildSummary (line 134) | function buildSummary(results: ProviderResult[]): SmokeRunResult["summar...

FILE: packages/cli/scripts/smoke/types.ts
  type WireFormat (line 6) | type WireFormat = "anthropic-compat" | "openai-compat" | "ollama";
  type Capability (line 9) | type Capability = "tool_calling" | "reasoning" | "vision";
  type ProbeStatus (line 12) | type ProbeStatus = "pass" | "fail" | "skip";
  type ProbeResult (line 14) | interface ProbeResult {
  type ProviderResult (line 24) | interface ProviderResult {
  type SmokeRunResult (line 32) | interface SmokeRunResult {
  type SmokeProviderConfig (line 46) | interface SmokeProviderConfig {
  type ProbeFn (line 63) | type ProbeFn = (config: SmokeProviderConfig, signal: AbortSignal) => Pro...
  type AnthropicResponse (line 66) | interface AnthropicResponse {
  type OllamaResponse (line 77) | interface OllamaResponse {
  type OpenAIResponse (line 95) | interface OpenAIResponse {

FILE: packages/cli/src/adapters/anthropic-api-format.ts
  class AnthropicAPIFormat (line 13) | class AnthropicAPIFormat extends BaseAPIFormat {
    method constructor (line 16) | constructor(modelId: string, providerName: string) {
    method processTextContent (line 21) | processTextContent(textContent: string, _accumulatedText: string): Ada...
    method shouldHandle (line 29) | shouldHandle(modelId: string): boolean {
    method getName (line 33) | getName(): string {
    method convertMessages (line 42) | override convertMessages(claudeRequest: any, _filterFn?: any): any[] {
    method stripUnsupportedContentTypes (line 47) | private stripUnsupportedContentTypes(message: any): any {
    method convertTools (line 71) | override convertTools(claudeRequest: any, _summarize?: boolean): any[] {
    method buildPayload (line 80) | override buildPayload(claudeRequest: any, messages: any[], tools: any[...
    method getStreamFormat (line 113) | override getStreamFormat(): StreamFormat {
    method getContextWindow (line 117) | override getContextWindow(): number {
    method supportsVision (line 129) | override supportsVision(): boolean {

FILE: packages/cli/src/adapters/api-format.ts
  type APIFormat (line 16) | interface APIFormat {

FILE: packages/cli/src/adapters/base-api-format.ts
  function matchesModelFamily (line 28) | function matchesModelFamily(modelId: string, family: string): boolean {
  type ToolCall (line 36) | interface ToolCall {
  type AdapterResult (line 42) | interface AdapterResult {
  method constructor (line 60) | constructor(modelId: string) {
  method getToolNameLimit (line 86) | getToolNameLimit(): number | null {
  method getToolNameMap (line 94) | getToolNameMap(): Map<string, string> {
  method restoreToolName (line 101) | restoreToolName(name: string): string {
  method prepareRequest (line 112) | prepareRequest(request: any, originalRequest: any): any {
  method reset (line 119) | reset(): void {
  method convertMessages (line 132) | convertMessages(claudeRequest: any, filterIdentityFn?: (s: string) => st...
  method convertTools (line 140) | convertTools(claudeRequest: any, summarize = false): any[] {
  method buildPayload (line 149) | buildPayload(claudeRequest: any, messages: any[], tools: any[]): any {
  method getStreamFormat (line 172) | getStreamFormat(): StreamFormat {
  method getContextWindow (line 180) | getContextWindow(): number {
  method getPricing (line 188) | getPricing(providerName: string): ModelPricing {
  method supportsVision (line 195) | supportsVision(): boolean {
  method shouldFilterThinking (line 203) | shouldFilterThinking(): boolean {
  method truncateToolNames (line 213) | protected truncateToolNames(request: any): void {
  method truncateToolNamesInMessages (line 236) | protected truncateToolNamesInMessages(messages: any[]): void {
  class DefaultAPIFormat (line 260) | class DefaultAPIFormat extends BaseAPIFormat {
    method processTextContent (line 261) | processTextContent(textContent: string, accumulatedText: string): Adap...
    method shouldHandle (line 269) | shouldHandle(modelId: string): boolean {
    method getName (line 273) | getName(): string {
  type BaseModelAdapter (line 284) | type BaseModelAdapter = BaseAPIFormat;
  type DefaultAdapter (line 288) | type DefaultAdapter = DefaultAPIFormat;

FILE: packages/cli/src/adapters/codex-api-format.ts
  function normalizeCodexModel (line 28) | function normalizeCodexModel(modelId: string | undefined): string {
  class CodexAPIFormat (line 41) | class CodexAPIFormat extends BaseAPIFormat {
    method constructor (line 42) | constructor(modelId: string) {
    method processTextContent (line 46) | processTextContent(textContent: string, _accumulatedText: string): Ada...
    method shouldHandle (line 54) | shouldHandle(modelId: string): boolean {
    method getName (line 58) | getName(): string {
    method getStreamFormat (line 62) | override getStreamFormat(): StreamFormat {
    method getContextWindow (line 66) | override getContextWindow(): number {
    method buildPayload (line 70) | override buildPayload(claudeRequest: any, messages: any[], tools: any[...
    method convertMessagesToResponsesAPI (line 127) | private convertMessagesToResponsesAPI(messages: any[]): any[] {

FILE: packages/cli/src/adapters/deepseek-model-dialect.ts
  class DeepSeekModelDialect (line 11) | class DeepSeekModelDialect extends BaseAPIFormat {
    method processTextContent (line 12) | processTextContent(textContent: string, accumulatedText: string): Adap...
    method prepareRequest (line 23) | override prepareRequest(request: any, originalRequest: any): any {
    method shouldHandle (line 38) | shouldHandle(modelId: string): boolean {
    method getName (line 42) | getName(): string {

FILE: packages/cli/src/adapters/dialect-manager.ts
  class DialectManager (line 22) | class DialectManager {
    method constructor (line 26) | constructor(modelId: string) {
    method getAdapter (line 45) | getAdapter(): BaseAPIFormat {
    method needsTransformation (line 57) | needsTransformation(): boolean {

FILE: packages/cli/src/adapters/gemini-api-format.ts
  constant REASONING_PATTERNS (line 24) | const REASONING_PATTERNS = [
  constant REASONING_CONTINUATION_PATTERNS (line 46) | const REASONING_CONTINUATION_PATTERNS = [
  class GeminiAPIFormat (line 64) | class GeminiAPIFormat extends BaseAPIFormat {
    method constructor (line 76) | constructor(modelId: string) {
    method convertMessages (line 82) | override convertMessages(claudeRequest: any, _filterIdentityFn?: (s: s...
    method convertUserParts (line 100) | private convertUserParts(msg: any): any[] {
    method convertAssistantParts (line 173) | private convertAssistantParts(msg: any): any[] {
    method convertTools (line 223) | override convertTools(claudeRequest: any, _summarize = false): any[] {
    method buildPayload (line 230) | override buildPayload(claudeRequest: any, messages: any[], tools: any[...
    method registerToolCall (line 287) | registerToolCall(toolId: string, name: string, thoughtSignature?: stri...
    method processTextContent (line 296) | processTextContent(textContent: string, _accumulatedText: string): Ada...
    method isReasoningLine (line 344) | private isReasoningLine(line: string): boolean {
    method isReasoningContinuation (line 348) | private isReasoningContinuation(line: string): boolean {
    method getStreamFormat (line 354) | override getStreamFormat(): StreamFormat {
    method reset (line 363) | override reset(): void {
    method getContextWindow (line 369) | override getContextWindow(): number {
    method shouldHandle (line 373) | shouldHandle(modelId: string): boolean {
    method getName (line 377) | getName(): string {
    method extractThoughtSignaturesFromReasoningDetails (line 386) | extractThoughtSignaturesFromReasoningDetails(
    method getThoughtSignature (line 406) | getThoughtSignature(toolCallId: string): string | undefined {
    method hasThoughtSignature (line 411) | hasThoughtSignature(toolCallId: string): boolean {
    method getAllThoughtSignatures (line 416) | getAllThoughtSignatures(): Map<string, string> {

FILE: packages/cli/src/adapters/glm-model-dialect.ts
  class GLMModelDialect (line 14) | class GLMModelDialect extends BaseAPIFormat {
    method processTextContent (line 15) | processTextContent(textContent: string, accumulatedText: string): Adap...
    method prepareRequest (line 23) | override prepareRequest(request: any, originalRequest: any): any {
    method shouldHandle (line 33) | shouldHandle(modelId: string): boolean {
    method getName (line 41) | getName(): string {
    method getContextWindow (line 45) | override getContextWindow(): number {
    method supportsVision (line 49) | override supportsVision(): boolean {

FILE: packages/cli/src/adapters/grok-model-dialect.ts
  class GrokModelDialect (line 17) | class GrokModelDialect extends BaseAPIFormat {
    method processTextContent (line 20) | processTextContent(textContent: string, accumulatedText: string): Adap...
    method prepareRequest (line 83) | override prepareRequest(request: any, originalRequest: any): any {
    method parseXmlParameters (line 113) | private parseXmlParameters(xmlContent: string): Record<string, any> {
    method shouldHandle (line 134) | shouldHandle(modelId: string): boolean {
    method getName (line 138) | getName(): string {
    method getContextWindow (line 142) | override getContextWindow(): number {
    method reset (line 149) | reset(): void {

FILE: packages/cli/src/adapters/litellm-api-format.ts
  constant INLINE_IMAGE_MODEL_PATTERNS (line 20) | const INLINE_IMAGE_MODEL_PATTERNS = ["minimax"];
  class LiteLLMAPIFormat (line 22) | class LiteLLMAPIFormat extends DefaultAPIFormat {
    method constructor (line 27) | constructor(modelId: string, baseUrl: string) {
    method getName (line 36) | getName(): string {
    method shouldHandle (line 40) | shouldHandle(modelId: string): boolean {
    method supportsVision (line 44) | supportsVision(): boolean {
    method convertMessages (line 52) | convertMessages(claudeRequest: any, filterIdentityFn?: (s: string) => ...
    method buildPayload (line 103) | buildPayload(claudeRequest: any, messages: any[], tools: any[]): any {
    method getContextWindow (line 130) | getContextWindow(): number {
    method checkVisionSupport (line 137) | private checkVisionSupport(): boolean {

FILE: packages/cli/src/adapters/local-adapter.ts
  type SamplingParams (line 18) | interface SamplingParams {
  class LocalModelAdapter (line 26) | class LocalModelAdapter extends BaseAPIFormat {
    method constructor (line 30) | constructor(modelId: string, providerName: string) {
    method processTextContent (line 40) | processTextContent(textContent: string, accumulatedText: string): Adap...
    method shouldHandle (line 44) | shouldHandle(modelId: string): boolean {
    method getName (line 48) | getName(): string {
    method reset (line 52) | override reset(): void {
    method supportsVision (line 57) | supportsVision(): boolean {
    method convertMessages (line 63) | override convertMessages(claudeRequest: any, filterIdentityFn?: (s: st...
    method convertTools (line 91) | override convertTools(claudeRequest: any, summarize = false): any[] {
    method buildPayload (line 98) | override buildPayload(claudeRequest: any, messages: any[], tools: any[...
    method prepareRequest (line 136) | override prepareRequest(request: any, originalRequest: any): any {
    method getToolNameMap (line 153) | override getToolNameMap(): Map<string, string> {
    method getContextWindow (line 161) | override getContextWindow(): number {
    method getSamplingParams (line 167) | private getSamplingParams(): SamplingParams {
    method buildSystemGuidance (line 189) | private buildSystemGuidance(toolCount: number): string {

FILE: packages/cli/src/adapters/minimax-model-dialect.ts
  class MiniMaxModelDialect (line 15) | class MiniMaxModelDialect extends BaseAPIFormat {
    method processTextContent (line 16) | processTextContent(textContent: string, accumulatedText: string): Adap...
    method prepareRequest (line 31) | override prepareRequest(request: any, originalRequest: any): any {
    method getContextWindow (line 56) | override getContextWindow(): number {
    method supportsVision (line 65) | override supportsVision(): boolean {
    method shouldFilterThinking (line 73) | override shouldFilterThinking(): boolean {
    method shouldHandle (line 77) | shouldHandle(modelId: string): boolean {
    method getName (line 81) | getName(): string {

FILE: packages/cli/src/adapters/model-catalog.ts
  type ModelEntry (line 9) | interface ModelEntry {
  constant MODEL_CATALOG (line 28) | const MODEL_CATALOG: ModelEntry[] = [
  function lookupModel (line 114) | function lookupModel(modelId: string): ModelEntry | undefined {
  constant DEFAULT_CONTEXT_WINDOW (line 130) | const DEFAULT_CONTEXT_WINDOW = 0;
  constant DEFAULT_SUPPORTS_VISION (line 133) | const DEFAULT_SUPPORTS_VISION = true;

FILE: packages/cli/src/adapters/model-dialect.ts
  type ModelDialect (line 10) | interface ModelDialect {

FILE: packages/cli/src/adapters/ollama-api-format.ts
  class OllamaAPIFormat (line 14) | class OllamaAPIFormat extends BaseAPIFormat {
    method constructor (line 15) | constructor(modelId: string) {
    method processTextContent (line 19) | processTextContent(textContent: string, _accumulatedText: string): Ada...
    method shouldHandle (line 27) | shouldHandle(_modelId: string): boolean {
    method getName (line 31) | getName(): string {
    method convertMessages (line 39) | override convertMessages(claudeRequest: any, _filterFn?: any): any[] {
    method convertTools (line 66) | override convertTools(_claudeRequest: any, _summarize?: boolean): any[] {
    method buildPayload (line 73) | override buildPayload(_claudeRequest: any, messages: any[], _tools: an...
    method getStreamFormat (line 81) | override getStreamFormat(): StreamFormat {
    method getContextWindow (line 85) | override getContextWindow(): number {
    method supportsVision (line 89) | override supportsVision(): boolean {
    method processUserMessage (line 95) | private processUserMessage(msg: any): any {
    method processAssistantMessage (line 113) | private processAssistantMessage(msg: any): any {

FILE: packages/cli/src/adapters/openai-api-format.ts
  class OpenAIAPIFormat (line 19) | class OpenAIAPIFormat extends BaseAPIFormat {
    method constructor (line 20) | constructor(modelId: string) {
    method processTextContent (line 24) | processTextContent(textContent: string, accumulatedText: string): Adap...
    method getStreamFormat (line 32) | override getStreamFormat(): StreamFormat {
    method prepareRequest (line 39) | override prepareRequest(request: any, originalRequest: any): any {
    method shouldHandle (line 62) | shouldHandle(modelId: string): boolean {
    method getName (line 66) | getName(): string {
    method getContextWindow (line 72) | override getContextWindow(): number {
    method buildPayload (line 76) | override buildPayload(claudeRequest: any, messages: any[], tools: any[...
    method isReasoningModel (line 82) | private isReasoningModel(): boolean {
    method usesMaxCompletionTokens (line 87) | private usesMaxCompletionTokens(): boolean {
    method buildChatCompletionsPayload (line 97) | private buildChatCompletionsPayload(claudeRequest: any, messages: any[...

FILE: packages/cli/src/adapters/openrouter-api-format.ts
  class OpenRouterAPIFormat (line 18) | class OpenRouterAPIFormat extends BaseAPIFormat {
    method constructor (line 21) | constructor(modelId: string) {
    method modelSupportsReasoning (line 30) | private modelSupportsReasoning(): boolean {
    method processTextContent (line 43) | processTextContent(textContent: string, accumulatedText: string): Adap...
    method shouldHandle (line 47) | shouldHandle(modelId: string): boolean {
    method getName (line 51) | getName(): string {
    method reset (line 55) | override reset(): void {
    method convertMessages (line 62) | override convertMessages(claudeRequest: any, filterIdentityFn?: (s: st...
    method appendToSystemPrompt (line 87) | private appendToSystemPrompt(messages: any[], text: string): void {
    method convertTools (line 97) | override convertTools(claudeRequest: any, summarize = false): any[] {
    method buildPayload (line 113) | override buildPayload(claudeRequest: any, messages: any[], tools: any[...
    method prepareRequest (line 152) | override prepareRequest(request: any, originalRequest: any): any {
    method getToolNameMap (line 156) | override getToolNameMap(): Map<string, string> {
    method extractThoughtSignaturesFromReasoningDetails (line 166) | extractThoughtSignaturesFromReasoningDetails(reasoningDetails: any[]):...

FILE: packages/cli/src/adapters/qwen-model-dialect.ts
  constant QWEN_SPECIAL_TOKENS (line 13) | const QWEN_SPECIAL_TOKENS = [
  class QwenModelDialect (line 21) | class QwenModelDialect extends BaseAPIFormat {
    method processTextContent (line 22) | processTextContent(textContent: string, accumulatedText: string): Adap...
    method prepareRequest (line 55) | override prepareRequest(request: any, originalRequest: any): any {
    method shouldHandle (line 74) | shouldHandle(modelId: string): boolean {
    method getName (line 78) | getName(): string {

FILE: packages/cli/src/adapters/tool-name-utils.ts
  function hashToolName (line 14) | function hashToolName(name: string): string {
  function truncateToolName (line 35) | function truncateToolName(name: string, maxLength: number): string {

FILE: packages/cli/src/adapters/xiaomi-model-dialect.ts
  class XiaomiModelDialect (line 14) | class XiaomiModelDialect extends BaseAPIFormat {
    method processTextContent (line 15) | processTextContent(textContent: string, accumulatedText: string): Adap...
    method getToolNameLimit (line 23) | override getToolNameLimit(): number | null {
    method prepareRequest (line 27) | override prepareRequest(request: any, originalRequest: any): any {
    method shouldHandle (line 43) | shouldHandle(modelId: string): boolean {
    method getName (line 47) | getName(): string {

FILE: packages/cli/src/auth/auth-commands.ts
  type OAuthInstance (line 17) | interface OAuthInstance {
  type OAuthProvider (line 22) | interface OAuthProvider {
  constant AUTH_PROVIDERS (line 30) | const AUTH_PROVIDERS: OAuthProvider[] = [
  function getAuthStatus (line 54) | function getAuthStatus(provider: OAuthProvider): string {
  function selectProvider (line 59) | async function selectProvider(action: string): Promise<OAuthProvider> {
  function findProvider (line 71) | function findProvider(name: string): OAuthProvider | null {
  function loginCommand (line 83) | async function loginCommand(providerArg?: string): Promise<void> {
  function logoutCommand (line 107) | async function logoutCommand(providerArg?: string): Promise<void> {

FILE: packages/cli/src/auth/codex-oauth.ts
  type CodexCredentials (line 29) | interface CodexCredentials {
  type TokenResponse (line 39) | interface TokenResponse {
  constant OAUTH_CONFIG (line 50) | const OAUTH_CONFIG = {
  class CodexOAuth (line 65) | class CodexOAuth {
    method getInstance (line 75) | static getInstance(): CodexOAuth {
    method constructor (line 85) | private constructor() {
    method hasCredentials (line 94) | hasCredentials(): boolean {
    method getCredentialsPath (line 101) | private getCredentialsPath(): string {
    method login (line 110) | async login(): Promise<void> {
    method logout (line 155) | async logout(): Promise<void> {
    method getAccessToken (line 169) | async getAccessToken(): Promise<string> {
    method getAccountId (line 199) | getAccountId(): string | undefined {
    method refreshToken (line 206) | async refreshToken(): Promise<void> {
    method isTokenValid (line 219) | private isTokenValid(): boolean {
    method doRefreshToken (line 228) | private async doRefreshToken(): Promise<string> {
    method loadCredentials (line 289) | private loadCredentials(): CodexCredentials | null {
    method saveCredentials (line 317) | private saveCredentials(credentials: CodexCredentials): void {
    method generateCodeVerifier (line 342) | private generateCodeVerifier(): string {
    method generateCodeChallenge (line 349) | private async generateCodeChallenge(verifier: string): Promise<string> {
    method extractAccountId (line 359) | private extractAccountId(idToken: string): string | undefined {
    method buildAuthUrl (line 386) | private buildAuthUrl(codeChallenge: string, state: string, redirectUri...
    method startCallbackServer (line 409) | private async startCallbackServer(
    method exchangeCodeForTokens (line 528) | private async exchangeCodeForTokens(
    method openBrowser (line 571) | private async openBrowser(url: string): Promise<void> {
  function getCodexOAuth (line 597) | function getCodexOAuth(): CodexOAuth {
  function getValidCodexAccessToken (line 605) | async function getValidCodexAccessToken(): Promise<string> {

FILE: packages/cli/src/auth/gemini-oauth.ts
  type GeminiCredentials (line 28) | interface GeminiCredentials {
  type TokenResponse (line 37) | interface TokenResponse {
  constant OAUTH_CONFIG (line 70) | const OAUTH_CONFIG = {
  class GeminiOAuth (line 86) | class GeminiOAuth {
    method getInstance (line 96) | static getInstance(): GeminiOAuth {
    method constructor (line 106) | private constructor() {
    method hasCredentials (line 115) | hasCredentials(): boolean {
    method getCredentialsPath (line 122) | private getCredentialsPath(): string {
    method login (line 131) | async login(): Promise<void> {
    method logout (line 169) | async logout(): Promise<void> {
    method getAccessToken (line 183) | async getAccessToken(): Promise<string> {
    method refreshToken (line 216) | async refreshToken(): Promise<void> {
    method isTokenValid (line 229) | private isTokenValid(): boolean {
    method doRefreshToken (line 237) | private async doRefreshToken(): Promise<string> {
    method loadCredentials (line 293) | private loadCredentials(): GeminiCredentials | null {
    method saveCredentials (line 321) | private saveCredentials(credentials: GeminiCredentials): void {
    method generateCodeVerifier (line 346) | private generateCodeVerifier(): string {
    method generateCodeChallenge (line 353) | private async generateCodeChallenge(verifier: string): Promise<string> {
    method buildAuthUrl (line 361) | private buildAuthUrl(codeChallenge: string, state: string, redirectUri...
    method startCallbackServer (line 381) | private async startCallbackServer(
    method exchangeCodeForTokens (line 499) | private async exchangeCodeForTokens(
    method openBrowser (line 542) | private async openBrowser(url: string): Promise<void> {
  function getGeminiOAuth (line 568) | function getGeminiOAuth(): GeminiOAuth {
  constant CODE_ASSIST_API_BASE (line 576) | const CODE_ASSIST_API_BASE = "https://cloudcode-pa.googleapis.com/v1inte...
  type ClientMetadata (line 578) | interface ClientMetadata {
  type AllowedTier (line 585) | interface AllowedTier {
  type LoadCodeAssistResponse (line 590) | interface LoadCodeAssistResponse {
  type LROResponse (line 597) | interface LROResponse {
  function getValidAccessToken (line 609) | async function getValidAccessToken(): Promise<string> {
  constant TIER_SHORT_NAMES (line 620) | const TIER_SHORT_NAMES: Record<string, string> = {
  function getGeminiTierDisplayName (line 631) | function getGeminiTierDisplayName(): string {
  function getGeminiTierFullName (line 639) | function getGeminiTierFullName(): string {
  function setupGeminiUser (line 649) | async function setupGeminiUser(
  function callLoadCodeAssist (line 728) | async function callLoadCodeAssist(
  function callOnboardUser (line 755) | async function callOnboardUser(
  type QuotaBucket (line 788) | interface QuotaBucket {
  function retrieveUserQuota (line 801) | async function retrieveUserQuota(

FILE: packages/cli/src/auth/kimi-oauth.ts
  type KimiCredentials (line 32) | interface KimiCredentials {
  type DeviceAuthorization (line 43) | interface DeviceAuthorization {
  type TokenResponse (line 55) | interface TokenResponse {
  constant OAUTH_CONFIG (line 68) | const OAUTH_CONFIG = {
  class KimiOAuth (line 78) | class KimiOAuth {
    method getInstance (line 88) | static getInstance(): KimiOAuth {
    method constructor (line 99) | private constructor() {
    method hasCredentials (line 112) | hasCredentials(): boolean {
    method getCredentialsPath (line 119) | private getCredentialsPath(): string {
    method getDeviceIdPath (line 127) | private getDeviceIdPath(): string {
    method loadOrCreateDeviceId (line 136) | private loadOrCreateDeviceId(): string {
    method getVersion (line 182) | private getVersion(): string {
    method getPlatformHeaders (line 190) | getPlatformHeaders(): Record<string, string> {
    method login (line 204) | async login(): Promise<void> {
    method requestDeviceAuthorization (line 245) | private async requestDeviceAuthorization(): Promise<DeviceAuthorizatio...
    method pollForToken (line 291) | private async pollForToken(
    method pollForTokenWithRetry (line 346) | private async pollForTokenWithRetry(deviceCode: string, retryCount = 0...
    method openBrowser (line 390) | private async openBrowser(url: string): Promise<void> {
    method logout (line 411) | async logout(): Promise<void> {
    method getAccessToken (line 426) | async getAccessToken(): Promise<string> {
    method isTokenValid (line 456) | private isTokenValid(): boolean {
    method doRefreshToken (line 465) | private async doRefreshToken(): Promise<string> {
    method loadCredentials (line 546) | private loadCredentials(): KimiCredentials | null {
    method saveCredentials (line 580) | private saveCredentials(credentials: KimiCredentials): void {
  function getKimiOAuth (line 606) | function getKimiOAuth(): KimiOAuth {
  function getValidKimiAccessToken (line 614) | async function getValidKimiAccessToken(): Promise<string> {
  function hasKimiOAuthCredentials (line 624) | function hasKimiOAuthCredentials(): boolean {

FILE: packages/cli/src/auth/oauth-manager.ts
  type BaseCredentials (line 24) | interface BaseCredentials {
  method ensureClaudishDir (line 59) | protected static ensureClaudishDir(): string {
  method getCredentialsPath (line 67) | protected getCredentialsPath(): string {
  method loadCredentials (line 73) | protected loadCredentials(): T | null {
  method saveCredentials (line 91) | protected saveCredentials(credentials: T): void {
  method deleteCredentials (line 103) | protected deleteCredentials(): void {
  method hasCredentials (line 113) | hasCredentials(): boolean {
  method getAccessToken (line 117) | async getAccessToken(): Promise<string> {
  method refreshToken (line 140) | async refreshToken(): Promise<void> {
  method isTokenValid (line 149) | protected isTokenValid(): boolean {
  method generateCodeVerifier (line 156) | protected generateCodeVerifier(): string {
  method generateCodeChallenge (line 160) | protected generateCodeChallenge(verifier: string): string {
  method openBrowser (line 166) | protected async openBrowser(url: string, message?: string): Promise<void> {
  method logout (line 191) | async logout(): Promise<void> {

FILE: packages/cli/src/auth/oauth-registry.ts
  type OAuthProviderDescriptor (line 5) | interface OAuthProviderDescriptor {
  constant OAUTH_PROVIDERS (line 30) | const OAUTH_PROVIDERS: Record<string, OAuthProviderDescriptor> = {
  function hasValidOAuthCredentials (line 69) | function hasValidOAuthCredentials(descriptor: OAuthProviderDescriptor): ...
  function hasOAuthCredentials (line 97) | function hasOAuthCredentials(providerName: string): boolean {

FILE: packages/cli/src/auth/quota-command.ts
  constant RED (line 25) | const RED = "\x1b[31m";
  constant GRN (line 26) | const GRN = "\x1b[32m";
  constant YEL (line 27) | const YEL = "\x1b[33m";
  constant MAG (line 28) | const MAG = "\x1b[35m";
  constant CYN (line 29) | const CYN = "\x1b[36m";
  constant WHT (line 30) | const WHT = "\x1b[37m";
  constant GRY (line 31) | const GRY = "\x1b[90m";
  constant FALLBACK_CHAIN (line 34) | const FALLBACK_CHAIN = [
  type QuotaAdapter (line 46) | interface QuotaAdapter {
  constant QUOTA_ADAPTERS (line 53) | const QUOTA_ADAPTERS: QuotaAdapter[] = [
  function quotaCommand (line 72) | async function quotaCommand(provider?: string): Promise<void> {
  function geminiQuotaHandler (line 105) | async function geminiQuotaHandler(): Promise<void> {
  function codexQuotaHandler (line 208) | async function codexQuotaHandler(): Promise<void> {
  type QuotaBucket (line 336) | interface QuotaBucket {
  type VersionGroup (line 344) | interface VersionGroup {
  function groupByVersion (line 350) | function groupByVersion(buckets: QuotaBucket[]): VersionGroup[] {
  function extractVersion (line 377) | function extractVersion(modelId: string): string | undefined {
  function buildUsageBar (line 382) | function buildUsageBar(usedFraction: number, color: string, width = 24):...
  function formatRelativeReset (line 393) | function formatRelativeReset(resetTime: string): string {

FILE: packages/cli/src/auth/vertex-auth.ts
  type VertexAccessToken (line 22) | interface VertexAccessToken {
  type VertexConfig (line 27) | interface VertexConfig {
  class VertexAuthManager (line 35) | class VertexAuthManager {
    method getAccessToken (line 43) | async getAccessToken(): Promise<string> {
    method refreshToken (line 69) | async refreshToken(): Promise<void> {
    method isTokenValid (line 77) | private isTokenValid(): boolean {
    method doRefresh (line 85) | private async doRefresh(): Promise<string> {
    method tryADC (line 117) | private async tryADC(): Promise<VertexAccessToken | null> {
    method tryServiceAccount (line 151) | private async tryServiceAccount(): Promise<VertexAccessToken | null> {
  function getVertexConfig (line 190) | function getVertexConfig(): VertexConfig | null {
  function validateVertexOAuthConfig (line 206) | function validateVertexOAuthConfig(): string | null {
  function buildVertexOAuthEndpoint (line 237) | function buildVertexOAuthEndpoint(
  function getVertexAuthManager (line 279) | function getVertexAuthManager(): VertexAuthManager {

FILE: packages/cli/src/channel/e2e-channel.test.ts
  constant SERVER_ENTRY (line 27) | const SERVER_ENTRY = join(__dirname, "../index.ts");
  function runClaudeWithMcp (line 264) | async function runClaudeWithMcp(

FILE: packages/cli/src/channel/scrollback-buffer.ts
  constant ANSI_RE (line 7) | const ANSI_RE = /\x1b\[[0-9;]*[a-zA-Z]|\x1b\].*?\x07|\x1b[()][AB012]|\x1...
  class ScrollbackBuffer (line 9) | class ScrollbackBuffer {
    method constructor (line 16) | constructor(capacity = 2000) {
    method append (line 25) | append(data: string): void {
    method getLines (line 41) | getLines(n?: number): string[] {
    method totalLines (line 56) | get totalLines(): number {
    method size (line 61) | get size(): number {
    method clear (line 66) | clear(): void {

FILE: packages/cli/src/channel/session-manager.test.ts
  constant FAKE_CLAUDISH_TS (line 35) | const FAKE_CLAUDISH_TS = join(__dirname, "test-helpers", "fake-claudish....
  constant ORIGINAL_PATH (line 40) | const ORIGINAL_PATH = process.env.PATH ?? "";
  function waitUntil (line 68) | function waitUntil(predicate: () => boolean, timeoutMs = 5000, intervalM...
  function makeManager (line 81) | function makeManager(opts?: SessionManagerOptions): SessionManager {
  function quickSession (line 90) | function quickSession(

FILE: packages/cli/src/channel/session-manager.ts
  type SessionEntry (line 25) | interface SessionEntry {
  constant DEFAULT_MAX_SESSIONS (line 36) | const DEFAULT_MAX_SESSIONS = 20;
  constant DEFAULT_SCROLLBACK (line 37) | const DEFAULT_SCROLLBACK = 2000;
  constant DEFAULT_TIMEOUT (line 38) | const DEFAULT_TIMEOUT = 600;
  constant MAX_TIMEOUT (line 39) | const MAX_TIMEOUT = 3600;
  constant KILL_GRACE_MS (line 40) | const KILL_GRACE_MS = 5000;
  class SessionManager (line 42) | class SessionManager {
    method constructor (line 49) | constructor(options?: SessionManagerOptions) {
    method createSession (line 56) | createSession(opts: SessionCreateOptions): string {
    method sendInput (line 209) | sendInput(sessionId: string, text: string): boolean {
    method getOutput (line 226) | getOutput(
    method cancelSession (line 256) | cancelSession(sessionId: string): boolean {
    method listSessions (line 286) | listSessions(includeCompleted = false): SessionInfo[] {
    method getSession (line 305) | getSession(sessionId: string): SessionInfo {
    method shutdownAll (line 313) | async shutdownAll(): Promise<void> {
    method activeSessions (line 341) | private get activeSessions(): number {
    method getElapsed (line 350) | private getElapsed(startedAt: string): number {
    method setupSigint (line 354) | private setupSigint(): void {
    method cleanupSigint (line 363) | private cleanupSigint(): void {

FILE: packages/cli/src/channel/signal-watcher.ts
  constant QUIET_PERIOD_MS (line 9) | const QUIET_PERIOD_MS = 2000;
  constant TOOL_BATCH_MS (line 12) | const TOOL_BATCH_MS = 500;
  constant TOOL_PATTERNS (line 15) | const TOOL_PATTERNS = [
  constant QUESTION_PATTERNS (line 22) | const QUESTION_PATTERNS = [/\?\s*$/m, /\bchoose\b.*:/im, /\bselect\b.*:/...
  class SignalWatcher (line 24) | class SignalWatcher {
    method constructor (line 33) | constructor(
    method state (line 40) | get state(): SignalState {
    method feed (line 45) | feed(text: string): void {
    method processExited (line 80) | processExited(exitCode: number | null): void {
    method forceState (line 96) | forceState(state: SignalState, content?: string): void {
    method dispose (line 103) | dispose(): void {
    method transition (line 110) | private transition(newState: SignalState, extra?: Partial<SignalData>)...
    method detectToolUse (line 123) | private detectToolUse(text: string): string | null {
    method handleToolDetection (line 137) | private handleToolDetection(toolName: string): void {
    method clearQuietTimer (line 161) | private clearQuietTimer(): void {
    method clearTimers (line 168) | private clearTimers(): void {

FILE: packages/cli/src/channel/test-helpers/fake-claudish.ts
  function getFlag (line 18) | function getFlag(name: string): string | null {
  function hasFlag (line 24) | function hasFlag(name: string): boolean {
  function main (line 28) | async function main() {

FILE: packages/cli/src/channel/types.ts
  type SessionStatus (line 3) | type SessionStatus =
  type SignalState (line 13) | type SignalState =
  type SessionInfo (line 22) | interface SessionInfo {
  type SessionCreateOptions (line 35) | interface SessionCreateOptions {
  type ChannelEvent (line 43) | interface ChannelEvent {
  type SignalData (line 51) | interface SignalData {
  type SignalCallback (line 60) | type SignalCallback = (sessionId: string, data: SignalData) => void;
  type SessionManagerOptions (line 62) | interface SessionManagerOptions {

FILE: packages/cli/src/claude-runner.ts
  function hasNativeAnthropicMapping (line 16) | function hasNativeAnthropicMapping(config: ClaudishConfig): boolean {
  function isWindows (line 29) | function isWindows(): boolean {
  function createStatusLineScript (line 37) | function createStatusLineScript(tokenFilePath: string): string {
  function createTempSettingsFile (line 149) | function createTempSettingsFile(
  function mergeUserSettingsIfPresent (line 216) | function mergeUserSettingsIfPresent(
  function runClaudeWithProxy (line 261) | async function runClaudeWithProxy(
  function setupSignalHandlers (line 461) | function setupSignalHandlers(
  function findClaudeBinary (line 504) | async function findClaudeBinary(): Promise<string | null> {
  function checkClaudeInstalled (line 605) | async function checkClaudeInstalled(): Promise<boolean> {

FILE: packages/cli/src/cli-passthrough.test.ts
  constant MOCK_SETTINGS_PATH (line 27) | const MOCK_SETTINGS_PATH = "/mock/.claudish/settings-12345.json";
  function buildClaudeArgs (line 29) | function buildClaudeArgs(config: ClaudishConfig): string[] {
  constant MOCK_STATUS_LINE (line 69) | const MOCK_STATUS_LINE = { type: "command", command: "echo claudish", pa...
  function mergeUserSettingsLogic (line 71) | function mergeUserSettingsLogic(

FILE: packages/cli/src/cli.test.ts
  function computeModelId (line 183) | function computeModelId(config: ClaudishConfig): string | undefined {

FILE: packages/cli/src/cli.ts
  function getVersion (line 85) | function getVersion(): string {
  function clearAllModelCaches (line 97) | function clearAllModelCaches(): void {
  function parseAdvisorFlag (line 128) | function parseAdvisorFlag(value: string): {
  function parseArgs (line 163) | async function parseArgs(args: string[]): Promise<ClaudishConfig> {
  function fetchOllamaModels (line 631) | async function fetchOllamaModels(): Promise<any[]> {
  function formatModelDocPricing (line 696) | function formatModelDocPricing(pricing: ModelDoc["pricing"]): string {
  function formatModelDocContext (line 707) | function formatModelDocContext(ctx?: number): string {
  function formatModelDocCaps (line 714) | function formatModelDocCaps(caps?: ModelDoc["capabilities"]): string {
  function searchAndPrintModels (line 727) | async function searchAndPrintModels(query: string, jsonOutput: boolean):...
  function renderModelDocTable (line 799) | function renderModelDocTable(models: Array<ModelDoc & { rank?: number }>...
  function printLocalProvidersFooter (line 824) | async function printLocalProvidersFooter(): Promise<void> {
  function printTop100 (line 867) | async function printTop100(jsonOutput: boolean): Promise<void> {
  function printByProvider (line 914) | async function printByProvider(providerSlug: string, jsonOutput: boolean...
  function printRecommendedModels (line 953) | async function printRecommendedModels(jsonOutput: boolean, forceUpdate: ...
  function printVersion (line 1081) | function printVersion(): void {
  function probeModelRouting (line 1093) | async function probeModelRouting(
  function printHelp (line 1623) | function printHelp(): void {
  function printAIAgentGuide (line 1956) | function printAIAgentGuide(): void {
  function initializeClaudishSkill (line 1976) | async function initializeClaudishSkill(): Promise<void> {
  function printAvailableModels (line 2055) | function printAvailableModels(): void {

FILE: packages/cli/src/config-command.ts
  constant RESET (line 26) | const RESET = "\x1b[0m";
  constant BOLD (line 27) | const BOLD = "\x1b[1m";
  constant DIM (line 28) | const DIM = "\x1b[2m";
  constant GREEN (line 29) | const GREEN = "\x1b[32m";
  constant YELLOW (line 30) | const YELLOW = "\x1b[33m";
  constant CYAN (line 31) | const CYAN = "\x1b[36m";
  type ProviderDef (line 35) | interface ProviderDef {
  constant PROVIDERS (line 46) | const PROVIDERS: ProviderDef[] = [
  function maskKey (line 157) | function maskKey(key: string): string {
  function testProviderConnection (line 164) | async function testProviderConnection(provider: ProviderDef, key: string...
  function configureProviderKey (line 217) | async function configureProviderKey(provider: ProviderDef): Promise<void> {
  function configApiKeys (line 285) | async function configApiKeys(): Promise<void> {
  function configEndpoints (line 329) | async function configEndpoints(): Promise<void> {
  function configureProviderEndpoint (line 375) | async function configureProviderEndpoint(provider: ProviderDef): Promise...
  function configProfiles (line 438) | async function configProfiles(): Promise<void> {
  function configRouting (line 472) | async function configRouting(): Promise<void> {
  function configTelemetry (line 586) | async function configTelemetry(): Promise<void> {
  function showCurrentConfig (line 668) | function showCurrentConfig(): void {
  function configCommand (line 759) | async function configCommand(): Promise<void> {

FILE: packages/cli/src/config-schema.ts
  type BuiltinDefaultProvider (line 78) | type BuiltinDefaultProvider = z.infer<typeof BuiltinDefaultProviderSchema>;
  type CustomEndpointSimple (line 79) | type CustomEndpointSimple = z.infer<typeof CustomEndpointSimpleSchema>;
  type CustomEndpointComplex (line 80) | type CustomEndpointComplex = z.infer<typeof CustomEndpointComplexSchema>;
  type CustomEndpoint (line 81) | type CustomEndpoint = z.infer<typeof CustomEndpointSchema>;

FILE: packages/cli/src/config.ts
  constant DEFAULT_PORT_RANGE (line 3) | const DEFAULT_PORT_RANGE = { start: 3000, end: 9000 };
  constant ENV (line 6) | const ENV = {
  constant OPENROUTER_API_URL (line 39) | const OPENROUTER_API_URL = "https://openrouter.ai/api/v1/chat/completions";
  constant OPENROUTER_HEADERS (line 40) | const OPENROUTER_HEADERS = {

FILE: packages/cli/src/default-provider.test.ts
  function makeConfig (line 9) | function makeConfig(overrides: Partial<ClaudishProfileConfig> = {}): Cla...

FILE: packages/cli/src/default-provider.ts
  type DefaultProviderSource (line 15) | type DefaultProviderSource =
  type ResolvedDefaultProvider (line 23) | interface ResolvedDefaultProvider {
  type ResolveOptions (line 32) | interface ResolveOptions {
  function resolveDefaultProvider (line 48) | function resolveDefaultProvider(opts: ResolveOptions): ResolvedDefaultPr...
  function buildLegacyHint (line 84) | function buildLegacyHint(resolved: ResolvedDefaultProvider): string | nu...

FILE: packages/cli/src/diag-output.ts
  type DiagOutput (line 11) | interface DiagOutput {
  function getClaudishDir (line 19) | function getClaudishDir(): string {
  function getDiagLogPath (line 33) | function getDiagLogPath(): string {
  class LogFileDiagOutput (line 41) | class LogFileDiagOutput implements DiagOutput {
    method constructor (line 45) | constructor() {
    method write (line 60) | write(msg: string): void {
    method cleanup (line 70) | cleanup(): void {
    method getLogPath (line 84) | getLogPath(): string {
  class NullDiagOutput (line 93) | class NullDiagOutput implements DiagOutput {
    method write (line 94) | write(_msg: string): void {
    method cleanup (line 98) | cleanup(): void {
  function createDiagOutput (line 111) | function createDiagOutput(options: {

FILE: packages/cli/src/format-translation.test.ts
  constant FIXTURES_DIR (line 22) | const FIXTURES_DIR = join(__dirname, "test-fixtures", "sse-responses");
  type ClaudeEvent (line 25) | interface ClaudeEvent {
  function fixtureToResponse (line 34) | function fixtureToResponse(fixturePath: string): Response {
  function parseClaudeSseStream (line 56) | async function parseClaudeSseStream(response: Response): Promise<ClaudeE...
  function extractText (line 98) | function extractText(events: ClaudeEvent[]): string {
  function extractToolNames (line 106) | function extractToolNames(events: ClaudeEvent[]): string[] {
  function extractStopReason (line 115) | function extractStopReason(events: ClaudeEvent[]): string | null {
  function createMockContext (line 121) | function createMockContext(): any {
  function getParser (line 141) | async function getParser() {
  function getDefaultAdapter (line 146) | async function getDefaultAdapter() {
  function getParser (line 221) | async function getParser() {
  function getConverter (line 267) | async function getConverter() {
  function getAdapter (line 414) | async function getAdapter() {
  function getSanitizer (line 790) | async function getSanitizer() {
  function getAdapter (line 981) | async function getAdapter() {
  function getParser (line 1170) | async function getParser() {
  function getParser (line 1340) | async function getParser() {
  function makeMiniMaxAdapter (line 1345) | async function makeMiniMaxAdapter() {
  function getParser (line 1533) | async function getParser() {

FILE: packages/cli/src/handlers/composed-handler.test.ts
  function makeFakeTransport (line 10) | function makeFakeTransport(): ProviderTransport {

FILE: packages/cli/src/handlers/composed-handler.ts
  type BaseModelAdapter (line 24) | type BaseModelAdapter = BaseAPIFormat;
  function extractAuthHeaders (line 46) | function extractAuthHeaders(c: Context): VisionProxyAuthHeaders {
  type ComposedHandlerOptions (line 53) | interface ComposedHandlerOptions {
  class ComposedHandler (line 70) | class ComposedHandler implements ModelHandler {
    method constructor (line 91) | constructor(
    method getAdapter (line 152) | private getAdapter(): BaseModelAdapter {
    method getModelContextWindow (line 157) | private getModelContextWindow(): number {
    method getModelSupportsVision (line 162) | private getModelSupportsVision(): boolean {
    method getActiveAdapterName (line 167) | private getActiveAdapterName(): string {
    method handle (line 173) | async handle(c: Context, payload: any): Promise<Response> {
    method handleStream (line 679) | private handleStream(
    method getTokenTracker (line 795) | getTokenTracker(): TokenTracker {
    method fetchQuotaForStatusLine (line 800) | private async fetchQuotaForStatusLine(): Promise<void> {
    method setFallbackMeta (line 820) | setFallbackMeta(chain: string[], attempts: number): void {
    method shutdown (line 824) | async shutdown(): Promise<void> {
  function getRecoveryHint (line 834) | function getRecoveryHint(status: number, errorText: string, providerName...

FILE: packages/cli/src/handlers/default-provider-e2e.test.ts
  constant PORT_BASE (line 30) | const PORT_BASE = 19200;
  function nextPort (line 32) | function nextPort(): number {
  function captureStderr (line 41) | function captureStderr(): void {
  function releaseStderr (line 78) | function releaseStderr(): string {
  constant REAL_CONFIG_PATH (line 92) | const REAL_CONFIG_PATH = join(process.env.HOME ?? tmpdir(), ".claudish",...
  function sandboxHome (line 96) | function sandboxHome(configJson?: Record<string, unknown>): string {
  function clearHomeSandbox (line 116) | function clearHomeSandbox(): void {
  function spinProxy (line 132) | async function spinProxy(opts: {
  function killProxy (line 149) | async function killProxy(): Promise<void> {
  function askProxy (line 177) | async function askProxy(
  constant HAS_OR (line 292) | const HAS_OR = !!process.env.OPENROUTER_API_KEY;
  constant HAS_LL (line 293) | const HAS_LL = !!(process.env.LITELLM_BASE_URL && process.env.LITELLM_AP...
  constant HAS_XAI (line 294) | const HAS_XAI = !!process.env.XAI_API_KEY;
  constant KNOWN_PROVIDERS (line 647) | const KNOWN_PROVIDERS = new Set([
  function fetchCatalog (line 675) | async function fetchCatalog(): Promise<any> {

FILE: packages/cli/src/handlers/fallback-handler.test.ts
  constant TEST_PORT (line 23) | const TEST_PORT = 18900 + Math.floor(Math.random() * 100);
  function ensureProxy (line 27) | async function ensureProxy(): Promise<number> {
  function sendMessage (line 53) | async function sendMessage(
  function hasAnyCredentials (line 144) | function hasAnyCredentials(): boolean {
  function mockHandler (line 391) | function mockHandler(status: number, body: string) {
  function runFallback (line 399) | async function runFallback(firstStatus: number, firstBody: string): Prom...

FILE: packages/cli/src/handlers/fallback-handler.ts
  type FallbackCandidate (line 17) | interface FallbackCandidate {
  class FallbackHandler (line 24) | class FallbackHandler implements ModelHandler {
    method constructor (line 29) | constructor(candidates: FallbackCandidate[]) {
    method handle (line 38) | async handle(c: Context, payload: any): Promise<Response> {
    method formatCombinedError (line 107) | private formatCombinedError(
    method shutdown (line 139) | async shutdown(): Promise<void> {
  function isRetryableError (line 154) | function isRetryableError(status: number, errorBody: string): boolean {
  function parseErrorMessage (line 211) | function parseErrorMessage(body: string): string {
  function truncate (line 223) | function truncate(s: string, max: number): string {

FILE: packages/cli/src/handlers/native-handler-advisor.ts
  constant ADVISOR_SERVER_TOOL_TYPE (line 30) | const ADVISOR_SERVER_TOOL_TYPE = "advisor_20260301";
  constant ADVISOR_BETA_FLAG (line 31) | const ADVISOR_BETA_FLAG = "advisor-tool-2026-03-01";
  type AdvisorSwapConfig (line 33) | interface AdvisorSwapConfig {
  function loadAdvisorSwapConfig (line 42) | function loadAdvisorSwapConfig(
  type AdvisorInfo (line 55) | interface AdvisorInfo {
  function swapAdvisorToolInBody (line 73) | function swapAdvisorToolInBody(
  function stripAdvisorBeta (line 125) | function stripAdvisorBeta(
  function logAdvisorEvent (line 147) | function logAdvisorEvent(
  function recordAdvisorEventsFromChunk (line 169) | function recordAdvisorEventsFromChunk(
  constant MAX_TRACKED (line 214) | const MAX_TRACKED = 256;
  function extractAdvisorToolUseIds (line 224) | function extractAdvisorToolUseIds(chunkText: string): void {
  function rememberAdvisorToolUseId (line 243) | function rememberAdvisorToolUseId(id: string): void {
  function _debug_getTrackedAdvisorIds (line 254) | function _debug_getTrackedAdvisorIds(): string[] {
  function _debug_resetTrackedAdvisorIds (line 259) | function _debug_resetTrackedAdvisorIds(): void {
  function rewriteAdvisorToolResults (line 272) | function rewriteAdvisorToolResults(
  function stubAdvisorAdvice (line 319) | function stubAdvisorAdvice(toolUseId: string): string {
  function findPendingAdvisorToolResults (line 340) | function findPendingAdvisorToolResults(
  function convertToOpenAIMessages (line 363) | function convertToOpenAIMessages(
  function extractBlocksAsText (line 375) | function extractBlocksAsText(content: any): string {
  constant ADVISOR_SYSTEM_PROMPT (line 399) | const ADVISOR_SYSTEM_PROMPT = `You are a strategic advisor to a coding a...
  constant COLLECTOR_SYSTEM_PROMPT (line 411) | const COLLECTOR_SYSTEM_PROMPT = `You are synthesizing advice from multip...
  function buildAdvisorRequest (line 419) | function buildAdvisorRequest(
  function callAdvisorModel (line 480) | async function callAdvisorModel(
  function isAnthropicModel (line 509) | function isAnthropicModel(parsed: ReturnType<typeof parseModelSpec>): bo...
  function callAnthropicCollector (line 518) | async function callAnthropicCollector(
  function callCollectorModel (line 551) | async function callCollectorModel(
  function fetchMultiModelAdvice (line 595) | async function fetchMultiModelAdvice(

FILE: packages/cli/src/handlers/native-handler.ts
  class NativeHandler (line 17) | class NativeHandler implements ModelHandler {
    method constructor (line 23) | constructor(apiKey?: string, advisorModels?: string[], advisorCollecto...
    method handle (line 31) | async handle(c: Context, payload: any): Promise<Response> {
    method shutdown (line 265) | async shutdown(): Promise<void> {
  function trimForLog (line 276) | function trimForLog(payload: any): any {

FILE: packages/cli/src/handlers/shared/anthropic-error.ts
  type AnthropicErrorType (line 6) | type AnthropicErrorType =
  type AnthropicErrorEnvelope (line 16) | interface AnthropicErrorEnvelope {
  function statusToErrorType (line 27) | function statusToErrorType(status: number): AnthropicErrorType {
  function wrapAnthropicError (line 47) | function wrapAnthropicError(
  function ensureAnthropicErrorFormat (line 63) | function ensureAnthropicErrorFormat(

FILE: packages/cli/src/handlers/shared/format/identity-filter.ts
  function filterIdentity (line 11) | function filterIdentity(content: string): string {

FILE: packages/cli/src/handlers/shared/format/openai-messages.ts
  function convertMessagesToOpenAI (line 11) | function convertMessagesToOpenAI(
  function processUserMessage (line 48) | function processUserMessage(msg: any, messages: any[], simpleFormat = fa...
  function processAssistantMessage (line 101) | function processAssistantMessage(msg: any, messages: any[], simpleFormat...

FILE: packages/cli/src/handlers/shared/format/openai-tools.ts
  function sanitizeSchemaForOpenAI (line 23) | function sanitizeSchemaForOpenAI(schema: any): any {
  function convertToolsToOpenAI (line 64) | function convertToolsToOpenAI(req: any, summarize = false): any[] {
  function summarizeToolDescription (line 85) | function summarizeToolDescription(name: string, description: string): st...
  function summarizeToolParameters (line 111) | function summarizeToolParameters(schema: any): any {

FILE: packages/cli/src/handlers/shared/gemini-queue.ts
  type QueuedRequest (line 19) | interface QueuedRequest {
  type QueueStats (line 28) | interface QueueStats {
  class GeminiRequestQueue (line 49) | class GeminiRequestQueue {
    method constructor (line 64) | private constructor() {
    method getInstance (line 71) | static getInstance(): GeminiRequestQueue {
    method enqueue (line 85) | async enqueue(fetchFn: () => Promise<Response>): Promise<Response> {
    method processQueue (line 115) | private async processQueue(): Promise<void> {
    method waitForNextSlot (line 166) | private async waitForNextSlot(): Promise<void> {
    method handleRateLimitResponse (line 191) | private handleRateLimitResponse(errorText: string): void {
    method handleSuccessResponse (line 233) | private handleSuccessResponse(): void {
    method getStats (line 252) | getStats(): QueueStats {

FILE: packages/cli/src/handlers/shared/gemini-schema.ts
  function sanitizeToolNameForGemini (line 21) | function sanitizeToolNameForGemini(name: string | undefined | null): str...
  function normalizeType (line 54) | function normalizeType(type: any): string {
  function sanitizeSchemaForGemini (line 78) | function sanitizeSchemaForGemini(schema: any): any {
  function convertToolsToGemini (line 151) | function convertToolsToGemini(tools: any[] | undefined): any {

FILE: packages/cli/src/handlers/shared/local-queue.ts
  type QueuedRequest (line 31) | interface QueuedRequest {
  type QueueStats (line 41) | interface QueueStats {
  class LocalModelQueue (line 69) | class LocalModelQueue {
    method constructor (line 85) | private constructor() {
    method getInstance (line 98) | static getInstance(): LocalModelQueue {
    method isEnabled (line 108) | static isEnabled(): boolean {
    method enqueue (line 126) | async enqueue(
    method processQueue (line 192) | private async processQueue(): Promise<void> {
    method executeRequest (line 219) | private async executeRequest(request: QueuedRequest): Promise<void> {
    method isOOMError (line 282) | private isOOMError(errorBody: string): boolean {
    method getMaxParallelFromEnv (line 301) | private getMaxParallelFromEnv(): number {
    method delay (line 322) | private delay(ms: number): Promise<void> {
    method getStats (line 329) | getStats(): QueueStats {

FILE: packages/cli/src/handlers/shared/openrouter-queue.ts
  type QueuedRequest (line 27) | interface QueuedRequest {
  type RateLimitState (line 36) | interface RateLimitState {
  type QueueStats (line 58) | interface QueueStats {
  class OpenRouterRequestQueue (line 83) | class OpenRouterRequestQueue {
    method constructor (line 108) | private constructor() {
    method getInstance (line 117) | static getInstance(): OpenRouterRequestQueue {
    method enqueue (line 131) | async enqueue(fetchFn: () => Promise<Response>): Promise<Response> {
    method processQueue (line 167) | private async processQueue(): Promise<void> {
    method waitForNextSlot (line 234) | private async waitForNextSlot(): Promise<void> {
    method calculateDelay (line 256) | private calculateDelay(): number {
    method parseRateLimitHeaders (line 323) | private parseRateLimitHeaders(response: Response): void {
    method handleRateLimitError (line 370) | private async handleRateLimitError(response: Response): Promise<void> {
    method handleSuccessResponse (line 419) | private handleSuccessResponse(): void {
    method getStats (line 444) | getStats(): QueueStats {

FILE: packages/cli/src/handlers/shared/remote-provider-types.ts
  type RemoteProviderConfig (line 11) | interface RemoteProviderConfig {
  type ModelPricing (line 27) | interface ModelPricing {
  type RemoteProvider (line 43) | interface RemoteProvider {
  type ResolvedRemoteProvider (line 59) | interface ResolvedRemoteProvider {
  constant PROVIDER_DEFAULTS (line 71) | const PROVIDER_DEFAULTS: Record<string, ModelPricing> = {
  constant FREE_PROVIDERS (line 81) | const FREE_PROVIDERS = new Set(["opencode-zen", "zen"]);
  constant SUBSCRIPTION_PROVIDERS (line 84) | const SUBSCRIPTION_PROVIDERS = new Set(["minimax-coding", "kimi-coding",...
  constant PROVIDER_ALIAS (line 87) | const PROVIDER_ALIAS: Record<string, string> = {
  function registerDynamicPricingLookup (line 110) | function registerDynamicPricingLookup(
  function getModelPricing (line 123) | function getModelPricing(provider: string, modelName: string): ModelPric...
  function calculateCost (line 152) | function calculateCost(

FILE: packages/cli/src/handlers/shared/stream-parsers/anthropic-sse.ts
  type AnthropicPassthroughOpts (line 16) | interface AnthropicPassthroughOpts {
  function createAnthropicPassthroughStream (line 31) | function createAnthropicPassthroughStream(

FILE: packages/cli/src/handlers/shared/stream-parsers/gemini-sse.ts
  type GeminiSseOptions (line 14) | interface GeminiSseOptions {
  function createGeminiSseStream (line 25) | function createGeminiSseStream(

FILE: packages/cli/src/handlers/shared/stream-parsers/ollama-jsonl.ts
  function createOllamaJsonlStream (line 15) | function createOllamaJsonlStream(

FILE: packages/cli/src/handlers/shared/stream-parsers/openai-responses-sse.ts
  function createResponsesStreamHandler (line 18) | function createResponsesStreamHandler(

FILE: packages/cli/src/handlers/shared/stream-parsers/openai-sse.ts
  type StreamingState (line 20) | interface StreamingState {
  type ToolState (line 34) | interface ToolState {
  function validateToolArguments (line 48) | function validateToolArguments(
  function createStreamingState (line 83) | function createStreamingState(): StreamingState {
  function createStreamingResponseHandler (line 102) | function createStreamingResponseHandler(
  function estimateTokens (line 704) | function estimateTokens(text: string): number {

FILE: packages/cli/src/handlers/shared/token-tracker.ts
  type TokenTrackerConfig (line 19) | interface TokenTrackerConfig {
  class TokenTracker (line 27) | class TokenTracker {
    method constructor (line 38) | constructor(port: number, config: TokenTrackerConfig) {
    method setActiveModelName (line 44) | setActiveModelName(name: string): void {
    method setProviderDisplayName (line 49) | setProviderDisplayName(name: string): void {
    method setQuotaRemaining (line 54) | setQuotaRemaining(fraction: number): void {
    method rewrite (line 59) | rewrite(): void {
    method update (line 67) | update(inputTokens: number, outputTokens: number): void {
    method accumulateBoth (line 84) | accumulateBoth(inputTokens: number, outputTokens: number): void {
    method updateWithDelta (line 105) | updateWithDelta(inputTokens: number, outputTokens: number): void {
    method updateWithActualCost (line 146) | updateWithActualCost(
    method updateLocal (line 171) | updateLocal(inputTokens: number, outputTokens: number): void {
    method setContextWindow (line 181) | setContextWindow(contextWindow: number): void {
    method getTotalCost (line 186) | getTotalCost(): number {
    method getInputTokens (line 191) | getInputTokens(): number {
    method getOutputTokens (line 196) | getOutputTokens(): number {
    method getPricing (line 200) | private getPricing(): ModelPricing {
    method getDisplayName (line 204) | private getDisplayName(): string {
    method writeFile (line 213) | private writeFile(inputTokens: number, outputTokens: number, isEstimat...

FILE: packages/cli/src/handlers/shared/tool-call-recovery.ts
  type ExtractedToolCall (line 13) | interface ExtractedToolCall {
  type ToolSchema (line 19) | interface ToolSchema {
  function extractToolCallsFromText (line 33) | function extractToolCallsFromText(text: string): ExtractedToolCall[] {
  function inferMissingParameters (line 313) | function inferMissingParameters(
  function generateRetryPrompt (line 499) | function generateRetryPrompt(
  function canRepairToolCall (line 530) | function canRepairToolCall(
  function getToolCallingGuidance (line 551) | function getToolCallingGuidance(): string {
  function validateAndRepairToolCall (line 579) | function validateAndRepairToolCall(

FILE: packages/cli/src/handlers/shared/web-search-detector.ts
  constant WEB_SEARCH_NAMES (line 9) | const WEB_SEARCH_NAMES = new Set([
  function isWebSearchToolCall (line 18) | function isWebSearchToolCall(toolName: string): boolean {
  function warnWebSearchUnsupported (line 25) | function warnWebSearchUnsupported(toolName: string, modelName: string): ...

FILE: packages/cli/src/handlers/types.ts
  type ModelHandler (line 3) | interface ModelHandler {

FILE: packages/cli/src/index.ts
  function loadStoredApiKeys (line 17) | function loadStoredApiKeys(): void {
  function handlePromptExit (line 51) | function handlePromptExit(err: unknown): void {
  function runCli (line 160) | async function runCli() {

FILE: packages/cli/src/logger.ts
  constant FLUSH_INTERVAL_MS (line 12) | const FLUSH_INTERVAL_MS = 100;
  constant MAX_BUFFER_SIZE (line 13) | const MAX_BUFFER_SIZE = 50;
  function flushLogBuffer (line 22) | function flushLogBuffer(): void {
  function flushAlwaysOnBuffer (line 39) | function flushAlwaysOnBuffer(): void {
  function scheduleFlush (line 49) | function scheduleFlush(): void {
  function rotateOldLogs (line 78) | function rotateOldLogs(dir: string, keep: number): void {
  function structuralRedact (line 97) | function structuralRedact(jsonStr: string): string {
  constant CONTENT_KEYS (line 108) | const CONTENT_KEYS = new Set([
  function redactDeep (line 118) | function redactDeep(val: any, key?: string): any {
  function isStructuralLogWorthy (line 144) | function isStructuralLogWorthy(msg: string): boolean {
  function redactLogLine (line 168) | function redactLogLine(message: string, timestamp: string): string {
  function initLogger (line 183) | function initLogger(
  function log (line 243) | function log(message: string, forceConsole = false): void {
  function logStderr (line 279) | function logStderr(message: string): void {
  function setDiagOutput (line 294) | function setDiagOutput(output: DiagOutput | null): void {
  function setStderrQuiet (line 303) | function setStderrQuiet(quiet: boolean): void {
  function getLogFilePath (line 310) | function getLogFilePath(): string | null {
  function getAlwaysOnLogPath (line 317) | function getAlwaysOnLogPath(): string | null {
  function isLoggingEnabled (line 324) | function isLoggingEnabled(): boolean {
  function maskCredential (line 332) | function maskCredential(credential: string): string {
  function setLogLevel (line 345) | function setLogLevel(level: "debug" | "info" | "minimal"): void {
  function getLogLevel (line 355) | function getLogLevel(): "debug" | "info" | "minimal" {
  function truncateContent (line 362) | function truncateContent(content: string | any, maxLength: number = 200)...
  function logStructured (line 375) | function logStructured(label: string, data: Record<string, any>): void {

FILE: packages/cli/src/mcp-server.ts
  constant CLAUDISH_CACHE_DIR (line 53) | const CLAUDISH_CACHE_DIR = join(homedir(), ".claudish");
  constant ALL_MODELS_CACHE_PATH (line 54) | const ALL_MODELS_CACHE_PATH = join(CLAUDISH_CACHE_DIR, "all-models.json");
  constant CACHE_MAX_AGE_DAYS (line 55) | const CACHE_MAX_AGE_DAYS = 2;
  constant INSTRUCTIONS (line 58) | const INSTRUCTIONS = `Claudish MCP server provides access to external AI...
  type ToolGroup (line 86) | type ToolGroup = "low-level" | "agentic" | "channel";
  type ToolDefinition (line 88) | interface ToolDefinition {
  function loadAllModels (line 105) | async function loadAllModels(forceRefresh = false): Promise<any[]> {
  function getProxy (line 148) | async function getProxy(): Promise<ProxyServer> {
  function parseAnthropicSse (line 171) | function parseAnthropicSse(raw: string): {
  function runPromptViaProxy (line 208) | async function runPromptViaProxy(
  function fuzzyScore (line 248) | function fuzzyScore(text: string, query: string): number {
  function formatTeamResult (line 264) | function formatTeamResult(
  function sanitize (line 304) | function sanitize(text: string | undefined): string {
  function defineTools (line 317) | function defineTools(sessionManager: SessionManager): ToolDefinition[] {
  function resolveToolGroups (line 1030) | function resolveToolGroups(mode: string): Set<ToolGroup> {
  function main (line 1046) | async function main() {
  function startMcpServer (line 1142) | function startMcpServer() {

FILE: packages/cli/src/middleware/gemini-thought-signature.ts
  class GeminiThoughtSignatureMiddleware (line 30) | class GeminiThoughtSignatureMiddleware implements ModelMiddleware {
    method shouldHandle (line 49) | shouldHandle(modelId: string): boolean {
    method onInit (line 53) | onInit(): void {
    method beforeRequest (line 66) | beforeRequest(context: RequestContext): void {
    method afterResponse (line 153) | afterResponse(context: NonStreamingResponseContext): void {
    method afterStreamChunk (line 192) | afterStreamChunk(context: StreamChunkContext): void {
    method afterStreamComplete (line 229) | afterStreamComplete(metadata: Map<string, any>): void {

FILE: packages/cli/src/middleware/manager.ts
  class MiddlewareManager (line 19) | class MiddlewareManager {
    method register (line 27) | register(middleware: ModelMiddleware): void {
    method initialize (line 42) | async initialize(): Promise<void> {
    method getActiveMiddlewares (line 69) | private getActiveMiddlewares(modelId: string): ModelMiddleware[] {
    method getActiveNames (line 77) | getActiveNames(modelId: string): string[] {
    method beforeRequest (line 84) | async beforeRequest(context: RequestContext): Promise<void> {
    method afterResponse (line 112) | async afterResponse(context: NonStreamingResponseContext): Promise<voi...
    method afterStreamChunk (line 140) | async afterStreamChunk(context: StreamChunkContext): Promise<void> {
    method afterStreamComplete (line 170) | async afterStreamComplete(modelId: string, metadata: Map<string, any>)...

FILE: packages/cli/src/middleware/types.ts
  type RequestContext (line 11) | interface RequestContext {
  type NonStreamingResponseContext (line 28) | interface NonStreamingResponseContext {
  type StreamChunkContext (line 39) | interface StreamChunkContext {
  type ModelMiddleware (line 62) | interface ModelMiddleware {

FILE: packages/cli/src/model-catalog.test.ts
  constant MINIMAX_API_KEY (line 21) | const MINIMAX_API_KEY = process.env.MINIMAX_CODING_API_KEY || process.en...
  constant SKIP_REAL_API (line 22) | const SKIP_REAL_API = !MINIMAX_API_KEY;
  constant MINIMAX_API_BASE (line 24) | const MINIMAX_API_BASE = "https://api.minimax.io/anthropic/v1/messages";
  function buildMinimaxPayload (line 366) | function buildMinimaxPayload(claudeRequest: any, modelId = "MiniMax-M2.7...

FILE: packages/cli/src/model-loader.ts
  type RecommendedModelEntry (line 20) | interface RecommendedModelEntry {
  type RecommendedModelsDoc (line 51) | interface RecommendedModelsDoc {
  type ModelDoc (line 63) | interface ModelDoc {
  type ModelMetadata (line 97) | interface ModelMetadata {
  constant FIREBASE_BASE_URL (line 112) | const FIREBASE_BASE_URL = "https://us-central1-claudish-6da10.cloudfunct...
  constant FIREBASE_RECOMMENDED_URL (line 113) | const FIREBASE_RECOMMENDED_URL = `${FIREBASE_BASE_URL}?catalog=recommend...
  constant RECOMMENDED_MODELS_CACHE_PATH (line 115) | const RECOMMENDED_MODELS_CACHE_PATH = join(
  constant RECOMMENDED_CACHE_MAX_AGE_HOURS (line 120) | const RECOMMENDED_CACHE_MAX_AGE_HOURS = 12;
  constant RECOMMENDED_FETCH_TIMEOUT_MS (line 121) | const RECOMMENDED_FETCH_TIMEOUT_MS = 5000;
  constant SEARCH_FETCH_TIMEOUT_MS (line 122) | const SEARCH_FETCH_TIMEOUT_MS = 10000;
  function getBundledRecommendedModelsPath (line 128) | function getBundledRecommendedModelsPath(): string {
  constant FIREBASE_SLUG_TO_PROVIDER_NAME (line 145) | const FIREBASE_SLUG_TO_PROVIDER_NAME: Record<string, string> = {
  type RecommendedModelGroup (line 161) | interface RecommendedModelGroup {
  function groupRecommendedModels (line 177) | function groupRecommendedModels(
  function collectRoutingPrefixes (line 215) | function collectRoutingPrefixes(
  function parsePriceAvg (line 237) | function parsePriceAvg(s?: string): number {
  function parseCtx (line 245) | function parseCtx(s?: string): number {
  function normalizePricingDisplay (line 259) | function normalizePricingDisplay(raw?: string): string {
  type QuickPicks (line 270) | interface QuickPicks {
  function computeQuickPicks (line 278) | function computeQuickPicks(primaries: RecommendedModelEntry[]): QuickPic...
  function getRecommendedModels (line 345) | async function getRecommendedModels(
  function getRecommendedModelsSync (line 408) | function getRecommendedModelsSync(): RecommendedModelsDoc {
  function warmRecommendedModels (line 432) | async function warmRecommendedModels(): Promise<RecommendedModelsDoc | n...
  function isFreshEnough (line 440) | function isFreshEnough(doc: RecommendedModelsDoc): boolean {
  function loadBundledRecommendedModels (line 447) | function loadBundledRecommendedModels(): RecommendedModelsDoc {
  function searchModels (line 470) | async function searchModels(query: string, limit = 50): Promise<ModelDoc...
  function searchModelsByProvider (line 488) | async function searchModelsByProvider(
  function getModelByIdFromFirebase (line 512) | async function getModelByIdFromFirebase(modelId: string): Promise<ModelD...
  type Top100Entry (line 535) | interface Top100Entry extends ModelDoc {
  type Top100Response (line 557) | interface Top100Response {
  function getTop100Models (line 578) | async function getTop100Models(): Promise<Top100Response> {
  type ProviderListEntry (line 597) | interface ProviderListEntry {
  function getProviderList (line 606) | async function getProviderList(): Promise<ProviderListEntry[]> {
  function getModelsByProvider (line 623) | async function getModelsByProvider(provider: string, limit = 200): Promi...
  function loadModelInfo (line 644) | function loadModelInfo(): Record<OpenRouterModel, ModelMetadata> {
  function getAvailableModels (line 676) | function getAvailableModels(): OpenRouterModel[] {
  type LiteLLMModel (line 694) | interface LiteLLMModel {
  type LiteLLMCache (line 707) | interface LiteLLMCache {
  constant LITELLM_CACHE_MAX_AGE_HOURS (line 712) | const LITELLM_CACHE_MAX_AGE_HOURS = 24;
  function fetchLiteLLMModels (line 717) | async function fetchLiteLLMModels(

FILE: packages/cli/src/model-selector.ts
  type ModelInfo (line 25) | interface ModelInfo {
  constant RECOMMENDED_PROVIDER_SOURCE_MAP (line 45) | const RECOMMENDED_PROVIDER_SOURCE_MAP: Record<
  constant RECOMMENDED_PROVIDER_LABEL_MAP (line 57) | const RECOMMENDED_PROVIDER_LABEL_MAP: Record<string, string> = {
  function getRecommendedModelSource (line 66) | function getRecommendedModelSource(provider: string): ModelInfo["source"] {
  function getRecommendedProviderLabel (line 70) | function getRecommendedProviderLabel(provider: string): string {
  function loadRecommendedModels (line 79) | async function loadRecommendedModels(forceRefresh = false): Promise<Mode...
  function parseContextString (line 102) | function parseContextString(ctx?: string): number {
  type PickerProvider (line 111) | interface PickerProvider {
  constant FIREBASE_PROVIDER_LABEL_MAP (line 117) | const FIREBASE_PROVIDER_LABEL_MAP: Record<string, string> = {
  function formatFirebaseProviderLabel (line 144) | function formatFirebaseProviderLabel(slug: string): string {
  function formatContextLength (line 160) | function formatContextLength(ctx?: number): string {
  function formatAveragePricing (line 166) | function formatAveragePricing(pricing?: ModelDoc["pricing"]): ModelInfo[...
  function modelDocToModelInfo (line 192) | function modelDocToModelInfo(model: ModelDoc): ModelInfo {
  function dedupeModels (line 212) | function dedupeModels(models: ModelInfo[]): ModelInfo[] {
  function buildPickerProviders (line 223) | function buildPickerProviders(entries: ProviderListEntry[]): PickerProvi...
  function buildPickerProvidersFromModels (line 231) | function buildPickerProvidersFromModels(models: ModelInfo[]): PickerProv...
  function matchesProvider (line 253) | function matchesProvider(model: ModelInfo, providerSlug: string): boolean {
  function filterModelsLocally (line 257) | function filterModelsLocally(
  function getXAIContextWindow (line 287) | function getXAIContextWindow(modelId: string): { context: string; contex...
  function fetchXAIModels (line 314) | async function fetchXAIModels(): Promise<ModelInfo[]> {
  function getGeminiPricing (line 379) | function getGeminiPricing(modelId: string): { input: string; output: str...
  function fetchGeminiModels (line 434) | async function fetchGeminiModels(): Promise<ModelInfo[]> {
  function getFreeModels (line 492) | async function getFreeModels(): Promise<ModelInfo[]> {
  function getAllModelsForSearch (line 501) | async function getAllModelsForSearch(forceUpdate = false): Promise<Model...
  function formatModelChoice (line 594) | function formatModelChoice(model: ModelInfo, showSource = false): string {
  constant PROVIDER_FILTER_ALIASES (line 637) | const PROVIDER_FILTER_ALIASES: Record<string, string> = {
  function parseProviderFilter (line 679) | function parseProviderFilter(
  function fuzzyMatch (line 737) | function fuzzyMatch(text: string, query: string): number {
  type ModelSelectorOptions (line 768) | interface ModelSelectorOptions {
  function selectModel (line 778) | async function selectModel(options: ModelSelectorOptions = {}): Promise<...
  constant ALL_PROVIDER_CHOICES (line 944) | const ALL_PROVIDER_CHOICES: Array<{
  function getProviderChoices (line 1028) | function getProviderChoices() {
  constant PROVIDER_MODEL_PREFIX (line 1039) | const PROVIDER_MODEL_PREFIX: Record<string, string> = {
  constant PROVIDER_SOURCE_FILTER (line 1061) | const PROVIDER_SOURCE_FILTER: Record<string, string> = {
  function getKnownModels (line 1081) | function getKnownModels(provider: string): ModelInfo[] {
  function filterModelsByProvider (line 1267) | function filterModelsByProvider(allModels: ModelInfo[], provider: string...
  function selectModelFromProvider (line 1284) | async function selectModelFromProvider(
  function selectModelsForProfile (line 1403) | async function selectModelsForProfile(): Promise<{
  function promptForApiKey (line 1468) | async function promptForApiKey(): Promise<string> {
  function promptForProfileName (line 1491) | async function promptForProfileName(existing: string[] = []): Promise<st...
  function promptForProfileDescription (line 1515) | async function promptForProfileDescription(): Promise<string> {
  function selectProfile (line 1526) | async function selectProfile(
  function confirmAction (line 1544) | async function confirmAction(message: string): Promise<boolean> {

FILE: packages/cli/src/port-manager.ts
  function findAvailablePort (line 7) | async function findAvailablePort(startPort = 3000, endPort = 9000): Prom...
  function isPortAvailable (line 28) | async function isPortAvailable(port: number): Promise<boolean> {

FILE: packages/cli/src/probe/probe-results-printer.ts
  constant ANSI_RE (line 39) | const ANSI_RE = /\x1b\[[0-9;]*[A-Za-z]/g;
  function stripAnsi (line 41) | function stripAnsi(s: string): string {
  function visibleLength (line 46) | function visibleLength(s: string): number {
  function padVisible (line 51) | function padVisible(
  function truncate (line 63) | function truncate(s: string, max: number): string {
  function wordWrap (line 71) | function wordWrap(text: string, maxWidth: number): string[] {
  type ChainEntry (line 104) | interface ChainEntry {
  type WiringInfo (line 114) | interface WiringInfo {
  type ModelResult (line 124) | interface ModelResult {
  type Writer (line 135) | type Writer = (s: string) => boolean;
  constant MIN_CARD_WIDTH (line 137) | const MIN_CARD_WIDTH = 60;
  constant CARD_PADDING_LEFT (line 138) | const CARD_PADDING_LEFT = 2;
  constant CARD_PADDING_RIGHT (line 139) | const CARD_PADDING_RIGHT = 2;
  function summaryColor (line 141) | function summaryColor(live: number, total: number): string {
  function statusColor (line 147) | function statusColor(state: string): string {
  function shortStatusLabel (line 153) | function shortStatusLabel(probe: ProbeResult | undefined, hasCreds: bool...
  function renderBorderTop (line 181) | function renderBorderTop(title: string, summary: string, width: number):...
  function renderBorderBottom (line 202) | function renderBorderBottom(width: number): string {
  function renderBlankLine (line 206) | function renderBlankLine(width: number): string {
  function renderTextLine (line 217) | function renderTextLine(body: string, width: number, bg?: string): string {
  function renderRow (line 244) | function renderRow(
  function renderSepRow (line 298) | function renderSepRow(widths: number[], width: number): string {
  type RowData (line 326) | interface RowData {
  function buildRowData (line 338) | function buildRowData(result: ModelResult, isLiveProbe: boolean): RowDat...
  function buildDirectRowData (line 390) | function buildDirectRowData(result: ModelResult): RowData[] {
  function computeColumnWidths (line 416) | function computeColumnWidths(rows: RowData[]): number[] {
  function computeCardWidth (line 431) | function computeCardWidth(
  function formatContextWindow (line 461) | function formatContextWindow(ctx: number): string {
  function buildKeyLine (line 467) | function buildKeyLine(activeEntry?: ChainEntry, directKeyVar?: string): ...
  function buildWireLine (line 482) | function buildWireLine(wiring: WiringInfo, activeProvider?: string): str...
  type CardLayout (line 493) | interface CardLayout {
  function buildCardLayout (line 504) | function buildCardLayout(
  function computeRequiredWidth (line 562) | function computeRequiredWidth(
  function renderCard (line 577) | function renderCard(
  function printProbeResults (line 686) | function printProbeResults(

FILE: packages/cli/src/probe/probe-tui-app.tsx
  type ProbeStepState (line 19) | interface ProbeStepState {
  type ProbeLinkState (line 24) | interface ProbeLinkState {
  type ProbeAppState (line 38) | interface ProbeAppState {
  class ProbeStore (line 49) | class ProbeStore {
    method constructor (line 53) | constructor(initial: ProbeAppState) {
    method getState (line 57) | getState(): ProbeAppState {
    method setState (line 61) | setState(updater: (prev: ProbeAppState) => ProbeAppState): void {
    method subscribe (line 66) | subscribe(fn: () => void): () => void {
  function useProbeStore (line 74) | function useProbeStore(store: ProbeStore): ProbeAppState {
  function useAnimationFrame (line 81) | function useAnimationFrame(active: boolean): number {
  constant ANIM_FRAMES (line 93) | const ANIM_FRAMES = ["\u2593", "\u2592", "\u2591", "\u2592"];
  constant BAR_WIDTH (line 94) | const BAR_WIDTH = 20;
  function formatElapsed (line 96) | function formatElapsed(ms: number): string {
  function padEndSafe (line 103) | function padEndSafe(s: string, n: number): string {
  function stripAnsi (line 108) | function stripAnsi(text: string): string {
  function Banner (line 114) | function Banner() {
  function StepIndicator (line 182) | function StepIndicator({ step }: { step: ProbeStepState }) {
  function ProgressBar (line 207) | function ProgressBar({
  function ModelGroup (line 280) | function ModelGroup({
  function ProbeApp (line 330) | function ProbeApp({ store }: { store: ProbeStore }) {

FILE: packages/cli/src/probe/probe-tui-runtime.tsx
  type ProbeRuntime (line 13) | interface ProbeRuntime {
  function startProbeTui (line 18) | async function startProbeTui(

FILE: packages/cli/src/profile-commands.ts
  constant RESET (line 46) | const RESET = "\x1b[0m";
  constant BOLD (line 47) | const BOLD = "\x1b[1m";
  constant DIM (line 48) | const DIM = "\x1b[2m";
  constant GREEN (line 49) | const GREEN = "\x1b[32m";
  constant YELLOW (line 50) | const YELLOW = "\x1b[33m";
  constant CYAN (line 51) | const CYAN = "\x1b[36m";
  constant MAGENTA (line 52) | const MAGENTA = "\x1b[35m";
  function parseScopeFlag (line 59) | function parseScopeFlag(args: string[]): {
  function resolveScope (line 82) | async function resolveScope(scopeFlag: ProfileScope | undefined): Promis...
  function scopeBadge (line 107) | function scopeBadge(scope: ProfileScope, shadowed?: boolean): string {
  function initCommand (line 123) | async function initCommand(scopeFlag?: ProfileScope): Promise<void> {
  function profileListCommand (line 177) | async function profileListCommand(scopeFilter?: ProfileScope): Promise<v...
  function profileAddCommand (line 212) | async function profileAddCommand(scopeFlag?: ProfileScope): Promise<void> {
  function profileRemoveCommand (line 242) | async function profileRemoveCommand(name?: string, scopeFlag?: ProfileSc...
  function profileUseCommand (line 328) | async function profileUseCommand(name?: string, scopeFlag?: ProfileScope...
  function profileShowCommand (line 394) | async function profileShowCommand(name?: string, scopeFlag?: ProfileScop...
  function profileEditCommand (line 447) | async function profileEditCommand(name?: string, scopeFlag?: ProfileScop...
  function printProfile (line 559) | function printProfile(
  function printProfileWithScope (line 584) | function printProfileWithScope(profile: ProfileWithScope): void {
  function printModelMapping (line 603) | function printModelMapping(models: ModelMapping): void {
  function profileCommand (line 617) | async function profileCommand(args: string[]): Promise<void> {
  function printProfileHelp (line 658) | function printProfileHelp(): void {

FILE: packages/cli/src/profile-config.ts
  constant CONFIG_DIR (line 17) | const CONFIG_DIR = join(homedir(), ".claudish");
  constant CONFIG_FILE (line 18) | const CONFIG_FILE = join(CONFIG_DIR, "config.json");
  constant LOCAL_CONFIG_FILENAME (line 19) | const LOCAL_CONFIG_FILENAME = ".claudish.json";
  type ProfileScope (line 21) | type ProfileScope = "local" | "global";
  type ModelMapping (line 27) | interface ModelMapping {
  type Profile (line 37) | interface Profile {
  type ProfileWithScope (line 48) | interface ProfileWithScope extends Profile {
  type RoutingEntry (line 58) | type RoutingEntry = string;
  type RoutingRules (line 65) | type RoutingRules = Record<string, RoutingEntry[]>;
  type TelemetryConsent (line 72) | interface TelemetryConsent {
  type StatsConsent (line 91) | interface StatsConsent {
  type ClaudishProfileConfig (line 107) | interface ClaudishProfileConfig {
  constant DEFAULT_CONFIG (line 150) | const DEFAULT_CONFIG: ClaudishProfileConfig = {
  function ensureConfigDir (line 169) | function ensureConfigDir(): void {
  function loadConfig (line 179) | function loadConfig(): ClaudishProfileConfig {
  function saveConfig (line 233) | function saveConfig(config: ClaudishProfileConfig): void {
  function configExists (line 241) | function configExists(): boolean {
  function getConfigPath (line 248) | function getConfigPath(): string {
  function getLocalConfigPath (line 257) | function getLocalConfigPath(): string {
  function localConfigExists (line 264) | function localConfigExists(): boolean {
  function isProjectDirectory (line 271) | function isProjectDirectory(): boolean {
  function loadLocalConfig (line 282) | function loadLocalConfig(): ClaudishProfileConfig | null {
  function saveLocalConfig (line 312) | function saveLocalConfig(config: ClaudishProfileConfig): void {
  function loadConfigForScope (line 318) | function loadConfigForScope(scope: ProfileScope): ClaudishProfileConfig {
  function saveConfigForScope (line 325) | function saveConfigForScope(config: ClaudishProfileConfig, scope: Profil...
  function configExistsForScope (line 336) | function configExistsForScope(scope: ProfileScope): boolean {
  function getConfigPathForScope (line 346) | function getConfigPathForScope(scope: ProfileScope): string {
  function getProfile (line 359) | function getProfile(name: string, scope?: ProfileScope): Profile | undef...
  function getDefaultProfile (line 385) | function getDefaultProfile(scope?: ProfileScope): Profile {
  function getProfileNames (line 426) | function getProfileNames(scope?: ProfileScope): string[] {
  function setProfile (line 449) | function setProfile(profile: Profile, scope: ProfileScope = "global"): v...
  function deleteProfile (line 469) | function deleteProfile(name: string, scope: ProfileScope = "global"): bo...
  function setDefaultProfile (line 499) | function setDefaultProfile(name: string, scope: ProfileScope = "global")...
  function getModelMapping (line 515) | function getModelMapping(profileName?: string): ModelMapping {
  function createProfile (line 528) | function createProfile(
  function listProfiles (line 550) | function listProfiles(): Profile[] {
  function listAllProfiles (line 561) | function listAllProfiles(): ProfileWithScope[] {
  function getApiKey (line 597) | function getApiKey(envVar: string): string | undefined {
  function setApiKey (line 605) | function setApiKey(envVar: string, value: string): void {
  function removeApiKey (line 615) | function removeApiKey(envVar: string): void {
  function getEndpoint (line 628) | function getEndpoint(name: string): string | undefined {
  function setEndpoint (line 636) | function setEndpoint(name: string, value: string): void {
  function removeEndpoint (line 646) | function removeEndpoint(name: string): void {

FILE: packages/cli/src/providers/all-models-cache.test.ts
  function makeTmpCachePath (line 25) | function makeTmpCachePath(): { path: string; dir: string; cleanup: () =>...

FILE: packages/cli/src/providers/all-models-cache.ts
  type SlimModelEntry (line 27) | interface SlimModelEntry {
  type DiskCacheV2 (line 38) | interface DiskCacheV2 {
  constant ALL_MODELS_CACHE_PATH (line 46) | const ALL_MODELS_CACHE_PATH = join(homedir(), ".claudish", "all-models.j...
  function readAllModelsCache (line 59) | function readAllModelsCache(path: string = ALL_MODELS_CACHE_PATH): DiskC...
  function writeAllModelsCache (line 98) | function writeAllModelsCache(

FILE: packages/cli/src/providers/api-key-map.ts
  constant API_KEY_MAP (line 5) | const API_KEY_MAP: Record<string, { envVar: string; aliases?: string[] }...

FILE: packages/cli/src/providers/api-key-provenance.ts
  type KeyLayer (line 19) | interface KeyLayer {
  type KeyProvenance (line 25) | interface KeyProvenance {
  function maskKey (line 33) | function maskKey(key: string | undefined | null): string | null {
  function resolveApiKeyProvenance (line 45) | function resolveApiKeyProvenance(envVar: string, aliases?: string[]): Ke...
  function formatProvenanceLog (line 117) | function formatProvenanceLog(p: KeyProvenance): string {
  function formatProvenanceProbe (line 127) | function formatProvenanceProbe(p: KeyProvenance, indent: string = "    "...
  function readDotenvKey (line 150) | function readDotenvKey(envVars: string[]): string | null {
  function readConfigKey (line 164) | function readConfigKey(envVar: string): string | null {

FILE: packages/cli/src/providers/auto-route.ts
  type AutoRouteResult (line 10) | interface AutoRouteResult {
  type AutoRouteReason (line 18) | type AutoRouteReason =
  function readLiteLLMCacheSync (line 25) | function readLiteLLMCacheSync(baseUrl: string): Array<{ id: string; name...
  function checkOAuthForProvider (line 40) | function checkOAuthForProvider(nativeProvider: string, modelName: string...
  function checkApiKeyForProvider (line 52) | function checkApiKeyForProvider(nativeProvider: string, modelName: strin...
  type ProviderHintInfo (line 86) | interface ProviderHintInfo {
  constant PROVIDER_HINT_MAP (line 93) | const PROVIDER_HINT_MAP: Record<string, ProviderHintInfo> = {
  function getAutoRouteHint (line 117) | function getAutoRouteHint(modelName: string, nativeProvider: string): st...
  function autoRoute (line 148) | function autoRoute(modelName: string, nativeProvider: string): AutoRoute...
  type FallbackRoute (line 203) | interface FallbackRoute {
  constant PROVIDER_TO_PREFIX (line 220) | const PROVIDER_TO_PREFIX: Record<string, string> = (() => {
  constant DISPLAY_NAMES (line 231) | const DISPLAY_NAMES: Record<string, string> = (() => {
  type SubscriptionAlternative (line 249) | interface SubscriptionAlternative {
  constant SUBSCRIPTION_ALTERNATIVES (line 256) | const SUBSCRIPTION_ALTERNATIVES: Record<string, SubscriptionAlternative>...
  function readZenModelCacheSync (line 298) | function readZenModelCacheSync(): Set<string> | null {
  function isZenCompatibleModel (line 315) | function isZenCompatibleModel(modelName: string): boolean {
  function warmZenModelCache (line 325) | async function warmZenModelCache(): Promise<void> {
  function readZenGoModelCacheSync (line 351) | function readZenGoModelCacheSync(): Set<string> | null {
  function isZenGoCompatibleModel (line 368) | function isZenGoCompatibleModel(modelName: string): boolean {
  function warmZenGoModelCache (line 379) | async function warmZenGoModelCache(): Promise<void> {
  function hasProviderCredentials (line 401) | function hasProviderCredentials(provider: string): boolean {
  function getDefaultProviderRoute (line 418) | function getDefaultProviderRoute(
  function getFallbackChain (line 473) | function getFallbackChain(

FILE: packages/cli/src/providers/catalog-resolvers/litellm.ts
  function getCachePath (line 13) | function getCachePath(): string | null {
  class LiteLLMCatalogResolver (line 31) | class LiteLLMCatalogResolver implements ModelCatalogResolver {
    method resolveSync (line 34) | resolveSync(userInput: string): string | null {
    method warmCache (line 60) | async warmCache(): Promise<void> {
    method isCacheWarm (line 76) | isCacheWarm(): boolean {
    method ensureReady (line 80) | async ensureReady(_timeoutMs: number): Promise<void> {
    method _getModelIds (line 86) | private _getModelIds(): string[] | null {

FILE: packages/cli/src/providers/catalog-resolvers/openrouter.test.ts
  function entry (line 14) | function entry(
  constant SAMPLE_CATALOG (line 23) | const SAMPLE_CATALOG = [
  function createResolverWithCache (line 55) | function createResolverWithCache(data: typeof SAMPLE_CATALOG): OpenRoute...

FILE: packages/cli/src/providers/catalog-resolvers/openrouter.ts
  constant FIREBASE_CATALOG_URL (line 10) | const FIREBASE_CATALOG_URL =
  type DiskCache (line 14) | type DiskCache = DiskCacheV2;
  class OpenRouterCatalogResolver (line 37) | class OpenRouterCatalogResolver implements ModelCatalogResolver {
    method resolveSync (line 40) | resolveSync(userInput: string): string | null {
    method warmCache (line 99) | async warmCache(): Promise<void> {
    method isCacheWarm (line 106) | isCacheWarm(): boolean {
    method ensureReady (line 110) | async ensureReady(timeoutMs: number): Promise<void> {
    method _getOpenRouterExternalId (line 129) | private _getOpenRouterExternalId(entry: SlimModelEntry): string | null {
    method _getEntries (line 142) | private _getEntries(): SlimModelEntry[] | null {
    method _fetchAndCache (line 167) | private async _fetchAndCache(): Promise<void> {

FILE: packages/cli/src/providers/catalog-resolvers/static-fallback.ts
  constant OPENROUTER_VENDOR_MAP (line 6) | const OPENROUTER_VENDOR_MAP: Record<string, string> = {
  function staticOpenRouterFallback (line 33) | function staticOpenRouterFallback(userInput: string): string | null {

FILE: packages/cli/src/providers/custom-endpoints-loader.test.ts
  function makeConfig (line 18) | function makeConfig(

FILE: packages/cli/src/providers/custom-endpoints-loader.ts
  type LoadResult (line 47) | interface LoadResult {
  function loadCustomEndpoints (line 58) | function loadCustomEndpoints(config: ClaudishProfileConfig): LoadResult {
  function buildProviderDefinition (line 90) | function buildProviderDefinition(
  function buildProviderProfile (line 136) | function buildProviderProfile(ep: CustomEndpoint): ProviderProfile {
  function buildSimpleHandler (line 148) | function buildSimpleHandler(
  function buildComplexHandler (line 193) | function buildComplexHandler(
  function resolveCustomEndpointApiKey (line 266) | function resolveCustomEndpointApiKey(ep: CustomEndpoint): string {
  function stripTrailingSlash (line 273) | function stripTrailingSlash(url: string): string {
  function sanitizeEnvName (line 277) | function sanitizeEnvName(name: string): string {

FILE: packages/cli/src/providers/model-catalog-resolver.ts
  type ModelCatalogResolver (line 22) | interface ModelCatalogResolver {
  type ModelResolutionResult (line 63) | interface ModelResolutionResult {
  constant RESOLVER_REGISTRY (line 76) | const RESOLVER_REGISTRY = new Map<string, ModelCatalogResolver>();
  function registerResolver (line 78) | function registerResolver(resolver: ModelCatalogResolver): void {
  function getResolver (line 82) | function getResolver(provider: string): ModelCatalogResolver | null {
  function resolveModelNameSync (line 97) | function resolveModelNameSync(
  function logResolution (line 127) | function logResolution(
  function ensureCatalogReady (line 146) | async function ensureCatalogReady(
  function warmAllCatalogs (line 161) | async function warmAllCatalogs(providers?: string[]): Promise<void> {

FILE: packages/cli/src/providers/model-parser.ts
  type ParsedModel (line 48) | interface ParsedModel {
  constant PROVIDER_SHORTCUTS (line 75) | const PROVIDER_SHORTCUTS: Record<string, string> = _getShortcuts();
  constant LOCAL_PROVIDERS (line 80) | const LOCAL_PROVIDERS = {
  method has (line 81) | has(name: string): boolean {
  constant DIRECT_API_PROVIDERS (line 89) | const DIRECT_API_PROVIDERS = {
  method has (line 90) | has(name: string): boolean {
  constant NATIVE_MODEL_PATTERNS (line 98) | const NATIVE_MODEL_PATTERNS = _getNativeModelPatterns();
  constant LEGACY_PREFIX_PATTERNS (line 103) | const LEGACY_PREFIX_PATTERNS = _getLegacyPrefixPatterns();
  function parseModelSpec (line 115) | function parseModelSpec(modelSpec: string): ParsedModel {
  function isLocalProviderName (line 226) | function isLocalProviderName(provider: string): boolean {
  function isDirectApiProvider (line 233) | function isDirectApiProvider(provider: string): boolean {
  function getLegacySyntaxWarning (line 240) | function getLegacySyntaxWarning(parsed: ParsedModel): string | null {
  function formatModelSpec (line 255) | function formatModelSpec(provider: string, model: string, concurrency?: ...

FILE: packages/cli/src/providers/probe-live.ts
  type ProbeState (line 15) | type ProbeState =
  type ProbeResult (line 26) | interface ProbeResult {
  constant OAUTH_PROVIDERS (line 42) | const OAUTH_PROVIDERS = new Set(["vertex", "gemini-codeassist"]);
  constant PROBE_PROMPT (line 43) | const PROBE_PROMPT = "ping";
  constant PROBE_MAX_TOKENS (line 44) | const PROBE_MAX_TOKENS = 1;
  type ProbeLinkInput (line 46) | interface ProbeLinkInput {
  function probeLink (line 53) | async function probeLink(
  function annotateOAuthHint (line 124) | function annotateOAuthHint(
  function safeReadBody (line 153) | async function safeReadBody(response: Response): Promise<string> {
  function classifyHttpError (line 162) | function classifyHttpError(
  function extractErrorMessage (line 208) | function extractErrorMessage(body: string): string | undefined {
  function consumeProbeStream (line 233) | async function consumeProbeStream(
  type SseVerdict (line 289) | type SseVerdict = "live" | Omit<ProbeResult, "latencyMs"> | null;
  function interpretSseEvent (line 291) | function interpretSseEvent(rawEvent: string): SseVerdict {
  function isContentEvent (line 332) | function isContentEvent(parsed: any, eventType: string): boolean {
  function describeProbeState (line 347) | function describeProbeState(result: ProbeResult): string {
  function isReadyState (line 372) | function isReadyState(state: ProbeState): boolean {
  function isFailureState (line 376) | function isFailureState(state: ProbeState): boolean {

FILE: packages/cli/src/providers/provider-definitions.ts
  type TransportType (line 22) | type TransportType =
  type TokenStrategy (line 36) | type TokenStrategy = "delta-aware" | "accumulate-both" | undefined;
  type ProviderCapabilities (line 38) | interface ProviderCapabilities {
  type ProviderDefinition (line 46) | interface ProviderDefinition {
  constant BUILTIN_PROVIDERS (line 99) | const BUILTIN_PROVIDERS: ProviderDefinition[] = [
  function ensureProviderByNameCache (line 664) | function ensureProviderByNameCache(): Map<string, ProviderDefinition> {
  function getShortcuts (line 682) | function getShortcuts(): Record<string, string> {
  function getLegacyPrefixPatterns (line 706) | function getLegacyPrefixPatterns(): Array<{
  function getNativeModelPatterns (line 734) | function getNativeModelPatterns(): Array<{ pattern: RegExp; provider: st...
  function getProviderByName (line 756) | function getProviderByName(name: string): ProviderDefinition | undefined {
  function getApiKeyInfo (line 766) | function getApiKeyInfo(providerName: string): {
  function getDisplayName (line 788) | function getDisplayName(providerName: string): string {
  function getEffectiveBaseUrl (line 796) | function getEffectiveBaseUrl(def: ProviderDefinition): string {
  function isLocalTransport (line 810) | function isLocalTransport(providerName: string): boolean {
  function isDirectApiProvider (line 830) | function isDirectApiProvider(providerName: string): boolean {
  function toRemoteProvider (line 849) | function toRemoteProvider(def: ProviderDefinition): RemoteProvider {
  function getAllProviders (line 879) | function getAllProviders(): ProviderDefinition[] {
  function getShortestPrefix (line 889) | function getShortestPrefix(providerName: string): string {
  function getApiKeyEnvVars (line 898) | function getApiKeyEnvVars(
  function isProviderAvailable (line 921) | function isProviderAvailable(def: ProviderDefinition): boolean {
  function isProviderAvailableByName (line 956) | function isProviderAvailableByName(providerName: string): boolean {

FILE: packages/cli/src/providers/provider-profiles.ts
  type BaseModelAdapter (line 21) | type BaseModelAdapter = BaseAPIFormat;
  type ProfileContext (line 54) | interface ProfileContext {
  type ProviderProfile (line 75) | interface ProviderProfile {
  method createHandler (line 90) | createHandler(ctx) {
  method createHandler (line 103) | createHandler(ctx) {
  method createHandler (line 117) | createHandler(ctx) {
  method createHandler (line 134) | createHandler(ctx) {
  method createHandler (line 149) | createHandler(ctx) {
  method createHandler (line 163) | createHandler(ctx) {
  method createHandler (line 190) | createHandler(ctx) {
  method createHandler (line 236) | createHandler(ctx) {
  method createHandler (line 250) | createHandler(ctx) {
  method createHandler (line 280) | createHandler(ctx) {
  constant PROVIDER_PROFILES (line 351) | const PROVIDER_PROFILES: Record<string, ProviderProfile> = {
  function createHandlerForProvider (line 382) | function createHandlerForProvider(ctx: ProfileContext): ModelHandler | n...

FILE: packages/cli/src/providers/provider-registry.ts
  type LocalProvider (line 13) | interface LocalProvider {
  type ResolvedProvider (line 21) | interface ResolvedProvider {
  type UrlParsedModel (line 28) | interface UrlParsedModel {
  function getRegisteredProviders (line 68) | function getRegisteredProviders(): LocalProvider[] {
  function resolveProvider (line 77) | function resolveProvider(modelId: string): ResolvedProvider | null {
  function isLocalProvider (line 127) | function isLocalProvider(modelId: string): boolean {
  function parseUrlModel (line 151) | function parseUrlModel(modelId: string): UrlParsedModel | null {
  function createUrlProvider (line 191) | function createUrlProvider(parsed: UrlParsedModel): LocalProvider {

FILE: packages/cli/src/providers/provider-resolver.ts
  type ProviderCategory (line 48) | type ProviderCategory =
  type ProviderResolution (line 58) | interface ProviderResolution {
  type ApiKeyInfo (line 92) | interface ApiKeyInfo {
  function getApiKeyInfoForProvider (line 104) | function getApiKeyInfoForProvider(providerName: string): ApiKeyInfo {
  constant API_KEY_INFO (line 125) | const API_KEY_INFO = new Proxy<Record<string, ApiKeyInfo>>(
  method get (line 128) | get(_target, prop: string) {
  method has (line 131) | has() {
  constant PROVIDER_DISPLAY_NAMES (line 140) | const PROVIDER_DISPLAY_NAMES = new Proxy<Record<string, string>>(
  method get (line 143) | get(_target, prop: string) {
  function isApiKeyAvailable (line 154) | function isApiKeyAvailable(info: ApiKeyInfo): boolean {
  function resolveModelProvider (line 208) | function resolveModelProvider(modelId: string | undefined): ProviderReso...
  function validateApiKeysForModels (line 424) | function validateApiKeysForModels(models: (string | undefined)[]): Provi...
  function getMissingKeyResolutions (line 434) | function getMissingKeyResolutions(resolutions: ProviderResolution[]): Pr...
  function getMissingKeyError (line 444) | function getMissingKeyError(resolution: ProviderResolution): string {
  function getMissingKeysError (line 533) | function getMissingKeysError(resolutions: ProviderResolution[]): string {
  function requiresOpenRouterKey (line 578) | function requiresOpenRouterKey(modelId: string | undefined): boolean {
  function isLocalModel (line 592) | function isLocalModel(modelId: string | undefined): boolean {

FILE: packages/cli/src/providers/remote-provider-registry.ts
  function resolveRemoteProvider (line 54) | function resolveRemoteProvider(modelId: string): ResolvedRemoteProvider ...
  function hasRemoteProviderPrefix (line 101) | function hasRemoteProviderPrefix(modelId: string): boolean {
  function getRemoteProviderType (line 109) | function getRemoteProviderType(modelId: string): string | null {
  function validateRemoteProviderApiKey (line 118) | function validateRemoteProviderApiKey(provider: RemoteProvider): string ...
  function getRegisteredRemoteProviders (line 157) | function getRegisteredRemoteProviders(): RemoteProvider[] {

FILE: packages/cli/src/providers/routing-rules.ts
  function loadRoutingRules (line 13) | function loadRoutingRules(): RoutingRules | null {
  function validateRoutingRules (line 28) | function validateRoutingRules(rules: RoutingRules): void {
  function matchRoutingRule (line 50) | function matchRoutingRule(modelName: string, rules: RoutingRules): Routi...
  function buildRoutingChain (line 74) | function buildRoutingChain(
  function globMatch (line 114) | function globMatch(pattern: string, value: string): boolean {

FILE: packages/cli/src/providers/runtime-providers.test.ts
  function makeDef (line 16) | function makeDef(name: string, overrides: Partial<ProviderDefinition> = ...
  function makeProfile (line 32) | function makeProfile(): ProviderProfile {

FILE: packages/cli/src/providers/runtime-providers.ts
  function registerRuntimeProvider (line 25) | function registerRuntimeProvider(def: ProviderDefinition): void {
  function registerRuntimeProfile (line 32) | function registerRuntimeProfile(name: string, profile: ProviderProfile):...
  function getRuntimeProviders (line 40) | function getRuntimeProviders(): ReadonlyMap<string, ProviderDefinition> {
  function getRuntimeProfiles (line 48) | function getRuntimeProfiles(): ReadonlyMap<string, ProviderProfile> {
  function clearRuntimeRegistry (line 56) | function clearRuntimeRegistry(): void {

FILE: packages/cli/src/providers/transport/anthropic-compat.test.ts
  constant TEST_API_KEY (line 19) | const TEST_API_KEY = "test-key-abc123";

FILE: packages/cli/src/providers/transport/anthropic-compat.ts
  class AnthropicProviderTransport (line 17) | class AnthropicProviderTransport implements ProviderTransport {
    method constructor (line 25) | constructor(provider: RemoteProvider, apiKey: string) {
    method getEndpoint (line 32) | getEndpoint(): string {
    method getHeaders (line 36) | async getHeaders(): Promise<Record<string, string>> {
    method formatDisplayName (line 79) | private static formatDisplayName(name: string): string {

FILE: packages/cli/src/providers/transport/gemini-apikey.ts
  class GeminiProviderTransport (line 16) | class GeminiProviderTransport implements ProviderTransport {
    method constructor (line 25) | constructor(provider: RemoteProvider, modelName: string, apiKey: strin...
    method getEndpoint (line 31) | getEndpoint(_model?: string): string {
    method getHeaders (line 36) | async getHeaders(): Promise<Record<string, string>> {
    method enqueueRequest (line 46) | async enqueueRequest(fetchFn: () => Promise<Response>): Promise<Respon...

FILE: packages/cli/src/providers/transport/gemini-codeassist.ts
  constant CODE_ASSIST_BASE (line 25) | const CODE_ASSIST_BASE = "https://cloudcode-pa.googleapis.com";
  constant CODE_ASSIST_ENDPOINT (line 26) | const CODE_ASSIST_ENDPOINT = `${CODE_ASSIST_BASE}/v1internal:streamGener...
  constant CODE_ASSIST_FALLBACK_CHAIN (line 32) | const CODE_ASSIST_FALLBACK_CHAIN = [
  constant MAX_RETRY_ATTEMPTS (line 41) | const MAX_RETRY_ATTEMPTS = 3;
  constant DEFAULT_RATE_LIMIT_DELAY_MS (line 43) | const DEFAULT_RATE_LIMIT_DELAY_MS = 10_000;
  function buildGeminiCliUserAgent (line 49) | function buildGeminiCliUserAgent(model?: string): string {
  function createActivityRequestId (line 56) | function createActivityRequestId(): string {
  type QuotaClassification (line 61) | interface QuotaClassification {
  function classify429 (line 77) | function classify429(responseBody: string): QuotaClassification | null {
  function parseRetryDelay (line 141) | function parseRetryDelay(value: any): number | undefined {
  class GeminiCodeAssistProviderTransport (line 156) | class GeminiCodeAssistProviderTransport implements ProviderTransport {
    method displayName (line 159) | get displayName(): string {
    method constructor (line 178) | constructor(modelName: string) {
    method getActiveModelName (line 186) | getActiveModelName(): string | undefined {
    method getEndpoint (line 190) | getEndpoint(): string {
    method getHeaders (line 194) | async getHeaders(): Promise<Record<string, string>> {
    method refreshAuth (line 206) | async refreshAuth(): Promise<void> {
    method transformPayload (line 224) | transformPayload(payload: any): any {
    method buildEnvelope (line 233) | private buildEnvelope(innerPayload: any, model: string): any {
    method enqueueRequest (line 256) | async enqueueRequest(fetchFn: () => Promise<Response>): Promise<Respon...
    method handleCapacityExhausted (line 317) | private async handleCapacityExhausted(
    method logQuotaInfo (line 387) | private async logQuotaInfo(): Promise<void> {
    method getQuotaRemaining (line 420) | async getQuotaRemaining(modelName: string): Promise<number | undefined> {

FILE: packages/cli/src/providers/transport/litellm.ts
  constant MODEL_EXTRA_HEADERS (line 17) | const MODEL_EXTRA_HEADERS: Array<{ pattern: string; headers: Record<stri...
  class LiteLLMProviderTransport (line 21) | class LiteLLMProviderTransport implements ProviderTransport {
    method constructor (line 30) | constructor(baseUrl: string, apiKey: string, modelName: string) {
    method overrideStreamFormat (line 40) | overrideStreamFormat(): StreamFormat {
    method getEndpoint (line 44) | getEndpoint(): string {
    method getHeaders (line 48) | async getHeaders(): Promise<Record<string, string>> {
    method getExtraPayloadFields (line 55) | getExtraPayloadFields(): Record<string, any> {
    method getExtraHeaders (line 70) | private getExtraHeaders(): Record<string, string> | null {

FILE: packages/cli/src/providers/transport/local.ts
  constant DISPLAY_NAMES (line 29) | const DISPLAY_NAMES: Record<string, string> = {
  class LocalTransport (line 37) | class LocalTransport implements ProviderTransport {
    method constructor (line 49) | constructor(config: LocalProviderConfig, modelName: string, options?: ...
    method getEndpoint (line 73) | getEndpoint(): string {
    method getHeaders (line 77) | async getHeaders(): Promise<Record<string, string>> {
    method getRequestInit (line 81) | getRequestInit(): Record<string, any> {
    method getExtraPayloadFields (line 89) | getExtraPayloadFields(): Record<string, any> {
    method enqueueRequest (line 99) | async enqueueRequest(fetchFn: () => Promise<Response>): Promise<Respon...
    method refreshAuth (line 108) | async refreshAuth(): Promise<void> {
    method getContextWindow (line 119) | getContextWindow(): number {
    method getConfig (line 124) | getConfig(): LocalProviderConfig {
    method checkHealth (line 130) | private async checkHealth(): Promise<boolean> {
    method fetchContextWindow (line 180) | private async fetchContextWindow(): Promise<void> {
    method fetchOllamaContextWindow (line 196) | private async fetchOllamaContextWindow(): Promise<void> {
    method fetchLMStudioContextWindow (line 236) | private async fetchLMStudioContextWindow(): Promise<void> {
    method getConnectionErrorMessage (line 279) | private getConnectionErrorMessage(): string {

FILE: packages/cli/src/providers/transport/ollamacloud.ts
  class OllamaProviderTransport (line 11) | class OllamaProviderTransport implements ProviderTransport {
    method constructor (line 19) | constructor(provider: RemoteProvider, apiKey: string) {
    method getEndpoint (line 24) | getEndpoint(): string {
    method getHeaders (line 28) | async getHeaders(): Promise<Record<string, string>> {

FILE: packages/cli/src/providers/transport/openai-codex.ts
  function buildOAuthHeaders (line 22) | function buildOAuthHeaders(token: string, accountId?: string): Record<st...
  constant CHATGPT_API_URL (line 39) | const CHATGPT_API_URL = "https://chatgpt.com/backend-api/codex";
  class OpenAICodexTransport (line 41) | class OpenAICodexTransport extends OpenAIProviderTransport {
    method getHeaders (line 42) | override async getHeaders(): Promise<Record<string, string>> {
    method getEndpoint (line 54) | getEndpoint(): string {
    method tryOAuthHeaders (line 76) | private async tryOAuthHeaders(): Promise<Record<string, string> | null> {
    method transformPayload (line 107) | transformPayload(payload: any): any {

FILE: packages/cli/src/providers/transport/openai.ts
  class OpenAIProviderTransport (line 13) | class OpenAIProviderTransport implements ProviderTransport {
    method constructor (line 22) | constructor(provider: RemoteProvider, modelName: string, apiKey: strin...
    method getEndpoint (line 35) | getEndpoint(): string {
    method getHeaders (line 42) | async getHeaders(): Promise<Record<string, string>> {
    method enqueueRequest (line 54) | async enqueueRequest(fetchFn: () => Promise<Response>): Promise<Respon...
    method formatDisplayName (line 98) | static formatDisplayName(name: string): string {
  class OpenAITimeoutError (line 108) | class OpenAITimeoutError extends Error {
    method constructor (line 109) | constructor(baseUrl: string) {
  class OpenAIConnectionError (line 115) | class OpenAIConnectionError extends Error {
    method constructor (line 116) | constructor(baseUrl: string, code: string) {

FILE: packages/cli/src/providers/transport/openrouter.ts
  constant OPENROUTER_API_URL (line 18) | const OPENROUTER_API_URL = "https://openrouter.ai/api/v1/chat/completions";
  class OpenRouterProviderTransport (line 20) | class OpenRouterProviderTransport implements ProviderTransport {
    method constructor (line 28) | constructor(apiKey: string, _modelId?: string) {
    method overrideStreamFormat (line 37) | overrideStreamFormat(): StreamFormat {
    method getEndpoint (line 41) | getEndpoint(): string {
    method getHeaders (line 45) | async getHeaders(): Promise<Record<string, string>> {
    method enqueueRequest (line 53) | async enqueueRequest(fetchFn: () => Promise<Response>): Promise<Respon...
    method getContextWindow (line 62) | getContextWindow(): number {

FILE: packages/cli/src/providers/transport/poe.ts
  constant POE_API_URL (line 12) | const POE_API_URL = "https://api.poe.com/v1/chat/completions";
  class PoeProvider (line 14) | class PoeProvider implements ProviderTransport {
    method constructor (line 21) | constructor(apiKey: string) {
    method getEndpoint (line 25) | getEndpoint(): string {
    method getHeaders (line 29) | async getHeaders(): Promise<Record<string, string>> {

FILE: packages/cli/src/providers/transport/types.ts
  type StreamFormat (line 9) | type StreamFormat =
  type ProviderTransport (line 23) | interface ProviderTransport {

FILE: packages/cli/src/providers/transport/vertex-oauth.ts
  type ParsedVertexModel (line 23) | interface ParsedVertexModel {
  function parseVertexModel (line 33) | function parseVertexModel(modelId: string): ParsedVertexModel {
  class VertexProviderTransport (line 41) | class VertexProviderTransport implements ProviderTransport {
    method constructor (line 50) | constructor(config: VertexConfig, parsed: ParsedVertexModel) {
    method getEndpoint (line 64) | getEndpoint(): string {
    method getHeaders (line 73) | async getHeaders(): Promise<Record<string, string>> {
    method getRequestInit (line 79) | getRequestInit(): Record<string, any> {
    method refreshAuth (line 85) | async refreshAuth(): Promise<void> {
    method forceRefreshAuth (line 94) | async forceRefreshAuth(): Promise<void> {
    method transformPayload (line 105) | transformPayload(payload: any): any {
    method getParsed (line 114) | getParsed(): ParsedVertexModel {

FILE: packages/cli/src/proxy-server.ts
  function getEffectiveDefaultProvider (line 54) | function getEffectiveDefaultProvider(): string {
  type ProxyServerOptions (line 64) | interface ProxyServerOptions {
  function createProxyServer (line 72) | async function createProxyServer(

FILE: packages/cli/src/services/pricing-cache.ts
  constant CACHE_DIR (line 30) | const CACHE_DIR = join(homedir(), ".claudish");
  constant CACHE_FILE (line 31) | const CACHE_FILE = join(CACHE_DIR, "pricing-cache.json");
  constant CACHE_TTL_MS (line 32) | const CACHE_TTL_MS = 24 * 60 * 60 * 1000;
  constant PROVIDER_TO_OR_PREFIX (line 41) | const PROVIDER_TO_OR_PREFIX: Record<string, string[]> = {
  function getDynamicPricingSync (line 60) | function getDynamicPricingSync(
  function warmPricingCache (line 104) | async function warmPricingCache(): Promise<void> {
  function loadDiskCache (line 128) | function loadDiskCache(): boolean {

FILE: packages/cli/src/services/vision-proxy.ts
  constant VISION_MODEL (line 13) | const VISION_MODEL = "claude-sonnet-4-20250514";
  constant MAX_TOKENS_PER_IMAGE (line 14) | const MAX_TOKENS_PER_IMAGE = 1024;
  constant VISION_ENDPOINT (line 15) | const VISION_ENDPOINT = "https://api.anthropic.com/v1/messages";
  constant TIMEOUT_MS (line 16) | const TIMEOUT_MS = 30_000;
  constant DESCRIPTION_PROMPT (line 18) | const DESCRIPTION_PROMPT = `Describe this image in detail for a model th...
  type VisionProxyAuthHeaders (line 33) | interface VisionProxyAuthHeaders {
  type OpenAIImageBlock (line 41) | interface OpenAIImageBlock {
  function parseDataUrl (line 52) | function parseDataUrl(dataUrl: string): { mediaType: string; data: strin...
  function describeImage (line 74) | async function describeImage(
  function describeImages (line 164) | async function describeImages(

FILE: packages/cli/src/stats-buffer.test.ts
  constant CLAUDISH_DIR (line 11) | const CLAUDISH_DIR = join(homedir(), ".claudish");
  constant BUFFER_FILE (line 12) | const BUFFER_FILE = join(CLAUDISH_DIR, "stats-buffer.json");
  constant BACKUP_FILE (line 13) | const BACKUP_FILE = join(CLAUDISH_DIR, "stats-buffer.json.bak");
  function makeEvent (line 15) | function makeEvent(overrides: Partial<StatsEvent> = {}): StatsEvent {

FILE: packages/cli/src/stats-buffer.ts
  constant BUFFER_MAX_BYTES (line 25) | const BUFFER_MAX_BYTES = 64 * 1024;
  constant FLUSH_EVERY_N_EVENTS (line 26) | const FLUSH_EVERY_N_EVENTS = 10;
  constant FLUSH_EVERY_MS (line 27) | const FLUSH_EVERY_MS = 60_000;
  constant CLAUDISH_DIR (line 29) | const CLAUDISH_DIR = join(homedir(), ".claudish");
  constant BUFFER_FILE (line 30) | const BUFFER_FILE = join(CLAUDISH_DIR, "stats-buffer.json");
  type BufferFile (line 32) | interface BufferFile {
  function ensureDir (line 47) | function ensureDir(): void {
  function readFromDisk (line 56) | function readFromDisk(): StatsEvent[] {
  function enforceSizeCap (line 72) | function enforceSizeCap(events: StatsEvent[]): StatsEvent[] {
  function writeToDisk (line 87) | function writeToDisk(events: StatsEvent[]): void {
  function flushToDisk (line 106) | function flushToDisk(): void {
  function scheduleFlushed (line 119) | function scheduleFlushed(): void {
  function appendEvent (line 137) | function appendEvent(event: StatsEvent): void {
  function readBuffer (line 161) | function readBuffer(): StatsEvent[] {
  function clearBuffer (line 173) | function clearBuffer(): void {
  function flushBufferToDisk (line 189) | function flushBufferToDisk(): void {
  function getBufferStats (line 200) | function getBufferStats(): { events: number; bytes: number } {
  function syncFlushOnExit (line 214) | function syncFlushOnExit(): void {

FILE: packages/cli/src/stats-otlp.test.ts
  constant SAMPLE_RESOURCE (line 10) | const SAMPLE_RESOURCE: OtlpResource = {
  constant SAMPLE_EVENT (line 19) | const SAMPLE_EVENT: StatsEvent = {

FILE: packages/cli/src/stats-otlp.ts
  type StatsEvent (line 17) | interface StatsEvent {
  type StatsConsent (line 64) | interface StatsConsent {
  type OtlpStringAttr (line 79) | interface OtlpStringAttr {
  type OtlpIntAttr (line 84) | interface OtlpIntAttr {
  type OtlpDoubleAttr (line 89) | interface OtlpDoubleAttr {
  type OtlpBoolAttr (line 94) | interface OtlpBoolAttr {
  type OtlpArrayAttr (line 99) | interface OtlpArrayAttr {
  type OtlpAttr (line 104) | type OtlpAttr = OtlpStringAttr | OtlpIntAttr | OtlpDoubleAttr | OtlpBool...
  type OtlpLogRecord (line 106) | interface OtlpLogRecord {
  type OtlpResource (line 114) | interface OtlpResource {
  function stringAttr (line 125) | function stringAttr(key: string, value: string): OtlpStringAttr {
  function intAttr (line 129) | function intAttr(key: string, value: number): OtlpIntAttr {
  function doubleAttr (line 133) | function doubleAttr(key: string, value: number): OtlpDoubleAttr {
  function boolAttr (line 137) | function boolAttr(key: string, value: boolean): OtlpBoolAttr {
  function arrayAttr (line 141) | function arrayAttr(key: string, values: string[]): OtlpArrayAttr {
  function buildResource (line 158) | function buildResource(res: OtlpResource): OtlpAttr[] {
  function eventToLogRecord (line 184) | function eventToLogRecord(event: StatsEvent): OtlpLogRecord {
  function formatOtlpBatch (line 239) | function formatOtlpBatch(events: StatsEvent[], resource: OtlpResource): ...

FILE: packages/cli/src/stats.test.ts
  constant CLAUDISH_DIR (line 6) | const CLAUDISH_DIR = join(homedir(), ".claudish");
  constant CONFIG_FILE (line 7) | const CONFIG_FILE = join(CLAUDISH_DIR, "config.json");
  function backupFile (line 9) | function backupFile(path: string): string | null {
  function restoreFile (line 23) | function restoreFile(path: string, backup: string | null): void {

FILE: packages/cli/src/stats.ts
  constant STATS_ENDPOINT (line 37) | const STATS_ENDPOINT = "https://claudish.com/v1/stats";
  constant FLUSH_INTERVAL_MS (line 38) | const FLUSH_INTERVAL_MS = 24 * 60 * 60 * 1000;
  constant MONTHLY_INTERVAL_MS (line 39) | const MONTHLY_INTERVAL_MS = 30 * 24 * 60 * 60 * 1000;
  constant SEND_TIMEOUT_MS (line 40) | const SEND_TIMEOUT_MS = 5000;
  function getVersion (line 71) | function getVersion(): string {
  function detectTimezone (line 77) | function detectTimezone(): string {
  function isStatsDisabledByEnv (line 85) | function isStatsDisabledByEnv(): boolean {
  function initStats (line 96) | function initStats(config: ClaudishConfig): void {
  function recordStats (line 135) | function recordStats(partial: Partial<StatsEvent>): void {
  function checkAndFlush (line 197) | function checkAndFlush(): void {
  function flushStats (line 224) | async function flushStats(): Promise<void> {
  function showMonthlyBanner (line 290) | function showMonthlyBanner(): void {
  function handleStatsCommand (line 350) | async function handleStatsCommand(subcommand: string): Promise<void> {

FILE: packages/cli/src/team-cli.ts
  function getFlag (line 14) | function getFlag(args: string[], flag: string): string | undefined {
  function hasFlag (line 20) | function hasFlag(args: string[], flag: string): boolean {
  function printStatus (line 26) | function printStatus(status: TeamStatus): void {
  function printHelp (line 44) | function printHelp(): void {
  function teamCommand (line 78) | async function teamCommand(args: string[]): Promise<void> {

FILE: packages/cli/src/team-grid.e2e-helpers.ts
  function findMagmuxForTest (line 34) | function findMagmuxForTest(): string {
  type PtyRunOptions (line 58) | interface PtyRunOptions {
  type PtyHandle (line 66) | interface PtyHandle {
  function runInPty (line 89) | function runInPty(opts: PtyRunOptions): PtyHandle {
  function stripAnsi (line 154) | function stripAnsi(input: string): string {
  function shellQuote (line 172) | function shellQuote(arg: string): string {
  function tclBrace (line 184) | function tclBrace(s: string): string {
  type MagmuxEvent (line 206) | interface MagmuxEvent {
  type MagmuxSubscription (line 211) | interface MagmuxSubscription {
  type MagmuxSocketBaseline (line 223) | interface MagmuxSocketBaseline {
  function snapshotMagmuxSockets (line 234) | function snapshotMagmuxSockets(): MagmuxSocketBaseline {
  function findNewestMagmuxSocket (line 255) | async function findNewestMagmuxSocket(
  function subscribeToMagmuxSocket (line 301) | async function subscribeToMagmuxSocket(
  function writeGridfile (line 434) | function writeGridfile(lines: string[]): {

FILE: packages/cli/src/team-grid.e2e.test.ts
  constant E2E_TIMEOUT (line 33) | const E2E_TIMEOUT = 150_000;
  function devClaudishCommand (line 251) | function devClaudishCommand(model: string, prompt: string): string {

FILE: packages/cli/src/team-grid.ts
  type RouteInfo (line 25) | interface RouteInfo {
  function resolveRouteInfo (line 31) | function resolveRouteInfo(modelId: string): RouteInfo {
  constant BANNER_BG_COLORS (line 105) | const BANNER_BG_COLORS = [
  function pickBannerColor (line 119) | function pickBannerColor(model: string, used: Set<number>): string {
  function buildPaneHeader (line 131) | function buildPaneHeader(model: string, prompt: string, bg: string): str...
  function findMagmuxBinary (line 173) | function findMagmuxBinary(): string {
  type PaneResult (line 226) | interface PaneResult {
  type MagmuxResultsEvent (line 241) | interface MagmuxResultsEvent {
  function subscribeToMagmux (line 254) | async function subscribeToMagmux(
  function buildTeamStatus (line 316) | function buildTeamStatus(
  function runWithGrid (line 390) | async function runWithGrid(

FILE: packages/cli/src/team-orchestrator.test.ts
  function getOrchestrator (line 31) | async function getOrchestrator() {
  function makeTempDir (line 38) | function makeTempDir(): string {
  function readJson (line 43) | function readJson<T>(filePath: string): T {
  type ManifestModelEntry (line 49) | interface ManifestModelEntry {
  type TeamManifest (line 54) | interface TeamManifest {
  type ModelStatus (line 60) | interface ModelStatus {
  type TeamStatus (line 68) | interface TeamStatus {
  function getShuffle (line 457) | async function getShuffle() {
  function getBuilder (line 487) | async function getBuilder() {
  function getAggregate (line 527) | async function getAggregate() {
  function getParser (line 726) | async function getParser() {
  function writeResponse (line 731) | function writeResponse(filename: string, content: string) {
  function makeVoteBlock (line 735) | function makeVoteBlock(

FILE: packages/cli/src/team-orchestrator.ts
  type TeamManifest (line 14) | interface TeamManifest {
  type ModelStatus (line 20) | interface ModelStatus {
  type TeamStatus (line 28) | interface TeamStatus {
  type TeamRunOptions (line 33) | interface TeamRunOptions {
  type TeamJudgeOptions (line 39) | interface TeamJudgeOptions {
  type VoteResult (line 44) | interface VoteResult {
  type TeamVerdict (line 53) | interface TeamVerdict {
  function validateSessionPath (line 73) | function validateSessionPath(sessionPath: string): string {
  constant SENTINEL_MODELS (line 88) | const SENTINEL_MODELS = new Set([
  function isSentinelModel (line 100) | function isSentinelModel(model: string): boolean {
  function setupSession (line 113) | function setupSession(sessionPath: string, models: string[], input?: str...
  function runModels (line 197) | async function runModels(
  function judgeResponses (line 362) | async function judgeResponses(
  function getStatus (line 411) | function getStatus(sessionPath: string): TeamStatus {
  function fisherYatesShuffle (line 417) | function fisherYatesShuffle<T>(arr: T[]): T[] {
  function getDefaultJudgeModels (line 425) | function getDefaultJudgeModels(sessionPath: string): string[] {
  function buildJudgePrompt (line 432) | function buildJudgePrompt(input: string, responses: Record<string, strin...
  function parseJudgeVotes (line 462) | function parseJudgeVotes(judgePath: string, responseIds: string[]): Vote...
  function aggregateVerdict (line 513) | function aggregateVerdict(votes: VoteResult[], responseIds: string[]): T...
  function formatVerdict (line 538) | function formatVerdict(verdict: TeamVerdict, sessionPath: string): string {

FILE: packages/cli/src/team-timeout-repro.test.ts
  function makeFakeClaudish (line 38) | function makeFakeClaudish(delayMs: number = 50): string {

FILE: packages/cli/src/telemetry.test.ts
  constant CONFIG_PATH (line 15) | const CONFIG_PATH = join(homedir(), ".claudish", "config.json");
  constant BACKUP_PATH (line 16) | const BACKUP_PATH = join(homedir(), ".claudish", "config.json.telemetry-...
  function backupConfig (line 18) | function backupConfig() {
  function restoreConfig (line 25) | function restoreConfig() {

FILE: packages/cli/src/telemetry.ts
  constant TELEMETRY_ENDPOINT (line 24) | const TELEMETRY_ENDPOINT = "https://claudish.com/v1/report";
  constant MAX_REPORT_BYTES (line 27) | const MAX_REPORT_BYTES = 4096;
  constant KNOWN_PUBLIC_HOSTS (line 34) | const KNOWN_PUBLIC_HOSTS = new Set([
  constant PUBLIC_PROVIDERS (line 48) | const PUBLIC_PROVIDERS = new Set([
  type TelemetryConsent (line 96) | interface TelemetryConsent {
  type ErrorContext (line 116) | interface ErrorContext {
  type TelemetryReport (line 147) | interface TelemetryReport {
  function getVersion (line 189) | function getVersion(): string {
  function detectRuntime (line 199) | function detectRuntime(): string {
  function detectInstallMethod (line 211) | function detectInstallMethod(): string {
  function sanitizeMessage (line 245) | function sanitizeMessage(msg: string): string {
  function sanitizeModelId (line 316) | function sanitizeModelId(modelId: string, providerName: string): string {
  function classifyError (line 335) | function classifyError(
  function buildReport (line 413) | function buildReport(ctx: ErrorContext): TelemetryReport {
  function enforceReportSize (line 473) | function enforceReportSize(report: TelemetryReport): string | null {
  function sendReport (line 495) | async function sendReport(report: TelemetryReport): Promise<void> {
  function showConsentPromptAsync (line 525) | function showConsentPromptAsync(ctx: ErrorContext): void {
  function runConsentPrompt (line 550) | async function runConsentPrompt(ctx: ErrorContext): Promise<void> {
  function initTelemetry (line 620) | function initTelemetry(config: ClaudishConfig): void {
  function setClaudeCodeRunning (line 653) | function setClaudeCodeRunning(running: boolean): void {
  function reportError (line 666) | function reportError(ctx: ErrorContext): void {
  function handleTelemetryCommand (line 709) | async function handleTelemetryCommand(subcommand: string): Promise<void> {

FILE: packages/cli/src/test-fixtures/extract-sse-from-log.ts
  type Turn (line 56) | interface Turn {

FILE: packages/cli/src/transform.ts
  constant DROP_KEYS (line 8) | const DROP_KEYS = [
  type DroppedParams (line 29) | interface DroppedParams {
  function sanitizeRoot (line 36) | function sanitizeRoot(req: any): DroppedParams {
  function mapTools (line 71) | function mapTools(req: any): void {
  function mapToolChoice (line 107) | function mapToolChoice(req: any): void {
  function extractTextContent (line 145) | function extractTextContent(content: any): string {
  function transformMessages (line 183) | function transformMessages(req: any): void {
  function removeUriFormat (line 311) | function removeUriFormat(schema: any): any {
  function transformOpenAIToClaude (line 349) | function transformOpenAIToClaude(claudeRequestInput: any): {

FILE: packages/cli/src/tui/App.tsx
  constant VERSION (line 21) | const VERSION = "v5.16";
  constant COMMON_MODELS (line 24) | const COMMON_MODELS = [
  constant PROVIDER_PREFIXES (line 45) | const PROVIDER_PREFIXES = PROVIDERS.map((p) => ({
  type Tab (line 51) | type Tab = "providers" | "profiles" | "routing" | "privacy";
  type Mode (line 52) | type Mode =
  type ProbeMode (line 66) | type ProbeMode = "idle" | "input" | "running" | "done";
  type ProbeEntry (line 68) | interface ProbeEntry {
  function bytesHuman (line 78) | function bytesHuman(b: number): string {
  function App (line 84) | function App() {

FILE: packages/cli/src/tui/index.tsx
  function startConfigTui (line 6) | async function startConfigTui(): Promise<void> {

FILE: packages/cli/src/tui/providers.ts
  type ProviderDef (line 8) | interface ProviderDef {
  constant SKIP (line 20) | const SKIP = new Set(["qwen", "native-anthropic"]);
  function toProviderDef (line 22) | function toProviderDef(def: ProviderDefinition): ProviderDef {
  constant PROVIDERS (line 35) | const PROVIDERS: ProviderDef[] = getAllProviders()
  function maskKey (line 42) | function maskKey(key: string | undefined): string {

FILE: packages/cli/src/tui/test-provider.ts
  type TestResult (line 16) | type TestResult =
  constant TIMEOUT_MS (line 24) | const TIMEOUT_MS = 10_000;
  function resolveBaseUrl (line 29) | function resolveBaseUrl(def: ProviderDefinition): string {
  type ApiFamily (line 42) | type ApiFamily = "openai" | "anthropic" | "gemini" | "ollamacloud" | "un...
  function getApiFamily (line 44) | function getApiFamily(def: ProviderDefinition): ApiFamily {
  function testOpenAI (line 66) | async function testOpenAI(baseUrl: string, apiKey: string): Promise<Test...
  function testAnthropic (line 89) | async function testAnthropic(
  function testGemini (line 126) | async function testGemini(baseUrl: string, apiKey: string): Promise<Test...
  function testOllamaCloud (line 142) | async function testOllamaCloud(baseUrl: string, apiKey: string): Promise...
  function testProviderKey (line 165) | async function testProviderKey(providerName: string, apiKey: string): Pr...

FILE: packages/cli/src/types.ts
  type OpenRouterModel (line 4) | type OpenRouterModel = string;
  type ClaudishConfig (line 7) | interface ClaudishConfig {
  type AnthropicMessage (line 59) | interface AnthropicMessage {
  type ContentBlock (line 64) | interface ContentBlock {
  type AnthropicRequest (line 74) | interface AnthropicRequest {
  type AnthropicResponse (line 84) | interface AnthropicResponse {
  type OpenRouterMessage (line 98) | interface OpenRouterMessage {
  type OpenRouterRequest (line 103) | interface OpenRouterRequest {
  type OpenRouterResponse (line 112) | interface OpenRouterResponse {
  type ProxyServer (line 130) | interface ProxyServer {
  type ModelHandler (line 137) | interface ModelHandler {
  type RequestContext (line 142) | interface RequestContext {
  type StreamChunkContext (line 148) | interface StreamChunkContext {
  type NonStreamingResponseContext (line 155) | interface NonStreamingResponseContext {
  type ModelMiddleware (line 160) | interface ModelMiddleware {
  type IssueSeverity (line 175) | type IssueSeverity = "error" | "warning" | "info";
  type ValidationIssue (line 177) | interface ValidationIssue {
  type ValidationReport (line 185) | interface ValidationReport {

FILE: packages/cli/src/update-checker.ts
  constant NPM_REGISTRY_URL (line 15) | const NPM_REGISTRY_URL = "https://registry.npmjs.org/claudish/latest";
  constant CACHE_MAX_AGE_MS (line 17) | const CACHE_MAX_AGE_MS = 24 * 60 * 60 * 1000;
  constant RESET (line 20) | const RESET = "\x1b[0m";
  constant BOLD (line 21) | const BOLD = "\x1b[1m";
  constant GREEN (line 22) | const GREEN = "\x1b[32m";
  constant CYAN (line 23) | const CYAN = "\x1b[36m";
  constant DIM (line 24) | const DIM = "\x1b[2m";
  type UpdateCache (line 26) | interface UpdateCache {
  function getCacheFilePath (line 37) | function getCacheFilePath(): string {
  function readCache (line 63) | function readCache(): UpdateCache | null {
  function writeCache (line 79) | function writeCache(latestVersion: string | null): void {
  function isCacheValid (line 95) | function isCacheValid(cache: UpdateCache): boolean {
  function clearCache (line 103) | function clearCache(): void {
  function compareVersions (line 118) | function compareVersions(v1: string, v2: string): number {
  function fetchLatestVersion (line 134) | async function fetchLatestVersion(): Promise<string | null> {
  function checkForUpdates (line 167) | async function checkForUpdates(

FILE: packages/cli/src/update-command.ts
  constant RESET (line 17) | const RESET = "\x1b[0m";
  constant BOLD (line 18) | const BOLD = "\x1b[1m";
  constant GREEN (line 19) | const GREEN = "\x1b[32m";
  constant YELLOW (line 20) | const YELLOW = "\x1b[33m";
  constant CYAN (line 21) | const CYAN = "\x1b[36m";
  constant RED (line 22) | const RED = "\x1b[31m";
  constant MAGENTA (line 23) | const MAGENTA = "\x1b[35m";
  constant DIM (line 24) | const DIM = "\x1b[2m";
  type InstallationInfo (line 26) | interface InstallationInfo {
  type GitHubRelease (line 31) | interface GitHubRelease {
  type ChangelogItem (line 37) | interface ChangelogItem {
  type ChangelogEntry (line 42) | interface ChangelogEntry {
  function detectInstallationMethod (line 51) | function detectInstallationMethod(): InstallationInfo {
  function getUpdateCommand (line 80) | function getUpdateCommand(method: InstallationInfo["method"]): string {
  function executeUpdate (line 96) | async function executeUpdate(command: string): Promise<boolean> {
  constant SECTION_TYPE_MAP (line 113) | const SECTION_TYPE_MAP: Record<string, ChangelogItem["type"] | null> = {
  function parseRelease (line 130) | function parseRelease(r: GitHubRelease): ChangelogEntry {
  function fetchChangelog (line 189) | async function fetchChangelog(
  function itemStyle (line 239) | function itemStyle(type: ChangelogItem["type"]): { symbol: string; color...
  function displayChangelog (line 257) | function displayChangelog(entries: ChangelogEntry[]): void {
  function printManualInstructions (line 299) | function printManualInstructions(): void {
  function updateCommand (line 310) | async function updateCommand(): Promise<void> {

FILE: packages/cli/src/utils.ts
  function fuzzyScore (line 6) | function fuzzyScore(text: string, query: string): number {
  function formatCurrency (line 64) | function formatCurrency(amount: number): string {

FILE: packages/cli/src/version.ts
  constant VERSION (line 2) | const VERSION = "7.0.3";

FILE: packages/cli/src/zai-glm.e2e.test.ts
  constant HAVE_ZAI (line 25) | const HAVE_ZAI = !!process.env.ZAI_API_KEY;
  constant HAVE_GC (line 26) | const HAVE_GC = !!process.env.GLM_CODING_API_KEY || !!process.env.ZAI_CO...
  constant HAVE_GLM (line 27) | const HAVE_GLM = !!process.env.ZHIPU_API_KEY || !!process.env.GLM_API_KEY;
  constant TEST_PROMPT (line 29) | const TEST_PROMPT = "Reply with exactly the word: ok";
  constant TEST_MODEL (line 30) | const TEST_MODEL = "glm-4.6";
  constant TEST_TIMEOUT (line 33) | const TEST_TIMEOUT = 60_000;

FILE: packages/macos-bridge/scripts/full-test.js
  constant BRIDGE_DIR (line 14) | const BRIDGE_DIR = new URL("..", import.meta.url).pathname;
  function runAppleScript (line 16) | function runAppleScript(script) {
  function main (line 24) | async function main() {

FILE: packages/macos-bridge/scripts/simple-test.js
  constant BRIDGE_DIR (line 9) | const BRIDGE_DIR = new URL("..", import.meta.url).pathname;
  function main (line 11) | async function main() {

FILE: packages/macos-bridge/scripts/test-cycletls.ts
  function testClaudeBootstrap (line 9) | async function testClaudeBootstrap() {

FILE: packages/macos-bridge/src/auth.ts
  class AuthManager (line 14) | class AuthManager {
    method constructor (line 18) | constructor() {
    method generateToken (line 27) | private generateToken(): string {
    method hashToken (line 35) | private hashToken(token: string): string {
    method getToken (line 43) | getToken(): string {
    method validateToken (line 50) | validateToken(providedToken: string): boolean {
    method middleware (line 61) | middleware() {
    method getMaskedToken (line 93) | getMaskedToken(): string {

FILE: packages/macos-bridge/src/bridge.test.ts
  constant BASE_URL (line 14) | const BASE_URL = "http://127.0.0.1";

FILE: packages/macos-bridge/src/certificate-manager.ts
  type CertKeyPair (line 6) | interface CertKeyPair {
  constant MAX_LEAF_CERT_CACHE_SIZE (line 12) | const MAX_LEAF_CERT_CACHE_SIZE = 100;
  class CertificateManager (line 23) | class CertificateManager {
    method constructor (line 29) | constructor(certDir: string) {
    method initialize (line 36) | async initialize(): Promise<void> {
    method getCACertPEM (line 85) | getCACertPEM(): string {
    method getCACertFingerprint (line 95) | getCACertFingerprint(): string {
    method getCertForDomain (line 109) | async getCertForDomain(domain: string): Promise<CertKeyPair> {
    method preGenerateCerts (line 139) | async preGenerateCerts(domains: string[]): Promise<void> {
    method hasCA (line 146) | hasCA(): boolean {
    method getCAMetadata (line 153) | getCAMetadata(): { fingerprint: string; validFrom: Date; validTo: Date...
    method getLeafCertCount (line 167) | getLeafCertCount(): number {
    method getCertDir (line 174) | getCertDir(): string {
    method generateCA (line 181) | private async generateCA(): Promise<void> {
    method saveCA (line 229) | private async saveCA(certPath: string, keyPath: string): Promise<void> {
    method generateLeafCert (line 251) | private async generateLeafCert(domain: string): Promise<CertKeyPair> {
    method fileExists (line 320) | private async fileExists(filePath: string): Promise<boolean> {

FILE: packages/macos-bridge/src/config-manager.ts
  function createDefaultConfig (line 12) | function createDefaultConfig(): BridgeConfig {
  class ConfigManager (line 34) | class ConfigManager {
    method constructor (line 37) | constructor() {
    method getConfig (line 44) | getConfig(): BridgeConfig {
    method updateConfig (line 51) | updateConfig(updates: Partial<BridgeConfig>): BridgeConfig {
    method setConfig (line 87) | setConfig(config: BridgeConfig): void {
    method getMappingForApp (line 94) | getMappingForApp(appName: string): AppModelMapping | undefined {
    method setMappingForApp (line 101) | setMappingForApp(appName: string, mapping: AppModelMapping): void {
    method removeMappingForApp (line 108) | removeMappingForApp(appName: string): void {
    method getModelMapping (line 116) | getModelMapping(appName: string, originalModel: string): string | unde...
    method setModelMapping (line 127) | setModelMapping(appName: string, originalModel: string, targetModel: s...
    method removeModelMapping (line 140) | removeModelMapping(appName: string, originalModel: string): void {
    method isEnabled (line 149) | isEnabled(): boolean {
    method setEnabled (line 156) | setEnabled(enabled: boolean): void {
    method getConfiguredApps (line 163) | getConfiguredApps(): string[] {
    method exportConfig (line 170) | exportConfig(): string {
    method importConfig (line 177) | importConfig(jsonString: string): void {

FILE: packages/macos-bridge/src/connect-handler.ts
  type TrafficEntry (line 14) | interface TrafficEntry {
  type TrafficCallback (line 30) | type TrafficCallback = (entry: TrafficEntry) => void;
  type ModelTracker (line 35) | interface ModelTracker {
  type CapturedAuth (line 47) | interface CapturedAuth {
  type RoutingConfig (line 59) | interface RoutingConfig {
  class CONNECTHandler (line 77) | class CONNECTHandler {
    method constructor (line 137) | constructor(
    method setCycleTLSManager (line 152) | setCycleTLSManager(manager: CycleTLSManager): void {
    method setApiKeys (line 159) | setApiKeys(apiKeys: ApiKeys): void {
    method getModelTracker (line 166) | getModelTracker(): ModelTracker {
    method getConversationModel (line 173) | getConversationModel(conversationId: string): string | null {
    method getConversationModels (line 180) | getConversationModels(): Record<string, string> {
    method getCapturedAuth (line 191) | getCapturedAuth(): CapturedAuth {
    method hasAuth (line 198) | hasAuth(): boolean {
    method setRoutingConfig (line 207) | setRoutingConfig(config: RoutingConfig): void {
    method getRoutingConfig (line 218) | getRoutingConfig(): RoutingConfig {
    method getLogs (line 225) | getLogs(): LogEntry[] {
    method clearLogs (line 232) | clearLogs(): void {
    method getRoutingTarget (line 240) | getRoutingTarget(model: string): string | null {
    method shouldRouteConversation (line 250) | shouldRouteConversation(conversationId: string): {
    method fetchConversations (line 270) | async fetchConversations(): Promise<Array<{ uuid: string; model: strin...
    method handle (line 330) | handle(req: http.IncomingMessage, clientSocket: net.Socket, head: Buff...
    method parseConnectRequest (line 359) | private parseConnectRequest(req: http.IncomingMessage): {
    method upgradeTLS (line 385) | private async upgradeTLS(
    method captureAuthFromRequest (line 461) | private captureAuthFromRequest(data: Buffer | string, path: string): v...
    method extractModelFromPath (line 517) | private extractModelFromPath(path: string): string | null {
    method extractConversationFromPath (line 526) | private extractConversationFromPath(path: string): string | null {
    method trackModelUsage (line 534) | private trackModelUsage(
    method parseResponseLine (line 586) | private parseResponseLine(data: Buffer | string): {
    method shouldCaptureResponse (line 620) | private shouldCaptureResponse(path: string): boolean {
    method decompressBody (line 628) | private async decompressBody(data: Buffer, encoding: string): Promise<...
    method transformToAnthropicFormat (line 650) | transformToAnthropicFormat(
    method shouldRouteRequest (line 727) | shouldRouteRequest(
    method forwardStreamingRequest (line 786) | private async forwardStreamingRequest(
    method forwardViaNativeTLS (line 858) | private async forwardViaNativeTLS(
    method forwardWithMessageInjection (line 949) | private async forwardWithMessageInjection(
    method buildHTTPResponse (line 1116) | private buildHTTPResponse(
    method forwardViaCycleTLS (line 1140) | private async forwardViaCycleTLS(
    method getStatusText (line 1252) | private getStatusText(statusCode: number): string {
    method handleDecryptedHTTP (line 1280) | private handleDecryptedHTTP(tlsSocket: tls.TLSSocket, hostname?: strin...
    method analyzeResponse (line 1603) | private async analyzeResponse(responseBuffer: Buffer[], contentEncodin...
    method handleInterceptedRequest (line 1666) | private async handleInterceptedRequest(
    method streamErrorAsResponse (line 1731) | private streamErrorAsResponse(
    method saveCompletionRequestDebug (line 1828) | private saveCompletionRequestDebug(
    method callProviderAPI (line 1847) | private async callProviderAPI(targetModel: string, anthropicRequest: u...
    method streamTransformedResponse (line 1936) | private async streamTransformedResponse(
    method writeErrorResponse (line 2314) | private writeErrorResponse(tlsSocket: tls.TLSSocket, err: unknown): vo...
    method respondError (line 2336) | private respondError(socket: net.Socket, message: string): void {

FILE: packages/macos-bridge/src/cycletls-manager.ts
  type CycleTLSClient (line 10) | type CycleTLSClient = Awaited<ReturnType<typeof initCycleTLS>>;
  type RequestOptions (line 12) | interface RequestOptions {
  type Response (line 18) | interface Response {
  class CycleTLSManager (line 24) | class CycleTLSManager {
    method initialize (line 39) | async initialize(): Promise<void> {
    method request (line 59) | async request(url: string, options: RequestOptions): Promise<Response> {
    method shutdown (line 201) | async shutdown(): Promise<void> {
    method isInitialized (line 215) | isInitialized(): boolean {
    method getStats (line 222) | getStats(): { requestCount: number; errorCount: number } {

FILE: packages/macos-bridge/src/detection.ts
  type AppPattern (line 13) | interface AppPattern {
  constant KNOWN_APPS (line 21) | const KNOWN_APPS: AppPattern[] = [
  function extractPlatform (line 78) | function extractPlatform(userAgent: string): string | undefined {
  function detectUserAgent (line 97) | function detectUserAgent(userAgent: string): UserAgentDetection {
  function isClaudeDesktop (line 165) | function isClaudeDesktop(userAgent: string): boolean {
  function getClaudeDesktopVersion (line 172) | function getClaudeDesktopVersion(userAgent: string): string | undefined {
  type RequestHeaders (line 180) | interface RequestHeaders {
  function detectFromHeaders (line 194) | function detectFromHeaders(headers: RequestHeaders): UserAgentDetection {

FILE: packages/macos-bridge/src/http-parser.ts
  type ParsedHTTPRequest (line 11) | interface ParsedHTTPRequest {
  class HTTPRequestParser (line 23) | class HTTPRequestParser {
    method feed (line 36) | feed(chunk: Buffer): void {
    method tryParseHeaders (line 53) | private tryParseHeaders(): void {
    method isComplete (line 119) | isComplete(): boolean {
    method parse (line 154) | parse(): ParsedHTTPRequest | null {
    method decodeChunkedBody (line 190) | private decodeChunkedBody(chunkedData: Buffer): Buffer {
    method getState (line 221) | getState(): { method: string | null; contentLength: number | null; bod...
    method reset (line 233) | reset(): void {
    method getHeaders (line 247) | getHeaders(): Record<string, string> {
    method getRequestLine (line 254) | getRequestLine(): { method: string; path: string; httpVersion: string ...

FILE: packages/macos-bridge/src/https-proxy-server.ts
  constant MAX_CONTEXT_CACHE_SIZE (line 8) | const MAX_CONTEXT_CACHE_SIZE = 100;
  type HTTPSProxyServerOptions (line 10) | interface HTTPSProxyServerOptions {
  type ConnectHandler (line 16) | type ConnectHandler = (
  class HTTPSProxyServer (line 22) | class HTTPSProxyServer {
    method constructor (line 31) | constructor(
    method setConnectHandler (line 42) | setConnectHandler(handler: ConnectHandler): void {
    method start (line 51) | async start(port = 0): Promise<number> {
    method stop (line 119) | async stop(): Promise<void> {
    method getPort (line 143) | getPort(): number {
    method getServer (line 150) | getServer(): https.Server | null {
    method handleSNI (line 157) | private async handleSNI(

FILE: packages/macos-bridge/src/index.ts
  function main (line 22) | async function main() {

FILE: packages/macos-bridge/src/process-manager.ts
  class ProcessManager (line 20) | class ProcessManager {
    method constructor (line 25) | constructor(dataDir?: string) {
    method acquire (line 40) | async acquire(): Promise<boolean> {
    method updatePidFile (line 110) | async updatePidFile(port: number): Promise<void> {
    method release (line 133) | async release(): Promise<void> {
    method isLocked (line 154) | isLocked(): boolean {
    method findZombies (line 170) | async findZombies(): Promise<ProcessInfo[]> {
    method cleanupZombies (line 206) | async cleanupZombies(): Promise<number> {
    method getProcessInfo (line 248) | private async getProcessInfo(pid: number): Promise<ProcessInfo | null> {
    method parseProcessLine (line 275) | private parseProcessLine(line: string): ProcessInfo | null {
    method isClaudishBridge (line 310) | private isClaudishBridge(command: string): boolean {
    method isProcessAlive (line 321) | private isProcessAlive(pid: number): boolean {
    method killProcess (line 335) | private async killProcess(pid: number, signal: string): Promise<boolea...
    method waitForProcessExit (line 360) | private async waitForProcessExit(pid: number, timeout: number): Promis...
    method findPortOwner (line 377) | async findPortOwner(port: number): Promise<number | null> {
    method isPortInUse (line 391) | async isPortInUse(port: number): Promise<boolean> {
    method validatePort (line 399) | async validatePort(port: number): Promise<boolean> {
    method healthCheck (line 424) | async healthCheck(): Promise<boolean> {
    method readPidFile (line 455) | private readPidFile(): PidFileData | null {
    method recoverFromCrash (line 480) | async recoverFromCrash(): Promise<{ recovered: boolean; message: strin...

FILE: packages/macos-bridge/src/routing-middleware.ts
  type RoutingContext (line 34) | interface RoutingContext {
  type Handler (line 45) | interface Handler {
  class RoutingMiddleware (line 53) | class RoutingMiddleware {
    method constructor (line 59) | constructor(
    method createHandlerForModel (line 70) | private createHandlerForModel(model: string): Handler {
    method getHandlerForModel (line 161) | private getHandlerForModel(model: string): Handler {
    method resolveTargetModel (line 174) | private resolveTargetModel(appName: string, requestedModel: string): s...
    method updateDetectedApp (line 199) | private updateDetectedApp(name: string, confidence: number, userAgent:...
    method computeCost (line 221) | private computeCost(model: string, inputTokens: number, outputTokens: ...
    method logRequest (line 253) | private logRequest(
    method parseTokenUsage (line 286) | private parseTokenUsage(data: unknown): { inputTokens: number; outputT...
    method handleStreamingResponse (line 305) | private async handleStreamingResponse(
    method handle (line 367) | handle() {
    method getLogs (line 467) | getLogs(): LogEntry[] {
    method getDetectedApps (line 474) | getDetectedApps(): DetectedApp[] {
    method clearLogs (line 481) | clearLogs(): void {
    method shutdown (line 488) | async shutdown(): Promise<void> {

FILE: packages/macos-bridge/src/server.ts
  type BridgeStartResult (line 37) | interface BridgeStartResult {
  class BridgeServer (line 45) | class BridgeServer {
    method constructor (line 64) | constructor() {
    method setupRoutes (line 80) | private setupRoutes(): void {
    method writeDebugLog (line 914) | private writeDebugLog(entry: RawTrafficEntry, extra?: string): void {
    method forwardToRealServer (line 924) | private forwardToRealServer(
    method cleanupStaleLockFile (line 974) | private cleanupStaleLockFile(): void {
    method start (line 1014) | async start(port = 8899): Promise<BridgeStartResult> {
    method stop (line 1088) | async stop(): Promise<void> {
    method getToken (line 1136) | getToken(): string {

FILE: packages/macos-bridge/src/types.ts
  type ApiKeys (line 8) | interface ApiKeys {
  type AppModelMapping (line 21) | interface AppModelMapping {
  type BridgeConfig (line 33) | interface BridgeConfig {
  type BridgeStartOptions (line 45) | interface BridgeStartOptions {
  type DetectedApp (line 53) | interface DetectedApp {
  type ProxyStatus (line 64) | interface ProxyStatus {
  type ProxyEnableResponse (line 79) | interface ProxyEnableResponse {
  type LogEntry (line 89) | interface LogEntry {
  type RawTrafficEntry (line 105) | interface RawTrafficEntry {
  type LogFilter (line 121) | interface LogFilter {
  type LogResponse (line 131) | interface LogResponse {
  type HealthResponse (line 141) | interface HealthResponse {
  type UserAgentDetection (line 150) | interface UserAgentDetection {
  type ApiResponse (line 160) | interface ApiResponse<T = unknown> {
  type ProcessInfo (line 169) | interface ProcessInfo {
  type PidFileData (line 178) | interface PidFileData {

FILE: scripts/generate-manifest.ts
  type PlatformInfo (line 14) | interface PlatformInfo {
  type Manifest (line 19) | interface Manifest {
  constant PLATFORM_MAP (line 25) | const PLATFORM_MAP: Record<string, string> = {
  function computeSha256 (line 32) | function computeSha256(filePath: string): string {
  function generateManifest (line 37) | function generateManifest(version: string, releaseDir: string): Manifest {

FILE: scripts/update-models.ts
  constant MODELS_JSON_PATH (line 15) | const MODELS_JSON_PATH = join(import.meta.dir, "../packages/cli/recommen...
  constant TOP_WEEKLY_PROGRAMMING_MODELS (line 23) | const TOP_WEEKLY_PROGRAMMING_MODELS = [
  function updateModels (line 32) | async function updateModels(): Promise<void> {

[
  {
    "path": ".github/ISSUE_TRIAGE.md",
    "chars": 3314,
    "preview": "# Issue Triage Bot Setup\n\nThe Claudish project uses an automated issue triage bot powered by [Claude Code](https://githu"
  },
  {
    "path": ".github/prompts/issue-comment-system.md",
    "chars": 2908,
    "preview": "# Claudish Issue Comment Reply Agent\n\nYou are responding to a follow-up comment on a GitHub issue where you (claudish-bo"
  },
  {
    "path": ".github/prompts/issue-triage-system.md",
    "chars": 6521,
    "preview": "# Claudish Issue Triage Agent\n\nYou are triaging GitHub issues for the Claudish CLI tool.\n\n## Project Context\n\nClaudish ("
  },
  {
    "path": ".github/release.yml",
    "chars": 472,
    "preview": "changelog:\n  exclude:\n    labels:\n      - skip-changelog\n    authors:\n      - github-actions[bot]\n  categories:\n    - ti"
  },
  {
    "path": ".github/workflows/claude-code.yml",
    "chars": 1158,
    "preview": "name: Claude Code PR Assistant\n\non:\n  pull_request:\n    types: [opened, synchronize, reopened]\n  pull_request_review_com"
  },
  {
    "path": ".github/workflows/issue-triage.yml",
    "chars": 10184,
    "preview": "name: Issue Triage\n\non:\n  issues:\n    types: [opened]\n  issue_comment:\n    types: [created]\n  workflow_dispatch:\n    inp"
  },
  {
    "path": ".github/workflows/release.yml",
    "chars": 13906,
    "preview": "name: Release\n\non:\n  push:\n    tags:\n      - 'v*'\n\npermissions:\n  contents: write\n  id-token: write  # Required for npm "
  },
  {
    "path": ".github/workflows/smoke-test.yml",
    "chars": 1442,
    "preview": "name: Smoke Tests\n\non:\n  schedule:\n    - cron: \"0 6 * * *\" # Daily at 06:00 UTC\n  workflow_dispatch: # Manual trigger\n\nj"
  },
  {
    "path": ".gitignore",
    "chars": 879,
    "preview": "# Dependencies\nnode_modules/\n\n# Build output\ndist/\nbuild/\n\n# Environment files\n.env\n.env.local\n.env.*.local\n\n# IDE\n.idea"
  },
  {
    "path": "AI_AGENT_GUIDE.md",
    "chars": 19577,
    "preview": "# Claudish AI Agent Usage Guide\n\n**Version:** 2.2.0\n**Target Audience:** AI Agents running within Claude Code\n**Purpose:"
  },
  {
    "path": "CHANGELOG.md",
    "chars": 74459,
    "preview": "# Changelog\n\nAll notable changes to [Claudish](https://github.com/MadAppGang/claudish).\n\n## [7.0.3] - 2026-04-21\n\n### Bu"
  },
  {
    "path": "CLAUDE.md",
    "chars": 15419,
    "preview": "# Claudish - Development Notes\n\n## Release Process\n\n**Releases are handled by CI/CD** - do NOT manually run `npm publish"
  },
  {
    "path": "README.md",
    "chars": 50565,
    "preview": "<div align=\"center\">\n\n# 🔮 Claudish\n\n### Claude Code. Any Model.\n\n[![npm version](https://img.shields.io/npm/v/claudish.s"
  },
  {
    "path": "apps/.gitignore",
    "chars": 83,
    "preview": "# Swift build artifacts\n.build/\n.swiftpm/\n*.xcodeproj/\n*.xcworkspace/\nDerivedData/\n"
  },
  {
    "path": "apps/ClaudishProxy/Package.swift",
    "chars": 557,
    "preview": "// swift-tools-version: 5.9\n// The swift-tools-version declares the minimum version of Swift required to build this pack"
  },
  {
    "path": "apps/ClaudishProxy/Sources/ApiKeyManager.swift",
    "chars": 10392,
    "preview": "import Foundation\nimport Security\n\n/// Manages API keys with secure Keychain storage\n///\n/// Responsibilities:\n/// - Sto"
  },
  {
    "path": "apps/ClaudishProxy/Sources/BridgeManager.swift",
    "chars": 24428,
    "preview": "import Foundation\nimport Combine\n\n/// Manages the claudish-bridge Node.js process and HTTP communication\n///\n/// Respons"
  },
  {
    "path": "apps/ClaudishProxy/Sources/CertificateManager.swift",
    "chars": 10580,
    "preview": "import Foundation\nimport Security\n\n/// Manages certificate installation and keychain operations for HTTPS interception\n@"
  },
  {
    "path": "apps/ClaudishProxy/Sources/ClaudishProxyApp.swift",
    "chars": 30049,
    "preview": "import SwiftUI\nimport AppKit\n\n/// App version and metadata\nenum AppInfo {\n    static let version = \"1.0.0\"\n    static le"
  },
  {
    "path": "apps/ClaudishProxy/Sources/ModelProvider.swift",
    "chars": 11624,
    "preview": "import Foundation\nimport SwiftUI\n\n// MARK: - Model Types\n\n/// Provider category for models\nenum ModelProviderType: Strin"
  },
  {
    "path": "apps/ClaudishProxy/Sources/Models.swift",
    "chars": 13687,
    "preview": "import Foundation\n\n// MARK: - API Response Types\n\n/// Health check response from bridge\nstruct HealthResponse: Codable {"
  },
  {
    "path": "apps/ClaudishProxy/Sources/ProcessManager.swift",
    "chars": 9534,
    "preview": "import Foundation\nimport Combine\n\n/// Manages spawning and lifecycle of proxied Claude Desktop instances\n///\n/// Instead"
  },
  {
    "path": "apps/ClaudishProxy/Sources/ProfileManager.swift",
    "chars": 10284,
    "preview": "import Foundation\nimport SwiftUI\nimport Combine\n\n/// Manager for model profiles with storage and bridge integration\n@Mai"
  },
  {
    "path": "apps/ClaudishProxy/Sources/ProfilePicker.swift",
    "chars": 3728,
    "preview": "import SwiftUI\n\n/// Profile picker for menu bar dropdown\nstruct ProfilePicker: View {\n    @ObservedObject var profileMan"
  },
  {
    "path": "apps/ClaudishProxy/Sources/ProfilesSettingsView.swift",
    "chars": 33643,
    "preview": "import SwiftUI\nimport UniformTypeIdentifiers\n\n/// Wrapper for sheet binding - nil means new profile, non-nil means edit\n"
  },
  {
    "path": "apps/ClaudishProxy/Sources/SettingsView.swift",
    "chars": 39402,
    "preview": "import SwiftUI\n\n/// Settings window for configuring model mappings\nstruct SettingsView: View {\n    @ObservedObject var b"
  },
  {
    "path": "apps/ClaudishProxy/Sources/StatsDatabase.swift",
    "chars": 13637,
    "preview": "import Foundation\nimport SQLite3\n\n/// SQLite database manager for persistent stats storage\n/// Location: ~/Library/Appli"
  },
  {
    "path": "apps/ClaudishProxy/Sources/StatsPanel.swift",
    "chars": 9099,
    "preview": "import SwiftUI\n\n// MARK: - Components\n\nstruct DropdownSelector: View {\n    @Binding var selection: StatsManager.StatsPer"
  },
  {
    "path": "apps/ClaudishProxy/Sources/Theme.swift",
    "chars": 4509,
    "preview": "import SwiftUI\n\n/// Theme colors and styling constants for ClaudishProxy\n/// Based on the dark theme design from stats-p"
  },
  {
    "path": "apps/ClaudishProxy/Sources/UnifiedModelPicker.swift",
    "chars": 13984,
    "preview": "import SwiftUI\n\n/// Unified picker for profiles and models with search\nstruct UnifiedModelPicker: View {\n    @ObservedOb"
  },
  {
    "path": "biome.json",
    "chars": 882,
    "preview": "{\n  \"$schema\": \"https://biomejs.dev/schemas/1.9.4/schema.json\",\n  \"vcs\": {\n    \"enabled\": true,\n    \"clientKind\": \"git\","
  },
  {
    "path": "cliff.toml",
    "chars": 1550,
    "preview": "# git-cliff configuration for automatic changelog generation\n# https://git-cliff.org/docs/configuration\n\n[changelog]\nhea"
  },
  {
    "path": "design-references/stats-panel-style.md",
    "chars": 17143,
    "preview": "# Stats Panel Design Specification\n\n**Purpose**: Design reference for implementing credit usage and statistics panels in"
  },
  {
    "path": "docs/advanced/automation.md",
    "chars": 4887,
    "preview": "# Automation\n\n**Claudish in scripts, pipelines, and CI/CD.**\n\nSingle-shot mode makes Claudish perfect for automation. He"
  },
  {
    "path": "docs/advanced/cost-tracking.md",
    "chars": 3261,
    "preview": "# Cost Tracking\n\n**Know what you're spending. No surprises.**\n\nOpenRouter charges per token. Claudish can help you track"
  },
  {
    "path": "docs/advanced/environment.md",
    "chars": 4292,
    "preview": "# Environment Variables\n\n**Every knob you can turn. Complete reference.**\n\n---\n\n## Required\n\n### `OPENROUTER_API_KEY`\n\nY"
  },
  {
    "path": "docs/advanced/mtm-to-magmux-migration.md",
    "chars": 15131,
    "preview": "# Migrating from MTM to magmux\n\n**Version**: v6.5.0\n**Last updated**: 2026-04-01\n**Status**: Steps 1-3 complete. magmux "
  },
  {
    "path": "docs/ai-integration/for-agents.md",
    "chars": 5989,
    "preview": "# Claudish for AI Agents\n\n**How Claude Code sub-agents should use Claudish. Technical reference.**\n\nThis guide is for AI"
  },
  {
    "path": "docs/api-key-architecture.md",
    "chars": 6720,
    "preview": "# API Key Validation Architecture\n\nThis document describes the centralized API key validation system implemented in Clau"
  },
  {
    "path": "docs/api-reference.md",
    "chars": 38810,
    "preview": "# API Reference\n\nClaudish exposes a Firebase Cloud Functions HTTP API for model catalog data and telemetry, plus an MCP "
  },
  {
    "path": "docs/getting-started/quick-start.md",
    "chars": 4179,
    "preview": "# Quick Start Guide\n\n**From zero to running in 3 minutes. No fluff.**\n\n---\n\n## Prerequisites\n\nYou need two things:\n\n1. *"
  },
  {
    "path": "docs/index.md",
    "chars": 6634,
    "preview": "# Claudish Documentation\n\n**Run Claude Code with any AI model. Simple as that.**\n\nYou've got Claude Code. It's brilliant"
  },
  {
    "path": "docs/models/choosing-models.md",
    "chars": 5805,
    "preview": "# Choosing the Right Model\n\n**Different models, different strengths. Here's how to pick.**\n\nOpenRouter gives you access "
  },
  {
    "path": "docs/models/model-mapping.md",
    "chars": 5525,
    "preview": "# Model Mapping\n\n**Different models for different roles. Advanced optimization.**\n\nClaude Code uses different model \"tie"
  },
  {
    "path": "docs/settings-reference.md",
    "chars": 39136,
    "preview": "# Claudish Settings Reference\n\n**Session**: dev-research-claudish-settings-20260316-012741-6e25c3bb\n**Date**: 2026-03-16"
  },
  {
    "path": "docs/three-layer-architecture.md",
    "chars": 21420,
    "preview": "# Three-layer adapter architecture\n\n**Version**: v5.14.0+\n**Last updated**: 2026-03-22\n\nClaudish proxies Claude Code req"
  },
  {
    "path": "docs/troubleshooting.md",
    "chars": 7211,
    "preview": "# Troubleshooting\n\n**Something broken? Let's fix it.**\n\n---\n\n## Installation Issues\n\n### \"command not found: claudish\"\n\n"
  },
  {
    "path": "docs/usage/interactive-mode.md",
    "chars": 3636,
    "preview": "# Interactive Mode\n\n**The full Claude Code experience, different brain.**\n\nThis is how most people use Claudish. You pic"
  },
  {
    "path": "docs/usage/magmux.md",
    "chars": 6979,
    "preview": "# Magmux\n\n**A minimal terminal multiplexer for running AI models side by side.**\n\nMagmux splits your terminal into panes"
  },
  {
    "path": "docs/usage/mcp-server.md",
    "chars": 14401,
    "preview": "# MCP Server Mode\n\n**Use any claudish model as a tool inside Claude Code.**\n\nClaudish isn't just a CLI. It's also an MCP"
  },
  {
    "path": "docs/usage/monitor-mode.md",
    "chars": 3302,
    "preview": "# Monitor Mode\n\n**See exactly what Claude Code is doing under the hood.**\n\nMonitor mode is different. Instead of routing"
  },
  {
    "path": "docs/usage/single-shot-mode.md",
    "chars": 3814,
    "preview": "# Single-Shot Mode\n\n**One task. One result. Exit.**\n\nInteractive sessions are great for exploration. But sometimes you j"
  },
  {
    "path": "experiments/tool-replacement-proxy-2026-04/README.md",
    "chars": 9941,
    "preview": "# Tool Replacement via API Proxy — Claude Code Extension Technique\n\n**Status**: Active (Stage 2 PoC validated, Stage 2.1"
  },
  {
    "path": "experiments/tool-replacement-proxy-2026-04/claudish-patch/native-handler-advisor.test.ts",
    "chars": 8700,
    "preview": "import { afterEach, describe, expect, it } from \"bun:test\";\nimport {\n  _debug_getTrackedAdvisorIds,\n  _debug_resetTracke"
  },
  {
    "path": "experiments/tool-replacement-proxy-2026-04/claudish-patch/native-handler-advisor.ts",
    "chars": 11998,
    "preview": "/**\n * Advisor-tool transformer for NativeHandler (monitor mode).\n *\n * PURPOSE — experimental\n * ======================"
  },
  {
    "path": "experiments/tool-replacement-proxy-2026-04/claudish-patch/native-handler.patch",
    "chars": 7420,
    "preview": "diff --git a/packages/cli/src/handlers/native-handler.ts b/packages/cli/src/handlers/native-handler.ts\nindex 405c9ce..03"
  },
  {
    "path": "experiments/tool-replacement-proxy-2026-04/evidence/evidence-index.ndjson",
    "chars": 626,
    "preview": "{\"ts\":\"2026-04-14T11:52:21.848Z\",\"n\":3,\"method\":\"POST\",\"path\":\"/v1/messages\",\"hasAdvisor\":false,\"betaHeader\":\"interleave"
  },
  {
    "path": "experiments/tool-replacement-proxy-2026-04/evidence/evidence-req-advisor-enabled.json",
    "chars": 340513,
    "preview": "{\n  \"method\": \"POST\",\n  \"url\": \"http://127.0.0.1:8787/v1/messages?beta=true\",\n  \"pathname\": \"/v1/messages\",\n  \"headers\":"
  },
  {
    "path": "experiments/tool-replacement-proxy-2026-04/evidence/evidence-resp-advisor-enabled.ndjson",
    "chars": 160191,
    "preview": "{\"event\":\"message_start\",\"data\":{\"type\":\"message_start\",\"message\":{\"model\":\"claude-sonnet-4-6\",\"id\":\"msg_01Ez6qHzzSBGx1T"
  },
  {
    "path": "experiments/tool-replacement-proxy-2026-04/evidence/evidence-stage1-swap.ndjson",
    "chars": 439746,
    "preview": "{\"ts\":\"2026-04-15T02:24:14.469Z\",\"kind\":\"request_body\",\"swapApplied\":false,\"model\":\"claude-haiku-4-5-20251001\",\"body\":{\""
  },
  {
    "path": "experiments/tool-replacement-proxy-2026-04/evidence/evidence-stage2-rewrite.ndjson",
    "chars": 440156,
    "preview": "{\"ts\":\"2026-04-15T06:32:18.882Z\",\"kind\":\"request_body\",\"swapApplied\":false,\"rewrittenIds\":[],\"model\":\"claude-haiku-4-5-2"
  },
  {
    "path": "experiments/tool-replacement-proxy-2026-04/evidence/evidence-stage2-ui-transcript.txt",
    "chars": 21206,
    "preview": "  Failure modes:\n\n  ┌──────────────┬─────────────────────────────────────┬─────────────────────────────────────┐\n  │   F"
  },
  {
    "path": "experiments/tool-replacement-proxy-2026-04/journal/2026-04-10-to-15-investigation.md",
    "chars": 6029,
    "preview": "# Investigation Journal: 2026-04-10 → 2026-04-15\n\n## Day 1 (April 10): Research Phase\n\n**Goal**: Understand Anthropic's "
  },
  {
    "path": "experiments/tool-replacement-proxy-2026-04/poc/01-recording-proxy.ts",
    "chars": 8186,
    "preview": "#!/usr/bin/env bun\n/**\n * PoC Phase 1: Recording Proxy\n *\n * Minimal passthrough proxy that:\n *   1. Receives requests o"
  },
  {
    "path": "experiments/tool-replacement-proxy-2026-04/poc/02-mock-advisor-proxy.ts",
    "chars": 14767,
    "preview": "#!/usr/bin/env bun\n/**\n * PoC Phase 2: Mock Advisor Proxy\n *\n * This proxy does NOT forward to Anthropic. It fabricates "
  },
  {
    "path": "experiments/tool-replacement-proxy-2026-04/poc/03-sdk-validation.ts",
    "chars": 4237,
    "preview": "#!/usr/bin/env bun\n/**\n * PoC Phase 2b: Validate mock proxy against the real Anthropic SDK\n *\n * This is the strongest v"
  },
  {
    "path": "experiments/tool-replacement-proxy-2026-04/poc/04-multi-turn-validation.ts",
    "chars": 4887,
    "preview": "#!/usr/bin/env bun\n/**\n * PoC Phase 2c: Multi-turn round-trip validation\n *\n * Per the Anthropic advisor docs, clients M"
  },
  {
    "path": "experiments/tool-replacement-proxy-2026-04/poc/05-tool-loop-proxy.ts",
    "chars": 20585,
    "preview": "#!/usr/bin/env bun\n/**\n * PoC Phase 3: Tool-Loop Advisor Replacement Proxy\n *\n * This is the real proof of concept for t"
  },
  {
    "path": "experiments/tool-replacement-proxy-2026-04/poc/06-sdk-e2e-validation.ts",
    "chars": 11939,
    "preview": "#!/usr/bin/env bun\n/**\n * PoC Phase 3b: End-to-end validation with the real Anthropic SDK\n *\n * The strongest validation"
  },
  {
    "path": "experiments/tool-replacement-proxy-2026-04/poc/README.md",
    "chars": 8250,
    "preview": "# Advisor-Replacement Proxy — Proof of Concept\n\nThis directory contains a working proof-of-concept validating that a pro"
  },
  {
    "path": "experiments/tool-replacement-proxy-2026-04/research/01-advisor-pattern-research.md",
    "chars": 23159,
    "preview": "# Research Report: Claude Advisor Tool Pattern + Claudish Integration\n\n**Session**: dev-research-advisor-tool-claudish-2"
  },
  {
    "path": "experiments/tool-replacement-proxy-2026-04/research/01-research-plan.md",
    "chars": 15330,
    "preview": "# Research Plan: Advisor Tool Pattern + Claudish Integration\n\n**Session:** dev-research-advisor-tool-claudish-20260410-1"
  },
  {
    "path": "experiments/tool-replacement-proxy-2026-04/research/02-proxy-replacement-architecture.md",
    "chars": 14602,
    "preview": "# Research Report: Transparent Advisor Tool Replacement via API Proxy\n\n**Session**: dev-research-advisor-proxy-replaceme"
  },
  {
    "path": "experiments/tool-replacement-proxy-2026-04/research/03-how-to-enable-advisor.md",
    "chars": 11314,
    "preview": "# How to Enable the Native Claude Code Advisor Tool\n\n**Validated 2026-04-14** with Claude Code 2.1.107, `claude-sonnet-4"
  },
  {
    "path": "experiments/tool-replacement-proxy-2026-04/research/04-real-test-results.md",
    "chars": 8269,
    "preview": "# Real-Claude-Code Test Results (2026-04-14)\n\n## TL;DR\n\nRan real Claude Code 2.1.107 through the recording proxy. Captur"
  },
  {
    "path": "experiments/tool-replacement-proxy-2026-04/research/05-stage1-tool-swap.md",
    "chars": 6927,
    "preview": "# Stage 1 Results — Advisor Tool Swap Validation\n\n**Date**: 2026-04-15\n**Claude Code**: v2.1.108\n**Executor model**: cla"
  },
  {
    "path": "experiments/tool-replacement-proxy-2026-04/research/06-stage2-tool-result-rewrite.md",
    "chars": 8237,
    "preview": "# Stage 2 Results — Approach 1 PoC Works End-to-End\n\n**Date**: 2026-04-15\n**Claude Code**: v2.1.109\n**Executor**: Opus 4"
  },
  {
    "path": "install.sh",
    "chars": 3939,
    "preview": "#!/bin/bash\n# claudish installer\n# Usage: curl -fsSL https://raw.githubusercontent.com/MadAppGang/claudish/main/install."
  },
  {
    "path": "landingpage/.firebaserc",
    "chars": 56,
    "preview": "{\n  \"projects\": {\n    \"default\": \"claudish-6da10\"\n  }\n}\n"
  },
  {
    "path": "landingpage/.gitignore",
    "chars": 1232,
    "preview": "# Logs\nlogs\n*.log\nnpm-debug.log*\nyarn-debug.log*\nyarn-error.log*\nfirebase-debug.log*\nfirebase-debug.*.log*\n\n# Firebase c"
  },
  {
    "path": "landingpage/App.tsx",
    "chars": 6081,
    "preview": "import React from \"react\";\nimport HeroSection from \"./components/HeroSection\";\nimport SubscriptionSection from \"./compon"
  },
  {
    "path": "landingpage/README.md",
    "chars": 529,
    "preview": "# Claudish Landing Page\n\nThe marketing site for [Claudish](https://github.com/MadAppGang/claudish) - run Claude Code wit"
  },
  {
    "path": "landingpage/components/BlockLogo.tsx",
    "chars": 3283,
    "preview": "import React from \"react\";\n\n// Grid definition: 1 = filled block, 0 = empty space\nconst LETTERS: Record<string, number[]"
  },
  {
    "path": "landingpage/components/BridgeDiagram.tsx",
    "chars": 7086,
    "preview": "import React, { useState, useEffect } from \"react\";\n\nexport const BridgeDiagram: React.FC = () => {\n  const [modelIndex,"
  },
  {
    "path": "landingpage/components/Changelog.tsx",
    "chars": 13860,
    "preview": "import React, { useEffect, useState } from \"react\";\n\ninterface GitHubRelease {\n  id: number;\n  tag_name: string;\n  name:"
  },
  {
    "path": "landingpage/components/FeatureSection.tsx",
    "chars": 23318,
    "preview": "import type React from \"react\";\nimport { useEffect, useState } from \"react\";\nimport { HIGHLIGHT_FEATURES, STANDARD_FEATU"
  },
  {
    "path": "landingpage/components/HeroSection.tsx",
    "chars": 16648,
    "preview": "import type React from \"react\";\nimport { useEffect, useRef, useState } from \"react\";\nimport { HERO_SEQUENCE } from \"../c"
  },
  {
    "path": "landingpage/components/MultiModelAnimation.tsx",
    "chars": 15686,
    "preview": "import React, { useState, useEffect, useRef } from \"react\";\nimport { TerminalWindow } from \"./TerminalWindow\";\n\nexport c"
  },
  {
    "path": "landingpage/components/SmartRouting.tsx",
    "chars": 25585,
    "preview": "import React, { useState, useEffect, useRef } from \"react\";\nimport { TerminalWindow } from \"./TerminalWindow\";\nimport { "
  },
  {
    "path": "landingpage/components/SubscriptionSection.tsx",
    "chars": 7397,
    "preview": "import {\n  Bot,\n  Brain,\n  Check,\n  Cloud,\n  Zap as FastIcon,\n  HardDrive,\n  MessageSquareCode,\n  Moon,\n  ShieldCheck,\n "
  },
  {
    "path": "landingpage/components/SupportSection.tsx",
    "chars": 3767,
    "preview": "import React from \"react\";\n\nconst SupportSection: React.FC = () => {\n  return (\n    <section className=\"py-16 bg-[#08080"
  },
  {
    "path": "landingpage/components/TerminalWindow.tsx",
    "chars": 1340,
    "preview": "import React from \"react\";\n\ninterface TerminalWindowProps {\n  children: React.ReactNode;\n  className?: string;\n  title?:"
  },
  {
    "path": "landingpage/components/TypingAnimation.tsx",
    "chars": 936,
    "preview": "import React, { useState, useEffect } from \"react\";\n\ninterface TypingAnimationProps {\n  text: string;\n  speed?: number;\n"
  },
  {
    "path": "landingpage/components/VisionSection.tsx",
    "chars": 6669,
    "preview": "import type React from \"react\";\nimport { TerminalWindow } from \"./TerminalWindow\";\n\nexport const VisionSection: React.FC"
  },
  {
    "path": "landingpage/constants.ts",
    "chars": 5907,
    "preview": "import type { Feature, ModelCard, TerminalLine } from \"./types\";\n\nexport const HERO_SEQUENCE: TerminalLine[] = [\n  // 1."
  },
  {
    "path": "landingpage/firebase.json",
    "chars": 590,
    "preview": "{\n  \"hosting\": {\n    \"public\": \"dist\",\n    \"ignore\": [\"firebase.json\", \"**/.*\", \"**/node_modules/**\"],\n    \"rewrites\": ["
  },
  {
    "path": "landingpage/firebase.ts",
    "chars": 661,
    "preview": "import { initializeApp } from \"firebase/app\";\nimport { getAnalytics, isSupported } from \"firebase/analytics\";\n\nconst fir"
  },
  {
    "path": "landingpage/index.html",
    "chars": 9354,
    "preview": "<!DOCTYPE html>\n<html lang=\"en\">\n  <head>\n    <meta charset=\"utf-8\" />\n    <meta name=\"viewport\" content=\"width=device-w"
  },
  {
    "path": "landingpage/index.tsx",
    "chars": 404,
    "preview": "import React from \"react\";\nimport ReactDOM from \"react-dom/client\";\nimport App from \"./App\";\nimport \"./firebase\"; // Ini"
  },
  {
    "path": "landingpage/metadata.json",
    "chars": 157,
    "preview": "{\n  \"name\": \"Claudish\",\n  \"description\": \"A landing page for Claudish - the universal model wrapper for Claude Code CLI."
  },
  {
    "path": "landingpage/package.json",
    "chars": 534,
    "preview": "{\n  \"name\": \"claudish\",\n  \"private\": true,\n  \"version\": \"0.0.0\",\n  \"type\": \"module\",\n  \"scripts\": {\n    \"dev\": \"vite\",\n "
  },
  {
    "path": "landingpage/pnpm-workspace.yaml",
    "chars": 71,
    "preview": "onlyBuiltDependencies:\n  - '@firebase/util'\n  - esbuild\n  - protobufjs\n"
  },
  {
    "path": "landingpage/public/site.webmanifest",
    "chars": 438,
    "preview": "{\n  \"name\": \"Claudish\",\n  \"short_name\": \"Claudish\",\n  \"icons\": [\n    {\n      \"src\": \"/web-app-manifest-192x192.png\",\n   "
  },
  {
    "path": "landingpage/tsconfig.json",
    "chars": 491,
    "preview": "{\n  \"compilerOptions\": {\n    \"target\": \"ES2022\",\n    \"experimentalDecorators\": true,\n    \"useDefineForClassFields\": fals"
  },
  {
    "path": "landingpage/types.ts",
    "chars": 732,
    "preview": "export interface TerminalLine {\n  id: string;\n  type:\n    | \"input\"\n    | \"output\"\n    | \"success\"\n    | \"info\"\n    | \"a"
  },
  {
    "path": "landingpage/vite.config.ts",
    "chars": 549,
    "preview": "import path from \"path\";\nimport { defineConfig, loadEnv } from \"vite\";\nimport react from \"@vitejs/plugin-react\";\n\nexport"
  },
  {
    "path": "package.json",
    "chars": 1969,
    "preview": "{\n  \"name\": \"claudish-monorepo\",\n  \"version\": \"7.0.3\",\n  \"private\": true,\n  \"description\": \"Monorepo for Claudish - Run "
  },
  {
    "path": "packages/.gitignore",
    "chars": 40,
    "preview": "# Build outputs\n*/dist/\n*/node_modules/\n"
  },
  {
    "path": "packages/cli/.gitignore",
    "chars": 17,
    "preview": ".claudish-team-*\n"
  },
  {
    "path": "packages/cli/AI_AGENT_GUIDE.md",
    "chars": 19561,
    "preview": "# Claudish AI Agent Usage Guide\n\n**Version:** 7.0.0\n**Target Audience:** AI Agents running within Claude Code\n**Purpose:"
  },
  {
    "path": "packages/cli/bin/claudish.cjs",
    "chars": 1401,
    "preview": "#!/usr/bin/env node\n\n// Launcher script: checks for Bun runtime before starting claudish.\n// Claudish uses Bun-specific "
  },
  {
    "path": "packages/cli/package.json",
    "chars": 2214,
    "preview": "{\n  \"name\": \"claudish\",\n  \"version\": \"7.0.3\",\n  \"description\": \"Run Claude Code with any model - OpenRouter, Ollama, LM "
  },
  {
    "path": "packages/cli/recommended-models.json",
    "chars": 7265,
    "preview": "{\n  \"version\": \"1.2.0\",\n  \"lastUpdated\": \"2026-03-16\",\n  \"source\": \"https://openrouter.ai/models?categories=programming&"
  },
  {
    "path": "packages/cli/scripts/generate-version.ts",
    "chars": 615,
    "preview": "/**\n * Generate version.ts from package.json\n * Run before bundling so the version is baked into compiled binaries.\n */\n"
  },
  {
    "path": "packages/cli/scripts/smoke/probes.ts",
    "chars": 17647,
    "preview": "/**\n * Smoke test probe implementations.\n *\n * Three probes: tool calling, reasoning, vision.\n * Each returns a ProbeRes"
  },
  {
    "path": "packages/cli/scripts/smoke/providers.ts",
    "chars": 7095,
    "preview": "/**\n * Provider discovery for smoke tests.\n *\n * Imports from the main source tree to reuse base URLs, auth schemes,\n * "
  },
  {
    "path": "packages/cli/scripts/smoke/reporter.ts",
    "chars": 4508,
    "preview": "/**\n * Terminal table and JSON file output for smoke test results.\n */\n\nimport { mkdirSync, writeFileSync } from \"node:f"
  },
  {
    "path": "packages/cli/scripts/smoke/types.ts",
    "chars": 2663,
    "preview": "/**\n * Smoke test types and interfaces\n */\n\n// Wire format classification\nexport type WireFormat = \"anthropic-compat\" | "
  },
  {
    "path": "packages/cli/scripts/smoke-test.ts",
    "chars": 7175,
    "preview": "#!/usr/bin/env bun\n/**\n * Claudish Smoke Test Suite\n *\n * Validates all available providers by running tool calling, rea"
  },
  {
    "path": "packages/cli/scripts/smoke.test.ts",
    "chars": 15719,
    "preview": "/**\n * Black-box unit tests for the claudish smoke test framework.\n *\n * Tests are based on expected behavior (requireme"
  },
  {
    "path": "packages/cli/skills/claudish-usage/SKILL.md",
    "chars": 35886,
    "preview": "---\nname: claudish-usage\ndescription: CRITICAL - Guide for using Claudish CLI ONLY through sub-agents to run Claude Code"
  },
  {
    "path": "packages/cli/src/adapters/anthropic-api-format.ts",
    "chars": 4547,
    "preview": "/**\n * AnthropicAPIFormat — Layer 1 wire format for Anthropic Messages API.\n *\n * Identity transform for providers that "
  },
  {
    "path": "packages/cli/src/adapters/api-format.ts",
    "chars": 1318,
    "preview": "/**\n * APIFormat — translates between Claude API format and target model's wire format.\n *\n * Each implementation repres"
  },
  {
    "path": "packages/cli/src/adapters/base-api-format.ts",
    "chars": 9230,
    "preview": "/**\n * Base class for API format implementations (Layer 1) and model dialect\n * implementations (Layer 2).\n *\n * Differe"
  },
  {
    "path": "packages/cli/src/adapters/codex-api-format.ts",
    "chars": 6487,
    "preview": "/**\n * CodexAPIFormat — Layer 1 wire format for the OpenAI Responses API (Codex models).\n *\n * The Codex Responses API i"
  },
  {
    "path": "packages/cli/src/adapters/deepseek-model-dialect.ts",
    "chars": 1434,
    "preview": "/**\n * DeepSeekModelDialect — Layer 2 dialect for DeepSeek models.\n *\n * Handles DeepSeek-specific quirks:\n * - Strips u"
  },
  {
    "path": "packages/cli/src/adapters/dialect-manager.ts",
    "chars": 2241,
    "preview": "/**\n * DialectManager — selects the appropriate Layer 2 ModelDialect for a given model.\n *\n * This allows ComposedHandle"
  },
  {
    "path": "packages/cli/src/adapters/gemini-api-format.ts",
    "chars": 15400,
    "preview": "/**\n * GeminiAPIFormat — Layer 1 wire format for Google Gemini generateContent API.\n *\n * Handles Gemini-specific transf"
  },
  {
    "path": "packages/cli/src/adapters/glm-model-dialect.ts",
    "chars": 1649,
    "preview": "/**\n * GLMModelDialect — Layer 2 dialect for Zhipu AI GLM models.\n *\n * Handles GLM-specific quirks:\n * - Context window"
  },
  {
    "path": "packages/cli/src/adapters/grok-model-dialect.ts",
    "chars": 4772,
    "preview": "/**\n * GrokModelDialect — Layer 2 dialect for xAI Grok models.\n *\n * Translates xAI XML function calls to Claude Code to"
  },
  {
    "path": "packages/cli/src/adapters/index.ts",
    "chars": 604,
    "preview": "/**\n * Model format and dialect implementations\n */\n\nexport { BaseAPIFormat, DefaultAPIFormat } from \"./base-api-format."
  },
  {
    "path": "packages/cli/src/adapters/litellm-api-format.ts",
    "chars": 5015,
    "preview": "/**\n * LiteLLMAPIFormat — Layer 1 wire format for LiteLLM proxy.\n *\n * Handles LiteLLM-specific model transforms:\n * - I"
  },
  {
    "path": "packages/cli/src/adapters/local-adapter.ts",
    "chars": 8975,
    "preview": "/**\n * LocalModelAdapter — adapter for local OpenAI-compatible providers.\n *\n * Wraps a model-specific adapter (Qwen, De"
  },
  {
    "path": "packages/cli/src/adapters/minimax-model-dialect.ts",
    "chars": 3097,
    "preview": "/**\n * MiniMaxModelDialect — Layer 2 dialect for MiniMax models.\n *\n * Handles MiniMax-specific quirks:\n * - Context win"
  },
  {
    "path": "packages/cli/src/adapters/model-catalog.test.ts",
    "chars": 7657,
    "preview": "/**\n * Tests for the centralized model-catalog.ts lookupModel() function.\n */\n\nimport { describe, test, expect } from \"b"
  },
  {
    "path": "packages/cli/src/adapters/model-catalog.ts",
    "chars": 5799,
    "preview": "/**\n * Centralized model metadata catalog.\n *\n * Eliminates scattered hardcoded model metadata across adapter files.\n * "
  },
  {
    "path": "packages/cli/src/adapters/model-dialect.ts",
    "chars": 1050,
    "preview": "/**\n * ModelDialect — translates model-specific dialect differences.\n *\n * Each model family has its own dialect: contex"
  },
  {
    "path": "packages/cli/src/adapters/ollama-api-format.ts",
    "chars": 3842,
    "preview": "/**\n * OllamaAPIFormat — Layer 1 wire format for OllamaCloud API.\n *\n * Converts Claude messages to OllamaCloud's simple"
  },
  {
    "path": "packages/cli/src/adapters/openai-api-format.ts",
    "chars": 4544,
    "preview": "/**\n * OpenAIAPIFormat — Layer 1 wire format for OpenAI Chat Completions API.\n *\n * Handles:\n * - Context window detecti"
  },
  {
    "path": "packages/cli/src/adapters/openrouter-api-format.ts",
    "chars": 6068,
    "preview": "/**\n * OpenRouterAPIFormat — Layer 1 wire format for OpenRouter API.\n *\n * Wraps a model-specific dialect (Grok, Gemini,"
  },
  {
    "path": "packages/cli/src/adapters/qwen-model-dialect.ts",
    "chars": 2573,
    "preview": "/**\n * QwenModelDialect — Layer 2 dialect for Qwen (Alibaba) models.\n *\n * Handles Qwen-specific quirks:\n * - Strips spe"
  },
  {
    "path": "packages/cli/src/adapters/tool-name-utils.ts",
    "chars": 1607,
    "preview": "/**\n * Tool name truncation utilities for model adapters\n *\n * Some model APIs (e.g., OpenAI) impose a maximum length on"
  },
  {
    "path": "packages/cli/src/adapters/xiaomi-model-dialect.ts",
    "chars": 1638,
    "preview": "/**\n * XiaomiModelDialect — Layer 2 dialect for Xiaomi (MiMo) models.\n *\n * Handles Xiaomi-specific quirks:\n * - 64-char"
  },
  {
    "path": "packages/cli/src/auth/auth-commands.ts",
    "chars": 3680,
    "preview": "/**\n * Unified login/logout subcommands for OAuth providers.\n *\n * Usage:\n *   claudish login [provider]   - Interactive"
  },
  {
    "path": "packages/cli/src/auth/codex-oauth.ts",
    "chars": 18394,
    "preview": "/**\n * OpenAI Codex OAuth Authentication Manager\n *\n * Handles OAuth2 PKCE flow for OpenAI Codex API access via ChatGPT "
  },
  {
    "path": "packages/cli/src/auth/gemini-oauth.ts",
    "chars": 25086,
    "preview": "/**\n * Gemini OAuth Authentication Manager\n *\n * Handles OAuth2 PKCE flow for Gemini Code Assist API access.\n * Supports"
  },
  {
    "path": "packages/cli/src/auth/kimi-oauth.ts",
    "chars": 19100,
    "preview": "/**\n * Kimi OAuth Authentication Manager\n *\n * Handles Device Authorization Grant (RFC 8628) for Kimi/Moonshot AI API ac"
  },
  {
    "path": "packages/cli/src/auth/oauth-manager.ts",
    "chars": 6255,
    "preview": "/**\n * OAuthManager — shared base class for all OAuth providers.\n *\n * Handles:\n * - Credential file I/O with 0600 permi"
  },
  {
    "path": "packages/cli/src/auth/oauth-registry.ts",
    "chars": 3582,
    "preview": "import { existsSync, readFileSync } from \"node:fs\";\nimport { join } from \"node:path\";\nimport { homedir } from \"node:os\";"
  },
  {
    "path": "packages/cli/src/auth/quota-command.ts",
    "chars": 15483,
    "preview": "/**\n * Quota/usage subcommand for OAuth providers.\n *\n * Usage:\n *   claudish quota [provider]   - Show quota usage for "
  },
  {
    "path": "packages/cli/src/auth/vertex-auth.ts",
    "chars": 8056,
    "preview": "/**\n * Vertex AI OAuth Authentication Manager\n *\n * Handles OAuth2 token generation for full Vertex AI access.\n * Suppor"
  },
  {
    "path": "packages/cli/src/channel/e2e-channel.test.ts",
    "chars": 13979,
    "preview": "/**\n * E2E tests for channel mode using real Claude Code.\n *\n * Spawns `claude -p` with `--mcp-config` pointing at our M"
  },
  {
    "path": "packages/cli/src/channel/index.ts",
    "chars": 346,
    "preview": "export { ScrollbackBuffer } from \"./scrollback-buffer.js\";\nexport { SignalWatcher } from \"./signal-watcher.js\";\nexport {"
  },
  {
    "path": "packages/cli/src/channel/scrollback-buffer.test.ts",
    "chars": 2955,
    "preview": "import { describe, test, expect } from \"bun:test\";\nimport { ScrollbackBuffer } from \"./scrollback-buffer.js\";\n\ndescribe("
  },
  {
    "path": "packages/cli/src/channel/scrollback-buffer.ts",
    "chars": 2145,
    "preview": "// ─── ScrollbackBuffer ────────────────────────────────────────────────────────\n//\n// In-memory ring buffer for PTY out"
  },
  {
    "path": "packages/cli/src/channel/session-manager.test.ts",
    "chars": 15329,
    "preview": "/**\n * Unit tests for SessionManager.\n *\n * SessionManager normally spawns `claudish`, but here we intercept by\n * prepe"
  },
  {
    "path": "packages/cli/src/channel/session-manager.ts",
    "chars": 11326,
    "preview": "// ─── SessionManager ──────────────────────────────────────────────────────────\n//\n// Manages the lifecycle of channel "
  },
  {
    "path": "packages/cli/src/channel/signal-watcher.test.ts",
    "chars": 4518,
    "preview": "import { describe, test, expect, beforeEach, afterEach } from \"bun:test\";\nimport { SignalWatcher } from \"./signal-watche"
  },
  {
    "path": "packages/cli/src/channel/signal-watcher.ts",
    "chars": 5418,
    "preview": "// ─── SignalWatcher ────────────────────────────────────────────────────────────\n//\n// Per-session state machine that d"
  },
  {
    "path": "packages/cli/src/channel/test-helpers/fake-claudish.ts",
    "chars": 1787,
    "preview": "#!/usr/bin/env bun\n/**\n * Fake claudish binary for session-manager unit tests.\n *\n * Behavior is controlled via CLI flag"
  },
  {
    "path": "packages/cli/src/channel/types.ts",
    "chars": 1379,
    "preview": "// ─── Channel Mode Types ──────────────────────────────────────────────────────\n\nexport type SessionStatus =\n  | \"start"
  },
  {
    "path": "packages/cli/src/claude-runner.ts",
    "chars": 23904,
    "preview": "import type { ChildProcess } from \"node:child_process\";\nimport { spawn } from \"node:child_process\";\nimport { writeFileSy"
  },
  {
    "path": "packages/cli/src/cli-passthrough.test.ts",
    "chars": 18411,
    "preview": "/**\n * E2E tests for the flag passthrough feature.\n *\n * Validates the complete flow: parseArgs → arg-building logic (as"
  },
  {
    "path": "packages/cli/src/cli.test.ts",
    "chars": 11735,
    "preview": "/**\n * Black box tests for parseArgs() in cli.ts.\n *\n * Tests are derived solely from requirements and API contracts:\n *"
  },
  {
    "path": "packages/cli/src/cli.ts",
    "chars": 79003,
    "preview": "import { VERSION } from \"./version.js\";\nimport { ENV } from \"./config.js\";\nimport type { ClaudishConfig } from \"./types."
  },
  {
    "path": "packages/cli/src/config-command.ts",
    "chars": 24593,
    "preview": "/**\n * Claudish Config TUI\n *\n * Interactive configuration menu for claudish. Allows users to:\n *   - Set/remove API key"
  },
  {
    "path": "packages/cli/src/config-schema.test.ts",
    "chars": 4214,
    "preview": "import { describe, expect, test } from \"bun:test\";\nimport {\n  BuiltinDefaultProviderSchema,\n  CustomEndpointComplexSchem"
  },
  {
    "path": "packages/cli/src/config-schema.ts",
    "chars": 3035,
    "preview": "/**\n * Config schemas for the LiteLLM-demotion refactor (Phase 1).\n *\n * Defines:\n *   - BuiltinDefaultProviderSchema — "
  },
  {
    "path": "packages/cli/src/config.ts",
    "chars": 2492,
    "preview": "// Claudish configuration constants\n\nexport const DEFAULT_PORT_RANGE = { start: 3000, end: 9000 };\n\n// Environment varia"
  },
  {
    "path": "packages/cli/src/default-provider.test.ts",
    "chars": 4893,
    "preview": "import { describe, expect, test } from \"bun:test\";\nimport {\n  buildLegacyHint,\n  resolveDefaultProvider,\n  type Resolved"
  },
  {
    "path": "packages/cli/src/default-provider.ts",
    "chars": 3505,
    "preview": "/**\n * Pure resolver for the effective default provider used when a bare model name\n * is supplied without an explicit `"
  },
  {
    "path": "packages/cli/src/diag-output.ts",
    "chars": 3226,
    "preview": "import { createWriteStream, mkdirSync, writeFileSync, unlinkSync } from \"node:fs\";\nimport { homedir } from \"node:os\";\nim"
  },
  {
    "path": "packages/cli/src/format-translation.test.ts",
    "chars": 57967,
    "preview": "/**\n * Format Translation Integration Tests\n *\n * Tests the SSE stream parser pipeline by replaying real (or seed) SSE f"
  },
  {
    "path": "packages/cli/src/glm-adapter.test.ts",
    "chars": 8844,
    "preview": "/**\n * E2E tests for GLM dialect and three-layer adapter architecture.\n *\n * Validates:\n * 1. GLMModelDialect model dete"
  },
  {
    "path": "packages/cli/src/handlers/composed-handler.test.ts",
    "chars": 1988,
    "preview": "import { describe, expect, test } from \"bun:test\";\nimport type { ProviderTransport } from \"../providers/transport/types."
  },
  {
    "path": "packages/cli/src/handlers/composed-handler.ts",
    "chars": 37175,
    "preview": "/**\n * ComposedHandler — composes a ProviderTransport + ModelAdapter to implement ModelHandler.\n *\n * This is the univer"
  },
  {
    "path": "packages/cli/src/handlers/default-provider-e2e.test.ts",
    "chars": 30365,
    "preview": "/**\n * Phase 5 end-to-end tests for the LiteLLM-demotion refactor.\n *\n * Black-box tests. The proxy is invoked in-proces"
  },
  {
    "path": "packages/cli/src/handlers/fallback-handler.test.ts",
    "chars": 18984,
    "preview": "/**\n * E2E tests for the provider fallback mechanism.\n *\n * These tests use REAL API tokens and hit actual provider endp"
  },
  {
    "path": "packages/cli/src/handlers/fallback-handler.ts",
    "chars": 7829,
    "preview": "/**\n * FallbackHandler — tries multiple providers in priority order.\n *\n * When the primary provider fails with a retrya"
  },
  {
    "path": "packages/cli/src/handlers/native-handler-advisor.test.ts",
    "chars": 15863,
    "preview": "import { afterEach, describe, expect, it } from \"bun:test\";\nimport {\n  _debug_getTrackedAdvisorIds,\n  _debug_resetTracke"
  },
  {
    "path": "packages/cli/src/handlers/native-handler-advisor.ts",
    "chars": 22697,
    "preview": "/**\n * Advisor-tool transformer for NativeHandler (monitor mode).\n *\n * PURPOSE — experimental\n * ======================"
  },
  {
    "path": "packages/cli/src/handlers/native-handler.ts",
    "chars": 11234,
    "preview": "import type { Context } from \"hono\";\nimport type { ModelHandler } from \"./types.js\";\nimport { log, maskCredential } from"
  },
  {
    "path": "packages/cli/src/handlers/shared/anthropic-error.test.ts",
    "chars": 4809,
    "preview": "import { describe, it, expect } from \"bun:test\";\nimport {\n  statusToErrorType,\n  wrapAnthropicError,\n  ensureAnthropicEr"
  },
  {
    "path": "packages/cli/src/handlers/shared/anthropic-error.ts",
    "chars": 2541,
    "preview": "/**\n * Anthropic error envelope wrapper.\n * All proxy error responses MUST use this format.\n */\n\nexport type AnthropicEr"
  },
  {
    "path": "packages/cli/src/handlers/shared/format/identity-filter.ts",
    "chars": 820,
    "preview": "/**\n * Identity filter for Claude-specific markers in system prompts.\n *\n * Removes or replaces Claude-specific identity"
  },
  {
    "path": "packages/cli/src/handlers/shared/format/openai-messages.ts",
    "chars": 5497,
    "preview": "/**\n * OpenAI message format conversion utilities.\n *\n * Converts Claude/Anthropic message format to OpenAI message form"
  },
  {
    "path": "packages/cli/src/handlers/shared/format/openai-tools.ts",
    "chars": 4384,
    "preview": "/**\n * OpenAI tool schema conversion utilities.\n *\n * Converts Claude/Anthropic tool definitions to OpenAI function form"
  },
  {
    "path": "packages/cli/src/handlers/shared/gemini-queue.ts",
    "chars": 8188,
    "preview": "/**\n * Gemini Request Queue\n *\n * Singleton request queue for serializing Gemini API requests to prevent rate limit exha"
  },
  {
    "path": "packages/cli/src/handlers/shared/gemini-schema.ts",
    "chars": 5619,
    "preview": "/**\n * Gemini Schema Utilities\n *\n * Shared utilities for converting JSON Schema to Gemini's API format.\n * Used by both"
  },
  {
    "path": "packages/cli/src/handlers/shared/local-queue.ts",
    "chars": 10942,
    "preview": "/**\n * Local Model Request Queue\n *\n * Singleton queue for controlling concurrency to local models (Ollama, LM Studio, v"
  },
  {
    "path": "packages/cli/src/handlers/shared/openai-compat.ts",
    "chars": 717,
    "preview": "/**\n * Re-export shim for backwards compatibility.\n * All implementations have moved to focused modules:\n * - format/ope"
  },
  {
    "path": "packages/cli/src/handlers/shared/openrouter-queue.ts",
    "chars": 15197,
    "preview": "/**\n * OpenRouter Request Queue\n *\n * Singleton request queue for serializing OpenRouter API requests to prevent rate li"
  },
  {
    "path": "packages/cli/src/handlers/shared/remote-provider-types.ts",
    "chars": 5215,
    "preview": "/**\n * Types for remote API providers (OpenRouter, Gemini, OpenAI)\n *\n * These types define the common interface for clo"
  },
  {
    "path": "packages/cli/src/handlers/shared/stream-parsers/anthropic-sse.ts",
    "chars": 12501,
    "preview": "/**\n * Anthropic SSE passthrough stream parser.\n *\n * For providers that speak native Anthropic format (MiniMax, Kimi, Z"
  },
  {
    "path": "packages/cli/src/handlers/shared/stream-parsers/gemini-sse.ts",
    "chars": 10868,
    "preview": "/**\n * Gemini SSE → Claude SSE stream parser.\n *\n * Gemini streams SSE with `data: {\"candidates\": [{\"content\": {\"parts\":"
  },
  {
    "path": "packages/cli/src/handlers/shared/stream-parsers/index.ts",
    "chars": 576,
    "preview": "/**\n * Stream parsers — convert provider-specific streaming formats to Claude SSE.\n *\n * Each parser takes a Response fr"
  },
  {
    "path": "packages/cli/src/handlers/shared/stream-parsers/ollama-jsonl.ts",
    "chars": 5044,
    "preview": "/**\n * Ollama JSONL → Claude SSE stream parser.\n *\n * Ollama sends line-by-line JSON (NOT SSE):\n *   {\"message\": {\"conte"
  },
  {
    "path": "packages/cli/src/handlers/shared/stream-parsers/openai-responses-sse.ts",
    "chars": 12583,
    "preview": "/**\n * OpenAI Responses API SSE → Claude SSE stream parser.\n *\n * Handles Codex models that use /v1/responses instead of"
  },
  {
    "path": "packages/cli/src/handlers/shared/stream-parsers/openai-sse.ts",
    "chars": 29917,
    "preview": "/**\n * OpenAI SSE → Claude SSE stream parser.\n *\n * Converts OpenAI-compatible Server-Sent Events to Claude SSE format.\n"
  },
  {
    "path": "packages/cli/src/handlers/shared/token-tracker.ts",
    "chars": 9061,
    "preview": "/**\n * TokenTracker — unified token tracking and cost accounting.\n *\n * Replaces the 8 independent writeTokenFile implem"
  }
]

// ... and 152 more files (download for full content)