devlensio 0.4.3 → 0.6.0

package/dist/graph/index.js

@@ -5,6 +5,7 @@ import { detectEventEdges } from "./edges/eventEdges.js";
 import { detectGuardEdges } from "./edges/guardEdges.js";
 import { detectHookEdges } from "./edges/hookEdges.js";
 import { detectImportEdges } from "./edges/importEdges.js";
+import { detectNavigationEdges } from "./edges/navigationEdges.js";
 import { detectPropEdges } from "./edges/propEdges.js";
 import { detectRouteEdges } from "./edges/routeEdge.js";
 import { detectStateEdges } from "./edges/stateEdges.js";
@@ -29,6 +30,7 @@ export function detectEdges(nodes, routeNodes, repoPath, fingerprint) {
     const guardEdges = detectGuardEdges(nodes, lookupMp, routeNodes, repoPath, fingerprint);
     const testEdges = detectTestEdges(lookupMp, repoPath); // This does not needs nodes, as it detect edges from the file
     const nextjsApiCallEdges = detectNextjsApiCallEdges(nodes, repoPath);
+    const navResult = detectNavigationEdges(nodes, repoPath);
     // Collect all dynamically-created third-party method nodes (dedup by id)
     const newThirdPartyNodesMap = new Map();
     for (const n of [...importResult.thirdPartyMethodNodes, ...callResult.newThirdPartyNodes]) {
@@ -49,6 +51,8 @@ export function detectEdges(nodes, routeNodes, repoPath, fingerprint) {
     console.log(`  Ghost nodes created: ${eventResults.ghostNodes.length}`);
     console.log(`  Third-party method nodes: ${newThirdPartyNodes.length}`);
     console.log(` NEXTJS_API_CALL edges: ${nextjsApiCallEdges.length}`);
+    console.log(`  NAVIGATES_TO edges: ${navResult.edges.length}`);
+    console.log(`  Navigation ghost route nodes: ${navResult.ghostNodes.length}`);
     const allEdges = [
         ...callEdges,
         ...importEdges,
@@ -60,10 +64,17 @@ export function detectEdges(nodes, routeNodes, repoPath, fingerprint) {
         ...guardEdges,
         ...testEdges,
         ...nextjsApiCallEdges,
+        ...navResult.edges,
     ];
     console.log(`Total edges detected: ${allEdges.length}`);
+    // Merge nav ghost route nodes, deduped by id (never overwrite a real node).
+    const allGhostMap = new Map();
+    for (const n of [...eventResults.ghostNodes, ...newThirdPartyNodes, ...navResult.ghostNodes]) {
+        if (!allGhostMap.has(n.id))
+            allGhostMap.set(n.id, n);
+    }
     return {
         edges: allEdges,
-        ghostNodes: [...eventResults.ghostNodes, ...newThirdPartyNodes],
+        ghostNodes: [...allGhostMap.values()],
     };
 }

package/dist/graph/index.test.js

@@ -9,8 +9,10 @@ import { detectStateEdges } from "./edges/stateEdges.js";
 import { detectPropEdges } from "./edges/propEdges.js";
 import { detectEventEdges } from "./edges/eventEdges.js";
 import { detectGuardEdges } from "./edges/guardEdges.js";
+import { detectRouteEdges } from "./edges/routeEdge.js";
 import { detectEdges } from "./index.js";
-// ─── Helpers ──────────────────────────────────────────────────────────────────
+import { detectNavigationEdges } from "./edges/navigationEdges.js";
+//  Helpers 
 function createFakeRepo(files) {
     const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "devlens-graph-test-"));
     for (const [filePath, content] of Object.entries(files)) {
@@ -46,7 +48,7 @@ function debugNodes(repoPath) {
     }
     return nodes;
 }
-// ─── CALLS edges ──────────────────────────────────────────────────────────────
+//  CALLS edges 
 describe("detectCallEdges", () => {
     it("should detect a direct function call", () => {
         const repoPath = createFakeRepo({
@@ -107,7 +109,7 @@ describe("detectCallEdges", () => {
         deleteFakeRepo(repoPath);
     });
 });
-// ─── IMPORTS edges ────────────────────────────────────────────────────────────
+//  IMPORTS edges 
 describe("detectImportEdges", () => {
     it("should detect relative imports between files", () => {
         // Both files in same src/ folder so relative import resolves cleanly
@@ -177,7 +179,7 @@ describe("detectImportEdges", () => {
         deleteFakeRepo(repoPath);
     });
 });
-// ─── STATE edges ──────────────────────────────────────────────────────────────
+//  STATE edges 
 describe("detectStateEdges", () => {
     it("should detect zustand store usage in a component", () => {
         const repoPath = createFakeRepo({
@@ -264,7 +266,7 @@ describe("detectStateEdges", () => {
         deleteFakeRepo(repoPath);
     });
 });
-// ─── PROP_PASS edges ──────────────────────────────────────────────────────────
+//  PROP_PASS edges 
 describe("detectPropEdges", () => {
     it("should detect prop passing from parent to child", () => {
         const repoPath = createFakeRepo({
@@ -346,7 +348,7 @@ describe("detectPropEdges", () => {
         deleteFakeRepo(repoPath);
     });
 });
-// ─── EVENT edges ──────────────────────────────────────────────────────────────
+//  EVENT edges 
 describe("detectEventEdges", () => {
     it("should detect custom event emitter and create ghost node", () => {
         const repoPath = createFakeRepo({
@@ -406,7 +408,7 @@ describe("detectEventEdges", () => {
         deleteFakeRepo(repoPath);
     });
 });
-// ─── GUARDS edges ─────────────────────────────────────────────────────────────
+//  GUARDS edges 
 describe("detectGuardEdges", () => {
     it("should detect Next.js middleware guards", () => {
         const repoPath = createFakeRepo({
@@ -501,7 +503,7 @@ describe("detectGuardEdges", () => {
         deleteFakeRepo(repoPath);
     });
 });
-// ─── Full pipeline ────────────────────────────────────────────────────────────
+//  Full pipeline 
 describe("detectEdges", () => {
     it("should return edges and ghost nodes from full pipeline", () => {
         const repoPath = createFakeRepo({
@@ -540,3 +542,256 @@ describe("detectEdges", () => {
         deleteFakeRepo(repoPath);
     });
 });
+//  NAVIGATES_TO edges 
+describe("detectNavigationEdges", () => {
+    // Synthesizes a navigable ROUTE CodeNode the way routesToCodeNodes would,
+    // so detectNavigationEdges can build its route index from it.
+    function makeRouteCodeNode(urlPath, opts = {}) {
+        const filePath = opts.filePath ?? "src/router.tsx";
+        return {
+            id: `${filePath}::${urlPath}`,
+            name: urlPath,
+            type: "ROUTE",
+            filePath,
+            startLine: 1,
+            endLine: 1,
+            metadata: {
+                urlPath,
+                routeNodeType: "REACT_ROUTER_ROUTE",
+                isDynamic: opts.isDynamic ?? false,
+                framework: "react-router",
+                routeKind: "react-router",
+            },
+        };
+    }
+    it("creates a NAVIGATES_TO edge for navigate('/dashboard')", () => {
+        const repoPath = createFakeRepo({
+            "src/Page.tsx": `
+        import { useNavigate } from "react-router-dom";
+        export function Page() {
+          const navigate = useNavigate();
+          function go() { navigate('/dashboard'); }
+          return <button onClick={go}>Go</button>;
+        }
+      `,
+        });
+        const { nodes } = parseRepo(repoPath);
+        const routeNode = makeRouteCodeNode("/dashboard");
+        const { edges } = detectNavigationEdges([...nodes, routeNode], repoPath);
+        const navEdge = edges.find((e) => e.type === "NAVIGATES_TO" && e.to === routeNode.id);
+        expect(navEdge).toBeDefined();
+        expect(navEdge?.metadata?.matchType).toBe("exact");
+        deleteFakeRepo(repoPath);
+    });
+    it("matches router.push('/users/123') against a dynamic /users/:id route", () => {
+        const repoPath = createFakeRepo({
+            "src/Page.tsx": `
+        import { useRouter } from "next/navigation";
+        export function Page() {
+          const router = useRouter();
+          function go() { router.push('/users/123'); }
+          return null;
+        }
+      `,
+        });
+        const { nodes } = parseRepo(repoPath);
+        const routeNode = makeRouteCodeNode("/users/:id", { isDynamic: true });
+        const { edges } = detectNavigationEdges([...nodes, routeNode], repoPath);
+        const navEdge = edges.find((e) => e.type === "NAVIGATES_TO" && e.to === routeNode.id);
+        expect(navEdge).toBeDefined();
+        expect(navEdge?.metadata?.matchType).toBe("dynamic");
+        deleteFakeRepo(repoPath);
+    });
+    it("creates a NAVIGATES_TO edge for <Link to>", () => {
+        const repoPath = createFakeRepo({
+            "src/Nav.tsx": `
+        import { Link } from "react-router-dom";
+        export function Nav() {
+          return <Link to="/about">About</Link>;
+        }
+      `,
+        });
+        const { nodes } = parseRepo(repoPath);
+        const routeNode = makeRouteCodeNode("/about");
+        const { edges } = detectNavigationEdges([...nodes, routeNode], repoPath);
+        expect(edges.find((e) => e.type === "NAVIGATES_TO" && e.to === routeNode.id)).toBeDefined();
+        deleteFakeRepo(repoPath);
+    });
+    it("detects native window.location.href and window.history.pushState", () => {
+        const repoPath = createFakeRepo({
+            "src/nav.ts": `
+        export function login() {
+          window.location.href = '/login';
+        }
+        export function pushX() {
+          window.history.pushState(null, '', '/x');
+        }
+      `,
+        });
+        const { nodes } = parseRepo(repoPath);
+        const loginRoute = makeRouteCodeNode("/login");
+        const xRoute = makeRouteCodeNode("/x");
+        const { edges } = detectNavigationEdges([...nodes, loginRoute, xRoute], repoPath);
+        expect(edges.find((e) => e.type === "NAVIGATES_TO" && e.to === loginRoute.id)).toBeDefined();
+        expect(edges.find((e) => e.type === "NAVIGATES_TO" && e.to === xRoute.id)).toBeDefined();
+        deleteFakeRepo(repoPath);
+    });
+    it("creates an unresolved ghost route (never [npm]/-prefixed) for an unmatched path", () => {
+        const repoPath = createFakeRepo({
+            "src/Page.tsx": `
+        import { useNavigate } from "react-router-dom";
+        export function Page() {
+          const navigate = useNavigate();
+          function go() { navigate('/nope-not-a-route'); }
+          return null;
+        }
+      `,
+        });
+        const { nodes } = parseRepo(repoPath);
+        // No matching route node provided → should synthesize an unresolved ghost.
+        const { edges, ghostNodes } = detectNavigationEdges([...nodes], repoPath);
+        const ghost = ghostNodes.find((n) => n.id === "[route]::/nope-not-a-route");
+        expect(ghost).toBeDefined();
+        expect(ghost?.type).toBe("ROUTE");
+        expect(ghost?.id.startsWith("[npm]/")).toBe(false);
+        expect(ghost?.metadata.isUnresolved).toBe(true);
+        const edge = edges.find((e) => e.to === "[route]::/nope-not-a-route");
+        expect(edge?.metadata?.matchType).toBe("unresolved");
+        deleteFakeRepo(repoPath);
+    });
+    it("does NOT create a NAVIGATES_TO edge for <Link> from a non-routing lib (MUI)", () => {
+        const repoPath = createFakeRepo({
+            "src/Nav.tsx": `
+        import { Link } from "@mui/material";
+        export function Nav() {
+          return <Link href="/about">About</Link>;
+        }
+      `,
+        });
+        const { nodes } = parseRepo(repoPath);
+        const routeNode = makeRouteCodeNode("/about");
+        const { edges } = detectNavigationEdges([...nodes, routeNode], repoPath);
+        expect(edges.find((e) => e.type === "NAVIGATES_TO")).toBeUndefined();
+        deleteFakeRepo(repoPath);
+    });
+    it("route node and react-router-dom THIRD_PARTY node coexist — distinct ids, no duplicates", () => {
+        const repoPath = createFakeRepo({
+            "src/Page.tsx": `
+        import { useNavigate } from "react-router-dom";
+        export function Page() {
+          const navigate = useNavigate();
+          function go() { navigate('/users'); }
+          return null;
+        }
+      `,
+        });
+        const { nodes } = parseRepo(repoPath);
+        // The react-router-dom package THIRD_PARTY node — synthesized as thirdPartyLibs
+        // would create it (keyed by name) so importEdges materializes its method node.
+        const pkgNode = {
+            id: "[npm]/react-router-dom",
+            name: "react-router-dom",
+            type: "THIRD_PARTY",
+            filePath: "[npm]/react-router-dom",
+            startLine: 0,
+            endLine: 0,
+            metadata: { isThirdParty: true, packageVersion: "6.0.0", category: "routing" },
+        };
+        const routeNode = makeRouteCodeNode("/users");
+        const inputNodes = [...nodes, pkgNode, routeNode];
+        const fingerprint = makeFingerprint({ framework: "react", router: "react-router" });
+        const result = detectEdges(inputNodes, [], repoPath, fingerprint);
+        const allNodes = [...inputNodes, ...result.ghostNodes];
+        const tpMethod = allNodes.find((n) => n.id === "[npm]/react-router-dom::useNavigate");
+        const usersRoute = allNodes.find((n) => n.type === "ROUTE" && n.id === routeNode.id);
+        // both exist, with disjoint namespaces
+        expect(tpMethod).toBeDefined();
+        expect(tpMethod?.type).toBe("THIRD_PARTY");
+        expect(usersRoute).toBeDefined();
+        expect(usersRoute?.id.startsWith("[npm]/")).toBe(false);
+        expect(tpMethod?.id).not.toBe(usersRoute?.id);
+        // no duplicate ids anywhere in the combined node set
+        const ids = allNodes.map((n) => n.id);
+        expect(new Set(ids).size).toBe(ids.length);
+        // the NAVIGATES_TO edge coexists with the third-party CALLS/IMPORTS edges
+        expect(result.edges.find((e) => e.type === "NAVIGATES_TO" && e.to === routeNode.id)).toBeDefined();
+        deleteFakeRepo(repoPath);
+    });
+});
+//  HANDLES edges for React Router routes 
+describe("detectRouteEdges — React Router", () => {
+    function makeRRRouteNode(urlPath, rendersComponent, filePath = "src/App.tsx") {
+        return {
+            id: `${filePath}::${urlPath}`,
+            name: urlPath,
+            type: "ROUTE",
+            filePath,
+            startLine: 1,
+            endLine: 1,
+            metadata: {
+                urlPath,
+                routeKind: "react-router",
+                routeNodeType: "REACT_ROUTER_ROUTE",
+                rendersComponent,
+            },
+        };
+    }
+    it("creates a HANDLES edge from a route to a component in the same file", () => {
+        const repoPath = createFakeRepo({
+            "src/App.tsx": `
+        import { Routes, Route } from "react-router-dom";
+        export function Home() { return <div>Home</div>; }
+        export default function App() {
+          return <Routes><Route path="/" element={<Home/>} /></Routes>;
+        }
+      `,
+        });
+        const { nodes } = parseRepo(repoPath);
+        const routeNode = makeRRRouteNode("/", "Home");
+        const allNodes = [...nodes, routeNode];
+        const lookup = buildLookupMaps(allNodes);
+        const edges = detectRouteEdges(allNodes, lookup);
+        const handles = edges.find((e) => e.type === "HANDLES" && e.from === routeNode.id && e.to.includes("Home"));
+        expect(handles).toBeDefined();
+        expect(handles?.metadata?.routeKind).toBe("react-router");
+        deleteFakeRepo(repoPath);
+    });
+    it("resolves a route component imported from another file", () => {
+        const repoPath = createFakeRepo({
+            "src/Home.tsx": `export default function Home() { return <div>Home</div>; }`,
+            "src/App.tsx": `
+        import { Routes, Route } from "react-router-dom";
+        import Home from "./Home";
+        export default function App() {
+          return <Routes><Route path="/" element={<Home/>} /></Routes>;
+        }
+      `,
+        });
+        const { nodes } = parseRepo(repoPath);
+        const routeNode = makeRRRouteNode("/", "Home");
+        const allNodes = [...nodes, routeNode];
+        const lookup = buildLookupMaps(allNodes);
+        const edges = detectRouteEdges(allNodes, lookup);
+        const handles = edges.find((e) => e.type === "HANDLES" && e.from === routeNode.id);
+        expect(handles).toBeDefined();
+        expect(handles?.to).toContain("Home.tsx"); // resolved across files, not App.tsx
+        deleteFakeRepo(repoPath);
+    });
+    it("leaves a route with no resolvable component as an orphan (no HANDLES edge)", () => {
+        const repoPath = createFakeRepo({
+            "src/App.tsx": `
+        import { Routes, Route } from "react-router-dom";
+        export default function App() {
+          return <Routes><Route path="/ghost" element={<Missing/>} /></Routes>;
+        }
+      `,
+        });
+        const { nodes } = parseRepo(repoPath);
+        const routeNode = makeRRRouteNode("/ghost", "Missing");
+        const allNodes = [...nodes, routeNode];
+        const lookup = buildLookupMaps(allNodes);
+        const edges = detectRouteEdges(allNodes, lookup);
+        expect(edges.find((e) => e.from === routeNode.id)).toBeUndefined();
+        deleteFakeRepo(repoPath);
+    });
+});

package/dist/index.d.ts

@@ -9,7 +9,8 @@ export * from "./pipeline/index.js";
 export * from "./config/types.js";
 export { queue } from "./jobs/index.js";
 export { storage } from "./storage/index.js";
-export { resolveConfig, initConfig, maskConfig, writeConfig } from "./config/index.js";
+export { resolveConfig, initConfig, maskConfig, writeConfig, resolveAllProviders, setActiveProvider, removeProvider as removeProviderConfig, } from "./config/index.js";
+export type { AllProvidersResult } from "./config/index.js";
 export { readPackageDependencies, categorizeLibrary } from "./graph/thirdPartyLibs.js";
 export { analyzePipeline } from "./pipeline/index.js";
 export { runSummarization } from "./summarizer/index.js";
@@ -18,3 +19,7 @@ export { EDGE_LABELS } from "./summarizer/prompts.js";
 export { CycleGroup, TopologicalResult } from "./summarizer/types.js";
 export { buildGraphIndex, getBlastRadius, getKHop, getSubgraph, findCycles, } from "./graph/traversal.js";
 export type { GraphIndex, TraversalHit, TraversalResult, TraversalOpts, SubgraphResult, } from "./graph/traversal.js";
+export { loadCatalog, findProvider, saveProvider, removeProvider, resetUserCatalog, listUserProviders, } from "./config/providers/catalog.js";
+export type { CatalogProvider, CatalogProviderInput } from "./config/providers/catalog.js";
+export { listModels } from "./summarizer/providers/models.js";
+export type { ListModelsOpts } from "./summarizer/providers/models.js";

package/dist/index.js

@@ -11,7 +11,7 @@ export * from "./config/types.js";
 export { queue } from "./jobs/index.js";
 export { storage } from "./storage/index.js";
 // Config helpers
-export { resolveConfig, initConfig, maskConfig, writeConfig } from "./config/index.js";
+export { resolveConfig, initConfig, maskConfig, writeConfig, resolveAllProviders, setActiveProvider, removeProvider as removeProviderConfig, } from "./config/index.js";
 // Pre-scan helpers
 export { readPackageDependencies, categorizeLibrary } from "./graph/thirdPartyLibs.js";
 // Pipeline & analysis
@@ -21,3 +21,7 @@ export { computeClusters } from "./clustering/index.js";
 export { EDGE_LABELS } from "./summarizer/prompts.js";
 // Graph traversal & queries (consumed by the MCP server)
 export { buildGraphIndex, getBlastRadius, getKHop, getSubgraph, findCycles, } from "./graph/traversal.js";
+// Provider catalog (consumed by DevLens OSS frontend & CLI)
+export { loadCatalog, findProvider, saveProvider, removeProvider, resetUserCatalog, listUserProviders, } from "./config/providers/catalog.js";
+// Dynamic model discovery (consumed by DevLens OSS CLI)
+export { listModels } from "./summarizer/providers/models.js";

package/dist/parser/extractors/objectMethods.js

@@ -87,7 +87,7 @@ function walkObject(file, objLiteral, prefix, fileDirective, out) {
         const kind = prop.getKind();
         // Shorthand method:  streamingData(args) { ... }  (incl. async)
         if (kind === SyntaxKind.MethodDeclaration) {
-            const name = prop.getName?.();
+            const name = typeof prop.getName?.() !== "string" ? undefined : prop.getName().replace(/^['"`]|['"`]$/g, "");
             if (!name)
                 continue;
             out.push(buildNode(file, `${prefix}.${name}`, prop, prop, fileDirective));
@@ -96,7 +96,7 @@ function walkObject(file, objLiteral, prefix, fileDirective, out) {
         // Everything else we handle needs a name + initializer.
         if (kind !== SyntaxKind.PropertyAssignment)
             continue; // skip spread/shorthand/get/set
-        const name = prop.getName?.();
+        const name = typeof prop.getName?.() !== "string" ? undefined : prop.getName().replace(/^['"`]|['"`]$/g, "");
         const init = prop.getInitializer?.();
         if (!name || !init)
             continue;

package/dist/parser/index.test.js

@@ -296,16 +296,6 @@ describe("parseRepo", () => {
         expect(nodeModuleNode).toBeUndefined();
         deleteFakeRepo(repoPath);
     });
-    it("should ignore test files", () => {
-        const repoPath = createFakeRepo({
-            "src/Button.tsx": `export function Button() { return <button />; }`,
-            "src/Button.test.tsx": `export function FakeButton() { return <button />; }`,
-        });
-        const result = parseRepo(repoPath);
-        const testNode = result.nodes.find((n) => n.filePath.includes(".test."));
-        expect(testNode).toBeUndefined();
-        deleteFakeRepo(repoPath);
-    });
     it("should ignore config files", () => {
         const repoPath = createFakeRepo({
             "src/Button.tsx": `export function Button() { return <button />; }`,

package/dist/pipeline/index.js

@@ -123,6 +123,32 @@ function routesToCodeNodes(routes, repoPath) {
                 },
             });
         }
+        else if (route.type === "REACT_ROUTER_ROUTE") {
+            // React Router / TanStack / wouter route — a single ROUTE node, no method.
+            const name = route.urlPath;
+            const id = `${relativeFilePath}::${name}`;
+            nodes.push({
+                id,
+                name,
+                type: "ROUTE",
+                filePath: relativeFilePath,
+                startLine: 1,
+                endLine: 1,
+                parentFile: `file::${relativeFilePath}`,
+                metadata: {
+                    urlPath: route.urlPath,
+                    httpMethod: null,
+                    isDynamic: route.isDynamic,
+                    isCatchAll: route.isCatchAll,
+                    isGroupRoute: route.isGroupRoute,
+                    params: route.params ?? [],
+                    routeNodeType: "REACT_ROUTER_ROUTE",
+                    framework: "react-router",
+                    routeKind: "react-router",
+                    rendersComponent: route.rendersComponent, // resolved to a HANDLES edge in routeEdge.ts
+                },
+            });
+        }
         else {
             // Next.js RouteNode — one node per HTTP method for API routes,
             // one node for page/layout/etc.

package/dist/summarizer/providers/anthropic.d.ts

@@ -1,9 +1,10 @@
 import type { LLMClient, LLMRequest, NodeSummaryOutput } from "./types.js";
 export declare class AnthropicClient implements LLMClient {
     readonly provider: "anthropic";
+    readonly providerName?: string;
     readonly model: string;
     private client;
-    constructor(apiKey: string, model: string);
+    constructor(apiKey: string, model: string, baseURL?: string, providerName?: string);
     summarize(request: LLMRequest): Promise<NodeSummaryOutput>;
     validateConnection(): Promise<void>;
 }

package/dist/summarizer/providers/anthropic.js

@@ -33,10 +33,11 @@ function parseResponse(raw) {
     };
 }
 export class AnthropicClient {
-    constructor(apiKey, model) {
+    constructor(apiKey, model, baseURL, providerName) {
         this.provider = "anthropic";
         this.model = model;
-        this.client = new Anthropic({ apiKey });
+        this.providerName = providerName;
+        this.client = new Anthropic({ apiKey, ...(baseURL ? { baseURL } : {}) });
     }
     async summarize(request) {
         const systemMessage = request.messages.find(m => m.role === "system");

package/dist/summarizer/providers/index.js

@@ -1,43 +1,27 @@
-// providers/index.ts has one job — given the config, return the right LLMClient instance. It's the factory that the batch loop calls so it never has to know which provider is being used.
+// providers/index.ts has one job — given the config, return the right LLMClient instance.
+// It's the factory that the batch loop calls so it never has to know which provider is being used.
+// The switch has exactly 2 arms: the two wire protocols (openai, anthropic).
+// Brand identity (providerName) is data — resolved from the catalog or user input.
+import { findProvider } from "../../config/providers/catalog.js";
 import { AnthropicClient } from "./anthropic.js";
-import { GeminiClient } from "./gemini.js";
-import { OllamaClient } from "./ollama.js";
 import { OpenAIClient } from "./openai.js";
-import { OpenRouterClient } from "./openRouter.js";
-// ─── Factory ──────────────────────────────────────────────────────────────────
-//
-// Single entry point for the batch loop — returns the right LLMClient
-// based on config. Caller never imports individual provider classes.
-//
-// Throws clearly if:
-//   - provider is unknown
-//   - apiKey is missing for cloud providers (fail fast before the batch loop)
 export function createLLMClient(config) {
-    const { provider, model, apiKey, baseUrl } = config;
+    const { provider, providerName, model, apiKey, baseUrl } = config;
+    const entry = findProvider(providerName ?? "");
+    const needsKey = entry?.requiresKey ?? true; // unknown/custom → require key
+    const effectiveBase = baseUrl ?? entry?.baseUrl;
     switch (provider) {
-        case "anthropic":
+        case "openai": {
+            if (needsKey && !apiKey)
+                throw new Error(`Provider "${providerName}" requires an API key`);
+            return new OpenAIClient(apiKey ?? "ollama", model, effectiveBase, providerName);
+        }
+        case "anthropic": {
             if (!apiKey)
-                throw new Error("Anthropic provider requires an API key");
-            return new AnthropicClient(apiKey, model);
-        case "openai":
-            if (!apiKey)
-                throw new Error("OpenAI provider requires an API key");
-            return new OpenAIClient(apiKey, model);
-        case "openrouter":
-            if (!apiKey)
-                throw new Error("OpenRouter provider requires an API key");
-            return new OpenRouterClient(apiKey, model);
-        case "gemini":
-            if (!apiKey)
-                throw new Error("Gemini provider requires an API key");
-            return new GeminiClient(apiKey, model);
-        case "ollama":
-            return new OllamaClient(model, baseUrl);
-        case "managed":
-            // Cloud SaaS only — platform injects the key via request headers.
-            // Should never reach here in local mode.
-            throw new Error("Managed provider is only available in cloud mode");
+                throw new Error(`Provider "${providerName}" requires an API key`);
+            return new AnthropicClient(apiKey, model, effectiveBase, providerName);
+        }
         default:
-            throw new Error(`Unknown LLM provider: ${provider}`);
+            throw new Error(`Unknown provider protocol: ${provider}`);
     }
 }

package/dist/summarizer/providers/models.d.ts

@@ -0,0 +1,11 @@
+export interface ListModelsOpts {
+    protocol: "openai" | "anthropic";
+    baseUrl: string;
+    apiKey?: string;
+}
+/**
+ * Fetches the live model list from a provider's models endpoint.
+ * Returns deduped (case-insensitive), sorted model ID strings.
+ * Throws on auth/network errors with a clear message.
+ */
+export declare function listModels(opts: ListModelsOpts): Promise<string[]>;