@omnitype-code/cli 0.1.1 → 0.1.2

package/dist/core/TranscriptScanner.js

@@ -0,0 +1,233 @@
+"use strict";
+/**
+ * Transcript-based model detection — TypeScript port of git-ai's model_extraction.rs.
+ *
+ * Strategy: for each AI tool, find the most recently modified session file,
+ * read its tail (50 KB), scan lines in reverse for a model field, fall back
+ * to the head for tools that emit model_change events at session start.
+ *
+ * Results are cached for 60 s so directory scanning doesn't run on every edit.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scanTranscripts = scanTranscripts;
+exports.invalidateTranscriptCache = invalidateTranscriptCache;
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const TAIL_BYTES = 51200; // 50 KB — mirrors git-ai
+const HEAD_LINES = 20;
+const CACHE_TTL = 60000; // re-scan directories at most once per minute
+const HOME = os.homedir();
+// ── Model extraction from a single JSONL line ─────────────────────────────────
+function modelFromLine(line) {
+    const t = line.trim();
+    if (!t)
+        return undefined;
+    let j;
+    try {
+        j = JSON.parse(t);
+    }
+    catch {
+        return undefined;
+    }
+    // Copilot CLI / Windsurf: session.model_change event
+    if (j?.type === 'session.model_change') {
+        const m = j?.data?.newModel;
+        if (typeof m === 'string' && m)
+            return m;
+    }
+    // Standard JSONL: message.model, top-level model, or modelID
+    const candidate = j?.message?.model ?? j?.model ?? j?.modelID ?? j?.data?.model;
+    if (typeof candidate === 'string' && candidate && candidate !== '<synthetic>')
+        return candidate;
+    return undefined;
+}
+// ── JSONL extraction: tail scan + head fallback ───────────────────────────────
+function extractJsonl(filePath) {
+    let fd;
+    try {
+        fd = fs.openSync(filePath, 'r');
+        const size = fs.fstatSync(fd).size;
+        if (!size) {
+            fs.closeSync(fd);
+            return undefined;
+        }
+        const readSize = Math.min(TAIL_BYTES, size);
+        const seekPos = size - readSize;
+        const buf = Buffer.alloc(readSize);
+        fs.readSync(fd, buf, 0, readSize, seekPos);
+        fs.closeSync(fd);
+        fd = undefined;
+        // Reverse-scan the tail
+        const lines = buf.toString('utf8').split('\n');
+        for (let i = lines.length - 1; i >= 0; i--) {
+            const m = modelFromLine(lines[i]);
+            if (m)
+                return m;
+        }
+        // Head fallback: model_change events are emitted at session start
+        if (seekPos > 0) {
+            const head = fs.readFileSync(filePath, 'utf8').split('\n');
+            for (let i = 0; i < Math.min(HEAD_LINES, head.length); i++) {
+                const m = modelFromLine(head[i]);
+                if (m)
+                    return m;
+            }
+        }
+    }
+    catch { /* unreadable */ }
+    finally {
+        if (fd !== undefined)
+            try {
+                fs.closeSync(fd);
+            }
+            catch { }
+    }
+    return undefined;
+}
+// ── Amp: thread JSON — model lives in messages[].usage.model ─────────────────
+function extractAmp(filePath) {
+    try {
+        const messages = JSON.parse(fs.readFileSync(filePath, 'utf8'))?.messages ?? [];
+        for (let i = messages.length - 1; i >= 0; i--) {
+            const m = messages[i]?.usage?.model;
+            if (typeof m === 'string' && m)
+                return m;
+        }
+    }
+    catch { }
+    return undefined;
+}
+const SPECS = [
+    {
+        tool: 'claude-code',
+        dirs: () => {
+            const base = process.env.CLAUDE_CONFIG_DIR ?? path.join(HOME, '.claude');
+            const alt = path.join(HOME, '.config', 'claude');
+            return [path.join(base, 'projects'), path.join(alt, 'projects')];
+        },
+        ext: '.jsonl',
+        extract: extractJsonl,
+    },
+    {
+        tool: 'codex',
+        dirs: () => [path.join(HOME, '.codex')],
+        ext: '.jsonl',
+        extract: extractJsonl,
+    },
+    {
+        tool: 'gemini-cli',
+        dirs: () => [path.join(HOME, '.gemini', 'tmp')],
+        ext: '.jsonl',
+        extract: extractJsonl,
+    },
+    {
+        tool: 'amp',
+        dirs: () => {
+            const xdg = process.env.XDG_DATA_HOME;
+            const local = process.env.LOCALAPPDATA;
+            if (process.platform === 'win32')
+                return local ? [path.join(local, 'amp', 'threads')] : [];
+            return [path.join(xdg ?? path.join(HOME, '.local', 'share'), 'amp', 'threads')];
+        },
+        ext: '.json',
+        extract: extractAmp,
+    },
+    {
+        tool: 'windsurf',
+        dirs: () => [path.join(HOME, '.codeium', 'windsurf', 'conversations')],
+        ext: '.jsonl',
+        extract: extractJsonl,
+    },
+];
+// ── Directory scanner: finds the newest file with the given extension ─────────
+function newestFile(dirs, ext) {
+    let best;
+    function scan(dir, depth = 0) {
+        if (depth > 6)
+            return;
+        let entries;
+        try {
+            entries = fs.readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const e of entries) {
+            const full = path.join(dir, e.name);
+            if (e.isDirectory())
+                scan(full, depth + 1);
+            else if (e.isFile() && e.name.endsWith(ext)) {
+                try {
+                    const mtime = fs.statSync(full).mtimeMs;
+                    if (!best || mtime > best.mtime)
+                        best = { path: full, mtime };
+                }
+                catch { }
+            }
+        }
+    }
+    for (const dir of dirs)
+        scan(dir);
+    return best;
+}
+// ── Public API ────────────────────────────────────────────────────────────────
+let _cache;
+let _cacheAt = 0;
+/**
+ * Returns the model from the most recently modified AI session transcript,
+ * across all supported tools. Result is cached for 60 s.
+ */
+function scanTranscripts() {
+    if (_cache && Date.now() - _cacheAt < CACHE_TTL)
+        return _cache;
+    let best;
+    for (const spec of SPECS) {
+        const file = newestFile(spec.dirs(), spec.ext);
+        if (!file)
+            continue;
+        if (best && file.mtime <= best.mtime)
+            continue;
+        const model = spec.extract(file.path);
+        if (!model)
+            continue;
+        best = { model, tool: spec.tool, mtime: file.mtime };
+    }
+    _cache = best;
+    _cacheAt = Date.now();
+    return best;
+}
+function invalidateTranscriptCache() { _cache = undefined; _cacheAt = 0; }

package/dist/daemon.js

@@ -47,6 +47,7 @@ const ModelDetector_1 = require("./core/ModelDetector");
 const FileProvenance_1 = require("./core/FileProvenance");
 const Heartbeat_1 = require("./core/Heartbeat");
 const UI_1 = require("./core/UI");
+const ToolHookInstallers_1 = require("./core/ToolHookInstallers");
 const PUSH_INTERVAL_MS = 60000;
 const IDLE_PUSH_MS = 10000;
 const IGNORE_DIRS = /[/\\](\.git|node_modules|\.next|dist|build|__pycache__|\.venv|venv)[/\\]/;
@@ -90,6 +91,8 @@ function startDaemon(opts) {
         UI_1.UI.error('Not signed in. Run: omnitype login');
         process.exit(1);
     }
+    // Auto-install preToolUse hooks into Cursor, Windsurf, Codex if present.
+    (0, ToolHookInstallers_1.installAllToolHooks)();
     const watchPath = path.resolve(opts.watchPath);
     const projectName = opts.projectName;
     const branch = opts.branch ?? gitBranch(watchPath);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@omnitype-code/cli",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "OmniType CLI — editor-agnostic code provenance tracking",
   "license": "MIT",
   "bin": {

package/src/core/ModelDetector.ts

@@ -1,19 +1,8 @@
-/**
- * CLI ModelDetector — editor-agnostic model detection.
- *
- * Detection tiers:
- *   1. Universal sentinel   (~/.omnitype/active-model.json)
- *   2. Hooks sentinel file  (~/.claude/provenance-hook.json)
- *   3. Host IDE config      (Cursor/Windsurf/Zed settings.json — scanned generically)
- *   4. Config files         (per-tool config paths: .aider.conf.yml, etc.)
- *   5. Environment variables (CLAUDE_MODEL, AIDER_MODEL, etc.)
- *   6. Process detection    (lsof / ps — identifies the writing process)
- */
-
 import * as fs from 'fs';
 import * as os from 'os';
 import * as path from 'path';
 import { execFileSync } from 'child_process';
+import { scanTranscripts } from './TranscriptScanner';
 
 export interface ModelDetectionResult {
   model: string;
@@ -22,115 +11,107 @@ export interface ModelDetectionResult {
 }
 
 const UNKNOWN: ModelDetectionResult = { model: 'unknown', tool: 'unknown', confidence: 'low' };
-const HOOKS_SENTINEL_PATH = path.join(os.homedir(), '.claude', 'provenance-hook.json');
-const UNIVERSAL_SENTINEL_PATH = path.join(os.homedir(), '.omnitype', 'active-model.json');
-const SENTINEL_MAX_AGE_MS = 10_000;
+const SENTINEL_MAX_AGE_MS = 30_000; // 30 s — covers slow multi-file AI diffs
+const UNIVERSAL_PATH = path.join(os.homedir(), '.omnitype', 'active-model.json');
+const HOOKS_PATH     = path.join(os.homedir(), '.claude', 'provenance-hook.json');
 
-const MODEL_PATTERN = /\b(claude-[\w.-]+|gpt-[\w.-]+|o[1234](?:-[\w.-]+)?|gemini-[\w.-]+|gemma[\w.-]*|llama-[\w.-]+|mistral[\w.-]*|codestral[\w.-]*|deepseek[\w.-]*|qwen[\w.-]+|command[\w.-]*|phi[\w.-]+|grok[\w.-]*|kimi[\w.-]*|moonshot[\w.-]*)\b/i;
+// Matches model identifier strings from all major providers.
+const MODEL_PATTERN = /\b(claude-[\w.-]+|gpt-[\w.-]+|o[134](?:-[\w.-]+)?|gemini-[\w.-]+|gemma[\w.-]*|llama-[\w.-]+|mistral[\w.-]*|codestral[\w.-]*|deepseek[\w.-]*|qwen[\w.-]+|command[\w.-]*|phi[\w.-]+|grok[\w.-]*|kimi[\w.-]*|moonshot[\w.-]*)\b/i;
 
-// Maps known CLI/IDE env vars to their tool
+// Each tool lists its OWN env vars only. Shared vars (OPENAI_MODEL) are NOT duplicated
+// across tools — the first matching entry wins, so ambiguous vars are assigned to
+// the most common owner (openai). Tools with a dedicated var (CODEX_MODEL) are checked
+// earlier so they can claim edits even when OPENAI_MODEL is also set.
 const ENV_VARS: Array<{ vars: string[]; tool: string }> = [
-  { vars: ['CLAUDE_MODEL', 'CLAUDE_CODE_MODEL', 'ANTHROPIC_MODEL'], tool: 'claude-code' },
+  { vars: ['CLAUDE_CODE_MODEL', 'CLAUDE_MODEL', 'ANTHROPIC_MODEL'], tool: 'claude-code' },
   { vars: ['AIDER_MODEL'],                                           tool: 'aider' },
+  { vars: ['CODEX_MODEL'],                                           tool: 'codex' },   // before generic OPENAI_MODEL
   { vars: ['OPENAI_MODEL', 'OPENAI_API_MODEL'],                     tool: 'openai' },
-  { vars: ['GEMINI_MODEL', 'GEMINI_API_KEY'],                       tool: 'gemini-cli' },
-  { vars: ['OLLAMA_MODEL'],                                         tool: 'ollama' },
-  { vars: ['COPILOT_MODEL'],                                        tool: 'copilot' },
-  { vars: ['LLM_MODEL'],                                            tool: 'openhands' },
-  { vars: ['TABBY_MODEL'],                                          tool: 'tabby' },
+  { vars: ['GEMINI_MODEL'],                                          tool: 'gemini-cli' },
+  { vars: ['OLLAMA_MODEL'],                                          tool: 'ollama' },
+  { vars: ['COPILOT_MODEL'],                                         tool: 'copilot' },
+  { vars: ['LLM_MODEL'],                                             tool: 'openhands' },
+  { vars: ['TABBY_MODEL'],                                           tool: 'tabby' },
 ];
 
-const KNOWN_FORKS = [
-  'Cursor', 'Windsurf', 'PearAI', 'Void', 'Trae', 'Zed', 'Antigravity'
-];
+const KNOWN_FORKS = ['Cursor', 'Windsurf', 'PearAI', 'Void', 'Trae', 'Zed', 'Antigravity'];
+const AUTO_SENTINELS = new Set(['auto', 'cursor-auto', 'windsurf-auto', 'default', 'best']);
+
+// Host IDE processes: always running — their presence does NOT mean they caused the edit.
+const HOST_IDE_PROCS = new Set(['cursor', 'windsurf', 'antigravity', 'pearai', 'void', 'trae', 'zed']);
 
-// lsof command-name → tool mapping
-const LSOF_CMD_MAP: Array<{ match: string; tool: string }> = [
-  { match: 'claude',    tool: 'claude-code' },
-  { match: 'aider',     tool: 'aider' },
-  { match: 'cursor',    tool: 'cursor' },
-  { match: 'windsurf',  tool: 'windsurf' },
-  { match: 'zed',       tool: 'zed' },
-  { match: 'pearai',    tool: 'pearai' },
-  { match: 'void',      tool: 'void' },
-  { match: 'tabby',     tool: 'tabby' },
-  { match: 'goose',     tool: 'goose' },
-  { match: 'node',      tool: 'unknown-cli' },
-  { match: 'python',    tool: 'unknown-cli' },
+const PROC_MAP: Array<{ match: string; tool: string }> = [
+  { match: 'claude',   tool: 'claude-code' },
+  { match: 'aider',    tool: 'aider' },
+  { match: 'goose',    tool: 'goose' },
+  { match: 'codex',    tool: 'codex' },
+  { match: 'tabby',    tool: 'tabby' },
 ];
 
 export class ModelDetector {
   detect(changedFilePath?: string): ModelDetectionResult {
     return (
-      this._fromUniversalSentinel() ??
-      this._fromHooksSentinel() ??
-      this._fromIdeConfigs() ??
+      this._sentinel(UNIVERSAL_PATH, changedFilePath) ??
+      this._sentinel(HOOKS_PATH, changedFilePath) ??
       this._fromEnv() ??
-      this._fromPsPatterns() ??
+      this._fromTranscripts() ??
+      this._fromIdeConfigs() ??
+      this._fromPs() ??
       (changedFilePath ? this._fromLsof(changedFilePath) : undefined) ??
       UNKNOWN
     );
   }
 
-  private _fromUniversalSentinel(): ModelDetectionResult | undefined {
-    try {
-      const stat = fs.statSync(UNIVERSAL_SENTINEL_PATH);
-      if (Date.now() - stat.mtimeMs > SENTINEL_MAX_AGE_MS) return undefined;
-      const data = JSON.parse(fs.readFileSync(UNIVERSAL_SENTINEL_PATH, 'utf8'));
-      if (!data?.model || data.model === 'unknown') return undefined;
-      return { model: data.model, tool: data.tool ?? 'unknown-tool', confidence: 'deterministic' };
-    } catch { return undefined; }
+  private _fromTranscripts(): ModelDetectionResult | undefined {
+    const r = scanTranscripts();
+    if (!r) return undefined;
+    return { model: r.model, tool: r.tool, confidence: 'high' };
   }
 
-  private _fromHooksSentinel(): ModelDetectionResult | undefined {
+  private _sentinel(filePath: string, changedPath?: string): ModelDetectionResult | undefined {
     try {
-      const stat = fs.statSync(HOOKS_SENTINEL_PATH);
-      if (Date.now() - stat.mtimeMs > SENTINEL_MAX_AGE_MS) return undefined;
-      const data = JSON.parse(fs.readFileSync(HOOKS_SENTINEL_PATH, 'utf8'));
-      if (!data?.model || data.model === 'unknown') return undefined;
-      return { model: data.model, tool: data.tool ?? 'claude-code', confidence: 'deterministic' };
+      const mtime = fs.statSync(filePath).mtimeMs;
+      const d = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+      if (!d?.model || d.model === 'unknown') return undefined;
+
+      if (d.file && changedPath) {
+        // File-path gated: trust only if the sentinel targets this exact file.
+        // Use a generous TTL since path specificity eliminates cross-file contamination.
+        if (d.file !== changedPath) return undefined;
+        if (Date.now() - mtime > 120_000) return undefined; // 2 min max
+      } else {
+        // No path info: fall back to strict TTL to minimise false attribution.
+        if (Date.now() - mtime > SENTINEL_MAX_AGE_MS) return undefined;
+      }
+
+      if (!d?.model || d.model === 'unknown') return undefined;
+      return { model: d.model, tool: d.tool ?? 'unknown-tool', confidence: 'deterministic' };
     } catch { return undefined; }
   }
 
-  private _fromIdeConfigs(): ModelDetectionResult | undefined {
-    for (const appName of KNOWN_FORKS) {
-      const scan = this._scanIdeSettings(appName);
-      if (scan) {
-        return { 
-          model: scan.model, 
-          tool: appName.toLowerCase(), 
-          confidence: scan.isAuto ? 'medium' : 'high' 
-        };
-      }
-    }
+  private _fromEnv(): ModelDetectionResult | undefined {
+    for (const { vars, tool } of ENV_VARS)
+      for (const v of vars) { const val = process.env[v]; if (val && MODEL_PATTERN.test(val)) return { model: val, tool, confidence: 'high' }; }
     return undefined;
   }
 
-  private _fromEnv(): ModelDetectionResult | undefined {
-    for (const { vars, tool } of ENV_VARS) {
-      for (const v of vars) {
-        const val = process.env[v];
-        if (val && MODEL_PATTERN.test(val)) {
-          return { model: val, tool, confidence: 'high' };
-        }
-      }
+  private _fromIdeConfigs(): ModelDetectionResult | undefined {
+    for (const appName of KNOWN_FORKS) {
+      const scan = this._scanIdeSettings(appName);
+      if (scan) return { model: scan.model, tool: appName.toLowerCase(), confidence: scan.isAuto ? 'medium' : 'high' };
     }
     return undefined;
   }
 
-  private _fromPsPatterns(): ModelDetectionResult | undefined {
+  private _fromPs(): ModelDetectionResult | undefined {
     if (process.platform === 'win32') return undefined;
     try {
       const lines = execFileSync('ps', ['ax', '-o', 'args='], { timeout: 800, encoding: 'utf8' }).split('\n');
-      for (const line of lines) {
-        for (const entry of LSOF_CMD_MAP) {
-          if (line.toLowerCase().includes(entry.match)) {
-            // Fallback model name
-            return { model: `${entry.tool}-default`, tool: entry.tool, confidence: 'low' };
-          }
-        }
-      }
-    } catch { /* ps unavailable */ }
+      for (const line of lines)
+        for (const { match, tool } of PROC_MAP)
+          if (line.toLowerCase().includes(match) && !HOST_IDE_PROCS.has(tool))
+            return { model: `${tool}-default`, tool, confidence: 'low' };
+    } catch {}
     return undefined;
   }
 
@@ -141,57 +122,36 @@ export class ModelDetector {
       for (const line of out.split('\n')) {
         if (!line.startsWith('c')) continue;
         const cmd = line.slice(1).toLowerCase();
-        for (const entry of LSOF_CMD_MAP) {
-          if (cmd.includes(entry.match)) {
-            return { model: `${entry.tool}-default`, tool: entry.tool, confidence: 'low' };
-          }
-        }
+        for (const { match, tool } of PROC_MAP)
+          if (cmd.includes(match) && !HOST_IDE_PROCS.has(tool))
+            return { model: `${tool}-default`, tool, confidence: 'low' };
       }
-    } catch { /* lsof unavailable */ }
+    } catch {}
     return undefined;
   }
 
   private _scanIdeSettings(appName: string): { model: string; isAuto: boolean } | undefined {
-    for (const p of this._getIdeSettingsPaths(appName)) {
+    for (const p of this._idePaths(appName)) {
       try {
-        const raw = fs.readFileSync(p, 'utf8');
-        const json = JSON.parse(raw);
-        const flat = this._flattenObject(json);
-        
-        const AUTO_SENTINELS = new Set(['auto', 'cursor-auto', 'windsurf-auto', 'default', 'best']);
+        const flat = this._flatten(JSON.parse(fs.readFileSync(p, 'utf8')));
         const candidates: Array<{ key: string; value: string }> = [];
-
         for (const [key, value] of Object.entries(flat)) {
-          if (typeof value !== 'string' || !value) continue;
-          if (!key.toLowerCase().includes('model')) continue;
-
-          if (AUTO_SENTINELS.has(value.toLowerCase())) {
-            candidates.push({ key, value: `${appName.toLowerCase()}-auto` });
-            continue;
-          }
-
-          if (MODEL_PATTERN.test(value)) {
-            candidates.push({ key, value: value.toLowerCase() });
-          }
-        }
-
-        if (candidates.length > 0) {
-          const real = candidates.filter(c => !c.value.endsWith('-auto'));
-          const pick = real.length > 0
-            ? real.sort((a, b) => b.key.length - a.key.length)[0]
-            : candidates.sort((a, b) => b.key.length - a.key.length)[0];
-          return { model: pick.value, isAuto: pick.value.endsWith('-auto') };
+          if (typeof value !== 'string' || !key.toLowerCase().includes('model')) continue;
+          if (AUTO_SENTINELS.has(value.toLowerCase())) { candidates.push({ key, value: `${appName.toLowerCase()}-auto` }); continue; }
+          if (MODEL_PATTERN.test(value)) candidates.push({ key, value: value.toLowerCase() });
         }
-      } catch { /* absent */ }
+        if (!candidates.length) continue;
+        const real = candidates.filter(c => !c.value.endsWith('-auto'));
+        const pick = (real.length ? real : candidates).sort((a, b) => b.key.length - a.key.length)[0];
+        return { model: pick.value, isAuto: pick.value.endsWith('-auto') };
+      } catch {}
     }
     return undefined;
   }
 
-  private _getIdeSettingsPaths(appName: string): string[] {
-    const toolId = appName.toLowerCase().replace(/\s+/g, '-');
-    const dirCandidates = [...new Set([appName, toolId])];
-
-    return dirCandidates.map(dir => {
+  private _idePaths(appName: string): string[] {
+    const id = appName.toLowerCase().replace(/\s+/g, '-');
+    return [...new Set([appName, id])].map(dir => {
       switch (process.platform) {
         case 'darwin': return path.join(os.homedir(), 'Library', 'Application Support', dir, 'User', 'settings.json');
         case 'win32':  return path.join(process.env.APPDATA ?? '', dir, 'User', 'settings.json');
@@ -200,16 +160,14 @@ export class ModelDetector {
     });
   }
 
-  private _flattenObject(obj: Record<string, unknown>, prefix = '', depth = 0): Record<string, unknown> {
+  private _flatten(obj: Record<string, unknown>, prefix = '', depth = 0): Record<string, unknown> {
     if (depth > 5) return {};
     const out: Record<string, unknown> = {};
     for (const [k, v] of Object.entries(obj)) {
       const key = prefix ? `${prefix}.${k}` : k;
-      if (v !== null && typeof v === 'object' && !Array.isArray(v)) {
-        Object.assign(out, this._flattenObject(v as Record<string, unknown>, key, depth + 1));
-      } else {
-        out[key] = v;
-      }
+      if (v !== null && typeof v === 'object' && !Array.isArray(v))
+        Object.assign(out, this._flatten(v as Record<string, unknown>, key, depth + 1));
+      else out[key] = v;
     }
     return out;
   }