devlensio 0.4.3 → 0.6.0

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

@@ -17,7 +17,7 @@ export interface ProjectFingerprint {
     databases: DatabaseLibrary[];
     rawDependencies: Record<string, string>;
 }
-export type RouteNodeType = "PAGE" | "LAYOUT" | "API_ROUTE" | "LOADING" | "ERROR" | "MIDDLEWARE" | "NOT_FOUND";
+export type RouteNodeType = "PAGE" | "LAYOUT" | "API_ROUTE" | "LOADING" | "ERROR" | "MIDDLEWARE" | "NOT_FOUND" | "REACT_ROUTER_ROUTE";
 export interface RouteNode {
     type: RouteNodeType;
     nodeId?: string;
@@ -29,6 +29,7 @@ export interface RouteNode {
     layoutPath?: string;
     params?: string[];
     httpMethods?: string[];
+    rendersComponent?: string;
 }
 export interface BackendRouteNode {
     type: "BACKEND_ROUTE";
@@ -69,7 +70,7 @@ export interface CodeNode {
     score?: Number;
     metadata: Record<string, unknown>;
 }
-export type EdgeType = "CALLS" | "IMPORTS" | "READS_FROM" | "WRITES_TO" | "PROP_PASS" | "EMITS" | "LISTENS" | "WRAPPED_BY" | "GUARDS" | "HANDLES" | "TESTS" | "USES" | "NEXTJS_API_CALL";
+export type EdgeType = "CALLS" | "IMPORTS" | "READS_FROM" | "WRITES_TO" | "PROP_PASS" | "EMITS" | "LISTENS" | "WRAPPED_BY" | "GUARDS" | "HANDLES" | "TESTS" | "USES" | "NEXTJS_API_CALL" | "NAVIGATES_TO";
 export interface CodeEdge {
     from: string;
     to: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "devlensio",
-  "version": "0.4.3",
+  "version": "0.6.0",
   "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();
-    }
-}