@balpal4495/quorum 3.3.2 → 3.3.3

package/bin/__tests__/chronicle.test.js

@@ -0,0 +1,80 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest"
+import { promises as fs } from "fs"
+import path from "path"
+import os from "os"
+import { findChronicleDir } from "../shared/chronicle.js"
+
+// ── helpers ───────────────────────────────────────────────────────────────────
+
+async function makeTmpDir() {
+  return fs.mkdtemp(path.join(os.tmpdir(), "quorum-test-"))
+}
+
+async function rmrf(dir) {
+  await fs.rm(dir, { recursive: true, force: true })
+}
+
+// ── findChronicleDir ──────────────────────────────────────────────────────────
+
+describe("findChronicleDir", () => {
+  let tmpDir
+
+  beforeEach(async () => {
+    tmpDir = await makeTmpDir()
+  })
+
+  afterEach(async () => {
+    await rmrf(tmpDir)
+  })
+
+  it("returns the .chronicle path when found directly in startDir", async () => {
+    const chronicleDir = path.join(tmpDir, ".chronicle")
+    await fs.mkdir(chronicleDir)
+
+    const result = await findChronicleDir(tmpDir)
+    expect(result).toBe(chronicleDir)
+  })
+
+  it("walks up the tree to find .chronicle in a parent directory", async () => {
+    const chronicleDir = path.join(tmpDir, ".chronicle")
+    await fs.mkdir(chronicleDir)
+
+    // Nested three levels deep — chronicle lives at root
+    const nested = path.join(tmpDir, "src", "components", "ui")
+    await fs.mkdir(nested, { recursive: true })
+
+    const result = await findChronicleDir(nested)
+    expect(result).toBe(chronicleDir)
+  })
+
+  it("returns null when no .chronicle directory exists anywhere in the tree", async () => {
+    const nested = path.join(tmpDir, "src", "deep")
+    await fs.mkdir(nested, { recursive: true })
+
+    const result = await findChronicleDir(nested)
+    expect(result).toBeNull()
+  })
+
+  it("ignores a .chronicle file (not a directory)", async () => {
+    // .chronicle exists as a file — must not be returned
+    await fs.writeFile(path.join(tmpDir, ".chronicle"), "not a dir")
+
+    const result = await findChronicleDir(tmpDir)
+    expect(result).toBeNull()
+  })
+
+  it("finds the nearest .chronicle when multiple exist in ancestor chain", async () => {
+    // Parent has a .chronicle, nested subdir has its own .chronicle
+    const parentChronicle = path.join(tmpDir, ".chronicle")
+    await fs.mkdir(parentChronicle)
+
+    const subDir = path.join(tmpDir, "sub")
+    const subChronicle = path.join(subDir, ".chronicle")
+    await fs.mkdir(subDir)
+    await fs.mkdir(subChronicle)
+
+    // From inside subDir — should find the closer one
+    const result = await findChronicleDir(subDir)
+    expect(result).toBe(subChronicle)
+  })
+})

package/bin/shared/llm.js

@@ -5,25 +5,52 @@ import path from "path"
 const execAsync = promisify(exec)
 
 /**
- * Auto-detect an available LLM provider from the environment.
+ * Auto-detect all available LLM providers from the environment and return a
+ * cascading provider that falls back automatically on quota / rate-limit errors.
  *
- * Priority:
+ * Detection order (highest priority first):
  *   1. ANTHROPIC_API_KEY            → Anthropic Claude
  *   2. OPENAI_API_KEY               → OpenAI (or compatible via OPENAI_BASE_URL)
  *   3. GEMINI_API_KEY               → Google Gemini (API)
- *   4. OPENAI_BASE_URL (no key)     → OpenAI-compatible endpoint (Azure, Groq, Ollama, etc.)
- *   5. OLLAMA_HOST env var          → Ollama (explicit host)
- *   6. localhost:11434 probe        → Ollama (auto-detect)
- *   7. gemini CLI in PATH           → Google Gemini (CLI subprocess)
+ *   4. OPENAI_BASE_URL (no key)     → OpenAI-compatible endpoint (Azure, Groq, etc.)
+ *   5. OLLAMA_HOST / localhost:11434 → Ollama (probed in parallel with the above)
+ *   6. gemini CLI in PATH           → Google Gemini (CLI subprocess)
  *
- * Returns { llm: LLMProvider, name: string } or null.
+ * All detected providers are tried in order. A 429 / quota / rate-limit error
+ * from one provider causes a silent fallback to the next rather than a hard
+ * failure. Only non-quota errors or exhausting all providers throws.
+ *
+ * Returns { llm, name } where name is the primary provider, or null if none found.
  */
 export async function detectProvider() {
+  const candidates = await gatherCandidates()
+  if (candidates.length === 0) return null
+  if (candidates.length === 1) return candidates[0]
+
+  return {
+    llm:  createCascadingLLM(candidates),
+    name: candidates[0].name,
+  }
+}
+
+/**
+ * Collect every available provider — all that can be detected run in parallel.
+ * Ollama is probed concurrently with API-key checks so it doesn't add latency.
+ */
+async function gatherCandidates() {
+  // Probe async sources concurrently
+  const [ollamaModel, geminiCLIAvail] = await Promise.all([
+    probeOllama(process.env.OLLAMA_HOST || "http://localhost:11434"),
+    probeGeminiCLI(),
+  ])
+
+  const candidates = []
+
   if (process.env.ANTHROPIC_API_KEY) {
-    return {
+    candidates.push({
       llm:  createAnthropicProvider(process.env.ANTHROPIC_API_KEY),
       name: "Anthropic",
-    }
+    })
   }
 
   if (process.env.OPENAI_API_KEY) {
@@ -31,45 +58,75 @@ export async function detectProvider() {
     const name = base
       ? `OpenAI-compatible (${new URL(base).hostname})`
       : "OpenAI"
-    return {
+    candidates.push({
       llm:  createOpenAICompatProvider(process.env.OPENAI_API_KEY, base || "https://api.openai.com/v1"),
       name,
-    }
+    })
+  } else if (process.env.OPENAI_BASE_URL) {
+    const base = process.env.OPENAI_BASE_URL.replace(/\/$/, "")
+    candidates.push({
+      llm:  createOpenAICompatProvider("", base),
+      name: `OpenAI-compatible (${new URL(base).hostname})`,
+    })
   }
 
   if (process.env.GEMINI_API_KEY) {
-    return {
+    candidates.push({
       llm:  createGeminiProvider(process.env.GEMINI_API_KEY),
       name: "Gemini",
-    }
-  }
-
-  if (process.env.OPENAI_BASE_URL) {
-    const base = process.env.OPENAI_BASE_URL.replace(/\/$/, "")
-    return {
-      llm:  createOpenAICompatProvider("", base),
-      name: `OpenAI-compatible (${new URL(base).hostname})`,
-    }
+    })
   }
 
-  const ollamaHost = process.env.OLLAMA_HOST || "http://localhost:11434"
-  const ollamaModel = await probeOllama(ollamaHost)
   if (ollamaModel) {
-    return {
-      llm:  createOpenAICompatProvider("", `${ollamaHost}/v1`, ollamaModel),
+    const host = process.env.OLLAMA_HOST || "http://localhost:11434"
+    candidates.push({
+      llm:  createOpenAICompatProvider("", `${host}/v1`, ollamaModel),
       name: `Ollama (${ollamaModel})`,
-    }
+    })
   }
 
-  const geminiCLI = await probeGeminiCLI()
-  if (geminiCLI) {
-    return {
+  if (geminiCLIAvail) {
+    candidates.push({
       llm:  createGeminiCLIProvider(),
       name: "Gemini CLI",
-    }
+    })
   }
 
-  return null
+  return candidates
+}
+
+/**
+ * Returns true if the error looks like a quota / rate-limit response
+ * (HTTP 429, "quota exceeded", "rate limit", etc.).
+ */
+function isQuotaError(err) {
+  return /429|quota|rate.?limit/i.test(String(err?.message ?? ""))
+}
+
+/**
+ * Wraps multiple provider functions into a single LLM function.
+ * On a quota error the next provider is tried automatically with a stderr notice.
+ * All other errors are re-thrown immediately from the failing provider.
+ */
+function createCascadingLLM(candidates) {
+  return async function llm(messages, model) {
+    let lastErr
+    for (let i = 0; i < candidates.length; i++) {
+      try {
+        return await candidates[i].llm(messages, model)
+      } catch (err) {
+        lastErr = err
+        if (isQuotaError(err) && i < candidates.length - 1) {
+          process.stderr.write(
+            `\n  ⚠  ${candidates[i].name} quota/rate-limit — falling back to ${candidates[i + 1].name}\n\n`,
+          )
+          continue
+        }
+        throw err
+      }
+    }
+    throw lastErr
+  }
 }
 
 /** Convenience wrapper — returns the provider function or null. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@balpal4495/quorum",
-  "version": "3.3.2",
+  "version": "3.3.3",
   "description": "Git-backed memory and design review for AI coding agents",
   "type": "module",
   "license": "MIT",
@@ -43,8 +43,8 @@
   },
   "scripts": {
     "build": "tsc -p tsconfig.build.json",
-    "test": "vitest run modules/ evals/",
-    "test:watch": "vitest modules/",
+    "test": "vitest run modules/ evals/ bin/",
+    "test:watch": "vitest modules/ bin/",
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {