devlensio 1.0.2 → 1.0.4

package/dist/config/backcompat.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/config/backcompat.test.js

@@ -0,0 +1,188 @@
+// Back-compat + tolerance tests for the config system (plan issue 15, M1).
+//
+// Each scenario runs in a SUBPROCESS with HOME pointed at a throwaway dir:
+// CONFIG_FILE is resolved from os.homedir() at module load, so isolation only
+// works in a fresh process. This also guarantees these tests can never touch
+// the developer's real ~/.devlens/config.json.
+//
+// Run: bun test src/config/backcompat.test.ts
+import { describe, test, expect } from "bun:test";
+import { spawnSync } from "node:child_process";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+const ROOT = path.resolve(import.meta.dir, "..", ".."); // engine repo root
+function runScenario(name, files, script) {
+    const home = fs.mkdtempSync(path.join(os.tmpdir(), `devlens-cfg-${name}-`));
+    for (const [rel, content] of Object.entries(files)) {
+        const p = path.join(home, rel);
+        fs.mkdirSync(path.dirname(p), { recursive: true });
+        fs.writeFileSync(p, content);
+    }
+    const env = { ...process.env, HOME: home };
+    // strip ambient LLM env so fixtures are hermetic
+    for (const k of Object.keys(env)) {
+        if (k.startsWith("DEVLENS_LLM") || k.startsWith("DEVLENS_EMBED") || k.startsWith("DEVLENS_BATCH")) {
+            delete env[k];
+        }
+    }
+    const r = spawnSync("bun", ["-e", script], {
+        cwd: ROOT,
+        env,
+        encoding: "utf8",
+        timeout: 30000,
+    });
+    if (r.error)
+        throw r.error;
+    const out = (r.stdout ?? "").trim().split("\n").pop() ?? "";
+    let result;
+    try {
+        result = JSON.parse(out);
+    }
+    catch {
+        result = { parseError: r.stdout, status: r.status, stderr: r.stderr };
+    }
+    return { home, result, stderr: r.stderr ?? "" };
+}
+const CONFIG_REL = ".devlens/config.json";
+const PROBE = `
+  const m = await import("./src/config/index.js");
+  const out = {};
+  try {
+    const c = m.resolveConfig(undefined, { validate: false });
+    out.tolerant = { provider: c.summarization.provider, providerName: c.summarization.providerName ?? null, model: c.summarization.model, hasKey: !!c.summarization.apiKey };
+  } catch (e) { out.tolerantErr = e instanceof Error ? e.message : String(e); }
+  try {
+    m.resolveConfig();
+    out.validating = "ok";
+  } catch (e) { out.validatingErr = e instanceof Error ? e.message : String(e); }
+  out.configured = m.hasSummarizationConfigured();
+  console.log(JSON.stringify(out));
+`;
+describe("fresh install (no config file)", () => {
+    const s = runScenario("fresh", {}, PROBE);
+    test("tolerant read resolves defaults without error", () => {
+        expect(s.result.tolerantErr).toBeUndefined();
+        expect(s.result.tolerant).toMatchObject({ provider: "anthropic", hasKey: false });
+    });
+    test("validating read fails with the actionable missing-key message", () => {
+        expect(String(s.result.validatingErr)).toContain("summarization.apiKey is required");
+        expect(String(s.result.validatingErr)).toContain("devlens init");
+    });
+    test("hasSummarizationConfigured() = false", () => {
+        expect(s.result.configured).toBe(false);
+    });
+});
+describe("incomplete config (provider, no key)", () => {
+    const s = runScenario("incomplete", { [CONFIG_REL]: JSON.stringify({ summarization: { provider: "openai", providerName: "deepseek", model: "deepseek-chat" } }) }, PROBE);
+    test("tolerant read works (init/config/analyze can run)", () => {
+        expect(s.result.tolerantErr).toBeUndefined();
+        expect(s.result.tolerant).toMatchObject({ provider: "openai", providerName: "deepseek", hasKey: false });
+    });
+    test("only the validating path throws", () => {
+        expect(String(s.result.validatingErr)).toContain("apiKey is required");
+        expect(s.result.configured).toBe(false);
+    });
+});
+describe("valid config (current multi-provider v2)", () => {
+    const s = runScenario("valid", {
+        [CONFIG_REL]: JSON.stringify({
+            summarization: {
+                active: "openai:deepseek",
+                providers: {
+                    "openai:deepseek": { provider: "openai", providerName: "deepseek", model: "deepseek-chat", apiKey: "sk-x", batchSize: 25 },
+                },
+            },
+        }),
+    }, PROBE);
+    test("both paths resolve; configured = true", () => {
+        expect(s.result.tolerantErr).toBeUndefined();
+        expect(s.result.validating).toBe("ok");
+        expect(s.result.configured).toBe(true);
+        expect(s.result.tolerant).toMatchObject({ provider: "openai", providerName: "deepseek", hasKey: true });
+    });
+});
+describe("broken config JSON", () => {
+    const s = runScenario("broken", { [CONFIG_REL]: "{ not json" }, PROBE);
+    test("tolerant read STILL reports the invalid-JSON error (never silent)", () => {
+        expect(String(s.result.tolerantErr)).toContain("invalid JSON");
+        expect(String(s.result.validatingErr)).toContain("invalid JSON");
+        expect(s.result.configured).toBe(false);
+    });
+});
+describe("old v1 flat config (pre multi-provider)", () => {
+    const flat = JSON.stringify({ summarization: { provider: "openai", providerName: "mybrand", model: "m1", apiKey: "sk-old", batchSize: 30 } });
+    const s = runScenario("flat", { [CONFIG_REL]: flat }, PROBE);
+    test("loads fine on both paths", () => {
+        expect(s.result.tolerantErr).toBeUndefined();
+        expect(s.result.validating).toBe("ok");
+        expect(s.result.configured).toBe(true);
+    });
+    test("migrates the file to multi-provider format (active + providers)", () => {
+        const raw = JSON.parse(fs.readFileSync(path.join(s.home, CONFIG_REL), "utf8"));
+        expect(raw.summarization.active).toBe("openai:mybrand");
+        expect(raw.summarization.providers["openai:mybrand"].apiKey).toBe("sk-old");
+    });
+});
+describe("v1 config with a BRAND in provider (deepseek)", () => {
+    const s = runScenario("brand", { [CONFIG_REL]: JSON.stringify({ summarization: { provider: "deepseek", model: "m1", apiKey: "sk-b" } }) }, PROBE);
+    test("migrates brand → protocol + providerName without error", () => {
+        expect(s.result.tolerantErr).toBeUndefined();
+        expect(s.result.tolerant).toMatchObject({ provider: "openai", providerName: "deepseek", hasKey: true });
+        expect(s.result.validating).toBe("ok");
+    });
+});
+describe("legacy OLLAMA config (provider removed)", () => {
+    const s = runScenario("ollama", { [CONFIG_REL]: JSON.stringify({ summarization: { provider: "ollama", model: "qwen2.5-coder:3b", baseUrl: "http://localhost:11434/v1" } }) }, PROBE);
+    test("tolerant read loads (old configs must keep working)", () => {
+        expect(s.result.tolerantErr).toBeUndefined();
+        expect(s.result.tolerant).toMatchObject({ provider: "openai", providerName: "ollama", hasKey: false });
+    });
+    test("validating read gives the 'no longer supported' migration message", () => {
+        expect(String(s.result.validatingErr)).toContain("Ollama is no longer supported");
+        expect(s.result.configured).toBe(false);
+    });
+    test("stderr carries the not-in-catalog warning (once)", () => {
+        expect(s.stderr).toContain("not in the provider catalog");
+    });
+});
+describe("config with an embedding block but no embedding key", () => {
+    const s = runScenario("embedding", {
+        [CONFIG_REL]: JSON.stringify({
+            summarization: { provider: "openai", providerName: "deepseek", model: "m", apiKey: "sk-ok" },
+            embedding: { provider: "openai", model: "text-embedding-3-small" },
+        }),
+    }, PROBE);
+    test("validating read no longer demands an embedding key (issue 14)", () => {
+        expect(s.result.validating).toBe("ok");
+        expect(s.result.tolerantErr).toBeUndefined();
+        expect(s.result.configured).toBe(true);
+    });
+});
+describe("provider catalog", () => {
+    test("ollama is gone from the shipped catalog", () => {
+        const s = runScenario("catalog", {}, `
+      const { loadCatalog } = await import("./src/config/providers/catalog.js");
+      const names = loadCatalog().map(p => p.name);
+      console.log(JSON.stringify({ names }));
+    `);
+        const names = (s.result.names ?? []);
+        expect(names).not.toContain("ollama");
+        expect(names).toContain("deepseek");
+        expect(names).toContain("anthropic");
+    });
+});
+describe("env-var key counts as configured", () => {
+    const home = fs.mkdtempSync(path.join(os.tmpdir(), "devlens-cfg-env-"));
+    fs.mkdirSync(path.join(home, ".devlens"), { recursive: true });
+    const r = spawnSync("bun", ["-e", `const m = await import("./src/config/index.js"); console.log(JSON.stringify({ configured: m.hasSummarizationConfigured(), hasKey: !!m.resolveConfig(undefined,{validate:false}).summarization.apiKey }));`], {
+        cwd: ROOT,
+        encoding: "utf8",
+        timeout: 30000,
+        env: { ...process.env, HOME: home, DEVLENS_LLM_KEY: "sk-from-env" },
+    });
+    test("DEVLENS_LLM_KEY enables hasSummarizationConfigured()", () => {
+        const out = JSON.parse((r.stdout ?? "").trim().split("\n").pop() ?? "{}");
+        expect(out).toEqual({ configured: true, hasKey: true });
+    });
+});

package/dist/config/index.d.ts

@@ -1,13 +1,15 @@
 import { type DevLensConfig, type ProviderConfigEntry } from "./types.js";
-export declare function detectOllama(): Promise<boolean>;
 export declare function initConfig(): Promise<void>;
-export declare function resolveConfig(req?: Request): DevLensConfig;
+export declare function resolveConfig(req?: Request, opts?: {
+    validate?: boolean;
+}): DevLensConfig;
+export declare function hasSummarizationConfigured(req?: Request): boolean;
 export type { DevLensConfig } from "./types.js";
 export type { SafeConfig } from "./writer.js";
 export { maskConfig, writeConfig, atomicWrite } from "./writer.js";
 export { CONFIG_FILE, CONFIG_DIR, ENV } from "./providers/file.js";
 export { sanitizeHeaders, CONFIG_HEADERS } from "./types.js";
-export { OLLAMA_DEFAULTS, ANTHROPIC_DEFAULTS } from "./types.js";
+export { ANTHROPIC_DEFAULTS } from "./types.js";
 export type { ProviderConfigEntry, MultiProviderStorage } from "./types.js";
 export { makeProviderKey, parseProviderKey } from "./types.js";
 export interface AllProvidersResult {

package/dist/config/index.js

@@ -1,72 +1,35 @@
-import { OLLAMA_DEFAULTS, ANTHROPIC_DEFAULTS, makeProviderKey } from "./types.js";
+import { ANTHROPIC_DEFAULTS, makeProviderKey } from "./types.js";
 import { loadFileConfig } from "./providers/file.js";
 import { applyRequestHeaders } from "./providers/request.js";
 import { atomicWrite } from "./writer.js";
 import { CONFIG_FILE } from "./providers/paths.js";
+import { findProvider } from "./providers/catalog.js";
 import fs from "fs";
-//  Ollama Detection 
+//  Startup Initialization
 //
-// Pings Ollama's default endpoint at server startup.
-// Used by resolveConfig() to choose which defaults to fall back to:
-//   - Ollama running  → OLLAMA_DEFAULTS (free, private, zero API cost)
-//   - Ollama absent   → ANTHROPIC_DEFAULTS (user must set apiKey)
-//
-// Uses a short timeout — we don't want server startup to hang for 30 seconds
-// if Ollama is not installed. 2 seconds is enough for a local HTTP ping.
-//
-// Called ONCE at startup and the result is cached — see `cachedDefaults` below.
-const OLLAMA_PING_URL = "http://localhost:11434";
-const OLLAMA_PING_TIMEOUT_MS = 2000;
-export async function detectOllama() {
-    try {
-        const controller = new AbortController();
-        const timeout = setTimeout(() => controller.abort(), OLLAMA_PING_TIMEOUT_MS);
-        const res = await fetch(OLLAMA_PING_URL, {
-            signal: controller.signal,
-            method: "GET",
-        });
-        clearTimeout(timeout);
-        return res.ok;
-    }
-    catch {
-        // Ollama not running, not installed, or timed out — all treated the same
-        return false;
-    }
-}
-//  Startup Initialization 
-//
-// detectOllama() is called once when the server starts (in server/index.ts).
-// The result is stored here so resolveConfig() doesn't ping Ollama on
-// every single request — that would be slow and noisy.
-//
-// initConfig() must be called before any request is handled.
-// Until it is called, resolveConfig() falls back to ANTHROPIC_DEFAULTS safely.
+// Historically this pinged a local Ollama endpoint to pick defaults and logged
+// the result with console.log — noise, and a real hazard for the MCP stdio
+// transport (stdout is the JSON-RPC channel). Ollama support has been removed;
+// initConfig() is now a quiet, idempotent shim kept for call-site
+// compatibility (OSS `devlens serve` + MCP servers await it at startup).
 let cachedDefaults = ANTHROPIC_DEFAULTS;
 let initialized = false;
 export async function initConfig() {
     if (initialized)
         return;
-    const ollamaRunning = await detectOllama();
-    if (ollamaRunning) {
-        cachedDefaults = OLLAMA_DEFAULTS;
-        console.log("⚡ Ollama detected — using local LLM defaults");
-        console.log(`   Summarization: ${OLLAMA_DEFAULTS.summarization.model}`);
-        console.log(`   Embedding:     ${OLLAMA_DEFAULTS.embedding.model}`);
-    }
-    else {
-        cachedDefaults = ANTHROPIC_DEFAULTS;
-        console.log("☁️  Ollama not detected — using Anthropic defaults");
-        console.log("   Add an apiKey to ~/.devlens/config.json to enable summarization");
-        console.log(`   Or set ${(await import("./providers/file.js")).ENV.LLM_KEY}=your-key`);
-    }
     initialized = true;
 }
 // This function reads config.json fresh on every call —
 // so if the user edits settings in the UI, the next job picks up the change
 // without requiring a server restart.
-export function resolveConfig(req) {
+//
+// opts.validate === false → tolerant read: an incomplete summarization config
+// (missing API key etc.) resolves fine and is only reported when summarization
+// actually runs. Used by display paths (devlens config/doctor/init) and by
+// structure-only analysis (GitHub issue #10).
+export function resolveConfig(req, opts) {
     // Step 1 — load file config merged with detected defaults + env vars
-    const fileConfig = loadFileConfig(cachedDefaults);
+    const fileConfig = loadFileConfig(cachedDefaults, opts);
     if (!req)
         return fileConfig;
     // In local mode, ignore headers even if present
@@ -75,10 +38,29 @@ export function resolveConfig(req) {
     // Step 4 — apply header overrides for cloud users
     return applyRequestHeaders(fileConfig, req);
 }
+// True when summarization can actually run with the current config: the active
+// provider either needs no key, or has one (file or env). Never throws on an
+// incomplete config — callers use it to auto-skip summarization instead of
+// failing analysis (GitHub issue #10). Returns false when config.json is
+// unreadable: summarization must not run, but analysis may still proceed.
+export function hasSummarizationConfigured(req) {
+    try {
+        const config = resolveConfig(req, { validate: false });
+        const providerName = config.summarization.providerName ?? config.summarization.provider;
+        if (providerName === "ollama")
+            return false; // removed provider
+        const entry = findProvider(providerName);
+        const needsKey = entry?.requiresKey ?? true;
+        return !needsKey || !!config.summarization.apiKey;
+    }
+    catch {
+        return false;
+    }
+}
 export { maskConfig, writeConfig, atomicWrite } from "./writer.js";
 export { CONFIG_FILE, CONFIG_DIR, ENV } from "./providers/file.js";
 export { sanitizeHeaders, CONFIG_HEADERS } from "./types.js";
-export { OLLAMA_DEFAULTS, ANTHROPIC_DEFAULTS } from "./types.js";
+export { ANTHROPIC_DEFAULTS } from "./types.js";
 export { makeProviderKey, parseProviderKey } from "./types.js";
 /** Read the raw multi-provider storage from config.json (no defaults applied). */
 function readProviderStorage() {
@@ -107,7 +89,8 @@ export function resolveAllProviders() {
         };
     }
     // Fallback: use the resolved active config to synthesise one entry
-    const config = loadFileConfig(ANTHROPIC_DEFAULTS);
+    // (tolerant read — a missing key must not break the settings UI)
+    const config = loadFileConfig(ANTHROPIC_DEFAULTS, { validate: false });
     const key = makeProviderKey(config.summarization.provider, config.summarization.providerName ?? config.summarization.provider);
     return {
         active: key,

package/dist/config/providers/file.d.ts

@@ -18,4 +18,6 @@ export declare const ENV: {
 };
 /** Public — reads the raw config.json as a plain object. Used by multi-provider helpers. */
 export declare function readRawConfigFile(): Record<string, unknown>;
-export declare function loadFileConfig(defaults?: DevLensConfig): DevLensConfig;
+export declare function loadFileConfig(defaults?: DevLensConfig, opts?: {
+    validate?: boolean;
+}): DevLensConfig;

package/dist/config/providers/file.js

@@ -6,9 +6,9 @@ export { CONFIG_DIR, CONFIG_FILE } from "./paths.js";
 // ─── Constants ────────────────────────────────────────────────────────────────
 //
 // For Docker users who prefer env vars over config files.
-// A Docker user running Ollama in the same network would set:
-//   DEVLENS_LLM_PROVIDER=ollama
-//   DEVLENS_LLM_BASE_URL=http://ollama:11434
+// A Docker user with their own endpoint would set:
+//   DEVLENS_LLM_PROVIDER=openai
+//   DEVLENS_LLM_BASE_URL=https://my-endpoint.example/v1
 //
 // Priority: config file wins over env vars.
 // Env vars only fill fields that the config file left empty.
@@ -67,16 +67,24 @@ function migrateProviderConfig(config) {
     const p = config.summarization.provider;
     if (p === "openai" || p === "anthropic")
         return config;
+    // Known brand → its catalog protocol. Unknown brand (including providers
+    // removed from the catalog, e.g. "ollama") → treat as a custom
+    // OpenAI-compatible entry instead of throwing: configs written by older CLI
+    // versions must keep loading. The actionable error ("no longer supported" /
+    // missing key) fires at SUMMARIZE time, never on a plain config read.
     const entry = findProvider(p);
-    if (!entry)
-        throw new Error(`DevLens: "${p}" is not a valid provider protocol. Wire protocol must be "openai" or "anthropic". ` +
-            `Fix: set "provider" to "openai" and "providerName" to "${p}" in ~/.devlens/config.json`);
-    const migrated = { ...config, summarization: { ...config.summarization, provider: entry.protocol, providerName: entry.name } };
+    const protocol = entry?.protocol ?? "openai";
+    const name = entry?.name ?? p;
+    if (!entry) {
+        console.warn(`DevLens: "${p}" is not in the provider catalog — ` +
+            `treating it as a custom OpenAI-compatible provider.`);
+    }
+    const migrated = { ...config, summarization: { ...config.summarization, provider: protocol, providerName: name } };
     try {
         const raw = JSON.parse(fs.readFileSync(CONFIG_FILE, "utf-8"));
-        raw.summarization = { ...raw.summarization, provider: entry.protocol };
+        raw.summarization = { ...raw.summarization, provider: protocol };
         if (!raw.summarization.providerName)
-            raw.summarization.providerName = entry.name;
+            raw.summarization.providerName = name;
         const tmp = CONFIG_FILE + ".tmp";
         fs.writeFileSync(tmp, JSON.stringify(raw, null, 2));
         fs.renameSync(tmp, CONFIG_FILE);
@@ -85,7 +93,7 @@ function migrateProviderConfig(config) {
     return migrated;
 }
 const VALID_LLM_PROTOCOLS = new Set(["openai", "anthropic"]);
-const VALID_EMBED_PROTOCOLS = new Set(["openai", "anthropic", "openrouter", "gemini", "ollama"]);
+const VALID_EMBED_PROTOCOLS = new Set(["openai", "anthropic", "openrouter", "gemini"]);
 function sanitizeProviderEnv(raw) {
     if (!raw)
         return undefined;
@@ -176,45 +184,35 @@ function buildNeo4jFromEnv() {
         return undefined;
     return { url, username, password, storeRawCode };
 }
-//  Validation 
+//  Validation //
 //
-// Only validates what cannot have a sensible default.
+// Only validates what cannot have a sensible default. Called from
+// loadFileConfig() ONLY when validation is requested (summarize paths);
+// display/init/analyze paths resolve tolerantly — see loadFileConfig opts.
 // Key requirement is resolved from the catalog's `requiresKey` per provider.
 // If a providerName isn't in the catalog (custom), we default to requiring a key.
 //
 // Error messages are actionable — they tell the user exactly how to fix the problem.
-const EMBEDDING_PROVIDERS_NEEDING_KEY = new Set([
-    "anthropic",
-    "openai",
-    "openrouter",
-    "gemini",
-]);
 function validate(config) {
-    const { summarization, embedding } = config;
+    const { summarization } = config;
+    // Ollama support was removed — fail with a migration hint, never a generic
+    // missing-key error. (Tolerant reads never reach here; this fires only when
+    // actually summarizing.)
+    if (summarization.providerName === "ollama") {
+        throw new Error(`DevLens config error: Ollama is no longer supported.\n` +
+            `  Fix: run "devlens init" to configure a cloud provider,\n` +
+            `  or switch the active provider with "devlens config --active <provider:key>".`);
+    }
     // Summarization apiKey — resolved from catalog
     const entry = findProvider(summarization.providerName ?? "");
     const needsKey = entry?.requiresKey ?? true; // unknown/custom → require key
     if (needsKey && !summarization.apiKey) {
         throw new Error(`DevLens config error: summarization.apiKey is required for "${summarization.providerName ?? summarization.provider}".\n` +
-            `  Fix option 1 — add to ${CONFIG_FILE}:\n` +
+            `  Fix option 1 — run "devlens init" (or "devlens config --set") to configure a provider.\n` +
+            `  Fix option 2 — add to ${CONFIG_FILE}:\n` +
             `    { "summarization": { "apiKey": "your-key-here" } }\n` +
-            `  Fix option 2 — set environment variable:\n` +
-            `    ${ENV.LLM_KEY}=your-key-here \n` +
-            `Fix option 3 - Skip Summarization`);
-    }
-    // Embedding apiKey — only validate if the user explicitly configured embedding.
-    // If the user only set summarization, embedding may still be at default (openai
-    // with no key) which is fine — embedding is only needed for vector search (cloud).
-    const rawFile = readFileConfig();
-    const userSetEmbedding = !!rawFile.embedding?.provider;
-    if (userSetEmbedding &&
-        EMBEDDING_PROVIDERS_NEEDING_KEY.has(embedding.provider) &&
-        !embedding.apiKey) {
-        throw new Error(`DevLens config error: embedding.apiKey is required when provider is "${embedding.provider}".\n` +
-            `  Fix option 1 — add to ${CONFIG_FILE}:\n` +
-            `    { "embedding": { "apiKey": "your-key-here" } }\n` +
-            `  Fix option 2 — set environment variable:\n` +
-            `    ${ENV.EMBED_KEY}=your-key-here`);
+            `  Fix option 3 — set environment variable ${ENV.LLM_KEY}=your-key-here\n` +
+            `  Fix option 4 — run analyze WITHOUT --summarize (structure-only needs no key).`);
     }
     // Neo4j — if any field is provided, all three must be present
     if (config.neo4j) {
@@ -230,14 +228,6 @@ function validate(config) {
                 `    ${ENV.NEO4J_PASSWORD}=your-password`);
         }
     }
-    // Ollama baseUrl format
-    if (summarization.providerName === "ollama") {
-        const base = summarization.baseUrl ?? "http://localhost:11434/v1";
-        if (!base.startsWith("http://") && !base.startsWith("https://")) {
-            throw new Error(`DevLens config error: summarization.baseUrl must start with http:// or https://.\n` +
-                `  Got: "${base}"`);
-        }
-    }
 }
 //  readFileConfig
 //
@@ -308,21 +298,24 @@ function extractActiveProvider(storage) {
         batchSize: entry.batchSize,
     };
 }
-//  loadFileConfig 
+//  loadFileConfig
 //
 // Public entry point — called by resolveConfig() in config/index.ts.
 //
-// Takes the active defaults (chosen by detectOllama() in index.ts):
-//   - OLLAMA_DEFAULTS    if Ollama is running at startup
-//   - ANTHROPIC_DEFAULTS if Ollama is not detected
-//
 // Steps:
 //   1. Read ~/.devlens/config.json  (partial — only what user set)
 //   2. Deep merge onto provided defaults
 //   3. Apply env vars for any still-missing fields
-//   4. Validate — throw clear errors for anything missing or invalid
+//   4. Validate (only when opts.validate !== false) — see opts below
 //   5. Return fully resolved DevLensConfig — never partial, never undefined fields
-export function loadFileConfig(defaults = ANTHROPIC_DEFAULTS) {
+//
+// opts.validate:
+//   - default (true): summarize paths — throws actionable errors for missing
+//     keys / incomplete neo4j / removed providers.
+//   - false: tolerant reads for display, init, config editing and
+//     structure-only analysis — an incomplete summarization config is NOT an
+//     error here (GitHub issue #10). Invalid JSON in the file still throws.
+export function loadFileConfig(defaults = ANTHROPIC_DEFAULTS, opts = {}) {
     let partial = readFileConfig();
     // ── Multi-provider detection & migration ─────────────────────────────────
     if (partial.summarization) {
@@ -376,6 +369,7 @@ export function loadFileConfig(defaults = ANTHROPIC_DEFAULTS) {
     const merged = deepMerge(defaults, partial);
     const migrated = migrateProviderConfig(merged);
     const withEnv = applyEnvVars(migrated);
-    validate(withEnv);
+    if (opts.validate !== false)
+        validate(withEnv);
     return withEnv;
 }

package/dist/config/providers/providers.default.js

@@ -7,6 +7,5 @@ export const DEFAULT_PROVIDERS = [
     { name: "mistral", label: "Mistral", protocol: "openai", baseUrl: "https://api.mistral.ai/v1", requiresKey: true },
     { name: "xai", label: "xAI Grok", protocol: "openai", baseUrl: "https://api.x.ai/v1", requiresKey: true },
     { name: "openrouter", label: "OpenRouter", protocol: "openai", baseUrl: "https://openrouter.ai/api/v1", requiresKey: true },
-    { name: "ollama", label: "Ollama (local)", protocol: "openai", baseUrl: "http://localhost:11434/v1", requiresKey: false },
 ];
 export const CATALOG_VERSION = 2;

package/dist/config/providers/request.js

@@ -1,6 +1,6 @@
 import { CONFIG_HEADERS } from "../types.js";
 const VALID_LLM_PROTOCOLS = new Set(["openai", "anthropic"]);
-const VALID_EMBED_PROTOCOLS = new Set(["openai", "anthropic", "openrouter", "gemini", "ollama"]);
+const VALID_EMBED_PROTOCOLS = new Set(["openai", "anthropic", "openrouter", "gemini"]);
 function rejectPlaceholder(v) {
     if (!v)
         return undefined;

package/dist/config/types.d.ts

@@ -48,7 +48,6 @@ export interface DevLensConfig {
     embedding: EmbeddingConfig;
     neo4j?: Neo4jConfig;
 }
-export declare const OLLAMA_DEFAULTS: DevLensConfig;
 export declare const ANTHROPIC_DEFAULTS: DevLensConfig;
 export declare const CONFIG_HEADERS: {
     readonly PROVIDER: "x-llm-provider";

package/dist/config/types.js

@@ -12,22 +12,6 @@ export function parseProviderKey(key) {
 // Note: apiKey is intentionally absent from all defaults.
 // If a user reaches the defaults with no key configured anywhere,
 // the system fails clearly at the LLM call — never silently sends an empty key.
-export const OLLAMA_DEFAULTS = {
-    deploymentMode: "local",
-    summarization: {
-        provider: "openai",
-        providerName: "ollama",
-        model: "qwen2.5-coder:3b", // code-aware, 3B params, runs on ~2GB RAM
-        baseUrl: "http://localhost:11434/v1",
-        batchSize: 50,
-    },
-    embedding: {
-        provider: "ollama",
-        model: "nomic-embed-text", // best local embedding model, 768 dims
-        baseUrl: "http://localhost:11434/v1",
-    },
-    // neo4j absent — file-only mode is the safe default
-};
 export const ANTHROPIC_DEFAULTS = {
     deploymentMode: "local",
     summarization: {
@@ -58,12 +42,12 @@ export const CONFIG_HEADERS = {
     PROVIDER_NAME: "x-llm-provider-name", // e.g. "deepseek" — brand identity
     MODEL: "x-llm-model", // e.g. "claude-haiku-4-5"
     API_KEY: "x-llm-key",
-    BASE_URL: "x-llm-base-url", // for Ollama: "http://localhost:11434"
+    BASE_URL: "x-llm-base-url", // e.g. "https://api.deepseek.com"
     BATCH_SIZE: "x-batch-size", // e.g. "30"
     EMBED_PROVIDER: "x-embed-provider",
     EMBED_MODEL: "x-embed-model",
     EMBED_KEY: "x-embed-key",
-    EMBED_BASE_URL: "x-embed-base-url", // for Ollama embedding
+    EMBED_BASE_URL: "x-embed-base-url", // cloud embedding endpoint
     NEO4J_URL: "x-neo4j-url",
     NEO4J_USER: "x-neo4j-user",
     NEO4J_PASSWORD: "x-neo4j-password",

package/dist/index.d.ts

@@ -9,7 +9,7 @@ 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, resolveAllProviders, setActiveProvider, removeProvider as removeProviderConfig, } from "./config/index.js";
+export { resolveConfig, hasSummarizationConfigured, 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";

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, resolveAllProviders, setActiveProvider, removeProvider as removeProviderConfig, } from "./config/index.js";
+export { resolveConfig, hasSummarizationConfigured, initConfig, maskConfig, writeConfig, resolveAllProviders, setActiveProvider, removeProvider as removeProviderConfig, } from "./config/index.js";
 // Pre-scan helpers
 export { readPackageDependencies, categorizeLibrary } from "./graph/thirdPartyLibs.js";
 // Pipeline & analysis

package/dist/jobs/queue/memory.js

@@ -116,7 +116,18 @@ export class InMemoryQueue {
             this._markCancelled(jobId, true);
             return true;
         }
-        // Running or paused — signal the runner
+        // Paused: NO runner loop is active (the summarizer returned at the
+        // pause checkpoint), so a cancelRequested flag would sit forever —
+        // resumeJob() even clears it. Mark cancelled right here. The
+        // checkpoint file stays on disk (cleanedUp=false), so a later
+        // summarize resumes from where it stopped.
+        if (job.status === "paused") {
+            job.cancelRequested = true;
+            job.pauseRequested = false;
+            this._markCancelled(jobId, false);
+            return true;
+        }
+        // Running — signal the runner (checked between batches)
         job.cancelRequested = true;
         job.pauseRequested = false; // clear pause signal if both were set
         console.log(`🚫 Cancel requested for job ${jobId}`);

package/dist/pipeline/index.d.ts

@@ -46,6 +46,7 @@ export interface PipelineResult {
     isGithubRepo: boolean;
     gitInfo: GitInfo;
 }
+export declare function worktreeCommitHash(nodes: CodeNode[]): string;
 export declare function routesToCodeNodes(routes: (RouteNode | BackendRouteNode)[], repoPath: string): CodeNode[];
 export declare function analyzePipeline(repoPath: string, isGithubRepo: boolean, options?: PipelineOptions): Promise<PipelineResult>;
 export declare function refilterPipeline(stored: PipelineResult, thresholds: FilterThresholds): Pick<PipelineResult, "nodes" | "edges" | "stats">;

package/dist/pipeline/index.js

@@ -15,6 +15,12 @@ function generateGraphId(repoPath, isGithubRepo) {
         .digest("hex")
         .slice(0, 16);
 }
+// Stable id for repos without git: derived from node ids + code hashes, so the
+// same content overwrites one snapshot in place instead of accumulating timestamps
+export function worktreeCommitHash(nodes) {
+    const parts = nodes.map((n) => `${n.id}:${n.codeHash ?? ""}`).sort();
+    return "worktree-" + createHash("sha256").update(parts.join("|")).digest("hex").slice(0, 12);
+}
 // Gets current git state of the repo
 // Falls back gracefully if git is not initialized
 function getGitInfo(repoPath) {
@@ -28,9 +34,11 @@ function getGitInfo(repoPath) {
         return { commitHash, branch, message, hasGit: true };
     }
     catch {
-        // No git, or no commits yet — use timestamp as version key
+        // No git, or no commits yet. Placeholder resolved to a content-derived
+        // id after extraction (see worktreeCommitHash) so unchanged repos reuse
+        // one snapshot instead of growing a new timestamped one per analyze
         return {
-            commitHash: Date.now().toString(),
+            commitHash: "worktree-pending",
             branch: "unknown",
             message: "no git history",
             hasGit: false,
@@ -221,6 +229,10 @@ export async function analyzePipeline(repoPath, isGithubRepo, options) {
     }
     const allNodes = extractorResult.nodes;
     const allEdges = extractorResult.edges;
+    if (!gitInfo.hasGit) {
+        gitInfo.commitHash = worktreeCommitHash(allNodes);
+        gitInfo.message = "worktree snapshot";
+    }
     //  Step 5: Score and filter 
     console.log("\n[5/5] Scoring and filtering...");
     const scoringResult = scoreAndFilter(allNodes, allEdges, options?.thresholds);

package/dist/storage/fileStorage.d.ts

@@ -21,6 +21,7 @@ export interface CommitSummary {
     edgeCount: number;
     hasGit: boolean;
     isSummarized?: boolean;
+    isIndexed?: boolean;
 }
 export interface GraphMeta {
     graphId: string;
@@ -101,6 +102,8 @@ export declare function deleteCommit(graphId: string, commitHash: string): boole
 export declare function diffCommits(graphId: string, fromHash: string, toHash: string): NodeDiff | undefined;
 export declare function markCommitSummarized(graphId: string, commitHash: string): void;
 export declare function isCommitSummarized(graphId: string, commitHash: string): boolean;
+export declare function markCommitIndexed(graphId: string, commitHash: string): void;
+export declare function isCommitIndexed(graphId: string, commitHash: string): boolean;
 export declare function findLastSummarizedAncestor(graphId: string, commitHash: string, repoPath: string): Promise<string | undefined>;
 export declare function saveNodeSummaries(graphId: string, commitHash: string, nodeUpdates: Map<string, {
     technicalSummary: string;

package/dist/storage/fileStorage.js

@@ -182,9 +182,14 @@ export function saveGraph(result, options) {
         commits: [],
         summarizedCommits: [],
     };
-    // Replace if same commit already exists, else append
+    // Replace if same commit already exists, else append.
+    // Carry over flags the rebuilt summary does not know about (same hazard as
+    // isSummarized: buildCommitSummary starts from scratch)
     const existingCommit = meta.commits.findIndex((c) => c.commitHash === commitHash);
     if (existingCommit >= 0) {
+        const prev = meta.commits[existingCommit];
+        if (prev.isIndexed)
+            newSummary.isIndexed = true;
         meta.commits[existingCommit] = newSummary;
     }
     else {
@@ -500,6 +505,23 @@ export function isCommitSummarized(graphId, commitHash) {
         return false;
     return meta.summarizedCommits?.includes(commitHash);
 }
+// Marks a commit as having a derived .search.json index
+export function markCommitIndexed(graphId, commitHash) {
+    const meta = readMeta(graphId);
+    if (!meta)
+        return;
+    const commit = meta.commits.find((c) => c.commitHash === commitHash);
+    if (!commit || commit.isIndexed)
+        return;
+    commit.isIndexed = true;
+    writeMeta(meta);
+}
+export function isCommitIndexed(graphId, commitHash) {
+    const meta = readMeta(graphId);
+    if (!meta)
+        return false;
+    return meta.commits.find((c) => c.commitHash === commitHash)?.isIndexed === true;
+}
 // Finds the most recent ancestor commit that has been summarized.
 // Uses simple-git to walk the commit history of the repo.
 // Returns undefined if no summarized ancestor exists (= full summarization needed).
@@ -601,6 +623,8 @@ export const fileStorage = {
     diffCommits,
     markCommitSummarized,
     isCommitSummarized,
+    markCommitIndexed,
+    isCommitIndexed,
     findLastSummarizedAncestor,
     saveNodeSummaries,
     getCheckpointPath,

package/dist/storage/interface.d.ts

@@ -11,6 +11,8 @@ export interface GraphStorage {
     diffCommits(graphId: string, fromHash: string, toHash: string): NodeDiff | undefined;
     markCommitSummarized(graphId: string, commitHash: string): void;
     isCommitSummarized(graphId: string, commitHash: string): boolean;
+    markCommitIndexed(graphId: string, commitHash: string): void;
+    isCommitIndexed(graphId: string, commitHash: string): boolean;
     findLastSummarizedAncestor(graphId: string, commitHash: string, repoPath: string): Promise<string | undefined>;
     saveNodeSummaries(graphId: string, commitHash: string, nodeUpdates: Map<string, {
         technicalSummary: string;

package/dist/summarizer/providers/index.js

@@ -12,13 +12,13 @@ export function createLLMClient(config) {
     const effectiveBase = baseUrl ?? entry?.baseUrl;
     switch (provider) {
         case "openai": {
-            if (needsKey && !apiKey)
-                throw new Error(`Provider "${providerName}" requires an API key`);
-            return new OpenAIClient(apiKey ?? "ollama", model, effectiveBase, providerName);
+            if (!apiKey)
+                throw new Error(`No API key configured for "${providerName}" — run "devlens init" to set one up.`);
+            return new OpenAIClient(apiKey, model, effectiveBase, providerName);
         }
         case "anthropic": {
             if (!apiKey)
-                throw new Error(`Provider "${providerName}" requires an API key`);
+                throw new Error(`No API key configured for "${providerName}" — run "devlens init" to set one up.`);
             return new AnthropicClient(apiKey, model, effectiveBase, providerName);
         }
         default:

package/dist/summarizer/providers/openai.js

@@ -26,7 +26,7 @@ function parseResponse(raw) {
         tokensUsed: 0,
     };
 }
-// Also used as the base for OpenRouter and Ollama —
+// Also used as the base for other OpenAI-compatible providers —
 // both expose OpenAI-compatible APIs, just with a different baseURL.
 export class OpenAIClient {
     constructor(apiKey, model, baseURL, providerName) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "devlensio",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "description": "Codebase intelligence engine for TypeScript/JavaScript/React/Next.js, Python, Java, Go, and Rust repositories.",
   "type": "module",
   "main": "./dist/index.js",
@@ -21,7 +21,14 @@
     "prepack": "node extractors/java/build.mjs && node extractors/go/build.mjs && node extractors/rust/build.mjs",
     "postinstall": "node extractors/python/setup.mjs"
   },
-  "keywords": ["codebase", "graph", "ast", "typescript", "javascript", "devtools"],
+  "keywords": [
+    "codebase",
+    "graph",
+    "ast",
+    "typescript",
+    "javascript",
+    "devtools"
+  ],
   "author": "",
   "license": "AGPL-3.0",
   "files": [
@@ -63,4 +70,4 @@
     "ts-node-dev": "^2.0.0",
     "typescript": "^5.9.3"
   }
-}
+}