devlensio 0.4.4 → 0.6.1

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[]>;

package/dist/summarizer/providers/models.js

@@ -0,0 +1,113 @@
+const FETCH_TIMEOUT_MS = 10000;
+/**
+ * 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 async function listModels(opts) {
+    if (opts.protocol === "openai") {
+        return listOpenAIModels(opts.baseUrl, opts.apiKey);
+    }
+    return listAnthropicModels(opts.baseUrl, opts.apiKey);
+}
+//  OpenAI-style lister
+// GET {baseUrl}/models  |  Authorization: Bearer {apiKey}
+// Tolerant of URLs with or without /v1 — tries as-is first, retries with /v1 if empty.
+async function listOpenAIModels(baseUrl, apiKey) {
+    const headers = {
+        "Content-Type": "application/json",
+    };
+    if (apiKey) {
+        headers["Authorization"] = `Bearer ${apiKey}`;
+    }
+    async function tryFetch(url) {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+        try {
+            return await fetch(url, { method: "GET", headers, signal: controller.signal });
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+    const cleanBase = baseUrl.replace(/\/+$/, "");
+    let res = await tryFetch(`${cleanBase}/models`);
+    // If URL has no /v1 segment and the request returned nothing useful, retry with /v1
+    if (!res.ok && !cleanBase.includes("/v1")) {
+        res = await tryFetch(`${cleanBase}/v1/models`);
+    }
+    if (res.status === 401) {
+        throw new Error("Invalid API key for this provider. Check your key in config.");
+    }
+    if (!res.ok) {
+        throw new Error(`Failed to fetch models: ${res.status} ${res.statusText}`);
+    }
+    const body = (await res.json());
+    return normalizeModels((body.data ?? []).map((m) => m.id));
+}
+//  Anthropic-style lister 
+// GET {baseUrl}/v1/models  |  x-api-key + anthropic-version
+// Paginated — loops via after_id until has_more === false
+async function listAnthropicModels(baseUrl, apiKey) {
+    if (!apiKey) {
+        throw new Error("Anthropic-style provider requires an API key to list models.");
+    }
+    const headers = {
+        "x-api-key": apiKey,
+        "anthropic-version": "2023-06-01",
+        "Content-Type": "application/json",
+    };
+    const base = `${baseUrl.replace(/\/+$/, "")}/v1/models`;
+    const allIds = [];
+    let afterId;
+    let hasMore = true;
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+    try {
+        while (hasMore) {
+            const url = afterId
+                ? `${base}?after_id=${afterId}&limit=1000`
+                : `${base}?limit=1000`;
+            const res = await fetch(url, {
+                method: "GET",
+                headers,
+                signal: controller.signal,
+            });
+            if (res.status === 401) {
+                throw new Error("Invalid API key for this provider. Check your key in config.");
+            }
+            if (!res.ok) {
+                throw new Error(`Failed to fetch models: ${res.status} ${res.statusText}`);
+            }
+            const body = (await res.json());
+            allIds.push(...(body.data ?? []).map((m) => m.id));
+            hasMore = body.has_more ?? false;
+            afterId = body.last_id;
+        }
+        return normalizeModels(allIds);
+    }
+    catch (err) {
+        if (err.name === "AbortError") {
+            throw new Error(`Timed out fetching models from ${baseUrl} after ${FETCH_TIMEOUT_MS}ms`);
+        }
+        throw err;
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+//  Normalization 
+// Dedupe case-insensitively, sort ascending.
+function normalizeModels(models) {
+    const seen = new Set();
+    const result = [];
+    for (const m of models) {
+        const key = m.toLowerCase();
+        if (!seen.has(key)) {
+            seen.add(key);
+            result.push(m);
+        }
+    }
+    result.sort((a, b) => a.localeCompare(b));
+    return result;
+}

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

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

package/dist/summarizer/providers/openai.js

@@ -29,9 +29,10 @@ function parseResponse(raw) {
 // Also used as the base for OpenRouter and Ollama —
 // both expose OpenAI-compatible APIs, just with a different baseURL.
 export class OpenAIClient {
-    constructor(apiKey, model, baseURL) {
+    constructor(apiKey, model, baseURL, providerName) {
         this.provider = "openai";
         this.model = model;
+        this.providerName = providerName;
         this.client = new OpenAI({ apiKey, ...(baseURL ? { baseURL } : {}) });
     }
     async summarize(request) {

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

@@ -20,13 +20,8 @@ export interface NodeSummaryOutput {
 }
 export interface LLMClient {
     readonly provider: LLMProvider;
+    readonly providerName?: string;
     readonly model: string;
     summarize(request: LLMRequest): Promise<NodeSummaryOutput>;
     validateConnection(): Promise<void>;
 }
-export type LLMClientFactory = (config: {
-    provider: LLMProvider;
-    model: string;
-    apiKey?: string;
-    baseUrl?: string;
-}) => LLMClient;

package/dist/types.d.ts

@@ -1,7 +1,7 @@
 export type Language = "javascript" | "typescript" | "python" | "unknown";
-export type Framework = "nextjs" | "react" | "express" | "fastify" | "koa" | "unknown";
+export type Framework = "nextjs" | "react" | "express" | "fastify" | "koa" | "hono" | "elysia" | "bun" | "unknown";
 export type FrontendFramework = "nextjs" | "react";
-export type BackendFramework = "express" | "fastify" | "koa";
+export type BackendFramework = "express" | "fastify" | "koa" | "hono" | "elysia" | "bun";
 export type RouterType = "app" | "pages" | "app+pages" | "react-router" | "none";
 export type ProjectType = "frontend" | "backend" | "fullstack" | "unknown";
 export type StateLibrary = "zustand" | "redux" | "recoil" | "jotai" | "context-only";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "devlensio",
-  "version": "0.4.4",
+  "version": "0.6.1",
   "description": "Codebase intelligence engine for TypeScript/JavaScript/Reactjs/Nextjs repositories.",
   "type": "module",
   "main": "./dist/index.js",

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

@@ -1,9 +0,0 @@
-import type { LLMClient, LLMRequest, NodeSummaryOutput } from "./types.js";
-export declare class GeminiClient implements LLMClient {
-    readonly provider: "gemini";
-    readonly model: string;
-    private ai;
-    constructor(apiKey: string, model: string);
-    summarize(request: LLMRequest): Promise<NodeSummaryOutput>;
-    validateConnection(): Promise<void>;
-}

package/dist/summarizer/providers/gemini.js

@@ -1,79 +0,0 @@
-import { GoogleGenAI } from "@google/genai";
-// ─── Response Parser ──────────────────────────────────────────────────────────
-//
-// Same XML format as all other providers — consistent across the board.
-const VALID_SEVERITIES = new Set(["none", "low", "medium", "high"]);
-function parseXmlTag(text, tag) {
-    const match = text.match(new RegExp(`<${tag}>([\\s\\S]*?)<\\/${tag}>`));
-    return match ? match[1].trim() : "";
-}
-function parseResponse(raw) {
-    const technicalSummary = parseXmlTag(raw, "technical");
-    const businessSummary = parseXmlTag(raw, "business");
-    const severityRaw = parseXmlTag(raw, "security_severity").toLowerCase();
-    const securitySummary = parseXmlTag(raw, "security_summary");
-    const severity = VALID_SEVERITIES.has(severityRaw)
-        ? severityRaw
-        : "none";
-    return {
-        technicalSummary: technicalSummary || raw.trim(),
-        businessSummary: businessSummary || "",
-        security: {
-            severity,
-            summary: severity === "none" ? "" : securitySummary,
-        },
-        tokensUsed: 0,
-    };
-}
-export class GeminiClient {
-    constructor(apiKey, model) {
-        this.provider = "gemini";
-        this.model = model;
-        this.ai = new GoogleGenAI({ apiKey });
-    }
-    async summarize(request) {
-        const systemMessage = request.messages.find(m => m.role === "system");
-        const userMessages = request.messages.filter(m => m.role !== "system");
-        const contents = userMessages.map(m => ({
-            role: "user",
-            parts: [{ text: m.content }],
-        }));
-        const response = await this.ai.models.generateContent({
-            model: this.model,
-            contents,
-            config: {
-                systemInstruction: systemMessage?.content,
-                temperature: request.temperature ?? 0,
-                maxOutputTokens: request.maxTokens ?? 2048,
-            },
-        });
-        const raw = response.text ?? "";
-        const result = parseResponse(raw);
-        result.tokensUsed =
-            (response.usageMetadata?.promptTokenCount ?? 0) +
-                (response.usageMetadata?.candidatesTokenCount ?? 0);
-        return result;
-    }
-    async validateConnection() {
-        try {
-            await this.ai.models.generateContent({
-                model: this.model,
-                contents: [{ role: "user", parts: [{ text: "hi" }] }],
-                config: { maxOutputTokens: 10 },
-            });
-        }
-        catch (err) {
-            const status = err?.status ?? err?.statusCode ?? err?.code;
-            const message = err?.message ?? "";
-            if (status === 400 || message.includes("API_KEY_INVALID") || message.includes("invalid api key"))
-                throw new Error(`Gemini API key is invalid or missing. Check your key in config.`);
-            if (status === 403 || message.includes("PERMISSION_DENIED"))
-                throw new Error(`Gemini API key does not have permission to use model "${this.model}".`);
-            if (status === 404 || message.includes("models/") || message.includes("not found"))
-                throw new Error(`Gemini model "${this.model}" not found. Check model name in config.`);
-            if (status === 429 || message.includes("RESOURCE_EXHAUSTED"))
-                throw new Error(`Gemini rate limit hit during connection check. Try again shortly.`);
-            throw new Error(`Gemini connection failed: ${message || "unknown error"}`);
-        }
-    }
-}

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

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

package/dist/summarizer/providers/ollama.js

@@ -1,23 +0,0 @@
-import { OpenAIClient } from "./openai.js";
-const OLLAMA_DEFAULT_BASE_URL = "http://localhost:11434";
-// ─── OllamaClient ─────────────────────────────────────────────────────────────
-//
-// Ollama exposes an OpenAI-compatible API at /v1 — wraps OpenAIClient.
-// No API key needed for local usage — passes a placeholder to satisfy the SDK.
-// baseURL is configurable for users running Ollama on a non-default port or host.
-// /v1 is always appended — user-provided baseURL should not include it.
-export class OllamaClient {
-    constructor(model, baseURL) {
-        this.provider = "ollama";
-        this.model = model;
-        const base = (baseURL ?? OLLAMA_DEFAULT_BASE_URL).replace(/\/+$/, "");
-        this.inner = new OpenAIClient("ollama", // placeholder — Ollama doesn't validate the key
-        model, `${base}/v1`);
-    }
-    summarize(request) {
-        return this.inner.summarize(request);
-    }
-    validateConnection() {
-        return this.inner.validateConnection();
-    }
-}

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

@@ -1,9 +0,0 @@
-import type { LLMClient, LLMRequest, NodeSummaryOutput } from "./types.js";
-export declare class OpenRouterClient implements LLMClient {
-    readonly provider: "openrouter";
-    readonly model: string;
-    private inner;
-    constructor(apiKey: string, model: string);
-    summarize(request: LLMRequest): Promise<NodeSummaryOutput>;
-    validateConnection(): Promise<void>;
-}

package/dist/summarizer/providers/openRouter.js

@@ -1,19 +0,0 @@
-import { OpenAIClient } from "./openai.js";
-const OPENROUTER_BASE_URL = "https://openrouter.ai/api/v1";
-// ─── OpenRouterClient ─────────────────────────────────────────────────────────
-//
-// OpenRouter exposes an OpenAI-compatible API — no new logic needed.
-// Just wraps OpenAIClient with the correct baseURL and overrides provider. (OpenAI actually set the industry standard for the response of the LLMs through API.Everyone follows the OpenAI standard,  Aside of course Anthropic, because its anthropic, who even go against pentagon.)
-export class OpenRouterClient {
-    constructor(apiKey, model) {
-        this.provider = "openrouter";
-        this.model = model;
-        this.inner = new OpenAIClient(apiKey, model, OPENROUTER_BASE_URL);
-    }
-    summarize(request) {
-        return this.inner.summarize(request);
-    }
-    validateConnection() {
-        return this.inner.validateConnection();
-    }
-}